/*====================================================================*
- 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.
*====================================================================*/
/*
* colormap.c
*
* Colormap creation, copy, destruction, addition
* PIXCMAP *pixcmapCreate()
* PIXCMAP *pixcmapCreateRandom()
* PIXCMAP *pixcmapCreateLinear()
* PIXCMAP *pixcmapCopy()
* void pixcmapDestroy()
* l_int32 pixcmapAddColor()
* l_int32 pixcmapAddNewColor()
* l_int32 pixcmapAddBlackOrWhite()
* l_int32 pixcmapSetBlackAndWhite()
* l_int32 pixcmapGetCount()
* l_int32 pixcmapGetDepth()
* l_int32 pixcmapGetMinDepth()
* l_int32 pixcmapGetFreeCount()
* l_int32 pixcmapClear()
*
* Colormap random access and test
* l_int32 pixcmapGetColor()
* l_int32 pixcmapResetColor()
* l_int32 pixcmapGetIndex()
* l_int32 pixcmapHasColor()
* l_int32 pixcmapCountGrayColors()
* l_int32 pixcmapGetRankIntensity()
* l_int32 pixcmapGetNearestIndex()
* l_int32 pixcmapGetNearestGrayIndex()
* l_int32 pixcmapGetExtremeValue()
*
* Colormap conversion
* PIXCMAP *pixcmapGrayToColor()
* PIXCMAP *pixcmapColorToGray()
*
* Colormap I/O
* l_int32 pixcmapReadStream()
* l_int32 pixcmapWriteStream()
*
* Extract colormap arrays
* l_int32 pixcmapToArrays()
* l_int32 pixcmapToRGBTable()
*
* Colormap transforms
* l_int32 pixcmapGammaTRC()
* l_int32 pixcmapContrastTRC()
* l_int32 pixcmapShiftIntensity()
* l_int32 pixcmapConvertRGBToHSV()
* l_int32 pixcmapConvertHSVToRGB()
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "allheaders.h"
/*-------------------------------------------------------------*
* Colormap creation and addition *
*-------------------------------------------------------------*/
/*!
* pixcmapCreate()
*
* Input: depth (bpp, of pix)
* Return: cmap, or null on error
*/
PIXCMAP *
pixcmapCreate(l_int32 depth)
{
RGBA_QUAD *cta;
PIXCMAP *cmap;
PROCNAME("pixcmapCreate");
if (depth != 1 && depth != 2 && depth !=4 && depth != 8)
return (PIXCMAP *)ERROR_PTR("depth not in {1,2,4,8}", procName, NULL);
if ((cmap = (PIXCMAP *)CALLOC(1, sizeof(PIXCMAP))) == NULL)
return (PIXCMAP *)ERROR_PTR("cmap not made", procName, NULL);
cmap->depth = depth;
cmap->nalloc = 1 << depth;
if ((cta = (RGBA_QUAD *)CALLOC(cmap->nalloc, sizeof(RGBA_QUAD))) == NULL)
return (PIXCMAP *)ERROR_PTR("cta not made", procName, NULL);
cmap->array = cta;
cmap->n = 0;
return cmap;
}
/*!
* pixcmapCreateRandom()
*
* Input: depth (bpp, of pix; 2, 4 or 8)
* hasblack (1 if the first color is black; 0 if no black)
* haswhite (1 if the last color is white; 0 if no white)
* Return: cmap, or null on error
*
* Notes:
* (1) This sets up a colormap with random colors,
* where the first color is optionally black, the last color
* is optionally white, and the remaining colors are
* chosen randomly.
* (2) The number of randomly chosen colors is:
* 2^(depth) - haswhite - hasblack
* (3) Because rand() is seeded, it might disrupt otherwise
* deterministic results if also used elsewhere in a program.
* (4) rand() is not threadsafe, and will generate garbage if run
* on multiple threads at once -- though garbage is generally
* what you want from a random number generator!
* (5) Modern rand()s have equal randomness in low and high order
* bits, but older ones don't. Here, we're just using rand()
* to choose colors for output.
*/
PIXCMAP *
pixcmapCreateRandom(l_int32 depth,
l_int32 hasblack,
l_int32 haswhite)
{
l_int32 ncolors, i;
l_int32 red[256], green[256], blue[256];
PIXCMAP *cmap;
PROCNAME("pixcmapCreateRandom");
if (depth != 2 && depth != 4 && depth != 8)
return (PIXCMAP *)ERROR_PTR("depth not in {2, 4, 8}", procName, NULL);
if (hasblack != 0) hasblack = 1;
if (haswhite != 0) haswhite = 1;
cmap = pixcmapCreate(depth);
ncolors = 1 << depth;
if (hasblack) /* first color is optionally black */
pixcmapAddColor(cmap, 0, 0, 0);
for (i = hasblack; i < ncolors - haswhite; i++) {
red[i] = (l_uint32)rand() & 0xff;
green[i] = (l_uint32)rand() & 0xff;
blue[i] = (l_uint32)rand() & 0xff;
pixcmapAddColor(cmap, red[i], green[i], blue[i]);
}
if (haswhite) /* last color is optionally white */
pixcmapAddColor(cmap, 255, 255, 255);
return cmap;
}
/*!
* pixcmapCreateLinear()
*
* Input: d (depth of pix for this colormap; 1, 2, 4 or 8)
* nlevels (valid in range [2, 2^d])
* Return: cmap, or null on error
*
* Notes:
* (1) Colormap has equally spaced gray color values
* from black (0, 0, 0) to white (255, 255, 255).
*/
PIXCMAP *
pixcmapCreateLinear(l_int32 d,
l_int32 nlevels)
{
l_int32 maxlevels, i, val;
PIXCMAP *cmap;
PROCNAME("pixcmapCreateLinear");
if (d != 1 && d != 2 && d !=4 && d != 8)
return (PIXCMAP *)ERROR_PTR("d not in {1, 2, 4, 8}", procName, NULL);
maxlevels = 1 << d;
if (nlevels < 2 || nlevels > maxlevels)
return (PIXCMAP *)ERROR_PTR("invalid nlevels", procName, NULL);
cmap = pixcmapCreate(d);
for (i = 0; i < nlevels; i++) {
val = (255 * i) / (nlevels - 1);
pixcmapAddColor(cmap, val, val, val);
}
return cmap;
}
/*!
* pixcmapCopy()
*
* Input: cmaps
* Return: cmapd, or null on error
*/
PIXCMAP *
pixcmapCopy(PIXCMAP *cmaps)
{
l_int32 nbytes;
PIXCMAP *cmapd;
PROCNAME("pixcmapCopy");
if (!cmaps)
return (PIXCMAP *)ERROR_PTR("cmaps not defined", procName, NULL);
if ((cmapd = (PIXCMAP *)CALLOC(1, sizeof(PIXCMAP))) == NULL)
return (PIXCMAP *)ERROR_PTR("cmapd not made", procName, NULL);
nbytes = cmaps->nalloc * sizeof(RGBA_QUAD);
if ((cmapd->array = (void *)CALLOC(1, nbytes)) == NULL)
return (PIXCMAP *)ERROR_PTR("cmap array not made", procName, NULL);
memcpy(cmapd->array, cmaps->array, nbytes);
cmapd->n = cmaps->n;
cmapd->nalloc = cmaps->nalloc;
cmapd->depth = cmaps->depth;
return cmapd;
}
/*!
* pixcmapDestroy()
*
* Input: &cmap (<set to null>)
* Return: void
*/
void
pixcmapDestroy(PIXCMAP **pcmap)
{
PIXCMAP *cmap;
PROCNAME("pixcmapDestroy");
if (pcmap == NULL) {
L_WARNING("ptr address is null!", procName);
return;
}
if ((cmap = *pcmap) == NULL)
return;
FREE(cmap->array);
FREE(cmap);
*pcmap = NULL;
return;
}
/*!
* pixcmapAddColor()
*
* Input: cmap
* rval, gval, bval (colormap entry to be added; each number
* is in range [0, ... 255])
* Return: 0 if OK, 1 on error
*
* Note: always adds the color if there is room.
*/
l_int32
pixcmapAddColor(PIXCMAP *cmap,
l_int32 rval,
l_int32 gval,
l_int32 bval)
{
RGBA_QUAD *cta;
PROCNAME("pixcmapAddColor");
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (cmap->n >= cmap->nalloc)
return ERROR_INT("no free color entries", procName, 1);
cta = (RGBA_QUAD *)cmap->array;
cta[cmap->n].red = rval;
cta[cmap->n].green = gval;
cta[cmap->n].blue = bval;
cmap->n++;
return 0;
}
/*!
* pixcmapAddNewColor()
*
* Input: cmap
* rval, gval, bval (colormap entry to be added; each number
* is in range [0, ... 255])
* &index (<return> index of color)
* Return: 0 if OK, 1 on error; 2 if unable to add color
*
* Notes:
* (1) This only adds color if not already there.
* (2) This returns the index of the new (or existing) color.
* (3) Returns 2 with a warning if unable to add this color;
* the caller should check the return value.
*/
l_int32
pixcmapAddNewColor(PIXCMAP *cmap,
l_int32 rval,
l_int32 gval,
l_int32 bval,
l_int32 *pindex)
{
PROCNAME("pixcmapAddNewColor");
if (!pindex)
return ERROR_INT("&index not defined", procName, 1);
*pindex = 0;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
/* Check if the color is already present. */
if (!pixcmapGetIndex(cmap, rval, gval, bval, pindex)) /* found */
return 0;
/* We need to add the color. Is there room? */
if (cmap->n >= cmap->nalloc) {
L_WARNING("no free color entries", procName);
return 2;
}
/* There's room. Add it. */
pixcmapAddColor(cmap, rval, gval, bval);
*pindex = pixcmapGetCount(cmap) - 1;
return 0;
}
/*!
* pixcmapAddBlackOrWhite()
*
* Input: cmap
* color (0 for black, 1 for white)
* &index (<optional return> index of color; can be null)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This only adds color if not already there.
* (2) This sets index to the requested color.
* (3) If there is no room in the colormap, returns the index
* of the closest color.
*/
l_int32
pixcmapAddBlackOrWhite(PIXCMAP *cmap,
l_int32 color,
l_int32 *pindex)
{
l_int32 index;
PROCNAME("pixcmapAddBlackOrWhite");
if (pindex) *pindex = 0;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (color == 0) { /* black */
if (pixcmapGetFreeCount(cmap) > 0)
pixcmapAddNewColor(cmap, 0, 0, 0, &index);
else
pixcmapGetRankIntensity(cmap, 0.0, &index);
}
else { /* white */
if (pixcmapGetFreeCount(cmap) > 0)
pixcmapAddNewColor(cmap, 255, 255, 255, &index);
else
pixcmapGetRankIntensity(cmap, 1.0, &index);
}
if (pindex)
*pindex = index;
return 0;
}
/*!
* pixcmapSetBlackAndWhite()
*
* Input: cmap
* setblack (0 for no operation; 1 to set darkest color to black)
* setwhite (0 for no operation; 1 to set lightest color to white)
* Return: 0 if OK, 1 on error
*/
l_int32
pixcmapSetBlackAndWhite(PIXCMAP *cmap,
l_int32 setblack,
l_int32 setwhite)
{
l_int32 index;
PROCNAME("pixcmapSetBlackAndWhite");
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (setblack) {
pixcmapGetRankIntensity(cmap, 0.0, &index);
pixcmapResetColor(cmap, index, 0, 0, 0);
}
if (setwhite) {
pixcmapGetRankIntensity(cmap, 1.0, &index);
pixcmapResetColor(cmap, index, 255, 255, 255);
}
return 0;
}
/*!
* pixcmapGetCount()
*
* Input: cmap
* Return: count, or 0 on error
*/
l_int32
pixcmapGetCount(PIXCMAP *cmap)
{
PROCNAME("pixcmapGetCount");
if (!cmap)
return ERROR_INT("cmap not defined", procName, 0);
return cmap->n;
}
/*!
* pixcmapGetFreeCount()
*
* Input: cmap
* Return: free entries, or 0 on error
*/
l_int32
pixcmapGetFreeCount(PIXCMAP *cmap)
{
PROCNAME("pixcmapGetFreeCount");
if (!cmap)
return ERROR_INT("cmap not defined", procName, 0);
return (cmap->nalloc - cmap->n);
}
/*!
* pixcmapGetDepth()
*
* Input: cmap
* Return: depth, or 0 on error
*/
l_int32
pixcmapGetDepth(PIXCMAP *cmap)
{
PROCNAME("pixcmapGetDepth");
if (!cmap)
return ERROR_INT("cmap not defined", procName, 0);
return cmap->depth;
}
/*!
* pixcmapGetMinDepth()
*
* Input: cmap
* &mindepth (<return> minimum depth to support the colormap)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) On error, &mindepth is returned as 0.
*/
l_int32
pixcmapGetMinDepth(PIXCMAP *cmap,
l_int32 *pmindepth)
{
l_int32 ncolors;
PROCNAME("pixcmapGetMinDepth");
if (!pmindepth)
return ERROR_INT("&mindepth not defined", procName, 1);
*pmindepth = 0;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
ncolors = pixcmapGetCount(cmap);
if (ncolors <= 4)
*pmindepth = 2;
else if (ncolors <= 16)
*pmindepth = 4;
else /* ncolors > 16 */
*pmindepth = 8;
return 0;
}
/*!
* pixcmapClear()
*
* Input: cmap
* Return: 0 if OK, 1 on error
*
* Note: this removes the colors by setting the count to 0.
*/
l_int32
pixcmapClear(PIXCMAP *cmap)
{
PROCNAME("pixcmapClear");
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
cmap->n = 0;
return 0;
}
/*-------------------------------------------------------------*
* Colormap random access *
*-------------------------------------------------------------*/
/*!
* pixcmapGetColor()
*
* Input: cmap
* index
* &rval, &gval, &bval (<return> each color value in l_int32)
* Return: 0 if OK, 1 if not accessable (caller should check)
*/
l_int32
pixcmapGetColor(PIXCMAP *cmap,
l_int32 index,
l_int32 *prval,
l_int32 *pgval,
l_int32 *pbval)
{
RGBA_QUAD *cta;
PROCNAME("pixcmapGetColor");
if (!prval || !pgval || !pbval)
return ERROR_INT("&rval, &gval, &bval not all defined", procName, 1);
*prval = *pgval = *pbval = 0;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (index < 0 || index >= cmap->n)
return ERROR_INT("index out of bounds", procName, 1);
cta = (RGBA_QUAD *)cmap->array;
*prval = cta[index].red;
*pgval = cta[index].green;
*pbval = cta[index].blue;
return 0;
}
/*!
* pixcmapResetColor()
*
* Input: cmap
* index
* rval, gval, bval (colormap entry to be reset; each number
* is in range [0, ... 255])
* Return: 0 if OK, 1 if not accessable (caller should check)
*
* Note: this resets sets the color of an entry that has already
* been set and included in the count of colors
*/
l_int32
pixcmapResetColor(PIXCMAP *cmap,
l_int32 index,
l_int32 rval,
l_int32 gval,
l_int32 bval)
{
RGBA_QUAD *cta;
PROCNAME("pixcmapResetColor");
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (index < 0 || index >= cmap->n)
return ERROR_INT("index out of bounds", procName, 1);
cta = (RGBA_QUAD *)cmap->array;
cta[index].red = rval;
cta[index].green = gval;
cta[index].blue = bval;
return 0;
}
/*!
* pixcmapGetIndex()
*
* Input: cmap
* rval, gval, bval (colormap colors to search for; each number
* is in range [0, ... 255])
* &index (<return>)
* Return: 0 if found, 1 if not found (caller must check)
*/
l_int32
pixcmapGetIndex(PIXCMAP *cmap,
l_int32 rval,
l_int32 gval,
l_int32 bval,
l_int32 *pindex)
{
l_int32 n, i;
RGBA_QUAD *cta;
PROCNAME("pixcmapGetIndex");
if (!pindex)
return ERROR_INT("&index not defined", procName, 1);
*pindex = 0;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
n = pixcmapGetCount(cmap);
cta = (RGBA_QUAD *)cmap->array;
for (i = 0; i < n; i++) {
if (rval == cta[i].red && gval == cta[i].green && bval == cta[i].blue) {
*pindex = i;
return 0;
}
}
return 1;
}
/*!
* pixcmapHasColor()
*
* Input: cmap
* &color (<return> TRUE if cmap has color; FALSE otherwise)
* Return: 0 if OK, 1 on error
*/
l_int32
pixcmapHasColor(PIXCMAP *cmap,
l_int32 *pcolor)
{
l_int32 n, i;
l_int32 *rmap, *gmap, *bmap;
PROCNAME("pixcmapHasColor");
if (!pcolor)
return ERROR_INT("&color not defined", procName, 1);
*pcolor = FALSE;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (pixcmapToArrays(cmap, &rmap, &gmap, &bmap))
return ERROR_INT("colormap arrays not made", procName, 1);
n = pixcmapGetCount(cmap);
for (i = 0; i < n; i++) {
if ((rmap[i] != gmap[i]) || (rmap[i] != bmap[i])) {
*pcolor = TRUE;
break;
}
}
FREE(rmap);
FREE(gmap);
FREE(bmap);
return 0;
}
/*!
* pixcmapCountGrayColors()
*
* Input: cmap
* &ngray (<return> number of gray colors)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This counts the unique gray colors, including black and white.
*/
l_int32
pixcmapCountGrayColors(PIXCMAP *cmap,
l_int32 *pngray)
{
l_int32 n, i, rval, gval, bval, count;
l_int32 *array;
PROCNAME("pixcmapCountGrayColors");
if (!pngray)
return ERROR_INT("&ngray not defined", procName, 1);
*pngray = 0;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
array = (l_int32 *)CALLOC(256, sizeof(l_int32));
n = pixcmapGetCount(cmap);
count = 0;
for (i = 0; i < n; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
if ((rval == gval) && (rval == bval) && (array[rval] == 0)) {
array[rval] = 1;
count++;
}
}
FREE(array);
*pngray = count;
return 0;
}
/*!
* pixcmapGetRankIntensity()
*
* Input: cmap
* rankval (0.0 for darkest, 1.0 for lightest color)
* &index (<return> the index into the colormap that
* corresponds to the rank intensity color)
* Return: 0 if OK, 1 on error
*/
l_int32
pixcmapGetRankIntensity(PIXCMAP *cmap,
l_float32 rankval,
l_int32 *pindex)
{
l_int32 n, i, rval, gval, bval, rankindex;
NUMA *na, *nasort;
PROCNAME("pixcmapGetRankIntensity");
if (!pindex)
return ERROR_INT("&index not defined", procName, 1);
*pindex = 0;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (rankval < 0.0 || rankval > 1.0)
return ERROR_INT("rankval not in [0.0 ... 1.0]", procName, 1);
n = pixcmapGetCount(cmap);
na = numaCreate(n);
for (i = 0; i < n; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
numaAddNumber(na, rval + gval + bval);
}
nasort = numaGetSortIndex(na, L_SORT_INCREASING);
rankindex = (l_int32)(rankval * (n - 1) + 0.5);
numaGetIValue(nasort, rankindex, pindex);
numaDestroy(&na);
numaDestroy(&nasort);
return 0;
}
/*!
* pixcmapGetNearestIndex()
*
* Input: cmap
* rval, gval, bval (colormap colors to search for; each number
* is in range [0, ... 255])
* &index (<return> the index of the nearest color)
* Return: 0 if OK, 1 on error (caller must check)
*
* Notes:
* (1) Returns the index of the exact color if possible, otherwise the
* index of the color closest to the target color.
* (2) Nearest color is that which is the least sum-of-squares distance
* from the target color.
*/
l_int32
pixcmapGetNearestIndex(PIXCMAP *cmap,
l_int32 rval,
l_int32 gval,
l_int32 bval,
l_int32 *pindex)
{
l_int32 i, n, delta, dist, mindist;
RGBA_QUAD *cta;
PROCNAME("pixcmapGetNearestIndex");
if (!pindex)
return ERROR_INT("&index not defined", procName, 1);
*pindex = UNDEF;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if ((cta = (RGBA_QUAD *)cmap->array) == NULL)
return ERROR_INT("cta not defined(!)", procName, 1);
n = pixcmapGetCount(cmap);
mindist = 3 * 255 * 255 + 1;
for (i = 0; i < n; i++) {
delta = cta[i].red - rval;
dist = delta * delta;
delta = cta[i].green - gval;
dist += delta * delta;
delta = cta[i].blue - bval;
dist += delta * delta;
if (dist < mindist) {
*pindex = i;
if (dist == 0)
break;
mindist = dist;
}
}
return 0;
}
/*!
* pixcmapGetNearestGrayIndex()
*
* Input: cmap
* val (gray value to search for; in range [0, ... 255])
* &index (<return> the index of the nearest color)
* Return: 0 if OK, 1 on error (caller must check)
*
* Notes:
* (1) This should be used on gray colormaps. It uses only the
* green value of the colormap.
* (2) Returns the index of the exact color if possible, otherwise the
* index of the color closest to the target color.
*/
l_int32
pixcmapGetNearestGrayIndex(PIXCMAP *cmap,
l_int32 val,
l_int32 *pindex)
{
l_int32 i, n, dist, mindist;
RGBA_QUAD *cta;
PROCNAME("pixcmapGetNearestGrayIndex");
if (!pindex)
return ERROR_INT("&index not defined", procName, 1);
*pindex = 0;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (val < 0 || val > 255)
return ERROR_INT("val not in [0 ... 255]", procName, 1);
if ((cta = (RGBA_QUAD *)cmap->array) == NULL)
return ERROR_INT("cta not defined(!)", procName, 1);
n = pixcmapGetCount(cmap);
mindist = 256;
for (i = 0; i < n; i++) {
dist = cta[i].green - val;
dist = L_ABS(dist);
if (dist < mindist) {
*pindex = i;
if (dist == 0)
break;
mindist = dist;
}
}
return 0;
}
/*!
* pixcmapGetExtremeValue()
*
* Input: cmap
* type (L_CHOOSE_MIN or L_CHOOSE_MAX)
* &rval (<optional return> red component)
* &gval (<optional return> green component)
* &bval (<optional return> blue component)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) Returns for selected components the extreme value
* (either min or max) of the color component that is
* found in the colormap.
*/
l_int32
pixcmapGetExtremeValue(PIXCMAP *cmap,
l_int32 type,
l_int32 *prval,
l_int32 *pgval,
l_int32 *pbval)
{
l_int32 i, n, rval, gval, bval, extrval, extgval, extbval;
PROCNAME("pixcmapGetExtremeValue");
if (!prval && !pgval && !pbval)
return ERROR_INT("no result requested for return", procName, 1);
if (prval) *prval = 0;
if (pgval) *pgval = 0;
if (pbval) *pbval = 0;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (type != L_CHOOSE_MIN && type != L_CHOOSE_MAX)
return ERROR_INT("invalid type", procName, 1);
if (type == L_CHOOSE_MIN) {
extrval = 100000;
extgval = 100000;
extbval = 100000;
}
else {
extrval = 0;
extgval = 0;
extbval = 0;
}
n = pixcmapGetCount(cmap);
for (i = 0; i < n; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
if ((type == L_CHOOSE_MIN && rval < extrval) ||
(type == L_CHOOSE_MAX && rval > extrval))
extrval = rval;
if ((type == L_CHOOSE_MIN && gval < extgval) ||
(type == L_CHOOSE_MAX && gval > extgval))
extgval = gval;
if ((type == L_CHOOSE_MIN && bval < extbval) ||
(type == L_CHOOSE_MAX && bval > extbval))
extbval = bval;
}
if (prval) *prval = extrval;
if (pgval) *pgval = extgval;
if (pbval) *pbval = extbval;
return 0;
}
/*-------------------------------------------------------------*
* Colormap conversion *
*-------------------------------------------------------------*/
/*!
* pixcmapGrayToColor()
*
* Input: color
* Return: cmap, or null on error
*
* Notes:
* (1) This creates a colormap that maps from gray to
* a specific color. In the mapping, each component
* is faded to white, depending on the gray value.
* (2) In use, this is simply attached to a grayscale pix
* to give it the input color.
*/
PIXCMAP *
pixcmapGrayToColor(l_uint32 color)
{
l_int32 i, rval, gval, bval;
PIXCMAP *cmap;
extractRGBValues(color, &rval, &gval, &bval);
cmap = pixcmapCreate(8);
for (i = 0; i < 256; i++) {
pixcmapAddColor(cmap, rval + (i * (255 - rval)) / 255,
gval + (i * (255 - gval)) / 255,
bval + (i * (255 - bval)) / 255);
}
return cmap;
}
/*!
* pixcmapColorToGray()
*
* Input: cmap
* rwt, gwt, bwt (non-negative; these should add to 1.0)
* Return: cmap (gray), or null on error
*
* Notes:
* (1) This creates a gray colormap from an arbitrary colormap.
* (2) In use, attach the output gray colormap to the pix
* (or a copy of it) that provided the input colormap.
*/
PIXCMAP *
pixcmapColorToGray(PIXCMAP *cmaps,
l_float32 rwt,
l_float32 gwt,
l_float32 bwt)
{
l_int32 i, n, rval, gval, bval, val;
l_float32 sum;
PIXCMAP *cmapd;
PROCNAME("pixcmapColorToGray");
if (!cmaps)
return (PIXCMAP *)ERROR_PTR("cmaps not defined", procName, NULL);
if (rwt < 0.0 || gwt < 0.0 || bwt < 0.0)
return (PIXCMAP *)ERROR_PTR("weights not all >= 0.0", procName, NULL);
/* Make sure the sum of weights is 1.0; otherwise, you can get
* overflow in the gray value. */
sum = rwt + gwt + bwt;
if (sum == 0.0) {
L_WARNING("all weights zero; setting equal to 1/3", procName);
rwt = gwt = bwt = 0.33333;
sum = 1.0;
}
if (L_ABS(sum - 1.0) > 0.0001) { /* maintain ratios with sum == 1.0 */
L_WARNING("weights don't sum to 1; maintaining ratios", procName);
rwt = rwt / sum;
gwt = gwt / sum;
bwt = bwt / sum;
}
cmapd = pixcmapCopy(cmaps);
n = pixcmapGetCount(cmapd);
for (i = 0; i < n; i++) {
pixcmapGetColor(cmapd, i, &rval, &gval, &bval);
val = (l_int32)(rwt * rval + gwt * gval + bwt * bval + 0.5);
pixcmapResetColor(cmapd, i, val, val, val);
}
return cmapd;
}
/*-------------------------------------------------------------*
* Colormap I/O *
*-------------------------------------------------------------*/
/*!
* pixcmapReadStream()
*
* Input: stream
* Return: cmap, or null on error
*/
PIXCMAP *
pixcmapReadStream(FILE *fp)
{
l_int32 rval, gval, bval;
l_int32 i, index, ret, depth, ncolors;
PIXCMAP *cmap;
PROCNAME("pixcmapReadStream");
if (!fp)
return (PIXCMAP *)ERROR_PTR("stream not defined", procName, NULL);
ret = fscanf(fp, "\nPixcmap: depth = %d bpp; %d colors\n",
&depth, &ncolors);
if (ret != 2 ||
(depth != 1 && depth != 2 && depth != 4 && depth != 8) ||
(ncolors < 2 || ncolors > 256))
return (PIXCMAP *)ERROR_PTR("invalid cmap size", procName, NULL);
fscanf(fp, "Color R-val G-val B-val\n");
fscanf(fp, "--------------------------------\n");
if ((cmap = pixcmapCreate(depth)) == NULL)
return (PIXCMAP *)ERROR_PTR("cmap not made", procName, NULL);
for (i = 0; i < ncolors; i++) {
fscanf(fp, "%3d %3d %3d %3d\n",
&index, &rval, &gval, &bval);
pixcmapAddColor(cmap, rval, gval, bval);
}
return cmap;
}
/*!
* pixcmapWriteStream()
*
* Input: stream, cmap
* Return: 0 if OK, 1 on error
*/
l_int32
pixcmapWriteStream(FILE *fp,
PIXCMAP *cmap)
{
l_int32 *rmap, *gmap, *bmap;
l_int32 i;
PROCNAME("pixcmapWriteStream");
if (!fp)
return ERROR_INT("stream not defined", procName, 1);
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (pixcmapToArrays(cmap, &rmap, &gmap, &bmap))
return ERROR_INT("colormap arrays not made", procName, 1);
fprintf(fp, "\nPixcmap: depth = %d bpp; %d colors\n", cmap->depth, cmap->n);
fprintf(fp, "Color R-val G-val B-val\n");
fprintf(fp, "--------------------------------\n");
for (i = 0; i < cmap->n; i++)
fprintf(fp, "%3d %3d %3d %3d\n",
i, rmap[i], gmap[i], bmap[i]);
fprintf(fp, "\n");
FREE(rmap);
FREE(gmap);
FREE(bmap);
return 0;
}
/*-------------------------------------------------------------*
* Extract colormap arrays *
*-------------------------------------------------------------*/
/*!
* pixcmapToArrays()
*
* Input: colormap
* &rmap, &gmap, &bmap (<return> colormap arrays)
* Return: 0 if OK; 1 on error
*/
l_int32
pixcmapToArrays(PIXCMAP *cmap,
l_int32 **prmap,
l_int32 **pgmap,
l_int32 **pbmap)
{
l_int32 *rmap, *gmap, *bmap;
l_int32 i, ncolors;
RGBA_QUAD *cta;
PROCNAME("pixcmapToArrays");
if (!prmap || !pgmap || !pbmap)
return ERROR_INT("&rmap, &gmap, &bmap not all defined", procName, 1);
*prmap = *pgmap = *pbmap = NULL;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
ncolors = pixcmapGetCount(cmap);
if (((rmap = (l_int32 *)CALLOC(ncolors, sizeof(l_int32))) == NULL) ||
((gmap = (l_int32 *)CALLOC(ncolors, sizeof(l_int32))) == NULL) ||
((bmap = (l_int32 *)CALLOC(ncolors, sizeof(l_int32))) == NULL))
return ERROR_INT("calloc fail for *map", procName, 1);
*prmap = rmap;
*pgmap = gmap;
*pbmap = bmap;
cta = (RGBA_QUAD *)cmap->array;
for (i = 0; i < ncolors; i++) {
rmap[i] = cta[i].red;
gmap[i] = cta[i].green;
bmap[i] = cta[i].blue;
}
return 0;
}
/*!
* pixcmapToRGBTable()
*
* Input: colormap
* &tab (<return> table of rgba values for the colormap)
* &ncolors (<optional return> size of table)
* Return: 0 if OK; 1 on error
*/
l_int32
pixcmapToRGBTable(PIXCMAP *cmap,
l_uint32 **ptab,
l_int32 *pncolors)
{
l_int32 i, ncolors, rval, gval, bval;
l_uint32 *tab;
PROCNAME("pixcmapToRGBTable");
if (!ptab)
return ERROR_INT("&tab not defined", procName, 1);
*ptab = NULL;
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
ncolors = pixcmapGetCount(cmap);
if (pncolors)
*pncolors = ncolors;
if ((tab = (l_uint32 *)CALLOC(ncolors, sizeof(l_uint32))) == NULL)
return ERROR_INT("tab not made", procName, 1);
*ptab = tab;
for (i = 0; i < ncolors; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
composeRGBPixel(rval, gval, bval, &tab[i]);
}
/* for (i = 0; i < ncolors; i++)
fprintf(stderr, "Color[%d] = %x\n", i, tab[i]); */
return 0;
}
/*-------------------------------------------------------------*
* Colormap transforms *
*-------------------------------------------------------------*/
/*!
* pixcmapGammaTRC()
*
* Input: colormap
* gamma (gamma correction; must be > 0.0)
* minval (input value that gives 0 for output; can be < 0)
* maxval (input value that gives 255 for output; can be > 255)
* Return: 0 if OK; 1 on error
*
* Notes:
* - in-place transform
* - see pixGammaTRC() and numaGammaTRC() in enhance.c for
* description and use of transform
*/
l_int32
pixcmapGammaTRC(PIXCMAP *cmap,
l_float32 gamma,
l_int32 minval,
l_int32 maxval)
{
l_int32 rval, gval, bval, trval, tgval, tbval, i, ncolors;
NUMA *nag;
PROCNAME("pixcmapGammaTRC");
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (gamma <= 0.0) {
L_WARNING("gamma must be > 0.0; setting to 1.0", procName);
gamma = 1.0;
}
if (minval >= maxval)
return ERROR_INT("minval not < maxval", procName, 1);
if ((nag = numaGammaTRC(gamma, minval, maxval)) == NULL)
return ERROR_INT("nag not made", procName, 1);
ncolors = pixcmapGetCount(cmap);
for (i = 0; i < ncolors; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
numaGetIValue(nag, rval, &trval);
numaGetIValue(nag, gval, &tgval);
numaGetIValue(nag, bval, &tbval);
pixcmapResetColor(cmap, i, trval, tgval, tbval);
}
numaDestroy(&nag);
return 0;
}
/*!
* pixcmapContrastTRC()
*
* Input: colormap
* factor (generally between 0.0 (no enhancement)
* and 1.0, but can be larger than 1.0)
* Return: 0 if OK; 1 on error
*
* Notes:
* - in-place transform
* - see pixContrastTRC() and numaContrastTRC() in enhance.c for
* description and use of transform
*/
l_int32
pixcmapContrastTRC(PIXCMAP *cmap,
l_float32 factor)
{
l_int32 i, ncolors, rval, gval, bval, trval, tgval, tbval;
NUMA *nac;
PROCNAME("pixcmapContrastTRC");
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (factor < 0.0) {
L_WARNING("factor must be >= 0.0; setting to 0.0", procName);
factor = 0.0;
}
if ((nac = numaContrastTRC(factor)) == NULL)
return ERROR_INT("nac not made", procName, 1);
ncolors = pixcmapGetCount(cmap);
for (i = 0; i < ncolors; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
numaGetIValue(nac, rval, &trval);
numaGetIValue(nac, gval, &tgval);
numaGetIValue(nac, bval, &tbval);
pixcmapResetColor(cmap, i, trval, tgval, tbval);
}
numaDestroy(&nac);
return 0;
}
/*!
* pixcmapShiftIntensity()
*
* Input: colormap
* fraction (between -1.0 and +1.0)
* Return: 0 if OK; 1 on error
*
* Notes:
* - in-place transform
* - This does a proportional shift of the intensity for each color.
* - If fraction < 0.0, it moves all colors towards (0,0,0).
* This darkens the image.
* - If fraction > 0.0, it moves all colors towards (255,255,255)
* This fades the image.
* - The equivalent transform can be accomplished with pixcmapGammaTRC(),
* but it is considerably more difficult (see numaGammaTRC()).
*/
l_int32
pixcmapShiftIntensity(PIXCMAP *cmap,
l_float32 fraction)
{
l_int32 i, ncolors, rval, gval, bval;
PROCNAME("pixcmapShiftIntensity");
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
if (fraction < -1.0 || fraction > 1.0)
return ERROR_INT("fraction not in [-1.0, 1.0]", procName, 1);
ncolors = pixcmapGetCount(cmap);
for (i = 0; i < ncolors; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
if (fraction < 0.0)
pixcmapResetColor(cmap, i,
(l_int32)((1.0 + fraction) * rval),
(l_int32)((1.0 + fraction) * gval),
(l_int32)((1.0 + fraction) * bval));
else
pixcmapResetColor(cmap, i,
rval + (l_int32)(fraction * (255 - rval)),
gval + (l_int32)(fraction * (255 - gval)),
bval + (l_int32)(fraction * (255 - bval)));
}
return 0;
}
/*!
* pixcmapConvertRGBToHSV()
*
* Input: colormap
* Return: 0 if OK; 1 on error
*
* Notes:
* - in-place transform
* - See convertRGBToHSV() for def'n of HSV space.
* - replaces: r --> h, g --> s, b --> v
*/
l_int32
pixcmapConvertRGBToHSV(PIXCMAP *cmap)
{
l_int32 i, ncolors, rval, gval, bval, hval, sval, vval;
PROCNAME("pixcmapConvertRGBToHSV");
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
ncolors = pixcmapGetCount(cmap);
for (i = 0; i < ncolors; i++) {
pixcmapGetColor(cmap, i, &rval, &gval, &bval);
convertRGBToHSV(rval, gval, bval, &hval, &sval, &vval);
pixcmapResetColor(cmap, i, hval, sval, vval);
}
return 0;
}
/*!
* pixcmapConvertHSVToRGB()
*
* Input: colormap
* Return: 0 if OK; 1 on error
*
* Notes:
* - in-place transform
* - See convertRGBToHSV() for def'n of HSV space.
* - replaces: h --> r, s --> g, v --> b
*/
l_int32
pixcmapConvertHSVToRGB(PIXCMAP *cmap)
{
l_int32 i, ncolors, rval, gval, bval, hval, sval, vval;
PROCNAME("pixcmapConvertHSVToRGB");
if (!cmap)
return ERROR_INT("cmap not defined", procName, 1);
ncolors = pixcmapGetCount(cmap);
for (i = 0; i < ncolors; i++) {
pixcmapGetColor(cmap, i, &hval, &sval, &vval);
convertHSVToRGB(hval, sval, vval, &rval, &gval, &bval);
pixcmapResetColor(cmap, i, rval, gval, bval);
}
return 0;
}