jint Java_com_googlecode_leptonica_android_ReadFile_nativeReadFiles(JNIEnv *env, jclass clazz,
jstring dirName, jstring prefix) {
LOGV(__FUNCTION__);
PIXA *pixad = NULL;
const char *c_dirName = env->GetStringUTFChars(dirName, NULL);
if (c_dirName == NULL) {
LOGE("could not extract dirName string!");
return NULL;
}
const char *c_prefix = env->GetStringUTFChars(prefix, NULL);
if (c_prefix == NULL) {
LOGE("could not extract prefix string!");
return NULL;
}
pixad = pixaReadFiles(c_dirName, c_prefix);
env->ReleaseStringUTFChars(dirName, c_dirName);
env->ReleaseStringUTFChars(prefix, c_prefix);
return (jint) pixad;
}
main(int argc,
char **argv)
{
l_int32 i, w, h, d;
l_float32 time;
PIX *pixs, *pixf, *pixd;
PIXA *pixa;
char *filein, *fileout;
static char mainName[] = "edgetest";
if (argc != 3)
exit(ERROR_INT(" Syntax: edgetest filein fileout", mainName, 1));
filein = argv[1];
fileout = argv[2];
if ((pixs = pixRead(filein)) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
pixGetDimensions(pixs, &w, &h, &d);
if (d != 8)
exit(ERROR_INT("pix not 8 bpp", mainName, 1));
/* Speed: about 12 Mpix/GHz/sec */
startTimer();
pixf = pixSobelEdgeFilter(pixs, L_HORIZONTAL_EDGES);
pixd = pixThresholdToBinary(pixf, 60);
pixInvert(pixd, pixd);
time = stopTimer();
fprintf(stderr, "Time = %7.3f sec\n", time);
fprintf(stderr, "MPix/sec: %7.3f\n", 0.000001 * w * h / time);
pixDisplay(pixs, 0, 0);
pixInvert(pixf, pixf);
pixDisplay(pixf, 480, 0);
pixDisplay(pixd, 960, 0);
pixWrite(fileout, pixf, IFF_PNG);
pixDestroy(&pixd);
/* Threshold at different values */
pixInvert(pixf, pixf);
for (i = 10; i <= 120; i += 10) {
pixd = pixThresholdToBinary(pixf, i);
pixInvert(pixd, pixd);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
}
pixDestroy(&pixf);
/* Display tiled */
pixa = pixaReadFiles("/tmp", "junk_write_display");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 400, 3, 0, 25, 2);
pixWrite("/tmp/junktiles.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs);
exit(0);
}
main(int argc,
char **argv)
{
l_int32 i;
PIX *pixs, *pixt1, *pixt2, *pixt3, *pixd;
PIXA *pixa;
static char mainName[] = "livre_seedgen";
pixs = pixRead("pageseg2.tif");
startTimer();
for (i = 0; i < 100; i++) {
pixt1 = pixReduceRankBinaryCascade(pixs, 1, 4, 4, 3);
pixDestroy(&pixt1);
}
fprintf(stderr, "Time: %8.4f sec\n", stopTimer() / 100.);
/* 4 2x rank reductions (levels 1, 4, 4, 3), followed by 5x5 opening */
pixDisplayWrite(NULL, -1);
pixDisplayWriteFormat(pixs, 4, IFF_PNG);
pixt1 = pixReduceRankBinaryCascade(pixs, 1, 4, 0, 0);
pixDisplayWriteFormat(pixt1, 1, IFF_PNG);
pixt2 = pixReduceRankBinaryCascade(pixt1, 4, 3, 0, 0);
pixDisplayWriteFormat(pixt2, 1, IFF_PNG);
pixOpenBrick(pixt2, pixt2, 5, 5);
pixt3 = pixExpandBinaryReplicate(pixt2, 2);
pixDisplayWriteFormat(pixt3, 1, IFF_PNG);
/* Generate the output image */
pixa = pixaReadFiles("/tmp", "junk_write_display");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 250, 4, 0, 25, 2);
pixWrite("/tmp/seedgen.png", pixd, IFF_PNG);
pixDestroy(&pixs);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixd);
pixaDestroy(&pixa);
return 0;
}
main(int argc,
char **argv)
{
PIX *pixs, *pixsg, *pixg, *pixd;
PIXA *pixa;
static char mainName[] = "livre_tophat";
if (argc != 1)
return ERROR_INT(" Syntax: livre_tophat", mainName, 1);
/* Read the image in at 150 ppi. */
if ((pixs = pixRead("brothers.150.jpg")) == NULL)
return ERROR_INT("pix not made", mainName, 1);
pixDisplayWrite(NULL, -1);
pixDisplayWriteFormat(pixs, 2, IFF_JFIF_JPEG);
pixsg = pixConvertRGBToLuminance(pixs);
/* Black tophat (closing - original-image) and invert */
pixg = pixTophat(pixsg, 15, 15, L_TOPHAT_BLACK);
pixInvert(pixg, pixg);
pixDisplayWriteFormat(pixg, 2, IFF_JFIF_JPEG);
/* Set black point at 200, white point at 245. */
pixd = pixGammaTRC(NULL, pixg, 1.0, 200, 245);
pixDisplayWriteFormat(pixd, 2, IFF_JFIF_JPEG);
pixDestroy(&pixg);
pixDestroy(&pixd);
/* Generate the output image */
pixa = pixaReadFiles("/tmp", "junk_write_display");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 350, 3, 0, 25, 2);
pixWrite("/tmp/tophat.jpg", pixd, IFF_JFIF_JPEG);
pixDisplay(pixd, 0, 0);
pixDestroy(&pixd);
pixDestroy(&pixs);
pixDestroy(&pixsg);
return 0;
}
main(int argc,
char **argv)
{
char *dirin, *substr, *fileout;
l_int32 depth, width, ncols;
PIX *pixd;
PIXA *pixa;
static char mainName[] = "scaleandtile";
if (argc != 7)
return ERROR_INT(
"Syntax: scaleandtile dirin substr depth width ncols fileout",
mainName, 1);
dirin = argv[1];
substr = argv[2];
depth = atoi(argv[3]);
width = atoi(argv[4]);
ncols = atoi(argv[5]);
fileout = argv[6];
/* Read the specified images from file */
if ((pixa = pixaReadFiles(dirin, substr)) == NULL)
return ERROR_INT("safiles not made", mainName, 1);
fprintf(stderr, "Number of pix: %d\n", pixaGetCount(pixa));
/* Tile them */
pixd = pixaDisplayTiledAndScaled(pixa, depth, width, ncols,
BACKGROUND_COLOR, SPACING, BLACK_BORDER);
if (depth < 8)
pixWrite(fileout, pixd, IFF_PNG);
else
pixWrite(fileout, pixd, IFF_JFIF_JPEG);
pixaDestroy(&pixa);
pixDestroy(&pixd);
return 0;
}
int main(int argc,
char **argv)
{
l_int32 i, j, w, h, same;
l_float32 t, t1, t2;
GPLOT *gplot;
NUMA *nax, *nay1, *nay2;
PIX *pixs, *pixd, *pixt1, *pixt2, *pixt3, *pixt4;
PIXA *pixa;
static char mainName[] = "rank_reg";
if (argc != 1)
return ERROR_INT(" Syntax: rank_reg", mainName, 1);
if ((pixs = pixRead("lucasta.150.jpg")) == NULL)
return ERROR_INT("pixs not made", mainName, 1);
pixGetDimensions(pixs, &w, &h, NULL);
startTimer();
pixd = pixRankFilterGray(pixs, 15, 15, 0.4);
t = stopTimer();
fprintf(stderr, "Time = %7.3f sec\n", t);
fprintf(stderr, "MPix/sec: %7.3f\n", 0.000001 * w * h / t);
pixDisplay(pixs, 0, 200);
pixDisplay(pixd, 600, 200);
pixWrite("/tmp/filter.png", pixd, IFF_PNG);
pixDestroy(&pixd);
/* Get results for dilation */
startTimer();
pixt1 = pixDilateGray(pixs, 15, 15);
t = stopTimer();
fprintf(stderr, "Dilation time = %7.3f sec\n", t);
/* Get results for erosion */
pixt2 = pixErodeGray(pixs, 15, 15);
/* Get results using the rank filter for rank = 0.0 and 1.0.
* Don't use 0.0 or 1.0, because those are dispatched
* automatically to erosion and dilation! */
pixt3 = pixRankFilterGray(pixs, 15, 15, 0.0001);
pixt4 = pixRankFilterGray(pixs, 15, 15, 0.9999);
/* Compare */
pixEqual(pixt1, pixt4, &same);
if (same)
fprintf(stderr, "Correct: dilation results same as rank 1.0\n");
else
fprintf(stderr, "Error: dilation results differ from rank 1.0\n");
pixEqual(pixt2, pixt3, &same);
if (same)
fprintf(stderr, "Correct: erosion results same as rank 0.0\n");
else
fprintf(stderr, "Error: erosion results differ from rank 0.0\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
fprintf(stderr, "\n----------------------------------------\n");
fprintf(stderr, "The next part takes about 30 seconds\n");
fprintf(stderr, "----------------------------------------\n\n");
nax = numaMakeSequence(1, 1, SIZE);
nay1 = numaCreate(SIZE);
nay2 = numaCreate(SIZE);
gplot = gplotCreate("/tmp/rankroot", GPLOT_X11, "sec/MPix vs filter size",
"size", "time");
for (i = 1; i <= SIZE; i++) {
t1 = t2 = 0.0;
for (j = 0; j < 5; j++) {
startTimer();
pixt1 = pixRankFilterGray(pixs, i, SIZE + 1, 0.5);
t1 += stopTimer();
pixDestroy(&pixt1);
startTimer();
pixt1 = pixRankFilterGray(pixs, SIZE + 1, i, 0.5);
t2 += stopTimer();
if (j == 0)
pixDisplayWrite(pixt1, 1);
pixDestroy(&pixt1);
}
numaAddNumber(nay1, 1000000. * t1 / (5. * w * h));
numaAddNumber(nay2, 1000000. * t2 / (5. * w * h));
}
gplotAddPlot(gplot, nax, nay1, GPLOT_LINES, "vertical");
gplotAddPlot(gplot, nax, nay2, GPLOT_LINES, "horizontal");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
/* Display tiled */
pixa = pixaReadFiles("/tmp/display", "file");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 250, 5, 0, 25, 2);
pixWrite("/tmp/tiles.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs);
pixDisplayWrite(NULL, -1); /* clear out */
pixs = pixRead("test8.jpg");
for (i = 1; i <= 4; i++) {
pixt1 = pixScaleGrayRank2(pixs, i);
pixDisplay(pixt1, 300 * (i - 1), 100);
pixDestroy(&pixt1);
}
pixDestroy(&pixs);
pixs = pixRead("test24.jpg");
pixt1 = pixConvertRGBToLuminance(pixs);
pixt2 = pixScale(pixt1, 1.5, 1.5);
for (i = 1; i <= 4; i++) {
for (j = 1; j <= 4; j++) {
pixt3 = pixScaleGrayRankCascade(pixt2, i, j, 0, 0);
pixDisplayWrite(pixt3, 1);
pixDestroy(&pixt3);
}
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixs);
pixDisplayMultiple("/tmp/display/file*");
return 0;
}
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);
}
main(int argc,
char **argv)
{
l_int32 d;
PIX *pixs, *pixc, *pixr, *pixg, *pixb, *pixsg, *pixsm, *pixd;
PIXA *pixa;
static char mainName[] = "livre_adapt";
if (argc != 1)
exit(ERROR_INT(" Syntax: livre_adapt", mainName, 1));
/* Read the image in at 150 ppi. */
pixDisplayWrite(NULL, -1);
if ((pixs = pixRead("brothers.150.jpg")) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
pixDisplayWriteFormat(pixs, 2, IFF_JFIF_JPEG);
/* Normalize for uneven illumination on RGB image */
pixBackgroundNormRGBArraysMorph(pixs, NULL, 4, 5, 200,
&pixr, &pixg, &pixb);
pixd = pixApplyInvBackgroundRGBMap(pixs, pixr, pixg, pixb, 4, 4);
pixDisplayWriteFormat(pixd, 2, IFF_JFIF_JPEG);
pixDestroy(&pixr);
pixDestroy(&pixg);
pixDestroy(&pixb);
pixDestroy(&pixd);
/* Convert the RGB image to grayscale. */
pixsg = pixConvertRGBToLuminance(pixs);
pixDisplayWriteFormat(pixsg, 2, IFF_JFIF_JPEG);
/* Remove the text in the fg. */
pixc = pixCloseGray(pixsg, 25, 25);
pixDisplayWriteFormat(pixc, 2, IFF_JFIF_JPEG);
/* Smooth the bg with a convolution. */
pixsm = pixBlockconv(pixc, 15, 15);
pixDisplayWriteFormat(pixsm, 2, IFF_JFIF_JPEG);
pixDestroy(&pixc);
/* Normalize for uneven illumination on gray image. */
pixBackgroundNormGrayArrayMorph(pixsg, NULL, 4, 5, 200, &pixg);
pixc = pixApplyInvBackgroundGrayMap(pixsg, pixg, 4, 4);
pixDisplayWriteFormat(pixc, 2, IFF_JFIF_JPEG);
pixDestroy(&pixg);
/* Increase the dynamic range. */
pixd = pixGammaTRC(NULL, pixc, 1.0, 30, 180);
pixDisplayWriteFormat(pixd, 2, IFF_JFIF_JPEG);
pixDestroy(&pixc);
/* Threshold to 1 bpp. */
pixb = pixThresholdToBinary(pixd, 120);
pixDisplayWriteFormat(pixb, 2, IFF_PNG);
pixDestroy(&pixd);
pixDestroy(&pixb);
/* Generate the output image */
pixa = pixaReadFiles("/tmp", "junk_write_display");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 350, 4, 0, 25, 2);
pixWrite("/tmp/adapt.jpg", pixd, IFF_JFIF_JPEG);
pixDisplayWithTitle(pixd, 100, 100, NULL, 1);
pixDestroy(&pixd);
pixDestroy(&pixs);
pixDestroy(&pixsg);
return 0;
}
l_int32
DoPageSegmentation(PIX *pixs, /* should be at least 300 ppi */
l_int32 which) /* 1, 2, 3, 4 */
{
char buf[256];
l_int32 zero;
BOXA *boxatm, *boxahm;
PIX *pixr; /* image reduced to 150 ppi */
PIX *pixhs; /* image of halftone seed, 150 ppi */
PIX *pixm; /* image of mask of components, 150 ppi */
PIX *pixhm1; /* image of halftone mask, 150 ppi */
PIX *pixhm2; /* image of halftone mask, 300 ppi */
PIX *pixht; /* image of halftone components, 150 ppi */
PIX *pixnht; /* image without halftone components, 150 ppi */
PIX *pixi; /* inverted image, 150 ppi */
PIX *pixvws; /* image of vertical whitespace, 150 ppi */
PIX *pixtm1; /* image of closed textlines, 150 ppi */
PIX *pixtm2; /* image of refined text line mask, 150 ppi */
PIX *pixtm3; /* image of refined text line mask, 300 ppi */
PIX *pixtb1; /* image of text block mask, 150 ppi */
PIX *pixtb2; /* image of text block mask, 300 ppi */
PIX *pixnon; /* image of non-text or halftone, 150 ppi */
PIX *pixt1, *pixt2, *pixt3;
PIXA *pixa;
PIXCMAP *cmap;
PTAA *ptaa;
l_int32 ht_flag = 0;
l_int32 ws_flag = 0;
l_int32 text_flag = 0;
l_int32 block_flag = 0;
PROCNAME("DoPageSegmentation");
if (which == 1)
ht_flag = 1;
else if (which == 2)
ws_flag = 1;
else if (which == 3)
text_flag = 1;
else if (which == 4)
block_flag = 1;
else
return ERROR_INT("invalid parameter: not in [1...4]", procName, 1);
pixDisplayWrite(NULL, -1);
/* Reduce to 150 ppi */
pixt1 = pixScaleToGray2(pixs);
pixDisplayWriteFormat(pixt1, L_MAX(ws_flag, L_MAX(ht_flag, block_flag)),
IFF_PNG);
if (which == 1) pixWrite("/tmp/orig.gray.150.png", pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixr = pixReduceRankBinaryCascade(pixs, 1, 0, 0, 0);
/* Get seed for halftone parts */
pixt1 = pixReduceRankBinaryCascade(pixr, 4, 4, 3, 0);
pixt2 = pixOpenBrick(NULL, pixt1, 5, 5);
pixhs = pixExpandBinaryPower2(pixt2, 8);
pixDisplayWriteFormat(pixhs, ht_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/htseed.150.png", pixhs, IFF_PNG);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Get mask for connected regions */
pixm = pixCloseSafeBrick(NULL, pixr, 4, 4);
pixDisplayWriteFormat(pixm, ht_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/ccmask.150.png", pixm, IFF_PNG);
/* Fill seed into mask to get halftone mask */
pixhm1 = pixSeedfillBinary(NULL, pixhs, pixm, 4);
pixDisplayWriteFormat(pixhm1, ht_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/htmask.150.png", pixhm1, IFF_PNG);
pixhm2 = pixExpandBinaryPower2(pixhm1, 2);
/* Extract halftone stuff */
pixht = pixAnd(NULL, pixhm1, pixr);
if (which == 1) pixWrite("/tmp/ht.150.png", pixht, IFF_PNG);
/* Extract non-halftone stuff */
pixnht = pixXor(NULL, pixht, pixr);
pixDisplayWriteFormat(pixnht, text_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/text.150.png", pixnht, IFF_PNG);
pixZero(pixht, &zero);
if (zero)
fprintf(stderr, "No halftone parts found\n");
else
fprintf(stderr, "Halftone parts found\n");
/* Get bit-inverted image */
pixi = pixInvert(NULL, pixnht);
if (which == 1) pixWrite("/tmp/invert.150.png", pixi, IFF_PNG);
pixDisplayWriteFormat(pixi, ws_flag, IFF_PNG);
/* The whitespace mask will break textlines where there
* is a large amount of white space below or above.
* We can prevent this by identifying regions of the
* inverted image that have large horizontal (bigger than
* the separation between columns) and significant
* vertical extent (bigger than the separation between
* textlines), and subtracting this from the whitespace mask. */
pixt1 = pixMorphCompSequence(pixi, "o80.60", 0);
pixt2 = pixSubtract(NULL, pixi, pixt1);
pixDisplayWriteFormat(pixt2, ws_flag, IFF_PNG);
pixDestroy(&pixt1);
/* Identify vertical whitespace by opening inverted image */
pixt3 = pixOpenBrick(NULL, pixt2, 5, 1); /* removes thin vertical lines */
pixvws = pixOpenBrick(NULL, pixt3, 1, 200); /* gets long vertical lines */
pixDisplayWriteFormat(pixvws, L_MAX(text_flag, ws_flag), IFF_PNG);
if (which == 1) pixWrite("/tmp/vertws.150.png", pixvws, IFF_PNG);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
/* Get proto (early processed) text line mask. */
/* First close the characters and words in the textlines */
pixtm1 = pixCloseSafeBrick(NULL, pixnht, 30, 1);
pixDisplayWriteFormat(pixtm1, text_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/textmask1.150.png", pixtm1, IFF_PNG);
/* Next open back up the vertical whitespace corridors */
pixtm2 = pixSubtract(NULL, pixtm1, pixvws);
if (which == 1) pixWrite("/tmp/textmask2.150.png", pixtm2, IFF_PNG);
/* Do a small opening to remove noise */
pixOpenBrick(pixtm2, pixtm2, 3, 3);
pixDisplayWriteFormat(pixtm2, text_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/textmask3.150.png", pixtm2, IFF_PNG);
pixtm3 = pixExpandBinaryPower2(pixtm2, 2);
/* Join pixels vertically to make text block mask */
pixtb1 = pixMorphSequence(pixtm2, "c1.10 + o4.1", 0);
pixDisplayWriteFormat(pixtb1, block_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/textblock1.150.png", pixtb1, IFF_PNG);
/* Solidify the textblock mask and remove noise:
* (1) For each c.c., close the blocks and dilate slightly
* to form a solid mask.
* (2) Small horizontal closing between components
* (3) Open the white space between columns, again
* (4) Remove small components */
pixt1 = pixMorphSequenceByComponent(pixtb1, "c30.30 + d3.3", 8, 0, 0, NULL);
pixCloseSafeBrick(pixt1, pixt1, 10, 1);
pixDisplayWriteFormat(pixt1, block_flag, IFF_PNG);
pixt2 = pixSubtract(NULL, pixt1, pixvws);
pixt3 = pixSelectBySize(pixt2, 25, 5, 8, L_SELECT_IF_BOTH,
L_SELECT_IF_GTE, NULL);
pixDisplayWriteFormat(pixt3, block_flag, IFF_PNG);
if (which == 1) pixWrite("/tmp/textblock2.150.png", pixt3, IFF_PNG);
pixtb2 = pixExpandBinaryPower2(pixt3, 2);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
/* Identify the outlines of each textblock */
ptaa = pixGetOuterBordersPtaa(pixtb2);
pixt1 = pixRenderRandomCmapPtaa(pixtb2, ptaa, 1, 8, 1);
cmap = pixGetColormap(pixt1);
pixcmapResetColor(cmap, 0, 130, 130, 130); /* set interior to gray */
if (which == 1) pixWrite("/tmp/textblock3.300.png", pixt1, IFF_PNG);
pixDisplayWithTitle(pixt1, 480, 360, "textblock mask with outlines", DFLAG);
ptaaDestroy(&ptaa);
pixDestroy(&pixt1);
/* Fill line mask (as seed) into the original */
pixt1 = pixSeedfillBinary(NULL, pixtm3, pixs, 8);
pixOr(pixtm3, pixtm3, pixt1);
pixDestroy(&pixt1);
if (which == 1) pixWrite("/tmp/textmask.300.png", pixtm3, IFF_PNG);
pixDisplayWithTitle(pixtm3, 480, 360, "textline mask 4", DFLAG);
/* Fill halftone mask (as seed) into the original */
pixt1 = pixSeedfillBinary(NULL, pixhm2, pixs, 8);
pixOr(pixhm2, pixhm2, pixt1);
pixDestroy(&pixt1);
if (which == 1) pixWrite("/tmp/htmask.300.png", pixhm2, IFF_PNG);
pixDisplayWithTitle(pixhm2, 520, 390, "halftonemask 2", DFLAG);
/* Find objects that are neither text nor halftones */
pixt1 = pixSubtract(NULL, pixs, pixtm3); /* remove text pixels */
pixnon = pixSubtract(NULL, pixt1, pixhm2); /* remove halftone pixels */
if (which == 1) pixWrite("/tmp/other.300.png", pixnon, IFF_PNG);
pixDisplayWithTitle(pixnon, 540, 420, "other stuff", DFLAG);
pixDestroy(&pixt1);
/* Write out b.b. for text line mask and halftone mask components */
boxatm = pixConnComp(pixtm3, NULL, 4);
boxahm = pixConnComp(pixhm2, NULL, 8);
if (which == 1) boxaWrite("/tmp/textmask.boxa", boxatm);
if (which == 1) boxaWrite("/tmp/htmask.boxa", boxahm);
pixa = pixaReadFiles("/tmp/display", "file");
pixt1 = pixaDisplayTiledAndScaled(pixa, 8, 250, 4, 0, 25, 2);
snprintf(buf, sizeof(buf), "/tmp/segout.%d.png", which);
pixWrite(buf, pixt1, IFF_PNG);
pixDestroy(&pixt1);
pixaDestroy(&pixa);
/* clean up to test with valgrind */
pixDestroy(&pixr);
pixDestroy(&pixhs);
pixDestroy(&pixm);
pixDestroy(&pixhm1);
pixDestroy(&pixhm2);
pixDestroy(&pixht);
pixDestroy(&pixnht);
pixDestroy(&pixi);
pixDestroy(&pixvws);
pixDestroy(&pixtm1);
pixDestroy(&pixtm2);
pixDestroy(&pixtm3);
pixDestroy(&pixtb1);
pixDestroy(&pixtb2);
pixDestroy(&pixnon);
boxaDestroy(&boxatm);
boxaDestroy(&boxahm);
return 0;
}
int main(int argc,
char **argv)
{
BOX *box;
PIX *pix, *pixs, *pixd, *pixt;
PIXA *pixa;
SEL *sel, *sel1, *sel2, *sel3;
SELA *sela4, *sela8, *sela48;
static char mainName[] = "ccthin1_reg";
if (argc != 1)
return ERROR_INT(" Syntax: ccthin1_reg", mainName, 1);
/* Generate and display all of the 4-cc sels */
sela4 = selaCreate(9);
sel = selCreateFromString(sel_4_1, 3, 3, "sel_4_1");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_2, 3, 3, "sel_4_2");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_3, 3, 3, "sel_4_3");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_4, 3, 3, "sel_4_4");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_5, 3, 3, "sel_4_5");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_6, 3, 3, "sel_4_6");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_7, 3, 3, "sel_4_7");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_8, 3, 3, "sel_4_8");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_9, 3, 3, "sel_4_9");
selaAddSel(sela4, sel, NULL, 0);
pixt = selaDisplayInPix(sela4, 35, 3, 15, 3);
pixWrite("/tmp/junkallsel4.png", pixt, IFF_PNG);
pixDestroy(&pixt);
selaDestroy(&sela4);
/* Generate and display all of the 8-cc sels */
sela8 = selaCreate(9);
sel = selCreateFromString(sel_8_1, 3, 3, "sel_8_1");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_2, 3, 3, "sel_8_2");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_3, 3, 3, "sel_8_3");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_4, 3, 3, "sel_8_4");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_5, 3, 3, "sel_8_5");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_6, 3, 3, "sel_8_6");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_7, 3, 3, "sel_8_7");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_8, 3, 3, "sel_8_8");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_9, 3, 3, "sel_8_9");
selaAddSel(sela8, sel, NULL, 0);
pixt = selaDisplayInPix(sela8, 35, 3, 15, 3);
pixWrite("/tmp/junkallsel8.png", pixt, IFF_PNG);
pixDestroy(&pixt);
selaDestroy(&sela8);
/* Generate and display all of the 4 and 8-cc preserving sels */
sela48 = selaCreate(3);
sel = selCreateFromString(sel_48_1, 3, 3, "sel_48_1");
selaAddSel(sela48, sel, NULL, 0);
sel = selCreateFromString(sel_48_2, 3, 3, "sel_48_2");
selaAddSel(sela48, sel, NULL, 0);
pixt = selaDisplayInPix(sela48, 35, 3, 15, 4);
pixWrite("/tmp/junkallsel48.png", pixt, IFF_PNG);
pixDestroy(&pixt);
selaDestroy(&sela48);
/* Generate and display three of the 4-cc sels and their rotations */
sela4 = selaCreate(3);
sel = selCreateFromString(sel_4_1, 3, 3, "sel_4_1");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela4, sel, NULL, 0);
selaAddSel(sela4, sel1, "sel_4_1_90", 0);
selaAddSel(sela4, sel2, "sel_4_1_180", 0);
selaAddSel(sela4, sel3, "sel_4_1_270", 0);
sel = selCreateFromString(sel_4_2, 3, 3, "sel_4_2");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela4, sel, NULL, 0);
selaAddSel(sela4, sel1, "sel_4_2_90", 0);
selaAddSel(sela4, sel2, "sel_4_2_180", 0);
selaAddSel(sela4, sel3, "sel_4_2_270", 0);
sel = selCreateFromString(sel_4_3, 3, 3, "sel_4_3");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela4, sel, NULL, 0);
selaAddSel(sela4, sel1, "sel_4_3_90", 0);
selaAddSel(sela4, sel2, "sel_4_3_180", 0);
selaAddSel(sela4, sel3, "sel_4_3_270", 0);
pixt = selaDisplayInPix(sela4, 35, 3, 15, 4);
pixWrite("/tmp/junksel4.png", pixt, IFF_PNG);
pixDestroy(&pixt);
selaDestroy(&sela4);
/* Generate and display four of the 8-cc sels and their rotations */
sela8 = selaCreate(4);
sel = selCreateFromString(sel_8_2, 3, 3, "sel_8_2");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela8, sel, NULL, 0);
selaAddSel(sela8, sel1, "sel_8_2_90", 0);
selaAddSel(sela8, sel2, "sel_8_2_180", 0);
selaAddSel(sela8, sel3, "sel_8_2_270", 0);
sel = selCreateFromString(sel_8_3, 3, 3, "sel_8_3");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela8, sel, NULL, 0);
selaAddSel(sela8, sel1, "sel_8_3_90", 0);
selaAddSel(sela8, sel2, "sel_8_3_180", 0);
selaAddSel(sela8, sel3, "sel_8_3_270", 0);
sel = selCreateFromString(sel_8_5, 3, 3, "sel_8_5");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela8, sel, NULL, 0);
selaAddSel(sela8, sel1, "sel_8_5_90", 0);
selaAddSel(sela8, sel2, "sel_8_5_180", 0);
selaAddSel(sela8, sel3, "sel_8_5_270", 0);
sel = selCreateFromString(sel_8_6, 3, 3, "sel_8_6");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela8, sel, NULL, 0);
selaAddSel(sela8, sel1, "sel_8_6_90", 0);
selaAddSel(sela8, sel2, "sel_8_6_180", 0);
selaAddSel(sela8, sel3, "sel_8_6_270", 0);
pixt = selaDisplayInPix(sela8, 35, 3, 15, 4);
pixWrite("/tmp/junksel8.png", pixt, IFF_PNG);
pixDestroy(&pixt);
selaDestroy(&sela8);
/* Test the best 4 and 8 cc thinning */
pixDisplayWrite(NULL, 0);
pix = pixRead("feyn.tif");
box = boxCreate(683, 799, 970, 479);
pixs = pixClipRectangle(pix, box, NULL);
pixDisplayWrite(pixs, 1);
pixt = pixThin(pixs, L_THIN_FG, 4, 0);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThin(pixs, L_THIN_BG, 4, 0);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThin(pixs, L_THIN_FG, 8, 0);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThin(pixs, L_THIN_BG, 8, 0);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
/* Display tiled */
pixa = pixaReadFiles("/tmp/display", "file");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 500, 1, 0, 25, 2);
pixWrite("/tmp/junktiles.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pix);
pixDestroy(&pixs);
boxDestroy(&box);
pixDisplayMultiple("/tmp/display/file*");
return 0;
}
main(int argc,
char **argv)
{
l_int32 index, maxiters, type;
BOX *box;
PIX *pix, *pixs, *pixd, *pixt;
PIXA *pixa;
static char mainName[] = "ccthin2_reg";
if (argc != 1 && argc != 3)
exit(ERROR_INT(" Syntax: ccthin2_reg [index maxiters]", mainName, 1));
pixDisplayWrite(NULL, 0);
if ((pix = pixRead("feyn.tif")) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
box = boxCreate(683, 799, 970, 479);
pixs = pixClipRectangle(pix, box, NULL);
pixDisplayWrite(pixs, 1);
/* Just do one of the examples */
if (argc == 3) {
index = atoi(argv[1]);
maxiters = atoi(argv[2]);
if (index <= 7)
type = L_THIN_FG;
else
type = L_THIN_BG;
pixt = pixThinExamples(pixs, type, index, maxiters,
"/tmp/junksels.png");
pixDisplay(pixt, 100, 100);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixDisplayMultiple("/tmp/junk_write_display*");
return 0;
}
/* Do all the examples */
pixt = pixThinExamples(pixs, L_THIN_FG, 1, 0, "/tmp/junksel_example1.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_FG, 2, 0, "/tmp/junksel_example2.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_FG, 3, 0, "/tmp/junksel_example3.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_FG, 4, 0, "/tmp/junksel_example4.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_FG, 5, 0, "/tmp/junksel_example5.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_FG, 6, 0, "/tmp/junksel_example6.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_FG, 7, 0, "/tmp/junksel_example7.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_BG, 8, 5, "/tmp/junksel_example8.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThinExamples(pixs, L_THIN_BG, 9, 5, "/tmp/junksel_example9.png");
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
/* Display the thinning results */
pixa = pixaReadFiles("/tmp", "junk_write_display");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 500, 1, 0, 25, 2);
pixWrite("/tmp/junktiles.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Display the sels used in the examples */
pixa = pixaReadFiles("/tmp", "junksel_example");
pixd = pixaDisplayTiledInRows(pixa, 1, 500, 1.0, 0, 50, 2);
pixWrite("/tmp/junksels.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pix);
pixDestroy(&pixs);
boxDestroy(&box);
pixDisplayMultiple("/tmp/junk_write_display*");
return 0;
}
main(int argc,
char **argv)
{
l_int32 i, wf, hf, w, h, d, same;
l_float32 rank, time;
PIX *pixs, *pixd, *pixt1, *pixt2, *pixt3, *pixt4;
PIXA *pixa;
char *filein, *fileout;
static char mainName[] = "ranktest";
if (argc != 6)
exit(ERROR_INT(" Syntax: ranktest filein wf hf rank fileout",
mainName, 1));
filein = argv[1];
wf = atoi(argv[2]);
hf = atoi(argv[3]);
rank = atof(argv[4]);
fileout = argv[5];
if ((pixs = pixRead(filein)) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
pixGetDimensions(pixs, &w, &h, &d);
if (d != 8 && d != 32)
exit(ERROR_INT("pix neither 8 nor 32 bpp", mainName, 1));
startTimer();
pixd = pixRankFilter(pixs, wf, hf, rank);
time = stopTimer();
fprintf(stderr, "Time = %7.3f sec\n", time);
fprintf(stderr, "MPix/sec: %7.3f\n", 0.000001 * w * h / time);
pixDisplay(pixs, 0, 0);
pixDisplay(pixd, 600, 0);
pixWrite(fileout, pixd, IFF_PNG);
pixDestroy(&pixd);
/* Get results for different rank values */
for (i = 0; i <= 10; i++) {
pixd = pixRankFilter(pixs, wf, hf, 0.1 * i);
pixDisplayWrite(pixd, 1);
pixDestroy(&pixd);
}
/* Make the dimensions odd to compare with dilation & erosion */
if (wf % 2 == 0) wf++;
if (hf % 2 == 0) hf++;
/* Get results for dilation and erosion */
if (d == 8) {
pixt1 = pixDilateGray(pixs, wf, hf);
pixt2 = pixErodeGray(pixs, wf, hf);
} else {
pixt1 = pixColorMorph(pixs, L_MORPH_DILATE, wf, hf);
pixt2 = pixColorMorph(pixs, L_MORPH_ERODE, wf, hf);
}
pixDisplayWrite(pixt1, 1); /* dilation */
/* Get results using the rank filter for rank = 0.0 and 1.0.
* Don't use 0.0 or 1.0, because those are dispatched
* automatically to erosion and dilation! */
pixt3 = pixRankFilter(pixs, wf, hf, 0.0001);
pixt4 = pixRankFilter(pixs, wf, hf, 0.9999);
/* Compare */
pixEqual(pixt1, pixt4, &same);
if (same)
fprintf(stderr, "Correct: dilation results same as rank 1.0\n");
else
fprintf(stderr, "Error: dilation results differ from rank 1.0\n");
pixEqual(pixt2, pixt3, &same);
if (same)
fprintf(stderr, "Correct: erosion results same as rank 0.0\n");
else
fprintf(stderr, "Error: erosion results differ from rank 0.0\n");
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Display tiled */
pixa = pixaReadFiles("/tmp", "junk_write_display");
pixd = pixaDisplayTiledAndScaled(pixa, d, 400, 3, 0, 25, 2);
pixWrite("/tmp/junktiles.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pixs);
return 0;
}