diff options
Diffstat (limited to 'src/3rdparty/autotrace/autotrace.h')
| -rw-r--r-- | src/3rdparty/autotrace/autotrace.h | 413 |
1 files changed, 413 insertions, 0 deletions
diff --git a/src/3rdparty/autotrace/autotrace.h b/src/3rdparty/autotrace/autotrace.h new file mode 100644 index 0000000..e56be9a --- /dev/null +++ b/src/3rdparty/autotrace/autotrace.h @@ -0,0 +1,413 @@ +/* autotrace.h --- Autotrace API + + Copyright (C) 2000, 2001, 2002 Martin Weber + + The author can be contacted at <martweb@gmx.net> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#ifndef AUTOTRACE_H +#define AUTOTRACE_H + +#include <stdio.h> + +#include "types.h" +#include "color.h" + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#ifndef N_ +#define N_(x) x +#endif /* Not def: N_ */ + +/* ===================================================================== * + * Typedefs + * ===================================================================== */ + +/* Third degree is the highest we deal with. */ + enum _at_polynomial_degree { + AT_LINEARTYPE = 1, + AT_QUADRATICTYPE = 2, + AT_CUBICTYPE = 3, + AT_PARALLELELLIPSETYPE = 4, + AT_ELLIPSETYPE = 5, + AT_CIRCLETYPE = 6 + /* not the real number of points to define a + circle but to distinguish between a cubic spline */ + }; + + enum _at_msg_type { + AT_MSG_NOT_SET = 0, /* is used in autotrace internally */ + AT_MSG_FATAL = 1, + AT_MSG_WARNING, + }; + + typedef struct _at_fitting_opts_type at_fitting_opts_type; + typedef struct _at_input_opts_type at_input_opts_type; + typedef struct _at_output_opts_type at_output_opts_type; + typedef struct _at_bitmap at_bitmap; + typedef enum _at_polynomial_degree at_polynomial_degree; + typedef struct _at_spline_type at_spline_type; + typedef struct _at_spline_list_type at_spline_list_type; + typedef struct _at_spline_list_array_type at_spline_list_array_type; +#define at_splines_type at_spline_list_array_type + typedef enum _at_msg_type at_msg_type; + +/* A Bezier spline can be represented as four points in the real plane: + a starting point, ending point, and two control points. The + curve always lies in the convex hull defined by the four points. It + is also convenient to save the divergence of the spline from the + straight line defined by the endpoints. */ + struct _at_spline_type { + at_real_coord v[4]; /* The control points. */ + at_polynomial_degree degree; + gfloat linearity; + }; + +/* Each outline in a character is typically represented by many + splines. So, here is a list structure for that: */ + struct _at_spline_list_type { + at_spline_type *data; + unsigned length; + gboolean clockwise; + at_color color; + gboolean open; + }; + +/* Each character is in general made up of many outlines. So here is one + more list structure. */ + struct _at_spline_list_array_type { + at_spline_list_type *data; + unsigned length; + + /* splines bbox */ + unsigned short height, width; + + /* the values for following members are inherited from + at_fitting_opts_type */ + at_color *background_color; + gboolean centerline; + gboolean preserve_width; + gfloat width_weight_factor; + + }; + +/* Fitting option. + With using at_fitting_opts_doc macro, the description of + each option could be get. e.g. at_fitting_opts_doc(background_color) */ + struct _at_fitting_opts_type { +#define at_doc__background_color \ +N_("background-color <hexadezimal>: the color of the background that " \ +"should be ignored, for example FFFFFF; " \ +"default is no background color.") + at_color *background_color; + +#define at_doc__charcode \ +N_("charcode <unsigned>: code of character to load from GF file, " \ +"allowed are 0..255; default is the first character in font.") + unsigned charcode; + +#define at_doc__color_count \ +N_("color-count <unsigned>: number of colors a color bitmap is reduced to, " \ +"it does not work on grayscale, allowed are 1..256; " \ +"default is 0, that means not color reduction is done.") + unsigned color_count; + +#define at_doc__corner_always_threshold \ +N_("corner-always-threshold <angle-in-degrees>: if the angle at a pixel is " \ +"less than this, it is considered a corner, even if it is within " \ +"`corner-surround' pixels of another corner; default is 60. ") + gfloat corner_always_threshold; + +#define at_doc__corner_surround \ +N_("corner-surround <unsigned>: number of pixels on either side of a " \ +"point to consider when determining if that point is a corner; " \ +"default is 4. ") + unsigned corner_surround; + +#define at_doc__corner_threshold \ +N_("corner-threshold <angle-in-degrees>: if a pixel, its predecessor(s), " \ +"and its successor(s) meet at an angle smaller than this, it's a " \ +"corner; default is 100. ") + gfloat corner_threshold; + +#define at_doc__error_threshold \ +N_("error-threshold <real>: subdivide fitted curves that are off by " \ +"more pixels than this; default is 2.0. ") + gfloat error_threshold; + +#define at_doc__filter_iterations \ +N_("filter-iterations <unsigned>: smooth the curve this many times " \ +"before fitting; default is 4.") + unsigned filter_iterations; + +#define at_doc__line_reversion_threshold \ +N_("line-reversion-threshold <real>: if a spline is closer to a straight " \ +"line than this, weighted by the square of the curve length, keep it a " \ +"straight line even if it is a list with curves; default is .01. ") + gfloat line_reversion_threshold; + +#define at_doc__line_threshold \ +N_("line-threshold <real>: if the spline is not more than this far away " \ +"from the straight line defined by its endpoints," \ +"then output a straight line; default is 1. ") + gfloat line_threshold; + +#define at_doc__remove_adjacent_corners \ +N_("remove-adjacent-corners: remove corners that are adjacent; " \ +"default doesn't remove.") + gboolean remove_adjacent_corners; + +#define at_doc__tangent_surround \ +N_("tangent-surround <unsigned>: number of points on either side of a " \ +"point to consider when computing the tangent at that point; " \ +" default is 3.") + unsigned tangent_surround; + +#define at_doc__despeckle_level \ +N_("despeckle-level <unsigned>: 0..20; default is no despeckling. ") + unsigned despeckle_level; + +#define at_doc__despeckle_tightness \ +N_("despeckle-tightness <real>: 0.0..8.0; default is 2.0. ") + gfloat despeckle_tightness; + +#define at_doc__noise_removal \ +N_("noise-removal <real>: 1.0..0.0; default is 0.99. ") + gfloat noise_removal; + +#define at_doc__centerline \ +N_("centerline: trace a character's centerline, rather than its outline. ") + gboolean centerline; + +#define at_doc__preserve_width \ +N_("preserve-width: whether to preserve linewith with centerline fitting; " \ +"default doesn't preserve.") + gboolean preserve_width; + +#define at_doc__width_weight_factor \ +N_("width-weight-factor <real>: weight factor for fitting the linewidth.") + gfloat width_weight_factor; + }; + + struct _at_input_opts_type { + at_color *background_color; + unsigned charcode; /* Character code used only in GF input. */ + }; + + struct _at_output_opts_type { + int dpi; /* DPI is used only in MIF output. */ + }; + + struct _at_bitmap { + unsigned short height; + unsigned short width; + unsigned char *bitmap; + unsigned int np; + }; + + typedef + void (*at_msg_func) (const gchar * msg, at_msg_type msg_type, gpointer client_data); + +/* + * Autotrace initializer + */ +#define AUTOTRACE_INIT + void autotrace_init(void); + +/* + * IO Handler typedefs + */ + + typedef struct _at_bitmap_reader at_bitmap_reader; + struct _at_bitmap_reader; + + typedef struct _at_spline_writer at_spline_writer; + struct _at_spline_writer; + +/* + * Progress handler typedefs + * 0.0 <= percentage <= 1.0 + */ + typedef void (*at_progress_func) (gfloat percentage, gpointer client_data); + +/* + * Test cancel + * Return TRUE if auto-tracing should be stopped. + */ + typedef gboolean(*at_testcancel_func) (gpointer client_data); + +/* ===================================================================== * + * Functions + * ===================================================================== */ + +/* --------------------------------------------------------------------- * + * Fitting option related + * + * TODO: internal data access, copy + * --------------------------------------------------------------------- */ + at_fitting_opts_type *at_fitting_opts_new(void); + at_fitting_opts_type *at_fitting_opts_copy(at_fitting_opts_type * original); + void at_fitting_opts_free(at_fitting_opts_type * opts); + +/* Gettextize */ +#define at_fitting_opts_doc(opt) at_fitting_opts_doc_func(at_doc__##opt) +/* Don't use next function directly from clients */ + const char *at_fitting_opts_doc_func(char *string); + +/* --------------------------------------------------------------------- * + * Input option related + * + * TODO: internal data access + * --------------------------------------------------------------------- */ + at_input_opts_type *at_input_opts_new(void); + at_input_opts_type *at_input_opts_copy(at_input_opts_type * original); + void at_input_opts_free(at_input_opts_type * opts); + +/* --------------------------------------------------------------------- * + * Output option related + * + * TODO: internal data access + * --------------------------------------------------------------------- */ + at_output_opts_type *at_output_opts_new(void); + at_output_opts_type *at_output_opts_copy(at_output_opts_type * original); + void at_output_opts_free(at_output_opts_type * opts); + +/* --------------------------------------------------------------------- * + * Bitmap related + * + * TODO: internal data access + * --------------------------------------------------------------------- */ + +/* There is two way to build at_bitmap. + 1. Using input reader + Use at_bitmap_read. + at_input_get_handler_by_suffix or + at_input_get_handler will help you to get at_bitmap_reader. + 2. Allocating a bitmap and rendering an image on it by yourself + Use at_bitmap_new. + + In both case, you have to call at_bitmap_free when at_bitmap * + data are no longer needed. */ + at_bitmap *at_bitmap_read(at_bitmap_reader * reader, gchar * filename, at_input_opts_type * opts, at_msg_func msg_func, gpointer msg_data); + at_bitmap *at_bitmap_new(unsigned short width, unsigned short height, unsigned int planes); + at_bitmap *at_bitmap_copy(const at_bitmap * src); + +/* We have to export functions that supports internal datum + access. Such functions might be useful for + at_bitmap_new user. */ + unsigned short at_bitmap_get_width(const at_bitmap * bitmap); + unsigned short at_bitmap_get_height(const at_bitmap * bitmap); + unsigned short at_bitmap_get_planes(const at_bitmap * bitmap); + void at_bitmap_get_color(const at_bitmap * bitmap, unsigned int row, unsigned int col, at_color * color); + gboolean at_bitmap_equal_color(const at_bitmap * bitmap, unsigned int row, unsigned int col, at_color * color); + void at_bitmap_free(at_bitmap * bitmap); + +/* --------------------------------------------------------------------- * + * Spline related + * + * TODO: internal data access + * --------------------------------------------------------------------- */ +/* at_splines_new + + args: + + BITMAP is modified in at_splines_new according to opts. Therefore + if you need the original bitmap image, you have to make a backup of + BITMAP with using at_bitmap_copy. + + MSG_FUNC and MSG_DATA are used to notify a client errors and + warning from autotrace. NULL is valid value for MSG_FUNC if + the client is not interested in the notifications. */ + at_splines_type *at_splines_new(at_bitmap * bitmap, at_fitting_opts_type * opts, at_msg_func msg_func, gpointer msg_data); + +/* at_splines_new_full + + args: + + NOTIFY_PROGRESS is called repeatedly inside at_splines_new_full + to notify the progress of the execution. This might be useful for + interactive applications. NOTIFY_PROGRESS is called following + format: + + NOTIFY_PROGRESS (percentage, progress_data); + + test_cancel is called repeatedly inside at_splines_new_full + to test whether the execution is canceled or not. + If test_cancel returns TRUE, execution of at_splines_new_full + is stopped as soon as possible and returns NULL. If test_cancel + returns FALSE, nothing happens. test_cancel is called following + format: + + TEST_CANCEL (testcancel_data); + + NULL is valid value for notify_progress and/or test_cancel if + you don't need to know the progress of the execution and/or + cancel the execution */ + at_splines_type *at_splines_new_full(at_bitmap * bitmap, at_fitting_opts_type * opts, at_msg_func msg_func, gpointer msg_data, at_progress_func notify_progress, gpointer progress_data, at_testcancel_func test_cancel, gpointer testcancel_data); + + void at_splines_write(at_spline_writer * writer, FILE * writeto, gchar * file_name, at_output_opts_type * opts, at_splines_type * splines, at_msg_func msg_func, gpointer msg_data); + + void at_splines_free(at_splines_type * splines); + +/* --------------------------------------------------------------------- * + * Input related + * --------------------------------------------------------------------- */ + at_bitmap_reader *at_input_get_handler(gchar * filename); + at_bitmap_reader *at_input_get_handler_by_suffix(gchar * suffix); + + const char **at_input_list_new(void); + void at_input_list_free(const char **list); + +/* at_input_shortlist + return value: Do free by yourself */ + char *at_input_shortlist(void); + +/* --------------------------------------------------------------------- * + * Output related + * --------------------------------------------------------------------- */ + at_spline_writer *at_output_get_handler(gchar * filename); + at_spline_writer *at_output_get_handler_by_suffix(const gchar * suffix); + const char **at_output_list_new(void); + void at_output_list_free(const char **list); + +/* at_output_shortlist + return value: Do free by yourself */ + char *at_output_shortlist(void); + +/* --------------------------------------------------------------------- * + * Misc + * --------------------------------------------------------------------- */ + +/* at_version + + args: + LONG_FORMAT == TRUE: "AutoTrace version x.y" + LONG_FORMAT == FALSE: "x.y" + + return value: Don't free. It is allocated statically */ + const char *at_version(gboolean long_format); + +/* at_home_site + + return value: Don't free. It is allocated statically */ + const char *at_home_site(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* AUTOTRACE_H */ |