/*!
* pixaSelectBySize()
*
* Input: pixas
* width, height (threshold dimensions)
* type (L_SELECT_WIDTH, L_SELECT_HEIGHT,
* L_SELECT_IF_EITHER, L_SELECT_IF_BOTH)
* relation (L_SELECT_IF_LT, L_SELECT_IF_GT,
* L_SELECT_IF_LTE, L_SELECT_IF_GTE)
* &changed (<optional return> 1 if changed; 0 otherwise)
* Return: pixad, or null on error
*
* Notes:
* (1) The args specify constraints on the size of the
* components that are kept.
* (2) Uses pix and box clones in the new pixa.
* (3) If the selection type is L_SELECT_WIDTH, the input
* height is ignored, and v.v.
* (4) To keep small components, use relation = L_SELECT_IF_LT or
* L_SELECT_IF_LTE.
* To keep large components, use relation = L_SELECT_IF_GT or
* L_SELECT_IF_GTE.
*/
PIXA *
pixaSelectBySize(PIXA *pixas,
l_int32 width,
l_int32 height,
l_int32 type,
l_int32 relation,
l_int32 *pchanged)
{
BOXA *boxa;
NUMA *na;
PIXA *pixad;
PROCNAME("pixaSelectBySize");
if (!pixas)
return (PIXA *)ERROR_PTR("pixas not defined", procName, NULL);
if (type != L_SELECT_WIDTH && type != L_SELECT_HEIGHT &&
type != L_SELECT_IF_EITHER && type != L_SELECT_IF_BOTH)
return (PIXA *)ERROR_PTR("invalid type", procName, NULL);
if (relation != L_SELECT_IF_LT && relation != L_SELECT_IF_GT &&
relation != L_SELECT_IF_LTE && relation != L_SELECT_IF_GTE)
return (PIXA *)ERROR_PTR("invalid relation", procName, NULL);
/* Compute the indicator array for saving components */
boxa = pixaGetBoxa(pixas, L_CLONE);
na = boxaMakeSizeIndicator(boxa, width, height, type, relation);
boxaDestroy(&boxa);
/* Filter to get output */
pixad = pixaSelectWithIndicator(pixas, na, pchanged);
numaDestroy(&na);
return pixad;
}
/*!
* pixaJoin()
*
* Input: pixad (dest pixa; add to this one)
* pixas (source pixa; add from this one)
* istart (starting index in nas)
* iend (ending index in nas; use 0 to cat all)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This appends a clone of each indicated pix in pixas to pixad
* (2) istart < 0 is taken to mean 'read from the start' (istart = 0)
* (3) iend <= 0 means 'read to the end'
*/
l_int32
pixaJoin(PIXA *pixad,
PIXA *pixas,
l_int32 istart,
l_int32 iend)
{
l_int32 ns, i;
BOXA *boxas, *boxad;
PIX *pix;
PROCNAME("pixaJoin");
if (!pixad)
return ERROR_INT("pixad not defined", procName, 1);
if (!pixas)
return ERROR_INT("pixas not defined", procName, 1);
if ((ns = pixaGetCount(pixas)) == 0) {
L_INFO("empty pixas", procName);
return 0;
}
if (istart < 0)
istart = 0;
if (istart >= ns)
return ERROR_INT("istart out of bounds", procName, 1);
if (iend <= 0)
iend = ns - 1;
if (iend >= ns)
return ERROR_INT("iend out of bounds", procName, 1);
if (istart > iend)
return ERROR_INT("istart > iend; nothing to add", procName, 1);
for (i = istart; i <= iend; i++) {
pix = pixaGetPix(pixas, i, L_CLONE);
pixaAddPix(pixad, pix, L_INSERT);
}
boxas = pixaGetBoxa(pixas, L_CLONE);
boxad = pixaGetBoxa(pixad, L_CLONE);
boxaJoin(boxad, boxas, 0, 0);
boxaDestroy(&boxas); /* just the clones */
boxaDestroy(&boxad);
return 0;
}
/*!
* pixaDisplay()
*
* Input: pixa
* w, h (if set to 0, determines the size from the
* b.b. of the components in pixa)
* Return: pix, or null on error
*
* Notes:
* (1) This uses the boxes to place each pix in the rendered composite.
* (2) Set w = h = 0 to use the b.b. of the components to determine
* the size of the returned pix.
* (3) Uses the first pix in pixa to determine the depth.
* (4) The background is written "white". On 1 bpp, each successive
* pix is "painted" (adding foreground), whereas for grayscale
* or color each successive pix is blitted with just the src.
* (5) If the pixa is empty, returns an empty 1 bpp pix.
*/
PIX *
pixaDisplay(PIXA *pixa,
l_int32 w,
l_int32 h)
{
l_int32 i, n, d, xb, yb, wb, hb;
BOXA *boxa;
PIX *pixt, *pixd;
PROCNAME("pixaDisplay");
if (!pixa)
return (PIX *)ERROR_PTR("pixa not defined", procName, NULL);
n = pixaGetCount(pixa);
if (n == 0 && w == 0 && h == 0)
return (PIX *)ERROR_PTR("no components; no size", procName, NULL);
if (n == 0) {
L_WARNING("no components; returning empty 1 bpp pix", procName);
return pixCreate(w, h, 1);
}
/* If w and h not input, determine the minimum size required
* to contain the origin and all c.c. */
if (w == 0 || h == 0) {
boxa = pixaGetBoxa(pixa, L_CLONE);
boxaGetExtent(boxa, &w, &h, NULL);
boxaDestroy(&boxa);
}
/* Use the first pix in pixa to determine the depth. */
pixt = pixaGetPix(pixa, 0, L_CLONE);
d = pixGetDepth(pixt);
pixDestroy(&pixt);
if ((pixd = pixCreate(w, h, d)) == NULL)
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
if (d > 1)
pixSetAll(pixd);
for (i = 0; i < n; i++) {
if (pixaGetBoxGeometry(pixa, i, &xb, &yb, &wb, &hb)) {
L_WARNING("no box found!", procName);
continue;
}
pixt = pixaGetPix(pixa, i, L_CLONE);
if (d == 1)
pixRasterop(pixd, xb, yb, wb, hb, PIX_PAINT, pixt, 0, 0);
else
pixRasterop(pixd, xb, yb, wb, hb, PIX_SRC, pixt, 0, 0);
pixDestroy(&pixt);
}
return pixd;
}
/*!
* \brief pixGetWordsInTextlines()
*
* \param[in] pixs 1 bpp, typ. 75 - 150 ppi
* \param[in] minwidth, minheight of saved components; smaller are discarded
* \param[in] maxwidth, maxheight of saved components; larger are discarded
* \param[out] pboxad word boxes sorted in textline line order
* \param[out] ppixad word images sorted in textline line order
* \param[out] pnai index of textline for each word
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) The input should be at a resolution of between 75 and 150 ppi.
* (2) The four size constraints on saved components are all
* scaled by %reduction.
* (3) The result are word images (and their b.b.), extracted in
* textline order, at either full res or 2x reduction,
* and with a numa giving the textline index for each word.
* (4) The pixa and boxa interfaces should make this type of
* application simple to put together. The steps are:
* ~ generate first estimate of word masks
* ~ get b.b. of these, and remove the small and big ones
* ~ extract pixa of the word images, using the b.b.
* ~ sort actual word images in textline order (2d)
* ~ flatten them to a pixa (1d), saving the textline index
* for each pix
* (5) In an actual application, it may be desirable to pre-filter
* the input image to remove large components, to extract
* single columns of text, and to deskew them. For example,
* to remove both large components and small noisy components
* that can interfere with the statistics used to estimate
* parameters for segmenting by words, but still retain text lines,
* the following image preprocessing can be done:
* Pix *pixt = pixMorphSequence(pixs, "c40.1", 0);
* Pix *pixf = pixSelectBySize(pixt, 0, 60, 8,
* L_SELECT_HEIGHT, L_SELECT_IF_LT, NULL);
* pixAnd(pixf, pixf, pixs); // the filtered image
* The closing turns text lines into long blobs, but does not
* significantly increase their height. But if there are many
* small connected components in a dense texture, this is likely
* to generate tall components that will be eliminated in pixf.
* </pre>
*/
l_int32
pixGetWordsInTextlines(PIX *pixs,
l_int32 minwidth,
l_int32 minheight,
l_int32 maxwidth,
l_int32 maxheight,
BOXA **pboxad,
PIXA **ppixad,
NUMA **pnai)
{
BOXA *boxa1, *boxad;
BOXAA *baa;
NUMA *nai;
NUMAA *naa;
PIXA *pixa1, *pixad;
PIXAA *paa;
PROCNAME("pixGetWordsInTextlines");
if (!pboxad || !ppixad || !pnai)
return ERROR_INT("&boxad, &pixad, &nai not all defined", procName, 1);
*pboxad = NULL;
*ppixad = NULL;
*pnai = NULL;
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
/* Get the bounding boxes of the words from the word mask. */
pixWordBoxesByDilation(pixs, minwidth, minheight, maxwidth, maxheight,
&boxa1, NULL, NULL);
/* Generate a pixa of the word images */
pixa1 = pixaCreateFromBoxa(pixs, boxa1, NULL); /* mask over each word */
/* Sort the bounding boxes of these words by line. We use the
* index mapping to allow identical sorting of the pixa. */
baa = boxaSort2d(boxa1, &naa, -1, -1, 4);
paa = pixaSort2dByIndex(pixa1, naa, L_CLONE);
/* Flatten the word paa */
pixad = pixaaFlattenToPixa(paa, &nai, L_CLONE);
boxad = pixaGetBoxa(pixad, L_COPY);
*pnai = nai;
*pboxad = boxad;
*ppixad = pixad;
pixaDestroy(&pixa1);
boxaDestroy(&boxa1);
boxaaDestroy(&baa);
pixaaDestroy(&paa);
numaaDestroy(&naa);
return 0;
}
/*!
* pixaAddBorderGeneral()
*
* Input: pixad (can be null or equal to pixas)
* pixas (containing pix of all depths; colormap ok)
* left, right, top, bot (number of pixels added)
* val (value of added border pixels)
* Return: pixad (with border added to each pix), including on error
*
* Notes:
* (1) For binary images:
* white: val = 0
* black: val = 1
* For grayscale images:
* white: val = 2 ** d - 1
* black: val = 0
* For rgb color images:
* white: val = 0xffffff00
* black: val = 0
* For colormapped images, use 'index' found this way:
* white: pixcmapGetRankIntensity(cmap, 1.0, &index);
* black: pixcmapGetRankIntensity(cmap, 0.0, &index);
* (2) For in-place replacement of each pix with a bordered version,
* use @pixad = @pixas. To make a new pixa, use @pixad = NULL.
* (3) In both cases, the boxa has sides adjusted as if it were
* expanded by the border.
*/
PIXA *
pixaAddBorderGeneral(PIXA *pixad,
PIXA *pixas,
l_int32 left,
l_int32 right,
l_int32 top,
l_int32 bot,
l_uint32 val)
{
l_int32 i, n, nbox;
BOX *box;
BOXA *boxad;
PIX *pixs, *pixd;
PROCNAME("pixaAddBorderGeneral");
if (!pixas)
return (PIXA *)ERROR_PTR("pixas not defined", procName, pixad);
if (left < 0 || right < 0 || top < 0 || bot < 0)
return (PIXA *)ERROR_PTR("negative border added!", procName, pixad);
if (pixad && (pixad != pixas))
return (PIXA *)ERROR_PTR("pixad defined but != pixas", procName, pixad);
n = pixaGetCount(pixas);
if (!pixad)
pixad = pixaCreate(n);
for (i = 0; i < n; i++) {
pixs = pixaGetPix(pixas, i, L_CLONE);
pixd = pixAddBorderGeneral(pixs, left, right, top, bot, val);
if (pixad == pixas) /* replace */
pixaReplacePix(pixad, i, pixd, NULL);
else
pixaAddPix(pixad, pixd, L_INSERT);
pixDestroy(&pixs);
}
nbox = pixaGetBoxaCount(pixas);
boxad = pixaGetBoxa(pixad, L_CLONE);
for (i = 0; i < nbox; i++) {
if ((box = pixaGetBox(pixas, i, L_COPY)) == NULL) {
L_WARNING_INT("box %d not found", procName, i);
break;
}
boxAdjustSides(box, box, -left, right, -top, bot);
if (pixad == pixas) /* replace */
boxaReplaceBox(boxad, i, box);
else
boxaAddBox(boxad, box, L_INSERT);
}
boxaDestroy(&boxad);
return pixad;
}
/*!
* pixaDisplayRandomCmap()
*
* Input: pixa (of 1 bpp components, with boxa)
* w, h (if set to 0, determines the size from the
* b.b. of the components in pixa)
* Return: pix (8 bpp, cmapped, with random colors on the components),
* or null on error
*
* Notes:
* (1) This uses the boxes to place each pix in the rendered composite.
* (2) By default, the background color is: black, cmap index 0.
* This can be changed by pixcmapResetColor()
*/
PIX *
pixaDisplayRandomCmap(PIXA *pixa,
l_int32 w,
l_int32 h)
{
l_int32 i, n, d, index, xb, yb, wb, hb;
BOXA *boxa;
PIX *pixs, *pixt, *pixd;
PIXCMAP *cmap;
PROCNAME("pixaDisplayRandomCmap");
if (!pixa)
return (PIX *)ERROR_PTR("pixa not defined", procName, NULL);
n = pixaGetCount(pixa);
if (n == 0)
return (PIX *)ERROR_PTR("no components", procName, NULL);
/* Use the first pix in pixa to verify depth is 1 bpp */
pixs = pixaGetPix(pixa, 0, L_CLONE);
d = pixGetDepth(pixs);
pixDestroy(&pixs);
if (d != 1)
return (PIX *)ERROR_PTR("components not 1 bpp", procName, NULL);
/* If w and h not input, determine the minimum size required
* to contain the origin and all c.c. */
if (w == 0 || h == 0) {
boxa = pixaGetBoxa(pixa, L_CLONE);
boxaGetExtent(boxa, &w, &h, NULL);
boxaDestroy(&boxa);
}
/* Set up an 8 bpp dest pix, with a colormap with 254 random colors */
if ((pixd = pixCreate(w, h, 8)) == NULL)
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
cmap = pixcmapCreateRandom(8, 1, 1);
pixSetColormap(pixd, cmap);
/* Color each component and blit it in */
for (i = 0; i < n; i++) {
index = 1 + (i % 254);
pixaGetBoxGeometry(pixa, i, &xb, &yb, &wb, &hb);
pixs = pixaGetPix(pixa, i, L_CLONE);
pixt = pixConvert1To8(NULL, pixs, 0, index);
pixRasterop(pixd, xb, yb, wb, hb, PIX_PAINT, pixt, 0, 0);
pixDestroy(&pixs);
pixDestroy(&pixt);
}
return pixd;
}
/*!
* \brief pixGetWordsInTextlines()
*
* \param[in] pixs 1 bpp, typ. 300 ppi
* \param[in] reduction 1 for input res; 2 for 2x reduction of input res
* \param[in] minwidth, minheight of saved components; smaller are discarded
* \param[in] maxwidth, maxheight of saved components; larger are discarded
* \param[out] pboxad word boxes sorted in textline line order
* \param[out] ppixad word images sorted in textline line order
* \param[out] pnai index of textline for each word
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) The input should be at a resolution of about 300 ppi.
* The word masks and word images can be computed at either
* 150 ppi or 300 ppi. For the former, set reduction = 2.
* (2) The four size constraints on saved components are all
* scaled by %reduction.
* (3) The result are word images (and their b.b.), extracted in
* textline order, at either full res or 2x reduction,
* and with a numa giving the textline index for each word.
* (4) The pixa and boxa interfaces should make this type of
* application simple to put together. The steps are:
* ~ optionally reduce by 2x
* ~ generate first estimate of word masks
* ~ get b.b. of these, and remove the small and big ones
* ~ extract pixa of the word images, using the b.b.
* ~ sort actual word images in textline order (2d)
* ~ flatten them to a pixa (1d), saving the textline index
* for each pix
* (5) In an actual application, it may be desirable to pre-filter
* the input image to remove large components, to extract
* single columns of text, and to deskew them. For example,
* to remove both large components and small noisy components
* that can interfere with the statistics used to estimate
* parameters for segmenting by words, but still retain text lines,
* the following image preprocessing can be done:
* Pix *pixt = pixMorphSequence(pixs, "c40.1", 0);
* Pix *pixf = pixSelectBySize(pixt, 0, 60, 8,
* L_SELECT_HEIGHT, L_SELECT_IF_LT, NULL);
* pixAnd(pixf, pixf, pixs); // the filtered image
* The closing turns text lines into long blobs, but does not
* significantly increase their height. But if there are many
* small connected components in a dense texture, this is likely
* to generate tall components that will be eliminated in pixf.
* </pre>
*/
l_int32
pixGetWordsInTextlines(PIX *pixs,
l_int32 reduction,
l_int32 minwidth,
l_int32 minheight,
l_int32 maxwidth,
l_int32 maxheight,
BOXA **pboxad,
PIXA **ppixad,
NUMA **pnai)
{
l_int32 maxdil;
BOXA *boxa1, *boxad;
BOXAA *baa;
NUMA *nai;
NUMAA *naa;
PIXA *pixa1, *pixad;
PIX *pix1;
PIXAA *paa;
PROCNAME("pixGetWordsInTextlines");
if (!pboxad || !ppixad || !pnai)
return ERROR_INT("&boxad, &pixad, &nai not all defined", procName, 1);
*pboxad = NULL;
*ppixad = NULL;
*pnai = NULL;
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (reduction != 1 && reduction != 2)
return ERROR_INT("reduction not in {1,2}", procName, 1);
if (reduction == 1) {
pix1 = pixClone(pixs);
maxdil = 18;
} else { /* reduction == 2 */
pix1 = pixReduceRankBinaryCascade(pixs, 1, 0, 0, 0);
maxdil = 9;
}
/* Get the bounding boxes of the words from the word mask. */
pixWordBoxesByDilation(pix1, maxdil, minwidth, minheight,
maxwidth, maxheight, &boxa1, NULL);
/* Generate a pixa of the word images */
pixa1 = pixaCreateFromBoxa(pix1, boxa1, NULL); /* mask over each word */
/* Sort the bounding boxes of these words by line. We use the
* index mapping to allow identical sorting of the pixa. */
baa = boxaSort2d(boxa1, &naa, -1, -1, 4);
paa = pixaSort2dByIndex(pixa1, naa, L_CLONE);
/* Flatten the word paa */
pixad = pixaaFlattenToPixa(paa, &nai, L_CLONE);
boxad = pixaGetBoxa(pixad, L_COPY);
*pnai = nai;
*pboxad = boxad;
*ppixad = pixad;
pixDestroy(&pix1);
pixaDestroy(&pixa1);
boxaDestroy(&boxa1);
boxaaDestroy(&baa);
pixaaDestroy(&paa);
numaaDestroy(&naa);
return 0;
}
/*!
* pixaEqual()
*
* Input: pixa1
* pixa2
* maxdist
* &naindex (<optional return> index array of correspondences
* &same (<return> 1 if equal; 0 otherwise)
* Return 0 if OK, 1 on error
*
* Notes:
* (1) The two pixa are the "same" if they contain the same
* boxa and the same ordered set of pix. However, if they
* have boxa, the pix in each pixa can differ in ordering
* by an amount given by the parameter @maxdist. If they
* don't have a boxa, the @maxdist parameter is ignored,
* and the ordering must be identical.
* (2) This applies only to boxa geometry, pixels and ordering;
* other fields in the pix are ignored.
* (3) naindex[i] gives the position of the box in pixa2 that
* corresponds to box i in pixa1. It is only returned if the
* pixa have boxa and the boxa are equal.
* (4) In situations where the ordering is very different, so that
* a large @maxdist is required for "equality", this should be
* implemented with a hash function for efficiency.
*/
l_int32
pixaEqual(PIXA *pixa1,
PIXA *pixa2,
l_int32 maxdist,
NUMA **pnaindex,
l_int32 *psame)
{
l_int32 i, j, n, same, sameboxa;
BOXA *boxa1, *boxa2;
NUMA *na;
PIX *pix1, *pix2;
PROCNAME("pixaEqual");
if (!psame)
return ERROR_INT("&same not defined", procName, 1);
*psame = 0;
sameboxa = 0;
na = NULL;
if (!pixa1 || !pixa2)
return ERROR_INT("pixa1 and pixa2 not both defined", procName, 1);
n = pixaGetCount(pixa1);
if (n != pixaGetCount(pixa2))
return 0;
boxa1 = pixaGetBoxa(pixa1, L_CLONE);
boxa2 = pixaGetBoxa(pixa2, L_CLONE);
if (!boxa1 && !boxa2)
maxdist = 0; /* exact ordering required */
if (boxa1 && !boxa2) {
boxaDestroy(&boxa1);
return 0;
}
if (!boxa1 && boxa2) {
boxaDestroy(&boxa2);
return 0;
}
if (boxa1 && boxa2) {
boxaEqual(boxa1, boxa2, maxdist, &na, &sameboxa);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
if (!sameboxa) {
numaDestroy(&na);
return 0;
}
}
for (i = 0; i < n; i++) {
pix1 = pixaGetPix(pixa1, i, L_CLONE);
if (na)
numaGetIValue(na, i, &j);
else
j = i;
pix2 = pixaGetPix(pixa2, j, L_CLONE);
pixEqual(pix1, pix2, &same);
pixDestroy(&pix1);
pixDestroy(&pix2);
if (!same) {
numaDestroy(&na);
return 0;
}
}
*psame = 1;
if (pnaindex)
*pnaindex = na;
else
numaDestroy(&na);
return 0;
}
/*!
* pixaaDisplay()
*
* Input: pixaa
* w, h (if set to 0, determines the size from the
* b.b. of the components in pixaa)
* Return: pix, or null on error
*
* Notes:
* (1) Each pix of the pixaa is displayed at the location given by
* its box, translated by the box of the containing pixa
* if it exists.
*/
PIX *
pixaaDisplay(PIXAA *pixaa,
l_int32 w,
l_int32 h)
{
l_int32 i, j, n, nbox, na, d, wmax, hmax, x, y, xb, yb, wb, hb;
BOXA *boxa1; /* top-level boxa */
BOXA *boxa;
PIX *pixt, *pixd;
PIXA *pixa;
PROCNAME("pixaaDisplay");
if (!pixaa)
return (PIX *)ERROR_PTR("pixaa not defined", procName, NULL);
n = pixaaGetCount(pixaa);
if (n == 0)
return (PIX *)ERROR_PTR("no components", procName, NULL);
/* If w and h not input, determine the minimum size required
* to contain the origin and all c.c. */
boxa1 = pixaaGetBoxa(pixaa, L_CLONE);
nbox = boxaGetCount(boxa1);
if (w == 0 || h == 0) {
if (nbox == n)
boxaGetExtent(boxa1, &w, &h, NULL);
else { /* have to use the lower-level boxa for each pixa */
wmax = hmax = 0;
for (i = 0; i < n; i++) {
pixa = pixaaGetPixa(pixaa, i, L_CLONE);
boxa = pixaGetBoxa(pixa, L_CLONE);
boxaGetExtent(boxa, &w, &h, NULL);
wmax = L_MAX(wmax, w);
hmax = L_MAX(hmax, h);
pixaDestroy(&pixa);
boxaDestroy(&boxa);
}
w = wmax;
h = hmax;
}
}
/* Get depth from first pix */
pixa = pixaaGetPixa(pixaa, 0, L_CLONE);
pixt = pixaGetPix(pixa, 0, L_CLONE);
d = pixGetDepth(pixt);
pixaDestroy(&pixa);
pixDestroy(&pixt);
if ((pixd = pixCreate(w, h, d)) == NULL)
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
x = y = 0;
for (i = 0; i < n; i++) {
pixa = pixaaGetPixa(pixaa, i, L_CLONE);
if (nbox == n)
boxaGetBoxGeometry(boxa1, i, &x, &y, NULL, NULL);
na = pixaGetCount(pixa);
for (j = 0; j < na; j++) {
pixaGetBoxGeometry(pixa, j, &xb, &yb, &wb, &hb);
pixt = pixaGetPix(pixa, j, L_CLONE);
pixRasterop(pixd, x + xb, y + yb, wb, hb, PIX_PAINT, pixt, 0, 0);
pixDestroy(&pixt);
}
pixaDestroy(&pixa);
}
boxaDestroy(&boxa1);
return pixd;
}
/*!
* pixaDisplayOnColor()
*
* Input: pixa
* w, h (if set to 0, determines the size from the
* b.b. of the components in pixa)
* color (background color to use)
* Return: pix, or null on error
*
* Notes:
* (1) This uses the boxes to place each pix in the rendered composite.
* (2) Set w = h = 0 to use the b.b. of the components to determine
* the size of the returned pix.
* (3) If any pix in @pixa are colormapped, or if the pix have
* different depths, it returns a 32 bpp pix. Otherwise,
* the depth of the returned pixa equals that of the pix in @pixa.
* (4) If the pixa is empty, return null.
*/
PIX *
pixaDisplayOnColor(PIXA *pixa,
l_int32 w,
l_int32 h,
l_uint32 bgcolor)
{
l_int32 i, n, xb, yb, wb, hb, hascmap, maxdepth, same;
BOXA *boxa;
PIX *pixt1, *pixt2, *pixd;
PIXA *pixat;
PROCNAME("pixaDisplayOnColor");
if (!pixa)
return (PIX *)ERROR_PTR("pixa not defined", procName, NULL);
if ((n = pixaGetCount(pixa)) == 0)
return (PIX *)ERROR_PTR("no components", procName, NULL);
/* If w and h are not input, determine the minimum size
* required to contain the origin and all c.c. */
if (w == 0 || h == 0) {
boxa = pixaGetBoxa(pixa, L_CLONE);
boxaGetExtent(boxa, &w, &h, NULL);
boxaDestroy(&boxa);
}
/* If any pix have colormaps, or if they have different depths,
* generate rgb */
pixaAnyColormaps(pixa, &hascmap);
pixaGetDepthInfo(pixa, &maxdepth, &same);
if (hascmap || !same) {
maxdepth = 32;
pixat = pixaCreate(n);
for (i = 0; i < n; i++) {
pixt1 = pixaGetPix(pixa, i, L_CLONE);
pixt2 = pixConvertTo32(pixt1);
pixaAddPix(pixat, pixt2, L_INSERT);
pixDestroy(&pixt1);
}
}
else
pixat = pixaCopy(pixa, L_CLONE);
/* Make the output pix and set the background color */
if ((pixd = pixCreate(w, h, maxdepth)) == NULL)
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
if ((maxdepth == 1 && bgcolor > 0) ||
(maxdepth == 2 && bgcolor >= 0x3) ||
(maxdepth == 4 && bgcolor >= 0xf) ||
(maxdepth == 8 && bgcolor >= 0xff) ||
(maxdepth == 16 && bgcolor >= 0xffff) ||
(maxdepth == 32 && bgcolor >= 0xffffff00)) {
pixSetAll(pixd);
}
else if (bgcolor > 0)
pixSetAllArbitrary(pixd, bgcolor);
/* Blit each pix into its place */
for (i = 0; i < n; i++) {
if (pixaGetBoxGeometry(pixat, i, &xb, &yb, &wb, &hb)) {
L_WARNING("no box found!", procName);
continue;
}
pixt1 = pixaGetPix(pixat, i, L_CLONE);
pixRasterop(pixd, xb, yb, wb, hb, PIX_SRC, pixt1, 0, 0);
pixDestroy(&pixt1);
}
pixaDestroy(&pixat);
return pixd;
}