![]() |
Leptonica
1.82.0
Image processing and image analysis suite
|
#include <string.h>
#include "allheaders.h"
Go to the source code of this file.
Macros | |
#define | DEBUG_SERIALIZE 0 |
Functions | |
l_ok | pixGetPixel (PIX *pix, l_int32 x, l_int32 y, l_uint32 *pval) |
l_ok | pixSetPixel (PIX *pix, l_int32 x, l_int32 y, l_uint32 val) |
l_ok | pixGetRGBPixel (PIX *pix, l_int32 x, l_int32 y, l_int32 *prval, l_int32 *pgval, l_int32 *pbval) |
l_ok | pixSetRGBPixel (PIX *pix, l_int32 x, l_int32 y, l_int32 rval, l_int32 gval, l_int32 bval) |
l_ok | pixSetCmapPixel (PIX *pix, l_int32 x, l_int32 y, l_int32 rval, l_int32 gval, l_int32 bval) |
l_ok | pixGetRandomPixel (PIX *pix, l_uint32 *pval, l_int32 *px, l_int32 *py) |
l_ok | pixClearPixel (PIX *pix, l_int32 x, l_int32 y) |
l_ok | pixFlipPixel (PIX *pix, l_int32 x, l_int32 y) |
void | setPixelLow (l_uint32 *line, l_int32 x, l_int32 depth, l_uint32 val) |
l_ok | pixGetBlackOrWhiteVal (PIX *pixs, l_int32 op, l_uint32 *pval) |
l_ok | pixClearAll (PIX *pix) |
l_ok | pixSetAll (PIX *pix) |
l_ok | pixSetAllGray (PIX *pix, l_int32 grayval) |
l_ok | pixSetAllArbitrary (PIX *pix, l_uint32 val) |
l_ok | pixSetBlackOrWhite (PIX *pixs, l_int32 op) |
l_ok | pixSetComponentArbitrary (PIX *pix, l_int32 comp, l_int32 val) |
l_ok | pixClearInRect (PIX *pix, BOX *box) |
l_ok | pixSetInRect (PIX *pix, BOX *box) |
l_ok | pixSetInRectArbitrary (PIX *pix, BOX *box, l_uint32 val) |
l_ok | pixBlendInRect (PIX *pixs, BOX *box, l_uint32 val, l_float32 fract) |
l_ok | pixSetPadBits (PIX *pix, l_int32 val) |
l_ok | pixSetPadBitsBand (PIX *pix, l_int32 by, l_int32 bh, l_int32 val) |
l_ok | pixSetOrClearBorder (PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_int32 op) |
l_ok | pixSetBorderVal (PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_uint32 val) |
l_ok | pixSetBorderRingVal (PIX *pixs, l_int32 dist, l_uint32 val) |
l_ok | pixSetMirroredBorder (PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot) |
PIX * | pixCopyBorder (PIX *pixd, PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot) |
PIX * | pixAddBorder (PIX *pixs, l_int32 npix, l_uint32 val) |
PIX * | pixAddBlackOrWhiteBorder (PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_int32 op) |
PIX * | pixAddBorderGeneral (PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_uint32 val) |
PIX * | pixRemoveBorder (PIX *pixs, l_int32 npix) |
PIX * | pixRemoveBorderGeneral (PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot) |
PIX * | pixRemoveBorderToSize (PIX *pixs, l_int32 wd, l_int32 hd) |
PIX * | pixAddMirroredBorder (PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot) |
PIX * | pixAddRepeatedBorder (PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot) |
PIX * | pixAddMixedBorder (PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot) |
PIX * | pixAddContinuedBorder (PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot) |
l_ok | pixShiftAndTransferAlpha (PIX *pixd, PIX *pixs, l_float32 shiftx, l_float32 shifty) |
PIX * | pixDisplayLayersRGBA (PIX *pixs, l_uint32 val, l_int32 maxw) |
PIX * | pixCreateRGBImage (PIX *pixr, PIX *pixg, PIX *pixb) |
PIX * | pixGetRGBComponent (PIX *pixs, l_int32 comp) |
l_ok | pixSetRGBComponent (PIX *pixd, PIX *pixs, l_int32 comp) |
PIX * | pixGetRGBComponentCmap (PIX *pixs, l_int32 comp) |
l_ok | pixCopyRGBComponent (PIX *pixd, PIX *pixs, l_int32 comp) |
l_ok | composeRGBPixel (l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 *ppixel) |
l_ok | composeRGBAPixel (l_int32 rval, l_int32 gval, l_int32 bval, l_int32 aval, l_uint32 *ppixel) |
void | extractRGBValues (l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval) |
void | extractRGBAValues (l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval, l_int32 *paval) |
l_int32 | extractMinMaxComponent (l_uint32 pixel, l_int32 type) |
l_ok | pixGetRGBLine (PIX *pixs, l_int32 row, l_uint8 *bufr, l_uint8 *bufg, l_uint8 *bufb) |
l_ok | setLineDataVal (l_uint32 *line, l_int32 j, l_int32 d, l_uint32 val) |
PIX * | pixEndianByteSwapNew (PIX *pixs) |
l_ok | pixEndianByteSwap (PIX *pixs) |
l_int32 | lineEndianByteSwap (l_uint32 *datad, l_uint32 *datas, l_int32 wpl) |
PIX * | pixEndianTwoByteSwapNew (PIX *pixs) |
l_ok | pixEndianTwoByteSwap (PIX *pixs) |
l_ok | pixGetRasterData (PIX *pixs, l_uint8 **pdata, size_t *pnbytes) |
l_ok | pixInferResolution (PIX *pix, l_float32 longside, l_int32 *pres) |
l_ok | pixAlphaIsOpaque (PIX *pix, l_int32 *popaque) |
l_uint8 ** | pixSetupByteProcessing (PIX *pix, l_int32 *pw, l_int32 *ph) |
l_ok | pixCleanupByteProcessing (PIX *pix, l_uint8 **lineptrs) |
void | l_setAlphaMaskBorder (l_float32 val1, l_float32 val2) |
Variables | |
static const l_uint32 | rmask32 [] |
LEPT_DLL l_float32 | AlphaMaskBorderVals [2] = {0.0, 0.5} |
This file has these basic operations: (1) Get and set: individual pixels, full image, rectangular region, pad pixels, border pixels, and color components for RGB (2) Add and remove border pixels (3) Endian byte swaps (4) Simple method for byte-processing images (instead of words) Pixel poking l_int32 pixGetPixel() l_int32 pixSetPixel() l_int32 pixGetRGBPixel() l_int32 pixSetRGBPixel() l_int32 pixSetCmapPixel() l_int32 pixGetRandomPixel() l_int32 pixClearPixel() l_int32 pixFlipPixel() void setPixelLow() Find black or white value l_int32 pixGetBlackOrWhiteVal() Full image clear/set/set-to-arbitrary-value l_int32 pixClearAll() l_int32 pixSetAll() l_int32 pixSetAllGray() l_int32 pixSetAllArbitrary() l_int32 pixSetBlackOrWhite() l_int32 pixSetComponentArbitrary() Rectangular region clear/set/set-to-arbitrary-value/blend l_int32 pixClearInRect() l_int32 pixSetInRect() l_int32 pixSetInRectArbitrary() l_int32 pixBlendInRect() Set pad bits l_int32 pixSetPadBits() l_int32 pixSetPadBitsBand() Assign border pixels l_int32 pixSetOrClearBorder() l_int32 pixSetBorderVal() l_int32 pixSetBorderRingVal() l_int32 pixSetMirroredBorder() PIX *pixCopyBorder() Add and remove border PIX *pixAddBorder() PIX *pixAddBlackOrWhiteBorder() PIX *pixAddBorderGeneral() PIX *pixRemoveBorder() PIX *pixRemoveBorderGeneral() PIX *pixRemoveBorderToSize() PIX *pixAddMirroredBorder() PIX *pixAddRepeatedBorder() PIX *pixAddMixedBorder() PIX *pixAddContinuedBorder() Helper functions using alpha l_int32 pixShiftAndTransferAlpha() PIX *pixDisplayLayersRGBA() Color sample setting and extraction PIX *pixCreateRGBImage() PIX *pixGetRGBComponent() l_int32 pixSetRGBComponent() PIX *pixGetRGBComponentCmap() l_int32 pixCopyRGBComponent() l_int32 composeRGBPixel() l_int32 composeRGBAPixel() void extractRGBValues() void extractRGBAValues() l_int32 extractMinMaxComponent() l_int32 pixGetRGBLine() Raster line pixel setter l_int32 setLineDataVal() Conversion between big and little endians PIX *pixEndianByteSwapNew() l_int32 pixEndianByteSwap() l_int32 lineEndianByteSwap() PIX *pixEndianTwoByteSwapNew() l_int32 pixEndianTwoByteSwap() Extract raster data as binary string l_int32 pixGetRasterData() Test alpha component opaqueness l_int32 pixAlphaIsOpaque() Infer resolution from image size l_int32 pixInferResolution() Setup helpers for 8 bpp byte processing l_uint8 **pixSetupByteProcessing() l_int32 pixCleanupByteProcessing() Setting parameters for antialias masking with alpha transforms void l_setAlphaMaskBorder()
Definition in file pix2.c.
l_ok composeRGBAPixel | ( | l_int32 | rval, |
l_int32 | gval, | ||
l_int32 | bval, | ||
l_int32 | aval, | ||
l_uint32 * | ppixel | ||
) |
[in] | rval,gval,bval,aval | |
[out] | ppixel | 32-bit pixel |
Notes: (1) All channels are 8 bits: the input values must be between 0 and 255. For speed, this is not enforced by masking with 0xff before shifting.
Definition at line 2783 of file pix2.c.
Referenced by pixcmapGetColor32(), pixcmapGetRGBA32(), and pixcmapToRGBTable().
l_ok composeRGBPixel | ( | l_int32 | rval, |
l_int32 | gval, | ||
l_int32 | bval, | ||
l_uint32 * | ppixel | ||
) |
[in] | rval,gval,bval | |
[out] | ppixel | 32-bit pixel |
Notes: (1) All channels are 8 bits: the input values must be between 0 and 255. For speed, this is not enforced by masking with 0xff before shifting. (2) A slower implementation uses macros: SET_DATA_BYTE(ppixel, COLOR_RED, rval); SET_DATA_BYTE(ppixel, COLOR_GREEN, gval); SET_DATA_BYTE(ppixel, COLOR_BLUE, bval);
Definition at line 2751 of file pix2.c.
Referenced by evalColorfillData(), makeColorfillTestData(), pixaDisplayBoxaa(), pixBlendBoxaRandom(), pixDisplayPtaa(), pixelFractionalShift(), pixelLinearMapToTargetColor(), pixelShiftByComponent(), and pixMakeGamutRGB().
l_int32 extractMinMaxComponent | ( | l_uint32 | pixel, |
l_int32 | type | ||
) |
[in] | pixel | 32 bpp RGB |
[in] | type | L_CHOOSE_MIN or L_CHOOSE_MAX |
Definition at line 2863 of file pix2.c.
References extractRGBValues().
void extractRGBAValues | ( | l_uint32 | pixel, |
l_int32 * | prval, | ||
l_int32 * | pgval, | ||
l_int32 * | pbval, | ||
l_int32 * | paval | ||
) |
[in] | pixel | 32 bit |
[out] | prval | [optional] red component |
[out] | pgval | [optional] green component |
[out] | pbval | [optional] blue component |
[out] | paval | [optional] alpha component |
void extractRGBValues | ( | l_uint32 | pixel, |
l_int32 * | prval, | ||
l_int32 * | pgval, | ||
l_int32 * | pbval | ||
) |
[in] | pixel | 32 bit |
[out] | prval | [optional] red component |
[out] | pgval | [optional] green component |
[out] | pbval | [optional] blue component |
Notes: (1) A slower implementation uses macros: *prval = GET_DATA_BYTE(&pixel, COLOR_RED); *pgval = GET_DATA_BYTE(&pixel, COLOR_GREEN); *pbval = GET_DATA_BYTE(&pixel, COLOR_BLUE);
Definition at line 2820 of file pix2.c.
Referenced by colorsAreSimilarForFill(), extractMinMaxComponent(), makeColorfillTestData(), pixaDisplayBoxaa(), pixcmapGrayToColor(), pixcmapShiftByComponent(), pixDisplayColorArray(), pixelColorIsValid(), pixelLinearMapToTargetColor(), pixelShiftByComponent(), pixGenerateMaskByBand32(), and pixGenerateMaskByDiscr32().
void l_setAlphaMaskBorder | ( | l_float32 | val1, |
l_float32 | val2 | ||
) |
[in] | val1,val2 | in [0.0 ... 1.0] |
Notes: (1) This sets the opacity values used to generate the two outer boundary rings in the alpha mask associated with geometric transforms such as pixRotateWithAlpha(). (2) The default values are val1 = 0.0 (completely transparent in the outermost ring) and val2 = 0.5 (half transparent in the second ring). When the image is blended, this completely removes the outer ring (shrinking the image by 2 in each direction), and alpha-blends with 0.5 the second ring. Using val1 = 0.25 and val2 = 0.75 gives a slightly more blurred border, with no perceptual difference at screen resolution. (3) The actual mask values are found by multiplying these normalized opacity values by 255.
l_int32 lineEndianByteSwap | ( | l_uint32 * | datad, |
l_uint32 * | datas, | ||
l_int32 | wpl | ||
) |
[in] | datad | dest byte array data, reordered on little-endians |
[in] | datas | a src line of pix data) |
[in] | wpl | number of 32 bit words in the line |
Notes: (1) This is used on little-endian platforms to swap the bytes within each word in the line of image data. Bytes 0 <==> 3 and 1 <==> 2 are swapped in the dest byte array data8d, relative to the pix data in datas. (2) The bytes represent 8 bit pixel values. They are swapped for little endians so that when the dest array datad is addressed by bytes, the pixels are chosen sequentially from left to right in the image.
PIX* pixAddBlackOrWhiteBorder | ( | PIX * | pixs, |
l_int32 | left, | ||
l_int32 | right, | ||
l_int32 | top, | ||
l_int32 | bot, | ||
l_int32 | op | ||
) |
[in] | pixs | all depths; colormap ok |
[in] | left,right,top,bot | number of pixels added |
[in] | op | L_GET_BLACK_VAL, L_GET_WHITE_VAL |
Notes: (1) See pixGetBlackOrWhiteVal() for possible side effect (adding a color to a colormap). (2) The only complication is that pixs may have a colormap. There are two ways to add the black or white border: (a) As done here (simplest, most efficient) (b) l_int32 ws, hs, d; pixGetDimensions(pixs, &ws, &hs, &d); Pix *pixd = pixCreate(ws + left + right, hs + top + bot, d); PixColormap *cmap = pixGetColormap(pixs); if (cmap != NULL) pixSetColormap(pixd, pixcmapCopy(cmap)); pixSetBlackOrWhite(pixd, L_SET_WHITE); // uses cmap pixRasterop(pixd, left, top, ws, hs, PIX_SET, pixs, 0, 0);
Definition at line 1863 of file pix2.c.
References L_GET_BLACK_VAL, L_GET_WHITE_VAL, pixAddBorderGeneral(), and pixGetBlackOrWhiteVal().
Referenced by pixaDisplayPairTiledInColumns(), pixDisplayOutliers(), and showExtractNumbers().
[in] | pixs | all depths; colormap ok |
[in] | npix | number of pixels to be added to each side |
[in] | val | value of added border pixels |
Notes: (1) See pixGetBlackOrWhiteVal() for values of black and white pixels.
Definition at line 1823 of file pix2.c.
References pixAddBorderGeneral(), and pixClone().
Referenced by pixaDisplayTiledAndScaled(), pixaDisplayTiledInColumns(), pixaDisplayTiledInRows(), pixDisplayColorArray(), pixGetOuterBorder(), pixSimpleCaptcha(), and recogDebugAverages().
PIX* pixAddBorderGeneral | ( | PIX * | pixs, |
l_int32 | left, | ||
l_int32 | right, | ||
l_int32 | top, | ||
l_int32 | bot, | ||
l_uint32 | val | ||
) |
[in] | pixs | all depths; colormap ok |
[in] | left,right,top,bot | number of pixels added |
[in] | val | value of added border pixels |
Notes: (1) For binary images: white: val = 0 black: val = 1 For grayscale images: white: val = 2 ** d - 1 black: val = 0 For rgb color images: white: val = 0xffffff00 black: val = 0 For colormapped images, set val to the appropriate colormap index. (2) If the added border is either black or white, you can use pixAddBlackOrWhiteBorder() The black and white values for all images can be found with pixGetBlackOrWhiteVal() which, if pixs is cmapped, may add an entry to the colormap. Alternatively, if pixs has a colormap, you can find the index of the pixel whose intensity is closest to white or black: white: pixcmapGetRankIntensity(cmap, 1.0, &index); black: pixcmapGetRankIntensity(cmap, 0.0, &index); and use that for val.
Definition at line 1917 of file pix2.c.
References pixCreate(), and pixGetDimensions().
Referenced by pixaAddBorderGeneral(), pixAddBlackOrWhiteBorder(), pixAddBorder(), pixAddContinuedBorder(), pixAddMirroredBorder(), pixAddMixedBorder(), pixAddRepeatedBorder(), pixaDisplayTiledByIndex(), pixaDisplayTiledWithText(), pixAffineSequential(), recogShowMatch(), and recogShowPath().
[in] | pixs | all depths; colormap ok |
[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 2257 of file pix2.c.
References PIX_SRC, pixAddBorderGeneral(), pixGetDimensions(), and pixRasterop().
[in] | pixs | all depths; colormap ok |
[in] | left,right,top,bot | number of pixels added |
Notes: (1) This applies what is effectively mirror boundary conditions. For the added border pixels in pixd, the pixels in pixs near the border are mirror-copied into the border region. (2) This is useful for avoiding special operations near boundaries when doing image processing operations such as rank filters and convolution. In use, one first adds mirrored pixels to each side of the image. The number of pixels added on each side is half the filter dimension. Then the image processing operations proceed over a region equal to the size of the original image, and write directly into a dest pix of the same size as pixs. (3) The general pixRasterop() is used for an in-place operation here because there is no overlap between the src and dest rectangles.
Definition at line 2101 of file pix2.c.
References PIX_SRC, pixAddBorderGeneral(), pixGetDimensions(), and pixRasterop().
Referenced by bilateralCreate(), pixBlockconvGrayUnnormalized(), pixSobelEdgeFilter(), and pixTilingGetTile().
[in] | pixs | all depths; colormap ok |
[in] | left,right,top,bot | number of pixels added |
Notes: (1) This applies mirrored boundary conditions horizontally and repeated b.c. vertically. (2) It is specifically used for avoiding special operations near boundaries when convolving a hue-saturation histogram with a given window size. The repeated b.c. are used vertically for hue, and the mirrored b.c. are used horizontally for saturation. The number of pixels added on each side is approximately (but not quite) half the filter dimension. The image processing operations can then proceed over a region equal to the size of the original image, and write directly into a dest pix of the same size as pixs. (3) The general pixRasterop() can be used for an in-place operation here because there is no overlap between the src and dest rectangles.
Definition at line 2210 of file pix2.c.
References PIX_SRC, pixAddBorderGeneral(), pixGetDimensions(), and pixRasterop().
[in] | pixs | all depths; colormap ok |
[in] | left,right,top,bot | number of pixels added |
Notes: (1) This applies a repeated border, as if the central part of the image is tiled over the plane. So, for example, the pixels in the left border come from the right side of the image. (2) The general pixRasterop() is used for an in-place operation here because there is no overlap between the src and dest rectangles.
Definition at line 2154 of file pix2.c.
References PIX_SRC, pixAddBorderGeneral(), pixGetDimensions(), and pixRasterop().
l_ok pixAlphaIsOpaque | ( | PIX * | pix, |
l_int32 * | popaque | ||
) |
[in] | pix | 32 bpp, spp == 4 |
[out] | popaque | 1 if spp == 4 and all alpha component values are 255 (opaque); 0 otherwise |
Notes: 1) On error, opaque is returned as 0 (FALSE).
[in] | pixs | 32 bpp rgb |
[in] | box | [optional] in which all pixels will be blended |
[in] | val | blend value; 0xrrggbb00 |
[in] | fract | fraction of color to be blended with each pixel in pixs |
Notes: (1) This is an in-place function. It blends the input color val with the pixels in pixs in the specified rectangle. If no rectangle is specified, it blends over the entire image.
Definition at line 1296 of file pix2.c.
Referenced by pixBlendBoxaRandom().
l_ok pixCleanupByteProcessing | ( | PIX * | pix, |
l_uint8 ** | lineptrs | ||
) |
[in] | pix | 8 bpp, no colormap |
[in] | lineptrs | ptrs to the beginning of each raster line of data |
Notes: (1) This must be called after processing that was initiated by pixSetupByteProcessing() has finished.
Definition at line 3526 of file pix2.c.
References pixEndianByteSwap().
l_ok pixClearAll | ( | PIX * | pix | ) |
[in] | pix | all depths; use cmapped with caution |
Notes: (1) Clears all data to 0. For 1 bpp, this is white; for grayscale or color, this is black. (2) Caution: for colormapped pix, this sets the color to the first one in the colormap. Be sure that this is the intended color!
Definition at line 789 of file pix2.c.
References Pix::data, Pix::h, and Pix::wpl.
Referenced by pixaAccumulateSamples(), pixaSplitPix(), pixDilate(), and pixHMT().
[in] | pix | all depths; can be cmapped |
[in] | box | in which all pixels will be cleared |
Notes: (1) Clears all data in rect to 0. For 1 bpp, this is white; for grayscale or color, this is black. (2) Caution: for colormapped pix, this sets the color to the first one in the colormap. Be sure that this is the intended color!
Definition at line 1118 of file pix2.c.
References boxGetGeometry(), PIX_CLR, and pixRasterop().
l_ok pixClearPixel | ( | PIX * | pix, |
l_int32 | x, | ||
l_int32 | y | ||
) |
[in] | pix | any depth; warning if colormapped |
[in] | x,y | pixel coords |
Notes: (1) If the point is outside the image, this returns an error (2), with 0 in pval. To avoid spamming output, it fails silently.
PIX* pixCopyBorder | ( | PIX * | pixd, |
PIX * | pixs, | ||
l_int32 | left, | ||
l_int32 | right, | ||
l_int32 | top, | ||
l_int32 | bot | ||
) |
[in] | pixd | all depths; colormap ok; can be NULL |
[in] | pixs | same depth and size as pixd |
[in] | left,right,top,bot | number of pixels to copy |
Notes: (1) pixd can be null, but otherwise it must be the same size and depth as pixs. Always returns pixd. (2) This is useful in situations where by setting a few border pixels we can avoid having to copy all pixels in pixs into pixd as an initialization step for some operation. Nevertheless, for safety, if making a new pixd, all the non-border pixels are initialized to 0.
Definition at line 1769 of file pix2.c.
References PIX_SRC, pixCreateTemplate(), pixGetDimensions(), pixRasterop(), and pixSizesEqual().
[in] | pixd | 32 bpp |
[in] | pixs | 32 bpp |
[in] | comp | one of the set: {COLOR_RED, COLOR_GREEN, COLOR_BLUE, L_ALPHA_CHANNEL} |
Notes: (1) The two images are registered to the UL corner. The sizes are usually the same, and a warning is issued if they differ.
[in] | pixr | 8 bpp red pix |
[in] | pixg | 8 bpp green pix |
[in] | pixb | 8 bpp blue pix |
Notes: (1) the 4th byte, sometimes called the "alpha channel", and which is often used for blending between different images, is left with 0 value. (2) see Note (4) in pix.h for details on storage of 8-bit samples within each 32-bit word. (3) This implementation, setting the r, g and b components sequentially, is much faster than setting them in parallel by constructing an RGB dest pixel and writing it to dest. The reason is there are many more cache misses when reading from 3 input images simultaneously.
Definition at line 2423 of file pix2.c.
References pixCreate(), and pixGetDimensions().
[in] | pixs | cmap or 32 bpp rgba |
[in] | val | 32 bit unsigned color to use as background |
[in] | maxw | max output image width; 0 for no scaling |
Notes: (1) Use val == 0xffffff00 for white background. (2) Three views are given: ~ the image with a fully opaque alpha ~ the alpha layer ~ the image as it would appear with a white background.
l_ok pixEndianByteSwap | ( | PIX * | pixs | ) |
[in] | pixs |
Notes: (1) This is used on little-endian platforms to swap the bytes within a word; bytes 0 and 3 are swapped, and bytes 1 and 2 are swapped. (2) This is required for little-endians in situations where we convert from a serialized byte order that is in raster order, as one typically has in file formats, to one with MSB-to-the-left in each 32-bit word, or v.v. See pix.h for a description of the canonical format (MSB-to-the left) that is used for both little-endian and big-endian platforms. For big-endians, the MSB-to-the-left word order has the bytes in raster order when serialized, so no byte flipping is required.
Definition at line 3074 of file pix2.c.
References pixGetData().
Referenced by pixCleanupByteProcessing().
[in] | pixs |
Notes: (1) This is used to convert the data in a pix to a serialized byte buffer in raster order, and, for RGB, in order RGBA. This requires flipping bytes within each 32-bit word for little-endian platforms, because the words have a MSB-to-the-left rule, whereas byte raster-order requires the left-most byte in each word to be byte 0. For big-endians, no swap is necessary, so this returns a clone. (2) Unlike pixEndianByteSwap(), which swaps the bytes in-place, this returns a new pix (or a clone). We provide this because often when serialization is done, the source pix needs to be restored to canonical little-endian order, and this requires a second byte swap. In such a situation, it is twice as fast to make a new pix in big-endian order, use it, and destroy it.
Definition at line 3010 of file pix2.c.
References pixClone(), and pixGetData().
l_ok pixEndianTwoByteSwap | ( | PIX * | pixs | ) |
[in] | pixs |
Notes: (1) This is used on little-endian platforms to swap the 2-byte entities within a 32-bit word. (2) This is equivalent to a full byte swap, as performed by pixEndianByteSwap(), followed by byte swaps in each of the 16-bit entities separately.
Definition at line 3239 of file pix2.c.
References pixGetData().
[in] | pixs |
Notes: (1) This is used on little-endian platforms to swap the 2-byte entities within a 32-bit word. (2) This is equivalent to a full byte swap, as performed by pixEndianByteSwap(), followed by byte swaps in each of the 16-bit entities separately. (3) Unlike pixEndianTwoByteSwap(), which swaps the shorts in-place, this returns a new pix (or a clone). We provide this to avoid having to swap twice in situations where the input pix must be restored to canonical little-endian order.
Definition at line 3185 of file pix2.c.
References pixClone(), and pixGetData().
l_ok pixFlipPixel | ( | PIX * | pix, |
l_int32 | x, | ||
l_int32 | y | ||
) |
[in] | pix | any depth, warning if colormapped |
[in] | x,y | pixel coords |
Notes: (1) If the point is outside the image, this returns an error (2), with 0 in pval. To avoid spamming output, it fails silently.
l_ok pixGetBlackOrWhiteVal | ( | PIX * | pixs, |
l_int32 | op, | ||
l_uint32 * | pval | ||
) |
[in] | pixs | all depths; cmap ok |
[in] | op | L_GET_BLACK_VAL, L_GET_WHITE_VAL |
[out] | pval | pixel value |
Notes: (1) Side effect. For a colormapped image, if the requested color is not present and there is room to add it in the cmap, it is added and the new index is returned. If there is no room, the index of the closest color in intensity is returned.
Definition at line 733 of file pix2.c.
References L_GET_BLACK_VAL, and L_GET_WHITE_VAL.
Referenced by pixAddBlackOrWhiteBorder().
l_ok pixGetPixel | ( | PIX * | pix, |
l_int32 | x, | ||
l_int32 | y, | ||
l_uint32 * | pval | ||
) |
[in] | pix | |
[in] | x,y | pixel coords |
[out] | pval | pixel value |
Notes: (1) This returns the value in the data array. If the pix is colormapped, it returns the colormap index, not the rgb value. (2) Because of the function overhead and the parameter checking, this is much slower than using the GET_DATA_*() macros directly. Speed on a 1 Mpixel RGB image, using a 3 GHz machine: * pixGet/pixSet: ~25 Mpix/sec * GET_DATA/SET_DATA: ~350 MPix/sec If speed is important and you're doing random access into the pix, use pixGetLinePtrs() and the array access macros. (3) If the point is outside the image, this returns an error (2), with 0 in pval. To avoid spamming output, it fails silently.
Definition at line 190 of file pix2.c.
References pixGetDimensions().
Referenced by getCutPathForHole(), kernelCreateFromPix(), localSearchForBackground(), pixColorFillFromSeed(), pixelIsOnColorBoundary(), pixGetRandomPixel(), pixGetVisitedNeighbors(), pixSearchBinaryMaze(), and pixSearchGrayMaze().
l_ok pixGetRandomPixel | ( | PIX * | pix, |
l_uint32 * | pval, | ||
l_int32 * | px, | ||
l_int32 * | py | ||
) |
[in] | pix | any depth; can be colormapped |
[out] | pval | [optional] pixel value |
[out] | px | [optional] x coordinate chosen; can be null |
[out] | py | [optional] y coordinate chosen; can be null |
Notes: (1) If the pix is colormapped, it returns the rgb value.
Definition at line 488 of file pix2.c.
References pixGetDimensions(), and pixGetPixel().
l_ok pixGetRasterData | ( | PIX * | pixs, |
l_uint8 ** | pdata, | ||
size_t * | pnbytes | ||
) |
[in] | pixs | 1, 8, 32 bpp |
[out] | pdata | raster data in memory |
[out] | pnbytes | number of bytes in data string |
Notes: (1) This returns the raster data as a byte string, padded to the byte. For 1 bpp, the first pixel is the MSbit in the first byte. For rgb, the bytes are in (rgb) order. This is the format required for flate encoding of pixels in a PostScript file.
Definition at line 3293 of file pix2.c.
References pixGetData(), pixGetDimensions(), and pixSetPadBits().
[in] | pixs | 32 bpp, or colormapped |
[in] | comp | one of {COLOR_RED, COLOR_GREEN, COLOR_BLUE, L_ALPHA_CHANNEL} |
Notes: (1) Three calls to this function generate the r, g and b 8 bpp component images. This is much faster than generating the three images in parallel, by extracting a src pixel and setting the pixels of each component image from it. The reason is there are many more cache misses when writing to three output images simultaneously.
Definition at line 2479 of file pix2.c.
Referenced by pixWarpStereoscopic().
[in] | pixs | colormapped |
[in] | comp | one of the set: {COLOR_RED, COLOR_GREEN, COLOR_BLUE} |
Notes: (1) In leptonica, we do not support alpha in colormaps.
l_ok pixGetRGBLine | ( | PIX * | pixs, |
l_int32 | row, | ||
l_uint8 * | bufr, | ||
l_uint8 * | bufg, | ||
l_uint8 * | bufb | ||
) |
[in] | pixs | 32 bpp |
[in] | row | |
[in] | bufr | array of red samples; size w bytes |
[in] | bufg | array of green samples; size w bytes |
[in] | bufb | array of blue samples; size w bytes |
Notes: (1) This puts rgb components from the input line in pixs into the given buffers.
l_ok pixGetRGBPixel | ( | PIX * | pix, |
l_int32 | x, | ||
l_int32 | y, | ||
l_int32 * | prval, | ||
l_int32 * | pgval, | ||
l_int32 * | pbval | ||
) |
[in] | pix | 32 bpp rgb, not colormapped |
[in] | x,y | pixel coords |
[out] | prval | [optional] red component |
[out] | pgval | [optional] green component |
[out] | pbval | [optional] blue component |
Notes: (1) If the point is outside the image, this returns an error (2), with 0 in pval. To avoid spamming output, it fails silently.
Definition at line 330 of file pix2.c.
References pixGetDimensions().
l_ok pixInferResolution | ( | PIX * | pix, |
l_float32 | longside, | ||
l_int32 * | pres | ||
) |
[in] | pix | |
[in] | longside | assumed max dimension, in inches |
[out] | pres | resolution (ppi) |
Notes: (1) This finds the resolution, assuming that the longest side of the image is longside. On error, returns 300 ppi. (2) This is useful for computing resolution for generating pdfs, when the images are scanned from pages of known size. There, longside is typically about 11.0.
Definition at line 3377 of file pix2.c.
References pixGetDimensions().
[in] | pixs | all depths; colormap ok |
[in] | npix | number to be removed from each of the 4 sides |
Definition at line 1972 of file pix2.c.
References pixClone(), and pixRemoveBorderGeneral().
[in] | pixs | all depths; colormap ok |
[in] | left,right,top,bot | number of pixels removed |
Definition at line 1993 of file pix2.c.
References pixCreate(), and pixGetDimensions().
Referenced by pixAffineSequential(), pixRemoveBorder(), and pixRemoveBorderToSize().
[in] | pixs | all depths; colormap ok |
[in] | wd | target width; use 0 if only removing from height |
[in] | hd | target height; use 0 if only removing from width |
Notes: (1) Removes pixels as evenly as possible from the sides of the image, leaving the central part. (2) Returns clone if no pixels requested removed, or the target sizes are larger than the image.
Definition at line 2046 of file pix2.c.
References pixClone(), pixGetDimensions(), and pixRemoveBorderGeneral().
l_ok pixSetAll | ( | PIX * | pix | ) |
[in] | pix | all depths; use cmapped with caution |
Notes: (1) Sets all data to 1. For 1 bpp, this is black; for grayscale or color, this is white. (2) Caution: for colormapped pix, this sets the pixel value to the maximum value supported by the colormap: 2^d - 1. However, this color may not be defined, because the colormap may not be full.
Definition at line 817 of file pix2.c.
Referenced by boxaCombineOverlaps(), boxaCombineOverlapsInPair(), boxaCompareRegions(), boxaDisplayTiled(), kernelDisplayInPix(), pixaDisplayTiled(), pixaDisplayTiledAndScaled(), pixaDisplayTiledInRows(), pixaSplitPix(), pixBlockrank(), pixErode(), pixHMT(), pixMakeFrameMask(), pixPadToCenterCentroid(), pixSearchGrayMaze(), selaAddCrossJunctions(), and selaAddTJunctions().
l_ok pixSetAllArbitrary | ( | PIX * | pix, |
l_uint32 | val | ||
) |
[in] | pix | all depths; use cmapped with caution |
[in] | val | value to set all pixels |
Notes: (1) Caution 1! For colormapped pix, val is used as an index into a colormap. Be sure that index refers to the intended color. If the color is not in the colormap, you should first add it and then call this function. (2) Caution 2! For 32 bpp pix, the interpretation of the LSB of val depends on whether spp == 3 (RGB) or spp == 4 (RGBA). For RGB, the LSB is ignored in image transformations. For RGBA, the LSB is interpreted as the alpha (transparency) component; full transparency has alpha == 0x0, whereas full opacity has alpha = 0xff. An RGBA image with full opacity behaves like an RGB image. (3) As an example of (2), suppose you want to initialize a 32 bpp pix with partial opacity, say 0xee337788. If the pix is 3 spp, the 0x88 alpha component will be ignored and may be changed in subsequent processing. However, if the pix is 4 spp, the alpha component will be retained and used. The function pixCreate(w, h, 32) makes an RGB image by default, and pixSetSpp(pix, 4) can be used to promote an RGB image to RGBA.
Definition at line 951 of file pix2.c.
Referenced by pixaccCreate(), pixaDisplayUnsplit(), pixaSplitPix(), pixDisplayColorArray(), pixInitAccumulate(), and recogShowAverageTemplates().
l_ok pixSetAllGray | ( | PIX * | pix, |
l_int32 | grayval | ||
) |
[in] | pix | all depths, cmap ok |
[in] | grayval | in range 0 ... 255 |
Notes: (1) N.B. For all images, grayval == 0 represents black and grayval == 255 represents white. (2) For depth < 8, we do our best to approximate the gray level. For 1 bpp images, any grayval < 128 is black; >= 128 is white. For 32 bpp images, each r,g,b component is set to grayval, and the alpha component is preserved. (3) If pix is colormapped, it adds the gray value, replicated in all components, to the colormap if it's not there and there is room. If the colormap is full, it finds the closest color in L2 distance of components. This index is written to all pixels.
Definition at line 859 of file pix2.c.
Referenced by pixApplyHorizDisparity(), and pixApplyVertDisparity().
l_ok pixSetBlackOrWhite | ( | PIX * | pixs, |
l_int32 | op | ||
) |
[in] | pixs | all depths; cmap ok |
[in] | op | L_SET_BLACK, L_SET_WHITE |
Notes: (1) Function for setting all pixels in an image to either black or white. (2) If pixs is colormapped, it adds black or white to the colormap if it's not there and there is room. If the colormap is full, it finds the closest color in intensity. This index is written to all pixels.
Definition at line 1021 of file pix2.c.
References L_SET_BLACK, and L_SET_WHITE.
Referenced by pixCopyWithBoxa(), pixQuadraticVShearSampled(), pixStretchHorizontalLI(), and pixStretchHorizontalSampled().
l_ok pixSetBorderRingVal | ( | PIX * | pixs, |
l_int32 | dist, | ||
l_uint32 | val | ||
) |
[in] | pixs | any depth; cmap OK |
[in] | dist | distance from outside; must be > 0; first ring is 1 |
[in] | val | value to set at each border pixel |
Notes: (1) The rings are single-pixel-wide rectangular sets of pixels at a given distance from the edge of the pix. This sets all pixels in a given ring to a value.
Definition at line 1667 of file pix2.c.
References pixGetDimensions(), and pixSetPixel().
l_ok pixSetBorderVal | ( | PIX * | pixs, |
l_int32 | left, | ||
l_int32 | right, | ||
l_int32 | top, | ||
l_int32 | bot, | ||
l_uint32 | val | ||
) |
[in] | pixs | 8, 16 or 32 bpp |
[in] | left,right,top,bot | amount to set |
[in] | val | value to set at each border pixel |
Notes: (1) The border region is defined to be the region in the image within a specific distance of each edge. Here, we allow the pixels within a specified distance of each edge to be set independently. This sets the pixels in the border region to the given input value. (2) For efficiency, use pixSetOrClearBorder() if you're setting the border to either black or white. (3) If d != 32, the input value should be masked off to the appropriate number of least significant bits. (4) The code is easily generalized for 2 or 4 bpp.
Definition at line 1563 of file pix2.c.
References pixGetData(), and pixGetDimensions().
Referenced by boxaDisplayTiled().
l_ok pixSetCmapPixel | ( | PIX * | pix, |
l_int32 | x, | ||
l_int32 | y, | ||
l_int32 | rval, | ||
l_int32 | gval, | ||
l_int32 | bval | ||
) |
[in] | pix | 2, 4 or 8 bpp, colormapped |
[in] | x,y | pixel coords |
[in] | rval | red component |
[in] | gval | green component |
[in] | bval | blue component |
Notes: (1) If the point is outside the image, this returns an error (2), and to avoid spamming output, it fails silently. (2) - If the color already exists, use it.
l_ok pixSetComponentArbitrary | ( | PIX * | pix, |
l_int32 | comp, | ||
l_int32 | val | ||
) |
[in] | pix | 32 bpp |
[in] | comp | COLOR_RED, COLOR_GREEN, COLOR_BLUE, L_ALPHA_CHANNEL |
[in] | val | value to set this component |
Notes: (1) For example, this can be used to set the alpha component to opaque: pixSetComponentArbitrary(pix, L_ALPHA_CHANNEL, 255)
[in] | pix | all depths, can be cmapped |
[in] | box | in which all pixels will be set |
Notes: (1) Sets all data in rect to 1. For 1 bpp, this is black; for grayscale or color, this is white. (2) Caution: for colormapped pix, this sets the pixel value to the maximum value supported by the colormap: 2^d - 1. However, this color may not be defined, because the colormap may not be full.
[in] | pix | all depths; can be cmapped |
[in] | box | in which all pixels will be set to val |
[in] | val | value to set all pixels |
Notes: (1) For colormapped pix, be sure the value is the intended one in the colormap. (2) Caution: for colormapped pix, this sets each pixel in the rect to the color at the index equal to val. Be sure that this index exists in the colormap and that it is the intended one!
Definition at line 1195 of file pix2.c.
References pixGetDimensions().
l_ok pixSetMirroredBorder | ( | PIX * | pixs, |
l_int32 | left, | ||
l_int32 | right, | ||
l_int32 | top, | ||
l_int32 | bot | ||
) |
[in] | pixs | all depths; colormap ok |
[in] | left,right,top,bot | number of pixels to set |
Notes: (1) This applies what is effectively mirror boundary conditions to a border region in the image. It is in-place. (2) This is useful for setting pixels near the border to a value representative of the near pixels to the interior. (3) The general pixRasterop() is used for an in-place operation here because there is no overlap between the src and dest rectangles.
Definition at line 1718 of file pix2.c.
References PIX_SRC, pixGetDimensions(), and pixRasterop().
l_ok pixSetOrClearBorder | ( | PIX * | pixs, |
l_int32 | left, | ||
l_int32 | right, | ||
l_int32 | top, | ||
l_int32 | bot, | ||
l_int32 | op | ||
) |
[in] | pixs | all depths |
[in] | left,right,top,bot | amount to set or clear |
[in] | op | operation PIX_SET or PIX_CLR |
Notes: (1) The border region is defined to be the region in the image within a specific distance of each edge. Here, we allow the pixels within a specified distance of each edge to be set independently. This either sets or clears all pixels in the border region. (2) For binary images, use PIX_SET for black and PIX_CLR for white. (3) For grayscale or color images, use PIX_SET for white and PIX_CLR for black.
Definition at line 1514 of file pix2.c.
References PIX_CLR, PIX_SET, pixGetDimensions(), and pixRasterop().
l_ok pixSetPadBits | ( | PIX * | pix, |
l_int32 | val | ||
) |
[in] | pix | 1, 2, 4, 8, 16, 32 bpp |
[in] | val | 0 or 1 |
Notes: (1) The pad bits are the bits that expand each scanline to a multiple of 32 bits. They are usually not used in image processing operations. When boundary conditions are important, as in seedfill, they must be set properly. (2) This sets the value of the pad bits (if any) in the last 32-bit word in each scanline. (3) For 32 bpp pix, there are no pad bits, so this is a no-op. (4) When writing formatted output, such as tiff, png or jpeg, the pad bits have no effect on the raster image that is generated by reading back from the file. However, in some cases, the compressed file itself will depend on the pad bits. This is seen, for example, in Windows with 2 and 4 bpp tiff-compressed images that have pad bits on each scanline. It is sometimes convenient to use a golden file with a byte-by-byte check to verify invariance. Consequently, and because setting the pad bits is cheap, the pad bits are set to 0 before writing these compressed files.
Definition at line 1382 of file pix2.c.
References pixGetData(), and pixGetDimensions().
Referenced by pixCentroid(), pixGetRasterData(), and pixWriteToTiffStream().
l_ok pixSetPadBitsBand | ( | PIX * | pix, |
l_int32 | by, | ||
l_int32 | bh, | ||
l_int32 | val | ||
) |
[in] | pix | 1, 2, 4, 8, 16, 32 bpp |
[in] | by | starting y value of band |
[in] | bh | height of band |
[in] | val | 0 or 1 |
Notes: (1) The pad bits are the bits that expand each scanline to a multiple of 32 bits. They are usually not used in image processing operations. When boundary conditions are important, as in seedfill, they must be set properly. (2) This sets the value of the pad bits (if any) in the last 32-bit word in each scanline, within the specified band of raster lines. (3) For 32 bpp pix, there are no pad bits, so this is a no-op.
Definition at line 1442 of file pix2.c.
References pixGetData(), and pixGetDimensions().
l_ok pixSetPixel | ( | PIX * | pix, |
l_int32 | x, | ||
l_int32 | y, | ||
l_uint32 | val | ||
) |
[in] | pix | |
[in] | x,y | pixel coords |
[in] | val | value to be inserted |
Notes: (1) Warning: the input value is not checked for overflow with respect the the depth of pix, and the sign bit (if any) is ignored. * For d == 1, val > 0 sets the bit on. * For d == 2, 4, 8 and 16, val is masked to the maximum allowable pixel value, and any (invalid) higher order bits are discarded. (2) See pixGetPixel() for information on performance. (3) If the point is outside the image, this returns an error (2), with 0 in pval. To avoid spamming output, it fails silently.
Definition at line 263 of file pix2.c.
References pixGetData(), and pixGetDimensions().
Referenced by ccbaDisplayBorder(), ccbaDisplayImage1(), ccbaDisplayImage2(), ccbaDisplaySPBorder(), identifyWatershedBasin(), kernelDisplayInPix(), makeColorfillTestData(), pixDisplayPtaa(), pixGenerateFromPta(), pixMakeGamutRGB(), pixSetBorderRingVal(), selaAddCrossJunctions(), and selaAddTJunctions().
[in] | pixd | 32 bpp |
[in] | pixs | 8 bpp |
[in] | comp | one of the set: {COLOR_RED, COLOR_GREEN, COLOR_BLUE, L_ALPHA_CHANNEL} |
Notes: (1) This places the 8 bpp pixel in pixs into the specified component (properly interleaved) in pixd, (2) The two images are registered to the UL corner; the sizes need not be the same, but a warning is issued if they differ.
l_ok pixSetRGBPixel | ( | PIX * | pix, |
l_int32 | x, | ||
l_int32 | y, | ||
l_int32 | rval, | ||
l_int32 | gval, | ||
l_int32 | bval | ||
) |
[in] | pix | 32 bpp rgb |
[in] | x,y | pixel coords |
[in] | rval | red component |
[in] | gval | green component |
[in] | bval | blue component |
Notes: (1) If the point is outside the image, this returns an error (2), and to avoid spamming output, it fails silently.
Definition at line 382 of file pix2.c.
References pixGetDimensions().
Referenced by displayHSVColorRange().
l_uint8** pixSetupByteProcessing | ( | PIX * | pix, |
l_int32 * | pw, | ||
l_int32 * | ph | ||
) |
[in] | pix | 8 bpp, no colormap |
[out] | pw | [optional] width |
[out] | ph | [optional] height |
Notes: (1) This is a simple helper for processing 8 bpp images with direct byte access. It can swap byte order within each word. (2) After processing, you must call pixCleanupByteProcessing(), which frees the lineptr array and restores byte order. (3) Usage: l_uint8 **lineptrs = pixSetupByteProcessing(pix, &w, &h); for (i = 0; i < h; i++) { l_uint8 *line = lineptrs[i]; for (j = 0; j < w; j++) { val = line[j]; ... } } pixCleanupByteProcessing(pix, lineptrs);
[in] | pixd | 32 bpp |
[in] | pixs | 32 bpp |
[in] | shiftx,shifty |
l_ok setLineDataVal | ( | l_uint32 * | line, |
l_int32 | j, | ||
l_int32 | d, | ||
l_uint32 | val | ||
) |
[in] | line | ptr to first word in raster line data |
[in] | j | index of pixels into the raster line |
[in] | d | depth of the pixel |
[in] | val | pixel value to be set |
Notes: (1) This is a convenience function to set a pixel value in a raster line where the depth of the image can have different values (1, 2, 4, 8, 16 or 32).
Definition at line 2952 of file pix2.c.
References SET_DATA_BIT_VAL, SET_DATA_BYTE, SET_DATA_DIBIT, SET_DATA_QBIT, and SET_DATA_TWO_BYTES.
void setPixelLow | ( | l_uint32 * | line, |
l_int32 | x, | ||
l_int32 | depth, | ||
l_uint32 | val | ||
) |
[in] | line | ptr to beginning of line, |
[in] | x | pixel location in line |
[in] | depth | bpp |
[in] | val | to be inserted |
Notes: (1) Caution: input variables are not checked!
Definition at line 679 of file pix2.c.
References CLEAR_DATA_BIT, lept_stderr(), SET_DATA_BIT, SET_DATA_BYTE, SET_DATA_DIBIT, SET_DATA_QBIT, and SET_DATA_TWO_BYTES.
|
static |