Grayscale image arithmetic. More...

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "allheaders.h"

Functions
l_int32	pixAddConstantGray (PIX *pixs, l_int32 val)
l_int32	pixMultConstantGray (PIX *pixs, l_float32 val)
PIX *	pixAddGray (PIX pixd, PIX pixs1, PIX *pixs2)
PIX *	pixSubtractGray (PIX pixd, PIX pixs1, PIX *pixs2)
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_int32	pixAccumulate (PIX pixd, PIX pixs, l_int32 op)
l_int32	pixMultConstAccumulate (PIX *pixs, l_float32 factor, l_uint32 offset)
PIX *	pixAbsDifference (PIX pixs1, PIX pixs2)
PIX *	pixMinOrMax (PIX pixd, PIX pixs1, PIX *pixs2, l_int32 type)
PIX *	pixMaxDynamicRange (PIX *pixs, l_int32 type)
l_float32 *	makeLogBase2Tab (void)
l_float32	getLogBase2 (l_int32 val, l_float32 *logtab)

Detailed Description

Grayscale image arithmetic.

    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()

    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()

    Two-image min and max operations (8 and 16 bpp)
         PIX        *pixMinOrMax()

    Scale pix for maximum dynamic range in 8 bpp image:
         PIX        *pixMaxDynamicRange()

    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.

Function Documentation

l_int32 pixAddConstantGray	(	PIX *	pixs,
		l_int32	val
	)

pixAddConstantGray()

Input: pixs (8, 16 or 32 bpp) val (amount to add to each pixel) Return: 0 if OK, 1 on error

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 96 of file pixarith.c.

References addConstantGrayLow(), ERROR_INT, pixGetData(), pixGetDimensions(), pixGetWpl(), and PROCNAME.

Referenced by main(), pixHDome(), pixMinMaxTiles(), and pixSeedfillGrayBasin().

l_int32 pixMultConstantGray	(	PIX *	pixs,
		l_float32	val
	)

pixMultConstantGray()

Input: pixs (8, 16 or 32 bpp) val (>= 0.0; amount to multiply by each pixel) Return: 0 if OK, 1 on error

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 131 of file pixarith.c.

References ERROR_INT, multConstantGrayLow(), pixGetData(), pixGetDimensions(), pixGetWpl(), and PROCNAME.

PIX* pixAddGray	(	PIX *	pixd,
		PIX *	pixs1,
		PIX *	pixs2
	)

pixAddGray()

Input: pixd (<optional>; this can be null, equal to pixs1, or different from pixs1) pixs1 (can be == to pixd) pixs2 Return: pixd always

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 180 of file pixarith.c.

References addGrayLow(), ERROR_PTR, L_MIN, L_WARNING, NULL, pixCopy(), pixGetData(), pixGetDepth(), pixGetDimensions(), pixGetWpl(), pixSizesEqual(), and PROCNAME.

Referenced by main().

PIX* pixSubtractGray	(	PIX *	pixd,
		PIX *	pixs1,
		PIX *	pixs2
	)

pixSubtractGray()

Input: pixd (<optional>; this can be null, equal to pixs1, or different from pixs1) pixs1 (can be == to pixd) pixs2 Return: pixd always

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 250 of file pixarith.c.

References ERROR_PTR, L_MIN, L_WARNING, NULL, pixCopy(), pixGetData(), pixGetDepth(), pixGetDimensions(), pixGetWpl(), pixSizesEqual(), PROCNAME, and subtractGrayLow().

Referenced by pixCompareGray(), pixCompareRGB(), pixFastTophat(), pixHalfEdgeByBandpass(), pixHDome(), pixMorphGradient(), and pixTophat().

PIX* pixThresholdToValue	(	PIX *	pixd,
		PIX *	pixs,
		l_int32	threshval,
		l_int32	setval
	)

pixThresholdToValue()

Input: pixd (<optional>; if not null, must be equal to pixs) pixs (8, 16, 32 bpp) threshval setval Return: pixd always

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 317 of file pixarith.c.

References ERROR_PTR, L_WARNING, NULL, pixCopy(), pixGetData(), pixGetDepth(), pixGetDimensions(), pixGetWpl(), PROCNAME, and thresholdToValueLow().

Referenced by main().

PIX* pixInitAccumulate	(	l_int32	w,
		l_int32	h,
		l_uint32	offset
	)

pixInitAccumulate()

Input: w, h (of accumulate array) offset (initialize the 32 bpp to have this value; not more than 0x40000000) Return: pixd (32 bpp), or null on error

Notes: (1) The offset must be >= 0. (2) The 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 383 of file pixarith.c.

References ERROR_PTR, NULL, pixCreate(), pixSetAllArbitrary(), and PROCNAME.

Referenced by jbAccumulateComposites(), and main().

PIX* pixFinalAccumulate	(	PIX *	pixs,
		l_uint32	offset,
		l_int32	depth
	)

pixFinalAccumulate()

Input: pixs (32 bpp) offset (same as used for initialization) depth (8, 16 or 32 bpp, of destination) Return: pixd (8, 16 or 32 bpp), or null on error

Notes: (1) The offset must be >= 0 and should not exceed 0x40000000. (2) The 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 415 of file pixarith.c.

References ERROR_PTR, finalAccumulateLow(), NULL, pixCopyResolution(), pixCreate(), pixGetData(), pixGetDepth(), pixGetDimensions(), pixGetWpl(), and PROCNAME.

Referenced by jbTemplatesFromComposites(), main(), and pixaccFinal().

PIX* pixFinalAccumulateThreshold	(	PIX *	pixs,
		l_uint32	offset,
		l_uint32	threshold
	)

pixFinalAccumulateThreshold()

Input: pixs (32 bpp) offset (same as used for initialization) threshold (values less than this are set in the destination) Return: pixd (1 bpp), or null on error

Notes: (1) The offset must be >= 0 and should not exceed 0x40000000. (2) The offset is subtracted from the src 32 bpp image

Definition at line 461 of file pixarith.c.

References ERROR_PTR, finalAccumulateThreshLow(), NULL, pixCopyResolution(), pixCreate(), pixGetData(), pixGetDepth(), pixGetDimensions(), pixGetWpl(), and PROCNAME.

l_int32 pixAccumulate	(	PIX *	pixd,
		PIX *	pixs,
		l_int32	op
	)

pixAccumulate()

Input: pixd (32 bpp) pixs (1, 8, 16 or 32 bpp) op (L_ARITH_ADD or L_ARITH_SUBTRACT) Return: 0 if OK; 1 on error

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 507 of file pixarith.c.

References accumulateLow(), ERROR_INT, L_ARITH_ADD, L_ARITH_SUBTRACT, L_MIN, NULL, pixGetData(), pixGetDepth(), pixGetDimensions(), pixGetWpl(), and PROCNAME.

Referenced by jbAccumulateComposites(), main(), pixaccAdd(), and pixaccSubtract().

l_int32 pixMultConstAccumulate	(	PIX *	pixs,
		l_float32	factor,
		l_uint32	offset
	)

pixMultConstAccumulate()

Input: pixs (32 bpp) factor offset (same as used for initialization) Return: 0 if OK; 1 on error

Notes: (1) The offset must be >= 0 and should not exceed 0x40000000. (2) This multiplies each pixel, relative to offset, by the input factor (3) The result is returned with the offset back in place.

Definition at line 555 of file pixarith.c.

References ERROR_INT, multConstAccumulateLow(), NULL, pixGetData(), pixGetDepth(), pixGetDimensions(), pixGetWpl(), and PROCNAME.

Referenced by jbTemplatesFromComposites(), main(), and pixaccMultConst().

PIX* pixAbsDifference	(	PIX *	pixs1,
		PIX *	pixs2
	)

pixAbsDifference()

Input: pixs1, pixs2 (both either 8 or 16 bpp gray, or 32 bpp RGB) Return: pixd, or null on error

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 599 of file pixarith.c.

References absDifferenceLow(), ERROR_PTR, L_MIN, NULL, pixCopyResolution(), pixCreate(), pixGetData(), pixGetDepth(), pixGetDimensions(), pixGetWpl(), and PROCNAME.

Referenced by main(), pixCompareGray(), pixCompareRGB(), and pixCompareTiled().

PIX* pixMinOrMax	(	PIX *	pixd,
		PIX *	pixs1,
		PIX *	pixs2,
		l_int32	type
	)

pixMinOrMax()

Input: pixd (<optional> destination: this can be null, equal to pixs1, or different from pixs1) pixs1 (can be == to pixd) pixs2 type (L_CHOOSE_MIN, L_CHOOSE_MAX) Return: pixd always

Notes: (1) This gives the min or max of two images. (2) The depth can be 8 or 16 bpp. (3) There are 3 cases:

if pixd == null, Min(src1, src2) --> new pixd
if pixd == pixs1, Min(src1, src2) --> src1 (in-place)
if pixd != pixs1, Min(src1, src2) --> input pixd

Definition at line 659 of file pixarith.c.

References ERROR_PTR, GET_DATA_BYTE, GET_DATA_TWO_BYTES, L_CHOOSE_MAX, L_CHOOSE_MIN, L_MAX, L_MIN, NULL, pixCopy(), pixGetData(), pixGetDepth(), pixGetDimensions(), pixGetWpl(), PROCNAME, SET_DATA_BYTE, and SET_DATA_TWO_BYTES.

Referenced by main().

PIX* pixMaxDynamicRange	(	PIX *	pixs,
		l_int32	type
	)

pixMaxDynamicRange()

Input: pixs (4, 8, 16 or 32 bpp source) type (L_LINEAR_SCALE or L_LOG_SCALE) Return: pixd (8 bpp), or null on error

Notes: (1) Scales pixel values to fit maximally within the dest 8 bpp pixd (2) Uses a LUT for log scaling

Definition at line 752 of file pixarith.c.

References ERROR_PTR, FREE, GET_DATA_BYTE, GET_DATA_QBIT, GET_DATA_TWO_BYTES, getLogBase2(), L_LINEAR_SCALE, L_LOG_SCALE, L_MAX, makeLogBase2Tab(), NULL, pixCopyResolution(), pixCreate(), pixGetData(), pixGetDepth(), pixGetDimensions(), pixGetWpl(), PROCNAME, SET_DATA_BYTE, and SET_DATA_QBIT.

Referenced by main(), pixDisplayWriteFormat(), pixFindHistoPeaksHSV(), and TestDistance().

l_float32* makeLogBase2Tab ( void )

Definition at line 933 of file pixarith.c.

References CALLOC, ERROR_PTR, NULL, and PROCNAME.

Referenced by pixMaxDynamicRange().

l_float32 getLogBase2	(	l_int32	val,
		l_float32 *	logtab
	)

Definition at line 960 of file pixarith.c.

References ERROR_INT, and PROCNAME.

Referenced by pixMaxDynamicRange().

pixarith.c File Reference

Functions

Detailed Description

Function Documentation