void
CopyStoreClean(PIXA *pixas,
l_int32 nlevels,
l_int32 ncopies)
{
l_int32 i, j;
PIX *pix, *pixt;
PIXA *pixa;
PIXAA *paa;
paa = pixaaCreate(0);
for (i = 0; i < nlevels ; i++) {
pixa = pixaCreate(0);
pixaaAddPixa(paa, pixa, L_INSERT);
pix = pixaGetPix(pixas, i, L_CLONE);
for (j = 0; j < ncopies; j++) {
pixt = pixCopy(NULL, pix);
pixaAddPix(pixa, pixt, L_INSERT);
}
pixDestroy(&pix);
}
pixaaDestroy(&paa);
return;
}
/*!
* recogaWritePixaa()
*
* Input: filename
* recoga
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) For each recognizer, this generates a pixa of all the
* unscaled images. They are combined into a pixaa for
* the set of recognizers. Each pix has has its character
* string in the pix text field.
* (2) As a side-effect, the character class label is written
* into each pix in recog.
*/
l_int32
recogaWritePixaa(const char *filename,
L_RECOGA *recoga)
{
l_int32 i;
PIXA *pixa;
PIXAA *paa;
L_RECOG *recog;
PROCNAME("recogaWritePixaa");
if (!filename)
return ERROR_INT("filename not defined", procName, 1);
if (!recoga)
return ERROR_INT("recoga not defined", procName, 1);
paa = pixaaCreate(recoga->n);
for (i = 0; i < recoga->n; i++) {
recog = recogaGetRecog(recoga, i);
recogAddCharstrLabels(recog);
pixa = pixaaFlattenToPixa(recog->pixaa_u, NULL, L_CLONE);
pixaaAddPixa(paa, pixa, L_INSERT);
}
pixaaWrite(filename, paa);
pixaaDestroy(&paa);
return 0;
}
/*!
* recogCreate()
*
* Input: scalew (scale all widths to this; use 0 for no scaling)
* scaleh (scale all heights to this; use 0 for no scaling)
* templ_type (L_USE_AVERAGE or L_USE_ALL)
* threshold (for binarization; typically ~128)
* maxyshift (from nominal centroid alignment; typically 0 or 1)
* Return: recog, or null on error
*
* Notes:
* (1) For a set trained on one font, such as numbers in a book,
* it is sensible to set scalew = scaleh = 0.
* (2) For a mixed training set, scaling to a fixed height,
* such as 32 pixels, but leaving the width unscaled, is effective.
* (3) The storage for most of the arrays is allocated when training
* is finished.
*/
L_RECOG *
recogCreate(l_int32 scalew,
l_int32 scaleh,
l_int32 templ_type,
l_int32 threshold,
l_int32 maxyshift)
{
L_RECOG *recog;
PIXA *pixa;
PIXAA *paa;
PROCNAME("recogCreate");
if (scalew < 0 || scaleh < 0)
return (L_RECOG *)ERROR_PTR("invalid scalew or scaleh", procName, NULL);
if (templ_type != L_USE_AVERAGE && templ_type != L_USE_ALL)
return (L_RECOG *)ERROR_PTR("invalid templ_type flag", procName, NULL);
if (threshold < 1 || threshold > 255)
return (L_RECOG *)ERROR_PTR("invalid threshold", procName, NULL);
if ((recog = (L_RECOG *)CALLOC(1, sizeof(L_RECOG))) == NULL)
return (L_RECOG *)ERROR_PTR("rec not made", procName, NULL);
recog->templ_type = templ_type;
recog->threshold = threshold;
recog->scalew = scalew;
recog->scaleh = scaleh;
recog->maxyshift = maxyshift;
recog->asperity_fr = DEFAULT_ASPERITY_FRACT;
recogSetPadParams(recog, NULL, NULL, NULL, -1, -1, -1);
recog->bmf = bmfCreate(NULL, 6);
recog->bmf_size = 6;
recog->maxarraysize = MAX_EXAMPLES_IN_CLASS;
recog->index = -1;
/* Generate the LUTs */
recog->centtab = makePixelCentroidTab8();
recog->sumtab = makePixelSumTab8();
recog->sa_text = sarrayCreate(0);
recog->dna_tochar = l_dnaCreate(0);
/* Input default values for min component size for splitting.
* These are overwritten when pixTrainingFinished() is called. */
recog->min_splitw = 6;
recog->min_splith = 6;
recog->max_splith = 60;
/* Generate the storage for the unscaled training bitmaps */
paa = pixaaCreate(recog->maxarraysize);
pixa = pixaCreate(1);
pixaaInitFull(paa, pixa);
pixaDestroy(&pixa);
recog->pixaa_u = paa;
/* Generate the storage for debugging */
recog->pixadb_boot = pixaCreate(2);
recog->pixadb_split = pixaCreate(2);
return recog;
}
/*!
* pixaaCreateFromPixa()
*
* Input: pixa
* n (number specifying subdivision of pixa)
* type (L_CHOOSE_CONSECUTIVE, L_CHOOSE_SKIP_BY)
* copyflag (L_CLONE, L_COPY)
* Return: pixaa, or null on error
*
* Notes:
* (1) This subdivides a pixa into a set of smaller pixa that
* are accumulated into a pixaa.
* (2) If type == L_CHOOSE_CONSECUTIVE, the first 'n' pix are
* put in a pixa and added to pixaa, then the next 'n', etc.
* If type == L_CHOOSE_SKIP_BY, the first pixa is made by
* aggregating pix[0], pix[n], pix[2*n], etc.
* (3) The copyflag specifies if each new pix is a copy or a clone.
*/
PIXAA *
pixaaCreateFromPixa(PIXA *pixa,
l_int32 n,
l_int32 type,
l_int32 copyflag)
{
l_int32 count, i, j, npixa;
PIX *pix;
PIXA *pixat;
PIXAA *pixaa;
PROCNAME("pixaaCreateFromPixa");
if (!pixa)
return (PIXAA *)ERROR_PTR("pixa not defined", procName, NULL);
count = pixaGetCount(pixa);
if (count == 0)
return (PIXAA *)ERROR_PTR("no pix in pixa", procName, NULL);
if (n <= 0)
return (PIXAA *)ERROR_PTR("n must be > 0", procName, NULL);
if (type != L_CHOOSE_CONSECUTIVE && type != L_CHOOSE_SKIP_BY)
return (PIXAA *)ERROR_PTR("invalid type", procName, NULL);
if (copyflag != L_CLONE && copyflag != L_COPY)
return (PIXAA *)ERROR_PTR("invalid copyflag", procName, NULL);
if (type == L_CHOOSE_CONSECUTIVE)
npixa = (count + n - 1) / n;
else /* L_CHOOSE_SKIP_BY */
npixa = L_MIN(n, count);
pixaa = pixaaCreate(npixa);
if (type == L_CHOOSE_CONSECUTIVE) {
for (i = 0; i < count; i++) {
if (i % n == 0)
pixat = pixaCreate(n);
pix = pixaGetPix(pixa, i, copyflag);
pixaAddPix(pixat, pix, L_INSERT);
if (i % n == n - 1)
pixaaAddPixa(pixaa, pixat, L_INSERT);
}
if (i % n != 0)
pixaaAddPixa(pixaa, pixat, L_INSERT);
}
else { /* L_CHOOSE_SKIP_BY */
for (i = 0; i < npixa; i++) {
pixat = pixaCreate(count / npixa + 1);
for (j = i; j < count; j += n) {
pix = pixaGetPix(pixa, j, copyflag);
pixaAddPix(pixat, pix, L_INSERT);
}
pixaaAddPixa(pixaa, pixat, L_INSERT);
}
}
return pixaa;
}
/*!
* pixaSort2dByIndex()
*
* Input: pixas
* naa (numaa that maps from the new pixaa to the input pixas)
* copyflag (L_CLONE or L_COPY)
* Return: pixaa (sorted), or null on error
*/
PIXAA *
pixaSort2dByIndex(PIXA *pixas,
NUMAA *naa,
l_int32 copyflag)
{
l_int32 pixtot, ntot, i, j, n, nn, index;
BOX *box;
NUMA *na;
PIX *pix;
PIXA *pixa;
PIXAA *pixaa;
PROCNAME("pixaSort2dByIndex");
if (!pixas)
return (PIXAA *)ERROR_PTR("pixas not defined", procName, NULL);
if (!naa)
return (PIXAA *)ERROR_PTR("naindex not defined", procName, NULL);
/* Check counts */
ntot = numaaGetNumberCount(naa);
pixtot = pixaGetCount(pixas);
if (ntot != pixtot)
return (PIXAA *)ERROR_PTR("element count mismatch", procName, NULL);
n = numaaGetCount(naa);
pixaa = pixaaCreate(n);
for (i = 0; i < n; i++) {
na = numaaGetNuma(naa, i, L_CLONE);
nn = numaGetCount(na);
pixa = pixaCreate(nn);
for (j = 0; j < nn; j++) {
numaGetIValue(na, j, &index);
pix = pixaGetPix(pixas, index, copyflag);
box = pixaGetBox(pixas, index, copyflag);
pixaAddPix(pixa, pix, L_INSERT);
pixaAddBox(pixa, box, L_INSERT);
}
pixaaAddPixa(pixaa, pixa, L_INSERT);
numaDestroy(&na);
}
return pixaa;
}
/*!
* pixaaReadStream()
*
* Input: stream
* Return: pixaa, or null on error
*/
PIXAA *
pixaaReadStream(FILE *fp)
{
l_int32 n, i, version;
l_int32 ignore;
BOXA *boxa;
PIXA *pixa;
PIXAA *pixaa;
PROCNAME("pixaaReadStream");
if (!fp)
return (PIXAA *)ERROR_PTR("stream not defined", procName, NULL);
if (fscanf(fp, "\nPixaa Version %d\n", &version) != 1)
return (PIXAA *)ERROR_PTR("not a pixaa file", procName, NULL);
if (version != PIXAA_VERSION_NUMBER)
return (PIXAA *)ERROR_PTR("invalid pixaa version", procName, NULL);
if (fscanf(fp, "Number of pixa = %d\n", &n) != 1)
return (PIXAA *)ERROR_PTR("not a pixaa file", procName, NULL);
if ((pixaa = pixaaCreate(n)) == NULL)
return (PIXAA *)ERROR_PTR("pixaa not made", procName, NULL);
if ((boxa = boxaReadStream(fp)) == NULL)
return (PIXAA *)ERROR_PTR("boxa not made", procName, NULL);
boxaDestroy(&pixaa->boxa);
pixaa->boxa = boxa;
for (i = 0; i < n; i++) {
if ((fscanf(fp, "\n\n --------------- pixa[%d] ---------------\n",
&ignore)) != 1) {
return (PIXAA *)ERROR_PTR("text reading", procName, NULL);
}
if ((pixa = pixaReadStream(fp)) == NULL)
return (PIXAA *)ERROR_PTR("pixa not read", procName, NULL);
pixaaAddPixa(pixaa, pixa, L_INSERT);
}
return pixaa;
}
/*!
* \brief recogCreate()
*
* \param[in] scalew scale all widths to this; use 0 otherwise
* \param[in] scaleh scale all heights to this; use 0 otherwise
* \param[in] linew width of normalized strokes; use 0 to skip
* \param[in] threshold for binarization; typically ~128; 0 for default
* \param[in] maxyshift from nominal centroid alignment; default is 1
* \return recog, or NULL on error
*
* <pre>
* Notes:
* (1) If %scalew == 0 and %scaleh == 0, no scaling is done.
* If one of these is 0 and the other is > 0, scaling is isotropic
* to the requested size. We typically do not set both > 0.
* (2) Use linew > 0 to convert the templates to images with fixed
* width strokes. linew == 0 skips the conversion.
* (3) The only valid values for %maxyshift are 0, 1 and 2.
* It is recommended to use %maxyshift == 1 (default value).
* Using %maxyshift == 0 is much faster than %maxyshift == 1, but
* it is much less likely to find the template with the best
* correlation. Use of anything but 1 results in a warning.
* (4) Scaling is used for finding outliers and for training a
* book-adapted recognizer (BAR) from a bootstrap recognizer (BSR).
* Scaling the height to a fixed value and scaling the width
* accordingly (e.g., %scaleh = 40, %scalew = 0) is recommended.
* (5) The storage for most of the arrays is allocated when training
* is finished.
* </pre>
*/
L_RECOG *
recogCreate(l_int32 scalew,
l_int32 scaleh,
l_int32 linew,
l_int32 threshold,
l_int32 maxyshift)
{
L_RECOG *recog;
PROCNAME("recogCreate");
if (scalew < 0 || scaleh < 0)
return (L_RECOG *)ERROR_PTR("invalid scalew or scaleh", procName, NULL);
if (linew > 10)
return (L_RECOG *)ERROR_PTR("invalid linew > 10", procName, NULL);
if (threshold == 0) threshold = DEFAULT_THRESHOLD;
if (threshold < 0 || threshold > 255) {
L_WARNING("invalid threshold; using default\n", procName);
threshold = DEFAULT_THRESHOLD;
}
if (maxyshift < 0 || maxyshift > 2) {
L_WARNING("invalid maxyshift; using default value\n", procName);
maxyshift = DEFAULT_MAXYSHIFT;
} else if (maxyshift == 0) {
L_WARNING("Using maxyshift = 0; faster, worse correlation results\n",
procName);
} else if (maxyshift == 2) {
L_WARNING("Using maxyshift = 2; slower\n", procName);
}
if ((recog = (L_RECOG *)LEPT_CALLOC(1, sizeof(L_RECOG))) == NULL)
return (L_RECOG *)ERROR_PTR("rec not made", procName, NULL);
recog->templ_use = L_USE_ALL_TEMPLATES; /* default */
recog->threshold = threshold;
recog->scalew = scalew;
recog->scaleh = scaleh;
recog->linew = linew;
recog->maxyshift = maxyshift;
recogSetParams(recog, 1, -1, -1.0, -1.0);
recog->bmf = bmfCreate(NULL, 6);
recog->bmf_size = 6;
recog->maxarraysize = MAX_EXAMPLES_IN_CLASS;
/* Generate the LUTs */
recog->centtab = makePixelCentroidTab8();
recog->sumtab = makePixelSumTab8();
recog->sa_text = sarrayCreate(0);
recog->dna_tochar = l_dnaCreate(0);
/* Input default values for min component size for splitting.
* These are overwritten when pixTrainingFinished() is called. */
recog->min_splitw = 6;
recog->max_splith = 60;
/* Allocate the paa for the unscaled training bitmaps */
recog->pixaa_u = pixaaCreate(recog->maxarraysize);
/* Generate the storage for debugging */
recog->pixadb_boot = pixaCreate(2);
recog->pixadb_split = pixaCreate(2);
return recog;
}
int main(int argc,
char **argv)
{
l_int32 w, h, d, w2, h2, i, ncols, ret;
l_float32 angle, conf;
BOX *box;
BOXA *boxa, *boxa2;
PIX *pix, *pixs, *pixb, *pixb2, *pixd;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIXA *pixam; /* mask with a single component over each column */
PIXA *pixac, *pixad, *pixat;
PIXAA *pixaa, *pixaa2;
SEL *selsplit;
static char mainName[] = "arabic_lines";
if (argc != 1)
return ERROR_INT(" Syntax: arabic_lines", mainName, 1);
pixDisplayWrite(NULL, -1); /* init debug output */
/* Binarize input */
pixs = pixRead("arabic.png");
pixGetDimensions(pixs, &w, &h, &d);
pix = pixConvertTo1(pixs, 128);
/* Deskew */
pixb = pixFindSkewAndDeskew(pix, 1, &angle, &conf);
pixDestroy(&pix);
fprintf(stderr, "Skew angle: %7.2f degrees; %6.2f conf\n", angle, conf);
pixDisplayWrite(pixb, 1);
/* Use full image morphology to find columns, at 2x reduction.
This only works for very simple layouts where each column
of text extends the full height of the input image. */
pixb2 = pixReduceRankBinary2(pixb, 2, NULL);
pix1 = pixMorphCompSequence(pixb2, "c5.500", 0);
boxa = pixConnComp(pix1, &pixam, 8);
ncols = boxaGetCount(boxa);
fprintf(stderr, "Num columns: %d\n", ncols);
pixDisplayWrite(pix1, 1);
/* Use selective region-based morphology to get the textline mask. */
pixad = pixaMorphSequenceByRegion(pixb2, pixam, "c100.3", 0, 0);
pixGetDimensions(pixb2, &w2, &h2, NULL);
pix2 = pixaDisplay(pixad, w2, h2);
pixDisplayWrite(pix2, 1);
pixDestroy(&pix2);
/* Some of the lines may be touching, so use a HMT to split the
lines in each column, and use a pixaa to save the results. */
selsplit = selCreateFromString(seltext, 17, 7, "selsplit");
pixaa = pixaaCreate(ncols);
for (i = 0; i < ncols; i++) {
pix3 = pixaGetPix(pixad, i, L_CLONE);
box = pixaGetBox(pixad, i, L_COPY);
pix4 = pixHMT(NULL, pix3, selsplit);
pixXor(pix4, pix4, pix3);
boxa2 = pixConnComp(pix4, &pixac, 8);
pixaaAddPixa(pixaa, pixac, L_INSERT);
pixaaAddBox(pixaa, box, L_INSERT);
pix5 = pixaDisplayRandomCmap(pixac, 0, 0);
pixDisplayWrite(pix5, 1);
fprintf(stderr, "Num textlines in col %d: %d\n", i,
boxaGetCount(boxa2));
pixDestroy(&pix5);
pixDestroy(&pix3);
pixDestroy(&pix4);
boxaDestroy(&boxa2);
}
/* Visual output */
ret = system("gthumb /tmp/display/file* &");
pixat = pixaReadFiles("/tmp/display", "file");
pix5 = selDisplayInPix(selsplit, 31, 2);
pixaAddPix(pixat, pix5, L_INSERT);
pix6 = pixaDisplayTiledAndScaled(pixat, 32, 400, 3, 0, 35, 3);
pixWrite("/tmp/result.png", pix6, IFF_PNG);
pixaDestroy(&pixat);
pixDestroy(&pix6);
/* Test pixaa I/O */
pixaaWrite("/tmp/pixaa", pixaa);
pixaa2 = pixaaRead("/tmp/pixaa");
pixaaWrite("/tmp/pixaa2", pixaa2);
/* Test pixaa display */
pixd = pixaaDisplay(pixaa, w2, h2);
pixWrite("/tmp/textlines.png", pixd, IFF_PNG);
pixDestroy(&pixd);
/* Cleanup */
pixDestroy(&pixb2);
pixDestroy(&pix1);
pixaDestroy(&pixam);
pixaDestroy(&pixad);
pixaaDestroy(&pixaa);
pixaaDestroy(&pixaa2);
boxaDestroy(&boxa);
selDestroy(&selsplit);
pixDestroy(&pixs);
pixDestroy(&pixb);
return 0;
}
main(int argc,
char **argv)
{
char *filein, *fileout;
l_int32 w, h, d, w2, h2, i, ncols;
l_float32 angle, conf;
BOX *box;
BOXA *boxa, *boxas, *boxad, *boxa2;
NUMA *numa;
PIX *pixs, *pixt, *pixb, *pixb2, *pixd;
PIX *pixtlm, *pixvws;
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6;
PIXA *pixam, *pixac, *pixad, *pixat;
PIXAA *pixaa, *pixaa2;
PTA *pta;
SEL *selsplit;
static char mainName[] = "textlinemask";
if (argc != 3)
exit(ERROR_INT(" Syntax: textlinemask filein fileout", mainName, 1));
filein = argv[1];
fileout = argv[2];
pixDisplayWrite(NULL, -1); /* init debug output */
if ((pixs = pixRead(filein)) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
pixGetDimensions(pixs, &w, &h, &d);
/* Binarize input */
if (d == 8)
pixt = pixThresholdToBinary(pixs, 128);
else if (d == 1)
pixt = pixClone(pixs);
else {
fprintf(stderr, "depth is %d\n", d);
exit(1);
}
/* Deskew */
pixb = pixFindSkewAndDeskew(pixt, 1, &angle, &conf);
pixDestroy(&pixt);
fprintf(stderr, "Skew angle: %7.2f degrees; %6.2f conf\n", angle, conf);
pixDisplayWrite(pixb, DEBUG_OUTPUT);
#if 1
/* Use full image morphology to find columns, at 2x reduction.
* This only works for very simple layouts where each column
* of text extends the full height of the input image.
* pixam has a pix component over each column. */
pixb2 = pixReduceRankBinary2(pixb, 2, NULL);
pixt1 = pixMorphCompSequence(pixb2, "c5.500", 0);
boxa = pixConnComp(pixt1, &pixam, 8);
ncols = boxaGetCount(boxa);
fprintf(stderr, "Num columns: %d\n", ncols);
pixDisplayWrite(pixt1, DEBUG_OUTPUT);
/* Use selective region-based morphology to get the textline mask. */
pixad = pixaMorphSequenceByRegion(pixb2, pixam, "c100.3", 0, 0);
pixGetDimensions(pixb2, &w2, &h2, NULL);
if (DEBUG_OUTPUT) {
pixt2 = pixaDisplay(pixad, w2, h2);
pixDisplayWrite(pixt2, DEBUG_OUTPUT);
pixDestroy(&pixt2);
}
/* Some of the lines may be touching, so use a HMT to split the
* lines in each column, and use a pixaa to save the results. */
selsplit = selCreateFromString(seltext, 17, 7, "selsplit");
pixaa = pixaaCreate(ncols);
for (i = 0; i < ncols; i++) {
pixt3 = pixaGetPix(pixad, i, L_CLONE);
box = pixaGetBox(pixad, i, L_COPY);
pixt4 = pixHMT(NULL, pixt3, selsplit);
pixXor(pixt4, pixt4, pixt3);
boxa2 = pixConnComp(pixt4, &pixac, 8);
pixaaAddPixa(pixaa, pixac, L_INSERT);
pixaaAddBox(pixaa, box, L_INSERT);
if (DEBUG_OUTPUT) {
pixt5 = pixaDisplayRandomCmap(pixac, 0, 0);
pixDisplayWrite(pixt5, DEBUG_OUTPUT);
fprintf(stderr, "Num textlines in col %d: %d\n", i,
boxaGetCount(boxa2));
pixDestroy(&pixt5);
}
pixDestroy(&pixt3);
pixDestroy(&pixt4);
boxaDestroy(&boxa2);
}
/* Visual output */
if (DEBUG_OUTPUT) {
pixDisplayMultiple("/tmp/junk_write_display*");
pixat = pixaReadFiles("/tmp", "junk_write_display");
pixt5 = selDisplayInPix(selsplit, 31, 2);
pixaAddPix(pixat, pixt5, L_INSERT);
pixt6 = pixaDisplayTiledAndScaled(pixat, 32, 400, 3, 0, 35, 3);
pixWrite(fileout, pixt6, IFF_PNG);
pixaDestroy(&pixat);
pixDestroy(&pixt6);
}
/* Test pixaa I/O */
pixaaWrite("/tmp/junkpixaa", pixaa);
pixaa2 = pixaaRead("/tmp/junkpixaa");
pixaaWrite("/tmp/junkpixaa2", pixaa2);
/* Test pixaa display */
pixd = pixaaDisplay(pixaa, w2, h2);
pixWrite("/tmp/junkdisplay", pixd, IFF_PNG);
pixDestroy(&pixd);
/* Cleanup */
pixDestroy(&pixb2);
pixDestroy(&pixt1);
pixaDestroy(&pixam);
pixaDestroy(&pixad);
pixaaDestroy(&pixaa);
pixaaDestroy(&pixaa2);
boxaDestroy(&boxa);
selDestroy(&selsplit);
#endif
#if 0
/* Use the baseline finder; not really what is needed */
numa = pixFindBaselines(pixb, &pta, 1);
#endif
#if 0
/* Use the textline mask function; parameters are not quite right */
pixb2 = pixReduceRankBinary2(pixb, 2, NULL);
pixtlm = pixGenTextlineMask(pixb2, &pixvws, NULL, 1);
pixDisplay(pixtlm, 0, 100);
pixDisplay(pixvws, 500, 100);
pixDestroy(&pixb2);
pixDestroy(&pixtlm);
pixDestroy(&pixvws);
#endif
#if 0
/* Use the Breuel whitespace partition method; slow and we would
* still need to work to extract the fg regions. */
pixb2 = pixReduceRankBinary2(pixb, 2, NULL);
boxas = pixConnComp(pixb2, NULL, 8);
boxad = boxaGetWhiteblocks(boxas, NULL, L_SORT_BY_HEIGHT,
3, 0.1, 200, 0.2, 0);
pixd = pixDrawBoxa(pixb2, boxad, 7, 0xe0708000);
pixDisplay(pixd, 100, 500);
pixDestroy(&pixb2);
pixDestroy(&pixd);
boxaDestroy(&boxas);
boxaDestroy(&boxad);
#endif
#if 0
/* Use morphology to find columns and then selective
* region-based morphology to get the textline mask.
* This is for display; we really want to get a pixa of the
* specific textline masks. */
startTimer();
pixb2 = pixReduceRankBinary2(pixb, 2, NULL);
pixt1 = pixMorphCompSequence(pixb2, "c5.500", 0); /* column mask */
pixt2 = pixMorphSequenceByRegion(pixb2, pixt1, "c100.3", 8, 0, 0, &boxa);
fprintf(stderr, "time = %7.3f sec\n", stopTimer());
pixDisplay(pixt1, 100, 500);
pixDisplay(pixt2, 800, 500);
pixDestroy(&pixb2);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
boxaDestroy(&boxa);
#endif
pixDestroy(&pixs);
pixDestroy(&pixb);
exit(0);
}
// Performs line segmentation
bool CubeLineSegmenter::LineSegment() {
// Use full image morphology to find columns
// This only works for simple layouts where each column
// of text extends the full height of the input image.
Pix *pix_temp1 = pixMorphCompSequence(img_, "c5.500", 0);
if (pix_temp1 == NULL) {
return false;
}
// Mask with a single component over each column
Pixa *pixam;
Boxa *boxa = pixConnComp(pix_temp1, &pixam, 8);
if (boxa == NULL) {
return false;
}
int init_morph_min_hgt = kLineSepMorphMinHgt;
char sequence_str[16];
sprintf(sequence_str, "c100.%d", init_morph_min_hgt);
// Use selective region-based morphology to get the textline mask.
Pixa *pixad = pixaMorphSequenceByRegion(img_, pixam, sequence_str, 0, 0);
if (pixad == NULL) {
return false;
}
// for all columns
int col_cnt = boxaGetCount(boxa);
// create columns
columns_ = pixaaCreate(col_cnt);
if (columns_ == NULL) {
return false;
}
// index columns based on readind order (RTL)
int *col_order = IndexRTL(pixad);
if (col_order == NULL) {
return false;
}
line_cnt_ = 0;
for (int col_idx = 0; col_idx < col_cnt; col_idx++) {
int col = col_order[col_idx];
// get the pix and box corresponding to the column
Pix *pixt3 = pixaGetPix(pixad, col, L_CLONE);
if (pixt3 == NULL) {
return false;
}
Box *col_box = pixad->boxa->box[col];
Pixa *pixac;
Boxa *boxa2 = pixConnComp(pixt3, &pixac, 8);
if (boxa2 == NULL) {
return false;
}
// offset the boxes by the column box
for (int line = 0; line < pixac->n; line++) {
pixac->boxa->box[line]->x += col_box->x;
pixac->boxa->box[line]->y += col_box->y;
}
// add the lines
if (AddLines(pixac) == true) {
if (pixaaAddBox(columns_, col_box, L_CLONE) != 0) {
return false;
}
}
pixDestroy(&pixt3);
boxaDestroy(&boxa2);
line_cnt_ += columns_->pixa[col_idx]->n;
}
pixaDestroy(&pixam);
pixaDestroy(&pixad);
boxaDestroy(&boxa);
delete []col_order;
pixDestroy(&pix_temp1);
return true;
}