| /*====================================================================* |
| - Copyright (C) 2001 Leptonica. All rights reserved. |
| - This software is distributed in the hope that it will be |
| - useful, but with NO WARRANTY OF ANY KIND. |
| - No author or distributor accepts responsibility to anyone for the |
| - consequences of using this software, or for whether it serves any |
| - particular purpose or works at all, unless he or she says so in |
| - writing. Everyone is granted permission to copy, modify and |
| - redistribute this source code, for commercial or non-commercial |
| - purposes, with the following restrictions: (1) the origin of this |
| - source code must not be misrepresented; (2) modified versions must |
| - be plainly marked as such; and (3) this notice may not be removed |
| - or altered from any source or modified source distribution. |
| *====================================================================*/ |
| |
| /* |
| * grayquant.c |
| * |
| * Thresholding from 8 bpp to 1 bpp |
| * |
| * Floyd-Steinberg dithering to binary |
| * PIX *pixDitherToBinary() |
| * PIX *pixDitherToBinarySpec() |
| * |
| * Simple (pixelwise) binarization with fixed threshold |
| * PIX *pixThresholdToBinary() |
| * |
| * Binarization with variable threshold |
| * PIX *pixVarThresholdToBinary() |
| * |
| * Slower implementation of Floyd-Steinberg dithering, using LUTs |
| * PIX *pixDitherToBinaryLUT() |
| * |
| * Generate a binary mask from pixels of particular values |
| * PIX *pixGenerateMaskByValue() |
| * PIX *pixGenerateMaskByBand() |
| * |
| * Thresholding from 8 bpp to 2 bpp |
| * |
| * Dithering to 2 bpp |
| * PIX *pixDitherTo2bpp() |
| * PIX *pixDitherTo2bppSpec() |
| * |
| * Simple (pixelwise) thresholding to 2 bpp with optional cmap |
| * PIX *pixThresholdTo2bpp() |
| * |
| * Simple (pixelwise) thresholding from 8 bpp to 4 bpp |
| * PIX *pixThresholdTo4bpp() |
| * |
| * 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() |
| * l_int32 *makeGrayQuantTargetTable() |
| * |
| * Quantization table for arbitrary thresholding of grayscale images |
| * l_int32 makeGrayQuantTableArb() |
| * 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() |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <math.h> |
| #include "allheaders.h" |
| |
| |
| static l_int32 numaFillCmapFromHisto(NUMA *na, PIXCMAP *cmap, |
| l_float32 minfract, l_int32 maxsize, |
| l_int32 **plut); |
| |
| |
| /*------------------------------------------------------------------* |
| * Binarization by Floyd-Steinberg dithering * |
| *------------------------------------------------------------------*/ |
| /*! |
| * pixDitherToBinary() |
| * |
| * Input: pixs |
| * Return: pixd (dithered binary), or null on error |
| * |
| * 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 2x faster |
| * than the implementation using LUTs. |
| */ |
| PIX * |
| pixDitherToBinary(PIX *pixs) |
| { |
| PROCNAME("pixDitherToBinary"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (pixGetDepth(pixs) != 8) |
| return (PIX *)ERROR_PTR("must be 8 bpp for dithering", procName, NULL); |
| |
| return pixDitherToBinarySpec(pixs, DEFAULT_CLIP_LOWER_1, |
| DEFAULT_CLIP_UPPER_1); |
| } |
| |
| |
| /*! |
| * pixDitherToBinarySpec() |
| * |
| * Input: pixs |
| * lowerclip (lower clip distance to black; use 0 for default) |
| * upperclip (upper clip distance to white; use 0 for default) |
| * Return: pixd (dithered binary), or null on error |
| * |
| * 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. |
| */ |
| PIX * |
| pixDitherToBinarySpec(PIX *pixs, |
| l_int32 lowerclip, |
| l_int32 upperclip) |
| { |
| l_int32 w, h, d, wplt, wpld; |
| l_uint32 *datat, *datad; |
| l_uint32 *bufs1, *bufs2; |
| PIX *pixt, *pixd; |
| |
| PROCNAME("pixDitherToBinarySpec"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 8) |
| return (PIX *)ERROR_PTR("must be 8 bpp for dithering", procName, NULL); |
| if (lowerclip < 0 || lowerclip > 255) |
| return (PIX *)ERROR_PTR("invalid value for lowerclip", procName, NULL); |
| if (upperclip < 0 || upperclip > 255) |
| return (PIX *)ERROR_PTR("invalid value for upperclip", procName, NULL); |
| |
| if ((pixd = pixCreate(w, h, 1)) == NULL) |
| return (PIX *)ERROR_PTR("pixd not made", procName, NULL); |
| pixCopyResolution(pixd, pixs); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| |
| /* Remove colormap if it exists */ |
| pixt = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE); |
| datat = pixGetData(pixt); |
| wplt = pixGetWpl(pixt); |
| |
| /* Two line buffers, 1 for current line and 2 for next line */ |
| if ((bufs1 = (l_uint32 *)CALLOC(wplt, sizeof(l_uint32))) == NULL) |
| return (PIX *)ERROR_PTR("bufs1 not made", procName, NULL); |
| if ((bufs2 = (l_uint32 *)CALLOC(wplt, sizeof(l_uint32))) == NULL) |
| return (PIX *)ERROR_PTR("bufs2 not made", procName, NULL); |
| |
| ditherToBinaryLow(datad, w, h, wpld, datat, wplt, bufs1, bufs2, |
| lowerclip, upperclip); |
| |
| FREE(bufs1); |
| FREE(bufs2); |
| pixDestroy(&pixt); |
| |
| return pixd; |
| } |
| |
| |
| /*------------------------------------------------------------------* |
| * Simple (pixelwise) binarization with fixed threshold * |
| *------------------------------------------------------------------*/ |
| /*! |
| * pixThresholdToBinary() |
| * |
| * Input: pixs (4 or 8 bpp) |
| * threshold value |
| * Return: pixd (1 bpp), or null on error |
| * |
| * Notes: |
| * (1) If the source pixel is less than the threshold value, |
| * the dest will be 1; otherwise, it will be 0 |
| */ |
| PIX * |
| pixThresholdToBinary(PIX *pixs, |
| l_int32 thresh) |
| { |
| l_int32 d, w, h, wplt, wpld; |
| l_uint32 *datat, *datad; |
| PIX *pixt, *pixd; |
| |
| PROCNAME("pixThresholdToBinary"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 4 && d != 8) |
| return (PIX *)ERROR_PTR("pixs must be 4 or 8 bpp", procName, NULL); |
| if (thresh < 0) |
| return (PIX *)ERROR_PTR("thresh must be non-negative", procName, NULL); |
| if (d == 4 && thresh > 16) |
| return (PIX *)ERROR_PTR("4 bpp thresh not in {0-16}", procName, NULL); |
| if (d == 8 && thresh > 256) |
| return (PIX *)ERROR_PTR("8 bpp thresh not in {0-256}", procName, NULL); |
| |
| if ((pixd = pixCreate(w, h, 1)) == NULL) |
| return (PIX *)ERROR_PTR("pixd not made", procName, NULL); |
| pixCopyResolution(pixd, pixs); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| |
| /* Remove colormap if it exists. If there is a colormap, |
| * pixt will be 8 bpp regardless of the depth of pixs. */ |
| pixt = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE); |
| datat = pixGetData(pixt); |
| wplt = pixGetWpl(pixt); |
| if (pixGetColormap(pixs) && d == 4) { /* promoted to 8 bpp */ |
| d = 8; |
| thresh *= 16; |
| } |
| |
| thresholdToBinaryLow(datad, w, h, wpld, datat, d, wplt, thresh); |
| pixDestroy(&pixt); |
| return pixd; |
| } |
| |
| |
| /*------------------------------------------------------------------* |
| * Binarization with variable threshold * |
| *------------------------------------------------------------------*/ |
| /*! |
| * pixVarThresholdToBinary() |
| * |
| * Input: pixs (8 bpp) |
| * pixg (8 bpp; contains threshold values for each pixel) |
| * Return: pixd (1 bpp), or null on error |
| * |
| * 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. |
| */ |
| PIX * |
| pixVarThresholdToBinary(PIX *pixs, |
| PIX *pixg) |
| { |
| l_int32 i, j, vals, valg, w, h, d, wpls, wplg, wpld; |
| l_uint32 *datas, *datag, *datad, *lines, *lineg, *lined; |
| PIX *pixd; |
| |
| PROCNAME("pixVarThresholdToBinary"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (!pixg) |
| return (PIX *)ERROR_PTR("pixg not defined", procName, NULL); |
| if (!pixSizesEqual(pixs, pixg)) |
| return (PIX *)ERROR_PTR("pix sizes not equal", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 8) |
| return (PIX *)ERROR_PTR("pixs must be 8 bpp", procName, NULL); |
| |
| pixd = pixCreate(w, h, 1); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| datas = pixGetData(pixs); |
| wpls = pixGetWpl(pixs); |
| datag = pixGetData(pixg); |
| wplg = pixGetWpl(pixg); |
| for (i = 0; i < h; i++) { |
| lines = datas + i * wpls; |
| lineg = datag + i * wplg; |
| lined = datad + i * wpld; |
| for (j = 0; j < w; j++) { |
| vals = GET_DATA_BYTE(lines, j); |
| valg = GET_DATA_BYTE(lineg, j); |
| if (vals < valg) |
| SET_DATA_BIT(lined, j); |
| } |
| } |
| |
| return pixd; |
| } |
| |
| |
| /*--------------------------------------------------------------------* |
| * Slower implementation of binarization by dithering using LUTs * |
| *--------------------------------------------------------------------*/ |
| /*! |
| * pixDitherToBinaryLUT() |
| * |
| * Input: pixs |
| * lowerclip (lower clip distance to black; use -1 for default) |
| * upperclip (upper clip distance to white; use -1 for default) |
| * Return: pixd (dithered binary), or null on error |
| * |
| * This implementation is deprecated. You should use pixDitherToBinary(). |
| * |
| * See comments in pixDitherToBinary() |
| * |
| * This implementation additionally uses three lookup tables to |
| * generate the output pixel value and the excess or deficit |
| * carried over to the neighboring pixels. |
| */ |
| PIX * |
| pixDitherToBinaryLUT(PIX *pixs, |
| l_int32 lowerclip, |
| l_int32 upperclip) |
| { |
| l_int32 w, h, d, wplt, wpld; |
| l_int32 *tabval, *tab38, *tab14; |
| l_uint32 *datat, *datad; |
| l_uint32 *bufs1, *bufs2; |
| PIX *pixt, *pixd; |
| |
| PROCNAME("pixDitherToBinaryLUT"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 8) |
| return (PIX *)ERROR_PTR("must be 8 bpp for dithering", procName, NULL); |
| if (lowerclip < 0) |
| lowerclip = DEFAULT_CLIP_LOWER_1; |
| if (upperclip < 0) |
| upperclip = DEFAULT_CLIP_UPPER_1; |
| |
| if ((pixd = pixCreate(w, h, 1)) == NULL) |
| return (PIX *)ERROR_PTR("pixd not made", procName, NULL); |
| pixCopyResolution(pixd, pixs); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| |
| /* Remove colormap if it exists */ |
| pixt = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE); |
| datat = pixGetData(pixt); |
| wplt = pixGetWpl(pixt); |
| |
| /* Two line buffers, 1 for current line and 2 for next line */ |
| if ((bufs1 = (l_uint32 *)CALLOC(wplt, sizeof(l_uint32))) == NULL) |
| return (PIX *)ERROR_PTR("bufs1 not made", procName, NULL); |
| if ((bufs2 = (l_uint32 *)CALLOC(wplt, sizeof(l_uint32))) == NULL) |
| return (PIX *)ERROR_PTR("bufs2 not made", procName, NULL); |
| |
| /* 3 lookup tables: 1-bit value, (3/8)excess, and (1/4)excess */ |
| make8To1DitherTables(&tabval, &tab38, &tab14, lowerclip, upperclip); |
| |
| ditherToBinaryLUTLow(datad, w, h, wpld, datat, wplt, bufs1, bufs2, |
| tabval, tab38, tab14); |
| |
| FREE(bufs1); |
| FREE(bufs2); |
| FREE(tabval); |
| FREE(tab38); |
| FREE(tab14); |
| pixDestroy(&pixt); |
| |
| return pixd; |
| } |
| |
| |
| /*--------------------------------------------------------------------* |
| * Generate a binary mask from pixels of particular value(s) * |
| *--------------------------------------------------------------------*/ |
| /*! |
| * pixGenerateMaskByValue() |
| * |
| * Input: pixs (8 bpp, or colormapped) |
| * val (of pixels for which we set 1 in dest) |
| * Return: pixd (1 bpp), or null on error |
| * |
| * Notes: |
| * (1) @val is the gray value of the pixels that we are selecting. |
| * (2) If pixs is colormapped, this first removes the colormap to |
| * generate an approximate grayscale value for each pixel, and |
| * then looks for gray pixels with the value @val. |
| * (3) If pixs is colormapped and you want to use @val to select |
| * the colormap index, you must first call pixDestroyColormap(pixs) |
| * to remove the colormap from pixs. |
| */ |
| PIX * |
| pixGenerateMaskByValue(PIX *pixs, |
| l_int32 val) |
| { |
| l_int32 i, j, w, h, wplg, wpld; |
| l_uint32 *datag, *datad, *lineg, *lined; |
| PIX *pixg, *pixd; |
| |
| PROCNAME("pixGenerateMaskByValue"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (pixGetDepth(pixs) != 8) |
| return (PIX *)ERROR_PTR("not 8 bpp", procName, NULL); |
| if (val < 0 || val > 255) |
| return (PIX *)ERROR_PTR("val out of 8 bpp range", procName, NULL); |
| |
| if (pixGetColormap(pixs)) |
| pixg = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE); |
| else |
| pixg = pixClone(pixs); |
| |
| pixGetDimensions(pixg, &w, &h, NULL); |
| pixd = pixCreate(w, h, 1); |
| pixCopyResolution(pixd, pixg); |
| datag = pixGetData(pixg); |
| wplg = pixGetWpl(pixg); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| for (i = 0; i < h; i++) { |
| lineg = datag + i * wplg; |
| lined = datad + i * wpld; |
| for (j = 0; j < w; j++) { |
| if (GET_DATA_BYTE(lineg, j) == val) |
| SET_DATA_BIT(lined, j); |
| } |
| } |
| |
| pixDestroy(&pixg); |
| return pixd; |
| } |
| |
| |
| /*! |
| * pixGenerateMaskByBand() |
| * |
| * Input: pixs (8 bpp, or colormapped) |
| * 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) |
| * inband (1 for finding pixels in [lower, upper]; |
| * 0 for finding pixels in [0, lower) union (upper, 255]) |
| * Return: pixd (1 bpp), or null on error |
| * |
| * 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, this first removes the colormap to |
| * generate an approximate grayscale value for each pixel, and |
| * then looks for gray pixels in or out of the given band. |
| * (3) If pixs is colormapped and you want to the band of values to |
| * select the colormap indices directly, you must first call |
| * pixDestroyColormap(pixs) to remove the colormap from pixs. |
| */ |
| PIX * |
| pixGenerateMaskByBand(PIX *pixs, |
| l_int32 lower, |
| l_int32 upper, |
| l_int32 inband) |
| { |
| l_int32 i, j, w, h, wplg, wpld, val; |
| l_uint32 *datag, *datad, *lineg, *lined; |
| PIX *pixg, *pixd; |
| |
| PROCNAME("pixGenerateMaskByBand"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (pixGetDepth(pixs) != 8) |
| return (PIX *)ERROR_PTR("not 8 bpp", procName, NULL); |
| if (lower < 0 || upper > 255) |
| return (PIX *)ERROR_PTR("invalid lower and/or upper", procName, NULL); |
| if (lower > upper) |
| return (PIX *)ERROR_PTR("lower > upper!", procName, NULL); |
| |
| if (pixGetColormap(pixs)) |
| pixg = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE); |
| else |
| pixg = pixClone(pixs); |
| |
| pixGetDimensions(pixg, &w, &h, NULL); |
| pixd = pixCreate(w, h, 1); |
| pixCopyResolution(pixd, pixg); |
| datag = pixGetData(pixg); |
| wplg = pixGetWpl(pixg); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| for (i = 0; i < h; i++) { |
| lineg = datag + i * wplg; |
| lined = datad + i * wpld; |
| for (j = 0; j < w; j++) { |
| val = GET_DATA_BYTE(lineg, j); |
| if (inband) { |
| if (val >= lower && val <= upper) |
| SET_DATA_BIT(lined, j); |
| } |
| else { /* out of band */ |
| if (val < lower || val > upper) |
| SET_DATA_BIT(lined, j); |
| } |
| } |
| } |
| |
| pixDestroy(&pixg); |
| return pixd; |
| } |
| |
| |
| /*------------------------------------------------------------------* |
| * Thresholding to 2 bpp by dithering * |
| *------------------------------------------------------------------*/ |
| /*! |
| * pixDitherTo2bpp() |
| * |
| * Input: pixs (8 bpp) |
| * cmapflag (1 to generate a colormap) |
| * Return: pixd (dithered 2 bpp), or null on error |
| * |
| * 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. |
| */ |
| PIX * |
| pixDitherTo2bpp(PIX *pixs, |
| l_int32 cmapflag) |
| { |
| PROCNAME("pixDitherTo2bpp"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (pixGetDepth(pixs) != 8) |
| return (PIX *)ERROR_PTR("must be 8 bpp for dithering", procName, NULL); |
| |
| return pixDitherTo2bppSpec(pixs, DEFAULT_CLIP_LOWER_2, |
| DEFAULT_CLIP_UPPER_2, cmapflag); |
| } |
| |
| |
| /*! |
| * pixDitherTo2bppSpec() |
| * |
| * Input: pixs (8 bpp) |
| * lowerclip (lower clip distance to black; use 0 for default) |
| * upperclip (upper clip distance to white; use 0 for default) |
| * cmapflag (1 to generate a colormap) |
| * Return: pixd (dithered 2 bpp), or null on error |
| * |
| * 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. |
| */ |
| PIX * |
| pixDitherTo2bppSpec(PIX *pixs, |
| l_int32 lowerclip, |
| l_int32 upperclip, |
| l_int32 cmapflag) |
| { |
| l_int32 w, h, d, wplt, wpld; |
| l_int32 *tabval, *tab38, *tab14; |
| l_uint32 *datat, *datad; |
| l_uint32 *bufs1, *bufs2; |
| PIX *pixt, *pixd; |
| PIXCMAP *cmap; |
| |
| PROCNAME("pixDitherTo2bppSpec"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 8) |
| return (PIX *)ERROR_PTR("must be 8 bpp for dithering", procName, NULL); |
| if (lowerclip < 0 || lowerclip > 255) |
| return (PIX *)ERROR_PTR("invalid value for lowerclip", procName, NULL); |
| if (upperclip < 0 || upperclip > 255) |
| return (PIX *)ERROR_PTR("invalid value for upperclip", procName, NULL); |
| |
| if ((pixd = pixCreate(w, h, 2)) == NULL) |
| return (PIX *)ERROR_PTR("pixd not made", procName, NULL); |
| pixCopyResolution(pixd, pixs); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| |
| /* If there is a colormap, remove it */ |
| pixt = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE); |
| datat = pixGetData(pixt); |
| wplt = pixGetWpl(pixt); |
| |
| /* Two line buffers, 1 for current line and 2 for next line */ |
| if ((bufs1 = (l_uint32 *)CALLOC(wplt, sizeof(l_uint32))) == NULL) |
| return (PIX *)ERROR_PTR("bufs1 not made", procName, NULL); |
| if ((bufs2 = (l_uint32 *)CALLOC(wplt, sizeof(l_uint32))) == NULL) |
| return (PIX *)ERROR_PTR("bufs2 not made", procName, NULL); |
| |
| /* 3 lookup tables: 2-bit value, (3/8)excess, and (1/4)excess */ |
| make8To2DitherTables(&tabval, &tab38, &tab14, lowerclip, upperclip); |
| |
| ditherTo2bppLow(datad, w, h, wpld, datat, wplt, bufs1, bufs2, |
| tabval, tab38, tab14); |
| |
| if (cmapflag) { |
| cmap = pixcmapCreateLinear(2, 4); |
| pixSetColormap(pixd, cmap); |
| } |
| |
| FREE(bufs1); |
| FREE(bufs2); |
| FREE(tabval); |
| FREE(tab38); |
| FREE(tab14); |
| pixDestroy(&pixt); |
| |
| return pixd; |
| } |
| |
| |
| /*--------------------------------------------------------------------* |
| * Simple (pixelwise) thresholding to 2 bpp with optional colormap * |
| *--------------------------------------------------------------------*/ |
| /*! |
| * pixThresholdTo2bpp() |
| * |
| * Input: pixs (8 bpp) |
| * nlevels (equally spaced; must be between 2 and 4) |
| * cmapflag (1 to build colormap; 0 otherwise) |
| * Return: pixd (2 bpp, optionally with colormap), or null on error |
| * |
| * 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. |
| */ |
| PIX * |
| pixThresholdTo2bpp(PIX *pixs, |
| l_int32 nlevels, |
| l_int32 cmapflag) |
| { |
| l_int32 *qtab; |
| l_int32 w, h, d, wplt, wpld; |
| l_uint32 *datat, *datad; |
| PIX *pixt, *pixd; |
| PIXCMAP *cmap; |
| |
| PROCNAME("pixThresholdTo2bpp"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 8) |
| return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL); |
| if (nlevels < 2 || nlevels > 4) |
| return (PIX *)ERROR_PTR("nlevels not in {2, 3, 4}", procName, NULL); |
| |
| /* Make the appropriate table */ |
| if (cmapflag) |
| qtab = makeGrayQuantIndexTable(nlevels); |
| else |
| qtab = makeGrayQuantTargetTable(4, 2); |
| |
| if ((pixd = pixCreate(w, h, 2)) == NULL) |
| return (PIX *)ERROR_PTR("pixd not made", procName, NULL); |
| pixCopyResolution(pixd, pixs); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| |
| if (cmapflag) { /* hold out (4 - nlevels) cmap entries */ |
| cmap = pixcmapCreateLinear(2, nlevels); |
| pixSetColormap(pixd, cmap); |
| } |
| |
| /* If there is a colormap in the src, remove it */ |
| pixt = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE); |
| datat = pixGetData(pixt); |
| wplt = pixGetWpl(pixt); |
| |
| thresholdTo2bppLow(datad, h, wpld, datat, wplt, qtab); |
| |
| if (qtab) FREE(qtab); |
| pixDestroy(&pixt); |
| return pixd; |
| } |
| |
| |
| /*----------------------------------------------------------------------* |
| * Simple (pixelwise) thresholding to 4 bpp * |
| *----------------------------------------------------------------------*/ |
| /*! |
| * pixThresholdTo4bpp() |
| * |
| * Input: pixs (8 bpp, can have colormap) |
| * nlevels (equally spaced; must be between 2 and 16) |
| * cmapflag (1 to build colormap; 0 otherwise) |
| * Return: pixd (4 bpp, optionally with colormap), or null on error |
| * |
| * 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. |
| */ |
| PIX * |
| pixThresholdTo4bpp(PIX *pixs, |
| l_int32 nlevels, |
| l_int32 cmapflag) |
| { |
| l_int32 *qtab; |
| l_int32 w, h, d, wplt, wpld; |
| l_uint32 *datat, *datad; |
| PIX *pixt, *pixd; |
| PIXCMAP *cmap; |
| |
| PROCNAME("pixThresholdTo4bpp"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 8) |
| return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL); |
| if (nlevels < 2 || nlevels > 16) |
| return (PIX *)ERROR_PTR("nlevels not in [2,...,16]", procName, NULL); |
| |
| /* Make the appropriate table */ |
| if (cmapflag) |
| qtab = makeGrayQuantIndexTable(nlevels); |
| else |
| qtab = makeGrayQuantTargetTable(16, 4); |
| |
| if ((pixd = pixCreate(w, h, 4)) == NULL) |
| return (PIX *)ERROR_PTR("pixd not made", procName, NULL); |
| pixCopyResolution(pixd, pixs); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| |
| if (cmapflag) { /* hold out (16 - nlevels) cmap entries */ |
| cmap = pixcmapCreateLinear(4, nlevels); |
| pixSetColormap(pixd, cmap); |
| } |
| |
| /* If there is a colormap in the src, remove it */ |
| pixt = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE); |
| datat = pixGetData(pixt); |
| wplt = pixGetWpl(pixt); |
| |
| thresholdTo4bppLow(datad, h, wpld, datat, wplt, qtab); |
| |
| if (qtab) FREE(qtab); |
| pixDestroy(&pixt); |
| return pixd; |
| } |
| |
| |
| /*----------------------------------------------------------------------* |
| * Simple (pixelwise) thresholding on 8 bpp with optional colormap * |
| *----------------------------------------------------------------------*/ |
| /*! |
| * pixThresholdOn8bpp() |
| * |
| * Input: pixs (8 bpp, can have colormap) |
| * nlevels (equally spaced; must be between 2 and 256) |
| * cmapflag (1 to build colormap; 0 otherwise) |
| * Return: pixd (8 bpp, optionally with colormap), or null on error |
| * |
| * 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(). |
| */ |
| PIX * |
| pixThresholdOn8bpp(PIX *pixs, |
| l_int32 nlevels, |
| l_int32 cmapflag) |
| { |
| l_int32 *qtab; /* quantization table */ |
| l_int32 i, j, w, h, wpld, val, newval; |
| l_uint32 *datad, *lined; |
| PIX *pixd; |
| PIXCMAP *cmap; |
| |
| PROCNAME("pixThresholdOn8bpp"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (pixGetDepth(pixs) != 8) |
| return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL); |
| if (nlevels < 2 || nlevels > 256) |
| return (PIX *)ERROR_PTR("nlevels not in [2,...,256]", procName, NULL); |
| |
| if (cmapflag) |
| qtab = makeGrayQuantIndexTable(nlevels); |
| else |
| qtab = makeGrayQuantTargetTable(nlevels, 8); |
| |
| /* Get a new pixd; if there is a colormap in the src, remove it */ |
| if (pixGetColormap(pixs)) |
| pixd = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE); |
| else |
| pixd = pixCopy(NULL, pixs); |
| |
| if (cmapflag) { /* hold out (256 - nlevels) cmap entries */ |
| cmap = pixcmapCreateLinear(8, nlevels); |
| pixSetColormap(pixd, cmap); |
| } |
| |
| pixGetDimensions(pixd, &w, &h, NULL); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| for (i = 0; i < h; i++) { |
| lined = datad + i * wpld; |
| for (j = 0; j < w; j++) { |
| val = GET_DATA_BYTE(lined, j); |
| newval = qtab[val]; |
| SET_DATA_BYTE(lined, j, newval); |
| } |
| } |
| |
| if (qtab) FREE(qtab); |
| return pixd; |
| } |
| |
| |
| /*----------------------------------------------------------------------* |
| * Arbitrary (pixelwise) thresholding from 8 bpp to 2, 4 or 8 bpp * |
| *----------------------------------------------------------------------*/ |
| /*! |
| * pixThresholdGrayArb() |
| * |
| * Input: pixs (8 bpp grayscale; can have colormap) |
| * edgevals (string giving edge value of each bin) |
| * outdepth (0, 2, 4 or 8 bpp; 0 is default for min depth) |
| * use_average (1 if use the average pixel value in colormap) |
| * setblack (1 if darkest color is set to black) |
| * setwhite (1 if lightest color is set to white) |
| * Return: pixd (2, 4 or 8 bpp quantized image with colormap), |
| * or null on error |
| * |
| * 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(). |
| */ |
| PIX * |
| pixThresholdGrayArb(PIX *pixs, |
| const char *edgevals, |
| l_int32 outdepth, |
| l_int32 use_average, |
| l_int32 setblack, |
| l_int32 setwhite) |
| { |
| l_int32 *qtab; |
| l_int32 w, h, d, i, j, n, wplt, wpld, val, newval; |
| l_uint32 *datat, *datad, *linet, *lined; |
| NUMA *na; |
| PIX *pixt, *pixd; |
| PIXCMAP *cmap; |
| |
| PROCNAME("pixThresholdGrayArb"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 8) |
| return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL); |
| if (!edgevals) |
| return (PIX *)ERROR_PTR("edgevals not defined", procName, NULL); |
| if (outdepth != 0 && outdepth != 2 && outdepth != 4 && outdepth != 8) |
| return (PIX *)ERROR_PTR("invalid outdepth", procName, NULL); |
| |
| /* Parse and sort (if required) the bin edge values */ |
| na = parseStringForNumbers(edgevals, " \t\n,"); |
| n = numaGetCount(na); |
| if (n > 255) |
| return (PIX *)ERROR_PTR("more than 256 levels", procName, NULL); |
| if (outdepth == 0) { |
| if (n <= 3) |
| outdepth = 2; |
| else if (n <= 15) |
| outdepth = 4; |
| else |
| outdepth = 8; |
| } |
| else if (n + 1 > (1 << outdepth)) { |
| L_WARNING("outdepth too small; setting to 8 bpp", procName); |
| outdepth = 8; |
| } |
| numaSort(na, na, L_SORT_INCREASING); |
| |
| /* Make the quantization LUT and the colormap */ |
| makeGrayQuantTableArb(na, outdepth, &qtab, &cmap); |
| if (use_average) { /* use the average value in each bin */ |
| pixcmapDestroy(&cmap); |
| makeGrayQuantColormapArb(pixs, qtab, outdepth, &cmap); |
| } |
| pixcmapSetBlackAndWhite(cmap, setblack, setwhite); |
| numaDestroy(&na); |
| |
| if ((pixd = pixCreate(w, h, outdepth)) == NULL) |
| return (PIX *)ERROR_PTR("pixd not made", procName, NULL); |
| pixCopyResolution(pixd, pixs); |
| pixSetColormap(pixd, cmap); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| |
| /* If there is a colormap in the src, remove it */ |
| pixt = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE); |
| datat = pixGetData(pixt); |
| wplt = pixGetWpl(pixt); |
| |
| if (outdepth == 2) |
| thresholdTo2bppLow(datad, h, wpld, datat, wplt, qtab); |
| else if (outdepth == 4) |
| thresholdTo4bppLow(datad, h, wpld, datat, wplt, qtab); |
| else { |
| for (i = 0; i < h; i++) { |
| lined = datad + i * wpld; |
| linet = datat + i * wplt; |
| for (j = 0; j < w; j++) { |
| val = GET_DATA_BYTE(linet, j); |
| newval = qtab[val]; |
| SET_DATA_BYTE(lined, j, newval); |
| } |
| } |
| } |
| |
| FREE(qtab); |
| pixDestroy(&pixt); |
| return pixd; |
| } |
| |
| |
| /*----------------------------------------------------------------------* |
| * Quantization tables for linear thresholds of grayscale images * |
| *----------------------------------------------------------------------*/ |
| /*! |
| * makeGrayQuantIndexTable() |
| * |
| * Input: nlevels (number of output levels) |
| * Return: table (maps input gray level to colormap index, |
| * or null on error) |
| * 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. |
| */ |
| l_int32 * |
| makeGrayQuantIndexTable(l_int32 nlevels) |
| { |
| l_int32 *tab; |
| l_int32 i, j, thresh; |
| |
| PROCNAME("makeGrayQuantIndexTable"); |
| |
| if ((tab = (l_int32 *)CALLOC(256, sizeof(l_int32))) == NULL) |
| return (l_int32 *)ERROR_PTR("calloc fail for tab", procName, NULL); |
| for (i = 0; i < 256; i++) { |
| for (j = 0; j < nlevels; j++) { |
| thresh = 255 * (2 * j + 1) / (2 * nlevels - 2); |
| if (i <= thresh) { |
| tab[i] = j; |
| /* fprintf(stderr, "tab[%d] = %d\n", i, j); */ |
| break; |
| } |
| } |
| } |
| return tab; |
| } |
| |
| |
| /*! |
| * makeGrayQuantTargetTable() |
| * |
| * Input: nlevels (number of output levels) |
| * depth (of dest pix, in bpp; 2, 4 or 8 bpp) |
| * Return: table (maps input gray level to thresholded gray level, |
| * or null on error) |
| * |
| * 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. |
| */ |
| l_int32 * |
| makeGrayQuantTargetTable(l_int32 nlevels, |
| l_int32 depth) |
| { |
| l_int32 *tab; |
| l_int32 i, j, thresh, maxval, quantval; |
| |
| PROCNAME("makeGrayQuantTargetTable"); |
| |
| if ((tab = (l_int32 *)CALLOC(256, sizeof(l_int32))) == NULL) |
| return (l_int32 *)ERROR_PTR("calloc fail for tab", procName, NULL); |
| maxval = (1 << depth) - 1; |
| if (depth < 8) |
| nlevels = 1 << depth; |
| for (i = 0; i < 256; i++) { |
| for (j = 0; j < nlevels; j++) { |
| thresh = 255 * (2 * j + 1) / (2 * nlevels - 2); |
| if (i <= thresh) { |
| quantval = maxval * j / (nlevels - 1); |
| tab[i] = quantval; |
| /* fprintf(stderr, "tab[%d] = %d\n", i, tab[i]); */ |
| break; |
| } |
| } |
| } |
| return tab; |
| } |
| |
| |
| /*----------------------------------------------------------------------* |
| * Quantization table for arbitrary thresholding of grayscale images * |
| *----------------------------------------------------------------------*/ |
| /*! |
| * makeGrayQuantTableArb() |
| * |
| * Input: na (numa of bin boundaries) |
| * outdepth (of colormap: 1, 2, 4 or 8) |
| * &tab (<return> table mapping input gray level to cmap index) |
| * &cmap (<return> colormap) |
| * Return: 0 if OK, 1 on error |
| * |
| * 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. |
| */ |
| l_int32 |
| makeGrayQuantTableArb(NUMA *na, |
| l_int32 outdepth, |
| l_int32 **ptab, |
| PIXCMAP **pcmap) |
| { |
| l_int32 i, j, n, jstart, ave, val; |
| l_int32 *tab; |
| PIXCMAP *cmap; |
| |
| PROCNAME("makeGrayQuantTableArb"); |
| |
| if (!ptab) |
| return ERROR_INT("&tab not defined", procName, 1); |
| *ptab = NULL; |
| if (!pcmap) |
| return ERROR_INT("&cmap not defined", procName, 1); |
| *pcmap = NULL; |
| if (!na) |
| return ERROR_INT("na not defined", procName, 1); |
| n = numaGetCount(na); |
| if (n + 1 > (1 << outdepth)) |
| return ERROR_INT("more bins than cmap levels", procName, 1); |
| |
| if ((tab = (l_int32 *)CALLOC(256, sizeof(l_int32))) == NULL) |
| return ERROR_INT("calloc fail for tab", procName, 1); |
| if ((cmap = pixcmapCreate(outdepth)) == NULL) |
| return ERROR_INT("cmap not made", procName, 1); |
| *ptab = tab; |
| *pcmap = cmap; |
| |
| /* First n bins */ |
| jstart = 0; |
| for (i = 0; i < n; i++) { |
| numaGetIValue(na, i, &val); |
| ave = (jstart + val) / 2; |
| pixcmapAddColor(cmap, ave, ave, ave); |
| for (j = jstart; j < val; j++) |
| tab[j] = i; |
| jstart = val; |
| } |
| |
| /* Last bin */ |
| ave = (jstart + 255) / 2; |
| pixcmapAddColor(cmap, ave, ave, ave); |
| for (j = jstart; j < 256; j++) |
| tab[j] = n; |
| |
| return 0; |
| } |
| |
| |
| /*! |
| * makeGrayQuantColormapArb() |
| * |
| * Input: pixs (8 bpp) |
| * tab (table mapping input gray level to cmap index) |
| * outdepth (of colormap: 1, 2, 4 or 8) |
| * &cmap (<return> colormap) |
| * Return: 0 if OK, 1 on error |
| * |
| * 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. |
| */ |
| l_int32 |
| makeGrayQuantColormapArb(PIX *pixs, |
| l_int32 *tab, |
| l_int32 outdepth, |
| PIXCMAP **pcmap) |
| { |
| l_int32 i, j, index, w, h, d, nbins, wpl, factor, val; |
| l_int32 *bincount, *binave, *binstart; |
| l_uint32 *line, *data; |
| |
| PROCNAME("makeGrayQuantColormapArb"); |
| |
| if (!pcmap) |
| return ERROR_INT("&cmap not defined", procName, 1); |
| *pcmap = NULL; |
| if (!pixs) |
| return ERROR_INT("pixs not defined", procName, 1); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 8) |
| return ERROR_INT("pixs not 8 bpp", procName, 1); |
| if (!tab) |
| return ERROR_INT("tab not defined", procName, 1); |
| nbins = tab[255] + 1; |
| if (nbins > (1 << outdepth)) |
| return ERROR_INT("more bins than cmap levels", procName, 1); |
| |
| /* Find the count and weighted count for each bin */ |
| if ((bincount = (l_int32 *)CALLOC(nbins, sizeof(l_int32))) == NULL) |
| return ERROR_INT("calloc fail for bincount", procName, 1); |
| if ((binave = (l_int32 *)CALLOC(nbins, sizeof(l_int32))) == NULL) |
| return ERROR_INT("calloc fail for binave", procName, 1); |
| factor = (l_int32)(sqrt((l_float64)(w * h) / 30000.) + 0.5); |
| factor = L_MAX(1, factor); |
| data = pixGetData(pixs); |
| wpl = pixGetWpl(pixs); |
| for (i = 0; i < h; i += factor) { |
| line = data + i * wpl; |
| for (j = 0; j < w; j += factor) { |
| val = GET_DATA_BYTE(line, j); |
| bincount[tab[val]]++; |
| binave[tab[val]] += val; |
| } |
| } |
| |
| /* Find the smallest gray values in each bin */ |
| if ((binstart = (l_int32 *)CALLOC(nbins, sizeof(l_int32))) == NULL) |
| return ERROR_INT("calloc fail for binstart", procName, 1); |
| for (i = 1, index = 1; i < 256; i++) { |
| if (tab[i] < index) continue; |
| if (tab[i] == index) |
| binstart[index++] = i; |
| } |
| |
| /* Get the averages. If there are no samples in a bin, use |
| * the center value of the bin. */ |
| *pcmap = pixcmapCreate(outdepth); |
| for (i = 0; i < nbins; i++) { |
| if (bincount[i]) |
| val = binave[i] / bincount[i]; |
| else { /* no samples in the bin */ |
| if (i < nbins - 1) |
| val = (binstart[i] + binstart[i + 1]) / 2; |
| else /* last bin */ |
| val = (binstart[i] + 255) / 2; |
| } |
| pixcmapAddColor(*pcmap, val, val, val); |
| } |
| |
| FREE(bincount); |
| FREE(binave); |
| FREE(binstart); |
| return 0; |
| } |
| |
| |
| /*--------------------------------------------------------------------* |
| * Thresholding from 32 bpp rgb to 1 bpp * |
| *--------------------------------------------------------------------*/ |
| /*! |
| * pixGenerateMaskByBand32() |
| * |
| * Input: pixs (32 bpp) |
| * refval (reference rgb value) |
| * delm (max amount below the ref value for any component) |
| * delp (max amount above the ref value for any component) |
| * Return: pixd (1 bpp), or null on error |
| * |
| * Notes: |
| * (1) Generates a 1 bpp mask pixd, the same size as pixs, where |
| * the fg pixels in the mask are those where each component |
| * is within -delm to +delp of the reference value. |
| */ |
| PIX * |
| pixGenerateMaskByBand32(PIX *pixs, |
| l_uint32 refval, |
| l_int32 delm, |
| l_int32 delp) |
| { |
| l_int32 i, j, w, h, d, wpls, wpld; |
| l_int32 rref, gref, bref, rval, gval, bval; |
| l_uint32 pixel; |
| l_uint32 *datas, *datad, *lines, *lined; |
| PIX *pixd; |
| |
| PROCNAME("pixGenerateMaskByBand32"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 32) |
| return (PIX *)ERROR_PTR("not 32 bpp", procName, NULL); |
| if (delm < 0 || delp < 0) |
| return (PIX *)ERROR_PTR("delm and delp must be >= 0", procName, NULL); |
| |
| extractRGBValues(refval, &rref, &gref, &bref); |
| pixd = pixCreate(w, h, 1); |
| pixCopyResolution(pixd, pixs); |
| datas = pixGetData(pixs); |
| wpls = pixGetWpl(pixs); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| for (i = 0; i < h; i++) { |
| lines = datas + i * wpls; |
| lined = datad + i * wpld; |
| for (j = 0; j < w; j++) { |
| pixel = lines[j]; |
| rval = (pixel >> L_RED_SHIFT) & 0xff; |
| if (rval < rref - delm || rval > rref + delp) |
| continue; |
| gval = (pixel >> L_GREEN_SHIFT) & 0xff; |
| if (gval < gref - delm || gval > gref + delp) |
| continue; |
| bval = (pixel >> L_BLUE_SHIFT) & 0xff; |
| if (bval < bref - delm || bval > bref + delp) |
| continue; |
| SET_DATA_BIT(lined, j); |
| } |
| } |
| |
| return pixd; |
| } |
| |
| |
| /*! |
| * pixGenerateMaskByDiscr32() |
| * |
| * Input: pixs (32 bpp) |
| * refval1 (reference rgb value) |
| * refval2 (reference rgb value) |
| * distflag (L_MANHATTAN_DISTANCE, L_EUCLIDEAN_DISTANCE) |
| * Return: pixd (1 bpp), or null on error |
| * |
| * 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. |
| */ |
| PIX * |
| pixGenerateMaskByDiscr32(PIX *pixs, |
| l_uint32 refval1, |
| l_uint32 refval2, |
| l_int32 distflag) |
| { |
| l_int32 i, j, w, h, d, wpls, wpld; |
| l_int32 rref1, gref1, bref1, rref2, gref2, bref2, rval, gval, bval; |
| l_uint32 pixel, dist1, dist2; |
| l_uint32 *datas, *datad, *lines, *lined; |
| PIX *pixd; |
| |
| PROCNAME("pixGenerateMaskByDiscr32"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 32) |
| return (PIX *)ERROR_PTR("not 32 bpp", procName, NULL); |
| if (distflag != L_MANHATTAN_DISTANCE && distflag != L_EUCLIDEAN_DISTANCE) |
| return (PIX *)ERROR_PTR("invalid distflag", procName, NULL); |
| |
| extractRGBValues(refval1, &rref1, &gref1, &bref1); |
| extractRGBValues(refval2, &rref2, &gref2, &bref2); |
| pixd = pixCreate(w, h, 1); |
| pixCopyResolution(pixd, pixs); |
| datas = pixGetData(pixs); |
| wpls = pixGetWpl(pixs); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| for (i = 0; i < h; i++) { |
| lines = datas + i * wpls; |
| lined = datad + i * wpld; |
| for (j = 0; j < w; j++) { |
| pixel = lines[j]; |
| extractRGBValues(pixel, &rval, &gval, &bval); |
| if (distflag == L_MANHATTAN_DISTANCE) { |
| dist1 = L_ABS(rref1 - rval); |
| dist2 = L_ABS(rref2 - rval); |
| dist1 += L_ABS(gref1 - gval); |
| dist2 += L_ABS(gref2 - gval); |
| dist1 += L_ABS(bref1 - bval); |
| dist2 += L_ABS(bref2 - bval); |
| } |
| else { |
| dist1 = (rref1 - rval) * (rref1 - rval); |
| dist2 = (rref2 - rval) * (rref2 - rval); |
| dist1 += (gref1 - gval) * (gref1 - gval); |
| dist2 += (gref2 - gval) * (gref2 - gval); |
| dist1 += (bref1 - bval) * (bref1 - bval); |
| dist2 += (bref2 - bval) * (bref2 - bval); |
| } |
| if (dist1 < dist2) |
| SET_DATA_BIT(lined, j); |
| } |
| } |
| |
| return pixd; |
| } |
| |
| |
| /*----------------------------------------------------------------------* |
| * Histogram-based grayscale quantization * |
| *----------------------------------------------------------------------*/ |
| /*! |
| * pixGrayQuantFromHisto() |
| * |
| * Input: pixd (<optional> quantized pix with cmap; can be null) |
| * pixs (8 bpp gray input pix; not cmapped) |
| * pixm (<optional> mask over pixels in pixs to quantize) |
| * 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) |
| * 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) |
| * Return: pixd (8 bpp, cmapped), or null on error |
| * |
| * 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. |
| */ |
| PIX * |
| pixGrayQuantFromHisto(PIX *pixd, |
| PIX *pixs, |
| PIX *pixm, |
| l_float32 minfract, |
| l_int32 maxsize) |
| { |
| l_int32 w, h, wd, hd, wm, hm, wpls, wplm, wpld; |
| l_int32 nc, nestim, i, j, vals, vald; |
| l_int32 *lut; |
| l_uint32 *datas, *datam, *datad, *lines, *linem, *lined; |
| NUMA *na; |
| PIX *pixmr; /* resized mask */ |
| PIXCMAP *cmap; |
| |
| PROCNAME("pixGrayQuantFromHisto"); |
| |
| if (!pixs || pixGetDepth(pixs) != 8) |
| return (PIX *)ERROR_PTR("pixs undefined or not 8 bpp", procName, NULL); |
| if (minfract < 0.01) { |
| L_WARNING("minfract < 0.01; setting to 0.05", procName); |
| minfract = 0.05; |
| } |
| if (maxsize < 2) { |
| L_WARNING("maxsize < 2; setting to 10", procName); |
| maxsize = 10; |
| } |
| if ((pixd && !pixm) || (!pixd && pixm)) |
| return (PIX *)ERROR_PTR("(pixd,pixm) not defined together", |
| procName, NULL); |
| pixGetDimensions(pixs, &w, &h, NULL); |
| if (pixd) { |
| if (pixGetDepth(pixm) != 1) |
| return (PIX *)ERROR_PTR("pixm not 1 bpp", procName, NULL); |
| if ((cmap = pixGetColormap(pixd)) == NULL) |
| return (PIX *)ERROR_PTR("pixd not cmapped", procName, NULL); |
| pixGetDimensions(pixd, &wd, &hd, NULL); |
| if (w != wd || h != hd) |
| return (PIX *)ERROR_PTR("pixs, pixd sizes differ", procName, NULL); |
| nc = pixcmapGetCount(cmap); |
| nestim = nc + (l_int32)(1.5 * 255 / maxsize); |
| fprintf(stderr, "nestim = %d\n", nestim); |
| if (nestim > 255) { |
| L_ERROR_INT("Estimate %d colors!", procName, nestim); |
| return (PIX *)ERROR_PTR("probably too many colors", procName, NULL); |
| } |
| pixGetDimensions(pixm, &wm, &hm, NULL); |
| if (w != wm || h != hm) { /* resize the mask */ |
| L_WARNING("mask and dest sizes not equal", procName); |
| pixmr = pixCreateNoInit(w, h, 1); |
| pixRasterop(pixmr, 0, 0, wm, hm, PIX_SRC, pixm, 0, 0); |
| pixRasterop(pixmr, wm, 0, w - wm, h, PIX_SET, NULL, 0, 0); |
| pixRasterop(pixmr, 0, hm, wm, h - hm, PIX_SET, NULL, 0, 0); |
| } |
| else |
| pixmr = pixClone(pixm); |
| } |
| else { |
| pixd = pixCreateTemplate(pixs); |
| cmap = pixcmapCreate(8); |
| pixSetColormap(pixd, cmap); |
| } |
| |
| /* Use original mask, if it exists, to select gray pixels */ |
| na = pixGetGrayHistogramMasked(pixs, pixm, 0, 0, 1); |
| |
| /* Fill out the cmap with gray colors, and generate the lut |
| * for pixel assignment. Issue a warning on failure. */ |
| if (numaFillCmapFromHisto(na, cmap, minfract, maxsize, &lut)) |
| L_ERROR("ran out of colors in cmap!", procName); |
| numaDestroy(&na); |
| |
| /* Assign the gray pixels to their cmap indices */ |
| datas = pixGetData(pixs); |
| datad = pixGetData(pixd); |
| wpls = pixGetWpl(pixs); |
| wpld = pixGetWpl(pixd); |
| if (!pixm) { |
| for (i = 0; i < h; i++) { |
| lines = datas + i * wpls; |
| lined = datad + i * wpld; |
| for (j = 0; j < w; j++) { |
| vals = GET_DATA_BYTE(lines, j); |
| vald = lut[vals]; |
| SET_DATA_BYTE(lined, j, vald); |
| } |
| } |
| FREE(lut); |
| return pixd; |
| } |
| |
| datam = pixGetData(pixmr); |
| wplm = pixGetWpl(pixmr); |
| for (i = 0; i < h; i++) { |
| lines = datas + i * wpls; |
| linem = datam + i * wplm; |
| lined = datad + i * wpld; |
| for (j = 0; j < w; j++) { |
| if (!GET_DATA_BIT(linem, j)) |
| continue; |
| vals = GET_DATA_BYTE(lines, j); |
| vald = lut[vals]; |
| SET_DATA_BYTE(lined, j, vald); |
| } |
| } |
| pixDestroy(&pixmr); |
| FREE(lut); |
| return pixd; |
| } |
| |
| |
| /*! |
| * numaFillCmapFromHisto() |
| * |
| * Input: na (histogram of gray values) |
| * cmap (8 bpp cmap, possibly initialized with color value) |
| * 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) |
| * 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) |
| * &lut (<return> lookup table from gray value to colormap index) |
| * Return: 0 if OK, 1 on error |
| * |
| * Notes: |
| * (1) This static function must be called from pixGrayQuantFromHisto() |
| */ |
| static l_int32 |
| numaFillCmapFromHisto(NUMA *na, |
| PIXCMAP *cmap, |
| l_float32 minfract, |
| l_int32 maxsize, |
| l_int32 **plut) |
| { |
| l_int32 mincount, index, sum, wtsum, span, istart, i, val, ret; |
| l_int32 *iahisto, *lut; |
| l_float32 total; |
| |
| PROCNAME("numaFillCmapFromHisto"); |
| |
| if (!plut) |
| return ERROR_INT("&lut not defined", procName, 1); |
| *plut = NULL; |
| if (!na) |
| return ERROR_INT("na not defined", procName, 1); |
| if (!cmap) |
| return ERROR_INT("cmap not defined", procName, 1); |
| |
| numaGetSum(na, &total); |
| mincount = (l_int32)(minfract * total); |
| iahisto = numaGetIArray(na); |
| if ((lut = (l_int32 *)CALLOC(256, sizeof(l_int32))) == NULL) |
| return ERROR_INT("lut not made", procName, 1); |
| *plut = lut; |
| index = pixcmapGetCount(cmap); /* start with number of colors |
| * already reserved */ |
| |
| /* March through, associating colors with sets of adjacent |
| * gray levels. During the process, the LUT that gives |
| * the colormap index for each gray level is computed. |
| * To complete a color, either the total count must equal |
| * or exceed @mincount, or the current span of colors must |
| * equal or exceed @maxsize. An empty span is not converted |
| * into a color; it is simply ignored. When a span is completed for a |
| * color, the weighted color in the span is added to the colormap. */ |
| sum = 0; |
| wtsum = 0; |
| istart = 0; |
| ret = 0; |
| for (i = 0; i < 256; i++) { |
| lut[i] = index; |
| sum += iahisto[i]; |
| wtsum += i * iahisto[i]; |
| span = i - istart + 1; |
| if (sum < mincount && span < maxsize) |
| continue; |
| |
| if (sum == 0) { /* empty span; don't save */ |
| istart = i + 1; |
| continue; |
| } |
| |
| /* Found new color; sum > 0 */ |
| val = (l_int32)((l_float32)wtsum / (l_float32)sum + 0.5); |
| ret = pixcmapAddColor(cmap, val, val, val); |
| istart = i + 1; |
| sum = 0; |
| wtsum = 0; |
| index++; |
| } |
| if (istart < 256 && sum > 0) { /* last one */ |
| span = 256 - istart; |
| val = (l_int32)((l_float32)wtsum / (l_float32)sum + 0.5); |
| ret = pixcmapAddColor(cmap, val, val, val); |
| } |
| |
| FREE(iahisto); |
| return ret; |
| } |
| |
| |
| /*----------------------------------------------------------------------* |
| * Color quantize grayscale image using existing colormap * |
| *----------------------------------------------------------------------*/ |
| /*! |
| * pixGrayQuantFromCmap() |
| * |
| * Input: pixs (8 bpp grayscale without cmap) |
| * cmap (to quantize to; of dest pix) |
| * mindepth (minimum depth of pixd: can be 2, 4 or 8 bpp) |
| * Return: pixd (2, 4 or 8 bpp, colormapped), or null on error |
| * |
| * 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. |
| */ |
| PIX * |
| pixGrayQuantFromCmap(PIX *pixs, |
| PIXCMAP *cmap, |
| l_int32 mindepth) |
| { |
| l_int32 i, j, index, w, h, d, depth, wpls, wpld; |
| l_int32 hascolor, vals, vald; |
| l_int32 *tab; |
| l_uint32 *datas, *datad, *lines, *lined; |
| PIXCMAP *cmapd; |
| PIX *pixd; |
| |
| PROCNAME("pixGrayQuantFromCmap"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (pixGetColormap(pixs) != NULL) { |
| L_WARNING("pixs already has a colormap; returning a copy", procName); |
| return pixCopy(NULL, pixs); |
| } |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 8) |
| return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL); |
| if (!cmap) |
| return (PIX *)ERROR_PTR("cmap not defined", procName, NULL); |
| if (mindepth != 2 && mindepth != 4 && mindepth != 8) |
| return (PIX *)ERROR_PTR("invalid mindepth", procName, NULL); |
| |
| /* Make sure the colormap is gray */ |
| pixcmapHasColor(cmap, &hascolor); |
| if (hascolor) { |
| L_WARNING("Converting colormap colors to gray", procName); |
| cmapd = pixcmapColorToGray(cmap, 0.3, 0.5, 0.2); |
| } |
| else |
| cmapd = pixcmapCopy(cmap); |
| |
| /* Make LUT into colormap */ |
| if ((tab = (l_int32 *)CALLOC(256, sizeof(l_int32))) == NULL) |
| return (PIX *)ERROR_PTR("tab not made", procName, NULL); |
| for (i = 0; i < 256; i++) { |
| pixcmapGetNearestGrayIndex(cmapd, i, &index); |
| tab[i] = index; |
| } |
| |
| pixcmapGetMinDepth(cmap, &depth); |
| depth = L_MAX(depth, mindepth); |
| pixd = pixCreate(w, h, depth); |
| pixSetColormap(pixd, cmapd); |
| pixCopyResolution(pixd, pixs); |
| pixCopyInputFormat(pixd, pixs); |
| datas = pixGetData(pixs); |
| datad = pixGetData(pixd); |
| wpls = pixGetWpl(pixs); |
| wpld = pixGetWpl(pixd); |
| for (i = 0; i < h; i++) { |
| lines = datas + i * wpls; |
| lined = datad + i * wpld; |
| for (j = 0; j < w; j++) { |
| vals = GET_DATA_BYTE(lines, j); |
| vald = tab[vals]; |
| if (depth == 2) |
| SET_DATA_DIBIT(lined, j, vald); |
| else if (depth == 4) |
| SET_DATA_QBIT(lined, j, vald); |
| else /* depth == 8 */ |
| SET_DATA_BYTE(lined, j, vald); |
| } |
| } |
| |
| FREE(tab); |
| return pixd; |
| } |
| |
| |
