![]() |
Leptonica
1.82.0
Image processing and image analysis suite
|
#include <string.h>
#include "allheaders.h"
Go to the source code of this file.
Functions | |
FPIX * | pixConvertToFPix (PIX *pixs, l_int32 ncomps) |
DPIX * | pixConvertToDPix (PIX *pixs, l_int32 ncomps) |
PIX * | fpixConvertToPix (FPIX *fpixs, l_int32 outdepth, l_int32 negvals, l_int32 errorflag) |
PIX * | fpixDisplayMaxDynamicRange (FPIX *fpixs) |
DPIX * | fpixConvertToDPix (FPIX *fpix) |
PIX * | dpixConvertToPix (DPIX *dpixs, l_int32 outdepth, l_int32 negvals, l_int32 errorflag) |
FPIX * | dpixConvertToFPix (DPIX *dpix) |
l_ok | fpixGetMin (FPIX *fpix, l_float32 *pminval, l_int32 *pxminloc, l_int32 *pyminloc) |
l_ok | fpixGetMax (FPIX *fpix, l_float32 *pmaxval, l_int32 *pxmaxloc, l_int32 *pymaxloc) |
l_ok | dpixGetMin (DPIX *dpix, l_float64 *pminval, l_int32 *pxminloc, l_int32 *pyminloc) |
l_ok | dpixGetMax (DPIX *dpix, l_float64 *pmaxval, l_int32 *pxmaxloc, l_int32 *pymaxloc) |
FPIX * | fpixScaleByInteger (FPIX *fpixs, l_int32 factor) |
DPIX * | dpixScaleByInteger (DPIX *dpixs, l_int32 factor) |
FPIX * | fpixLinearCombination (FPIX *fpixd, FPIX *fpixs1, FPIX *fpixs2, l_float32 a, l_float32 b) |
l_ok | fpixAddMultConstant (FPIX *fpix, l_float32 addc, l_float32 multc) |
DPIX * | dpixLinearCombination (DPIX *dpixd, DPIX *dpixs1, DPIX *dpixs2, l_float32 a, l_float32 b) |
l_ok | dpixAddMultConstant (DPIX *dpix, l_float64 addc, l_float64 multc) |
l_ok | fpixSetAllArbitrary (FPIX *fpix, l_float32 inval) |
l_ok | dpixSetAllArbitrary (DPIX *dpix, l_float64 inval) |
FPIX * | fpixAddBorder (FPIX *fpixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot) |
FPIX * | fpixRemoveBorder (FPIX *fpixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot) |
FPIX * | fpixAddMirroredBorder (FPIX *fpixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot) |
FPIX * | fpixAddContinuedBorder (FPIX *fpixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot) |
FPIX * | fpixAddSlopeBorder (FPIX *fpixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot) |
l_ok | fpixRasterop (FPIX *fpixd, l_int32 dx, l_int32 dy, l_int32 dw, l_int32 dh, FPIX *fpixs, l_int32 sx, l_int32 sy) |
FPIX * | fpixRotateOrth (FPIX *fpixs, l_int32 quads) |
FPIX * | fpixRotate180 (FPIX *fpixd, FPIX *fpixs) |
FPIX * | fpixRotate90 (FPIX *fpixs, l_int32 direction) |
FPIX * | fpixFlipLR (FPIX *fpixd, FPIX *fpixs) |
FPIX * | fpixFlipTB (FPIX *fpixd, FPIX *fpixs) |
FPIX * | fpixAffinePta (FPIX *fpixs, PTA *ptad, PTA *ptas, l_int32 border, l_float32 inval) |
FPIX * | fpixAffine (FPIX *fpixs, l_float32 *vc, l_float32 inval) |
FPIX * | fpixProjectivePta (FPIX *fpixs, PTA *ptad, PTA *ptas, l_int32 border, l_float32 inval) |
FPIX * | fpixProjective (FPIX *fpixs, l_float32 *vc, l_float32 inval) |
l_ok | linearInterpolatePixelFloat (l_float32 *datas, l_int32 w, l_int32 h, l_float32 x, l_float32 y, l_float32 inval, l_float32 *pval) |
PIX * | fpixThresholdToPix (FPIX *fpix, l_float32 thresh) |
FPIX * | pixComponentFunction (PIX *pix, l_float32 rnum, l_float32 gnum, l_float32 bnum, l_float32 rdenom, l_float32 gdenom, l_float32 bdenom) |
------------------------------------------ This file has these FPix utilities: ~ interconversions with pix, fpix, dpix ~ min and max values ~ integer scaling ~ arithmetic operations ~ set all ~ border functions ~ simple rasterop (source --> dest) ~ geometric transforms ------------------------------------------
Interconversions between Pix, FPix and DPix FPIX *pixConvertToFPix() DPIX *pixConvertToDPix() PIX *fpixConvertToPix() PIX *fpixDisplayMaxDynamicRange() [useful for debugging] DPIX *fpixConvertToDPix() PIX *dpixConvertToPix() FPIX *dpixConvertToFPix()
Min/max value l_int32 fpixGetMin() l_int32 fpixGetMax() l_int32 dpixGetMin() l_int32 dpixGetMax()
Integer scaling FPIX *fpixScaleByInteger() DPIX *dpixScaleByInteger()
Arithmetic operations FPIX *fpixLinearCombination() l_int32 fpixAddMultConstant() DPIX *dpixLinearCombination() l_int32 dpixAddMultConstant()
Set all l_int32 fpixSetAllArbitrary() l_int32 dpixSetAllArbitrary()
FPix border functions FPIX *fpixAddBorder() FPIX *fpixRemoveBorder() FPIX *fpixAddMirroredBorder() FPIX *fpixAddContinuedBorder() FPIX *fpixAddSlopeBorder()
FPix simple rasterop l_int32 fpixRasterop()
FPix rotation by multiples of 90 degrees FPIX *fpixRotateOrth() FPIX *fpixRotate180() FPIX *fpixRotate90() FPIX *fpixFlipLR() FPIX *fpixFlipTB()
FPix affine and projective interpolated transforms FPIX *fpixAffinePta() FPIX *fpixAffine() FPIX *fpixProjectivePta() FPIX *fpixProjective() l_int32 linearInterpolatePixelFloat()
Thresholding to 1 bpp Pix PIX *fpixThresholdToPix()
Generate function from components FPIX *pixComponentFunction()
Definition in file fpix2.c.
l_ok dpixAddMultConstant | ( | DPIX * | dpix, |
l_float64 | addc, | ||
l_float64 | multc | ||
) |
[in] | dpix | |
[in] | addc | use 0.0 to skip the operation |
[in] | multc | use 1.0 to skip the operation |
Notes: (1) This is an in-place operation. (2) It can be used to multiply each pixel by a constant, and also to add a constant to each pixel. Multiplication is done first.
Definition at line 1278 of file fpix2.c.
References dpixGetData(), dpixGetDimensions(), and dpixGetWpl().
[in] | dpix |
Definition at line 647 of file fpix2.c.
References dpixGetData(), dpixGetDimensions(), dpixGetWpl(), fpixCreate(), fpixGetData(), and fpixGetWpl().
[in] | dpixs | |
[in] | outdepth | 0, 8, 16 or 32 bpp |
[in] | negvals | L_CLIP_TO_ZERO, L_TAKE_ABSVAL |
[in] | errorflag | 1 to output error stats; 0 otherwise |
Notes: (1) Use outdepth = 0 to programmatically determine the output depth. If no values are greater than 255, it will set outdepth = 8; otherwise to 16 or 32. (2) Because we are converting a float to an unsigned int with a specified dynamic range (8, 16 or 32 bits), errors can occur. If errorflag == TRUE, output the number of values out of range, both negative and positive. (3) If a pixel value is positive and out of range, clip to the maximum value represented at the outdepth of 8, 16 or 32 bits.
Definition at line 543 of file fpix2.c.
References dpixGetData(), dpixGetDimensions(), dpixGetWpl(), L_CLIP_TO_ZERO, L_TAKE_ABSVAL, pixCreate(), and pixGetData().
l_ok dpixGetMax | ( | DPIX * | dpix, |
l_float64 * | pmaxval, | ||
l_int32 * | pxmaxloc, | ||
l_int32 * | pymaxloc | ||
) |
[in] | dpix | |
[out] | pmaxval | [optional] max value |
[out] | pxmaxloc | [optional] x location of max |
[out] | pymaxloc | [optional] y location of max |
Definition at line 854 of file fpix2.c.
References dpixGetData(), dpixGetDimensions(), and dpixGetWpl().
l_ok dpixGetMin | ( | DPIX * | dpix, |
l_float64 * | pminval, | ||
l_int32 * | pxminloc, | ||
l_int32 * | pyminloc | ||
) |
[in] | dpix | |
[out] | pminval | [optional] min value |
[out] | pxminloc | [optional] x location of min |
[out] | pyminloc | [optional] y location of min |
Definition at line 801 of file fpix2.c.
References dpixGetData(), dpixGetDimensions(), and dpixGetWpl().
DPIX* dpixLinearCombination | ( | DPIX * | dpixd, |
DPIX * | dpixs1, | ||
DPIX * | dpixs2, | ||
l_float32 | a, | ||
l_float32 | b | ||
) |
[in] | dpixd | [optional] this can be null, or equal to dpixs1 |
[in] | dpixs1 | can be equal to dpixd |
[in] | dpixs2 | |
[in] | a,b | multiplication factors on dpixs1 and dpixs2, rsp. |
Notes: (1) Computes pixelwise linear combination: a * src1 + b * src2 (2) Alignment is to UL corner; src1 and src2 do not have to be the same size. (3) There are 2 cases. The result can go to a new dest, or in-place to dpixs1: * dpixd == null: (src1 + src2) --> new dpixd * dpixd == dpixs1: (src1 + src2) --> src1 (in-place)
Definition at line 1222 of file fpix2.c.
References dpixCopy(), dpixGetData(), dpixGetDimensions(), and dpixGetWpl().
[in] | dpixs | typically low resolution |
[in] | factor | integer scaling factor |
Notes: (1) The width wd of dpixd is related to ws of dpixs by: wd = factor * (ws - 1) + 1 (and ditto for the height) We avoid special-casing boundary pixels in the interpolation by constructing fpixd by inserting (factor - 1) interpolated pixels between each pixel in fpixs. Then wd = ws + (ws - 1) * (factor - 1) (same as above) This also has the advantage that if we subsample by factor, throwing out all the interpolated pixels, we regain the original low resolution dpix.
Definition at line 1013 of file fpix2.c.
References dpixCreate(), dpixGetData(), dpixGetDimensions(), and dpixGetWpl().
l_ok dpixSetAllArbitrary | ( | DPIX * | dpix, |
l_float64 | inval | ||
) |
[in] | dpix | |
[in] | inval | to set at each pixel |
Definition at line 1356 of file fpix2.c.
References dpixGetData(), and dpixGetDimensions().
[in] | fpixs | |
[in] | left,right,top,bot | pixels on each side to be added |
Notes: (1) Adds border of '0' 32-bit pixels
Definition at line 1395 of file fpix2.c.
References fpixCopy(), fpixCopyResolution(), fpixCreate(), fpixGetDimensions(), and fpixRasterop().
Referenced by fpixAddContinuedBorder(), fpixAddMirroredBorder(), and fpixAddSlopeBorder().
FPIX* fpixAddContinuedBorder | ( | FPIX * | fpixs, |
l_int32 | left, | ||
l_int32 | right, | ||
l_int32 | top, | ||
l_int32 | bot | ||
) |
[in] | fpixs | |
[in] | left,right,top,bot | pixels on each side to be added |
Notes: (1) This adds pixels on each side whose values are equal to the value on the closest boundary pixel.
Definition at line 1522 of file fpix2.c.
References fpixAddBorder(), fpixGetDimensions(), and fpixRasterop().
[in] | fpixs | |
[in] | left,right,top,bot | pixels on each side to be added |
Notes: (1) See pixAddMirroredBorder() for situations of usage.
Definition at line 1475 of file fpix2.c.
References fpixAddBorder(), fpixGetDimensions(), and fpixRasterop().
Referenced by fpixConvolve().
l_ok fpixAddMultConstant | ( | FPIX * | fpix, |
l_float32 | addc, | ||
l_float32 | multc | ||
) |
[in] | fpix | |
[in] | addc | use 0.0 to skip the operation |
[in] | multc | use 1.0 to skip the operation |
Notes: (1) This is an in-place operation. (2) It can be used to multiply each pixel by a constant, and also to add a constant to each pixel. Multiplication is done first.
Definition at line 1164 of file fpix2.c.
References fpixGetData(), fpixGetDimensions(), and fpixGetWpl().
Referenced by dewarpPopulateFullRes().
[in] | fpixs | |
[in] | left,right,top,bot | pixels on each side to be added |
Notes: (1) This adds pixels on each side whose values have a normal derivative equal to the normal derivative at the boundary of fpixs.
Definition at line 1567 of file fpix2.c.
References fpixAddBorder(), fpixGetDimensions(), fpixGetPixel(), and fpixSetPixel().
Referenced by dewarpPopulateFullRes(), fpixAffinePta(), and fpixProjectivePta().
[in] | fpixs | 8 bpp |
[in] | vc | vector of 8 coefficients for projective transformation |
[in] | inval | value brought in; typ. 0 |
Definition at line 2068 of file fpix2.c.
References affineXformPt(), fpixCreateTemplate(), fpixGetData(), fpixGetDimensions(), fpixGetWpl(), fpixSetAllArbitrary(), and linearInterpolatePixelFloat().
Referenced by fpixAffinePta().
[in] | fpixs | 8 bpp |
[in] | ptad | 4 pts of final coordinate space |
[in] | ptas | 4 pts of initial coordinate space |
[in] | border | size of extension with constant normal derivative |
[in] | inval | value brought in; typ. 0 |
Notes: (1) If border > 0, all four sides are extended by that distance, and removed after the transformation is finished. Pixels that would be brought in to the trimmed result from outside the extended region are assigned inval. The purpose of extending the image is to avoid such assignments. (2) On the other hand, you may want to give all pixels that are brought in from outside fpixs a specific value. In that case, set border == 0.
Definition at line 2011 of file fpix2.c.
References fpixAddSlopeBorder(), fpixAffine(), fpixClone(), fpixDestroy(), fpixRemoveBorder(), getAffineXformCoeffs(), ptaClone(), ptaDestroy(), and ptaTransform().
[in] | fpix |
Definition at line 485 of file fpix2.c.
References dpixCreate(), dpixGetData(), dpixGetWpl(), fpixGetData(), fpixGetDimensions(), and fpixGetWpl().
[in] | fpixs | |
[in] | outdepth | 0, 8, 16 or 32 bpp |
[in] | negvals | L_CLIP_TO_ZERO, L_TAKE_ABSVAL |
[in] | errorflag | 1 to output error stats; 0 otherwise |
Notes: (1) Use outdepth = 0 to programmatically determine the output depth. If no values are greater than 255, it will set outdepth = 8; otherwise to 16 or 32. (2) Because we are converting a float to an unsigned int with a specified dynamic range (8, 16 or 32 bits), errors can occur. If errorflag == TRUE, output the number of values out of range, both negative and positive. (3) If a pixel value is positive and out of range, clip to the maximum value represented at the outdepth of 8, 16 or 32 bits.
Definition at line 324 of file fpix2.c.
References fpixGetData(), fpixGetDimensions(), fpixGetWpl(), L_CLIP_TO_ZERO, L_TAKE_ABSVAL, pixCreate(), and pixGetData().
Referenced by fpixaDisplayQuadtree().
[in] | fpixs |
Definition at line 428 of file fpix2.c.
References fpixGetData(), fpixGetDimensions(), fpixGetWpl(), pixCreate(), and pixGetData().
[in] | fpixd | [optional] can be null, or equal to fpixs |
[in] | fpixs |
Notes: (1) This does a left-right flip of the image, which is equivalent to a rotation out of the plane about a vertical line through the image center. (2) There are 2 cases for input: (a) fpixd == null (creates a new fpixd) (b) fpixd == fpixs (in-place operation) (3) For clarity, use these two patterns: (a) fpixd = fpixFlipLR(NULL, fpixs); (b) fpixFlipLR(fpixs, fpixs);
Definition at line 1900 of file fpix2.c.
References fpixCopy(), fpixGetData(), fpixGetDimensions(), and fpixGetWpl().
Referenced by fpixRotate180().
[in] | fpixd | [optional] can be null, or equal to fpixs |
[in] | fpixs |
Notes: (1) This does a top-bottom flip of the image, which is equivalent to a rotation out of the plane about a horizontal line through the image center. (2) There are 2 cases for input: (a) fpixd == null (creates a new fpixd) (b) fpixd == fpixs (in-place operation) (3) For clarity, use these two patterns: (a) fpixd = fpixFlipTB(NULL, fpixs); (b) fpixFlipTB(fpixs, fpixs);
Definition at line 1952 of file fpix2.c.
References fpixCopy(), fpixGetData(), fpixGetDimensions(), and fpixGetWpl().
Referenced by fpixRotate180().
l_ok fpixGetMax | ( | FPIX * | fpix, |
l_float32 * | pmaxval, | ||
l_int32 * | pxmaxloc, | ||
l_int32 * | pymaxloc | ||
) |
[in] | fpix | |
[out] | pmaxval | [optional] max value |
[out] | pxmaxloc | [optional] x location of max |
[out] | pymaxloc | [optional] y location of max |
Definition at line 748 of file fpix2.c.
References fpixGetData(), fpixGetDimensions(), and fpixGetWpl().
Referenced by fpixAutoRenderContours().
l_ok fpixGetMin | ( | FPIX * | fpix, |
l_float32 * | pminval, | ||
l_int32 * | pxminloc, | ||
l_int32 * | pyminloc | ||
) |
[in] | fpix | |
[out] | pminval | [optional] min value |
[out] | pxminloc | [optional] x location of min |
[out] | pyminloc | [optional] y location of min |
Definition at line 695 of file fpix2.c.
References fpixGetData(), fpixGetDimensions(), and fpixGetWpl().
Referenced by fpixAutoRenderContours().
FPIX* fpixLinearCombination | ( | FPIX * | fpixd, |
FPIX * | fpixs1, | ||
FPIX * | fpixs2, | ||
l_float32 | a, | ||
l_float32 | b | ||
) |
[in] | fpixd | [optional] this can be null, or equal to fpixs1 |
[in] | fpixs1 | can be equal to fpixd |
[in] | fpixs2 | |
[in] | a,b | multiplication factors on fpixs1 and fpixs2, rsp. |
Notes: (1) Computes pixelwise linear combination: a * src1 + b * src2 (2) Alignment is to UL corner; src1 and src2 do not have to be the same size. (3) There are 2 cases. The result can go to a new dest, or in-place to fpixs1: * fpixd == null: (src1 + src2) --> new fpixd * fpixd == fpixs1: (src1 + src2) --> src1 (in-place)
Definition at line 1108 of file fpix2.c.
References fpixCopy(), fpixGetData(), fpixGetDimensions(), and fpixGetWpl().
[in] | fpixs | 8 bpp |
[in] | vc | vector of 8 coefficients for projective transform |
[in] | inval | value brought in; typ. 0 |
Definition at line 2187 of file fpix2.c.
References fpixCreateTemplate(), fpixGetData(), fpixGetDimensions(), fpixGetWpl(), fpixSetAllArbitrary(), linearInterpolatePixelFloat(), and projectiveXformPt().
Referenced by fpixProjectivePta().
[in] | fpixs | 8 bpp |
[in] | ptad | 4 pts of final coordinate space |
[in] | ptas | 4 pts of initial coordinate space |
[in] | border | size of extension with constant normal derivative |
[in] | inval | value brought in; typ. 0 |
Notes: (1) If border > 0, all four sides are extended by that distance, and removed after the transformation is finished. Pixels that would be brought in to the trimmed result from outside the extended region are assigned inval. The purpose of extending the image is to avoid such assignments. (2) On the other hand, you may want to give all pixels that are brought in from outside fpixs a specific value. In that case, set border == 0.
Definition at line 2130 of file fpix2.c.
References fpixAddSlopeBorder(), fpixClone(), fpixDestroy(), fpixProjective(), fpixRemoveBorder(), getProjectiveXformCoeffs(), ptaClone(), ptaDestroy(), and ptaTransform().
l_ok fpixRasterop | ( | FPIX * | fpixd, |
l_int32 | dx, | ||
l_int32 | dy, | ||
l_int32 | dw, | ||
l_int32 | dh, | ||
FPIX * | fpixs, | ||
l_int32 | sx, | ||
l_int32 | sy | ||
) |
[in] | fpixd | dest fpix |
[in] | dx | x val of UL corner of dest rectangle |
[in] | dy | y val of UL corner of dest rectangle |
[in] | dw | width of dest rectangle |
[in] | dh | height of dest rectangle |
[in] | fpixs | src fpix |
[in] | sx | x val of UL corner of src rectangle |
[in] | sy | y val of UL corner of src rectangle |
Notes: (1) This is similar in structure to pixRasterop(), except it only allows copying from the source into the destination. For that reason, no op code is necessary. Additionally, all pixels are 32 bit words (float values), which makes the copy very simple. (2) Clipping of both src and dest fpix are done automatically. (3) This allows in-place copying, without checking to see if the result is valid: use for in-place with caution!
Definition at line 1656 of file fpix2.c.
References fpixGetData(), fpixGetDimensions(), and fpixGetWpl().
Referenced by fpixAddBorder(), fpixAddContinuedBorder(), fpixAddMirroredBorder(), and fpixRemoveBorder().
[in] | fpixs | |
[in] | left,right,top,bot | pixels on each side to be removed |
Definition at line 1431 of file fpix2.c.
References fpixCopy(), fpixCopyResolution(), fpixCreate(), fpixGetDimensions(), and fpixRasterop().
Referenced by fpixAffinePta(), and fpixProjectivePta().
[in] | fpixd | [optional] can be null, or equal to fpixs |
[in] | fpixs |
Notes: (1) This does a 180 rotation of the image about the center, which is equivalent to a left-right flip about a vertical line through the image center, followed by a top-bottom flip about a horizontal line through the image center. (2) There are 2 cases for input: (a) fpixd == null (creates a new fpixd) (b) fpixd == fpixs (in-place operation) (3) For clarity, use these two patterns: (a) fpixd = fpixRotate180(NULL, fpixs); (b) fpixRotate180(fpixs, fpixs);
Definition at line 1799 of file fpix2.c.
References fpixCopy(), fpixFlipLR(), and fpixFlipTB().
Referenced by fpixRotateOrth().
[in] | fpixs | |
[in] | direction | 1 = clockwise; -1 = counter-clockwise |
Notes: (1) This does a 90 degree rotation of the image about the center, either cw or ccw, returning a new pix. (2) The direction must be either 1 (cw) or -1 (ccw).
Definition at line 1832 of file fpix2.c.
References fpixCopyResolution(), fpixCreate(), fpixGetData(), fpixGetDimensions(), and fpixGetWpl().
Referenced by fpixRotateOrth().
[in] | fpixs | |
[in] | quads | 0-3; number of 90 degree cw rotations |
Definition at line 1756 of file fpix2.c.
References fpixCopy(), fpixRotate180(), and fpixRotate90().
[in] | fpixs | typically low resolution |
[in] | factor | integer scaling factor |
Notes: (1) The width wd of fpixd is related to ws of fpixs by: wd = factor * (ws - 1) + 1 (and ditto for the height) We avoid special-casing boundary pixels in the interpolation by constructing fpixd by inserting (factor - 1) interpolated pixels between each pixel in fpixs. Then wd = ws + (ws - 1) * (factor - 1) (same as above) This also has the advantage that if we subsample by factor, throwing out all the interpolated pixels, we regain the original low resolution fpix.
Definition at line 921 of file fpix2.c.
References fpixCreate(), fpixGetData(), fpixGetDimensions(), and fpixGetWpl().
Referenced by dewarpPopulateFullRes().
l_ok fpixSetAllArbitrary | ( | FPIX * | fpix, |
l_float32 | inval | ||
) |
[in] | fpix | |
[in] | inval | to set at each pixel |
Definition at line 1325 of file fpix2.c.
References fpixGetData(), and fpixGetDimensions().
Referenced by fpixAffine(), and fpixProjective().
[in] | fpix | |
[in] | thresh |
Notes: (1) For all values of fpix that are <= thresh, sets the pixel in pixd to 1.
Definition at line 2309 of file fpix2.c.
References fpixGetData(), fpixGetDimensions(), fpixGetWpl(), pixCreate(), and pixGetData().
l_ok linearInterpolatePixelFloat | ( | l_float32 * | datas, |
l_int32 | w, | ||
l_int32 | h, | ||
l_float32 | x, | ||
l_float32 | y, | ||
l_float32 | inval, | ||
l_float32 * | pval | ||
) |
[in] | datas | ptr to beginning of float image data |
[in] | w,h | dimensions of image |
[in] | x,y | floating pt location for evaluation |
[in] | inval | float value brought in from the outside when the input x,y location is outside the image |
[out] | pval | interpolated float value |
Notes: (1) This is a standard linear interpolation function. It is equivalent to area weighting on each component, and avoids "jaggies" when rendering sharp edges.
Definition at line 2245 of file fpix2.c.
References lept_stderr().
Referenced by fpixAffine(), and fpixProjective().
FPIX* pixComponentFunction | ( | PIX * | pix, |
l_float32 | rnum, | ||
l_float32 | gnum, | ||
l_float32 | bnum, | ||
l_float32 | rdenom, | ||
l_float32 | gdenom, | ||
l_float32 | bdenom | ||
) |
[in] | pix | 32 bpp rgb |
[in] | rnum,gnum,bnum | coefficients for numerator |
[in] | rdenom,gdenom,bdenom | coefficients for denominator |
Notes: (1) This stores a function of the component values of each input pixel in fpixd. (2) The function is a ratio of linear combinations of component values. There are two special cases for denominator coefficients: (a) The denominator is 1.0: input 0 for all denominator coefficients (b) Only one component is used in the denominator: input 1.0 for that denominator component and 0.0 for the other two. (3) If the denominator is 0, multiply by an arbitrary number that is much larger than 1. Choose 256 "arbitrarily".
[in] | pixs | 1, 2, 4, 8, 16 or 32 bpp |
[in] | ncomps | number of components: 3 for RGB, 1 otherwise |
Notes: (1) If colormapped, remove to grayscale. (2) If 32 bpp and ncomps == 3, this is RGB; convert to luminance. In all other cases the src image is treated as having a single component of pixel values.
[in] | pixs | 1, 2, 4, 8, 16 or 32 bpp |
[in] | ncomps | number of components: 3 for RGB, 1 otherwise |
Notes: (1) If colormapped, remove to grayscale. (2) If 32 bpp and ncomps == 3, this is RGB; convert to luminance. In all other cases the src image is treated as having a single component of pixel values.