![]() |
Leptonica
1.82.0
Image processing and image analysis suite
|
#include <math.h>
#include "allheaders.h"
Go to the source code of this file.
Macros | |
#define | M_PI 3.14159265358979323846 |
Functions | |
PTA * | ptaSubsample (PTA *ptas, l_int32 subfactor) |
l_ok | ptaJoin (PTA *ptad, PTA *ptas, l_int32 istart, l_int32 iend) |
l_ok | ptaaJoin (PTAA *ptaad, PTAA *ptaas, l_int32 istart, l_int32 iend) |
PTA * | ptaReverse (PTA *ptas, l_int32 type) |
PTA * | ptaTranspose (PTA *ptas) |
PTA * | ptaCyclicPerm (PTA *ptas, l_int32 xs, l_int32 ys) |
PTA * | ptaSelectRange (PTA *ptas, l_int32 first, l_int32 last) |
BOX * | ptaGetBoundingRegion (PTA *pta) |
l_ok | ptaGetRange (PTA *pta, l_float32 *pminx, l_float32 *pmaxx, l_float32 *pminy, l_float32 *pmaxy) |
PTA * | ptaGetInsideBox (PTA *ptas, BOX *box) |
PTA * | pixFindCornerPixels (PIX *pixs) |
l_int32 | ptaContainsPt (PTA *pta, l_int32 x, l_int32 y) |
l_int32 | ptaTestIntersection (PTA *pta1, PTA *pta2) |
PTA * | ptaTransform (PTA *ptas, l_int32 shiftx, l_int32 shifty, l_float32 scalex, l_float32 scaley) |
l_int32 | ptaPtInsidePolygon (PTA *pta, l_float32 x, l_float32 y, l_int32 *pinside) |
l_float32 | l_angleBetweenVectors (l_float32 x1, l_float32 y1, l_float32 x2, l_float32 y2) |
l_int32 | ptaPolygonIsConvex (PTA *pta, l_int32 *pisconvex) |
l_ok | ptaGetMinMax (PTA *pta, l_float32 *pxmin, l_float32 *pymin, l_float32 *pxmax, l_float32 *pymax) |
PTA * | ptaSelectByValue (PTA *ptas, l_float32 xth, l_float32 yth, l_int32 type, l_int32 relation) |
PTA * | ptaCropToMask (PTA *ptas, PIX *pixm) |
l_ok | ptaGetLinearLSF (PTA *pta, l_float32 *pa, l_float32 *pb, NUMA **pnafit) |
l_ok | ptaGetQuadraticLSF (PTA *pta, l_float32 *pa, l_float32 *pb, l_float32 *pc, NUMA **pnafit) |
l_ok | ptaGetCubicLSF (PTA *pta, l_float32 *pa, l_float32 *pb, l_float32 *pc, l_float32 *pd, NUMA **pnafit) |
l_ok | ptaGetQuarticLSF (PTA *pta, l_float32 *pa, l_float32 *pb, l_float32 *pc, l_float32 *pd, l_float32 *pe, NUMA **pnafit) |
l_ok | ptaNoisyLinearLSF (PTA *pta, l_float32 factor, PTA **pptad, l_float32 *pa, l_float32 *pb, l_float32 *pmederr, NUMA **pnafit) |
l_ok | ptaNoisyQuadraticLSF (PTA *pta, l_float32 factor, PTA **pptad, l_float32 *pa, l_float32 *pb, l_float32 *pc, l_float32 *pmederr, NUMA **pnafit) |
l_ok | applyLinearFit (l_float32 a, l_float32 b, l_float32 x, l_float32 *py) |
l_ok | applyQuadraticFit (l_float32 a, l_float32 b, l_float32 c, l_float32 x, l_float32 *py) |
l_ok | applyCubicFit (l_float32 a, l_float32 b, l_float32 c, l_float32 d, l_float32 x, l_float32 *py) |
l_ok | applyQuarticFit (l_float32 a, l_float32 b, l_float32 c, l_float32 d, l_float32 e, l_float32 x, l_float32 *py) |
l_ok | pixPlotAlongPta (PIX *pixs, PTA *pta, l_int32 outformat, const char *title) |
PTA * | ptaGetPixelsFromPix (PIX *pixs, BOX *box) |
PIX * | pixGenerateFromPta (PTA *pta, l_int32 w, l_int32 h) |
PTA * | ptaGetBoundaryPixels (PIX *pixs, l_int32 type) |
PTAA * | ptaaGetBoundaryPixels (PIX *pixs, l_int32 type, l_int32 connectivity, BOXA **pboxa, PIXA **ppixa) |
PTAA * | ptaaIndexLabeledPixels (PIX *pixs, l_int32 *pncc) |
PTA * | ptaGetNeighborPixLocs (PIX *pixs, l_int32 x, l_int32 y, l_int32 conn) |
PTA * | numaConvertToPta1 (NUMA *na) |
PTA * | numaConvertToPta2 (NUMA *nax, NUMA *nay) |
l_ok | ptaConvertToNuma (PTA *pta, NUMA **pnax, NUMA **pnay) |
PIX * | pixDisplayPta (PIX *pixd, PIX *pixs, PTA *pta) |
PIX * | pixDisplayPtaaPattern (PIX *pixd, PIX *pixs, PTAA *ptaa, PIX *pixp, l_int32 cx, l_int32 cy) |
PIX * | pixDisplayPtaPattern (PIX *pixd, PIX *pixs, PTA *pta, PIX *pixp, l_int32 cx, l_int32 cy, l_uint32 color) |
PTA * | ptaReplicatePattern (PTA *ptas, PIX *pixp, PTA *ptap, l_int32 cx, l_int32 cy, l_int32 w, l_int32 h) |
PIX * | pixDisplayPtaa (PIX *pixs, PTAA *ptaa) |
-------------------------------------- This file has these Pta utilities:
Simple rearrangements PTA *ptaSubsample() l_int32 ptaJoin() l_int32 ptaaJoin() PTA *ptaReverse() PTA *ptaTranspose() PTA *ptaCyclicPerm() PTA *ptaSelectRange()
Geometric BOX *ptaGetBoundingRegion() l_int32 *ptaGetRange() PTA *ptaGetInsideBox() PTA *pixFindCornerPixels() l_int32 ptaContainsPt() l_int32 ptaTestIntersection() PTA *ptaTransform() l_int32 ptaPtInsidePolygon() l_float32 l_angleBetweenVectors() l_int32 ptaPolygonIsConvex()
Min/max and filtering l_int32 ptaGetMinMax() PTA *ptaSelectByValue() PTA *ptaCropToMask()
Least Squares Fit l_int32 ptaGetLinearLSF() l_int32 ptaGetQuadraticLSF() l_int32 ptaGetCubicLSF() l_int32 ptaGetQuarticLSF() l_int32 ptaNoisyLinearLSF() l_int32 ptaNoisyQuadraticLSF() l_int32 applyLinearFit() l_int32 applyQuadraticFit() l_int32 applyCubicFit() l_int32 applyQuarticFit()
Interconversions with Pix l_int32 pixPlotAlongPta() PTA *ptaGetPixelsFromPix() PIX *pixGenerateFromPta() PTA *ptaGetBoundaryPixels() PTAA *ptaaGetBoundaryPixels() PTAA *ptaaIndexLabeledPixels() PTA *ptaGetNeighborPixLocs()
Interconversion with Numa PTA *numaConvertToPta1() PTA *numaConvertToPta2() l_int32 ptaConvertToNuma()
Display Pta and Ptaa PIX *pixDisplayPta() PIX *pixDisplayPtaaPattern() PIX *pixDisplayPtaPattern() PTA *ptaReplicatePattern() PIX *pixDisplayPtaa()
Definition in file ptafunc1.c.
l_ok applyCubicFit | ( | l_float32 | a, |
l_float32 | b, | ||
l_float32 | c, | ||
l_float32 | d, | ||
l_float32 | x, | ||
l_float32 * | py | ||
) |
[in] | a,b,c,d | cubic fit coefficients |
[in] | x | |
[out] | py | y = a * x^3 + b * x^2 + c * x + d |
Definition at line 1802 of file ptafunc1.c.
l_ok applyLinearFit | ( | l_float32 | a, |
l_float32 | b, | ||
l_float32 | x, | ||
l_float32 * | py | ||
) |
[in] | a,b | linear fit coefficients |
[in] | x | |
[out] | py | y = a * x + b |
Definition at line 1753 of file ptafunc1.c.
Referenced by dewarpLinearLSF().
l_ok applyQuadraticFit | ( | l_float32 | a, |
l_float32 | b, | ||
l_float32 | c, | ||
l_float32 | x, | ||
l_float32 * | py | ||
) |
[in] | a,b,c | quadratic fit coefficients |
[in] | x | |
[out] | py | y = a * x^2 + b * x + c |
Definition at line 1777 of file ptafunc1.c.
Referenced by dewarpFindVertDisparity(), and dewarpQuadraticLSF().
l_ok applyQuarticFit | ( | l_float32 | a, |
l_float32 | b, | ||
l_float32 | c, | ||
l_float32 | d, | ||
l_float32 | e, | ||
l_float32 | x, | ||
l_float32 * | py | ||
) |
[in] | a,b,c,d,e | quartic fit coefficients |
[in] | x | |
[out] | py | y = a * x^4 + b * x^3 + c * x^2 + d * x + e |
Definition at line 1828 of file ptafunc1.c.
l_float32 l_angleBetweenVectors | ( | l_float32 | x1, |
l_float32 | y1, | ||
l_float32 | x2, | ||
l_float32 | y2 | ||
) |
[in] | x1,y1 | end point of first vector |
[in] | x2,y2 | end point of second vector |
Notes: (1) This gives the angle between two vectors, going between vector1 (x1,y1) and vector2 (x2,y2). The angle is swept out from 1 --> 2. If this is clockwise, the angle is positive, but the result is folded into the interval [-pi, pi].
Definition at line 832 of file ptafunc1.c.
Referenced by ptaPtInsidePolygon().
[in] | na | numa with implicit y(x) |
Definition at line 2309 of file ptafunc1.c.
References numaGetCount(), numaGetFValue(), numaGetParameters(), ptaAddPt(), and ptaCreate().
[in] | nax | |
[in] | nay |
Definition at line 2339 of file ptafunc1.c.
References numaGetCount(), numaGetFValue(), ptaAddPt(), and ptaCreate().
[in] | pixd | can be same as pixs or NULL; 32 bpp if in-place |
[in] | pixs | 1, 2, 4, 8, 16 or 32 bpp |
[in] | pta | of path to be plotted |
Notes: (1) To write on an existing pixs, pixs must be 32 bpp and call with pixd == pixs: pixDisplayPta(pixs, pixs, pta); To write to a new pix, use pixd == NULL and call: pixd = pixDisplayPta(NULL, pixs, pta); (2) On error, returns pixd to avoid losing pixs if called as pixs = pixDisplayPta(pixs, pixs, pta);
Definition at line 2426 of file ptafunc1.c.
[in] | pixs | 1, 2, 4, 8, 16 or 32 bpp |
[in] | ptaa | array of paths to be plotted |
Definition at line 2672 of file ptafunc1.c.
References composeRGBPixel(), L_CLONE, numaDestroy(), numaGetIValue(), numaPseudorandomSequence(), pixConvertTo32(), pixDestroy(), pixGetDimensions(), pixSetPixel(), ptaaGetCount(), ptaaGetPta(), ptaDestroy(), ptaGetCount(), and ptaGetIPt().
PIX* pixDisplayPtaaPattern | ( | PIX * | pixd, |
PIX * | pixs, | ||
PTAA * | ptaa, | ||
PIX * | pixp, | ||
l_int32 | cx, | ||
l_int32 | cy | ||
) |
[in] | pixd | 32 bpp |
[in] | pixs | 1, 2, 4, 8, 16 or 32 bpp; 32 bpp if in place |
[in] | ptaa | giving locations at which the pattern is displayed |
[in] | pixp | 1 bpp pattern to be placed such that its reference point co-locates with each point in pta |
[in] | cx,cy | reference point in pattern |
Notes: (1) To write on an existing pixs, pixs must be 32 bpp and call with pixd == pixs: pixDisplayPtaPattern(pixs, pixs, pta, ...); To write to a new pix, use pixd == NULL and call: pixd = pixDisplayPtaPattern(NULL, pixs, pta, ...); (2) Puts a random color on each pattern associated with a pta. (3) On error, returns pixd to avoid losing pixs if called as pixs = pixDisplayPtaPattern(pixs, pixs, pta, ...); (4) A typical pattern to be used is a circle, generated with generatePtaFilledCircle()
Definition at line 2492 of file ptafunc1.c.
Referenced by dewarpFindVertDisparity().
PIX* pixDisplayPtaPattern | ( | PIX * | pixd, |
PIX * | pixs, | ||
PTA * | pta, | ||
PIX * | pixp, | ||
l_int32 | cx, | ||
l_int32 | cy, | ||
l_uint32 | color | ||
) |
[in] | pixd | can be same as pixs or NULL; 32 bpp if in-place |
[in] | pixs | 1, 2, 4, 8, 16 or 32 bpp |
[in] | pta | giving locations at which the pattern is displayed |
[in] | pixp | 1 bpp pattern to be placed such that its reference point co-locates with each point in pta |
[in] | cx,cy | reference point in pattern |
[in] | color | in 0xrrggbb00 format |
Notes: (1) To write on an existing pixs, pixs must be 32 bpp and call with pixd == pixs: pixDisplayPtaPattern(pixs, pixs, pta, ...); To write to a new pix, use pixd == NULL and call: pixd = pixDisplayPtaPattern(NULL, pixs, pta, ...); (2) On error, returns pixd to avoid losing pixs if called as pixs = pixDisplayPtaPattern(pixs, pixs, pta, ...); (3) A typical pattern to be used is a circle, generated with generatePtaFilledCircle()
Definition at line 2559 of file ptafunc1.c.
Referenced by pixRenderHorizEndPoints().
[in] | pixs | 1 bpp |
Notes: (1) Finds the 4 corner-most pixels, as defined by a search inward from each corner, using a 45 degree line.
Definition at line 578 of file ptafunc1.c.
[in] | pta | |
[in] | w,h | of pix |
Notes: (1) Points are rounded to nearest ints. (2) Any points outside (w,h) are silently discarded. (3) Output 1 bpp pix has values 1 for each point in the pta.
Definition at line 2023 of file ptafunc1.c.
References pixCreate(), pixSetPixel(), ptaGetCount(), and ptaGetIPt().
Referenced by dewarpFindVertDisparity(), pixRenderHorizEndPoints(), selDisplayInPix(), and wshedApply().
[in] | pixs | any depth |
[in] | pta | set of points on which to plot |
[in] | outformat | GPLOT_PNG, GPLOT_PS, GPLOT_EPS, GPLOT_LATEX |
[in] | title | [optional] for plot; can be null |
Notes: (1) This is a debugging function. (2) Removes existing colormaps and clips the pta to the input pixs. (3) If the image is RGB, three separate plots are generated.
Definition at line 1869 of file ptafunc1.c.
References lept_mkdir().
PTAA* ptaaGetBoundaryPixels | ( | PIX * | pixs, |
l_int32 | type, | ||
l_int32 | connectivity, | ||
BOXA ** | pboxa, | ||
PIXA ** | ppixa | ||
) |
[in] | pixs | 1 bpp |
[in] | type | L_BOUNDARY_FG, L_BOUNDARY_BG |
[in] | connectivity | 4 or 8 |
[out] | pboxa | [optional] bounding boxes of the c.c. |
[out] | ppixa | [optional] pixa of the c.c. |
Notes: (1) This generates a ptaa of either fg or bg boundary pixels, where each pta has the boundary pixels for a connected component. (2) We can't simply find all the boundary pixels and then select those within the bounding box of each component, because bounding boxes can overlap. It is necessary to extract and dilate or erode each component separately. Note also that special handling is required for bg pixels when the component touches the pix boundary.
Definition at line 2113 of file ptafunc1.c.
[in] | pixs | 32 bpp, of indices of c.c. |
[out] | pncc | [optional] number of connected components |
Notes: (1) The pixel values in pixs are the index of the connected component to which the pixel belongs; pixs is typically generated from a 1 bpp pix by pixConnCompTransform(). Background pixels in the generating 1 bpp pix are represented in pixs by 0. We do not check that the pixel values are correctly labelled. (2) Each pta in the returned ptaa gives the pixel locations corresponding to a connected component, with the label of each given by the index of the pta into the ptaa. (3) Initialize with the first pta in ptaa being empty and representing the background value (index 0) in the pix.
Definition at line 2196 of file ptafunc1.c.
[in] | ptaad | dest ptaa; add to this one |
[in] | ptaas | source ptaa; add from this one |
[in] | istart | starting index in ptaas |
[in] | iend | ending index in ptaas; use -1 to cat all |
Notes: (1) istart < 0 is taken to mean 'read from the start' (istart = 0) (2) iend < 0 means 'read to the end' (3) if ptas == NULL, this is a no-op
Definition at line 217 of file ptafunc1.c.
References L_CLONE, L_INSERT, ptaaAddPta(), ptaaGetCount(), and ptaaGetPta().
l_int32 ptaContainsPt | ( | PTA * | pta, |
l_int32 | x, | ||
l_int32 | y | ||
) |
[in] | pta | |
[in] | x,y | point |
Definition at line 670 of file ptafunc1.c.
References ptaGetCount(), and ptaGetIPt().
Referenced by getCutPathForHole().
[in] | pta | |
[out] | pnax | addr of nax |
[out] | pnay | addr of nay |
Definition at line 2375 of file ptafunc1.c.
References numaAddNumber(), numaCreate(), ptaGetCount(), and ptaGetPt().
[in] | ptas | input pta |
[in] | pixm | 1 bpp mask |
Definition at line 1039 of file ptafunc1.c.
[in] | ptas | |
[in] | xs,ys | start point; must be in ptas |
Notes: (1) Check to insure that (a) ptas is a closed path where the first and last points are identical, and (b) the resulting pta also starts and ends on the same point (which in this case is (xs, ys).
Definition at line 333 of file ptafunc1.c.
References ptaAddPt(), ptaCreate(), ptaGetCount(), and ptaGetIPt().
[in] | pixs | 1 bpp |
[in] | type | L_BOUNDARY_FG, L_BOUNDARY_BG |
Notes: (1) This generates a pta of either fg or bg boundary pixels. (2) See also pixGeneratePtaBoundary() for rendering of fg boundary pixels.
Definition at line 2064 of file ptafunc1.c.
[in] | pta |
Notes: (1) This is used when the pta represents a set of points in a two-dimensional image. It returns the box of minimum size containing the pts in the pta.
Definition at line 444 of file ptafunc1.c.
References boxCreate(), ptaGetCount(), and ptaGetIPt().
Referenced by selCreateFromPta().
l_ok ptaGetCubicLSF | ( | PTA * | pta, |
l_float32 * | pa, | ||
l_float32 * | pb, | ||
l_float32 * | pc, | ||
l_float32 * | pd, | ||
NUMA ** | pnafit | ||
) |
[in] | pta | |
[out] | pa | [optional] coeff a of LSF: y = ax^3 + bx^2 + cx + d |
[out] | pb | [optional] coeff b of LSF |
[out] | pc | [optional] coeff c of LSF |
[out] | pd | [optional] coeff d of LSF |
[out] | pnafit | [optional] numa of least square fit |
Notes: (1) This does a cubic least square fit to the set of points in pta. That is, it finds coefficients a, b, c and d that minimize:
sum (yi - a*xi*xi*xi -b*xi*xi -c*xi - d)^2 i
Differentiate this expression w/rt a, b, c and d, and solve the resulting four equations for these coefficients in terms of various sums over the input data (xi, yi). The four equations are in the form: f[0][0]a + f[0][1]b + f[0][2]c + f[0][3] = g[0] f[1][0]a + f[1][1]b + f[1][2]c + f[1][3] = g[1] f[2][0]a + f[2][1]b + f[2][2]c + f[2][3] = g[2] f[3][0]a + f[3][1]b + f[3][2]c + f[3][3] = g[3] (2) If &nafit is defined, this returns an array of fitted values, corresponding to the two implicit Numa arrays (nax and nay) in pta. Thus, just as you can plot the data in pta as nay vs. nax, you can plot the linear least square fit as nafit vs. nax. Get the nax array using ptaGetArrays(pta, &nax, NULL);
Definition at line 1320 of file ptafunc1.c.
References gaussjordan(), numaAddNumber(), numaCreate(), ptaGetCount(), and Pta::y.
[in] | ptas | input pts |
[in] | box |
Definition at line 538 of file ptafunc1.c.
References boxContainsPt(), ptaAddPt(), ptaCreate(), ptaGetCount(), and ptaGetPt().
[in] | pta | |
[out] | pa | [optional] slope a of least square fit: y = ax + b |
[out] | pb | [optional] intercept b of least square fit |
[out] | pnafit | [optional] numa of least square fit |
Notes: (1) Either or both &a and &b must be input. They determine the type of line that is fit. (2) If both &a and &b are defined, this returns a and b that minimize:
sum (yi - axi -b)^2 i
The method is simple: differentiate this expression w/rt a and b, and solve the resulting two equations for a and b in terms of various sums over the input data (xi, yi). (3) We also allow two special cases, where either a = 0 or b = 0: (a) If &a is given and &b = null, find the linear LSF that goes through the origin (b = 0). (b) If &b is given and &a = null, find the linear LSF with zero slope (a = 0). (4) If &nafit is defined, this returns an array of fitted values, corresponding to the two implicit Numa arrays (nax and nay) in pta. Thus, just as you can plot the data in pta as nay vs. nax, you can plot the linear least square fit as nafit vs. nax. Get the nax array using ptaGetArrays(pta, &nax, NULL);
Definition at line 1106 of file ptafunc1.c.
References numaAddNumber(), numaCreate(), ptaGetCount(), and Pta::y.
Referenced by dewarpLinearLSF(), and ptaNoisyLinearLSF().
l_ok ptaGetMinMax | ( | PTA * | pta, |
l_float32 * | pxmin, | ||
l_float32 * | pymin, | ||
l_float32 * | pxmax, | ||
l_float32 * | pymax | ||
) |
[in] | pta | |
[out] | pxmin | [optional] min of x |
[out] | pymin | [optional] min of y |
[out] | pxmax | [optional] max of x |
[out] | pymax | [optional] max of y |
Definition at line 918 of file ptafunc1.c.
References ptaGetCount(), and ptaGetPt().
[in] | pixs | any depth |
[in] | x,y | pixel from which we search for nearest neighbors |
[in] | conn | 4 or 8 connectivity |
Notes: (1) Generates a pta of all valid neighbor pixel locations, or NULL on error.
Definition at line 2253 of file ptafunc1.c.
References pixGetDimensions(), ptaAddPt(), and ptaCreate().
[in] | pixs | 1 bpp |
[in] | box | [optional] can be null |
Notes: (1) Generates a pta of fg pixels in the pix, within the box. If box == NULL, it uses the entire pix.
Definition at line 1970 of file ptafunc1.c.
Referenced by ptaReplicatePattern().
l_ok ptaGetQuadraticLSF | ( | PTA * | pta, |
l_float32 * | pa, | ||
l_float32 * | pb, | ||
l_float32 * | pc, | ||
NUMA ** | pnafit | ||
) |
[in] | pta | |
[out] | pa | [optional] coeff a of LSF: y = ax^2 + bx + c |
[out] | pb | [optional] coeff b of LSF: y = ax^2 + bx + c |
[out] | pc | [optional] coeff c of LSF: y = ax^2 + bx + c |
[out] | pnafit | [optional] numa of least square fit |
Notes: (1) This does a quadratic least square fit to the set of points in pta. That is, it finds coefficients a, b and c that minimize:
sum (yi - a*xi*xi -b*xi -c)^2 i
The method is simple: differentiate this expression w/rt a, b and c, and solve the resulting three equations for these coefficients in terms of various sums over the input data (xi, yi). The three equations are in the form: f[0][0]a + f[0][1]b + f[0][2]c = g[0] f[1][0]a + f[1][1]b + f[1][2]c = g[1] f[2][0]a + f[2][1]b + f[2][2]c = g[2] (2) If &nafit is defined, this returns an array of fitted values, corresponding to the two implicit Numa arrays (nax and nay) in pta. Thus, just as you can plot the data in pta as nay vs. nax, you can plot the linear least square fit as nafit vs. nax. Get the nax array using ptaGetArrays(pta, &nax, NULL);
Definition at line 1207 of file ptafunc1.c.
References gaussjordan(), numaAddNumber(), numaCreate(), ptaGetCount(), and Pta::y.
Referenced by dewarpFindVertDisparity(), dewarpQuadraticLSF(), and ptaNoisyQuadraticLSF().
l_ok ptaGetQuarticLSF | ( | PTA * | pta, |
l_float32 * | pa, | ||
l_float32 * | pb, | ||
l_float32 * | pc, | ||
l_float32 * | pd, | ||
l_float32 * | pe, | ||
NUMA ** | pnafit | ||
) |
[in] | pta | |
[out] | pa | [optional] coeff a of LSF: y = ax^4 + bx^3 + cx^2 + dx + e |
[out] | pb | [optional] coeff b of LSF |
[out] | pc | [optional] coeff c of LSF |
[out] | pd | [optional] coeff d of LSF |
[out] | pe | [optional] coeff e of LSF |
[out] | pnafit | [optional] numa of least square fit |
Notes: (1) This does a quartic least square fit to the set of points in pta. That is, it finds coefficients a, b, c, d and 3 that minimize:
sum (yi - a*xi*xi*xi*xi -b*xi*xi*xi -c*xi*xi - d*xi - e)^2 i
Differentiate this expression w/rt a, b, c, d and e, and solve the resulting five equations for these coefficients in terms of various sums over the input data (xi, yi). The five equations are in the form: f[0][0]a + f[0][1]b + f[0][2]c + f[0][3] + f[0][4] = g[0] f[1][0]a + f[1][1]b + f[1][2]c + f[1][3] + f[1][4] = g[1] f[2][0]a + f[2][1]b + f[2][2]c + f[2][3] + f[2][4] = g[2] f[3][0]a + f[3][1]b + f[3][2]c + f[3][3] + f[3][4] = g[3] f[4][0]a + f[4][1]b + f[4][2]c + f[4][3] + f[4][4] = g[4] (2) If &nafit is defined, this returns an array of fitted values, corresponding to the two implicit Numa arrays (nax and nay) in pta. Thus, just as you can plot the data in pta as nay vs. nax, you can plot the linear least square fit as nafit vs. nax. Get the nax array using ptaGetArrays(pta, &nax, NULL);
Definition at line 1450 of file ptafunc1.c.
References gaussjordan(), numaAddNumber(), numaCreate(), ptaGetCount(), and Pta::y.
l_ok ptaGetRange | ( | PTA * | pta, |
l_float32 * | pminx, | ||
l_float32 * | pmaxx, | ||
l_float32 * | pminy, | ||
l_float32 * | pmaxy | ||
) |
[in] | pta | |
[out] | pminx | [optional] min value of x |
[out] | pmaxx | [optional] max value of x |
[out] | pminy | [optional] min value of y |
[out] | pmaxy | [optional] max value of y |
Notes: (1) We can use pts to represent pairs of floating values, that are not necessarily tied to a two-dimension region. For example, the pts can represent a general function y(x).
Definition at line 488 of file ptafunc1.c.
References ptaGetCount(), and ptaGetPt().
Referenced by pixRenderPolygon().
[in] | ptad | dest pta; add to this one |
[in] | ptas | source pta; add from this one |
[in] | istart | starting index in ptas |
[in] | iend | ending index in ptas; use -1 to cat all |
Notes: (1) istart < 0 is taken to mean 'read from the start' (istart = 0) (2) iend < 0 means 'read to the end' (3) if ptas == NULL, this is a no-op
Definition at line 167 of file ptafunc1.c.
References ptaAddPt(), ptaGetCount(), and ptaGetIPt().
Referenced by boxaConvertToPta(), generatePtaBox(), generatePtaBoxa(), generatePtaHashBox(), generatePtaHashBoxa(), generatePtaPolyline(), generatePtaWideLine(), makePlotPtaFromNumaGen(), ptaUnionByAset(), ptaUnionByHmap(), selaAddCrossJunctions(), and selaAddTJunctions().
l_ok ptaNoisyLinearLSF | ( | PTA * | pta, |
l_float32 | factor, | ||
PTA ** | pptad, | ||
l_float32 * | pa, | ||
l_float32 * | pb, | ||
l_float32 * | pmederr, | ||
NUMA ** | pnafit | ||
) |
[in] | pta | |
[in] | factor | reject outliers with error greater than this number of medians; typically ~ 3 |
[out] | pptad | [optional] with outliers removed |
[out] | pa | [optional] slope a of least square fit: y = ax + b |
[out] | pb | [optional] intercept b of least square fit |
[out] | pmederr | [optional] median error |
[out] | pnafit | [optional] numa of least square fit to ptad |
Notes: (1) This does a linear least square fit to the set of points in pta. It then evaluates the errors and removes points whose error is >= factor * median_error. It then re-runs the linear LSF on the resulting points. (2) Either or both &a and &b must be input. They determine the type of line that is fit. (3) The median error can give an indication of how good the fit is likely to be.
Definition at line 1586 of file ptafunc1.c.
References numaAddNumber(), numaCreate(), numaDestroy(), numaGetFValue(), numaGetMedian(), ptaAddPt(), ptaCreate(), ptaDestroy(), ptaGetCount(), ptaGetLinearLSF(), and ptaGetPt().
l_ok ptaNoisyQuadraticLSF | ( | PTA * | pta, |
l_float32 | factor, | ||
PTA ** | pptad, | ||
l_float32 * | pa, | ||
l_float32 * | pb, | ||
l_float32 * | pc, | ||
l_float32 * | pmederr, | ||
NUMA ** | pnafit | ||
) |
[in] | pta | |
[in] | factor | reject outliers with error greater than this number of medians; typically ~ 3 |
[out] | pptad | [optional] with outliers removed |
[out] | pa | [optional] coeff a of LSF: y = ax^2 + bx + c |
[out] | pb | [optional] coeff b of LSF: y = ax^2 + bx + c |
[out] | pc | [optional] coeff c of LSF: y = ax^2 + bx + c |
[out] | pmederr | [optional] median error |
[out] | pnafit | [optional] numa of least square fit to ptad |
Notes: (1) This does a quadratic least square fit to the set of points in pta. It then evaluates the errors and removes points whose error is >= factor * median_error. It then re-runs a quadratic LSF on the resulting points.
Definition at line 1673 of file ptafunc1.c.
References numaAddNumber(), numaCreate(), numaDestroy(), numaGetFValue(), numaGetMedian(), ptaAddPt(), ptaCreate(), ptaDestroy(), ptaGetCount(), ptaGetPt(), and ptaGetQuadraticLSF().
l_int32 ptaPolygonIsConvex | ( | PTA * | pta, |
l_int32 * | pisconvex | ||
) |
[in] | pta | corners of polygon |
[out] | pisconvex | 1 if convex; 0 otherwise |
Notes: (1) A Pta of size n describes a polygon with n sides, where the n-th side goes from point[n - 1] to point[0]. (2) The pta must describe a CLOCKWISE traversal of the boundary of the polygon. (3) Algorithm: traversing the boundary in a cw direction, the polygon interior is always on the right. If the polygon is convex, for each set of 3 points, the third point is either on the ray extending from the first point and going through the second point, or to the right of it.
Definition at line 867 of file ptafunc1.c.
References ptaGetCount(), and ptaGetPt().
l_int32 ptaPtInsidePolygon | ( | PTA * | pta, |
l_float32 | x, | ||
l_float32 | y, | ||
l_int32 * | pinside | ||
) |
[in] | pta | vertices of a polygon |
[in] | x,y | point to be tested |
[out] | pinside | 1 if inside; 0 if outside or on boundary |
The abs value of the sum of the angles subtended from a point by the sides of a polygon, when taken in order traversing the polygon, is 0 if the point is outside the polygon and 2*pi if inside. The sign will be positive if traversed cw and negative if ccw.
Definition at line 780 of file ptafunc1.c.
References l_angleBetweenVectors(), ptaGetCount(), and ptaGetPt().
PTA* ptaReplicatePattern | ( | PTA * | ptas, |
PIX * | pixp, | ||
PTA * | ptap, | ||
l_int32 | cx, | ||
l_int32 | cy, | ||
l_int32 | w, | ||
l_int32 | h | ||
) |
[in] | ptas | "sparse" input pta |
[in] | pixp | [optional] 1 bpp pattern, to be replicated in output pta |
[in] | ptap | [optional] set of pts, to be replicated in output pta |
[in] | cx,cy | reference point in pattern |
[in] | w,h | clipping sizes for output pta |
Notes: (1) You can use either the image pixp or the set of pts ptap. (2) The pattern is placed with its reference point at each point in ptas, and all the fg pixels are colleced into ptad. For pixp, this is equivalent to blitting pixp at each point in ptas, and then converting the resulting pix to a pta.
Definition at line 2620 of file ptafunc1.c.
References ptaAddPt(), ptaClone(), ptaCreate(), ptaDestroy(), ptaGetCount(), ptaGetIPt(), and ptaGetPixelsFromPix().
Referenced by makePlotPtaFromNumaGen().
[in] | ptas | |
[in] | type | 0 for float values; 1 for integer values |
Definition at line 257 of file ptafunc1.c.
References ptaAddPt(), ptaCreate(), ptaGetCount(), ptaGetIPt(), and ptaGetPt().
[in] | ptas | |
[in] | xth,yth | threshold values |
[in] | type | L_SELECT_XVAL, L_SELECT_YVAL, L_SELECT_IF_EITHER, L_SELECT_IF_BOTH |
[in] | relation | L_SELECT_IF_LT, L_SELECT_IF_GT, L_SELECT_IF_LTE, L_SELECT_IF_GTE |
Definition at line 971 of file ptafunc1.c.
References L_SELECT_IF_BOTH, L_SELECT_IF_EITHER, L_SELECT_IF_GT, L_SELECT_IF_GTE, L_SELECT_IF_LT, L_SELECT_IF_LTE, L_SELECT_XVAL, L_SELECT_YVAL, ptaAddPt(), ptaCopy(), ptaCreate(), ptaGetCount(), and ptaGetPt().
[in] | ptas | |
[in] | first | use 0 to select from the beginning |
[in] | last | use -1 to select to the end |
Definition at line 389 of file ptafunc1.c.
References ptaAddPt(), ptaCopy(), ptaCreate(), ptaGetCount(), and ptaGetPt().
[in] | ptas | |
[in] | subfactor | subsample factor, >= 1 |
Definition at line 124 of file ptafunc1.c.
References ptaAddPt(), ptaCreate(), ptaGetCount(), and ptaGetPt().
[in] | pta1,pta2 |
Definition at line 699 of file ptafunc1.c.
References ptaGetCount(), and ptaGetIPt().
PTA* ptaTransform | ( | PTA * | ptas, |
l_int32 | shiftx, | ||
l_int32 | shifty, | ||
l_float32 | scalex, | ||
l_float32 | scaley | ||
) |
[in] | ptas | |
[in] | shiftx,shifty | |
[in] | scalex,scaley |
Notes: (1) Shift first, then scale.
Definition at line 740 of file ptafunc1.c.
References ptaAddPt(), ptaCreate(), ptaGetCount(), and ptaGetIPt().
Referenced by fpixAffinePta(), fpixProjectivePta(), and selDisplayInPix().
[in] | ptas |
Definition at line 293 of file ptafunc1.c.
References ptaAddPt(), ptaCreate(), ptaGetCount(), and ptaGetPt().
Referenced by pixRenderHorizEndPoints().