/*!
* pixInverseDFT()
*
* Input: dft
* w, h (image size)
* shiftflag (L_NO_SHIFTING or L_WITH_SHIFTING)
* outflag (L_CLIP_TO_ZERO, L_TAKE_ABSVAL,
* L_THRESH_NEG_TO_BLACK or L_THRESH_NEG_TO_WHITE)
* Return: pixd (8bpp), or null on error
*
* Notes:
* (1) Set @shiftflag to L_WITH_SHIFTING if the DC was moved to the
* center of the image during the DFT computation. Reshifting it
* will move the DC back to the top left corner (0, 0).
* (2) It is the responsibility of the caller to release the allocated
* complex array by invoking fftw_free().
*/
PIX *
pixInverseDFT(fftw_complex *dft,
l_int32 w,
l_int32 h,
l_int32 shiftflag,
l_int32 outflag)
{
PIX *pixd;
DPIX *dpix;
PROCNAME("pixInverseDFT");
dpix = dpixInverseDFT(dft, w, h);
/* Convert DPix to a Pix */
pixd = dpixConvertToPix(dpix, 8, outflag, 0, shiftflag);
dpixDestroy(&dpix);
return pixd;
}
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, 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, 20, 8);
pixDestroy(&pixt);
pixt = kernelDisplayInPix(kely, 41, 2);
regTestWritePixAndCheck(rp, pixt, IFF_PNG); /* 2 */
pixSaveTiled(pixt, pixa, 1, 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, 1, 20, 8);
pixt2 = pixConvolveSep(pixs, kelx, kely, 8, 1);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 5 */
pixSaveTiled(pixt2, pixa, 1, 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, 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, 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, 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, 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/grayroot.png");
regTestWritePixAndCheck(rp, pixt5, IFF_PNG); /* 10 */
pixSaveTiled(pixt5, pixa, 1, 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, 1, 20, 32);
pixt2 = pixConvolveSep(pixg, kelx, kely, 8, 1);
regTestWritePixAndCheck(rp, pixt2, IFF_JFIF_JPEG); /* 13 */
pixSaveTiled(pixt2, pixa, 1, 0, 20, 32);
pixt3 = pixConvolveRGB(pixs, kel);
regTestWritePixAndCheck(rp, pixt3, IFF_JFIF_JPEG); /* 14 */
pixSaveTiled(pixt3, pixa, 1, 0, 20, 32);
pixt4 = pixConvolveRGBSep(pixs, kelx, kely);
regTestWritePixAndCheck(rp, pixt4, IFF_JFIF_JPEG); /* 15 */
pixSaveTiled(pixt4, pixa, 1, 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, 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, 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);
dew = dewarpCreate(pixb, 35);
dewarpaInsertDewarp(dewa, dew);
dewarpBuildModel(dew, NULL);
dewarpPopulateFullRes(dew, NULL);
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/fpix1.fp", dew->fullvdispar);
fpix1 = fpixRead("/tmp/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);
}
