 |
Leptonica 1.85.0
Image processing and image analysis suite
|
|
Leptonica 1.85.0
Image processing and image analysis suite
|
#include <string.h>#include <math.h>#include "allheaders.h"Go to the source code of this file.
Functions | |
| l_ok | pixAddConstantGray (PIX *pixs, l_int32 val) |
| l_ok | pixMultConstantGray (PIX *pixs, l_float32 val) |
| PIX * | pixAddGray (PIX *pixd, PIX *pixs1, PIX *pixs2) |
| PIX * | pixSubtractGray (PIX *pixd, PIX *pixs1, PIX *pixs2) |
| PIX * | pixMultiplyGray (PIX *pixs, PIX *pixg, l_float32 norm) |
| PIX * | pixThresholdToValue (PIX *pixd, PIX *pixs, l_int32 threshval, l_int32 setval) |
| PIX * | pixInitAccumulate (l_int32 w, l_int32 h, l_uint32 offset) |
| PIX * | pixFinalAccumulate (PIX *pixs, l_uint32 offset, l_int32 depth) |
| PIX * | pixFinalAccumulateThreshold (PIX *pixs, l_uint32 offset, l_uint32 threshold) |
| l_ok | pixAccumulate (PIX *pixd, PIX *pixs, l_int32 op) |
| l_ok | pixMultConstAccumulate (PIX *pixs, l_float32 factor, l_uint32 offset) |
| PIX * | pixAbsDifference (PIX *pixs1, PIX *pixs2) |
| PIX * | pixAddRGB (PIX *pixs1, PIX *pixs2) |
| PIX * | pixMinOrMax (PIX *pixd, PIX *pixs1, PIX *pixs2, l_int32 type) |
| PIX * | pixMaxDynamicRange (PIX *pixs, l_int32 type) |
| PIX * | pixMaxDynamicRangeRGB (PIX *pixs, l_int32 type) |
| l_uint32 | linearScaleRGBVal (l_uint32 sval, l_float32 factor) |
| l_uint32 | logScaleRGBVal (l_uint32 sval, l_float32 *tab, l_float32 factor) |
| l_float32 * | makeLogBase2Tab (void) |
| l_float32 | getLogBase2 (l_int32 val, l_float32 *logtab) |
One-image grayscale arithmetic operations (8, 16, 32 bpp)
l_int32 pixAddConstantGray()
l_int32 pixMultConstantGray()
Two-image grayscale arithmetic operations (8, 16, 32 bpp)
PIX *pixAddGray()
PIX *pixSubtractGray()
PIX *pixMultiplyGray()
Grayscale threshold operation (8, 16, 32 bpp)
PIX *pixThresholdToValue()
Image accumulator arithmetic operations
PIX *pixInitAccumulate()
PIX *pixFinalAccumulate()
PIX *pixFinalAccumulateThreshold()
l_int32 pixAccumulate()
l_int32 pixMultConstAccumulate()
Absolute value of difference
PIX *pixAbsDifference()
Sum of color images
PIX *pixAddRGB()
Two-image min and max operations (8 and 16 bpp)
PIX *pixMinOrMax()
Scale pix for maximum dynamic range
PIX *pixMaxDynamicRange()
PIX *pixMaxDynamicRangeRGB()
RGB pixel value scaling
l_uint32 linearScaleRGBVal()
l_uint32 logScaleRGBVal()
Log base2 lookup
l_float32 *makeLogBase2Tab()
l_float32 getLogBase2()
The image accumulator operations are used when you expect
overflow from 8 bits on intermediate results. For example,
you might want a tophat contrast operator which is
3*I - opening(I,S) - closing(I,S)
To use these operations, first use the init to generate
a 16 bpp image, use the accumulate to add or subtract 8 bpp
images from that, or the multiply constant to multiply
by a small constant (much less than 256 -- we don't want
overflow from the 16 bit images!), and when you're finished
use final to bring the result back to 8 bpp, clipped
if necessary. There is also a divide function, which
can be used to divide one image by another, scaling the
result for maximum dynamic range, and giving back the
8 bpp result.
A simpler interface to the arithmetic operations is
provided in pixacc.c.
Definition in file pixarith.c.
| l_float32 getLogBase2 | ( | l_int32 | val, |
| l_float32 * | logtab ) |
Definition at line 1583 of file pixarith.c.
| l_uint32 linearScaleRGBVal | ( | l_uint32 | sval, |
| l_float32 | factor ) |
| [in] | sval | 32-bit rgb pixel value |
| [in] | factor | multiplication factor on each component |
Notes:
(1) factor must be chosen to be not greater than (255 / maxcomp),
where maxcomp is the maximum value of the pixel components.
Otherwise, the product will overflow a uint8. In use, factor
is the same for all pixels in a pix.
(2) No scaling is performed on the transparency ("A") component.
Definition at line 1500 of file pixarith.c.
Referenced by pixMaxDynamicRangeRGB().
| l_uint32 logScaleRGBVal | ( | l_uint32 | sval, |
| l_float32 * | tab, | ||
| l_float32 | factor ) |
| [in] | sval | 32-bit rgb pixel value |
| [in] | tab | 256 entry log-base-2 table |
| [in] | factor | multiplication factor on each component |
Notes:
(1) tab is made with makeLogBase2Tab().
(2) factor must be chosen to be not greater than
255.0 / log[base2](maxcomp), where maxcomp is the maximum
value of the pixel components. Otherwise, the product
will overflow a uint8. In use, factor is the same for
all pixels in a pix.
(3) No scaling is performed on the transparency ("A") component.
Definition at line 1533 of file pixarith.c.
Referenced by pixMaxDynamicRangeRGB().
| l_float32 * makeLogBase2Tab | ( | void | ) |
Definition at line 1558 of file pixarith.c.
| [in] | pixs1,pixs2 | both either 8 or 16 bpp gray, or 32 bpp RGB |
Notes:
(1) The depth of pixs1 and pixs2 must be equal.
(2) Clips computation to the min size, aligning the UL corners
(3) For 8 and 16 bpp, assumes one gray component.
(4) For 32 bpp, assumes 3 color components, and ignores the
LSB of each word (the alpha channel)
(5) Computes the absolute value of the difference between
each component value.
Definition at line 948 of file pixarith.c.
References GET_DATA_BYTE, GET_DATA_TWO_BYTES, SET_DATA_BYTE, and SET_DATA_TWO_BYTES.
| [in] | pixd | 32 bpp |
| [in] | pixs | 1, 8, 16 or 32 bpp |
| [in] | op | L_ARITH_ADD or L_ARITH_SUBTRACT |
Notes:
(1) This adds or subtracts each pixs value from pixd.
(2) This clips to the minimum of pixs and pixd, so they
do not need to be the same size.
(3) The alignment is to the origin [UL corner] of pixs & pixd.
Definition at line 799 of file pixarith.c.
References GET_DATA_BIT, GET_DATA_BYTE, and GET_DATA_TWO_BYTES.
| l_ok pixAddConstantGray | ( | PIX * | pixs, |
| l_int32 | val ) |
| [in] | pixs | 8, 16 or 32 bpp |
| [in] | val | amount to add to each pixel |
Notes:
(1) In-place operation.
(2) No clipping for 32 bpp.
(3) For 8 and 16 bpp, if val > 0 the result is clipped
to 0xff and 0xffff, rsp.
(4) For 8 and 16 bpp, if val < 0 the result is clipped to 0.
Definition at line 119 of file pixarith.c.
References GET_DATA_BYTE, GET_DATA_TWO_BYTES, SET_DATA_BYTE, and SET_DATA_TWO_BYTES.
| [in] | pixd | [optional]; this can be null, equal to pixs1, or different from pixs1 |
| [in] | pixs1 | can be equal to pixd |
| [in] | pixs2 |
Notes:
(1) Arithmetic addition of two 8, 16 or 32 bpp images.
(2) For 8 and 16 bpp, we do explicit clipping to 0xff and 0xffff,
respectively.
(3) Alignment is to UL corner.
(4) There are 3 cases. The result can go to a new dest,
in-place to pixs1, or to an existing input dest:
* pixd == null: (src1 + src2) --> new pixd
* pixd == pixs1: (src1 + src2) --> src1 (in-place)
* pixd != pixs1: (src1 + src2) --> input pixd
(5) pixs2 must be different from both pixd and pixs1.
Definition at line 261 of file pixarith.c.
References GET_DATA_BYTE, GET_DATA_TWO_BYTES, SET_DATA_BYTE, and SET_DATA_TWO_BYTES.
| [in] | pixs1,pixs2 | 32 bpp RGB, or colormapped |
Notes:
(1) Clips computation to the minimum size, aligning the UL corners.
(2) Removes any colormap to RGB, and ignores the LSB of each
pixel word (the alpha channel).
(3) Adds each component value, pixelwise, clipping to 255.
(4) This is useful to combine two images where most of the
pixels are essentially black, such as in pixPerceptualDiff().
Definition at line 1043 of file pixarith.c.
References REMOVE_CMAP_TO_FULL_COLOR.
| [in] | pixs | 32 bpp |
| [in] | offset | same as used for initialization |
| [in] | depth | 8, 16 or 32 bpp, of destination |
Notes:
(1) offset must be >= 0 and should not exceed 0x40000000.
(2) offset is subtracted from the src 32 bpp image
(3) For 8 bpp dest, the result is clipped to [0, 0xff]
(4) For 16 bpp dest, the result is clipped to [0, 0xffff]
Definition at line 669 of file pixarith.c.
References SET_DATA_BYTE, and SET_DATA_TWO_BYTES.
| [in] | pixs | 32 bpp |
| [in] | offset | same as used for initialization |
| [in] | threshold | values less than this are set in the destination |
Notes:
(1) offset must be >= 0 and should not exceed 0x40000000.
(2) offset is subtracted from the src 32 bpp image
Definition at line 744 of file pixarith.c.
References SET_DATA_BIT.
| PIX * pixInitAccumulate | ( | l_int32 | w, |
| l_int32 | h, | ||
| l_uint32 | offset ) |
| [in] | w,h | of accumulate array |
| [in] | offset | initialize the 32 bpp to have this value; not more than 0x40000000 |
Notes:
(1) offset must be >= 0.
(2) offset is used so that we can do arithmetic
with negative number results on l_uint32 data; it
prevents the l_uint32 data from going negative.
(3) Because we use l_int32 intermediate data results,
these should never exceed the max of l_int32 (0x7fffffff).
We do not permit the offset to be above 0x40000000,
which is half way between 0 and the max of l_int32.
(4) The same offset should be used for initialization,
multiplication by a constant, and final extraction!
(5) If you're only adding positive values, offset can be 0.
Definition at line 637 of file pixarith.c.
| [in] | pixs | 4, 8, 16 or 32 bpp source |
| [in] | type | L_LINEAR_SCALE or L_LOG_SCALE |
Notes:
(1) Scales pixel values to fit maximally within the dest 8 bpp pixd
(2) Assumes the source 'pixels' are a 1-component scalar. For
a 32 bpp source, each pixel is treated as a single number --
not as a 3-component rgb pixel value.
(3) Uses a LUT for log scaling.
Definition at line 1225 of file pixarith.c.
References GET_DATA_BYTE, GET_DATA_QBIT, GET_DATA_TWO_BYTES, SET_DATA_BYTE, and SET_DATA_QBIT.
| [in] | pixs | 32 bpp rgb source |
| [in] | type | L_LINEAR_SCALE or L_LOG_SCALE |
Notes:
(1) Scales pixel values to fit maximally within a 32 bpp dest pixd
(2) All color components are scaled with the same factor, based
on the maximum r, g or b component in the image. This should
not be used if the 32-bit value is a single number (e.g., a
count in a histogram generated by pixMakeHistoHS()).
(3) Uses a LUT for log scaling.
Definition at line 1411 of file pixarith.c.
References linearScaleRGBVal(), and logScaleRGBVal().
| [in] | pixd | [optional] destination: this can be null, equal to pixs1, or different from pixs1 |
| [in] | pixs1 | can be equal to pixd |
| [in] | pixs2 | |
| [in] | type | L_CHOOSE_MIN, L_CHOOSE_MAX |
Notes:
(1) This gives the min or max of two images, component-wise.
(2) The depth can be 8 or 16 bpp for 1 component, and 32 bpp
for a 3 component image. For 32 bpp, ignore the LSB
of each word (the alpha channel)
(3) There are 3 cases:
~ if pixd == null, MinOrMax(src1, src2) --> new pixd
~ if pixd == pixs1, MinOrMax(src1, src2) --> src1 (in-place)
~ if pixd != pixs1, MinOrMax(src1, src2) --> input pixd
Definition at line 1126 of file pixarith.c.
References GET_DATA_BYTE, GET_DATA_TWO_BYTES, SET_DATA_BYTE, and SET_DATA_TWO_BYTES.
| l_ok pixMultConstAccumulate | ( | PIX * | pixs, |
| l_float32 | factor, | ||
| l_uint32 | offset ) |
| [in] | pixs | 32 bpp |
| [in] | factor | |
| [in] | offset | same as used for initialization |
Notes:
(1) offset must be >= 0 and should not exceed 0x40000000.
(2) This multiplies each pixel, relative to offset, by factor.
(3) The result is returned with offset back in place.
Definition at line 896 of file pixarith.c.
| l_ok pixMultConstantGray | ( | PIX * | pixs, |
| l_float32 | val ) |
| [in] | pixs | 8, 16 or 32 bpp |
| [in] | val | >= 0.0; amount to multiply by each pixel |
Notes:
(1) In-place operation; val must be >= 0.
(2) No clipping for 32 bpp.
(3) For 8 and 16 bpp, the result is clipped to 0xff and 0xffff, rsp.
Definition at line 188 of file pixarith.c.
References GET_DATA_BYTE, GET_DATA_TWO_BYTES, SET_DATA_BYTE, and SET_DATA_TWO_BYTES.
| [in] | pixs | 32 bpp rgb or 8 bpp gray |
| [in] | pixg | 8 bpp gray |
| [in] | norm | multiplicative factor to avoid overflow; 0 for default |
Notes:
(1) This function can be used for correcting a scanned image
under non-uniform illumination. For that application,
pixs is the scanned image, pixg is an image whose values
are inversely related to light from a uniform (say, white)
target, and norm is typically the inverse of the maximum
pixel value in pixg.
(2) Set norm = 0 to get the default value, which is the inverse
of the max value in pixg. This avoids overflow in the product.
(3) For 32 bpp pixs, all 3 components are multiplied by the
same number.
(4) Alignment is to UL corner.
Definition at line 441 of file pixarith.c.
References GET_DATA_BYTE, L_SELECT_MAX, and SET_DATA_BYTE.
| [in] | pixd | [optional]; this can be null, equal to pixs1, or different from pixs1 |
| [in] | pixs1 | can be equal to pixd |
| [in] | pixs2 |
Notes:
(1) Arithmetic subtraction of two 8, 16 or 32 bpp images.
(2) Source pixs2 is always subtracted from source pixs1.
(3) Do explicit clipping to 0.
(4) Alignment is to UL corner.
(5) There are 3 cases. The result can go to a new dest,
in-place to pixs1, or to an existing input dest:
(a) pixd == null (src1 - src2) --> new pixd
(b) pixd == pixs1 (src1 - src2) --> src1 (in-place)
(d) pixd != pixs1 (src1 - src2) --> input pixd
(6) pixs2 must be different from both pixd and pixs1.
Definition at line 351 of file pixarith.c.
References GET_DATA_BYTE, GET_DATA_TWO_BYTES, SET_DATA_BYTE, and SET_DATA_TWO_BYTES.
| [in] | pixd | [optional]; if not null, must be equal to pixs |
| [in] | pixs | 8, 16, 32 bpp |
| [in] | threshval | |
| [in] | setval |
Notes: ~ operation can be in-place (pixs == pixd) or to a new pixd ~ if setval > threshval, sets pixels with a value >= threshval to setval ~ if setval < threshval, sets pixels with a value <= threshval to setval ~ if setval == threshval, no-op
Definition at line 530 of file pixarith.c.
References GET_DATA_BYTE, GET_DATA_TWO_BYTES, SET_DATA_BYTE, and SET_DATA_TWO_BYTES.
1.12.0