 |
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.
Macros | |
| #define | DEBUG_UNROLLING 0 |
Functions | |
| static void | ditherToBinaryLow (l_uint32 *datad, l_int32 w, l_int32 h, l_int32 wpld, l_uint32 *datas, l_int32 wpls, l_uint32 *bufs1, l_uint32 *bufs2, l_int32 lowerclip, l_int32 upperclip) |
| static void | thresholdToBinaryLow (l_uint32 *datad, l_int32 w, l_int32 h, l_int32 wpld, l_uint32 *datas, l_int32 d, l_int32 wpls, l_int32 thresh) |
| static void | ditherTo2bppLow (l_uint32 *datad, l_int32 w, l_int32 h, l_int32 wpld, l_uint32 *datas, l_int32 wpls, l_uint32 *bufs1, l_uint32 *bufs2, l_int32 *tabval, l_int32 *tab38, l_int32 *tab14) |
| static void | ditherTo2bppLineLow (l_uint32 *lined, l_int32 w, l_uint32 *bufs1, l_uint32 *bufs2, l_int32 *tabval, l_int32 *tab38, l_int32 *tab14, l_int32 lastlineflag) |
| static l_int32 | make8To2DitherTables (l_int32 **ptabval, l_int32 **ptab38, l_int32 **ptab14, l_int32 cliptoblack, l_int32 cliptowhite) |
| static void | thresholdTo2bppLow (l_uint32 *datad, l_int32 h, l_int32 wpld, l_uint32 *datas, l_int32 wpls, l_int32 *tab) |
| static void | thresholdTo4bppLow (l_uint32 *datad, l_int32 h, l_int32 wpld, l_uint32 *datas, l_int32 wpls, l_int32 *tab) |
| static l_int32 * | makeGrayQuantTargetTable (l_int32 nlevels, l_int32 depth) |
| static l_int32 | makeGrayQuantColormapArb (PIX *pixs, l_int32 *tab, l_int32 outdepth, PIXCMAP **pcmap) |
| static l_int32 | numaFillCmapFromHisto (NUMA *na, PIXCMAP *cmap, l_float32 minfract, l_int32 maxsize, l_int32 **plut) |
| PIX * | pixDitherToBinary (PIX *pixs) |
| PIX * | pixDitherToBinarySpec (PIX *pixs, l_int32 lowerclip, l_int32 upperclip) |
| void | ditherToBinaryLineLow (l_uint32 *lined, l_int32 w, l_uint32 *bufs1, l_uint32 *bufs2, l_int32 lowerclip, l_int32 upperclip, l_int32 lastlineflag) |
| PIX * | pixThresholdToBinary (PIX *pixs, l_int32 thresh) |
| void | thresholdToBinaryLineLow (l_uint32 *lined, l_int32 w, l_uint32 *lines, l_int32 d, l_int32 thresh) |
| PIX * | pixVarThresholdToBinary (PIX *pixs, PIX *pixg) |
| PIX * | pixAdaptThresholdToBinary (PIX *pixs, PIX *pixm, l_float32 gamma) |
| PIX * | pixAdaptThresholdToBinaryGen (PIX *pixs, PIX *pixm, l_float32 gamma, l_int32 blackval, l_int32 whiteval, l_int32 thresh) |
| PIX * | pixGenerateMaskByValue (PIX *pixs, l_int32 val, l_int32 usecmap) |
| PIX * | pixGenerateMaskByBand (PIX *pixs, l_int32 lower, l_int32 upper, l_int32 inband, l_int32 usecmap) |
| PIX * | pixDitherTo2bpp (PIX *pixs, l_int32 cmapflag) |
| PIX * | pixDitherTo2bppSpec (PIX *pixs, l_int32 lowerclip, l_int32 upperclip, l_int32 cmapflag) |
| PIX * | pixThresholdTo2bpp (PIX *pixs, l_int32 nlevels, l_int32 cmapflag) |
| PIX * | pixThresholdTo4bpp (PIX *pixs, l_int32 nlevels, l_int32 cmapflag) |
| PIX * | pixThresholdOn8bpp (PIX *pixs, l_int32 nlevels, l_int32 cmapflag) |
| PIX * | pixThresholdGrayArb (PIX *pixs, const char *edgevals, l_int32 outdepth, l_int32 use_average, l_int32 setblack, l_int32 setwhite) |
| l_int32 * | makeGrayQuantIndexTable (l_int32 nlevels) |
| l_ok | makeGrayQuantTableArb (NUMA *na, l_int32 outdepth, l_int32 **ptab, PIXCMAP **pcmap) |
| PIX * | pixGenerateMaskByBand32 (PIX *pixs, l_uint32 refval, l_int32 delm, l_int32 delp, l_float32 fractm, l_float32 fractp) |
| PIX * | pixGenerateMaskByDiscr32 (PIX *pixs, l_uint32 refval1, l_uint32 refval2, l_int32 distflag) |
| PIX * | pixGrayQuantFromHisto (PIX *pixd, PIX *pixs, PIX *pixm, l_float32 minfract, l_int32 maxsize) |
| PIX * | pixGrayQuantFromCmap (PIX *pixs, PIXCMAP *cmap, l_int32 mindepth) |
Thresholding from 8 bpp to 1 bpp
Floyd-Steinberg dithering to binary
PIX *pixDitherToBinary()
PIX *pixDitherToBinarySpec()
static void ditherToBinaryLow()
void ditherToBinaryLineLow()
Simple (pixelwise) binarization with fixed threshold
PIX *pixThresholdToBinary()
static void thresholdToBinaryLow()
void thresholdToBinaryLineLow()
Binarization with variable threshold
PIX *pixVarThresholdToBinary()
Binarization by adaptive mapping
PIX *pixAdaptThresholdToBinary()
PIX *pixAdaptThresholdToBinaryGen()
Generate a binary mask from pixels of particular values
PIX *pixGenerateMaskByValue()
PIX *pixGenerateMaskByBand()
Thresholding from 8 bpp to 2 bpp
Floyd-Steinberg-like dithering to 2 bpp
PIX *pixDitherTo2bpp()
PIX *pixDitherTo2bppSpec()
static void ditherTo2bppLow()
static void ditherTo2bppLineLow()
static l_int32 make8To2DitherTables()
Simple (pixelwise) thresholding to 2 bpp with optional cmap
PIX *pixThresholdTo2bpp()
static void thresholdTo2bppLow()
Simple (pixelwise) thresholding from 8 bpp to 4 bpp
PIX *pixThresholdTo4bpp()
static void thresholdTo4bppLow()
Simple (pixelwise) quantization on 8 bpp grayscale
PIX *pixThresholdOn8bpp()
Arbitrary (pixelwise) thresholding from 8 bpp to 2, 4 or 8 bpp
PIX *pixThresholdGrayArb()
Quantization tables for linear thresholds of grayscale images
l_int32 *makeGrayQuantIndexTable()
static l_int32 *makeGrayQuantTargetTable()
Quantization table for arbitrary thresholding of grayscale images
l_int32 makeGrayQuantTableArb()
static l_int32 makeGrayQuantColormapArb()
Thresholding from 32 bpp rgb to 1 bpp
(really color quantization, but it's better placed in this file)
PIX *pixGenerateMaskByBand32()
PIX *pixGenerateMaskByDiscr32()
Histogram-based grayscale quantization
PIX *pixGrayQuantFromHisto()
static l_int32 numaFillCmapFromHisto()
Color quantize grayscale image using existing colormap
PIX *pixGrayQuantFromCmap()
Definition in file grayquant.c.
| #define DEBUG_UNROLLING 0 |
Definition at line 138 of file grayquant.c.
|
static |
| [in] | lined | ptr to beginning of dest line |
| [in] | w | width of image in pixels |
| [in] | bufs1 | buffer of current source line |
| [in] | bufs2 | buffer of next source line |
| [in] | tabval | value to assign for current pixel |
| [in] | tab38 | excess value to give to neighboring 3/8 pixels |
| [in] | tab14 | excess value to give to neighboring 1/4 pixel |
| [in] | lastlineflag | 0 if not last dest line, 1 if last dest line |
Dispatches error diffusion dithering for a single line of the image. If lastlineflag == 0, both source buffers are used; otherwise, only bufs1 is used. We use source buffers because the error is propagated into them, and we don't want to change the input src image.
We break dithering out line by line to make it easier to combine functions like interpolative scaling and error diffusion dithering, as such a combination of operations obviates the need to generate a 2x grayscale image as an intermediary.
Definition at line 1175 of file grayquant.c.
References GET_DATA_BYTE, SET_DATA_BYTE, and SET_DATA_DIBIT.
Referenced by ditherTo2bppLow().
|
static |
Low-level function for doing Floyd-Steinberg error diffusion dithering from 8 bpp (datas) to 2 bpp (datad). Two source line buffers, bufs1 and bufs2, are provided, along with three 256-entry lookup tables: tabval gives the output pixel value, tab38 gives the extra (plus or minus) transferred to the pixels directly to the left and below, and tab14 gives the extra transferred to the diagonal below. The choice of 3/8 and 1/4 is traditional but arbitrary when you use a lookup table; the only constraint is that the sum is 1. See other comments below and in grayquant.c.
Definition at line 1117 of file grayquant.c.
References ditherTo2bppLineLow().
Referenced by pixDitherTo2bppSpec().
| void ditherToBinaryLineLow | ( | l_uint32 * | lined, |
| l_int32 | w, | ||
| l_uint32 * | bufs1, | ||
| l_uint32 * | bufs2, | ||
| l_int32 | lowerclip, | ||
| l_int32 | upperclip, | ||
| l_int32 | lastlineflag ) |
| [in] | lined | ptr to beginning of dest line |
| [in] | w | width of image in pixels |
| [in] | bufs1 | buffer of current source line |
| [in] | bufs2 | buffer of next source line |
| [in] | lowerclip | lower clip distance to black |
| [in] | upperclip | upper clip distance to white |
| [in] | lastlineflag | 0 if not last dest line, 1 if last dest line |
Dispatches FS error diffusion dithering for a single line of the image. If lastlineflag == 0, both source buffers are used; otherwise, only bufs1 is used. We use source buffers because the error is propagated into them, and we don't want to change the input src image.
We break dithering out line by line to make it easier to combine functions like interpolative scaling and error diffusion dithering, as such a combination of operations obviates the need to generate a 2x grayscale image as an intermediary.
Definition at line 322 of file grayquant.c.
References GET_DATA_BYTE, SET_DATA_BIT, and SET_DATA_BYTE.
Referenced by ditherToBinaryLow().
|
static |
See comments in pixDitherToBinary() in binarize.c
Definition at line 266 of file grayquant.c.
References ditherToBinaryLineLow().
Referenced by pixDitherToBinarySpec().
|
static |
| [out] | ptabval | value assigned to output pixel; 0, 1, 2 or 3 |
| [out] | ptab38 | amount propagated to pixels left and below |
| [out] | ptab14 | amount propagated to pixel to left and down |
| [in] | cliptoblack | values near 0 where the excess is not propagated |
| [in] | cliptowhite | values near 255 where the deficit is not propagated |
Definition at line 1253 of file grayquant.c.
Referenced by pixDitherTo2bppSpec().
|
static |
| [in] | pixs | 8 bpp |
| [in] | tab | table mapping input gray level to cmap index |
| [in] | outdepth | of colormap: 1, 2, 4 or 8 |
| [out] | pcmap | colormap |
Notes:
(1) The table is a 256-entry inverse colormap: it maps input gray
level to colormap index (the bin number). It is computed
using makeGrayQuantTableArb().
(2) The colormap generated here has quantized values at the
average gray value of the pixels that are in each bin.
(3) Returns an error if there are not enough levels in the
output colormap for the number of bins. The number
of bins must not exceed 2^outdepth.
Definition at line 1992 of file grayquant.c.
References GET_DATA_BYTE.
Referenced by pixThresholdGrayArb().
| l_int32 * makeGrayQuantIndexTable | ( | l_int32 | nlevels | ) |
| [in] | nlevels | number of output levels |
Notes:
(1) 'nlevels' is some number between 2 and 256 (typically 8 or less).
(2) The table is typically used for quantizing 2, 4 and 8 bpp
grayscale src pix, and generating a colormapped dest pix.
Definition at line 1820 of file grayquant.c.
Referenced by pixThresholdOn8bpp(), pixThresholdTo2bpp(), and pixThresholdTo4bpp().
| [in] | na | numa of bin boundaries |
| [in] | outdepth | of colormap: 1, 2, 4 or 8 |
| [out] | ptab | table mapping input gray level to cmap index |
| [out] | pcmap | colormap |
Notes:
(1) The number of bins is the count of na + 1.
(2) The bin boundaries in na must be sorted in increasing order.
(3) The table is an inverse colormap: it maps input gray level
to colormap index (the bin number).
(4) The colormap generated here has quantized values at the
center of each bin. If you want to use the average gray
value of pixels within the bin, discard the colormap and
compute it using makeGrayQuantColormapArb().
(5) Returns an error if there are not enough levels in the
output colormap for the number of bins. The number
of bins must not exceed 2^outdepth.
Definition at line 1922 of file grayquant.c.
Referenced by pixThresholdGrayArb().
|
static |
| [in] | nlevels | number of output levels |
| [in] | depth | of dest pix, in bpp; 2, 4 or 8 bpp |
Notes:
(1) nlevels is some number between 2 and 2^(depth)
(2) The table is used in two similar ways:
~ for 8 bpp, it quantizes to a given number of target levels
~ for 2 and 4 bpp, it thresholds to appropriate target values
that will use the full dynamic range of the dest pix.
(3) For depth = 8, the number of thresholds chosen is
('nlevels' - 1), and the 'nlevels' values stored in the
table are at the two at the extreme ends, (0, 255), plus
plus ('nlevels' - 2) values chosen at equal intervals between.
For example, for depth = 8 and 'nlevels' = 3, the two
threshold values are 3f and bf, and the three target pixel
values are 0, 7f and ff.
(4) For depth < 8, we ignore nlevels, and always use the maximum
number of levels, which is 2^(depth).
If you want nlevels < the maximum number, you should always
use a colormap.
Definition at line 1869 of file grayquant.c.
Referenced by pixThresholdOn8bpp(), pixThresholdTo2bpp(), and pixThresholdTo4bpp().
|
static |
| [in] | na | histogram of gray values |
| [in] | cmap | 8 bpp cmap, possibly initialized with color value |
| [in] | minfract | minimum fraction of pixels in a set of adjacent histo bins that causes the set to be automatically set aside as a color in the colormap; must be at least 0.01 |
| [in] | maxsize | maximum number of adjacent bins allowed to represent a color, regardless of the population of pixels in the bins; must be at least 2 |
| [out] | plut | lookup table from gray value to colormap index |
Notes:
(1) This static function must be called from pixGrayQuantFromHisto()
Definition at line 2433 of file grayquant.c.
Referenced by pixGrayQuantFromHisto().
| [in] | pixs | 8 bpp |
| [in] | pixm | [optional] 1 bpp image mask; can be null |
| [in] | gamma | gamma correction; must be > 0.0; typically ~1.0 |
Notes:
(1) This is a simple convenience function for doing adaptive
thresholding on a grayscale image with variable background.
It uses default parameters appropriate for typical text images.
Other high-level adaptive thresholding functions are
pixConvertTo1Adaptive() and pixCleanImage().
(2) pixm is a 1 bpp mask over "image" regions, which are not
expected to have a white background. The mask inhibits
background finding under the fg pixels of the mask. For
images with both text and image, the image regions would
be binarized (or quantized) by a different set of operations.
(3) As gamma is increased, the foreground pixels are reduced.
(4) Under the covers: The default background value for normalization
is 200, so we choose 170 for 'maxval' in pixGammaTRC. Likewise,
the default foreground threshold for normalization is 60,
so we choose 50 for 'minval' in pixGammaTRC. Because
170 was mapped to 255, choosing 200 for the threshold is
quite safe for avoiding speckle noise from the background.
Definition at line 722 of file grayquant.c.
References pixAdaptThresholdToBinaryGen().
| PIX * pixAdaptThresholdToBinaryGen | ( | PIX * | pixs, |
| PIX * | pixm, | ||
| l_float32 | gamma, | ||
| l_int32 | blackval, | ||
| l_int32 | whiteval, | ||
| l_int32 | thresh ) |
pixAdaptThresholdToBinaryGen()
| [in] | pixs | 8 bpp |
| [in] | pixm | [optional] 1 bpp image mask; can be null |
| [in] | gamma | gamma correction; must be > 0.0; typically ~1.0 |
| [in] | blackval | dark value to set to black (0) |
| [in] | whiteval | light value to set to white (255) |
| [in] | thresh | final threshold for binarization |
Notes:
(1) This is a convenience function for doing adaptive thresholding
on a grayscale image with variable background. Also see notes
in pixAdaptThresholdToBinary().
(2) Reducing gamma increases the foreground (text) pixels.
Use a low value (e.g., 0.5) for images with light text.
(3) For normal images, see default args in pixAdaptThresholdToBinary().
For images with very light text, these values are appropriate:
gamma ~0.5
blackval ~70
whiteval ~190
thresh ~200
Definition at line 760 of file grayquant.c.
References pixBackgroundNormSimple(), and pixThresholdToBinary().
Referenced by pixAdaptThresholdToBinary().
| [in] | pixs | 8 bpp |
| [in] | cmapflag | 1 to generate a colormap |
An analog of the Floyd-Steinberg error diffusion dithering algorithm is used to "dibitize" an 8 bpp grayscale image to 2 bpp, using equally spaced gray values of 0, 85, 170, and 255, which are served by thresholds of 43, 128 and 213. If cmapflag == 1, the colormap values are set to 0, 85, 170 and 255. If a pixel has a value between 0 and 42, it is dibitized to 0, and the excess above 0 is added to the three neighboring pixels, in the fractions 3/8 to i, j+1, 3/8 to i+1, j) and 1/4 to (i+1, j+1, truncating to 255 if necessary. If a pixel has a value between 43 and 127, it is dibitized to 1, and the excess above 85 is added to the three neighboring pixels as before. If the value is below 85, the excess is subtracted. With a value between 128 and 212, it is dibitized to 2, with the excess on either side of 170 distributed as before. Finally, with a value between 213 and 255, it is dibitized to 3, with the excess below 255 subtracted from the neighbors. We always truncate to 0 or 255. The details can be seen in the lookup table generation.
This function differs from straight dithering in that it allows clipping of grayscale to 0 or 255 if the values are sufficiently close, without distribution of the excess. This uses default values from pix.h to specify the range of lower and upper values near 0 and 255, rsp that are clipped to black and white without propagating the excess. Not propagating the excess has the effect of reducing the snake patterns in parts of the image that are nearly black or white; however, it also prevents any attempt to reproduce gray for those values.
The implementation uses 3 lookup tables for simplicity, and a pair of line buffers to avoid modifying pixs.
Definition at line 1004 of file grayquant.c.
References DEFAULT_CLIP_LOWER_2, DEFAULT_CLIP_UPPER_2, and pixDitherTo2bppSpec().
| [in] | pixs | 8 bpp |
| [in] | lowerclip | lower clip distance to black; use 0 for default |
| [in] | upperclip | upper clip distance to white; use 0 for default |
| [in] | cmapflag | 1 to generate a colormap |
Notes:
(1) See comments above in pixDitherTo2bpp() for details.
(2) The input parameters lowerclip and upperclip specify the range
of lower and upper values (near 0 and 255, rsp) that are
clipped to black and white without propagating the excess.
For that reason, lowerclip and upperclip should be small numbers.
Definition at line 1036 of file grayquant.c.
References ditherTo2bppLow(), make8To2DitherTables(), and REMOVE_CMAP_TO_GRAYSCALE.
Referenced by pixDitherTo2bpp().
| [in] | pixs |
The Floyd-Steinberg error diffusion dithering algorithm binarizes an 8 bpp grayscale image to a threshold of 128. If a pixel has a value above 127, it is binarized to white and the excess below 255 is subtracted from three neighboring pixels in the fractions 3/8 to i, j+1, 3/8 to i+1, j) and 1/4 to (i+1,j+1, truncating to 0 if necessary. Likewise, if it the pixel has a value below 128, it is binarized to black and the excess above 0 is added to the neighboring pixels, truncating to 255 if necessary.
This function differs from straight dithering in that it allows clipping of grayscale to 0 or 255 if the values are sufficiently close, without distribution of the excess. This uses default values to specify the range of lower and upper values near 0 and 255, rsp that are clipped to black and white without propagating the excess. Not propagating the excess has the effect of reducing the snake patterns in parts of the image that are nearly black or white; however, it also prevents the attempt to reproduce gray for those values.
The implementation is straightforward. It uses a pair of line buffers to avoid changing pixs. It is about the same speed as pixDitherToBinaryLUT(), which uses three LUTs.
Definition at line 175 of file grayquant.c.
References DEFAULT_CLIP_LOWER_1, DEFAULT_CLIP_UPPER_1, and pixDitherToBinarySpec().
| [in] | pixs | |
| [in] | lowerclip | lower clip distance to black; use 0 for default |
| [in] | upperclip | upper clip distance to white; use 0 for default |
Notes:
(1) See comments above in pixDitherToBinary() for details.
(2) The input parameters lowerclip and upperclip specify the range
of lower and upper values (near 0 and 255, rsp) that are
clipped to black and white without propagating the excess.
For that reason, lowerclip and upperclip should be small numbers.
Definition at line 205 of file grayquant.c.
References ditherToBinaryLow(), and REMOVE_CMAP_TO_GRAYSCALE.
Referenced by pixDitherToBinary().
| PIX * pixGenerateMaskByBand | ( | PIX * | pixs, |
| l_int32 | lower, | ||
| l_int32 | upper, | ||
| l_int32 | inband, | ||
| l_int32 | usecmap ) |
| [in] | pixs | 2, 4 or 8 bpp, or colormapped |
| [in] | lower,upper | two pixel values from which a range, either between (inband) or outside of (!inband), determines which pixels in pixs cause us to set a 1 in the dest mask |
| [in] | inband | 1 for finding pixels in [lower, upper]; 0 for finding pixels in [0, lower) union (upper, 255] |
| [in] | usecmap | 1 to retain cmap values; 0 to convert to gray |
Notes:
(1) Generates a 1 bpp mask pixd, the same size as pixs, where
the fg pixels in the mask are those either within the specified
band (for inband == 1) or outside the specified band
(for inband == 0).
(2) If pixs is colormapped, usecmap determines if the colormap
values are used, or if the colormap is removed to gray and
the gray values are used. For the latter, it generates
an approximate grayscale value for each pixel, and then looks
for gray pixels with the value val.
Definition at line 893 of file grayquant.c.
References GET_DATA_BYTE, GET_DATA_DIBIT, GET_DATA_QBIT, REMOVE_CMAP_TO_GRAYSCALE, and SET_DATA_BIT.
| PIX * pixGenerateMaskByBand32 | ( | PIX * | pixs, |
| l_uint32 | refval, | ||
| l_int32 | delm, | ||
| l_int32 | delp, | ||
| l_float32 | fractm, | ||
| l_float32 | fractp ) |
| [in] | pixs | 32 bpp |
| [in] | refval | reference rgb value |
| [in] | delm | max amount below the ref value for any component |
| [in] | delp | max amount above the ref value for any component |
| [in] | fractm | fractional amount below ref value for all components |
| [in] | fractp | fractional amount above ref value for all components |
Notes:
(1) Generates a 1 bpp mask pixd, the same size as pixs, where
the fg pixels in the mask within a band of rgb values
surrounding refval. The band can be chosen in two ways
for each component:
(a) Use (delm, delp) to specify how many levels down and up
(b) Use (fractm, fractp) to specify the fractional
distance toward 0 and 255, respectively.
Note that delm and delp must be in [0 ... 255], whereas
fractm and fractp must be in [0.0 - 1.0].
(2) Either (delm, delp) or (fractm, fractp) can be used.
Set each value in the other pair to 0.
Definition at line 2095 of file grayquant.c.
References SET_DATA_BIT.
| [in] | pixs | 32 bpp |
| [in] | refval1 | reference rgb value |
| [in] | refval2 | reference rgb value |
| [in] | distflag | L_MANHATTAN_DISTANCE, L_EUCLIDEAN_DISTANCE |
Notes:
(1) Generates a 1 bpp mask pixd, the same size as pixs, where
the fg pixels in the mask are those where the pixel in pixs
is "closer" to refval1 than to refval2.
(2) "Closer" can be defined in several ways, such as:
~ manhattan distance (L1)
~ euclidean distance (L2)
~ majority vote of the individual components
Here, we have a choice of L1 or L2.
Definition at line 2191 of file grayquant.c.
References L_EUCLIDEAN_DISTANCE, L_MANHATTAN_DISTANCE, and SET_DATA_BIT.
| [in] | pixs | 2, 4 or 8 bpp, or colormapped |
| [in] | val | of pixels for which we set 1 in dest |
| [in] | usecmap | 1 to retain cmap values; 0 to convert to gray |
Notes:
(1) val is the pixel value that we are selecting. It can be
either a gray value or a colormap index.
(2) If pixs is colormapped, usecmap determines if the colormap
index values are used, or if the colormap is removed to gray and
the gray values are used. For the latter, it generates
an approximate grayscale value for each pixel, and then looks
for gray pixels with the value val.
Definition at line 804 of file grayquant.c.
References GET_DATA_BYTE, GET_DATA_DIBIT, GET_DATA_QBIT, REMOVE_CMAP_TO_GRAYSCALE, and SET_DATA_BIT.
| [in] | pixs | 8 bpp grayscale without cmap |
| [in] | cmap | to quantize to; of dest pix |
| [in] | mindepth | minimum depth of pixd: can be 2, 4 or 8 bpp |
Notes:
(1) In use, pixs is an 8 bpp grayscale image without a colormap.
If there is an existing colormap, a warning is issued and
a copy of the input pixs is returned.
Definition at line 2522 of file grayquant.c.
References GET_DATA_BYTE, SET_DATA_BYTE, SET_DATA_DIBIT, and SET_DATA_QBIT.
| PIX * pixGrayQuantFromHisto | ( | PIX * | pixd, |
| PIX * | pixs, | ||
| PIX * | pixm, | ||
| l_float32 | minfract, | ||
| l_int32 | maxsize ) |
| [in] | pixd | [optional] quantized pix with cmap; can be null |
| [in] | pixs | 8 bpp gray input pix; not cmapped |
| [in] | pixm | [optional] mask over pixels in pixs to quantize |
| [in] | minfract | minimum fraction of pixels in a set of adjacent histo bins that causes the set to be automatically set aside as a color in the colormap; must be at least 0.01 |
| [in] | maxsize | maximum number of adjacent bins allowed to represent a color, regardless of the population of pixels in the bins; must be at least 2 |
Notes:
(1) This is useful for quantizing images with relatively few
colors, but which may have both color and gray pixels.
If there are color pixels, it is assumed that an input
rgb image has been color quantized first so that:
~ pixd has a colormap describing the color pixels
~ pixm is a mask over the non-color pixels in pixd
~ the colormap in pixd, and the color pixels in pixd,
have been repacked to go from 0 to n-1 (n colors)
If there are no color pixels, pixd and pixm are both null,
and all pixels in pixs are quantized to gray.
(2) A 256-entry histogram is built of the gray values in pixs.
If pixm exists, the pixels contributing to the histogram are
restricted to the fg of pixm. A colormap and LUT are generated
from this histogram. We break up the array into a set
of intervals, each one constituting a color in the colormap:
An interval is identified by summing histogram bins until
either the sum equals or exceeds the minfract of the total
number of pixels, or the span itself equals or exceeds maxsize.
The color of each bin is always an average of the pixels
that constitute it.
(3) Note that we do not specify the number of gray colors in
the colormap. Instead, we specify two parameters that
describe the accuracy of the color assignments; this and
the actual image determine the number of resulting colors.
(4) If a mask exists and it is not the same size as pixs, make
a new mask the same size as pixs, with the original mask
aligned at the UL corners. Set all additional pixels
in the (larger) new mask set to 1, causing those pixels
in pixd to be set as gray.
(5) We estimate the total number of colors (color plus gray);
if it exceeds 255, return null.
Definition at line 2303 of file grayquant.c.
References GET_DATA_BIT, GET_DATA_BYTE, numaFillCmapFromHisto(), PIX_SET, PIX_SRC, and SET_DATA_BYTE.
| PIX * pixThresholdGrayArb | ( | PIX * | pixs, |
| const char * | edgevals, | ||
| l_int32 | outdepth, | ||
| l_int32 | use_average, | ||
| l_int32 | setblack, | ||
| l_int32 | setwhite ) |
| [in] | pixs | 8 bpp grayscale; can have colormap |
| [in] | edgevals | string giving edge value of each bin |
| [in] | outdepth | 0, 2, 4 or 8 bpp; 0 is default for min depth |
| [in] | use_average | 1 if use the average pixel value in colormap |
| [in] | setblack | 1 if darkest color is set to black |
| [in] | setwhite | 1 if lightest color is set to white |
Notes:
(1) This function allows exact specification of the quantization bins.
The string edgevals is a space-separated set of values
specifying the dividing points between output quantization bins.
These threshold values are assigned to the bin with higher
values, so that each of them is the smallest value in their bin.
(2) The output image (pixd) depth is specified by outdepth. The
number of bins is the number of edgevals + 1. The
relation between outdepth and the number of bins is:
outdepth = 2 nbins <= 4
outdepth = 4 nbins <= 16
outdepth = 8 nbins <= 256
With outdepth == 0, the minimum required depth for the
given number of bins is used.
The output pixd has a colormap.
(3) The last 3 args determine the specific values that go into
the colormap.
(4) For use_average:
~ if TRUE, the average value of pixels falling in the bin is
chosen as the representative gray value. Otherwise,
~ if FALSE, the central value of each bin is chosen as
the representative value.
The colormap holds the representative value.
(5) For setblack, if TRUE the darkest color is set to (0,0,0).
(6) For setwhite, if TRUE the lightest color is set to (255,255,255).
(7) An alternative to using this function to quantize to
unequally-spaced bins is to first transform the 8 bpp pixs
using pixGammaTRC(), and follow this with pixThresholdTo4bpp().
Definition at line 1712 of file grayquant.c.
References GET_DATA_BYTE, L_SORT_INCREASING, makeGrayQuantColormapArb(), makeGrayQuantTableArb(), REMOVE_CMAP_TO_GRAYSCALE, SET_DATA_BYTE, thresholdTo2bppLow(), and thresholdTo4bppLow().
| [in] | pixs | 8 bpp, can have colormap |
| [in] | nlevels | equally spaced; must be between 2 and 256 |
| [in] | cmapflag | 1 to build colormap; 0 otherwise |
Notes:
(1) Valid values for nlevels is the set {2,...,256}.
(2) Any colormap on the input pixs is removed to 8 bpp grayscale.
(3) If cmapflag == 1, a colormap of size 'nlevels' is made,
and the pixel values in pixs are replaced by their
appropriate color indices. Otherwise, the pixel values
are the actual thresholded (i.e., quantized) grayscale values.
(4) If you don't want the thresholding to be equally spaced,
first transform the input 8 bpp src using pixGammaTRC().
Definition at line 1613 of file grayquant.c.
References GET_DATA_BYTE, makeGrayQuantIndexTable(), makeGrayQuantTargetTable(), REMOVE_CMAP_TO_GRAYSCALE, and SET_DATA_BYTE.
| [in] | pixs | 8 bpp |
| [in] | nlevels | equally spaced; must be between 2 and 4 |
| [in] | cmapflag | 1 to build colormap; 0 otherwise |
Notes:
(1) Valid values for nlevels is the set {2, 3, 4}.
(2) Any colormap on the input pixs is removed to 8 bpp grayscale.
(3) This function is typically invoked with cmapflag == 1.
In the situation where no colormap is desired, nlevels is
ignored and pixs is thresholded to 4 levels.
(4) The target output colors are equally spaced, with the
darkest at 0 and the lightest at 255. The thresholds are
chosen halfway between adjacent output values. A table
is built that specifies the mapping from src to dest.
(5) If cmapflag == 1, a colormap of size 'nlevels' is made,
and the pixel values in pixs are replaced by their
appropriate color indices. The number of holdouts,
4 - nlevels, will be between 0 and 2.
(6) If you don't want the thresholding to be equally spaced,
either first transform the 8 bpp src using pixGammaTRC().
or, if cmapflag == 1, after calling this function you can use
pixcmapResetColor() to change any individual colors.
(7) If a colormap is generated, it will specify (to display
programs) exactly how each level is to be represented in RGB
space. When representing text, 3 levels is far better than
2 because of the antialiasing of the single gray level,
and 4 levels (black, white and 2 gray levels) is getting
close to the perceptual quality of a (nearly continuous)
grayscale image. With 2 bpp, you can set up a colormap
and allocate from 2 to 4 levels to represent antialiased text.
Any left over colormap entries can be used for coloring regions.
For the same number of levels, the file size of a 2 bpp image
is about 10% smaller than that of a 4 bpp result for the same
number of levels. For both 2 bpp and 4 bpp, using 4 levels you
get compression far better than that of jpeg, because the
quantization to 4 levels will remove the jpeg ringing in the
background near character edges.
Definition at line 1358 of file grayquant.c.
References makeGrayQuantIndexTable(), makeGrayQuantTargetTable(), REMOVE_CMAP_TO_GRAYSCALE, and thresholdTo2bppLow().
| [in] | pixs | 8 bpp, can have colormap |
| [in] | nlevels | equally spaced; must be between 2 and 16 |
| [in] | cmapflag | 1 to build colormap; 0 otherwise |
Notes:
(1) Valid values for nlevels is the set {2, ... 16}.
(2) Any colormap on the input pixs is removed to 8 bpp grayscale.
(3) This function is typically invoked with cmapflag == 1.
In the situation where no colormap is desired, nlevels is
ignored and pixs is thresholded to 16 levels.
(4) The target output colors are equally spaced, with the
darkest at 0 and the lightest at 255. The thresholds are
chosen halfway between adjacent output values. A table
is built that specifies the mapping from src to dest.
(5) If cmapflag == 1, a colormap of size 'nlevels' is made,
and the pixel values in pixs are replaced by their
appropriate color indices. The number of holdouts,
16 - nlevels, will be between 0 and 14.
(6) If you don't want the thresholding to be equally spaced,
either first transform the 8 bpp src using pixGammaTRC().
or, if cmapflag == 1, after calling this function you can use
pixcmapResetColor() to change any individual colors.
(7) If a colormap is generated, it will specify, to display
programs, exactly how each level is to be represented in RGB
space. When representing text, 3 levels is far better than
2 because of the antialiasing of the single gray level,
and 4 levels (black, white and 2 gray levels) is getting
close to the perceptual quality of a (nearly continuous)
grayscale image. Therefore, with 4 bpp, you can set up a
colormap, allocate a relatively small fraction of the 16
possible values to represent antialiased text, and use the
other colormap entries for other things, such as coloring
text or background. Two other reasons for using a small number
of gray values for antialiased text are (1) PNG compression
gets worse as the number of levels that are used is increased,
and (2) using a small number of levels will filter out most of
the jpeg ringing that is typically introduced near sharp edges
of text. This filtering is partly responsible for the improved
compression.
Definition at line 1498 of file grayquant.c.
References makeGrayQuantIndexTable(), makeGrayQuantTargetTable(), REMOVE_CMAP_TO_GRAYSCALE, and thresholdTo4bppLow().
| [in] | pixs | 4 or 8 bpp |
| [in] | thresh | threshold value |
Notes:
(1) If the source pixel is less than the threshold value,
the dest will be 1; otherwise, it will be 0.
(2) For example, for 8 bpp src pix, if thresh == 256, the dest
1 bpp pix is all ones (fg), and if thresh == 0, the dest
pix is all zeros (bg).
Definition at line 443 of file grayquant.c.
References REMOVE_CMAP_TO_GRAYSCALE, and thresholdToBinaryLow().
Referenced by pixAdaptThresholdToBinaryGen().
| [in] | pixs | 8 bpp |
| [in] | pixg | 8 bpp; contains threshold values for each pixel |
Notes:
(1) If the pixel in pixs is less than the corresponding pixel
in pixg, the dest will be 1; otherwise it will be 0.
Definition at line 647 of file grayquant.c.
References GET_DATA_BYTE, and SET_DATA_BIT.
|
static |
Low-level function for thresholding from 8 bpp (datas) to 2 bpp (datad), using thresholds implicitly defined through tab, a 256-entry lookup table that gives a 2-bit output value for each possible input.
For each line, unroll the loop so that for each 32 bit src word, representing four consecutive 8-bit pixels, we compose one byte of output consisiting of four 2-bit pixels.
Definition at line 1420 of file grayquant.c.
References GET_DATA_BYTE, and SET_DATA_BYTE.
Referenced by pixThresholdGrayArb(), and pixThresholdTo2bpp().
|
static |
Low-level function for thresholding from 8 bpp (datas) to 4 bpp (datad), using thresholds implicitly defined through tab, a 256-entry lookup table that gives a 4-bit output value for each possible input.
For each line, unroll the loop so that for each 32 bit src word, representing four consecutive 8-bit pixels, we compose two bytes of output consisiting of four 4-bit pixels.
Definition at line 1560 of file grayquant.c.
References GET_DATA_BYTE, and SET_DATA_TWO_BYTES.
Referenced by pixThresholdGrayArb(), and pixThresholdTo4bpp().
| void thresholdToBinaryLineLow | ( | l_uint32 * | lined, |
| l_int32 | w, | ||
| l_uint32 * | lines, | ||
| l_int32 | d, | ||
| l_int32 | thresh ) |
Definition at line 517 of file grayquant.c.
|
static |
If the source pixel is less than thresh, the dest will be 1; otherwise, it will be 0
Definition at line 492 of file grayquant.c.
Referenced by pixThresholdToBinary().
1.12.0