/*!
* pixaGetFont()
*
* Input: dir (directory holding pixa of character set)
* fontsize (4, 6, 8, ... , 20)
* &bl1 (<return> baseline of row 1)
* &bl2 (<return> baseline of row 2)
* &bl3 (<return> baseline of row 3)
* Return: pixa of font bitmaps for 95 characters, or null on error
*
* Notes:
* (1) This reads a pre-computed pixa file with the 95 ascii chars.
*/
PIXA *
pixaGetFont(const char *dir,
l_int32 fontsize,
l_int32 *pbl0,
l_int32 *pbl1,
l_int32 *pbl2)
{
char *pathname;
l_int32 fileno;
PIXA *pixa;
PROCNAME("pixaGetFont");
fileno = (fontsize / 2) - 2;
if (fileno < 0 || fileno > NUM_FONTS)
return (PIXA *)ERROR_PTR("font size invalid", procName, NULL);
if (!pbl0 || !pbl1 || !pbl2)
return (PIXA *)ERROR_PTR("&bl not all defined", procName, NULL);
*pbl0 = baselines[fileno][0];
*pbl1 = baselines[fileno][1];
*pbl2 = baselines[fileno][2];
pathname = genPathname(dir, outputfonts[fileno]);
pixa = pixaRead(pathname);
FREE(pathname);
if (!pixa)
L_WARNING("pixa of char bitmaps not found\n", procName);
return pixa;
}
/*!
* l_autodecode_137()
*
* Input: index into array of functions
* Return: data struct (e.g., pixa) in memory
*/
void *
l_autodecode_137(l_int32 index)
{
l_uint8 *data1, *data2;
l_int32 size1;
size_t size2;
void *result = NULL;
l_int32 nfunc = 2;
PROCNAME("l_autodecode_137");
if (index < 0 || index >= nfunc) {
L_ERROR("invalid index = %d; must be less than %d\n", procName,
index, nfunc);
return NULL;
}
lept_mkdir("lept/auto");
/* Unencode selected string, write to file, and read it */
switch (index) {
case 0:
data1 = decodeBase64(l_strdata_0, strlen(l_strdata_0), &size1);
data2 = zlibUncompress(data1, size1, &size2);
l_binaryWrite("/tmp/lept/auto/data.bin","w", data2, size2);
result = (void *)pixaRead("/tmp/lept/auto/data.bin");
lept_free(data1);
lept_free(data2);
break;
case 1:
data1 = decodeBase64(l_strdata_1, strlen(l_strdata_1), &size1);
data2 = zlibUncompress(data1, size1, &size2);
l_binaryWrite("/tmp/lept/auto/data.bin","w", data2, size2);
result = (void *)pixaRead("/tmp/lept/auto/data.bin");
lept_free(data1);
lept_free(data2);
break;
default:
L_ERROR("invalid index", procName);
}
return result;
}
/*!
* l_bootnum_gen()
*
* Return: the bootnum pixa
*
* Call this way:
* PIXA *pixa = (PIXA *)l_bootnum_gen(); (C)
* Pixa *pixa = (Pixa *)l_bootnum_gen(); (C++)
*/
void *
l_bootnum_gen()
{
l_uint8 *data1, *data2;
l_int32 size1;
size_t size2;
void *result;
/* Unencode selected string, write to file, and read it */
data1 = decodeBase64(l_bootnum, strlen(l_bootnum), &size1);
data2 = zlibUncompress(data1, size1, &size2);
l_binaryWrite("/tmp/data.bin", "w", data2, size2);
result = (void *)pixaRead("/tmp/data.bin");
FREE(data1);
FREE(data2);
return result;
}
/*!
* l_bootnum_gen2()
*
* Return: the bootnum2 pixa
*
* Call this way:
* PIXA *pixa = (PIXA *)l_bootnum_gen2(); (C)
* Pixa *pixa = (Pixa *)l_bootnum_gen2(); (C++)
*/
void *
l_bootnum_gen2(void)
{
l_uint8 *data1, *data2;
l_int32 size1;
size_t size2;
void *result;
lept_mkdir("lept/auto");
/* Unencode selected string, write to file, and read it */
data1 = decodeBase64(l_bootnum2, strlen(l_bootnum2), &size1);
data2 = zlibUncompress(data1, size1, &size2);
l_binaryWrite("/tmp/lept/auto/data.bin", "w", data2, size2);
result = (void *)pixaRead("/tmp/lept/auto/data.bin");
lept_free(data1);
lept_free(data2);
return result;
}
PIXA *MakeBootnum2(void)
{
char *fname;
l_int32 i, n, w, h;
BOX *box;
PIX *pix;
PIXA *pixa;
L_RECOG *recog;
SARRAY *sa;
/* Phase 1: generate recog from the digit data */
recog = recogCreate(20, 32, L_USE_ALL, 120, 1);
sa = getSortedPathnamesInDirectory("recog/bootnums", "png", 0, 0);
n = sarrayGetCount(sa);
for (i = 0; i < n; i++) {
/* Read each pix: grayscale, multi-character, labelled */
fname = sarrayGetString(sa, i, L_NOCOPY);
if ((pix = pixRead(fname)) == NULL) {
fprintf(stderr, "Can't read %s\n", fname);
continue;
}
/* Convert to a set of 1 bpp, single character, labelled */
pixGetDimensions(pix, &w, &h, NULL);
box = boxCreate(0, 0, w, h);
recogTrainLabelled(recog, pix, box, NULL, 1, 0);
pixDestroy(&pix);
boxDestroy(&box);
}
recogTrainingFinished(recog, 1);
sarrayDestroy(&sa);
/* Phase 2: generate pixa consisting of 1 bpp, single character pix */
recogWritePixa("/tmp/lept/recog/digits/bootnum2.pa", recog);
pixa = pixaRead("/tmp/lept/recog/digits/bootnum2.pa");
recogDestroy(&recog);
return pixa;
}
l_int32 main(int argc,
char **argv)
{
char *boxatxt;
l_int32 i;
BOXA *boxa1, *boxa2, *boxa3;
BOXAA *baa, *baa1;
NUMAA *naa1;
PIX *pixdb, *pix1, *pix2, *pix3, *pix4;
PIXA *pixa1, *pixa2, *pixa3, *pixat;
L_RECOG *recog;
L_RECOGA *recoga;
SARRAY *sa1;
/* ----- Example identifying samples using training data ----- */
#if 1
/* Read the training data */
pixat = pixaRead("recog/sets/train06.pa");
recog = recogCreateFromPixa(pixat, 0, 0, L_USE_ALL, 128, 1);
recoga = recogaCreateFromRecog(recog);
pixaDestroy(&pixat);
/* Read the data from all samples */
pix1 = pixRead("recog/sets/samples06.png");
boxatxt = pixGetText(pix1);
boxa1 = boxaReadMem((l_uint8 *)boxatxt, strlen(boxatxt));
pixa1 = pixaCreateFromBoxa(pix1, boxa1, NULL);
pixDestroy(&pix1); /* destroys boxa1 */
/* Identify components in the sample data */
pixa2 = pixaCreate(0);
pixa3 = pixaCreate(0);
for (i = 0; i < 9; i++) {
/* if (i != 4) continue; */ /* dots form separate boxa */
/* if (i != 8) continue; */ /* broken 2 in '24' */
pix1 = pixaGetPix(pixa1, i, L_CLONE);
/* Show the 2d box data in the sample */
boxa2 = pixConnComp(pix1, NULL, 8);
baa = boxaSort2d(boxa2, NULL, 6, 6, 5);
pix2 = boxaaDisplay(baa, 3, 1, 0xff000000, 0x00ff0000, 0, 0);
pixaAddPix(pixa3, pix2, L_INSERT);
boxaaDestroy(&baa);
boxaDestroy(&boxa2);
/* Get the numbers in the sample */
recogaIdentifyMultiple(recoga, pix1, 0, 5, 3, &boxa3, NULL, &pixdb, 0);
sa1 = recogaExtractNumbers(recoga, boxa3, 0.7, -1, &baa1, &naa1);
sarrayWriteStream(stderr, sa1);
boxaaWriteStream(stderr, baa1);
numaaWriteStream(stderr, naa1);
pixaAddPix(pixa2, pixdb, L_INSERT);
/* pixaWrite("/tmp/pixa.pa", pixa2); */
pixDestroy(&pix1);
boxaDestroy(&boxa3);
boxaaDestroy(&baa1);
numaaDestroy(&naa1);
sarrayDestroy(&sa1);
}
pix3 = pixaDisplayLinearly(pixa2, L_VERT, 1.0, 0, 20, 1, NULL);
pixWrite("/tmp/pix3.png", pix3, IFF_PNG);
pix4 = pixaDisplayTiledInRows(pixa3, 32, 1500, 1.0, 0, 20, 2);
pixDisplay(pix4, 500, 0);
pixWrite("/tmp/pix4.png", pix4, IFF_PNG);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
pixDestroy(&pix1);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixaDestroy(&pixa1);
boxaDestroy(&boxa1);
recogaDestroy(&recoga);
#endif
return 0;
}
main(int argc,
char **argv)
{
char *filein;
l_int32 i, n, ns;
BOX *box;
BOXA *boxa, *boxas;
PIX *pixs, *pixt;
PIXA *pixa, *pixas, *pixas2;
static char mainName[] = "sorttest";
if (argc != 2)
exit(ERROR_INT(" Syntax: sorttest filein", mainName, 1));
filein = argv[1];
if ((pixs = pixRead(filein)) == NULL)
exit(ERROR_INT("pixs not made", mainName, 1));
#if 0
boxa = pixConnComp(pixs, NULL, 8);
n = boxaGetCount(boxa);
boxas = boxaSort(boxa, L_SORT_BY_PERIMETER, L_SORT_DECREASING, NULL);
ns = boxaGetCount(boxas);
fprintf(stderr, "Number of cc: n = %d, ns = %d\n", n, ns);
boxaWrite("/tmp/junkboxa.ba", boxas);
for (i = 0; i < n; i++) {
box = boxaGetBox(boxas, i, L_CLONE);
pixRenderBox(pixs, box, 2, L_FLIP_PIXELS);
boxDestroy(&box);
}
pixWrite("/tmp/junkout.png", pixs, IFF_PNG);
boxaDestroy(&boxa);
boxaDestroy(&boxas);
#endif
#if 1
boxa = pixConnComp(pixs, &pixa, 8);
n = pixaGetCount(pixa);
pixas = pixaSort(pixa, L_SORT_BY_Y, L_SORT_INCREASING, NULL, L_CLONE);
ns = pixaGetCount(pixas);
fprintf(stderr, "Number of cc: n = %d, ns = %d\n", n, ns);
pixaWrite("/tmp/junkpixa.pa", pixas);
pixas2 = pixaRead("/tmp/junkpixa.pa");
pixaWrite("/tmp/junkpixa2.pa", pixas2);
pixt = pixaDisplayOnLattice(pixas, 100, 100);
pixWrite("/tmp/junkpix.png", pixt, IFF_PNG);
boxaWrite("/tmp/junkboxa.ba", pixas->boxa);
pixDestroy(&pixt);
pixaDestroy(&pixa);
pixaDestroy(&pixas);
pixaDestroy(&pixas2);
boxaDestroy(&boxa);
#endif
pixDestroy(&pixs);
return 0;
}
int main(int argc,
char **argv)
{
char buf[512];
char *pathname, *datastr, *formstr;
l_uint8 *data1, *data2;
l_int32 i, bl1, bl2, bl3, sbytes, formbytes, fontsize, rbytes;
size_t nbytes;
PIX *pix1, *pix2, *pixd;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* ------------ Generate pixa char bitmap files from file ----------- */
lept_rmdir("filefonts");
lept_mkdir("filefonts");
for (i = 0; i < 9; i++) {
pixaSaveFont("fonts", "/tmp/filefonts", sizes[i]);
pathname = genPathname("/tmp/filefonts", outputfonts[i]);
pixa = pixaRead(pathname);
if (rp->display) {
fprintf(stderr, "Found %d chars in font size %d\n",
pixaGetCount(pixa), sizes[i]);
}
pixd = pixaDisplayTiled(pixa, 1500, 0, 15);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 0 - 8 */
if (i == 2) pixDisplayWithTitle(pixd, 100, 0, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
lept_free(pathname);
}
lept_rmdir("filefonts");
/* ---------- Generate pixa char bitmap files from string --------- */
lept_rmdir("strfonts");
lept_mkdir("strfonts");
for (i = 0; i < 9; i++) {
pixaSaveFont(NULL, "/tmp/strfonts", sizes[i]);
pathname = genPathname("/tmp/strfonts", outputfonts[i]);
pixa = pixaRead(pathname);
if (rp->display) {
fprintf(stderr, "Found %d chars in font size %d\n",
pixaGetCount(pixa), sizes[i]);
}
pixd = pixaDisplayTiled(pixa, 1500, 0, 15);
regTestWritePixAndCheck(rp, pixd, IFF_PNG); /* 9 - 17 */
if (i == 2) pixDisplayWithTitle(pixd, 100, 150, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
lept_free(pathname);
}
/* ----- Use pixaGetFont() and write the result out -----*/
lept_rmdir("pafonts");
lept_mkdir("pafonts");
for (i = 0; i < 9; i++) {
pixa = pixaGetFont("/tmp/strfonts", sizes[i], &bl1, &bl2, &bl3);
fprintf(stderr, "Baselines are at: %d, %d, %d\n", bl1, bl2, bl3);
snprintf(buf, sizeof(buf), "/tmp/pafonts/chars-%d.pa", sizes[i]);
pixaWrite(buf, pixa);
if (i == 2) {
pixd = pixaDisplayTiled(pixa, 1500, 0, 15);
pixDisplayWithTitle(pixd, 100, 300, NULL, rp->display);
pixDestroy(&pixd);
}
pixaDestroy(&pixa);
}
lept_rmdir("pafonts");
/* ------- Generate 4/3 encoded ascii strings from tiff files ------ */
lept_rmdir("fontencode");
lept_mkdir("fontencode");
for (i = 0; i < 9; i++) {
fontsize = 2 * i + 4;
pathname = genPathname("fonts", inputfonts[i]);
data1 = l_binaryRead(pathname, &nbytes);
datastr = encodeBase64(data1, nbytes, &sbytes);
if (rp->display)
fprintf(stderr, "nbytes = %lu, sbytes = %d\n",
(unsigned long)nbytes, sbytes);
formstr = reformatPacked64(datastr, sbytes, 4, 72, 1, &formbytes);
snprintf(buf, sizeof(buf), "/tmp/fontencode/formstr_%d.txt", fontsize);
l_binaryWrite(buf, "w", formstr, formbytes);
regTestCheckFile(rp, buf); /* 18-26 */
if (i == 8)
pix1 = pixReadMem(data1, nbytes); /* original */
FREE(data1);
data2 = decodeBase64(datastr, sbytes, &rbytes);
snprintf(buf, sizeof(buf), "/tmp/fontencode/image_%d.tif", fontsize);
l_binaryWrite(buf, "w", data2, rbytes);
if (i == 8) {
pix2 = pixReadMem(data2, rbytes); /* encode/decode */
regTestComparePix(rp, pix1, pix2); /* 27 */
pixDestroy(&pix1);
pixDestroy(&pix2);
}
FREE(data2);
FREE(pathname);
FREE(datastr);
FREE(formstr);
}
/* ------------ Get timing for font generation ----------- */
startTimer();
for (i = 0; i < 100; i++) {
pixa = pixaGenerateFontFromString(sizes[5], &bl1, &bl2, &bl3);
pixaDestroy(&pixa);
}
fprintf(stderr, "Time for font gen = %7.4f sec\n", stopTimer() / 100.0);
return regTestCleanup(rp);
}
int main(int argc,
char **argv) {
char buf[32];
char *filein, *fileout, *fontdir, *textstr;
l_int32 n, i, maxdepth, ntext, border, lossless, display, showtext;
l_float32 scalefact;
L_BMF *bmf;
PIX *pix1, *pix2, *pix3, *pix4, *pixd;
PIXA *pixa, *pixad;
static char mainName[] = "displaypixa";
if (argc != 3 && argc != 4 && argc != 7 && argc != 8) {
fprintf(stderr, "Syntax error in displaypixa:\n"
" displaypixa filein fileout [showtext]\n"
" displaypixa filein scalefact border"
" lossless disp fileout [showtext]\n");
return 1;
}
filein = argv[1];
if ((pixa = pixaRead(filein)) == NULL)
return ERROR_INT("pixa not made", mainName, 1);
pixaCountText(pixa, &ntext);
if (argc == 3 || argc == 4)
fileout = argv[2];
if (argc == 4)
showtext = atoi(argv[3]);
/* Simple specification; no output text */
if (argc == 3 ||
(argc == 4 && (ntext == 0 || showtext == 0))) { /* no text output */
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) { /* showtext == 1 && ntext > 0 */
n = pixaGetCount(pixa);
bmf = bmfCreate(NULL, 6);
pixad = 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(pixad, pix4, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
bmfDestroy(&bmf);
pixaVerifyDepth(pixad, &maxdepth);
pixd = pixaDisplayTiledInRows(pixad, 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(&pixad);
return 0;
}
/* Full specification */
scalefact = atof(argv[2]);
border = atoi(argv[3]);
lossless = atoi(argv[4]);
display = atoi(argv[5]);
fileout = argv[6];
showtext = (argc == 8) ? atoi(argv[7]) : 0;
if (showtext && ntext == 0)
L_INFO("No text found in any of the pix\n", mainName);
bmf = (showtext && ntext > 0) ? bmfCreate(NULL, 6) : NULL;
n = pixaGetCount(pixa);
pixad = 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 (bmf && 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(pixad, pix4, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
bmfDestroy(&bmf);
pixaVerifyDepth(pixad, &maxdepth);
pixd = pixaDisplayTiledInRows(pixad, 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(&pixad);
return 0;
}
/* ----------------------------------------------------- */
void ProcessDigits(l_int32 index)
{
char rootname[8] = "digit5";
char buf[64];
l_int32 i, nc, ns, same;
NUMA *na1;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIXA *pixa1, *pixa2, *pixa3;
/* Read the unfiltered, unscaled pixa of twenty-five 5s */
snprintf(buf, sizeof(buf), "digits/%s.orig-25.pa", rootname);
pixa1 = pixaRead(buf);
/* Number and show the input images */
snprintf(buf, sizeof(buf), "/tmp/lept/digit/%s.orig-num", rootname);
PixaDisplayNumbered(pixa1, buf);
/* Remove some of them */
na1 = numaCreateFromString(removeset);
pixaRemoveSelected(pixa1, na1);
numaDestroy(&na1);
snprintf(buf, sizeof(buf), "/tmp/lept/digit/%s.filt.pa", rootname);
pixaWrite(buf, pixa1);
/* Number and show the filtered images */
snprintf(buf, sizeof(buf), "/tmp/lept/digit/%s.filt-num", rootname);
PixaDisplayNumbered(pixa1, buf);
/* Extract the largest c.c., clip to the foreground,
* and scale the result to a fixed size. */
nc = pixaGetCount(pixa1);
pixa2 = pixaCreate(nc);
for (i = 0; i < nc; i++) {
pix1 = pixaGetPix(pixa1, i, L_CLONE);
/* A threshold of 140 gives reasonable results */
pix2 = pixThresholdToBinary(pix1, 140);
/* Join nearly touching pieces */
pix3 = pixCloseSafeBrick(NULL, pix2, 5, 5);
/* Take the largest (by area) connected component */
pix4 = pixFilterComponentBySize(pix3, 0, L_SELECT_BY_AREA, 8, NULL);
/* Extract the original 1 bpp pixels that have been
* covered by the closing operation */
pixAnd(pix4, pix4, pix2);
/* Grab the result as an image with no surrounding whitespace */
pixClipToForeground(pix4, &pix5, NULL);
/* Rescale the result to the canonical size */
pix6 = pixScaleToSize(pix5, 20, 30);
pixaAddPix(pixa2, pix6, L_INSERT);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
}
/* Add the index (a "5") in the text field of each pix; save pixa2 */
snprintf(buf, sizeof(buf), "%d", index);
for (i = 0; i < nc; i++) {
pix1 = pixaGetPix(pixa2, i, L_CLONE);
pixSetText(pix1, buf);
pixDestroy(&pix1);
}
snprintf(buf, sizeof(buf), "/tmp/lept/digit/%s.comp.pa", rootname);
pixaWrite(buf, pixa2);
/* Number and show the resulting binary templates */
snprintf(buf, sizeof(buf), "/tmp/lept/digit/%s.comp-num", rootname);
PixaDisplayNumbered(pixa2, buf);
/* Save the binary templates as a packed tiling (tiff g4).
* This is the most efficient way to represent the templates. */
pix1 = pixaDisplayOnLattice(pixa2, 20, 30, NULL, NULL);
pixDisplay(pix1, 1000, 500);
snprintf(buf, sizeof(buf), "/tmp/lept/digit/%s.comp.tif", rootname);
pixWrite(buf, pix1, IFF_TIFF_G4);
/* The number of templates is in the pix text string; check it. */
pix2 = pixRead(buf);
if (sscanf(pixGetText(pix2), "n = %d", &ns) != 1)
fprintf(stderr, "Failed to read the number of templates!\n");
if (ns != nc)
fprintf(stderr, "(stored = %d) != (actual number = %d)\n", ns, nc);
/* Reconstruct the pixa of templates from the tiled compressed
* image, and verify that the resulting pixa is the same. */
pixa3 = pixaMakeFromTiledPix(pix1, 20, 30, 0, 0, NULL);
pixaEqual(pixa2, pixa3, 0, NULL, &same);
if (!same)
fprintf(stderr, "Pixa are not the same!\n");
pixDestroy(&pix1);
pixDestroy(&pix2);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixaDestroy(&pixa3);
}
l_int32 main(int argc,
char **argv)
{
char *dir, *path;
char *str1 = NULL;
char *chara, *chara2;
char buf[256];
l_uint8 *data1, *data2, *data3, *data4;
l_int32 w, h, i, n, bx, by, bw, bh, nchar, nbytes, ret;
l_int32 *rtable64;
l_uint32 pixval;
size_t nbytes1, nbytes2, nout, nout2, nout3;
L_BMF *bmf;
BOX *box1, *box2;
BOXA *boxa;
PIX *pix, *pixs, *pixm, *pixg, *pixd;
PIX *pix0, *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
PIXA *pixas, *pixa1, *pixa2, *pixa3;
L_RECOG *recog;
L_STRCODE *strc;
if (argc != 1) {
fprintf(stderr, " Syntax: recog_bootnum\n");
return 1;
}
lept_mkdir("lept/recog/digits");
/* ----------------------- Bootnum 1 --------------------- */
/* Make the bootnum pixa from the images */
pixa1 = MakeBootnum1();
pixaWrite("/tmp/lept/recog/digits/bootnum1.pa", pixa1);
pix1 = pixaDisplayTiledWithText(pixa1, 1500, 1.0, 10, 2, 6, 0xff000000);
pixDisplay(pix1, 100, 0);
pixDestroy(&pix1);
pixaDestroy(&pixa1);
/* Generate the code to make the bootnum1 pixa.
* Note: the actual code we use is in bootnumgen1.c, and
* has already been compiled into the library. */
strc = strcodeCreate(101); /* arbitrary integer */
strcodeGenerate(strc, "/tmp/lept/recog/digits/bootnum1.pa", "PIXA");
strcodeFinalize(&strc, "/tmp/lept/auto");
lept_free(strc);
/* Generate the bootnum1 pixa from the generated code */
pixa1 = (PIXA *)l_bootnum_gen1();
pix1 = pixaDisplayTiledWithText(pixa1, 1500, 1.0, 10, 2, 6, 0xff000000);
/* pix1 = pixaDisplayTiled(pixa1, 1500, 0, 30); */
pixDisplay(pix1, 100, 0);
pixDestroy(&pix1);
/* Extend the bootnum1 pixa by erosion */
pixa3 = pixaExtendIterative(pixa1, L_MORPH_ERODE, 2, NULL, 1);
pix1 = pixaDisplayTiledWithText(pixa3, 1500, 1.0, 10, 2, 6, 0xff000000);
pixDisplay(pix1, 100, 0);
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa3);
/* ----------------------- Bootnum 2 --------------------- */
/* Make the bootnum pixa from the images */
L_INFO("the 4 errors below are due to bad input\n", "recog_bootnum");
pixa2 = MakeBootnum2();
pix1 = pixaDisplayTiledWithText(pixa2, 1500, 1.0, 10, 2, 6, 0xff000000);
pixDisplay(pix1, 100, 700);
pixDestroy(&pix1);
pixaDestroy(&pixa2);
/* Generate the code to make the bootnum2 pixa.
* Note: the actual code we use is in bootnumgen2.c. */
strc = strcodeCreate(102); /* another arbitrary integer */
strcodeGenerate(strc, "/tmp/lept/recog/digits/bootnum2.pa", "PIXA");
strcodeFinalize(&strc, "/tmp/lept/auto");
lept_free(strc);
/* Generate the bootnum2 pixa from the generated code */
pixa2 = (PIXA *)l_bootnum_gen2();
/* pix1 = pixaDisplayTiled(pixa2, 1500, 0, 30); */
pix1 = pixaDisplayTiledWithText(pixa2, 1500, 1.0, 10, 2, 6, 0xff000000);
pixDisplay(pix1, 100, 700);
pixDestroy(&pix1);
pixaDestroy(&pixa2);
#if 0
pixas = (PIXA *)l_bootnum_gen1();
/* pixas = pixaRead("recog/digits/bootnum1.pa"); */
pixaWrite("/tmp/junk.pa", pixas);
pixa1 = pixaRead("/tmp/junk.pa");
pixaWrite("/tmp/junk1.pa", pixa1);
pixa = pixaRead("/tmp/junk1.pa");
n = pixaGetCount(pixa);
for (i = 0; i < n; i++) {
pix = pixaGetPix(pixa, i, L_CLONE);
fprintf(stderr, "i = %d, text = %s\n", i, pixGetText(pix));
pixDestroy(&pix);
}
#endif
return 0;
}
PIXA *MakeBootnum1(void)
{
const char *str;
PIXA *pixa1, *pixa2, *pixa3;
pixa1 = pixaRead("recog/digits/digit_set02.pa");
str = "10, 27, 35, 45, 48, 74, 79, 97, 119, 124, 148";
pixa3 = pixaSelectWithString(pixa1, str, NULL);
pixaDestroy(&pixa1);
pixa1 = pixaRead("recog/digits/digit_set03.pa");
str = "2, 15, 30, 50, 60, 75, 95, 105, 121, 135";
pixa2 = pixaSelectWithString(pixa1, str, NULL);
pixaJoin(pixa3, pixa2, 0, -1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixa1 = pixaRead("recog/digits/digit_set05.pa");
str = "0, 15, 30, 49, 60, 75, 90, 105, 120, 135";
pixa2 = pixaSelectWithString(pixa1, str, NULL);
pixaJoin(pixa3, pixa2, 0, -1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixa1 = pixaRead("recog/digits/digit_set06.pa");
str = "4, 15, 30, 48, 60, 78, 90, 105, 120, 135";
pixa2 = pixaSelectWithString(pixa1, str, NULL);
pixaJoin(pixa3, pixa2, 0, -1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixa1 = pixaRead("recog/digits/digit_set07.pa");
str = "3, 15, 30, 45, 60, 77, 78, 91, 105, 120, 149";
pixa2 = pixaSelectWithString(pixa1, str, NULL);
pixaJoin(pixa3, pixa2, 0, -1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixa1 = pixaRead("recog/digits/digit_set08.pa");
str = "0, 20, 30, 45, 60, 75, 90, 106, 121, 135";
pixa2 = pixaSelectWithString(pixa1, str, NULL);
pixaJoin(pixa3, pixa2, 0, -1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixa1 = pixaRead("recog/digits/digit_set09.pa");
str = "0, 20, 32, 47, 54, 63, 75, 91, 105, 125, 136";
pixa2 = pixaSelectWithString(pixa1, str, NULL);
pixaJoin(pixa3, pixa2, 0, -1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixa1 = pixaRead("recog/digits/digit_set11.pa");
str = "0, 15, 36, 46, 62, 63, 76, 91, 106, 123, 135";
pixa2 = pixaSelectWithString(pixa1, str, NULL);
pixaJoin(pixa3, pixa2, 0, -1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixa1 = pixaRead("recog/digits/digit_set12.pa");
str = "1, 20, 31, 45, 61, 75, 95, 107, 120, 135";
pixa2 = pixaSelectWithString(pixa1, str, NULL);
pixaJoin(pixa3, pixa2, 0, -1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
pixa1 = pixaRead("recog/digits/digit_set13.pa");
str = "1, 16, 31, 48, 63, 78, 98, 105, 123, 136";
pixa2 = pixaSelectWithString(pixa1, str, NULL);
pixaJoin(pixa3, pixa2, 0, -1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
return pixa3;
}
