Leptonica  1.54
Файл src/pix5.c
#include <string.h>
#include <math.h>
#include "allheaders.h"

Макросы

#define DEBUG_EDGES   0

Функции

l_int32 pixaFindDimensions (PIXA *pixa, NUMA **pnaw, NUMA **pnah)
l_int32 pixFindAreaPerimRatio (PIX *pixs, l_int32 *tab, l_float32 *pfract)
NUMApixaFindPerimToAreaRatio (PIXA *pixa)
l_int32 pixFindPerimToAreaRatio (PIX *pixs, l_int32 *tab, l_float32 *pfract)
NUMApixaFindPerimSizeRatio (PIXA *pixa)
l_int32 pixFindPerimSizeRatio (PIX *pixs, l_int32 *tab, l_float32 *pratio)
NUMApixaFindAreaFraction (PIXA *pixa)
l_int32 pixFindAreaFraction (PIX *pixs, l_int32 *tab, l_float32 *pfract)
NUMApixaFindAreaFractionMasked (PIXA *pixa, PIX *pixm, l_int32 debug)
l_int32 pixFindAreaFractionMasked (PIX *pixs, BOX *box, PIX *pixm, l_int32 *tab, l_float32 *pfract)
NUMApixaFindWidthHeightRatio (PIXA *pixa)
NUMApixaFindWidthHeightProduct (PIXA *pixa)
l_int32 pixFindOverlapFraction (PIX *pixs1, PIX *pixs2, l_int32 x2, l_int32 y2, l_int32 *tab, l_float32 *pratio, l_int32 *pnoverlap)
BOXApixFindRectangleComps (PIX *pixs, l_int32 dist, l_int32 minw, l_int32 minh)
l_int32 pixConformsToRectangle (PIX *pixs, BOX *box, l_int32 dist, l_int32 *pconforms)
PIXApixClipRectangles (PIX *pixs, BOXA *boxa)
PIXpixClipRectangle (PIX *pixs, BOX *box, BOX **pboxc)
PIXpixClipMasked (PIX *pixs, PIX *pixm, l_int32 x, l_int32 y, l_uint32 outval)
l_int32 pixCropToMatch (PIX *pixs1, PIX *pixs2, PIX **ppixd1, PIX **ppixd2)
PIXpixCropToSize (PIX *pixs, l_int32 w, l_int32 h)
PIXpixResizeToMatch (PIX *pixs, PIX *pixt, l_int32 w, l_int32 h)
PIXpixMakeFrameMask (l_int32 w, l_int32 h, l_float32 hf1, l_float32 hf2, l_float32 vf1, l_float32 vf2)
l_int32 pixFractionFgInMask (PIX *pix1, PIX *pix2, l_float32 *pfract)
l_int32 pixClipToForeground (PIX *pixs, PIX **ppixd, BOX **pbox)
l_int32 pixTestClipToForeground (PIX *pixs, l_int32 *pcanclip)
l_int32 pixClipBoxToForeground (PIX *pixs, BOX *boxs, PIX **ppixd, BOX **pboxd)
l_int32 pixScanForForeground (PIX *pixs, BOX *box, l_int32 scanflag, l_int32 *ploc)
l_int32 pixClipBoxToEdges (PIX *pixs, BOX *boxs, l_int32 lowthresh, l_int32 highthresh, l_int32 maxwidth, l_int32 factor, PIX **ppixd, BOX **pboxd)
l_int32 pixScanForEdge (PIX *pixs, BOX *box, l_int32 lowthresh, l_int32 highthresh, l_int32 maxwidth, l_int32 factor, l_int32 scanflag, l_int32 *ploc)
NUMApixExtractOnLine (PIX *pixs, l_int32 x1, l_int32 y1, l_int32 x2, l_int32 y2, l_int32 factor)
l_float32 pixAverageOnLine (PIX *pixs, l_int32 x1, l_int32 y1, l_int32 x2, l_int32 y2, l_int32 factor)
NUMApixAverageIntensityProfile (PIX *pixs, l_float32 fract, l_int32 dir, l_int32 first, l_int32 last, l_int32 factor1, l_int32 factor2)
NUMApixReversalProfile (PIX *pixs, l_float32 fract, l_int32 dir, l_int32 first, l_int32 last, l_int32 minreversal, l_int32 factor1, l_int32 factor2)
l_int32 pixWindowedVarianceOnLine (PIX *pixs, l_int32 dir, l_int32 loc, l_int32 c1, l_int32 c2, l_int32 size, NUMA **pnad)
l_int32 pixMinMaxNearLine (PIX *pixs, l_int32 x1, l_int32 y1, l_int32 x2, l_int32 y2, l_int32 dist, l_int32 direction, NUMA **pnamin, NUMA **pnamax, l_float32 *pminave, l_float32 *pmaxave)
PIXpixRankRowTransform (PIX *pixs)
PIXpixRankColumnTransform (PIX *pixs)

Переменные

static const l_uint32 rmask32 []

Макросы

#define DEBUG_EDGES   0

Функции

pixaFindAreaFraction()

Input: pixa (of 1 bpp pix) Return: na (of area fractions for each pix), or null on error

Notes: (1) This is typically used for a pixa consisting of 1 bpp connected components.

NUMA* pixaFindAreaFractionMasked ( PIXA pixa,
PIX pixm,
l_int32  debug 
)

pixaFindAreaFractionMasked()

Input: pixa (of 1 bpp pix) pixm (mask image) debug (1 for output, 0 to suppress) Return: na (of ratio masked/total fractions for each pix), or null on error

Notes: (1) This is typically used for a pixa consisting of 1 bpp connected components, which has an associated boxa giving the location of the components relative to the mask origin. (2) The debug flag displays in green and red the masked and unmasked parts of the image from which pixa was derived.

l_int32 pixaFindDimensions ( PIXA pixa,
NUMA **  pnaw,
NUMA **  pnah 
)

pixaFindDimensions()

Input: pixa &naw (<optional return>=""> numa of pix widths) &nah (<optional return>=""> numa of pix heights) Return: 0 if OK, 1 on error

pixaFindPerimSizeRatio()

Input: pixa (of 1 bpp pix) Return: na (of fg perimeter/(2*(w+h)) ratio for each pix), or null on error

Notes: (1) This is typically used for a pixa consisting of 1 bpp connected components. (2) This has a minimum value for a circle of pi/4; a value for a rectangle component of approx. 1.0; and a value much larger than 1.0 for a component with a highly irregular boundary.

pixaFindPerimToAreaRatio()

Input: pixa (of 1 bpp pix) Return: na (of perimeter/arear ratio for each pix), or null on error

Notes: (1) This is typically used for a pixa consisting of 1 bpp connected components.

pixaFindWidthHeightProduct()

Input: pixa (of 1 bpp pix) Return: na (of width*height products for each pix), or null on error

Notes: (1) This is typically used for a pixa consisting of 1 bpp connected components.

pixaFindWidthHeightRatio()

Input: pixa (of 1 bpp pix) Return: na (of width/height ratios for each pix), or null on error

Notes: (1) This is typically used for a pixa consisting of 1 bpp connected components.

NUMA* pixAverageIntensityProfile ( PIX pixs,
l_float32  fract,
l_int32  dir,
l_int32  first,
l_int32  last,
l_int32  factor1,
l_int32  factor2 
)
l_float32 pixAverageOnLine ( PIX pixs,
l_int32  x1,
l_int32  y1,
l_int32  x2,
l_int32  y2,
l_int32  factor 
)

pixAverageOnLine()

Input: pixs (1 bpp or 8 bpp; no colormap) x1, y1 (starting pt for line) x2, y2 (end pt for line) factor (sampling; >= 1) Return: average of pixel values along line, or null on error.

Notes: (1) The line must be either horizontal or vertical, so either y1 == y2 (horizontal) or x1 == x2 (vertical). (2) If horizontal, x1 must be <= x2. If vertical, y1 must be <= y2. characterize the intensity smoothness along a line. (3) Input end points are clipped to the pix.

l_int32 pixClipBoxToEdges ( PIX pixs,
BOX boxs,
l_int32  lowthresh,
l_int32  highthresh,
l_int32  maxwidth,
l_int32  factor,
PIX **  ppixd,
BOX **  pboxd 
)

pixClipBoxToEdges()

Input: pixs (1 bpp) boxs (<optional> ; use full image if null) lowthresh (threshold to choose clipping location) highthresh (threshold required to find an edge) maxwidth (max allowed width between low and high thresh locs) factor (sampling factor along pixel counting direction) &pixd (<optional return>=""> clipped pix returned) &boxd (<optional return>=""> bounding box) Return: 0 if OK; 1 on error or if a fg edge is not found from all four sides.

Notes: (1) At least one of {&pixd, &boxd} must be specified. (2) If there are no fg pixels, the returned ptrs are null. (3) This function attempts to locate rectangular "image" regions of high-density fg pixels, that have well-defined edges on the four sides. (4) Edges are searched for on each side, iterating in order from left, right, top and bottom. As each new edge is found, the search box is resized to use that location. Once an edge is found, it is held. If no more edges are found in one iteration, the search fails. (5) See pixScanForEdge() for usage of the thresholds and . (6) The thresholds must be at least 1, and the low threshold cannot be larger than the high threshold. (7) If the low and high thresholds are both 1, this is equivalent to pixClipBoxToForeground().

l_int32 pixClipBoxToForeground ( PIX pixs,
BOX boxs,
PIX **  ppixd,
BOX **  pboxd 
)

pixClipBoxToForeground()

Input: pixs (1 bpp) boxs (<optional> ; use full image if null) &pixd (<optional return>=""> clipped pix returned) &boxd (<optional return>=""> bounding box) Return: 0 if OK; 1 on error or if there are no fg pixels

Notes: (1) At least one of {&pixd, &boxd} must be specified. (2) If there are no fg pixels, the returned ptrs are null. (3) Do not use &pixs for the 3rd arg or &boxs for the 4th arg; this will leak memory.

PIX* pixClipMasked ( PIX pixs,
PIX pixm,
l_int32  x,
l_int32  y,
l_uint32  outval 
)

pixClipMasked()

Input: pixs (1, 2, 4, 8, 16, 32 bpp; colormap ok) pixm (clipping mask, 1 bpp) x, y (origin of clipping mask relative to pixs) outval (val to use for pixels that are outside the mask) Return: pixd, (clipped pix) or null on error or if pixm doesn't intersect pixs

Notes: (1) If pixs has a colormap, it is preserved in pixd. (2) The depth of pixd is the same as that of pixs. (3) If the depth of pixs is 1, use = 0 for white background and 1 for black; otherwise, use the max value for white and 0 for black. If pixs has a colormap, the max value for is 0xffffffff; otherwise, it is 2^d - 1. (4) When using 1 bpp pixs, this is a simple clip and blend operation. For example, if both pix1 and pix2 are black text on white background, and you want to OR the fg on the two images, let pixm be the inverse of pix2. Then the operation takes all of pix1 that's in the bg of pix2, and for the remainder (which are the pixels corresponding to the fg of the pix2), paint them black (1) in pix1. The function call looks like pixClipMasked(pix2, pixInvert(pix1, pix1), x, y, 1);

PIX* pixClipRectangle ( PIX pixs,
BOX box,
BOX **  pboxc 
)

pixClipRectangle()

Input: pixs box (requested clipping region; const) &boxc (<optional return>=""> actual box of clipped region) Return: clipped pix, or null on error or if rectangle doesn't intersect pixs

Notes:

This should be simple, but there are choices to be made. The box is defined relative to the pix coordinates. However, if the box is not contained within the pix, we have two choices:

(1) clip the box to the pix (2) make a new pix equal to the full box dimensions, but let rasterop do the clipping and positioning of the src with respect to the dest

Choice (2) immediately brings up the problem of what pixel values to use that were not taken from the src. For example, on a grayscale image, do you want the pixels not taken from the src to be black or white or something else? To implement choice 2, one needs to specify the color of these extra pixels.

So we adopt (1), and clip the box first, if necessary, before making the dest pix and doing the rasterop. But there is another issue to consider. If you want to paste the clipped pix back into pixs, it must be properly aligned, and it is necessary to use the clipped box for alignment. Accordingly, this function has a third (optional) argument, which is the input box clipped to the src pix.

PIXA* pixClipRectangles ( PIX pixs,
BOXA boxa 
)

pixClipRectangles()

Input: pixs boxa (requested clipping regions) Return: pixa (consisting of requested regions), or null on error

Notes: (1) The returned pixa includes the actual regions clipped out from the input pixs.

l_int32 pixClipToForeground ( PIX pixs,
PIX **  ppixd,
BOX **  pbox 
)

pixClipToForeground()

Input: pixs (1 bpp) &pixd (<optional return>=""> clipped pix returned) &box (<optional return>=""> bounding box) Return: 0 if OK; 1 on error or if there are no fg pixels

Notes: (1) At least one of {&pixd, &box} must be specified. (2) If there are no fg pixels, the returned ptrs are null.

l_int32 pixConformsToRectangle ( PIX pixs,
BOX box,
l_int32  dist,
l_int32 pconforms 
)

pixConformsToRectangle()

Input: pixs (1 bpp) box (<optional> if null, use the entire pixs) dist (max distance allowed between bounding box and nearest foreground pixel within it) &conforms (<return> 0 (false) if not conforming; 1 (true) if conforming) Return: 0 if OK, 1 on error

Notes: (1) There are several ways to test if a connected component has an essentially rectangular boundary, such as: a. Fraction of fill into the bounding box b. Max-min distance of fg pixel from periphery of bounding box c. Max depth of bg intrusions into component within bounding box The weakness of (a) is that it is highly sensitive to holes within the c.c. The weakness of (b) is that it can have arbitrarily large intrusions into the c.c. Method (c) tests the integrity of the outer boundary of the c.c., with respect to the enclosing bounding box, so we use it. (2) This tests if the connected component within the box conforms to the box at all points on the periphery within . Inside, at a distance from the box boundary that is greater than , we don't care about the pixels in the c.c. (3) We can think of the conforming condition as follows: No pixel inside a distance from the boundary can connect to the boundary through a path through the bg. To implement this, we need to do a flood fill. We can go either from inside toward the boundary, or the other direction. It's easiest to fill from the boundary, and then verify that there are no filled pixels farther than from the boundary.

l_int32 pixCropToMatch ( PIX pixs1,
PIX pixs2,
PIX **  ppixd1,
PIX **  ppixd2 
)

pixCropToMatch()

Input: pixs1 (any depth, colormap OK) pixs2 (any depth, colormap OK) &pixd1 (<return> may be a clone) &pixd2 (<return> may be a clone) Return: 0 if OK, 1 on error

Notes: (1) This resizes pixs1 and/or pixs2 by cropping at the right and bottom, so that they're the same size. (2) If a pix doesn't need to be cropped, a clone is returned. (3) Note: the images are implicitly aligned to the UL corner.

PIX* pixCropToSize ( PIX pixs,
l_int32  w,
l_int32  h 
)

pixCropToSize()

Input: pixs (any depth, colormap OK) w, h (max dimensions of cropped image) Return: pixd (cropped if necessary) or null on error.

Notes: (1) If either w or h is smaller than the corresponding dimension of pixs, this returns a cropped image; otherwise it returns a clone of pixs.

NUMA* pixExtractOnLine ( PIX pixs,
l_int32  x1,
l_int32  y1,
l_int32  x2,
l_int32  y2,
l_int32  factor 
)

pixExtractOnLine()

Input: pixs (1 bpp or 8 bpp; no colormap) x1, y1 (one end point for line) x2, y2 (another end pt for line) factor (sampling; >= 1) Return: na (of pixel values along line), or null on error.

Notes: (1) Input end points are clipped to the pix. (2) If the line is either horizontal, or closer to horizontal than to vertical, the points will be extracted from left to right in the pix. Likewise, if the line is vertical, or closer to vertical than to horizontal, the points will be extracted from top to bottom. (3) Can be used with numaCountReverals(), for example, to characterize the intensity smoothness along a line.

l_int32 pixFindAreaFraction ( PIX pixs,
l_int32 tab,
l_float32 pfract 
)

pixFindAreaFraction()

Input: pixs (1 bpp) tab (<optional> pixel sum table, can be NULL) &fract (<return> fg area/size ratio) Return: 0 if OK, 1 on error

Notes: (1) This finds the ratio of the number of fg pixels to the size of the pix (w * h). It is typically used for a single connected component.

l_int32 pixFindAreaFractionMasked ( PIX pixs,
BOX box,
PIX pixm,
l_int32 tab,
l_float32 pfract 
)

pixFindAreaFractionMasked()

Input: pixs (1 bpp, typically a single component) box (<optional> for pixs relative to pixm) pixm (1 bpp mask, typically over the entire image from which the component pixs was extracted) tab (<optional> pixel sum table, can be NULL) &fract (<return> fg area/size ratio) Return: 0 if OK, 1 on error

Notes: (1) This finds the ratio of the number of masked fg pixels in pixs to the total number of fg pixels in pixs. It is typically used for a single connected component. If there are no fg pixels, this returns a ratio of 0.0. (2) The box gives the location of the pix relative to that of the UL corner of the mask. Therefore, the rasterop is performed with the pix translated to its location (x, y) in the mask before ANDing. If box == NULL, the UL corners of pixs and pixm are aligned.

l_int32 pixFindAreaPerimRatio ( PIX pixs,
l_int32 tab,
l_float32 pfract 
)

pixFindAreaPerimRatio()

Input: pixs (1 bpp) tab (<optional> pixel sum table, can be NULL) &fract (<return> area/perimeter ratio) Return: 0 if OK, 1 on error

Notes: (1) The area is the number of fg pixels that are not on the boundary (i.e., are not 8-connected to a bg pixel), and the perimeter is the number of fg boundary pixels. Returns 0.0 if there are no fg pixels. (2) This function is retained because clients are using it.

l_int32 pixFindOverlapFraction ( PIX pixs1,
PIX pixs2,
l_int32  x2,
l_int32  y2,
l_int32 tab,
l_float32 pratio,
l_int32 pnoverlap 
)

pixFindOverlapFraction()

Input: pixs1, pixs2 (1 bpp) x2, y2 (location in pixs1 of UL corner of pixs2) tab (<optional> pixel sum table, can be null) &ratio (<return> ratio fg intersection to fg union) &noverlap (<optional return>=""> number of overlapping pixels) Return: 0 if OK, 1 on error

Notes: (1) The UL corner of pixs2 is placed at (x2, y2) in pixs1. (2) This measure is similar to the correlation.

l_int32 pixFindPerimSizeRatio ( PIX pixs,
l_int32 tab,
l_float32 pratio 
)

pixFindPerimSizeRatio()

Input: pixs (1 bpp) tab (<optional> pixel sum table, can be NULL) &ratio (<return> perimeter/size ratio) Return: 0 if OK, 1 on error

Notes: (1) We take the 'size' as twice the sum of the width and height of pixs, and the perimeter is the number of fg boundary pixels. We use the fg pixels of the boundary because the pix may be clipped to the boundary, so an erosion is required to count all boundary pixels. (2) This has a large value for dendritic, fractal-like components with highly irregular boundaries. (3) This is typically used for a single connected component. It has a value of about 1.0 for rectangular components with relatively smooth boundaries.

l_int32 pixFindPerimToAreaRatio ( PIX pixs,
l_int32 tab,
l_float32 pfract 
)

pixFindPerimToAreaRatio()

Input: pixs (1 bpp) tab (<optional> pixel sum table, can be NULL) &fract (<return> perimeter/area ratio) Return: 0 if OK, 1 on error

Notes: (1) The perimeter is the number of fg boundary pixels, and the area is the number of fg pixels. This returns 0.0 if there are no fg pixels. (2) Unlike pixFindAreaPerimRatio(), this uses the full set of fg pixels for the area, and the ratio is taken in the opposite order. (3) This is typically used for a single connected component. This always has a value <= 1.0, and if the average distance of a fg pixel from the nearest bg pixel is d, this has a value ~1/d.

BOXA* pixFindRectangleComps ( PIX pixs,
l_int32  dist,
l_int32  minw,
l_int32  minh 
)

pixFindRectangleComps()

Input: pixs (1 bpp) dist (max distance allowed between bounding box and nearest foreground pixel within it) minw, minh (minimum size in each direction as a requirement for a conforming rectangle) Return: boxa (of components that conform), or null on error

Notes: (1) This applies the function pixConformsToRectangle() to each 8-c.c. in pixs, and returns a boxa containing the regions of all components that are conforming. (2) Conforming components must satisfy both the size constraint given by and the slop in conforming to a rectangle determined by .

l_int32 pixFractionFgInMask ( PIX pix1,
PIX pix2,
l_float32 pfract 
)

pixFractionFgInMask()

Input: pix1 (1 bpp) pix2 (1 bpp) &fract (<return> fraction of fg pixels in 1 that are aligned with the fg of 2) Return: 0 if OK, 1 on error.

Notes: (1) This gives the fraction of fg pixels in pix1 that are in the intersection (i.e., under the fg) of pix2: |1 & 2|/|1|, where |...| means the number of fg pixels. Note that this is different from the situation where pix1 and pix2 are reversed. (2) Both pix1 and pix2 are registered to the UL corners. A warning is issued if pix1 and pix2 have different sizes. (3) This can also be used to find the fraction of fg pixels in pix1 that are NOT under the fg of pix2: 1.0 - |1 & 2|/|1| (4) If pix1 or pix2 are empty, this returns = 0.0. (5) For example, pix2 could be a frame around the outside of the image, made from pixMakeFrameMask().

PIX* pixMakeFrameMask ( l_int32  w,
l_int32  h,
l_float32  hf1,
l_float32  hf2,
l_float32  vf1,
l_float32  vf2 
)

pixMakeFrameMask()

Input: w, h (dimensions of output 1 bpp pix) hf1 (horizontal fraction of half-width at outer frame bdry) hf2 (horizontal fraction of half-width at inner frame bdry) vf1 (vertical fraction of half-width at outer frame bdry) vf2 (vertical fraction of half-width at inner frame bdry) Return: pixd (1 bpp), or null on error.

Notes: (1) This makes an arbitrary 1-component mask with a centered frame. Input fractions are in [0.0 ... 1.0]; hf1 <= hf2 and vf1 <= vf2. Horizontal and vertical frame widths are independently specified. (2) Special case: to get a full fg mask, set all input values to 0.0. An empty fg mask has hf1 = vf1 = 1.0. A fg rectangle with no hole has hf2 == 1.0 or hv2 == 1.0. (3) The vertical thickness of the horizontal mask parts is 0.5 * (vf2 - vf1) * h. The horizontal thickness of the vertical mask parts is 0.5 * (hf2 - hf1) * w.

l_int32 pixMinMaxNearLine ( PIX pixs,
l_int32  x1,
l_int32  y1,
l_int32  x2,
l_int32  y2,
l_int32  dist,
l_int32  direction,
NUMA **  pnamin,
NUMA **  pnamax,
l_float32 pminave,
l_float32 pmaxave 
)

pixMinMaxNearLine()

Input: pixs (8 bpp; no colormap) x1, y1 (starting pt for line) x2, y2 (end pt for line) dist (distance to search from line in each direction) direction (L_SCAN_NEGATIVE, L_SCAN_POSITIVE, L_SCAN_BOTH) &namin (<optional return>=""> minimum values) &namax (<optional return>=""> maximum values) &minave (<optional return>=""> average of minimum values) &maxave (<optional return>=""> average of maximum values) Return: 0 if OK; 1 on error or if there are no sampled points within the image.

Notes: (1) If the line is more horizontal than vertical, the values are computed for [x1, x2], and the pixels are taken below and/or above the local y-value. Otherwise, the values are computed for [y1, y2] and the pixels are taken to the left and/or right of the local x value. (2) specifies which side (or both sides) of the line are scanned for min and max values. (3) There are two ways to tell if the returned values of min and max averages are valid: the returned values cannot be negative and the function must return 0. (4) All accessed pixels are clipped to the pix.

pixRankColumnTransform()

Input: pixs (8 bpp; no colormap) Return: pixd (with pixels sorted in each column, from min to max value)

Notes: (1) The time is O(n) in the number of pixels and runs about 50 Mpixels/sec on a 3 GHz machine.

PIX* pixRankRowTransform ( PIX pixs)

pixRankRowTransform()

Input: pixs (8 bpp; no colormap) Return: pixd (with pixels sorted in each row, from min to max value)

Notes: (1) The time is O(n) in the number of pixels and runs about 100 Mpixels/sec on a 3 GHz machine.

PIX* pixResizeToMatch ( PIX pixs,
PIX pixt,
l_int32  w,
l_int32  h 
)

pixResizeToMatch()

Input: pixs (1, 2, 4, 8, 16, 32 bpp; colormap ok) pixt (can be null; we use only the size) w, h (ignored if pixt is defined) Return: pixd (resized to match) or null on error

Notes: (1) This resizes pixs to make pixd, without scaling, by either cropping or extending separately in both width and height. Extension is done by replicating the last row or column. This is useful in a situation where, due to scaling operations, two images that are expected to be the same size can differ slightly in each dimension. (2) You can use either an existing pixt or specify both and . If pixt is defined, the values in and are ignored. (3) If pixt is larger than pixs (or if w and/or d is larger than the dimension of pixs, replicate the outer row and column of pixels in pixs into pixd.

NUMA* pixReversalProfile ( PIX pixs,
l_float32  fract,
l_int32  dir,
l_int32  first,
l_int32  last,
l_int32  minreversal,
l_int32  factor1,
l_int32  factor2 
)
l_int32 pixScanForEdge ( PIX pixs,
BOX box,
l_int32  lowthresh,
l_int32  highthresh,
l_int32  maxwidth,
l_int32  factor,
l_int32  scanflag,
l_int32 ploc 
)

pixScanForEdge()

Input: pixs (1 bpp) box (<optional> within which the search is conducted) lowthresh (threshold to choose clipping location) highthresh (threshold required to find an edge) maxwidth (max allowed width between low and high thresh locs) factor (sampling factor along pixel counting direction) scanflag (direction of scan; e.g., L_FROM_LEFT) &loc (<return> location in scan direction of first black pixel) Return: 0 if OK; 1 on error or if the edge is not found

Notes: (1) If there are no fg pixels, the position is set to 0. Caller must check the return value! (2) Use == NULL to scan from edge of pixs (3) As the scan progresses, the location where the sum of pixels equals or excees is noted (loc). The scan is stopped when the sum of pixels equals or exceeds . If the scan distance between loc and that point does not exceed , an edge is found and its position is taken to be loc. implicitly sets a minimum on the required gradient of the edge. (4) The thresholds must be at least 1, and the low threshold cannot be larger than the high threshold.

l_int32 pixScanForForeground ( PIX pixs,
BOX box,
l_int32  scanflag,
l_int32 ploc 
)

pixScanForForeground()

Input: pixs (1 bpp) box (<optional> within which the search is conducted) scanflag (direction of scan; e.g., L_FROM_LEFT) &loc (location in scan direction of first black pixel) Return: 0 if OK; 1 on error or if no fg pixels are found

Notes: (1) If there are no fg pixels, the position is set to 0. Caller must check the return value! (2) Use == NULL to scan from edge of pixs

l_int32 pixTestClipToForeground ( PIX pixs,
l_int32 pcanclip 
)

pixTestClipToForeground()

Input: pixs (1 bpp) &canclip (<return> 1 if fg does not extend to all four edges) Return: 0 if OK; 1 on error

Notes: (1) This is a lightweight test to determine if a 1 bpp image can be further cropped without loss of fg pixels. If it cannot, canclip is set to 0. (2) It does not test for the existence of any fg pixels. If there are no fg pixels, it will return = 1. Check the output of the subsequent call to pixClipToForeground().

l_int32 pixWindowedVarianceOnLine ( PIX pixs,
l_int32  dir,
l_int32  loc,
l_int32  c1,
l_int32  c2,
l_int32  size,
NUMA **  pnad 
)

pixWindowedVarianceOnLine()

Input: pixs (8 bpp; no colormap) dir (L_HORIZONTAL_LINE or L_VERTICAL_LINE) loc (location of the constant coordinate for the line) c1, c2 (end point coordinates for the line) size (window size; must be > 1) &nad (<return> windowed square root of variance) Return: 0 if OK; 1 on error

Notes: (1) The returned variance array traverses the line starting from the smallest coordinate, min(c1,c2). (2) Line end points are clipped to pixs. (3) The reference point for the variance calculation is the center of the window. Therefore, the numa start parameter from pixExtractOnLine() is incremented by /2, to align the variance values with the pixel coordinate. (4) The square root of the variance is the RMS deviation from the mean.


Переменные

const l_uint32 rmask32[] [static]
Инициализатор
 {0x0,
    0x00000001, 0x00000003, 0x00000007, 0x0000000f,
    0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
    0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
    0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
    0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff,
    0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff,
    0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff,
    0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff}