/*!
* dewarpSinglePageRun()
*
* Input: pixs (any depth)
* pixb (1 bpp)
* dewa (initialized)
* &pixd (<return> dewarped result)
* debug (1 for debugging output, 0 otherwise)
* Return: 0 if OK, 1 on error (list of page numbers), or null on error
*
* Notes:
* (1) Dewarps pixs and returns the result in &pixd.
* (2) The model parameters must be set before calling this.
* (3) If a model cannot be built, this returns a copy of pixs in &pixd.
*/
l_int32
dewarpSinglePageRun(PIX *pixs,
PIX *pixb,
L_DEWARPA *dewa,
PIX **ppixd,
l_int32 debug)
{
const char *debugfile;
l_int32 vsuccess, ret;
L_DEWARP *dew;
PROCNAME("dewarpSinglePageRun");
if (!ppixd)
return ERROR_INT("&pixd not defined", procName, 1);
*ppixd = NULL;
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (!pixb)
return ERROR_INT("pixs not defined", procName, 1);
if (!dewa)
return ERROR_INT("dewa not defined", procName, 1);
/* Generate the page model */
lept_mkdir("lept");
dew = dewarpCreate(pixb, 0);
dewarpaInsertDewarp(dewa, dew);
debugfile = (debug) ? "/tmp/lept/singlepage_model.pdf" : NULL;
dewarpBuildPageModel(dew, debugfile);
dewarpaModelStatus(dewa, 0, &vsuccess, NULL);
if (vsuccess == 0) {
L_ERROR("failure to build model for vertical disparity\n", procName);
*ppixd = pixCopy(NULL, pixs);
return 0;
}
/* Apply the page model */
debugfile = (debug) ? "/tmp/lept/singlepage_apply.pdf" : NULL;
ret = dewarpaApplyDisparity(dewa, 0, pixs, 255, 0, 0, ppixd, debugfile);
if (ret)
L_ERROR("invalid model; failure to apply disparity\n", procName);
return 0;
}
l_int32 main(int argc,
char **argv)
{
l_int32 method, pageno;
L_DEWARP *dew1;
L_DEWARPA *dewa;
PIX *pixs, *pixn, *pixg, *pixb, *pixd;
static char mainName[] = "dewarptest2";
if (argc != 2 && argc != 4)
return ERROR_INT("Syntax: dewarptest2 method [image pageno]",
mainName, 1);
if (argc == 2) {
pixs = pixRead("cat-35.jpg");
pageno = 35;
}
else {
pixs = pixRead(argv[2]);
pageno = atoi(argv[3]);
}
if (!pixs)
return ERROR_INT("image not read", mainName, 1);
method = atoi(argv[1]);
lept_mkdir("lept");
if (method == 1) { /* Use single page dewarp function */
dewarpSinglePage(pixs, 1, 100, 1, &pixd, NULL, 1);
pixDisplay(pixd, 100, 100);
} else { /* Break down into multiple steps; require min of only 6 lines */
dewa = dewarpaCreate(40, 30, 1, 6, 50);
dewarpaUseBothArrays(dewa, 1);
#if NORMALIZE
/* Normalize for varying background and binarize */
pixn = pixBackgroundNormSimple(pixs, NULL, NULL);
pixg = pixConvertRGBToGray(pixn, 0.5, 0.3, 0.2);
pixb = pixThresholdToBinary(pixg, 130);
pixDestroy(&pixn);
#else
/* Don't normalize; just threshold and clean edges */
pixg = pixConvertTo8(pixs, 0);
pixb = pixThresholdToBinary(pixg, 100);
pixSetOrClearBorder(pixb, 30, 30, 40, 40, PIX_CLR);
#endif
/* Run the basic functions */
dew1 = dewarpCreate(pixb, pageno);
dewarpaInsertDewarp(dewa, dew1);
dewarpBuildPageModel(dew1, "/tmp/lept/test2_model.pdf");
dewarpaApplyDisparity(dewa, pageno, pixg, -1, 0, 0, &pixd,
"/tmp/lept/test2_apply.pdf");
dewarpaInfo(stderr, dewa);
dewarpaDestroy(&dewa);
pixDestroy(&pixg);
pixDestroy(&pixb);
}
pixDestroy(&pixs);
pixDestroy(&pixd);
return 0;
}
l_int32 main(int argc,
char **argv)
{
char buf[64];
BOXA *boxa1, *boxa2, *boxa3, *boxa4;
L_DEWARP *dew;
L_DEWARPA *dewa;
PIX *pixs, *pixn, *pixg, *pixb, *pix2, *pix3, *pix4, *pix5, *pix6;
lept_mkdir("lept");
snprintf(buf, sizeof(buf), "cat.%03d.jpg", pageno);
pixs = pixRead(buf);
dewa = dewarpaCreate(40, 30, 1, 15, 10);
dewarpaUseBothArrays(dewa, 1);
/* Normalize for varying background and binarize */
pixn = pixBackgroundNormSimple(pixs, NULL, NULL);
pixg = pixConvertRGBToGray(pixn, 0.5, 0.3, 0.2);
pixb = pixThresholdToBinary(pixg, 130);
pixDisplay(pixb, 0, 100);
/* Build the model */
dew = dewarpCreate(pixb, pageno);
dewarpaInsertDewarp(dewa, dew);
if (build_output) {
snprintf(buf, sizeof(buf), "/tmp/lept/dewarp_build_%d.pdf", pageno);
dewarpBuildPageModel(dew, buf);
} else {
dewarpBuildPageModel(dew, NULL);
}
/* Apply the model */
dewarpPopulateFullRes(dew, pixg, 0, 0);
if (apply_output) {
snprintf(buf, sizeof(buf), "/tmp/lept/dewarp_apply_%d.pdf", pageno);
dewarpaApplyDisparity(dewa, pageno, pixb, 200, 0, 0, &pix2, buf);
} else {
dewarpaApplyDisparity(dewa, pageno, pixb, 200, 0, 0, &pix2, NULL);
}
pixDisplay(pix2, 200, 100);
/* Reverse direction: get the word boxes for the dewarped pix ... */
pixGetWordBoxesInTextlines(pix2, 5, 5, 500, 100, &boxa1, NULL);
pix3 = pixConvertTo32(pix2);
pixRenderBoxaArb(pix3, boxa1, 2, 255, 0, 0);
pixDisplay(pix3, 400, 100);
/* ... and map to the word boxes for the input image */
if (map_output) {
snprintf(buf, sizeof(buf), "/tmp/lept/dewarp_map1_%d.pdf", pageno);
dewarpaApplyDisparityBoxa(dewa, pageno, pix2, boxa1, 0, 0, 0, &boxa2,
buf);
} else {
dewarpaApplyDisparityBoxa(dewa, pageno, pix2, boxa1, 0, 0, 0, &boxa2,
NULL);
}
pix4 = pixConvertTo32(pixb);
pixRenderBoxaArb(pix4, boxa2, 2, 0, 255, 0);
pixDisplay(pix4, 600, 100);
/* Forward direction: get the word boxes for the input pix ... */
pixGetWordBoxesInTextlines(pixb, 5, 5, 500, 100, &boxa3, NULL);
pix5 = pixConvertTo32(pixb);
pixRenderBoxaArb(pix5, boxa3, 2, 255, 0, 0);
pixDisplay(pix5, 800, 100);
/* ... and map to the word boxes for the dewarped image */
if (map_output) {
snprintf(buf, sizeof(buf), "/tmp/lept/dewarp_map2_%d.pdf", pageno);
dewarpaApplyDisparityBoxa(dewa, pageno, pixb, boxa3, 1, 0, 0, &boxa4,
buf);
} else {
dewarpaApplyDisparityBoxa(dewa, pageno, pixb, boxa3, 1, 0, 0, &boxa4,
NULL);
}
pix6 = pixConvertTo32(pix2);
pixRenderBoxaArb(pix6, boxa4, 2, 0, 255, 0);
pixDisplay(pix6, 1000, 100);
dewarpaDestroy(&dewa);
pixDestroy(&pixs);
pixDestroy(&pixn);
pixDestroy(&pixg);
pixDestroy(&pixb);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
boxaDestroy(&boxa4);
return 0;
}
int main(int argc,
char **argv)
{
l_float32 sum, sumx, sumy, diff;
L_DEWARP *dew;
L_DEWARPA *dewa;
FPIX *fpixs, *fpixs2, *fpixs3, *fpixs4, *fpixg, *fpixd;
FPIX *fpix1, *fpix2, *fpixt1, *fpixt2;
DPIX *dpix, *dpix2;
L_KERNEL *kel, *kelx, *kely;
PIX *pixs, *pixs2, *pixs3, *pixt, *pixd, *pixg, *pixb, *pixn;
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6;
PIXA *pixa;
PTA *ptas, *ptad;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
pixa = pixaCreate(0);
/* Gaussian kernel */
kel = makeGaussianKernel(5, 5, 3.0, 4.0);
kernelGetSum(kel, &sum);
if (rp->display) fprintf(stderr, "Sum for 2d gaussian kernel = %f\n", sum);
pixt = kernelDisplayInPix(kel, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 0 */
pixSaveTiled(pixt, pixa, 1.0, 1, 20, 8);
pixDestroy(&pixt);
/* Separable gaussian kernel */
makeGaussianKernelSep(5, 5, 3.0, 4.0, &kelx, &kely);
kernelGetSum(kelx, &sumx);
if (rp->display) fprintf(stderr, "Sum for x gaussian kernel = %f\n", sumx);
kernelGetSum(kely, &sumy);
if (rp->display) fprintf(stderr, "Sum for y gaussian kernel = %f\n", sumy);
if (rp->display) fprintf(stderr, "Sum for x * y gaussian kernel = %f\n",
sumx * sumy);
pixt = kernelDisplayInPix(kelx, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 1 */
pixSaveTiled(pixt, pixa, 1.0, 0, 20, 8);
pixDestroy(&pixt);
pixt = kernelDisplayInPix(kely, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 2 */
pixSaveTiled(pixt, pixa, 1.0, 0, 20, 8);
pixDestroy(&pixt);
/* Use pixRasterop() to generate source image */
pixs = pixRead("test8.jpg");
pixs2 = pixRead("karen8.jpg");
pixRasterop(pixs, 150, 125, 150, 100, PIX_SRC, pixs2, 75, 100);
regTestWritePixAndCheck(rp, pixs, IFF_JFIF_JPEG); /* 3 */
/* Convolution directly with pix */
pixt1 = pixConvolve(pixs, kel, 8, 1);
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 4 */
pixSaveTiled(pixt1, pixa, 1.0, 1, 20, 8);
pixt2 = pixConvolveSep(pixs, kelx, kely, 8, 1);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 5 */
pixSaveTiled(pixt2, pixa, 1.0, 0, 20, 8);
/* Convolution indirectly with fpix, using fpixRasterop()
* to generate the source image. */
fpixs = pixConvertToFPix(pixs, 3);
fpixs2 = pixConvertToFPix(pixs2, 3);
fpixRasterop(fpixs, 150, 125, 150, 100, fpixs2, 75, 100);
fpixt1 = fpixConvolve(fpixs, kel, 1);
pixt3 = fpixConvertToPix(fpixt1, 8, L_CLIP_TO_ZERO, 1);
regTestWritePixAndCheck(rp, pixt3, IFF_JFIF_JPEG); /* 6 */
pixSaveTiled(pixt3, pixa, 1.0, 1, 20, 8);
fpixt2 = fpixConvolveSep(fpixs, kelx, kely, 1);
pixt4 = fpixConvertToPix(fpixt2, 8, L_CLIP_TO_ZERO, 1);
regTestWritePixAndCheck(rp, pixt4, IFF_JFIF_JPEG); /* 7 */
pixSaveTiled(pixt4, pixa, 1.0, 0, 20, 8);
pixDestroy(&pixs2);
fpixDestroy(&fpixs2);
fpixDestroy(&fpixt1);
fpixDestroy(&fpixt2);
/* Comparison of results */
pixCompareGray(pixt1, pixt2, L_COMPARE_ABS_DIFF, 0, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of pixConvolve and pixConvolveSep: %f\n",
diff);
pixCompareGray(pixt3, pixt4, L_COMPARE_ABS_DIFF, 0, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of fpixConvolve and fpixConvolveSep: %f\n",
diff);
pixCompareGray(pixt1, pixt3, L_COMPARE_ABS_DIFF, 0, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of pixConvolve and fpixConvolve: %f\n", diff);
pixCompareGray(pixt2, pixt4, L_COMPARE_ABS_DIFF, GPLOT_PNG, NULL,
&diff, NULL, NULL);
if (rp->display)
fprintf(stderr, "Ave diff of pixConvolveSep and fpixConvolveSep: %f\n",
diff);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
/* Test arithmetic operations; add in a fraction rotated by 180 */
pixs3 = pixRotate180(NULL, pixs);
regTestWritePixAndCheck(rp, pixs3, IFF_JFIF_JPEG); /* 8 */
pixSaveTiled(pixs3, pixa, 1.0, 1, 20, 8);
fpixs3 = pixConvertToFPix(pixs3, 3);
fpixd = fpixLinearCombination(NULL, fpixs, fpixs3, 20.0, 5.0);
fpixAddMultConstant(fpixd, 0.0, 23.174); /* multiply up in magnitude */
pixd = fpixDisplayMaxDynamicRange(fpixd); /* bring back to 8 bpp */
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 9 */
pixSaveTiled(pixd, pixa, 1.0, 0, 20, 8);
pixDestroy(&pixs3);
fpixDestroy(&fpixs3);
fpixDestroy(&fpixd);
pixDestroy(&pixd);
pixDestroy(&pixs);
fpixDestroy(&fpixs);
/* Save the comparison graph; gnuplot should have made it by now! */
#ifndef _WIN32
sleep(2);
#else
Sleep(2000);
#endif /* _WIN32 */
pixt5 = pixRead("/tmp/lept/compare_gray0.png");
regTestWritePixAndCheck(rp, pixt5, IFF_PNG); /* 10 */
pixSaveTiled(pixt5, pixa, 1.0, 1, 20, 8);
pixDestroy(&pixt5);
/* Display results */
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 11 */
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Test some more convolutions, with sampled output. First on pix */
pixa = pixaCreate(0);
pixs = pixRead("1555-7.jpg");
pixg = pixConvertTo8(pixs, 0);
l_setConvolveSampling(5, 5);
pixt1 = pixConvolve(pixg, kel, 8, 1);
regTestWritePixAndCheck(rp, pixt1, IFF_JFIF_JPEG); /* 12 */
pixSaveTiled(pixt1, pixa, 1.0, 1, 20, 32);
pixt2 = pixConvolveSep(pixg, kelx, kely, 8, 1);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 13 */
pixSaveTiled(pixt2, pixa, 1.0, 0, 20, 32);
pixt3 = pixConvolveRGB(pixs, kel);
regTestWritePixAndCheck(rp, pixt3, IFF_JFIF_JPEG); /* 14 */
pixSaveTiled(pixt3, pixa, 1.0, 0, 20, 32);
pixt4 = pixConvolveRGBSep(pixs, kelx, kely);
regTestWritePixAndCheck(rp, pixt4, IFF_JFIF_JPEG); /* 15 */
pixSaveTiled(pixt4, pixa, 1.0, 0, 20, 32);
/* Then on fpix */
fpixg = pixConvertToFPix(pixg, 1);
fpixt1 = fpixConvolve(fpixg, kel, 1);
pixt5 = fpixConvertToPix(fpixt1, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pixt5, IFF_JFIF_JPEG); /* 16 */
pixSaveTiled(pixt5, pixa, 1.0, 1, 20, 32);
fpixt2 = fpixConvolveSep(fpixg, kelx, kely, 1);
pixt6 = fpixConvertToPix(fpixt2, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pixt6, IFF_JFIF_JPEG); /* 17 */
pixSaveTiled(pixt2, pixa, 1.0, 0, 20, 32);
regTestCompareSimilarPix(rp, pixt1, pixt5, 2, 0.00, 0); /* 18 */
regTestCompareSimilarPix(rp, pixt2, pixt6, 2, 0.00, 0); /* 19 */
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
fpixDestroy(&fpixg);
fpixDestroy(&fpixt1);
fpixDestroy(&fpixt2);
pixd = pixaDisplay(pixa, 0, 0);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 20 */
pixDisplayWithTitle(pixd, 600, 100, NULL, rp->display);
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixd);
pixaDestroy(&pixa);
/* Test extension (continued and slope).
* First, build a smooth vertical disparity array;
* then extend and show the contours. */
pixs = pixRead("cat-35.jpg");
pixn = pixBackgroundNormSimple(pixs, NULL, NULL);
pixg = pixConvertRGBToGray(pixn, 0.5, 0.3, 0.2);
pixb = pixThresholdToBinary(pixg, 130);
dewa = dewarpaCreate(1, 30, 1, 15, 0);
if ((dew = dewarpCreate(pixb, 35)) == NULL) {
rp->success = FALSE;
L_ERROR("dew not made; tests 21-28 skipped (failed)\n", "fpix1_reg");
return regTestCleanup(rp);
}
dewarpaInsertDewarp(dewa, dew);
dewarpBuildPageModel(dew, NULL);
dewarpPopulateFullRes(dew, NULL, 0, 0);
fpixs = dew->fullvdispar;
fpixs2 = fpixAddContinuedBorder(fpixs, 200, 200, 100, 300);
fpixs3 = fpixAddSlopeBorder(fpixs, 200, 200, 100, 300);
dpix = fpixConvertToDPix(fpixs3);
fpixs4 = dpixConvertToFPix(dpix);
pixt1 = fpixRenderContours(fpixs, 2.0, 0.2);
pixt2 = fpixRenderContours(fpixs2, 2.0, 0.2);
pixt3 = fpixRenderContours(fpixs3, 2.0, 0.2);
pixt4 = fpixRenderContours(fpixs4, 2.0, 0.2);
pixt5 = pixRead("karen8.jpg");
dpix2 = pixConvertToDPix(pixt5, 1);
pixt6 = dpixConvertToPix(dpix2, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 21 */
pixDisplayWithTitle(pixt1, 0, 100, NULL, rp->display);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 22 */
pixDisplayWithTitle(pixt2, 470, 100, NULL, rp->display);
regTestWritePixAndCheck(rp, pixt3, IFF_PNG); /* 23 */
pixDisplayWithTitle(pixt3, 1035, 100, NULL, rp->display);
regTestComparePix(rp, pixt3, pixt4); /* 24 */
regTestComparePix(rp, pixt5, pixt6); /* 25 */
pixDestroy(&pixs);
pixDestroy(&pixn);
pixDestroy(&pixg);
pixDestroy(&pixb);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
fpixDestroy(&fpixs2);
fpixDestroy(&fpixs3);
fpixDestroy(&fpixs4);
dpixDestroy(&dpix);
dpixDestroy(&dpix2);
/* Test affine and projective transforms on fpix */
fpixWrite("/tmp/regout/fpix1.fp", dew->fullvdispar);
fpix1 = fpixRead("/tmp/regout/fpix1.fp");
pixt1 = fpixAutoRenderContours(fpix1, 40);
regTestWritePixAndCheck(rp, pixt1, IFF_PNG); /* 26 */
pixDisplayWithTitle(pixt1, 0, 500, NULL, rp->display);
pixDestroy(&pixt1);
MakePtasAffine(1, &ptas, &ptad);
fpix2 = fpixAffinePta(fpix1, ptad, ptas, 200, 0.0);
pixt2 = fpixAutoRenderContours(fpix2, 40);
regTestWritePixAndCheck(rp, pixt2, IFF_PNG); /* 27 */
pixDisplayWithTitle(pixt2, 400, 500, NULL, rp->display);
fpixDestroy(&fpix2);
pixDestroy(&pixt2);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
MakePtas(1, &ptas, &ptad);
fpix2 = fpixProjectivePta(fpix1, ptad, ptas, 200, 0.0);
pixt3 = fpixAutoRenderContours(fpix2, 40);
regTestWritePixAndCheck(rp, pixt3, IFF_PNG); /* 28 */
pixDisplayWithTitle(pixt3, 400, 500, NULL, rp->display);
fpixDestroy(&fpix2);
pixDestroy(&pixt3);
ptaDestroy(&ptas);
ptaDestroy(&ptad);
fpixDestroy(&fpix1);
dewarpaDestroy(&dewa);
kernelDestroy(&kel);
kernelDestroy(&kelx);
kernelDestroy(&kely);
return regTestCleanup(rp);
}
l_int32 main(int argc,
char **argv)
{
L_DEWARP *dew1, *dew2, *dew3;
L_DEWARPA *dewa1, *dewa2, *dewa3;
PIX *pixs, *pixn, *pixg, *pixb, *pixd;
PIX *pixs2, *pixn2, *pixg2, *pixb2, *pixd2;
PIX *pixd3, *pixc1, *pixc2;
/* pixs = pixRead("1555-7.jpg"); */
pixs = pixRead("cat-35.jpg");
dewa1 = dewarpaCreate(40, 30, 1, 15, 10);
dewarpaUseBothArrays(dewa1, 1);
/* Normalize for varying background and binarize */
pixn = pixBackgroundNormSimple(pixs, NULL, NULL);
pixg = pixConvertRGBToGray(pixn, 0.5, 0.3, 0.2);
pixb = pixThresholdToBinary(pixg, 130);
/* Run the basic functions */
dew1 = dewarpCreate(pixb, 35);
dewarpaInsertDewarp(dewa1, dew1);
dewarpBuildPageModel(dew1, "/tmp/dewarp_junk35.pdf"); /* debug output */
dewarpPopulateFullRes(dew1, pixg, 0, 0);
dewarpaApplyDisparity(dewa1, 35, pixg, 200, 0, 0, &pixd,
"/tmp/dewarp_debug_35.pdf");
/* Normalize another image. */
/* pixs2 = pixRead("1555-3.jpg"); */
pixs2 = pixRead("cat-7.jpg");
pixn2 = pixBackgroundNormSimple(pixs2, NULL, NULL);
pixg2 = pixConvertRGBToGray(pixn2, 0.5, 0.3, 0.2);
pixb2 = pixThresholdToBinary(pixg2, 130);
/* Run the basic functions */
dew2 = dewarpCreate(pixb2, 7);
dewarpaInsertDewarp(dewa1, dew2);
dewarpBuildPageModel(dew2, "/tmp/dewarp_junk7.pdf");
dewarpaApplyDisparity(dewa1, 7, pixg, 200, 0, 0, &pixd2,
"/tmp/dewarp_debug_7.pdf");
/* Serialize and deserialize dewarpa */
dewarpaWrite("/tmp/dewarpa1.dewa", dewa1);
dewa2 = dewarpaRead("/tmp/dewarpa1.dewa");
dewarpaWrite("/tmp/dewarpa2.dewa", dewa2);
dewa3 = dewarpaRead("/tmp/dewarpa2.dewa");
dewarpDebug(dewa3->dewarp[7], "dew1", 7);
dewarpaWrite("/tmp/dewarpa3.dewa", dewa3);
/* Repopulate and show the vertical disparity arrays */
dewarpPopulateFullRes(dew1, NULL, 0, 0);
pixc1 = fpixRenderContours(dew1->fullvdispar, 2.0, 0.2);
pixDisplay(pixc1, 1400, 900);
dew3 = dewarpaGetDewarp(dewa2, 35);
dewarpPopulateFullRes(dew3, pixs, 0, 0);
pixc2 = fpixRenderContours(dew3->fullvdispar, 2.0, 0.2);
pixDisplay(pixc2, 1400, 900);
dewarpaApplyDisparity(dewa2, 35, pixb, 200, 0, 0, &pixd3,
"/tmp/dewarp_debug_35b.pdf");
pixDisplay(pixd, 0, 1000);
pixDisplay(pixd2, 600, 1000);
pixDisplay(pixd3, 1200, 1000);
pixDestroy(&pixd3);
dewarpaDestroy(&dewa1);
dewarpaDestroy(&dewa2);
dewarpaDestroy(&dewa3);
pixDestroy(&pixs);
pixDestroy(&pixn);
pixDestroy(&pixg);
pixDestroy(&pixb);
pixDestroy(&pixd);
pixDestroy(&pixs2);
pixDestroy(&pixn2);
pixDestroy(&pixg2);
pixDestroy(&pixb2);
pixDestroy(&pixd2);
pixDestroy(&pixc1);
pixDestroy(&pixc2);
return 0;
}