pix.h

Go to the documentation of this file.

/*====================================================================*
 -  Copyright (C) 2001 Leptonica.  All rights reserved.
 -
 -  Redistribution and use in source and binary forms, with or without
 -  modification, are permitted provided that the following conditions
 -  are met:
 -  1. Redistributions of source code must retain the above copyright
 -     notice, this list of conditions and the following disclaimer.
 -  2. Redistributions in binary form must reproduce the above
 -     copyright notice, this list of conditions and the following
 -     disclaimer in the documentation and/or other materials
 -     provided with the distribution.
 -
 -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
 -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *====================================================================*/
 
#ifndef  LEPTONICA_PIX_H
#define  LEPTONICA_PIX_H
 
/*-------------------------------------------------------------------------*
 *                              Basic Pix                                  *
 *-------------------------------------------------------------------------*/
typedef struct Pix PIX;
 
typedef struct PixColormap  PIXCMAP;
 
typedef struct RGBA_Quad  RGBA_QUAD;
 
/*-------------------------------------------------------------------------*
 *                               Pix arrays                                *
 *-------------------------------------------------------------------------*/
typedef struct Pixa PIXA;
 
typedef struct Pixaa PIXAA;
 
/*-------------------------------------------------------------------------*
 *                    Basic rectangle and rectangle arrays                 *
 *-------------------------------------------------------------------------*/
typedef struct Box    BOX;
 
typedef struct Boxa  BOXA;
 
typedef struct Boxaa  BOXAA;
 
/*-------------------------------------------------------------------------*
 *                              Arrays of points                           *
 *-------------------------------------------------------------------------*/
typedef struct Pta PTA;
 
typedef struct Ptaa PTAA;
 
/*-------------------------------------------------------------------------*
 *                       Pix accumulator container                         *
 *-------------------------------------------------------------------------*/
typedef struct Pixacc PIXACC;
 
/*-------------------------------------------------------------------------*
 *                              Pix tiling                                 *
 *-------------------------------------------------------------------------*/
typedef struct PixTiling PIXTILING;
 
/*-------------------------------------------------------------------------*
 *                       FPix: pix with float array                        *
 *-------------------------------------------------------------------------*/
typedef struct FPix FPIX;
 
typedef struct FPixa FPIXA;
 
/*-------------------------------------------------------------------------*
 *                       DPix: pix with double array                       *
 *-------------------------------------------------------------------------*/
typedef struct DPix DPIX;
 
/*-------------------------------------------------------------------------*
 *                       Compressed pix and arrays                         *
 *-------------------------------------------------------------------------*/
typedef struct PixComp PIXC;
 
typedef struct PixaComp PIXAC;
 
 
 
/*-------------------------------------------------------------------------*
 *                           Colors for 32 RGBA                            *
 *-------------------------------------------------------------------------*/
/* <pre>
 *  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 used to a small extent in leptonica.
 *      (2) Do not change these values!  If you redefine them, functions
 *          that have the shifts hardcoded for efficiency and conciseness
 *          (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.
 *      (3) The shifts to extract the red, green, blue and alpha components
 *          from a 32 bit pixel are defined here.
 * </pre>
 */
 
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 */
 
 
/*-------------------------------------------------------------------------*
 *                       Colors for drawing boxes                          *
 *-------------------------------------------------------------------------*/
enum {
    L_DRAW_RED = 0,         
    L_DRAW_GREEN = 1,       
    L_DRAW_BLUE = 2,        
    L_DRAW_SPECIFIED = 3,   
    L_DRAW_RGB = 4,         
    L_DRAW_RANDOM = 5       
};
 
 
/*-------------------------------------------------------------------------*
 *                       Perceptual color weights                          *
 *-------------------------------------------------------------------------*/
/* <pre>
 *  Notes:
 *      (1) These perceptual weighting factors are ad-hoc, but they do
 *          add up to 1.  Unlike, for example, the weighting factors for
 *          converting RGB to luminance, or more specifically to Y in the
 *          YUV colorspace.  Those numbers come from the
 *          International Telecommunications Union, via ITU-R.
 * </pre>
 */
static const l_float32 L_RED_WEIGHT =   0.3f; 
static const l_float32 L_GREEN_WEIGHT = 0.5f; 
static const l_float32 L_BLUE_WEIGHT =  0.2f; 
/*-------------------------------------------------------------------------*
 *                        Flags for colormap conversion                    *
 *-------------------------------------------------------------------------*/
enum {
    REMOVE_CMAP_TO_BINARY = 0,     
    REMOVE_CMAP_TO_GRAYSCALE = 1,  
    REMOVE_CMAP_TO_FULL_COLOR = 2, 
    REMOVE_CMAP_WITH_ALPHA = 3,    
    REMOVE_CMAP_BASED_ON_SRC = 4   
};
 
 
/*------------------------------------------------------------------------*
 *!
 * <pre>
 * The following operation bit flags have been modified from Sun's
 * original "bitblt" (bit block transfer) operations (from the 1980s).
 *
 * 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 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
 *
 * [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.]
 *
 * Here are the 16 unique op flags:
 *
 *      PIX_CLR                           0000             0x0
 *      PIX_SET                           1111             0xf
 *      PIX_SRC                           1100             0xc
 *      PIX_DST                           1010             0xa
 *      PIX_NOT(PIX_SRC)                  0011             0x3
 *      PIX_NOT(PIX_DST)                  0101             0x5
 *      PIX_SRC | PIX_DST                 1110             0xe
 *      PIX_SRC & PIX_DST                 1000             0x8
 *      PIX_SRC ^ PIX_DST                 0110             0x6
 *      PIX_NOT(PIX_SRC) | PIX_DST        1011             0xb
 *      PIX_NOT(PIX_SRC) & PIX_DST        0010             0x2
 *      PIX_SRC | PIX_NOT(PIX_DST)        1101             0xd
 *      PIX_SRC & PIX_NOT(PIX_DST)        0100             0x4
 *      PIX_NOT(PIX_SRC | PIX_DST)        0001             0x1
 *      PIX_NOT(PIX_SRC & PIX_DST)        0111             0x7
 *      PIX_NOT(PIX_SRC ^ PIX_DST)        1001             0x9
 *
 * </pre>
 *-------------------------------------------------------------------------*/
 
#define   PIX_SRC      (0xc)                      
#define   PIX_DST      (0xa)                      
#define   PIX_NOT(op)  ((op) ^ 0x0f)              
#define   PIX_CLR      (0x0)                      
#define   PIX_SET      (0xf)                      
#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)        
/*-------------------------------------------------------------------------*
 *                         Access and storage flags                        *
 *-------------------------------------------------------------------------*/
/*
 * <pre>
 *  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.  OK to use except in two situations:
 *                (a) You change data through one of the handles but don't
 *                    want those changes to be seen by the other handle.
 *                (b) The application is multi-threaded.  Because the clone
 *                    operation is not atomic (e.g., locked with a mutex),
 *                    it is possible to end up with an incorrect ref count,
 *                    causing either a memory leak or a crash.
 *
 *  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., the
 *  string is not owned by the handle).  You must not either free the string
 *  or insert it in some other struct that would own it.  Specifically,
 *  for an Sarray, the copyflag for retrieval is either:
 *         L_COPY or L_NOCOPY
 *  and for insertion, the copyflag is either:
 *         L_COPY or one of {L_INSERT , L_NOCOPY} (the latter are equivalent
 *                                                 for insertion))
 *  Typical patterns are:
 *  (1) Reference a string in an Sarray with L_NOCOPY and insert a copy
 *      of it in another Sarray with L_COPY.
 *  (2) Copy a string from an Sarray with L_COPY and insert it in
 *      another Sarray with L_INSERT (or L_NOCOPY).
 *  In both cases, a copy is made and both Sarrays own their instance
 *  of that string.
 * </pre>
 */
enum {
    L_NOCOPY = 0,     
    L_INSERT = L_NOCOPY,    
    L_COPY = 1,       
    L_CLONE = 2,      
    L_COPY_CLONE = 3  
};
 
/*----------------------------------------------------------------------------*
 *                              Sort flags                                    *
 *----------------------------------------------------------------------------*/
enum {
    L_SHELL_SORT = 1,            
    L_BIN_SORT = 2               
};
 
enum {
    L_SORT_INCREASING = 1,       
    L_SORT_DECREASING = 2        
};
 
enum {
    L_SORT_BY_X = 1,             
    L_SORT_BY_Y = 2,             
    L_SORT_BY_RIGHT = 3,         
    L_SORT_BY_BOT = 4,           
    L_SORT_BY_WIDTH = 5,         
    L_SORT_BY_HEIGHT = 6,        
    L_SORT_BY_MIN_DIMENSION = 7, 
    L_SORT_BY_MAX_DIMENSION = 8, 
    L_SORT_BY_PERIMETER = 9,     
    L_SORT_BY_AREA = 10,         
    L_SORT_BY_ASPECT_RATIO = 11  
};
 
/*---------------------------------------------------------------------------*
 *                             Blend flags                                   *
 *---------------------------------------------------------------------------*/
enum {
    L_BLEND_WITH_INVERSE = 1,     
    L_BLEND_TO_WHITE = 2,         
    L_BLEND_TO_BLACK = 3,         
    L_BLEND_GRAY = 4,             
    L_BLEND_GRAY_WITH_INVERSE = 5 
};
 
enum {
    L_PAINT_LIGHT = 1,            
    L_PAINT_DARK = 2              
};
 
/*-------------------------------------------------------------------------*
 *                        Graphics pixel setting                           *
 *-------------------------------------------------------------------------*/
enum {
    L_SET_PIXELS = 1,           
    L_CLEAR_PIXELS = 2,         
    L_FLIP_PIXELS = 3           
};
 
/*-------------------------------------------------------------------------*
 *                     Size and location filter flags                      *
 *-------------------------------------------------------------------------*/
enum {
    L_SELECT_IF_LT = 1,         
    L_SELECT_IF_GT = 2,         
    L_SELECT_IF_LTE = 3,        
    L_SELECT_IF_GTE = 4         
};
 
enum {
    L_SELECT_BY_WIDTH = 1,          
    L_SELECT_BY_HEIGHT = 2,         
    L_SELECT_BY_MAX_DIMENSION = 3,  
    L_SELECT_BY_AREA = 4,           
    L_SELECT_BY_PERIMETER = 5       
};
 
enum {
    L_SELECT_WIDTH = 1,         
    L_SELECT_HEIGHT = 2,        
    L_SELECT_XVAL = 3,          
    L_SELECT_YVAL = 4,          
    L_SELECT_IF_EITHER = 5,     
    L_SELECT_IF_BOTH = 6        
};
 
enum {
    L_CHECK_WIDTH = 1,          
    L_CHECK_HEIGHT = 2,         
    L_CHECK_BOTH = 3            
};
 
/*-------------------------------------------------------------------------*
 *                    Color component selection flags                      *
 *-------------------------------------------------------------------------*/
enum {
    L_SELECT_RED = 1,           
    L_SELECT_GREEN = 2,         
    L_SELECT_BLUE = 3,          
    L_SELECT_MIN = 4,           
    L_SELECT_MAX = 5,           
    L_SELECT_AVERAGE = 6,       
    L_SELECT_HUE = 7,           
    L_SELECT_SATURATION = 8,    
    L_SELECT_WEIGHTED = 9       
};
 
/*-------------------------------------------------------------------------*
 *                          Color content flags                            *
 *-------------------------------------------------------------------------*/
enum {
    L_INTERMED_DIFF = 1,        
    L_AVE_MAX_DIFF_2 = 2,       
    L_MAX_DIFF = 3              
};
 
/*-------------------------------------------------------------------------*
 *                         16-bit conversion flags                         *
 *-------------------------------------------------------------------------*/
enum {
    L_LS_BYTE = 1,              
    L_MS_BYTE = 2,              
    L_AUTO_BYTE = 3,            
    L_CLIP_TO_FF = 4,           
    L_LS_TWO_BYTES = 5,         
    L_MS_TWO_BYTES = 6,         
    L_CLIP_TO_FFFF = 7          
};
 
/*-------------------------------------------------------------------------*
 *                        Rotate and shear flags                           *
 *-------------------------------------------------------------------------*/
enum {
    L_ROTATE_AREA_MAP = 1,     
    L_ROTATE_SHEAR = 2,        
    L_ROTATE_SAMPLING = 3      
};
 
enum {
    L_BRING_IN_WHITE = 1,      
    L_BRING_IN_BLACK = 2       
};
 
enum {
    L_SHEAR_ABOUT_CORNER = 1,  
    L_SHEAR_ABOUT_CENTER = 2   
};
 
/*-------------------------------------------------------------------------*
 *                     Affine transform order flags                        *
 *-------------------------------------------------------------------------*/
enum {
    L_TR_SC_RO = 1,            
    L_SC_RO_TR = 2,            
    L_RO_TR_SC = 3,            
    L_TR_RO_SC = 4,            
    L_RO_SC_TR = 5,            
    L_SC_TR_RO = 6             
};
 
/*-------------------------------------------------------------------------*
 *                       Grayscale filling flags                           *
 *-------------------------------------------------------------------------*/
enum {
    L_FILL_WHITE = 1,         
    L_FILL_BLACK = 2          
};
 
/*-------------------------------------------------------------------------*
 *                   Flags for setting to white or black                   *
 *-------------------------------------------------------------------------*/
enum {
    L_SET_WHITE = 1,         
    L_SET_BLACK = 2          
};
 
/*-------------------------------------------------------------------------*
 *                  Flags for getting white or black value                 *
 *-------------------------------------------------------------------------*/
enum {
    L_GET_WHITE_VAL = 1,     
    L_GET_BLACK_VAL = 2      
};
 
/*-------------------------------------------------------------------------*
 *                  Flags for 8 bit and 16 bit pixel sums                  *
 *-------------------------------------------------------------------------*/
enum {
    L_WHITE_IS_MAX = 1, 
    L_BLACK_IS_MAX = 2  
};
 
/*-------------------------------------------------------------------------*
 *                           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, 
    DEFAULT_CLIP_UPPER_1 = 10, 
    DEFAULT_CLIP_LOWER_2 = 5,  
    DEFAULT_CLIP_UPPER_2 = 5   
};
 
/*-------------------------------------------------------------------------*
 *                          Distance type flags                            *
 *-------------------------------------------------------------------------*/
enum {
    L_MANHATTAN_DISTANCE = 1,  
    L_EUCLIDEAN_DISTANCE = 2   
};
 
/*-------------------------------------------------------------------------*
 *                         Distance Value flags                            *
 *-------------------------------------------------------------------------*/
enum {
    L_NEGATIVE = 1,      
    L_NON_NEGATIVE = 2,  
    L_POSITIVE = 3,      
    L_NON_POSITIVE = 4,  
    L_ZERO = 5,          
    L_ALL = 6            
};
 
/*-------------------------------------------------------------------------*
 *                         Statistical measures                            *
 *-------------------------------------------------------------------------*/
enum {
    L_MEAN_ABSVAL = 1,         
    L_MEDIAN_VAL = 2,          
    L_MODE_VAL = 3,            
    L_MODE_COUNT = 4,          
    L_ROOT_MEAN_SQUARE = 5,    
    L_STANDARD_DEVIATION = 6,  
    L_VARIANCE = 7             
};
 
/*-------------------------------------------------------------------------*
 *                       Set index selection flags                         *
 *-------------------------------------------------------------------------*/
enum {
    L_CHOOSE_CONSECUTIVE = 1,  
    L_CHOOSE_SKIP_BY = 2       
};
 
/*-------------------------------------------------------------------------*
 *                         Text orientation flags                          *
 *-------------------------------------------------------------------------*/
enum {
    L_TEXT_ORIENT_UNKNOWN = 0, 
    L_TEXT_ORIENT_UP = 1,      
    L_TEXT_ORIENT_LEFT = 2,    
    L_TEXT_ORIENT_DOWN = 3,    
    L_TEXT_ORIENT_RIGHT = 4    
};
 
/*-------------------------------------------------------------------------*
 *                         Edge orientation flags                          *
 *-------------------------------------------------------------------------*/
enum {
    L_HORIZONTAL_EDGES = 0,   
    L_VERTICAL_EDGES = 1,     
    L_ALL_EDGES = 2           
};
 
/*-------------------------------------------------------------------------*
 *                         Line orientation flags                          *
 *-------------------------------------------------------------------------*/
enum {
    L_HORIZONTAL_LINE = 0,   
    L_POS_SLOPE_LINE = 1,    
    L_VERTICAL_LINE = 2,     
    L_NEG_SLOPE_LINE = 3,    
    L_OBLIQUE_LINE = 4       
};
 
/*-------------------------------------------------------------------------*
 *                         Image orientation flags                         *
 *-------------------------------------------------------------------------*/
enum {
    L_PORTRAIT_MODE = 0,   
    L_LANDSCAPE_MODE = 1   
};
 
/*-------------------------------------------------------------------------*
 *                           Scan direction flags                          *
 *-------------------------------------------------------------------------*/
enum {
    L_FROM_LEFT = 0,         
    L_FROM_RIGHT = 1,        
    L_FROM_TOP = 2,          
    L_FROM_BOT = 3,          
    L_SCAN_NEGATIVE = 4,     
    L_SCAN_POSITIVE = 5,     
    L_SCAN_BOTH = 6,         
    L_SCAN_HORIZONTAL = 7,   
    L_SCAN_VERTICAL = 8      
};
 
/*-------------------------------------------------------------------------*
 *                Box size adjustment and location flags                   *
 *-------------------------------------------------------------------------*/
enum {
    L_ADJUST_SKIP = 0,           
    L_ADJUST_LEFT = 1,           
    L_ADJUST_RIGHT = 2,          
    L_ADJUST_LEFT_AND_RIGHT = 3, 
    L_ADJUST_TOP = 4,            
    L_ADJUST_BOT = 5,            
    L_ADJUST_TOP_AND_BOT = 6,    
    L_ADJUST_CHOOSE_MIN = 7,     
    L_ADJUST_CHOOSE_MAX = 8,     
    L_SET_LEFT = 9,              
    L_SET_RIGHT = 10,            
    L_SET_TOP = 11,              
    L_SET_BOT = 12,              
    L_GET_LEFT = 13,             
    L_GET_RIGHT = 14,            
    L_GET_TOP = 15,              
    L_GET_BOT = 16               
};
 
/*-------------------------------------------------------------------------*
 *          Flags for modifying box boundaries using a second box          *
 *-------------------------------------------------------------------------*/
enum {
    L_USE_MINSIZE = 1,           
    L_USE_MAXSIZE = 2,           
    L_SUB_ON_LOC_DIFF = 3,       
    L_SUB_ON_SIZE_DIFF = 4,      
    L_USE_CAPPED_MIN = 5,        
    L_USE_CAPPED_MAX = 6         
};
 
/*-------------------------------------------------------------------------*
 *              Handling overlapping bounding boxes in boxa                *
 *-------------------------------------------------------------------------*/
enum {
    L_COMBINE = 1,         
    L_REMOVE_SMALL = 2     
};
 
/*-------------------------------------------------------------------------*
 *        Selecting or making a box from two (intersecting) boxes          *
 *-------------------------------------------------------------------------*/
enum {
    L_GEOMETRIC_UNION = 1,         
    L_GEOMETRIC_INTERSECTION = 2,  
    L_LARGEST_AREA = 3,            
    L_SMALLEST_AREA = 4            
};
 
/*-------------------------------------------------------------------------*
 *                    Flags for replacing invalid boxes                    *
 *-------------------------------------------------------------------------*/
enum {
    L_USE_ALL_BOXES = 1,         
    L_USE_SAME_PARITY_BOXES = 2  
};
 
/*-------------------------------------------------------------------------*
 *                    Flags for box corners and center                     *
 *-------------------------------------------------------------------------*/
enum {
    L_UPPER_LEFT = 1,         
    L_UPPER_RIGHT = 2,        
    L_LOWER_LEFT = 3,         
    L_LOWER_RIGHT = 4,        
    L_BOX_CENTER = 5          
};
 
/*-------------------------------------------------------------------------*
 *                            Horizontal warp                              *
 *-------------------------------------------------------------------------*/
enum {
    L_WARP_TO_LEFT = 1,    
    L_WARP_TO_RIGHT = 2    
};
 
enum {
    L_LINEAR_WARP = 1,     
    L_QUADRATIC_WARP = 2   
};
 
/*-------------------------------------------------------------------------*
 *                      Pixel selection for resampling                     *
 *-------------------------------------------------------------------------*/
enum {
    L_INTERPOLATED = 1,    
    L_SAMPLED = 2          
};
 
/*-------------------------------------------------------------------------*
 *                             Thinning flags                              *
 *-------------------------------------------------------------------------*/
enum {
    L_THIN_FG = 1,             
    L_THIN_BG = 2              
};
 
/*-------------------------------------------------------------------------*
 *                            Runlength flags                              *
 *-------------------------------------------------------------------------*/
enum {
    L_HORIZONTAL_RUNS = 0,   
    L_VERTICAL_RUNS = 1      
};
 
/*-------------------------------------------------------------------------*
 *                          Edge filter flags                              *
 *-------------------------------------------------------------------------*/
enum {
    L_SOBEL_EDGE = 1,        
    L_TWO_SIDED_EDGE = 2     
};
 
/*-------------------------------------------------------------------------*
 *             Subpixel color component ordering in LCD display            *
 *-------------------------------------------------------------------------*/
enum {
    L_SUBPIXEL_ORDER_RGB = 1,   
    L_SUBPIXEL_ORDER_BGR = 2,   
    L_SUBPIXEL_ORDER_VRGB = 3,  
    L_SUBPIXEL_ORDER_VBGR = 4   
};
 
/*-------------------------------------------------------------------------*
 *                          HSV histogram flags                            *
 *-------------------------------------------------------------------------*/
enum {
    L_HS_HISTO = 1,            
    L_HV_HISTO = 2,            
    L_SV_HISTO = 3             
};
 
/*-------------------------------------------------------------------------*
 *                HSV Region flags (inclusion, exclusion)                  *
 *-------------------------------------------------------------------------*/
enum {
    L_INCLUDE_REGION = 1,      
    L_EXCLUDE_REGION = 2       
};
 
/*-------------------------------------------------------------------------*
 *                Location flags for adding text to a pix                  *
 *-------------------------------------------------------------------------*/
enum {
    L_ADD_ABOVE = 1,           
    L_ADD_BELOW = 2,           
    L_ADD_LEFT = 3,            
    L_ADD_RIGHT = 4,           
    L_ADD_AT_TOP = 5,          
    L_ADD_AT_BOT = 6,          
    L_ADD_AT_LEFT = 7,         
    L_ADD_AT_RIGHT = 8         
};
 
/*-------------------------------------------------------------------------*
 *                       Flags for plotting on a pix                       *
 *-------------------------------------------------------------------------*/
enum {
    L_PLOT_AT_TOP = 1,         
    L_PLOT_AT_MID_HORIZ = 2,   
    L_PLOT_AT_BOT = 3,         
    L_PLOT_AT_LEFT = 4,        
    L_PLOT_AT_MID_VERT = 5,    
    L_PLOT_AT_RIGHT = 6        
};
 
/*-------------------------------------------------------------------------*
 *                    Flags for making simple masks                        *
 *-------------------------------------------------------------------------*/
enum {
    L_USE_INNER = 1,           
    L_USE_OUTER = 2            
};
 
/*-------------------------------------------------------------------------*
 *                   Flags for selecting display program                   *
 *-------------------------------------------------------------------------*/
enum {
    L_DISPLAY_WITH_NONE = 0,  
    L_DISPLAY_WITH_XZGV = 1,  
    L_DISPLAY_WITH_XLI = 2,   
    L_DISPLAY_WITH_XV = 3,    
    L_DISPLAY_WITH_IV = 4,    
    L_DISPLAY_WITH_OPEN = 5   
};
 
/*-------------------------------------------------------------------------*
 *    Flag(s) used in the 'special' pix field for non-default operations   *
 *      - 0 is default for chroma sampling in jpeg                         *
 *      - 10-19 are used for zlib compression in png write                 *
 *      - 4 and 8 are used for specifying connectivity in labelling        *
 *-------------------------------------------------------------------------*/
enum {
    L_NO_CHROMA_SAMPLING_JPEG = 1   
};
 
/*-------------------------------------------------------------------------*
 *          Handling negative values in conversion to unsigned int         *
 *-------------------------------------------------------------------------*/
enum {
    L_CLIP_TO_ZERO = 1,      
    L_TAKE_ABSVAL = 2        
};
 
/*-------------------------------------------------------------------------*
 *                        Relative to zero flags                           *
 *-------------------------------------------------------------------------*/
enum {
    L_LESS_THAN_ZERO = 1,    
    L_EQUAL_TO_ZERO = 2,     
    L_GREATER_THAN_ZERO = 3  
};
 
/*-------------------------------------------------------------------------*
 *         Flags for adding or removing trailing slash from string         *
 *-------------------------------------------------------------------------*/
enum {
    L_ADD_TRAIL_SLASH = 1,     
    L_REMOVE_TRAIL_SLASH = 2   
};
 
/*-------------------------------------------------------------------------*
 *               Pix allocator and deallocator function types              *
 *-------------------------------------------------------------------------*/
typedef void *(*alloc_fn)(size_t);
 
typedef void (*dealloc_fn)(void *);
 
#endif  /* LEPTONICA_PIX_H */