jint Java_com_example_ocr_Pixa_nativeCopy(JNIEnv *env, jclass clazz,
jint nativePixa) {
PIXA *pixas = (PIXA *) nativePixa;
PIXA *pixad = pixaCopy(pixas, L_CLONE);
return (jint) pixad;
}
/*!
* pixaaAddPixa()
*
* Input: pixaa
* pixa (to be added)
* copyflag:
* L_INSERT inserts the pixa directly
* L_COPY makes a new pixa and copies each pix and each box
* L_CLONE gives a new handle to the input pixa
* L_COPY_CLONE makes a new pixa and inserts clones of
* all pix and boxes
* Return: 0 if OK; 1 on error
*/
l_int32
pixaaAddPixa(PIXAA *pixaa,
PIXA *pixa,
l_int32 copyflag)
{
l_int32 n;
PIXA *pixac;
PROCNAME("pixaaAddPixa");
if (!pixaa)
return ERROR_INT("pixaa not defined", procName, 1);
if (!pixa)
return ERROR_INT("pixa not defined", procName, 1);
if (copyflag != L_INSERT && copyflag != L_COPY &&
copyflag != L_CLONE && copyflag != L_COPY_CLONE)
return ERROR_INT("invalid copyflag", procName, 1);
if (copyflag == L_INSERT)
pixac = pixa;
else {
if ((pixac = pixaCopy(pixa, copyflag)) == NULL)
return ERROR_INT("pixac not made", procName, 1);
}
n = pixaaGetCount(pixaa);
if (n >= pixaa->nalloc)
pixaaExtendArray(pixaa);
pixaa->pixa[n] = pixac;
pixaa->n++;
return 0;
}
jlong Java_com_googlecode_leptonica_android_Pixa_nativeCopy(JNIEnv *env, jclass clazz,
jlong nativePixa) {
PIXA *pixas = (PIXA *) nativePixa;
PIXA *pixad = pixaCopy(pixas, L_CLONE);
return (jlong) pixad;
}
/*!
* wshedBasins()
*
* Input: wshed
* &pixa (<optional return> mask of watershed basins)
* &nalevels (<optional return> watershed levels)
* Return: 0 if OK, 1 on error
*/
l_int32
wshedBasins(L_WSHED *wshed,
PIXA **ppixa,
NUMA **pnalevels) {
PROCNAME("wshedBasins");
if (!wshed)
return ERROR_INT("wshed not defined", procName, 1);
if (ppixa)
*ppixa = pixaCopy(wshed->pixad, L_CLONE);
if (pnalevels)
*pnalevels = numaClone(wshed->nalevels);
return 0;
}
/*!
* pixaSelectWithIndicator()
*
* Input: pixas
* na (indicator numa)
* &changed (<optional return> 1 if changed; 0 if clone returned)
* Return: pixad, or null on error
*
* Notes:
* (1) Returns a pixa clone if no components are removed.
* (2) Uses pix and box clones in the new pixa.
* (3) The indicator numa has values 0 (ignore) and 1 (accept).
*/
PIXA *
pixaSelectWithIndicator(PIXA *pixas,
NUMA *na,
l_int32 *pchanged)
{
l_int32 i, n, ival, nsave;
BOX *box;
PIX *pixt;
PIXA *pixad;
PROCNAME("pixaSelectWithIndicator");
if (!pixas)
return (PIXA *)ERROR_PTR("pixas not defined", procName, NULL);
if (!na)
return (PIXA *)ERROR_PTR("na not defined", procName, NULL);
nsave = 0;
n = numaGetCount(na);
for (i = 0; i < n; i++) {
numaGetIValue(na, i, &ival);
if (ival == 1) nsave++;
}
if (nsave == n) {
if (pchanged) *pchanged = FALSE;
return pixaCopy(pixas, L_CLONE);
}
if (pchanged) *pchanged = TRUE;
pixad = pixaCreate(nsave);
for (i = 0; i < n; i++) {
numaGetIValue(na, i, &ival);
if (ival == 0) continue;
pixt = pixaGetPix(pixas, i, L_CLONE);
box = pixaGetBox(pixas, i, L_CLONE);
pixaAddPix(pixad, pixt, L_INSERT);
pixaAddBox(pixad, box, L_INSERT);
}
return pixad;
}
/*!
* pixaaGetPixa()
*
* Input: pixaa
* index (to the index-th pixa)
* accesstype (L_COPY, L_CLONE, L_COPY_CLONE)
* Return: pixa, or null on error
*
* Notes:
* (1) L_COPY makes a new pixa with a copy of every pix
* (2) L_CLONE just makes a new reference to the pixa,
* and bumps the counter. You would use this, for example,
* when you need to extract some data from a pix within a
* pixa within a pixaa.
* (3) L_COPY_CLONE makes a new pixa with a clone of every pix
* and box
* (4) In all cases, you must invoke pixaDestroy() on the returned pixa
*/
PIXA *
pixaaGetPixa(PIXAA *pixaa,
l_int32 index,
l_int32 accesstype)
{
PIXA *pixa;
PROCNAME("pixaaGetPixa");
if (!pixaa)
return (PIXA *)ERROR_PTR("pixaa not defined", procName, NULL);
if (index < 0 || index >= pixaa->n)
return (PIXA *)ERROR_PTR("index not valid", procName, NULL);
if (accesstype != L_COPY && accesstype != L_CLONE &&
accesstype != L_COPY_CLONE)
return (PIXA *)ERROR_PTR("invalid accesstype", procName, NULL);
if ((pixa = pixaa->pixa[index]) == NULL) /* shouldn't happen! */
return (PIXA *)ERROR_PTR("no pixa[index]", procName, NULL);
return pixaCopy(pixa, accesstype);
}
/*!
* pixaDisplayTiled()
*
* Input: pixa
* maxwidth (of output image)
* background (0 for white, 1 for black)
* spacing
* Return: pix of tiled images, or null on error
*
* Notes:
* (1) This saves a pixa to a single image file of width not to
* exceed maxwidth, with background color either white or black,
* and with each subimage spaced on a regular lattice.
* (2) The lattice size is determined from the largest width and height,
* separately, of all pix in the pixa.
* (3) All pix in the pixa must be of equal depth.
* (4) If any pix has a colormap, all pix are rendered in rgb.
* (5) Careful: because no components are omitted, this is
* dangerous if there are thousands of small components and
* one or more very large one, because the size of the
* resulting pix can be huge!
*/
PIX *
pixaDisplayTiled(PIXA *pixa,
l_int32 maxwidth,
l_int32 background,
l_int32 spacing)
{
l_int32 w, h, wmax, hmax, wd, hd, d, hascmap;
l_int32 i, j, n, ni, ncols, nrows;
l_int32 ystart, xstart, wt, ht;
PIX *pix, *pixt, *pixd;
PIXA *pixat;
PROCNAME("pixaDisplayTiled");
if (!pixa)
return (PIX *)ERROR_PTR("pixa not defined", procName, NULL);
/* If any pix have colormaps, generate rgb */
if ((n = pixaGetCount(pixa)) == 0)
return (PIX *)ERROR_PTR("no components", procName, NULL);
pixaAnyColormaps(pixa, &hascmap);
if (hascmap) {
pixat = pixaCreate(n);
for (i = 0; i < n; i++) {
pixt = pixaGetPix(pixa, i, L_CLONE);
pix = pixConvertTo32(pixt);
pixaAddPix(pixat, pix, L_INSERT);
pixDestroy(&pixt);
}
}
else
pixat = pixaCopy(pixa, L_CLONE);
/* Find the largest width and height of the subimages */
wmax = hmax = 0;
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixat, i, L_CLONE);
pixGetDimensions(pix, &w, &h, NULL);
if (i == 0)
d = pixGetDepth(pix);
else if (d != pixGetDepth(pix)) {
pixDestroy(&pix);
pixaDestroy(&pixat);
return (PIX *)ERROR_PTR("depths not equal", procName, NULL);
}
if (w > wmax)
wmax = w;
if (h > hmax)
hmax = h;
pixDestroy(&pix);
}
/* Get the number of rows and columns and the output image size */
spacing = L_MAX(spacing, 0);
ncols = (l_int32)((l_float32)(maxwidth - spacing) /
(l_float32)(wmax + spacing));
nrows = (n + ncols - 1) / ncols;
wd = wmax * ncols + spacing * (ncols + 1);
hd = hmax * nrows + spacing * (nrows + 1);
if ((pixd = pixCreate(wd, hd, d)) == NULL) {
pixaDestroy(&pixat);
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
}
#if 0
fprintf(stderr, " nrows = %d, ncols = %d, wmax = %d, hmax = %d\n",
nrows, ncols, wmax, hmax);
fprintf(stderr, " space = %d, wd = %d, hd = %d, n = %d\n",
space, wd, hd, n);
#endif
/* Reset the background color if necessary */
if ((background == 1 && d == 1) || (background == 0 && d != 1))
pixSetAll(pixd);
/* Blit the images to the dest */
for (i = 0, ni = 0; i < nrows; i++) {
ystart = spacing + i * (hmax + spacing);
for (j = 0; j < ncols && ni < n; j++, ni++) {
xstart = spacing + j * (wmax + spacing);
pix = pixaGetPix(pixat, ni, L_CLONE);
wt = pixGetWidth(pix);
ht = pixGetHeight(pix);
pixRasterop(pixd, xstart, ystart, wt, ht, PIX_SRC, pix, 0, 0);
pixDestroy(&pix);
}
}
pixaDestroy(&pixat);
return pixd;
}
/*!
* pixaDisplayOnLattice()
*
* Input: pixa
* xspace
* yspace
* Return: pix of composite images, or null on error
*
* Notes:
* (1) This places each pix on sequentially on a regular lattice
* in the rendered composite. If a pix is too large to fit in the
* allocated lattice space, it is not rendered.
* (2) If any pix has a colormap, all pix are rendered in rgb.
* (3) This is useful when putting bitmaps of components,
* such as characters, into a single image.
*/
PIX *
pixaDisplayOnLattice(PIXA *pixa,
l_int32 xspace,
l_int32 yspace)
{
l_int32 n, nw, nh, w, h, d, wt, ht;
l_int32 index, i, j, hascmap;
PIX *pix, *pixt, *pixd;
PIXA *pixat;
PROCNAME("pixaDisplayOnLattice");
if (!pixa)
return (PIX *)ERROR_PTR("pixa not defined", procName, NULL);
/* If any pix have colormaps, generate rgb */
if ((n = pixaGetCount(pixa)) == 0)
return (PIX *)ERROR_PTR("no components", procName, NULL);
pixaAnyColormaps(pixa, &hascmap);
if (hascmap) {
pixat = pixaCreate(n);
for (i = 0; i < n; i++) {
pixt = pixaGetPix(pixa, i, L_CLONE);
pix = pixConvertTo32(pixt);
pixaAddPix(pixat, pix, L_INSERT);
pixDestroy(&pixt);
}
}
else
pixat = pixaCopy(pixa, L_CLONE);
nw = (l_int32)sqrt((l_float64)n);
nh = (n + nw - 1) / nw;
w = xspace * nw;
h = yspace * nh;
/* Use the first pix in pixa to determine the depth. */
pixaGetPixDimensions(pixat, 0, NULL, NULL, &d);
if ((pixd = pixCreate(w, h, d)) == NULL) {
pixaDestroy(&pixat);
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
}
index = 0;
for (i = 0; i < nh; i++) {
for (j = 0; j < nw && index < n; j++, index++) {
pixt = pixaGetPix(pixat, index, L_CLONE);
pixGetDimensions(pixt, &wt, &ht, NULL);
if (wt > xspace || ht > yspace) {
fprintf(stderr, "pix(%d) omitted; size %dx%d\n", index, wt, ht);
pixDestroy(&pixt);
continue;
}
pixRasterop(pixd, j * xspace, i * yspace, wt, ht,
PIX_PAINT, pixt, 0, 0);
pixDestroy(&pixt);
}
}
pixaDestroy(&pixat);
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;
}
int main(int argc,
char **argv)
{
char buf[32];
char *filein, *fileout, *fontdir, *textstr;
l_int32 n, i, maxdepth, ntext, border, lossless, display;
l_float32 scalefact;
L_BMF *bmf;
PIX *pix1, *pix2, *pix3, *pix4, *pixd;
PIXA *pixa, *pixat;
static char mainName[] = "displaypixa";
if (argc != 3 && argc != 4 && argc != 7 && argc != 8) {
fprintf(stderr, "Syntax error in displaypixa:\n"
" displaypixa filein fileout [fontdir]\n"
" displaypixa filein scalefact border"
" lossless disp fileout [fontdir]\n");
return 1;
}
filein = argv[1];
if ((pixa = pixaRead(filein)) == NULL)
return ERROR_INT("pixa not made", mainName, 1);
pixaCountText(pixa, &ntext);
/* Simple specification; no output text */
if (argc == 3 || (argc == 4 && ntext == 0)) { /* no text output */
fileout = argv[2];
pixaVerifyDepth(pixa, &maxdepth);
pixd = pixaDisplayTiledInRows(pixa, maxdepth, 1400, 1.0, 0, 10, 0);
pixDisplay(pixd, 100, 100);
if (pixGetDepth(pixd) == 1)
pixWrite(fileout, pixd, IFF_PNG);
else
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
return 0;
}
/* Simple specification with output text */
if (argc == 4) { /* ntext > 0 */
fileout = argv[2];
fontdir = argv[3];
n = pixaGetCount(pixa);
if ((bmf = bmfCreate(fontdir, 6)) == NULL) {
L_ERROR("couldn't read fontdir\n", mainName);
pixat = pixaCopy(pixa, L_CLONE);
} else {
pixat = pixaCreate(n);
for (i = 0; i < n; i++) {
pix1 = pixaGetPix(pixa, i, L_CLONE);
pix2 = pixConvertTo32(pix1);
pix3 = pixAddBorderGeneral(pix2, 10, 10, 5, 5, 0xffffff00);
textstr = pixGetText(pix1);
if (textstr && strlen(textstr) > 0) {
snprintf(buf, sizeof(buf), "%s", textstr);
pix4 = pixAddSingleTextblock(pix3, bmf, buf, 0xff000000,
L_ADD_BELOW, NULL);
} else {
pix4 = pixClone(pix3);
}
pixaAddPix(pixat, pix4, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
bmfDestroy(&bmf);
}
pixaVerifyDepth(pixat, &maxdepth);
pixd = pixaDisplayTiledInRows(pixat, maxdepth, 1400, 1.0, 0, 10, 0);
pixDisplay(pixd, 100, 100);
if (pixGetDepth(pixd) == 1)
pixWrite(fileout, pixd, IFF_PNG);
else
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixaDestroy(&pixat);
return 0;
}
/* Full specification */
scalefact = atof(argv[2]);
border = atoi(argv[3]);
lossless = atoi(argv[4]);
display = atoi(argv[5]);
fileout = argv[6];
fontdir = (argc == 8) ? argv[7] : NULL;
if (fontdir && ntext == 0)
L_WARNING("No text found in any of the pix\n", mainName);
if (fontdir && ntext > 0) {
if ((bmf = bmfCreate(fontdir, 6)) == NULL) {
L_ERROR("couldn't read fontdir\n", mainName);
pixat = pixaCopy(pixa, L_CLONE);
} else {
n = pixaGetCount(pixa);
pixat = pixaCreate(n);
for (i = 0; i < n; i++) {
pix1 = pixaGetPix(pixa, i, L_CLONE);
pix2 = pixConvertTo32(pix1);
pix3 = pixAddBorderGeneral(pix2, 10, 10, 5, 5, 0xffffff00);
textstr = pixGetText(pix1);
if (textstr && strlen(textstr) > 0) {
snprintf(buf, sizeof(buf), "%s", textstr);
pix4 = pixAddSingleTextblock(pix3, bmf, buf, 0xff000000,
L_ADD_BELOW, NULL);
} else {
pix4 = pixClone(pix3);
}
pixaAddPix(pixat, pix4, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
bmfDestroy(&bmf);
}
} else {
pixat = pixaCopy(pixa, L_CLONE);
}
pixaVerifyDepth(pixat, &maxdepth);
pixd = pixaDisplayTiledInRows(pixat, maxdepth, 1400, scalefact,
0, 10, border);
if (display) pixDisplay(pixd, 20, 20);
if (pixGetDepth(pixd) == 1 || lossless)
pixWrite(fileout, pixd, IFF_PNG);
else
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixaDestroy(&pixat);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 i, n;
l_float32 pi, angle, val;
BOX *box;
BOXA *boxa, *boxa1, *boxa2;
NUMA *na1, *na2;
PIX *pix, *pix1, *pix2;
PIXA *pixa1, *pixa2, *pixa3, *pixa4;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_rmfile("/tmp/regout/insert3.ba");
lept_rmfile("/tmp/regout/insert4.ba");
lept_rmfile("/tmp/regout/insert6.pa");
lept_rmfile("/tmp/regout/insert7.pa");
lept_rmfile("/tmp/regout/insert9.pa");
lept_rmfile("/tmp/regout/insert10.pa");
/* ----------------- Test numa operations -------------------- */
pi = 3.1415926535;
na1 = numaCreate(500);
for (i = 0; i < 500; i++) {
angle = 0.02293 * i * pi;
val = (l_float32)sin(angle);
numaAddNumber(na1, val);
}
numaWrite("/tmp/regout/insert0.na", na1);
na2 = numaCopy(na1);
n = numaGetCount(na2);
for (i = 0; i < n; i++) {
numaGetFValue(na2, i, &val);
numaRemoveNumber(na2, i);
numaInsertNumber(na2, i, val);
}
numaWrite("/tmp/regout/insert1.na", na2);
regTestCheckFile(rp, "/tmp/regout/insert0.na"); /* 0 */
regTestCheckFile(rp, "/tmp/regout/insert1.na"); /* 1 */
regTestCompareFiles(rp, 0, 1); /* 2 */
numaDestroy(&na1);
numaDestroy(&na2);
/* ----------------- Test boxa operations -------------------- */
pix1 = pixRead("feyn.tif");
box = boxCreate(1138, 1666, 1070, 380);
pix2 = pixClipRectangle(pix1, box, NULL);
boxDestroy(&box);
boxa1 = pixConnComp(pix2, NULL, 8);
boxaWrite("/tmp/regout/insert3.ba", boxa1);
boxa2 = boxaCopy(boxa1, L_COPY);
n = boxaGetCount(boxa2);
for (i = 0; i < n; i++) {
boxaRemoveBoxAndSave(boxa2, i, &box);
boxaInsertBox(boxa2, i, box);
}
boxaWrite("/tmp/regout/insert4.ba", boxa2);
regTestCheckFile(rp, "/tmp/regout/insert3.ba"); /* 3 */
regTestCheckFile(rp, "/tmp/regout/insert4.ba"); /* 4 */
regTestCompareFiles(rp, 3, 4); /* 5 */
pixDestroy(&pix1);
pixDestroy(&pix2);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* ----------------- Test pixa operations -------------------- */
pix1 = pixRead("feyn.tif");
box = boxCreate(1138, 1666, 1070, 380);
pix2 = pixClipRectangle(pix1, box, NULL);
boxDestroy(&box);
boxa = pixConnComp(pix2, &pixa1, 8);
boxaDestroy(&boxa);
pixaWrite("/tmp/regout/insert6.pa", pixa1);
regTestCheckFile(rp, "/tmp/regout/insert6.pa"); /* 6 */
pixDestroy(&pix1);
pixDestroy(&pix2);
/* Remove and insert each one */
pixa2 = pixaCopy(pixa1, L_COPY);
n = pixaGetCount(pixa2);
for (i = 0; i < n; i++) {
pixaRemovePixAndSave(pixa2, i, &pix, &box);
pixaInsertPix(pixa2, i, pix, box);
}
pixaWrite("/tmp/regout/insert7.pa", pixa2);
regTestCheckFile(rp, "/tmp/regout/insert7.pa"); /* 7 */
regTestCompareFiles(rp, 6, 7); /* 8 */
/* Move the last to the beginning; do it n times */
pixa3 = pixaCopy(pixa2, L_COPY);
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa3, n - 1, L_CLONE);
box = pixaGetBox(pixa3, n - 1, L_CLONE);
pixaInsertPix(pixa3, 0, pix, box);
pixaRemovePix(pixa3, n);
}
pixaWrite("/tmp/regout/insert9.pa", pixa3);
regTestCheckFile(rp, "/tmp/regout/insert9.pa"); /* 9 */
/* Move the first one to the end; do it n times */
pixa4 = pixaCopy(pixa3, L_COPY);
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa4, 0, L_CLONE);
box = pixaGetBox(pixa4, 0, L_CLONE);
pixaInsertPix(pixa4, n, pix, box); /* make sure insert works at end */
pixaRemovePix(pixa4, 0);
}
pixaWrite("/tmp/regout/insert10.pa", pixa4);
regTestCheckFile(rp, "/tmp/regout/insert10.pa"); /* 10 */
regTestCompareFiles(rp, 9, 10); /* 11 */
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
pixaDestroy(&pixa4);
return regTestCleanup(rp);
}
main(int argc,
char **argv)
{
l_int32 i, n;
l_float32 pi, angle, val;
BOX *box;
BOXA *boxa, *boxa1, *boxa2;
NUMA *na1, *na2;
PIX *pix, *pix1, *pix2, *pix3, *pixd;
PIXA *pixa1, *pixa2, *pixa3, *pixa4;
static char mainName[] = "inserttest";
#if 1
pi = 3.1415926535;
na1 = numaCreate(500);
for (i = 0; i < 500; i++) {
angle = 0.02293 * i * pi;
val = (l_float32)sin(angle);
numaAddNumber(na1, val);
}
numaWrite("/tmp/junknuma1", na1);
na2 = numaCopy(na1);
n = numaGetCount(na2);
for (i = 0; i < n; i++) {
numaGetFValue(na2, i, &val);
numaRemoveNumber(na2, i);
numaInsertNumber(na2, i, val);
}
numaWrite("/tmp/junknuma2", na2);
numaDestroy(&na1);
numaDestroy(&na2);
#endif
#if 1
pix1 = pixRead("feyn.tif");
box = boxCreate(1138, 1666, 1070, 380);
pix2 = pixClipRectangle(pix1, box, NULL);
boxDestroy(&box);
boxa1 = pixConnComp(pix2, NULL, 8);
boxaWrite("/tmp/junkboxa1", boxa1);
boxa2 = boxaCopy(boxa1, L_COPY);
n = boxaGetCount(boxa2);
for (i = 0; i < n; i++) {
box = boxaGetBox(boxa2, i, L_COPY);
boxaRemoveBox(boxa2, i);
boxaInsertBox(boxa2, i, box);
}
boxaWrite("/tmp/junkboxa2", boxa2);
pixDestroy(&pix1);
pixDestroy(&pix2);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
#endif
#if 1
pix1 = pixRead("feyn.tif");
box = boxCreate(1138, 1666, 1070, 380);
pix2 = pixClipRectangle(pix1, box, NULL);
boxDestroy(&box);
boxa = pixConnComp(pix2, &pixa1, 8);
boxaDestroy(&boxa);
pixaWrite("/tmp/junkpixa1", pixa1);
pixa2 = pixaCopy(pixa1, L_COPY);
n = pixaGetCount(pixa2);
/* Remove and insert each one */
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa2, i, L_COPY);
box = pixaGetBox(pixa2, i, L_COPY);
pixaRemovePix(pixa2, i);
pixaInsertPix(pixa2, i, pix, box);
}
pixaWrite("/tmp/junkpixa2", pixa2);
/* Move the last to the beginning; do it n times */
pixa3 = pixaCopy(pixa2, L_COPY);
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa3, n - 1, L_CLONE);
box = pixaGetBox(pixa3, n - 1, L_CLONE);
pixaInsertPix(pixa3, 0, pix, box);
pixaRemovePix(pixa3, n);
}
pixaWrite("/tmp/junkpixa3", pixa3);
/* Move the first one to the end; do it n times */
pixa4 = pixaCopy(pixa3, L_COPY);
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa4, 0, L_CLONE);
box = pixaGetBox(pixa4, 0, L_CLONE);
pixaInsertPix(pixa4, n, pix, box); /* make sure insert works at end */
pixaRemovePix(pixa4, 0);
}
pixaWrite("/tmp/junkpixa4", pixa4);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
pixaDestroy(&pixa4);
#endif
return 0;
}
