/*====================================================================*
- 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.
*====================================================================*/
/*
* colorseg.c
*
* Unsupervised color segmentation
*
* PIX *pixColorSegment()
* PIX *pixColorSegmentCluster()
* static l_int32 pixColorSegmentTryCluster()
* l_int32 pixAssignToNearestColor()
* l_int32 pixColorSegmentClean()
* l_int32 pixColorSegmentRemoveColors()
*
* Selection and display of range of colors in HSV space
*
* PIX *pixMakeRangeMaskHS()
* PIX *pixMakeRangeMaskHV()
* PIX *pixMakeRangeMaskSV()
* PIX *pixMakeHistoHS()
* PIX *pixMakeHistoHV()
* PIX *pixMakeHistoSV()
* PIX *pixFindHistoPeaksHSV()
* PIX *displayHSVColorRange()
*/
#include <stdio.h>
#include <stdlib.h>
#include "allheaders.h"
/* Maximum allowed iterations in Phase 1. */
static const l_int32 MAX_ALLOWED_ITERATIONS = 20;
/* Factor by which max dist is increased on each iteration */
static const l_float32 DIST_EXPAND_FACT = 1.3;
/* Octcube division level for computing nearest colormap color using LUT.
* Using 4 should suffice for up to 50 - 100 colors, and it is
* very fast. Using 5 takes 8 times as long to set up the LUT
* for little perceptual gain, even with 100 colors. */
static const l_int32 LEVEL_IN_OCTCUBE = 4;
static l_int32 pixColorSegmentTryCluster(PIX *pixd, PIX *pixs,
l_int32 maxdist, l_int32 maxcolors);
#ifndef NO_CONSOLE_IO
#define DEBUG_HISTO 1
#endif /* ~NO_CONSOLE_IO */
/*------------------------------------------------------------------*
* Unsupervised color segmentation *
*------------------------------------------------------------------*/
/*!
* pixColorSegment()
*
* Input: pixs (32 bpp; 24-bit color)
* maxdist (max euclidean dist to existing cluster)
* maxcolors (max number of colors allowed in first pass)
* selsize (linear size of sel for closing to remove noise)
* finalcolors (max number of final colors allowed after 4th pass)
* Return: pixd (8 bit with colormap), or null on error
*
* Color segmentation proceeds in four phases:
*
* Phase 1: pixColorSegmentCluster()
* The image is traversed in raster order. Each pixel either
* becomes the representative for a new cluster or is assigned to an
* existing cluster. Assignment is greedy. The data is stored in
* a colormapped image. Three auxiliary arrays are used to hold
* the colors of the representative pixels, for fast lookup.
* The average color in each cluster is computed.
*
* Phase 2. pixAssignToNearestColor()
* A second (non-greedy) clustering pass is performed, where each pixel
* is assigned to the nearest cluster (average). We also keep track
* of how many pixels are assigned to each cluster.
*
* Phase 3. pixColorSegmentClean()
* For each cluster, starting with the largest, do a morphological
* closing to eliminate small components within larger ones.
*
* Phase 4. pixColorSegmentRemoveColors()
* Eliminate all colors except the most populated 'finalcolors'.
* Then remove unused colors from the colormap, and reassign those
* pixels to the nearest remaining cluster, using the original pixel values.
*
* Notes:
* (1) The goal is to generate a small number of colors.
* Typically this would be specified by 'finalcolors',
* a number that would be somewhere between 3 and 6.
* The parameter 'maxcolors' specifies the maximum number of
* colors generated in the first phase. This should be
* larger than finalcolors, perhaps twice as large.
* If more than 'maxcolors' are generated in the first phase
* using the input 'maxdist', the distance is repeatedly
* increased by a multiplicative factor until the condition
* is satisfied. The implicit relation between 'maxdist'
* and 'maxcolors' is thus adjusted programmatically.
* (2) As a very rough guideline, given a target value of 'finalcolors',
* here are approximate values of 'maxdist' and 'maxcolors'
* to start with:
*
* finalcolors maxcolors maxdist
* ----------- --------- -------
* 3 6 100
* 4 8 90
* 5 10 75
* 6 12 60
*
* For a given number of finalcolors, if you use too many
* maxcolors, the result will be noisy. If you use too few,
* the result will be a relatively poor assignment of colors.
*/
PIX *
pixColorSegment(PIX *pixs,
l_int32 maxdist,
l_int32 maxcolors,
l_int32 selsize,
l_int32 finalcolors)
{
l_int32 *countarray;
PIX *pixd;
PROCNAME("pixColorSegment");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (pixGetDepth(pixs) != 32)
return (PIX *)ERROR_PTR("must be rgb color", procName, NULL);
/* Phase 1; original segmentation */
if ((pixd = pixColorSegmentCluster(pixs, maxdist, maxcolors)) == NULL)
return (PIX *)ERROR_PTR("pixt1 not made", procName, NULL);
/* pixWrite("junkpixd1", pixd, IFF_PNG); */
/* Phase 2; refinement in pixel assignment */
if ((countarray = (l_int32 *)CALLOC(256, sizeof(l_int32))) == NULL)
return (PIX *)ERROR_PTR("countarray not made", procName, NULL);
pixAssignToNearestColor(pixd, pixs, NULL, LEVEL_IN_OCTCUBE, countarray);
/* pixWrite("junkpixd2", pixd, IFF_PNG); */
/* Phase 3: noise removal by separately closing each color */
pixColorSegmentClean(pixd, selsize, countarray);
/* pixWrite("junkpixd3", pixd, IFF_PNG); */
FREE(countarray);
/* Phase 4: removal of colors with small population and
* reassignment of pixels to remaining colors */
pixColorSegmentRemoveColors(pixd, pixs, finalcolors);
return pixd;
}
/*!
* pixColorSegmentCluster()
*
* Input: pixs (32 bpp; 24-bit color)
* maxdist (max euclidean dist to existing cluster)
* maxcolors (max number of colors allowed in first pass)
* Return: pixd (8 bit with colormap), or null on error
*
* Notes:
* (1) This is phase 1. See description in pixColorSegment().
* (2) Greedy unsupervised classification. If the limit 'maxcolors'
* is exceeded, the computation is repeated with a larger
* allowed cluster size.
* (3) On each successive iteration, 'maxdist' is increased by a
* constant factor. See comments in pixColorSegment() for
* a guideline on parameter selection.
* Note that the diagonal of the 8-bit rgb color cube is about
* 440, so for 'maxdist' = 440, you are guaranteed to get 1 color!
*/
PIX *
pixColorSegmentCluster(PIX *pixs,
l_int32 maxdist,
l_int32 maxcolors)
{
l_int32 w, h, newmaxdist, ret, niters, ncolors, success;
PIX *pixd;
PIXCMAP *cmap;
PROCNAME("pixColorSegmentCluster");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (pixGetDepth(pixs) != 32)
return (PIX *)ERROR_PTR("must be rgb color", procName, NULL);
w = pixGetWidth(pixs);
h = pixGetHeight(pixs);
if ((pixd = pixCreate(w, h, 8)) == NULL)
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
cmap = pixcmapCreate(8);
pixSetColormap(pixd, cmap);
pixCopyResolution(pixd, pixs);
newmaxdist = maxdist;
niters = 0;
success = TRUE;
while (1) {
ret = pixColorSegmentTryCluster(pixd, pixs, newmaxdist, maxcolors);
niters++;
if (!ret) {
ncolors = pixcmapGetCount(cmap);
L_INFO_INT2("Success with %d colors after %d iters", procName,
ncolors, niters);
break;
}
if (niters == MAX_ALLOWED_ITERATIONS) {
L_WARNING_INT("too many iters; newmaxdist = %d",
procName, newmaxdist);
success = FALSE;
break;
}
newmaxdist = (l_int32)(DIST_EXPAND_FACT * (l_float32)newmaxdist);
}
if (!success) {
pixDestroy(&pixd);
return (PIX *)ERROR_PTR("failure in phase 1", procName, NULL);
}
return pixd;
}
/*!
* pixColorSegmentTryCluster()
*
* Input: pixd
* pixs
* maxdist
* maxcolors
* Return: 0 if OK, 1 on error
*
* Note: This function should only be called from pixColorSegCluster()
*/
static l_int32
pixColorSegmentTryCluster(PIX *pixd,
PIX *pixs,
l_int32 maxdist,
l_int32 maxcolors)
{
l_int32 rmap[256], gmap[256], bmap[256];
l_int32 w, h, wpls, wpld, i, j, k, found, ret, index, ncolors;
l_int32 rval, gval, bval, dist2, maxdist2;
l_int32 countarray[256];
l_int32 rsum[256], gsum[256], bsum[256];
l_uint32 *ppixel;
l_uint32 *datas, *datad, *lines, *lined;
PIXCMAP *cmap;
PROCNAME("pixColorSegmentTryCluster");
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (!pixd)
return ERROR_INT("pixd not defined", procName, 1);
w = pixGetWidth(pixs);
h = pixGetHeight(pixs);
maxdist2 = maxdist * maxdist;
cmap = pixGetColormap(pixd);
pixcmapClear(cmap);
for (k = 0; k < 256; k++) {
rsum[k] = gsum[k] = bsum[k] = 0;
rmap[k] = gmap[k] = bmap[k] = 0;
}
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++) {
ppixel = lines + j;
rval = GET_DATA_BYTE(ppixel, COLOR_RED);
gval = GET_DATA_BYTE(ppixel, COLOR_GREEN);
bval = GET_DATA_BYTE(ppixel, COLOR_BLUE);
ncolors = pixcmapGetCount(cmap);
found = FALSE;
for (k = 0; k < ncolors; k++) {
dist2 = (rval - rmap[k]) * (rval - rmap[k]) +
(gval - gmap[k]) * (gval - gmap[k]) +
(bval - bmap[k]) * (bval - bmap[k]);
if (dist2 <= maxdist2) { /* take it; greedy */
found = TRUE;
SET_DATA_BYTE(lined, j, k);
countarray[k]++;
rsum[k] += rval;
gsum[k] += gval;
bsum[k] += bval;
break;
}
}
if (!found) { /* Add a new color */
ret = pixcmapAddNewColor(cmap, rval, gval, bval, &index);
/* fprintf(stderr,
"index = %d, (i,j) = (%d,%d), rgb = (%d, %d, %d)\n",
index, i, j, rval, gval, bval); */
if (ret == 0 && index < maxcolors) {
countarray[index] = 1;
SET_DATA_BYTE(lined, j, index);
rmap[index] = rval;
gmap[index] = gval;
bmap[index] = bval;
rsum[index] = rval;
gsum[index] = gval;
bsum[index] = bval;
}
else {
L_INFO_INT("maxcolors exceeded for maxdist = %d",
procName, maxdist);
return 1;
}
}
}
}
/* Replace the colors in the colormap by the averages */
for (k = 0; k < ncolors; k++) {
rval = rsum[k] / countarray[k];
gval = gsum[k] / countarray[k];
bval = bsum[k] / countarray[k];
pixcmapResetColor(cmap, k, rval, gval, bval);
}
return 0;
}
/*!
* pixAssignToNearestColor()
*
* Input: pixd (8 bpp, colormapped)
* pixs (32 bpp; 24-bit color)
* pixm (<optional> 1 bpp)
* level (of octcube used for finding nearest color in cmap)
* countarray (<optional> ptr to array, in which we can store
* the number of pixels found in each color in
* the colormap in pixd)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This is used in phase 2 of color segmentation, where pixs
* is the original input image to pixColorSegment(), and
* pixd is the colormapped image returned from
* pixColorSegmentCluster(). It is also used, with a mask,
* in phase 4.
* (2) This is an in-place operation.
* (3) The colormap in pixd is unchanged.
* (4) pixs and pixd must be the same size (w, h).
* (5) The selection mask pixm can be null. If it exists, it must
* be the same size as pixs and pixd, and only pixels
* corresponding to fg in pixm are assigned. Set to
* NULL if all pixels in pixd are to be assigned.
* (6) The countarray can be null. If it exists, it is pre-allocated
* and of a size at least equal to the size of the colormap in pixd.
* (7) This does a best-fit (non-greedy) assignment of pixels to
* existing clusters. Specifically, it assigns each pixel
* in pixd to the color index in the pixd colormap that has a
* color closest to the corresponding rgb pixel in pixs.
* (8) 'level' is the octcube level used to quickly find the nearest
* color in the colormap for each pixel. For color segmentation,
* this parameter is set to LEVEL_IN_OCTCUBE.
* (9) We build a mapping table from octcube to colormap index so
* that this function can run in a time (otherwise) independent
* of the number of colors in the colormap. This avoids a
* brute-force search for the closest colormap color to each
* pixel in the image.
*/
l_int32
pixAssignToNearestColor(PIX *pixd,
PIX *pixs,
PIX *pixm,
l_int32 level,
l_int32 *countarray)
{
l_int32 w, h, wpls, wpld, wplm, i, j;
l_int32 rval, gval, bval, index;
l_int32 *cmaptab;
l_uint32 octindex;
l_uint32 *rtab, *gtab, *btab;
l_uint32 *ppixel;
l_uint32 *datas, *datad, *datam, *lines, *lined, *linem;
PIXCMAP *cmap;
PROCNAME("pixAssignToNearestColor");
if (!pixd)
return ERROR_INT("pixd not defined", procName, 1);
if ((cmap = pixGetColormap(pixd)) == NULL)
return ERROR_INT("cmap not found", procName, 1);
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (pixGetDepth(pixs) != 32)
return ERROR_INT("pixs not 32 bpp", procName, 1);
/* Set up the tables to map rgb to the nearest colormap index */
if (makeRGBToIndexTables(&rtab, >ab, &btab, level))
return ERROR_INT("index tables not made", procName, 1);
if ((cmaptab = pixcmapToOctcubeLUT(cmap, level, L_MANHATTAN_DISTANCE))
== NULL)
return ERROR_INT("cmaptab not made", procName, 1);
w = pixGetWidth(pixs);
h = pixGetHeight(pixs);
datas = pixGetData(pixs);
datad = pixGetData(pixd);
wpls = pixGetWpl(pixs);
wpld = pixGetWpl(pixd);
if (pixm) {
datam = pixGetData(pixm);
wplm = pixGetWpl(pixm);
}
for (i = 0; i < h; i++) {
lines = datas + i * wpls;
lined = datad + i * wpld;
if (pixm)
linem = datam + i * wplm;
for (j = 0; j < w; j++) {
if (pixm) {
if (!GET_DATA_BIT(linem, j))
continue;
}
ppixel = lines + j;
rval = GET_DATA_BYTE(ppixel, COLOR_RED);
gval = GET_DATA_BYTE(ppixel, COLOR_GREEN);
bval = GET_DATA_BYTE(ppixel, COLOR_BLUE);
/* Map from rgb to octcube index */
getOctcubeIndexFromRGB(rval, gval, bval, rtab, gtab, btab,
&octindex);
/* Map from octcube index to nearest colormap index */
index = cmaptab[octindex];
if (countarray)
countarray[index]++;
SET_DATA_BYTE(lined, j, index);
}
}
FREE(cmaptab);
FREE(rtab);
FREE(gtab);
FREE(btab);
return 0;
}
/*!
* pixColorSegmentClean()
*
* Input: pixs (8 bpp, colormapped)
* selsize (for closing)
* countarray (ptr to array containing the number of pixels
* found in each color in the colormap)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This operation is in-place.
* (2) This is phase 3 of color segmentation. It is the first
* part of a two-step noise removal process. Colors with a
* large population are closed first; this operation absorbs
* small sets of intercolated pixels of a different color.
*/
l_int32
pixColorSegmentClean(PIX *pixs,
l_int32 selsize,
l_int32 *countarray)
{
l_int32 i, ncolors, val;
NUMA *na, *nasi;
PIX *pixt1, *pixt2;
PIXCMAP *cmap;
SEL *sel;
PROCNAME("pixColorSegmentClean");
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (pixGetDepth(pixs) != 8)
return ERROR_INT("pixs not 8 bpp", procName, 1);
if ((cmap = pixGetColormap(pixs)) == NULL)
return ERROR_INT("cmap not found", procName, 1);
if (!countarray)
return ERROR_INT("countarray not defined", procName, 1);
if (selsize <= 1)
return 0; /* nothing to do */
/* Sort colormap indices in decreasing order of pixel population */
ncolors = pixcmapGetCount(cmap);
na = numaCreate(ncolors);
for (i = 0; i < ncolors; i++)
numaAddNumber(na, countarray[i]);
if ((nasi = numaGetSortIndex(na, L_SORT_DECREASING)) == NULL)
return ERROR_INT("nasi not made", procName, 1);
/* For each color, in order of decreasing population,
* do a closing and absorb the added pixels. Note that
* if the closing removes pixels at the border, they'll
* still appear in the xor and will be properly (re)set. */
sel = selCreateBrick(selsize, selsize, selsize / 2, selsize / 2, SEL_HIT);
for (i = 0; i < ncolors; i++) {
numaGetIValue(nasi, i, &val);
pixt1 = pixGenerateMaskByValue(pixs, val);
pixt2 = pixClose(NULL, pixt1, sel);
pixXor(pixt2, pixt2, pixt1); /* pixels to be added to type 'val' */
pixSetMasked(pixs, pixt2, val); /* add them */
pixDestroy(&pixt1);
pixDestroy(&pixt2);
}
selDestroy(&sel);
numaDestroy(&na);
numaDestroy(&nasi);
return 0;
}
/*!
* pixColorSegmentRemoveColors()
*
* Input: pixd (8 bpp, colormapped)
* pixs (24 bpp rgb, with initial pixel values)
* finalcolors (max number of colors to retain)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This operation is in-place.
* (2) This is phase 4 of color segmentation, and the second part
* of the 2-step noise removal. Only 'finalcolors' different
* colors are retained, with colors with smaller populations
* being replaced by the nearest color of the remaining colors.
* For highest accuracy, for pixels that are being replaced,
* we find the nearest colormap color to the original rgb color.
*/
l_int32
pixColorSegmentRemoveColors(PIX *pixd,
PIX *pixs,
l_int32 finalcolors)
{
l_int32 i, w, h, npix, minpix, ncolors, index, selected, tempcolor;
NUMA *na, *nasi;
PIX *pixm, *pixt;
PIXCMAP *cmap;
PROCNAME("pixColorSegmentRemoveColors");
if (!pixd)
return ERROR_INT("pixd not defined", procName, 1);
if (pixGetDepth(pixd) != 8)
return ERROR_INT("pixd not 8 bpp", procName, 1);
if ((cmap = pixGetColormap(pixd)) == NULL)
return ERROR_INT("cmap not found", procName, 1);
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
ncolors = pixcmapGetCount(cmap);
if (finalcolors >= ncolors) /* few enough colors already; nothing to do */
return 0;
/* Generate a mask over all pixels that are not in the
* 'finalcolors' most populated colors. Save the colormap
* index of any one of the retained colors in 'tempcolor'. */
na = pixGetGrayHistogram(pixd, 1);
if ((nasi = numaGetSortIndex(na, L_SORT_DECREASING)) == NULL)
return ERROR_INT("nasi not made", procName, 1);
numaGetIValue(nasi, finalcolors - 1, &index); /* retain down to this */
numaGetIValue(na, index, &minpix);
w = pixGetWidth(pixd);
h = pixGetHeight(pixd);
pixm = pixCreate(w, h, 1); /* initial mask with no fg pixels */
selected = FALSE;
for (i = 0; i < ncolors; i++) {
numaGetIValue(na, i, &npix);
if (npix < minpix && npix > 0) { /* these pixels to be reassigned */
pixt = pixGenerateMaskByValue(pixd, i);
pixOr(pixm, pixm, pixt);
pixDestroy(&pixt);
}
else if (selected == FALSE) {
tempcolor = i;
selected = TRUE;
}
}
/* Reassign the masked pixels temporarily to the saved index
* (tempcolor). This guarantees that no pixels are labeled by
* a colormap index of any colors that will be removed.
* The actual value doesn't matter, as long as it's one
* of the retained colors, because these pixels will later
* be reassigned based on the full set of colors retained
* in the colormap. */
pixSetMasked(pixd, pixm, tempcolor);
/* Now remove unused colors from the colormap. This reassigns
* image pixels as required. */
pixRemoveUnusedColors(pixd);
/* Finally, reassign the pixels under the mask (those that were
* given a 'tempcolor' value) to the nearest color in the colormap.
* This is the function used in phase 2 on all image pixels; here
* it is only used on the masked pixels given by pixm. */
pixAssignToNearestColor(pixd, pixs, pixm, LEVEL_IN_OCTCUBE, NULL);
pixDestroy(&pixm);
numaDestroy(&na);
numaDestroy(&nasi);
return 0;
}
/*------------------------------------------------------------------*
* Selection and display of range of colors in HSV space *
*------------------------------------------------------------------*/
/*!
* pixMakeRangeMaskHS()
*
* Input: pixs (24 bpp rgb)
* huecenter (center value of hue range)
* huehw (half-width of hue range)
* satcenter (center value of saturation range)
* sathw (half-width of saturation range)
* regionflag (L_INCLUDE_REGION, L_EXCLUDE_REGION)
* Return: pixd (1 bpp mask over selected pixels), or null on error
*
* Notes:
* (1) The pixels are selected based on the specified ranges of
* hue and saturation. For selection or exclusion, the pixel
* HS component values must be within both ranges. Care must
* be taken in finding the hue range because of wrap-around.
* (2) Use @regionflag == L_INCLUDE_REGION to take only those
* pixels within the rectangular region specified in HS space.
* Use @regionflag == L_EXCLUDE_REGION to take all pixels except
* those within the rectangular region specified in HS space.
*/
PIX *
pixMakeRangeMaskHS(PIX *pixs,
l_int32 huecenter,
l_int32 huehw,
l_int32 satcenter,
l_int32 sathw,
l_int32 regionflag)
{
l_int32 i, j, w, h, wplt, wpld, hstart, hend, sstart, send, hval, sval;
l_int32 *hlut, *slut;
l_uint32 pixel;
l_uint32 *datat, *datad, *linet, *lined;
PIX *pixt, *pixd;
PROCNAME("pixMakeRangeMaskHS");
if (!pixs || pixGetDepth(pixs) != 32)
return (PIX *)ERROR_PTR("pixs undefined or not 32 bpp", procName, NULL);
if (regionflag != L_INCLUDE_REGION && regionflag != L_EXCLUDE_REGION)
return (PIX *)ERROR_PTR("invalid regionflag", procName, NULL);
/* Set up LUTs for hue and saturation. These have the value 1
* within the specified intervals of hue and saturation. */
hlut = (l_int32 *)CALLOC(240, sizeof(l_int32));
slut = (l_int32 *)CALLOC(256, sizeof(l_int32));
sstart = L_MAX(0, satcenter - sathw);
send = L_MIN(255, satcenter + sathw);
for (i = sstart; i <= send; i++)
slut[i] = 1;
hstart = (huecenter - huehw + 240) % 240;
hend = (huecenter + huehw + 240) % 240;
if (hstart < hend) {
for (i = hstart; i <= hend; i++)
hlut[i] = 1;
}
else { /* wrap */
for (i = hstart; i < 240; i++)
hlut[i] = 1;
for (i = 0; i <= hend; i++)
hlut[i] = 1;
}
/* Generate the mask */
pixt = pixConvertRGBToHSV(NULL, pixs);
pixGetDimensions(pixs, &w, &h, NULL);
pixd = pixCreateNoInit(w, h, 1);
if (regionflag == L_INCLUDE_REGION)
pixClearAll(pixd);
else /* L_EXCLUDE_REGION */
pixSetAll(pixd);
datat = pixGetData(pixt);
datad = pixGetData(pixd);
wplt = pixGetWpl(pixt);
wpld = pixGetWpl(pixd);
for (i = 0; i < h; i++) {
linet = datat + i * wplt;
lined = datad + i * wpld;
for (j = 0; j < w; j++) {
pixel = linet[j];
hval = (pixel >> L_RED_SHIFT) & 0xff;
sval = (pixel >> L_GREEN_SHIFT) & 0xff;
if (hlut[hval] == 1 && slut[sval] == 1) {
if (regionflag == L_INCLUDE_REGION)
SET_DATA_BIT(lined, j);
else /* L_EXCLUDE_REGION */
CLEAR_DATA_BIT(lined, j);
}
}
}
FREE(hlut);
FREE(slut);
pixDestroy(&pixt);
return pixd;
}
/*!
* pixMakeRangeMaskHV()
*
* Input: pixs (24 bpp rgb)
* huecenter (center value of hue range)
* huehw (half-width of hue range)
* valcenter (center value of max intensity range)
* valhw (half-width of max intensity range)
* regionflag (L_INCLUDE_REGION, L_EXCLUDE_REGION)
* Return: pixd (1 bpp mask over selected pixels), or null on error
*
* Notes:
* (1) The pixels are selected based on the specified ranges of
* hue and max intensity values. For selection or exclusion,
* the pixel HV component values must be within both ranges.
* Care must be taken in finding the hue range because of wrap-around.
* (2) Use @regionflag == L_INCLUDE_REGION to take only those
* pixels within the rectangular region specified in HV space.
* Use @regionflag == L_EXCLUDE_REGION to take all pixels except
* those within the rectangular region specified in HV space.
*/
PIX *
pixMakeRangeMaskHV(PIX *pixs,
l_int32 huecenter,
l_int32 huehw,
l_int32 valcenter,
l_int32 valhw,
l_int32 regionflag)
{
l_int32 i, j, w, h, wplt, wpld, hstart, hend, vstart, vend, hval, vval;
l_int32 *hlut, *vlut;
l_uint32 pixel;
l_uint32 *datat, *datad, *linet, *lined;
PIX *pixt, *pixd;
PROCNAME("pixMakeRangeMaskHV");
if (!pixs || pixGetDepth(pixs) != 32)
return (PIX *)ERROR_PTR("pixs undefined or not 32 bpp", procName, NULL);
if (regionflag != L_INCLUDE_REGION && regionflag != L_EXCLUDE_REGION)
return (PIX *)ERROR_PTR("invalid regionflag", procName, NULL);
/* Set up LUTs for hue and maximum intensity (val). These have
* the value 1 within the specified intervals of hue and value. */
hlut = (l_int32 *)CALLOC(240, sizeof(l_int32));
vlut = (l_int32 *)CALLOC(256, sizeof(l_int32));
vstart = L_MAX(0, valcenter - valhw);
vend = L_MIN(255, valcenter + valhw);
for (i = vstart; i <= vend; i++)
vlut[i] = 1;
hstart = (huecenter - huehw + 240) % 240;
hend = (huecenter + huehw + 240) % 240;
if (hstart < hend) {
for (i = hstart; i <= hend; i++)
hlut[i] = 1;
}
else {
for (i = hstart; i < 240; i++)
hlut[i] = 1;
for (i = 0; i <= hend; i++)
hlut[i] = 1;
}
/* Generate the mask */
pixt = pixConvertRGBToHSV(NULL, pixs);
pixGetDimensions(pixs, &w, &h, NULL);
pixd = pixCreateNoInit(w, h, 1);
if (regionflag == L_INCLUDE_REGION)
pixClearAll(pixd);
else /* L_EXCLUDE_REGION */
pixSetAll(pixd);
datat = pixGetData(pixt);
datad = pixGetData(pixd);
wplt = pixGetWpl(pixt);
wpld = pixGetWpl(pixd);
for (i = 0; i < h; i++) {
linet = datat + i * wplt;
lined = datad + i * wpld;
for (j = 0; j < w; j++) {
pixel = linet[j];
hval = (pixel >> L_RED_SHIFT) & 0xff;
vval = (pixel >> L_BLUE_SHIFT) & 0xff;
if (hlut[hval] == 1 && vlut[vval] == 1) {
if (regionflag == L_INCLUDE_REGION)
SET_DATA_BIT(lined, j);
else /* L_EXCLUDE_REGION */
CLEAR_DATA_BIT(lined, j);
}
}
}
FREE(hlut);
FREE(vlut);
pixDestroy(&pixt);
return pixd;
}
/*!
* pixMakeRangeMaskSV()
*
* Input: pixs (24 bpp rgb)
* satcenter (center value of saturation range)
* sathw (half-width of saturation range)
* valcenter (center value of max intensity range)
* valhw (half-width of max intensity range)
* regionflag (L_INCLUDE_REGION, L_EXCLUDE_REGION)
* Return: pixd (1 bpp mask over selected pixels), or null on error
*
* Notes:
* (1) The pixels are selected based on the specified ranges of
* saturation and max intensity (val). For selection or
* exclusion, the pixel SV component values must be within both ranges.
* (2) Use @regionflag == L_INCLUDE_REGION to take only those
* pixels within the rectangular region specified in SV space.
* Use @regionflag == L_EXCLUDE_REGION to take all pixels except
* those within the rectangular region specified in SV space.
*/
PIX *
pixMakeRangeMaskSV(PIX *pixs,
l_int32 satcenter,
l_int32 sathw,
l_int32 valcenter,
l_int32 valhw,
l_int32 regionflag)
{
l_int32 i, j, w, h, wplt, wpld, sval, vval, sstart, send, vstart, vend;
l_int32 *slut, *vlut;
l_uint32 pixel;
l_uint32 *datat, *datad, *linet, *lined;
PIX *pixt, *pixd;
PROCNAME("pixMakeRangeMaskSV");
if (!pixs || pixGetDepth(pixs) != 32)
return (PIX *)ERROR_PTR("pixs undefined or not 32 bpp", procName, NULL);
if (regionflag != L_INCLUDE_REGION && regionflag != L_EXCLUDE_REGION)
return (PIX *)ERROR_PTR("invalid regionflag", procName, NULL);
/* Set up LUTs for saturation and max intensity (val).
* These have the value 1 within the specified intervals of
* saturation and max intensity. */
slut = (l_int32 *)CALLOC(256, sizeof(l_int32));
vlut = (l_int32 *)CALLOC(256, sizeof(l_int32));
sstart = L_MAX(0, satcenter - sathw);
send = L_MIN(255, satcenter + sathw);
vstart = L_MAX(0, valcenter - valhw);
vend = L_MIN(255, valcenter + valhw);
for (i = sstart; i <= send; i++)
slut[i] = 1;
for (i = vstart; i <= vend; i++)
vlut[i] = 1;
/* Generate the mask */
pixt = pixConvertRGBToHSV(NULL, pixs);
pixGetDimensions(pixs, &w, &h, NULL);
pixd = pixCreateNoInit(w, h, 1);
if (regionflag == L_INCLUDE_REGION)
pixClearAll(pixd);
else /* L_EXCLUDE_REGION */
pixSetAll(pixd);
datat = pixGetData(pixt);
datad = pixGetData(pixd);
wplt = pixGetWpl(pixt);
wpld = pixGetWpl(pixd);
for (i = 0; i < h; i++) {
linet = datat + i * wplt;
lined = datad + i * wpld;
for (j = 0; j < w; j++) {
pixel = linet[j];
sval = (pixel >> L_GREEN_SHIFT) & 0xff;
vval = (pixel >> L_BLUE_SHIFT) & 0xff;
if (slut[sval] == 1 && vlut[vval] == 1) {
if (regionflag == L_INCLUDE_REGION)
SET_DATA_BIT(lined, j);
else /* L_EXCLUDE_REGION */
CLEAR_DATA_BIT(lined, j);
}
}
}
FREE(slut);
FREE(vlut);
pixDestroy(&pixt);
return pixd;
}
/*!
* pixMakeHistoHS()
*
* Input: pixs (HSV colorspace)
* factor (subsampling factor; integer)
* &nahue (<optional return> hue histogram)
* &nasat (<optional return> saturation histogram)
* Return: pixd (32 bpp histogram in hue and saturation), or null on error
*
* Notes:
* (1) pixs is a 32 bpp image in HSV colorspace; hue is in the "red"
* byte, saturation is in the "green" byte.
* (2) In pixd, hue is displayed vertically; saturation horizontally.
* The dimensions of pixd are w = 256, h = 240, and the depth
* is 32 bpp. The value at each point is simply the number
* of pixels found at that value of hue and saturation.
*/
PIX *
pixMakeHistoHS(PIX *pixs,
l_int32 factor,
NUMA **pnahue,
NUMA **pnasat)
{
l_int32 i, j, w, h, wplt, hval, sval, nd;
l_uint32 pixel;
l_uint32 *datat, *linet;
void **lined32;
NUMA *nahue, *nasat;
PIX *pixt, *pixd;
PROCNAME("pixMakeHistoHS");
if (pnahue) *pnahue = NULL;
if (pnasat) *pnasat = NULL;
if (!pixs || pixGetDepth(pixs) != 32)
return (PIX *)ERROR_PTR("pixs undefined or not 32 bpp", procName, NULL);
if (pnahue) {
nahue = numaCreate(240);
numaSetCount(nahue, 240);
*pnahue = nahue;
}
if (pnasat) {
nasat = numaCreate(256);
numaSetCount(nasat, 256);
*pnasat = nasat;
}
if (factor <= 1)
pixt = pixClone(pixs);
else
pixt = pixScaleBySampling(pixs, 1.0 / (l_float32)factor,
1.0 / (l_float32)factor);
/* Create the hue-saturation histogram */
pixd = pixCreate(256, 240, 32);
lined32 = pixGetLinePtrs(pixd, NULL);
pixGetDimensions(pixt, &w, &h, NULL);
datat = pixGetData(pixt);
wplt = pixGetWpl(pixt);
for (i = 0; i < h; i++) {
linet = datat + i * wplt;
for (j = 0; j < w; j++) {
pixel = linet[j];
hval = (pixel >> L_RED_SHIFT) & 0xff;
#if DEBUG_HISTO
if (hval > 239) {
fprintf(stderr, "hval = %d for (%d,%d)\n", hval, i, j);
continue;
}
#endif /* DEBUG_HISTO */
sval = (pixel >> L_GREEN_SHIFT) & 0xff;
if (pnahue)
numaShiftValue(nahue, hval, 1.0);
if (pnasat)
numaShiftValue(nasat, sval, 1.0);
nd = GET_DATA_FOUR_BYTES(lined32[hval], sval);
SET_DATA_FOUR_BYTES(lined32[hval], sval, nd + 1);
}
}
FREE(lined32);
pixDestroy(&pixt);
return pixd;
}
/*!
* pixMakeHistoHV()
*
* Input: pixs (HSV colorspace)
* factor (subsampling factor; integer)
* &nahue (<optional return> hue histogram)
* &naval (<optional return> max intensity (value) histogram)
* Return: pixd (32 bpp histogram in hue and value), or null on error
*
* Notes:
* (1) pixs is a 32 bpp image in HSV colorspace; hue is in the "red"
* byte, max intensity ("value") is in the "blue" byte.
* (2) In pixd, hue is displayed vertically; intensity horizontally.
* The dimensions of pixd are w = 256, h = 240, and the depth
* is 32 bpp. The value at each point is simply the number
* of pixels found at that value of hue and intensity.
*/
PIX *
pixMakeHistoHV(PIX *pixs,
l_int32 factor,
NUMA **pnahue,
NUMA **pnaval)
{
l_int32 i, j, w, h, wplt, hval, vval, nd;
l_uint32 pixel;
l_uint32 *datat, *linet;
void **lined32;
NUMA *nahue, *naval;
PIX *pixt, *pixd;
PROCNAME("pixMakeHistoHV");
if (pnahue) *pnahue = NULL;
if (pnaval) *pnaval = NULL;
if (!pixs || pixGetDepth(pixs) != 32)
return (PIX *)ERROR_PTR("pixs undefined or not 32 bpp", procName, NULL);
if (pnahue) {
nahue = numaCreate(240);
numaSetCount(nahue, 240);
*pnahue = nahue;
}
if (pnaval) {
naval = numaCreate(256);
numaSetCount(naval, 256);
*pnaval = naval;
}
if (factor <= 1)
pixt = pixClone(pixs);
else
pixt = pixScaleBySampling(pixs, 1.0 / (l_float32)factor,
1.0 / (l_float32)factor);
/* Create the hue-value histogram */
pixd = pixCreate(256, 240, 32);
lined32 = pixGetLinePtrs(pixd, NULL);
pixGetDimensions(pixt, &w, &h, NULL);
datat = pixGetData(pixt);
wplt = pixGetWpl(pixt);
for (i = 0; i < h; i++) {
linet = datat + i * wplt;
for (j = 0; j < w; j++) {
pixel = linet[j];
hval = (pixel >> L_RED_SHIFT) & 0xff;
vval = (pixel >> L_BLUE_SHIFT) & 0xff;
if (pnahue)
numaShiftValue(nahue, hval, 1.0);
if (pnaval)
numaShiftValue(naval, vval, 1.0);
nd = GET_DATA_FOUR_BYTES(lined32[hval], vval);
SET_DATA_FOUR_BYTES(lined32[hval], vval, nd + 1);
}
}
FREE(lined32);
pixDestroy(&pixt);
return pixd;
}
/*!
* pixMakeHistoSV()
*
* Input: pixs (HSV colorspace)
* factor (subsampling factor; integer)
* &nasat (<optional return> sat histogram)
* &naval (<optional return> max intensity (value) histogram)
* Return: pixd (32 bpp histogram in sat and value), or null on error
*
* Notes:
* (1) pixs is a 32 bpp image in HSV colorspace; sat is in the "green"
* byte, max intensity ("value") is in the "blue" byte.
* (2) In pixd, sat is displayed vertically; intensity horizontally.
* The dimensions of pixd are w = 256, h = 256, and the depth
* is 32 bpp. The value at each point is simply the number
* of pixels found at that value of saturation and intensity.
*/
PIX *
pixMakeHistoSV(PIX *pixs,
l_int32 factor,
NUMA **pnasat,
NUMA **pnaval)
{
l_int32 i, j, w, h, wplt, sval, vval, nd;
l_uint32 pixel;
l_uint32 *datat, *linet;
void **lined32;
NUMA *nasat, *naval;
PIX *pixt, *pixd;
PROCNAME("pixMakeHistoSV");
if (pnasat) *pnasat = NULL;
if (pnaval) *pnaval = NULL;
if (!pixs || pixGetDepth(pixs) != 32)
return (PIX *)ERROR_PTR("pixs undefined or not 32 bpp", procName, NULL);
if (pnasat) {
nasat = numaCreate(256);
numaSetCount(nasat, 256);
*pnasat = nasat;
}
if (pnaval) {
naval = numaCreate(256);
numaSetCount(naval, 256);
*pnaval = naval;
}
if (factor <= 1)
pixt = pixClone(pixs);
else
pixt = pixScaleBySampling(pixs, 1.0 / (l_float32)factor,
1.0 / (l_float32)factor);
/* Create the hue-value histogram */
pixd = pixCreate(256, 256, 32);
lined32 = pixGetLinePtrs(pixd, NULL);
pixGetDimensions(pixt, &w, &h, NULL);
datat = pixGetData(pixt);
wplt = pixGetWpl(pixt);
for (i = 0; i < h; i++) {
linet = datat + i * wplt;
for (j = 0; j < w; j++) {
pixel = linet[j];
sval = (pixel >> L_GREEN_SHIFT) & 0xff;
vval = (pixel >> L_BLUE_SHIFT) & 0xff;
if (pnasat)
numaShiftValue(nasat, sval, 1.0);
if (pnaval)
numaShiftValue(naval, vval, 1.0);
nd = GET_DATA_FOUR_BYTES(lined32[sval], vval);
SET_DATA_FOUR_BYTES(lined32[sval], vval, nd + 1);
}
}
FREE(lined32);
pixDestroy(&pixt);
return pixd;
}
/*!
* pixFindHistoPeaksHSV()
*
* Input: pixs (32 bpp; HS, HV or SV histogram; not changed)
* type (L_HS_HISTO, L_HV_HISTO or L_SV_HISTO)
* width (half width of sliding window)
* height (half height of sliding window)
* npeaks (number of peaks to look for)
* erasefactor (ratio of erase window size to sliding window size)
* &pta (locations of maximum for each integrated peak area)
* &natot (integrated peak areas)
* &pixa (<optional return> pixa for debugging; NULL to skip)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) pixs is a 32 bpp histogram in a pair of HSV colorspace. It
* should be thought of as a single component with 32 bpc.
* (2) After each peak is found, the peak is erased with a window
* that is centered on the peak and scaled from the sliding
* window by @erasefactor. Typically, @erasefactor is chosen
* to be > 1.0.
* (3) Data for a maximum of @npeaks is returned in @pta and @natot.
*/
l_int32
pixFindHistoPeaksHSV(PIX *pixs,
l_int32 type,
l_int32 width,
l_int32 height,
l_int32 npeaks,
l_float32 erasefactor,
PTA **ppta,
NUMA **pnatot,
PIXA **ppixa)
{
l_int32 i, xmax, ymax, ewidth, eheight;
l_uint32 maxval;
BOX *box;
NUMA *natot;
PIX *pixh, *pixw, *pixt1, *pixt2;
PTA *pta;
PROCNAME("pixFindHistoPeaksHSV");
if (!pixs || pixGetDepth(pixs) != 32)
return ERROR_INT("pixs undefined or not 32 bpp", procName, 1);
if (!ppta || !pnatot)
return ERROR_INT("&pta and &natot not both defined", procName, 1);
if (type != L_HS_HISTO && type != L_HV_HISTO && type != L_SV_HISTO)
return ERROR_INT("invalid HSV histo type", procName, 1);
if ((pta = ptaCreate(npeaks)) == NULL)
return ERROR_INT("pta not made", procName, 1);
*ppta = pta;
if ((natot = numaCreate(npeaks)) == NULL)
return ERROR_INT("natot not made", procName, 1);
*pnatot = natot;
*ppta = pta;
if (type == L_SV_HISTO)
pixh = pixAddMirroredBorder(pixs, width + 1, width + 1, height + 1,
height + 1);
else /* type == L_HS_HISTO or type == L_HV_HISTO */
pixh = pixAddMixedBorder(pixs, width + 1, width + 1, height + 1,
height + 1);
/* Get the total count in the sliding window. If the window
* fully covers the peak, this will be the integrated
* volume under the peak. */
pixw = pixWindowedMean(pixh, width, height, 0);
pixDestroy(&pixh);
/* Sequentially identify and erase peaks in the histogram.
* If requested for debugging, save a pixa of the sequence of
* false color histograms. */
if (ppixa)
*ppixa = pixaCreate(0);
for (i = 0; i < npeaks; i++) {
pixGetMaxValueInRect(pixw, NULL, &maxval, &xmax, &ymax);
if (maxval == 0) break;
numaAddNumber(natot, maxval);
ptaAddPt(pta, xmax, ymax);
ewidth = (l_int32)(width * erasefactor);
eheight = (l_int32)(height * erasefactor);
box = boxCreate(xmax - ewidth, ymax - eheight, 2 * ewidth + 1,
2 * eheight + 1);
if (ppixa) {
pixt1 = pixMaxDynamicRange(pixw, L_LINEAR_SCALE);
pixt2 = pixConvertGrayToFalseColor(pixt1, 1.0);
pixaAddPix(*ppixa, pixt2, L_INSERT);
pixDestroy(&pixt1);
}
pixClearInRect(pixw, box);
boxDestroy(&box);
if (L_HS_HISTO || L_HV_HISTO) { /* clear wraps at bottom and top */
if (ymax - eheight < 0) { /* overlap to bottom */
box = boxCreate(xmax - ewidth, 240 + ymax - eheight,
2 * ewidth + 1, eheight - ymax);
}
else if (ymax + eheight > 239) { /* overlap to top */
box = boxCreate(xmax - ewidth, 0, 2 * ewidth + 1,
ymax + eheight - 239);
}
else
box = NULL;
if (box) {
pixClearInRect(pixw, box);
boxDestroy(&box);
}
}
}
pixDestroy(&pixw);
return 0;
}
/*!
* displayHSVColorRange()
*
* Input: hval (hue center value; in range [0 ... 240]
* sval (saturation center value; in range [0 ... 255]
* vval (max intensity value; in range [0 ... 255]
* huehw (half-width of hue range; > 0)
* sathw (half-width of saturation range; > 0)
* nsamp (number of samplings in each half-width in hue and sat)
* factor (linear size of each color square, in pixels; > 3)
* Return: pixd (32 bpp set of color squares over input range),
* or null on error
*
* Notes:
* (1) The total number of color samplings in each of the hue
* and saturation directions is 2 * nsamp + 1.
*/
PIX *
displayHSVColorRange(l_int32 hval,
l_int32 sval,
l_int32 vval,
l_int32 huehw,
l_int32 sathw,
l_int32 nsamp,
l_int32 factor)
{
l_int32 i, j, w, huedelta, satdelta, hue, sat, rval, gval, bval;
PIX *pixt, *pixd;
PROCNAME("displayHSVColorRange");
if (hval < 0 || hval > 240)
return (PIX *)ERROR_PTR("invalid hval", procName, NULL);
if (huehw < 5 || huehw > 120)
return (PIX *)ERROR_PTR("invalid huehw", procName, NULL);
if (sval - sathw < 0 || sval + sathw > 255)
return (PIX *)ERROR_PTR("invalid sval/sathw", procName, NULL);
if (nsamp < 1 || factor < 3)
return (PIX *)ERROR_PTR("invalid nsamp or rep. factor", procName, NULL);
if (vval < 0 || vval > 255)
return (PIX *)ERROR_PTR("invalid vval", procName, NULL);
w = (2 * nsamp + 1);
huedelta = (l_int32)((l_float32)huehw / (l_float32)nsamp);
satdelta = (l_int32)((l_float32)sathw / (l_float32)nsamp);
pixt = pixCreate(w, w, 32);
for (i = 0; i < w; i++) {
hue = hval + huedelta * (i - nsamp);
if (hue < 0) hue += 240;
if (hue >= 240) hue -= 240;
for (j = 0; j < w; j++) {
sat = sval + satdelta * (j - nsamp);
convertHSVToRGB(hue, sat, vval, &rval, &gval, &bval);
pixSetRGBPixel(pixt, j, i, rval, gval, bval);
}
}
pixd = pixExpandReplicate(pixt, factor);
pixDestroy(&pixt);
return pixd;
}