#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "allheaders.h"
#define DEBUG_CONVERT_TO_COLORMAP 0 |
#define DEBUG_UNROLLING 0 |
l_int32 convertHSVToRGB | ( | l_int32 | hval, | |
l_int32 | sval, | |||
l_int32 | vval, | |||
l_int32 * | prval, | |||
l_int32 * | pgval, | |||
l_int32 * | pbval | |||
) |
Input: hval, sval, vval &rval, &gval, &bval (<return> RGB values) Return: 0 if OK, 1 on error
Notes: (1) See convertRGBToHSV() for valid input range of HSV values and their interpretation in color space.
l_int32 convertRGBToHSV | ( | l_int32 | rval, | |
l_int32 | gval, | |||
l_int32 | bval, | |||
l_int32 * | phval, | |||
l_int32 * | psval, | |||
l_int32 * | pvval | |||
) |
Input: rval, gval, bval (RGB input) &hval, &sval, &vval (<return> HSV values) Return: 0 if OK, 1 on error
Notes: (1) The range of returned values is: h [0 ... 239] s [0 ... 255] v [0 ... 255] (2) If r = g = b, the pixel is gray (s = 0), and we define h = 0. (3) h wraps around, so that h = 0 and h = 240 are equivalent in hue space. (4) h has the following correspondence to color: h = 0 magenta h = 40 red h = 80 yellow h = 120 green h = 160 cyan h = 200 blue
Input: pixs (8 bpp) Return: 0 if OK, 1 on error
Notes: (1) If pixs has a colormap, this is a no-op.
Input: pixs (8 bpp) Return: 0 if OK, 1 on error
Notes: (1) This generates a colormapped version of the input image that has the same number of colormap entries as the input image has unique gray levels.
Input: pixs (8 bpp gray; 2, 4 or 8 bpp colormapped) color (32 bit rgba pixel) cmapflag (1 for result to have colormap; 0 for RGB) Return: pixd (8 bpp colormapped or 32 bpp rgb), or null on error
Notes: (1) This applies the specific color to the grayscale image. (2) If pixs already has a colormap, it is removed to gray before colorizing.
Input: pixs (16 bpp) whichbyte (1 for MSB, 0 for LSB) Return: pixd (8 bpp), or null on error
Notes: (1) For each dest pixel, use either the MSB or LSB of each src pixel.
Input: pixd (<optional> 16 bpp, can be null) pixs (1 bpp) val0 (16 bit value to be used for 0s in pixs) val1 (16 bit value to be used for 1s in pixs) Return: pixd (16 bpp)
Notes: (1) If pixd is null, a new pix is made. (2) If pixd is not null, it must be of equal width and height as pixs. It is always returned.
Input: pixd (<optional> 2 bpp, can be null) pixs (1 bpp) val0 (2 bit value to be used for 0s in pixs) val1 (2 bit value to be used for 1s in pixs) Return: pixd (2 bpp)
Notes: (1) If pixd is null, a new pix is made. (2) If pixd is not null, it must be of equal width and height as pixs. It is always returned. (3) A simple unpacking might use val0 = 0 and val1 = 3. (4) If you want a colormapped pixd, use pixConvert1To2Cmap().
Input: pixs (1 bpp) Return: pixd (2 bpp, cmapped)
Notes: (1) Input 0 is mapped to (255, 255, 255); 1 is mapped to (0, 0, 0)
Input: pixd (<optional> 32 bpp, can be null) pixs (1 bpp) val0 (32 bit value to be used for 0s in pixs) val1 (32 bit value to be used for 1s in pixs) Return: pixd (32 bpp)
Notes: (1) If pixd is null, a new pix is made. (2) If pixd is not null, it must be of equal width and height as pixs. It is always returned.
Input: pixd (<optional> 4 bpp, can be null) pixs (1 bpp) val0 (4 bit value to be used for 0s in pixs) val1 (4 bit value to be used for 1s in pixs) Return: pixd (4 bpp)
Notes: (1) If pixd is null, a new pix is made. (2) If pixd is not null, it must be of equal width and height as pixs. It is always returned. (3) A simple unpacking might use val0 = 0 and val1 = 15, or v.v. (4) If you want a colormapped pixd, use pixConvert1To4Cmap().
Input: pixs (1 bpp) Return: pixd (4 bpp, cmapped)
Notes: (1) Input 0 is mapped to (255, 255, 255); 1 is mapped to (0, 0, 0)
Input: pixd (<optional> 8 bpp, can be null) pixs (1 bpp) val0 (8 bit value to be used for 0s in pixs) val1 (8 bit value to be used for 1s in pixs) Return: pixd (8 bpp)
Notes: (1) If pixd is null, a new pix is made. (2) If pixd is not null, it must be of equal width and height as pixs. It is always returned. (3) A simple unpacking might use val0 = 0 and val1 = 255, or v.v. (4) In a typical application where one wants to use a colormap with the dest, you can use val0 = 0, val1 = 1 to make a non-cmapped 8 bpp pix, and then make a colormap and set 0 and 1 to the desired colors. Here is an example: pixd = pixConvert1To8(NULL, pixs, 0, 1); cmap = pixCreate(8); pixcmapAddColor(cmap, 255, 255, 255); pixcmapAddColor(cmap, 0, 0, 0); pixSetColormap(pixd, cmap);
PIX* pixConvert2To8 | ( | PIX * | pixs, | |
l_uint8 | val0, | |||
l_uint8 | val1, | |||
l_uint8 | val2, | |||
l_uint8 | val3, | |||
l_int32 | cmapflag | |||
) |
Input: pixs (2 bpp) val0 (8 bit value to be used for 00 in pixs) val1 (8 bit value to be used for 01 in pixs) val2 (8 bit value to be used for 10 in pixs) val3 (8 bit value to be used for 11 in pixs) cmapflag (TRUE if pixd is to have a colormap; FALSE otherwise) Return: pixd (8 bpp), or null on error
Notes:
Input: pixs (4 bpp) cmapflag (TRUE if pixd is to have a colormap; FALSE otherwise) Return: pixd (8 bpp), or null on error
Notes:
Input: pixs (8 bpp; colormap removed to gray) leftshift (number of bits: 0 is no shift; 8 replicates in MSB and LSB of dest) Return: pixd (16 bpp), or null on error
Notes: (1) For left shift of 8, the 8 bit value is replicated in both the MSB and the LSB of the pixels in pixd. That way, we get proportional mapping, with a correct map from 8 bpp white (0xff) to 16 bpp white (0xffff).
Input: pix (8 bpp) Return: 32 bpp rgb pix, or null on error
Notes: (1) If there is no colormap, replicates the gray value into the 3 MSB of the dest pixel. (2) Implicit assumption about RGB component ordering.
Input: pixs (1, 2, 4, 8, 16, 32 bpp) Return: pixd (1, 8, or 32 bpp), or null on error
Notes: (1) For wrapping in PostScript, we convert pixs to 1 bpp, 8 bpp (gray) and 32 bpp (RGB color). (2) Colormaps are removed. For pixs with colormaps, the images are converted to either 8 bpp gray or 32 bpp RGB, depending on whether the colormap has color content. (3) Images without colormaps, that are not 1 bpp or 32 bpp, are converted to 8 bpp gray.
Input: pixs (2, 4 or 8 bpp grayscale) Return: pixd (2, 4 or 8 bpp with colormap), or null on error
Notes: (1) This is a simple interface for adding a colormap to a 2, 4 or 8 bpp grayscale image without causing any quantization. There is some similarity to operations in grayquant.c, such as pixThresholdOn8bpp(), where the emphasis is on quantization with an arbitrary number of levels, and a colormap is an option. (2) Returns a copy if pixs already has a colormap. (3) For 8 bpp src, this is a lossless transformation. (4) For 2 and 4 bpp src, this generates a colormap that assumes full coverage of the gray space, with equally spaced levels: 4 levels for d = 2 and 16 levels for d = 4. (5) In all cases, the depth of the dest is the same as the src.
Input: pixs (8 bpp grayscale) mindepth (of pixd; valid values are 2, 4 and 8) Return: pixd (2, 4 or 8 bpp with colormap), or null on error
Notes: (1) Returns a copy if pixs already has a colormap. (2) This is a lossless transformation; there is no quantization. We compute the number of different gray values in pixs, and construct a colormap that has exactly these values. (3) 'mindepth' is the minimum depth of pixd. If mindepth == 8, pixd will always be 8 bpp. Let the number of different gray values in pixs be ngray. If mindepth == 4, we attempt to save pixd as a 4 bpp image, but if ngray > 16, pixd must be 8 bpp. Likewise, if mindepth == 2, the depth of pixd will be 2 if ngray <= 4 and 4 if ngray > 4 but <= 16.
Input: pixs (8 or 16 bpp grayscale) gamma factor (0.0 or 1.0 for default; > 1.0 for brighter; 2.0 is quite nice) Return: pixd (8 bpp with colormap), or null on error
Notes: (1) For 8 bpp input, this simply adds a colormap to the input image. (2) For 16 bpp input, it first converts to 8 bpp and then adds the colormap. (3) The colormap is modeled after the Matlab "jet" configuration.
Input: pixd (can be NULL; if not NULL, must == pixs) pixs Return: pixd always
Notes: (1) For pixs = pixd, this is in-place; otherwise pixd must be NULL. (2) The user takes responsibility for making sure that pixs is in our HSV space. The definition of our HSV space is given in convertRGBToHSV(). (3) The h, s and v values are stored in the same places as the r, g and b values, respectively. Here, they are explicitly placed in the 3 MS bytes in the pixel.
Input: pixs (1, 2, 4, 8 bpp, not cmapped) d (destination depth: 2, 4 or 8) Return: pixd (2, 4 or 8 bpp), or null on error
Notes: (1) This is a lossless unpacking (depth-increasing) conversion. If ds is the depth of pixs, then
Input: pixs (32 bpp rgb) ditherflag (1 to dither, 0 otherwise) Return: pixd (2, 4 or 8 bpp with colormap), or null on error
Notes: (1) This function has two relatively simple modes of color quantization: (a) If the image is made orthographically and has not more than 256 'colors' at the level 4 octcube leaves, it is quantized nearly exactly. The ditherflag is ignored. (b) Most natural images have more than 256 different colors; in that case we use adaptive octree quantization, with dithering if requested. (2) If there are not more than 256 occupied level 4 octcubes, the color in the colormap that represents all pixels in one of those octcubes is given by the first pixel that falls into that octcube. (3) If there are more than 256 colors, we use adaptive octree color quantization. (4) Dithering gives better visual results on images where there is a color wash (a slow variation of color), but it is about twice as slow and results in significantly larger files when losslessly compressed (e.g., into png).
Input: pix (32 bpp RGB) rwt, gwt, bwt (non-negative; these should add to 1.0, or use 0.0 for default) Return: 8 bpp pix, or null on error
Notes: (1) Use a weighted average of the RGB values.
Input: pix (32 bpp RGB) Return: 8 bpp pix, or null on error
Notes: (1) This function should be used if speed of conversion is paramount, and the green channel can be used as a fair representative of the RGB intensity. It is several times faster than pixConvertRGBToGray(). (2) To combine RGB to gray conversion with subsampling, use pixScaleRGBToGrayFast() instead.
Input: pix (32 bpp RGB) type (L_CHOOSE_MIN or L_CHOOSE_MAX) Return: 8 bpp pix, or null on error
Notes: (1) chooses among the 3 color components for each pixel (2) This is useful when looking for the maximum deviation of a component from either 0 or 255. For finding the deviation of a single component, it is more sensitive than using a weighted average.
Input: pixd (can be NULL; if not NULL, must == pixs) pixs Return: pixd always
Notes: (1) For pixs = pixd, this is in-place; otherwise pixd must be NULL. (2) The definition of our HSV space is given in convertRGBToHSV(). (3) The h, s and v values are stored in the same places as the r, g and b values, respectively. Here, they are explicitly placed in the 3 MS bytes in the pixel. (4) Normalizing to 1 and considering the r,g,b components, a simple way to understand the HSV space is:
Input: pixs (32 bpp RGB or 8 bpp with colormap) Return: pixd (8 bpp hue of HSV), or null on error
Notes: (1) The conversion to HSV hue is in-lined here. (2) If there is a colormap, it is removed. (3) If you just want the hue component, this does it at about 10 Mpixels/sec/GHz, which is about 2x faster than using pixConvertRGBToHSV()
Input: pix (32 bpp RGB) Return: 8 bpp pix, or null on error
Notes: (1) Use a standard luminance conversion.
Input: pixs (32 bpp RGB or 8 bpp with colormap) Return: pixd (8 bpp sat of HSV), or null on error
Notes: (1) The conversion to HSV sat is in-lined here. (2) If there is a colormap, it is removed. (3) If you just want the saturation component, this does it at about 12 Mpixels/sec/GHz.
Input: pixs (32 bpp RGB or 8 bpp with colormap) Return: pixd (8 bpp max component intensity of HSV), or null on error
Notes: (1) The conversion to HSV sat is in-lined here. (2) If there is a colormap, it is removed. (3) If you just want the value component, this does it at about 35 Mpixels/sec/GHz.
Input: pixs (1, 2, 4, 8, 16 or 32 bpp) threshold (for final binarization, relative to 8 bpp) Return: pixd (1 bpp), or null on error
Notes: (1) This is a top-level function, with simple default values used in pixConvertTo8() if unpacking is necessary. (2) Any existing colormap is removed. (3) If the input image has 1 bpp and no colormap, the operation is lossless and a copy is returned.
Input: pixs (1, 8 bpp) Return: pixd (16 bpp), or null on error
Usage: Top-level function, with simple default values for unpacking. 1 bpp: val0 = 0xffff, val1 = 0 8 bpp: replicates the 8 bit value in both the MSB and LSB of the 16 bit pixel.
Input: pixs (1, 2, 4, 8, 16 or 32 bpp) factor (submsampling factor; integer >= 1) threshold (for final binarization, relative to 8 bpp) Return: pixd (1 bpp), or null on error
Notes: (1) This is a fast, quick/dirty, top-level converter. (2) See pixConvertTo1() for default values.
Input: pixs (1, 2, 4, 8, 16 or 32 bpp) Return: pixd (32 bpp), or null on error
Usage: Top-level function, with simple default values for unpacking. 1 bpp: val0 = 255, val1 = 0 and then replication into R, G and B components 2 bpp: if colormapped, use the colormap values; otherwise, use val0 = 0, val1 = 0x55, val2 = 0xaa, val3 = 255 and replicate gray into R, G and B components 4 bpp: if colormapped, use the colormap values; otherwise, replicate 2 nybs into a byte, and then into R,G,B components 8 bpp: if colormapped, use the colormap values; otherwise, replicate gray values into R, G and B components 16 bpp: replicate MSB into R, G and B components 32 bpp: makes a copy
Notes: (1) Implicit assumption about RGB component ordering.
Input: pixs (1, 2, 4, 8, 16 or 32 bpp) factor (submsampling factor; integer >= 1) Return: pixd (32 bpp), or null on error
Notes: (1) This is a fast, quick/dirty, top-level converter. (2) See pixConvertTo32() for default values.
Input: pixs (1, 2, 4, 8, 16 or 32 bpp) cmapflag (TRUE if pixd is to have a colormap; FALSE otherwise) Return: pixd (8 bpp), or null on error
Notes: (1) This is a top-level function, with simple default values for unpacking. (2) The result, pixd, is made with a colormap if specified. (3) If d == 8, and cmapflag matches the existence of a cmap in pixs, the operation is lossless and it returns a copy. (4) The default values used are:
Input: pixs (1, 2, 4, 8, 16 or 32 bpp) factor (submsampling factor; integer >= 1) cmapflag (TRUE if pixd is to have a colormap; FALSE otherwise) Return: pixd (8 bpp), or null on error
Notes: (1) This is a fast, quick/dirty, top-level converter. (2) See pixConvertTo8() for default values.
Input: pixs (1, 2, 4, 8, 16, with or without colormap; or 32 bpp rgb) copyflag (use 0 to return clone if pixs does not need to be changed; 1 to return a copy in those situations) warnflag (1 to issue warning if colormap is removed; else 0) Return: pixd (8 bpp grayscale or 32 bpp rgb), or null on error
Notes: (1) If there is a colormap, the colormap is removed to 8 or 32 bpp, depending on whether the colors in the colormap are all gray. (2) If the input is either rgb or 8 bpp without a colormap, this returns either a clone or a copy, depending on . (3) Otherwise, the pix is converted to 8 bpp grayscale. In all cases, pixd does not have a colormap.
l_int32 pixQuantizeIfFewColors | ( | PIX * | pixs, | |
l_int32 | maxcolors, | |||
l_int32 | mingraycolors, | |||
l_int32 | octlevel, | |||
PIX ** | ppixd | |||
) |
Input: pixs (8 bpp gray or 32 bpp rgb) maxcolors (max number of colors allowed to be returned from pixColorsForQuantization(); use 0 for default) mingraycolors (min number of gray levels that a grayscale image is quantized to; use 0 for default) octlevel (for octcube quantization: 3 or 4) &pixd (2, 4 or 8 bpp quantized; null if too many colors) Return: 0 if OK, 1 on error or if pixs can't be quantized into a small number of colors.
Notes: (1) This is a wrapper that tests if the pix can be quantized with good quality using a small number of colors. If so, it does the quantization, defining a colormap and using pixels whose value is an index into the colormap. (2) If the image has color, it is quantized with 8 bpp pixels. If the image is essentially grayscale, the pixels are either 4 or 8 bpp, depending on the size of the required colormap. (3) = 3 works well for most images. However, for best quality, at a cost of more colors in the colormap, use = 4. (4) If the image already has a colormap, it returns a clone.
Input: pixs (see restrictions below) type (REMOVE_CMAP_TO_BINARY, REMOVE_CMAP_TO_GRAYSCALE, REMOVE_CMAP_TO_FULL_COLOR, REMOVE_CMAP_BASED_ON_SRC) Return: new pix, or null on error
Notes: (1) If there is no colormap, a clone is returned. (2) Otherwise, the input pixs is restricted to 1, 2, 4 or 8 bpp. (3) Use REMOVE_CMAP_TO_BINARY only on 1 bpp pix. (4) For grayscale conversion from RGB, use a weighted average of RGB values, and always return an 8 bpp pix, regardless of whether the input pixs depth is 2, 4 or 8 bpp.
Input: pix (8 bpp grayscale) d (destination depth: 1, 2, 4 or 8) nlevels (number of levels to be used for colormap) cmapflag (1 if makes colormap; 0 otherwise) Return: pixd (thresholded with standard dest thresholds), or null on error
Notes: (1) This uses, by default, equally spaced "target" values that depend on the number of levels, with thresholds halfway between. For N levels, with separation (N-1)/255, there are N-1 fixed thresholds. (2) For 1 bpp destination, the number of levels can only be 2 and if a cmap is made, black is (0,0,0) and white is (255,255,255), which is opposite to the convention without a colormap. (3) For 1, 2 and 4 bpp, the nlevels arg is used if a colormap is made; otherwise, we take the most significant bits from the src that will fit in the dest. (4) For 8 bpp, the input pixs is quantized to nlevels. The dest quantized with that mapping, either through a colormap table or directly with 8 bit values. (5) Typically you should not use make a colormap for 1 bpp dest. (6) This is not dithering. Each pixel is treated independently.
Input: pixs (1 bpp) depth (of destination: 2, 4, 8, 16 or 32 bpp) invert (0: binary 0 --> grayscale 0 binary 1 --> grayscale 0xff... 1: binary 0 --> grayscale 0xff... binary 1 --> grayscale 0) Return: pixd (2, 4, 8, 16 or 32 bpp), or null on error
Notes: (1) This function calls special cases of pixConvert1To*(), for 2, 4, 8, 16 and 32 bpp destinations.
const l_float32 L_BLUE_WEIGHT = 0.2 [static] |
const l_float32 L_GREEN_WEIGHT = 0.5 [static] |
const l_float32 L_RED_WEIGHT = 0.3 [static] |