| /*====================================================================* |
| - Copyright (C) 2001 Leptonica. All rights reserved. |
| - This software is distributed in the hope that it will be |
| - useful, but with NO WARRANTY OF ANY KIND. |
| - No author or distributor accepts responsibility to anyone for the |
| - consequences of using this software, or for whether it serves any |
| - particular purpose or works at all, unless he or she says so in |
| - writing. Everyone is granted permission to copy, modify and |
| - redistribute this source code, for commercial or non-commercial |
| - purposes, with the following restrictions: (1) the origin of this |
| - source code must not be misrepresented; (2) modified versions must |
| - be plainly marked as such; and (3) this notice may not be removed |
| - or altered from any source or modified source distribution. |
| *====================================================================*/ |
| |
| #ifndef LEPTONICA_PIX_H |
| #define LEPTONICA_PIX_H |
| |
| /* |
| * pix.h |
| * |
| * Contains the following structures: |
| * struct Pix |
| * struct PixColormap |
| * struct RGBA_Quad |
| * struct Pixa |
| * struct Pixaa |
| * struct Box |
| * struct Boxa |
| * struct Boxaa |
| * struct Pta |
| * struct Ptaa |
| * struct Pixacc |
| * struct PixTiling |
| * struct FPix |
| * struct DPix |
| * |
| * Contains definitions for: |
| * colors for RGB |
| * colormap conversion flags |
| * rasterop bit flags |
| * structure access flags (for insert, copy, clone, copy-clone) |
| * sorting flags (by type and direction) |
| * blending flags |
| * graphics pixel setting flags |
| * size filtering flags |
| * rotation and shear flags |
| * affine transform order flags * |
| * grayscale filling flags |
| * dithering flags |
| * distance flags |
| * statistical measures |
| * set selection flags |
| * text orientation flags |
| * edge orientation flags |
| * line orientation flags |
| * scan direction flags |
| * thinning flags |
| * runlength flags |
| * edge filter flags |
| * handling negative values in conversion to unsigned int |
| * relative to zero flags |
| * HSV histogram flags |
| * region flags (inclusion, exclusion) |
| */ |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Basic Pix * |
| *-------------------------------------------------------------------------*/ |
| struct Pix |
| { |
| l_uint32 w; /* width in pixels */ |
| l_uint32 h; /* height in pixels */ |
| l_uint32 d; /* depth in bits */ |
| l_uint32 wpl; /* 32-bit words/line */ |
| l_uint32 refcount; /* reference count (1 if no clones) */ |
| l_uint32 xres; /* image res (ppi) in x direction */ |
| /* (use 0 if unknown) */ |
| l_uint32 yres; /* image res (ppi) in y direction */ |
| /* (use 0 if unknown) */ |
| l_int32 informat; /* input file format, IFF_* */ |
| char *text; /* text string associated with pix */ |
| struct PixColormap *colormap; /* colormap (may be null) */ |
| l_uint32 *data; /* the image data */ |
| }; |
| typedef struct Pix PIX; |
| |
| |
| struct PixColormap |
| { |
| void *array; /* colormap table (array of RGBA_QUAD) */ |
| l_int32 depth; /* of pix (1, 2, 4 or 8 bpp) */ |
| l_int32 nalloc; /* number of color entries allocated */ |
| l_int32 n; /* number of color entries used */ |
| }; |
| typedef struct PixColormap PIXCMAP; |
| |
| |
| /* Colormap table entry (after the BMP version). |
| * Note that the BMP format stores the colormap table exactly |
| * as it appears here, with color samples being stored sequentially, |
| * in the order (b,g,r,a). */ |
| struct RGBA_Quad |
| { |
| l_uint8 blue; |
| l_uint8 green; |
| l_uint8 red; |
| l_uint8 reserved; |
| }; |
| typedef struct RGBA_Quad RGBA_QUAD; |
| |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Colors for 32 bpp * |
| *-------------------------------------------------------------------------*/ |
| /* Notes: |
| * (1) These are the byte indices for colors in 32 bpp images. |
| * They are used through the GET/SET_DATA_BYTE accessors. |
| * The 4th byte, typically known as the "alpha channel" and used |
| * for blending, is not explicitly used in leptonica. |
| * (2) If you redefine these values, functions that have the shifts |
| * hardcoded (instead of using the constants below) will break. |
| * These functions are labelled with "***" next to their names |
| * at the top of the files in which they are defined. |
| * Advice: Do not change these values! |
| * (3) The shifts to extract the red, green and blue components |
| * from a 32 bit pixel are defined in terms of these colors. |
| */ |
| enum { |
| COLOR_RED = 0, |
| COLOR_GREEN = 1, |
| COLOR_BLUE = 2, |
| L_ALPHA_CHANNEL = 3 |
| }; |
| |
| static const l_int32 L_RED_SHIFT = |
| 8 * (sizeof(l_uint32) - 1 - COLOR_RED); /* 24 */ |
| static const l_int32 L_GREEN_SHIFT = |
| 8 * (sizeof(l_uint32) - 1 - COLOR_GREEN); /* 16 */ |
| static const l_int32 L_BLUE_SHIFT = |
| 8 * (sizeof(l_uint32) - 1 - COLOR_BLUE); /* 8 */ |
| static const l_int32 L_ALPHA_SHIFT = |
| 8 * (sizeof(l_uint32) - 1 - L_ALPHA_CHANNEL); /* 0 */ |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Flags for colormap conversion * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| REMOVE_CMAP_TO_BINARY = 0, |
| REMOVE_CMAP_TO_GRAYSCALE = 1, |
| REMOVE_CMAP_TO_FULL_COLOR = 2, |
| REMOVE_CMAP_BASED_ON_SRC = 3 |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * |
| * The following operation bit flags have been modified from |
| * Sun's pixrect.h. |
| * |
| * The 'op' in 'rasterop' is represented by an integer |
| * composed with Boolean functions using the set of five integers |
| * given below. The integers, and the op codes resulting from |
| * boolean expressions on them, need only be in the range from 0 to 15. |
| * The function is applied on a per-pixel basis. |
| * |
| * Examples: the op code representing ORing the src and dest |
| * is computed using the bit OR, as PIX_SRC | PIX_DST; the op |
| * code representing XORing src and dest is found from |
| * PIX_SRC ^ PIX_DST; the op code representing ANDing src and dest |
| * is found from PIX_SRC & PIX_DST. Note that |
| * PIX_NOT(PIX_CLR) = PIX_SET, and v.v., as they must be. |
| * |
| * We would like to use the following set of definitions: |
| * |
| * #define PIX_SRC 0xc |
| * #define PIX_DST 0xa |
| * #define PIX_NOT(op) ((op) ^ 0xf) |
| * #define PIX_CLR 0x0 |
| * #define PIX_SET 0xf |
| * |
| * Now, these definitions differ from Sun's, in that Sun |
| * left-shifted each value by 1 pixel, and used the least |
| * significant bit as a flag for the "pseudo-operation" of |
| * clipping. We don't need this bit, because it is both |
| * efficient and safe ALWAYS to clip the rectangles to the src |
| * and dest images, which is what we do. See the notes in rop.h |
| * on the general choice of these bit flags. |
| * |
| * However, if you include Sun's xview package, you will get their |
| * definitions, and because I like using these flags, we will |
| * adopt the original Sun definitions to avoid redefinition conflicts. |
| * |
| * Then we have, for reference, the following 16 unique op flags: |
| * |
| * PIX_CLR 00000 0x0 |
| * PIX_SET 11110 0x1e |
| * PIX_SRC 11000 0x18 |
| * PIX_DST 10100 0x14 |
| * PIX_NOT(PIX_SRC) 00110 0x06 |
| * PIX_NOT(PIX_DST) 01010 0x0a |
| * PIX_SRC | PIX_DST 11100 0x1c |
| * PIX_SRC & PIX_DST 10000 0x10 |
| * PIX_SRC ^ PIX_DST 01100 0x0c |
| * PIX_NOT(PIX_SRC) | PIX_DST 10110 0x16 |
| * PIX_NOT(PIX_SRC) & PIX_DST 00100 0x04 |
| * PIX_SRC | PIX_NOT(PIX_DST) 11010 0x1a |
| * PIX_SRC & PIX_NOT(PIX_DST) 01000 0x08 |
| * PIX_NOT(PIX_SRC | PIX_DST) 00010 0x02 |
| * PIX_NOT(PIX_SRC & PIX_DST) 01110 0x0e |
| * PIX_NOT(PIX_SRC ^ PIX_DST) 10010 0x12 |
| * |
| *-------------------------------------------------------------------------*/ |
| #define PIX_SRC (0xc << 1) |
| #define PIX_DST (0xa << 1) |
| #define PIX_NOT(op) ((op) ^ 0x1e) |
| #define PIX_CLR (0x0 << 1) |
| #define PIX_SET (0xf << 1) |
| |
| #define PIX_PAINT (PIX_SRC | PIX_DST) |
| #define PIX_MASK (PIX_SRC & PIX_DST) |
| #define PIX_SUBTRACT (PIX_DST & PIX_NOT(PIX_SRC)) |
| #define PIX_XOR (PIX_SRC ^ PIX_DST) |
| |
| |
| /*-------------------------------------------------------------------------* |
| * |
| * Important Notes: |
| * |
| * (1) The image data is stored in a single contiguous |
| * array of l_uint32, into which the pixels are packed. |
| * By "packed" we mean that there are no unused bits |
| * between pixels, except for end-of-line padding to |
| * satisfy item (2) below. |
| * |
| * (2) Every image raster line begins on a 32-bit word |
| * boundary within this array. |
| * |
| * (3) Pix image data is stored in 32-bit units, with the |
| * pixels ordered from left to right in the image being |
| * stored in order from the MSB to LSB within the word, |
| * for both big-endian and little-endian machines. |
| * This is the natural ordering for big-endian machines, |
| * as successive bytes are stored and fetched progressively |
| * to the right. However, for little-endians, when storing |
| * we re-order the bytes from this byte stream order, and |
| * reshuffle again for byte access on 32-bit entities. |
| * So if the bytes come in sequence from left to right, we |
| * store them on little-endians in byte order: |
| * 3 2 1 0 7 6 5 4 ... |
| * This MSB to LSB ordering allows left and right shift |
| * operations on 32 bit words to move the pixels properly. |
| * |
| * (4) For 24-bit color images, use 32 bpp data, leaving |
| * the fourth byte unused. Within each 4 byte pixel, the |
| * colors are ordered from MSB to LSB, as follows: |
| * |
| * | MSB | 2nd MSB | 3rd MSB | LSB | |
| * red green blue unused |
| * 0 1 2 3 (big-endian) |
| * 3 2 1 0 (little-endian) |
| * |
| * Because we use MSB to LSB ordering within the 32-bit word, |
| * the individual 8-bit samples can be accessed with |
| * GET_DATA_BYTE and SET_DATA_BYTE macros, using the |
| * (implicitly big-ending) ordering |
| * red: byte 0 (MSB) |
| * green: byte 1 (2nd MSB) |
| * blue: byte 2 (3rd MSB) |
| * |
| * This specific color assignment is made in this file, |
| * through the definitions of COLOR_RED, etc. Then the R, G |
| * and B sample values can be retrieved using |
| * redval = GET_DATA_BYTE(&pixel, COLOR_RED); |
| * greenval = GET_DATA_BYTE(&pixel, COLOR_GREEN); |
| * blueval = GET_DATA_BYTE(&pixel, COLOR_BLUE); |
| * and they can be set with |
| * SET_DATA_BYTE(&pixel, COLOR_RED, redval); |
| * SET_DATA_BYTE(&pixel, COLOR_GREEN, greenval); |
| * SET_DATA_BYTE(&pixel, COLOR_BLUE, blueval); |
| * |
| * For extra speed we extract the R, G and B colors directly |
| * by shifting and masking, explicitly using the values in |
| * L_RED_SHIFT, L_GREEN_SHIFT and L_BLUE_SHIFT: |
| * (pixel32 >> L_RED_SHIFT) & 0xff; (red) |
| * (pixel32 >> L_GREEN_SHIFT) & 0xff; (green) |
| * (pixel32 >> L_BLUE_SHIFT) & 0xff; (blue) |
| * All these operations work properly on both big- and little-endians. |
| * |
| * For a few situations, these color shift values are hard-coded. |
| * Changing the RGB color component ordering through the assignments |
| * in this file will cause functions marked with "***" to fail. |
| * |
| * (5) A reference count is held within each pix, giving the |
| * number of ptrs to the pix. When a pixClone() call |
| * is made, the ref count is increased by 1, and |
| * when a pixDestroy() call is made, the reference count |
| * of the pix is decremented. The pix is only destroyed |
| * when the reference count goes to zero. |
| * |
| * (6) The version numbers (below) are used in the serialization |
| * of these data structures. They are placed in the files, |
| * and rarely (if ever) change. Provision is currently made for |
| * backward compatibility in reading from boxaa version 2. |
| * |
| * (7) The serialization dependencies are as follows: |
| * pixaa : pixa : boxa |
| * boxaa : boxa |
| * So, for example, pixaa and boxaa can be changed without |
| * forcing a change in pixa or boxa. However, if pixa is |
| * changed, it forces a change in pixaa, and if boxa is |
| * changed, if forces a change in the other three. |
| * We define four version numbers: |
| * PIXAA_VERSION_NUMBER |
| * PIXA_VERSION_NUMBER |
| * BOXAA_VERSION_NUMBER |
| * BOXA_VERSION_NUMBER |
| * |
| *-------------------------------------------------------------------------*/ |
| |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Array of pix * |
| *-------------------------------------------------------------------------*/ |
| |
| /* Serialization for primary data structures */ |
| #define PIXAA_VERSION_NUMBER 2 |
| #define PIXA_VERSION_NUMBER 2 |
| #define BOXA_VERSION_NUMBER 2 |
| #define BOXAA_VERSION_NUMBER 3 |
| |
| |
| struct Pixa |
| { |
| l_int32 n; /* number of Pix in ptr array */ |
| l_int32 nalloc; /* number of Pix ptrs allocated */ |
| l_uint32 refcount; /* reference count (1 if no clones) */ |
| struct Pix **pix; /* the array of ptrs to pix */ |
| struct Boxa *boxa; /* array of boxes */ |
| }; |
| typedef struct Pixa PIXA; |
| |
| |
| struct Pixaa |
| { |
| l_int32 n; /* number of Pixa in ptr array */ |
| l_int32 nalloc; /* number of Pixa ptrs allocated */ |
| struct Pixa **pixa; /* array of ptrs to pixa */ |
| struct Boxa *boxa; /* array of boxes */ |
| }; |
| typedef struct Pixaa PIXAA; |
| |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Basic rectangle and rectangle arrays * |
| *-------------------------------------------------------------------------*/ |
| struct Box |
| { |
| l_int32 x; |
| l_int32 y; |
| l_int32 w; |
| l_int32 h; |
| l_uint32 refcount; /* reference count (1 if no clones) */ |
| |
| }; |
| typedef struct Box BOX; |
| |
| struct Boxa |
| { |
| l_int32 n; /* number of box in ptr array */ |
| l_int32 nalloc; /* number of box ptrs allocated */ |
| l_uint32 refcount; /* reference count (1 if no clones) */ |
| struct Box **box; /* box ptr array */ |
| }; |
| typedef struct Boxa BOXA; |
| |
| struct Boxaa |
| { |
| l_int32 n; /* number of boxa in ptr array */ |
| l_int32 nalloc; /* number of boxa ptrs allocated */ |
| struct Boxa **boxa; /* boxa ptr array */ |
| }; |
| typedef struct Boxaa BOXAA; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Array of points * |
| *-------------------------------------------------------------------------*/ |
| #define PTA_VERSION_NUMBER 1 |
| |
| struct Pta |
| { |
| l_int32 n; /* actual number of pts */ |
| l_int32 nalloc; /* size of allocated arrays */ |
| l_int32 refcount; /* reference count (1 if no clones) */ |
| l_float32 *x, *y; /* arrays of floats */ |
| }; |
| typedef struct Pta PTA; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Array of Pta * |
| *-------------------------------------------------------------------------*/ |
| struct Ptaa |
| { |
| l_int32 n; /* number of pta in ptr array */ |
| l_int32 nalloc; /* number of pta ptrs allocated */ |
| struct Pta **pta; /* pta ptr array */ |
| }; |
| typedef struct Ptaa PTAA; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Pix accumulator container * |
| *-------------------------------------------------------------------------*/ |
| struct Pixacc |
| { |
| l_int32 w; /* array width */ |
| l_int32 h; /* array height */ |
| l_int32 offset; /* used to allow negative */ |
| /* intermediate results */ |
| struct Pix *pix; /* the 32 bit accumulator pix */ |
| }; |
| typedef struct Pixacc PIXACC; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Pix tiling * |
| *-------------------------------------------------------------------------*/ |
| struct PixTiling |
| { |
| struct Pix *pix; /* input pix (a clone) */ |
| l_int32 nx; /* number of tiles horizontally */ |
| l_int32 ny; /* number of tiles vertically */ |
| l_int32 w; /* tile width */ |
| l_int32 h; /* tile height */ |
| l_int32 xoverlap; /* overlap on left and right */ |
| l_int32 yoverlap; /* overlap on top and bottom */ |
| l_int32 strip; /* strip for paint; default is TRUE */ |
| }; |
| typedef struct PixTiling PIXTILING; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * FPix: pix with float array * |
| *-------------------------------------------------------------------------*/ |
| struct FPix |
| { |
| l_int32 w; /* width in pixels */ |
| l_int32 h; /* height in pixels */ |
| l_int32 wpl; /* 32-bit words/line */ |
| l_int32 refcount; /* reference count (1 if no clones) */ |
| l_int32 xres; /* image res (ppi) in x direction */ |
| /* (use 0 if unknown) */ |
| l_int32 yres; /* image res (ppi) in y direction */ |
| /* (use 0 if unknown) */ |
| l_float32 *data; /* the float image data */ |
| }; |
| typedef struct FPix FPIX; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * DPix: pix with double array * |
| *-------------------------------------------------------------------------*/ |
| struct DPix |
| { |
| l_int32 w; /* width in pixels */ |
| l_int32 h; /* height in pixels */ |
| l_int32 wpl; /* 32-bit words/line */ |
| l_int32 refcount; /* reference count (1 if no clones) */ |
| l_int32 xres; /* image res (ppi) in x direction */ |
| /* (use 0 if unknown) */ |
| l_int32 yres; /* image res (ppi) in y direction */ |
| /* (use 0 if unknown) */ |
| l_float64 *data; /* the double image data */ |
| }; |
| typedef struct DPix DPIX; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Access and storage flags * |
| *-------------------------------------------------------------------------*/ |
| /* |
| * For Pix, Box, Pta and Numa, there are 3 standard methods for handling |
| * the retrieval or insertion of a struct: |
| * (1) direct insertion (Don't do this if there is another handle |
| * somewhere to this same struct!) |
| * (2) copy (Always safe, sets up a refcount of 1 on the new object. |
| * Can be undesirable if very large, such as an image or |
| * an array of images.) |
| * (3) clone (Makes another handle to the same struct, and bumps the |
| * refcount up by 1. Safe to do unless you're changing |
| * data through one of the handles but don't want those |
| * changes to be seen by the other handle.) |
| * |
| * For Pixa and Boxa, which are structs that hold an array of clonable |
| * structs, there is an additional method: |
| * (4) copy-clone (Makes a new higher-level struct with a refcount |
| * of 1, but clones all the structs in the array.) |
| * |
| * Unlike the other structs, when retrieving a string from an Sarray, |
| * you are allowed to get a handle without a copy or clone (i.e., that |
| * you don't own!). You must not free or insert such a string! |
| * Specifically, for an Sarray, the copyflag for retrieval is either: |
| * TRUE (or 1 or L_COPY) |
| * or |
| * FALSE (or 0 or L_NOCOPY) |
| * For insertion, the copyflag is either: |
| * TRUE (or 1 or L_COPY) |
| * or |
| * FALSE (or 0 or L_INSERT) |
| * Note that L_COPY is always 1, and L_INSERT and L_NOCOPY are always 0. |
| */ |
| enum { |
| L_INSERT = 0, /* stuff it in; no copy, clone or copy-clone */ |
| L_COPY = 1, /* make/use a copy of the object */ |
| L_CLONE = 2, /* make/use clone (ref count) of the object */ |
| L_COPY_CLONE = 3 /* make a new object and fill with with clones */ |
| /* of each object in the array(s) */ |
| }; |
| static const l_int32 L_NOCOPY = 0; /* copyflag value in sarrayGetString() */ |
| |
| |
| /*--------------------------------------------------------------------------* |
| * Sort flags * |
| *--------------------------------------------------------------------------*/ |
| enum { |
| L_SORT_INCREASING = 1, /* sort in increasing order */ |
| L_SORT_DECREASING = 2 /* sort in decreasing order */ |
| }; |
| |
| enum { |
| L_SORT_BY_X = 3, /* sort box or c.c. by horiz location */ |
| L_SORT_BY_Y = 4, /* sort box or c.c. by vert location */ |
| L_SORT_BY_WIDTH = 5, /* sort box or c.c. by width */ |
| L_SORT_BY_HEIGHT = 6, /* sort box or c.c. by height */ |
| L_SORT_BY_MIN_DIMENSION = 7, /* sort box or c.c. by min dimension */ |
| L_SORT_BY_MAX_DIMENSION = 8, /* sort box or c.c. by max dimension */ |
| L_SORT_BY_PERIMETER = 9, /* sort box or c.c. by perimeter */ |
| L_SORT_BY_AREA = 10, /* sort box or c.c. by area */ |
| L_SORT_BY_ASPECT_RATIO = 11 /* sort box or c.c. by width/height ratio */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Blend flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_BLEND_WITH_INVERSE = 1, /* add some of src inverse to itself */ |
| L_BLEND_TO_WHITE = 2, /* shift src colors towards white */ |
| L_BLEND_TO_BLACK = 3, /* shift src colors towards black */ |
| L_BLEND_GRAY = 4, /* blend src directly with blender */ |
| L_BLEND_GRAY_WITH_INVERSE = 5 /* add amount of src inverse to itself, */ |
| /* based on blender pix value */ |
| }; |
| |
| enum { |
| L_PAINT_LIGHT = 1, /* colorize non-black pixels */ |
| L_PAINT_DARK = 2 /* colorize non-white pixels */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Graphics pixel setting * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_SET_PIXELS = 1, /* set all bits in each pixel to 1 */ |
| L_CLEAR_PIXELS = 2, /* set all bits in each pixel to 0 */ |
| L_FLIP_PIXELS = 3 /* flip all bits in each pixel */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Size filter flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_SELECT_WIDTH = 1, /* width must satisfy constraint */ |
| L_SELECT_HEIGHT = 2, /* height must satisfy constraint */ |
| L_SELECT_IF_EITHER = 3, /* either width or height can satisfy */ |
| L_SELECT_IF_BOTH = 4 /* both width and height must satisfy */ |
| }; |
| |
| enum { |
| L_SELECT_IF_LT = 1, /* save if value is less than threshold */ |
| L_SELECT_IF_GT = 2, /* save if value is more than threshold */ |
| L_SELECT_IF_LTE = 3, /* save if value is <= to the threshold */ |
| L_SELECT_IF_GTE = 4 /* save if value is >= to the threshold */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Rotate and shear flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_ROTATE_AREA_MAP = 1, /* use area map rotation, if possible */ |
| L_ROTATE_SHEAR = 2, /* use shear rotation */ |
| L_ROTATE_SAMPLING = 3 /* use sampling */ |
| }; |
| |
| enum { |
| L_BRING_IN_WHITE = 1, /* bring in white pixels from the outside */ |
| L_BRING_IN_BLACK = 2 /* bring in black pixels from the outside */ |
| }; |
| |
| enum { |
| L_SHEAR_ABOUT_CORNER = 1, /* shear image about UL corner */ |
| L_SHEAR_ABOUT_CENTER = 2 /* shear image about center */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Affine transform order flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_TR_SC_RO = 1, /* translate, scale, rotate */ |
| L_SC_RO_TR = 2, /* scale, rotate, translate */ |
| L_RO_TR_SC = 3, /* rotate, translate, scale */ |
| L_TR_RO_SC = 4, /* translate, rotate, scale */ |
| L_RO_SC_TR = 5, /* rotate, scale, translate */ |
| L_SC_TR_RO = 6 /* scale, translate, rotate */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Grayscale fill flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_FILL_WHITE = 1, /* fill white pixels (e.g, in fg map) */ |
| L_FILL_BLACK = 2 /* fill black pixels (e.g., in bg map) */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Dither parameters * |
| * If within this grayscale distance from black or white, * |
| * do not propagate excess or deficit to neighboring pixels. * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| DEFAULT_CLIP_LOWER_1 = 10, /* dist to black with no prop; 1 bpp */ |
| DEFAULT_CLIP_UPPER_1 = 10, /* dist to black with no prop; 1 bpp */ |
| DEFAULT_CLIP_LOWER_2 = 5, /* dist to black with no prop; 2 bpp */ |
| DEFAULT_CLIP_UPPER_2 = 5 /* dist to black with no prop; 2 bpp */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Distance flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_MANHATTAN_DISTANCE = 1, /* L1 distance (e.g., in color space) */ |
| L_EUCLIDEAN_DISTANCE = 2 /* L2 distance */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Statistical measures * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_MEAN_ABSVAL = 1, /* average of abs values */ |
| L_MEDIAN_VAL = 2, /* median value of set */ |
| L_MODE_VAL = 3, /* mode value of set */ |
| L_MODE_COUNT = 4, /* mode count of set */ |
| L_ROOT_MEAN_SQUARE = 5, /* rms of values */ |
| L_STANDARD_DEVIATION = 6, /* standard deviation from mean */ |
| L_VARIANCE = 7 /* variance of values */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Set selection flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_CHOOSE_CONSECUTIVE = 1, /* select 'n' consecutive */ |
| L_CHOOSE_SKIP_BY = 2 /* select at intervals of 'n' */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Text orientation flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_TEXT_ORIENT_UNKNOWN = 0, /* low confidence on text orientation */ |
| L_TEXT_ORIENT_UP = 1, /* portrait, text rightside-up */ |
| L_TEXT_ORIENT_LEFT = 2, /* landscape, text up to left */ |
| L_TEXT_ORIENT_DOWN = 3, /* portrait, text upside-down */ |
| L_TEXT_ORIENT_RIGHT = 4 /* landscape, text up to right */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Edge orientation flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_HORIZONTAL_EDGES = 0, /* filters for horizontal edges */ |
| L_VERTICAL_EDGES = 1, /* filters for vertical edges */ |
| L_ALL_EDGES = 2 /* filters for all edges */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Line orientation flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_HORIZONTAL_LINE = 0, /* horizontal line */ |
| L_POS_SLOPE_LINE = 1, /* 45 degree line with positive slope */ |
| L_VERTICAL_LINE = 2, /* vertical line */ |
| L_NEG_SLOPE_LINE = 3 /* 45 degree line with negative slope */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Scan direction flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_FROM_LEFT = 0, /* scan from left */ |
| L_FROM_RIGHT = 1, /* scan from right */ |
| L_FROM_TOP = 2, /* scan from top */ |
| L_FROM_BOTTOM = 3 /* scan from bottom */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Thinning flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_THIN_FG = 1, /* thin foreground of 1 bpp image */ |
| L_THIN_BG = 2 /* thin background of 1 bpp image */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Runlength flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_HORIZONTAL_RUNS = 0, /* determine runlengths of horizontal runs */ |
| L_VERTICAL_RUNS = 1 /* determine runlengths of vertical runs */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Edge filter flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_SOBEL_EDGE = 1, /* Sobel edge filter */ |
| L_TWO_SIDED_EDGE = 2 /* Two-sided edge filter */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Handling negative values in conversion to unsigned int * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_CLIP_TO_ZERO = 1, /* Clip negative values to 0 */ |
| L_TAKE_ABSVAL = 2 /* Convert to positive using L_ABS() */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Relative to zero flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_LESS_THAN_ZERO = 1, /* Choose values less than zero */ |
| L_EQUAL_TO_ZERO = 2, /* Choose values equal to zero */ |
| L_GREATER_THAN_ZERO = 3 /* Choose values greater than zero */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * HSV histogram flags * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_HS_HISTO = 1, /* Use hue-saturation histogram */ |
| L_HV_HISTO = 2, /* Use hue-value histogram */ |
| L_SV_HISTO = 3 /* Use saturation-value histogram */ |
| }; |
| |
| |
| /*-------------------------------------------------------------------------* |
| * Region flags (inclusion, exclusion) * |
| *-------------------------------------------------------------------------*/ |
| enum { |
| L_INCLUDE_REGION = 1, /* Use hue-saturation histogram */ |
| L_EXCLUDE_REGION = 2 /* Use hue-value histogram */ |
| }; |
| |
| |
| #endif /* LEPTONICA_PIX_H */ |
| |
