Skip to content

Commit

Permalink
Fix some regtest issues (thanks to Pierre Benoit)
Browse files Browse the repository at this point in the history 
* In fpix1_reg.c, do not generate gplot.  This displays the generated plot.
* In kernel_reg.c, do not attempt to use the plot data previously made
  by fpix1_reg.c.  Also use more standard pix variable names.
* In numa3_reg.c, write data to the correct directory (/tmp/lept/numa3).
* also add comment in pdfio1.c on choosing a default encoding.
  • Loading branch information
@DanBloomberg
DanBloomberg committed Aug 17, 2023
1 parent 6c15bd5 commit fd5da1c
Show file tree
Hide file tree
Showing 4 changed files with 109 additions and 117 deletions.
48 changes: 21 additions & 27 deletions prog/fpix1_reg.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -158,27 +158,21 @@ L_REGPARAMS *rp;
&diff, NULL, NULL);
lept_stderr("Ave diff of pixConvolve and fpixConvolve: %f\n", diff);
}
pixCompareGray(pix2, pix4, L_COMPARE_ABS_DIFF, GPLOT_PNG, NULL,
&diff, NULL, NULL);
lept_stderr("Ave diff of pixConvolveSep and fpixConvolveSep: %f\n", diff);
pix5 = pixRead("/tmp/lept/comp/compare_gray0.png");
regTestWritePixAndCheck(rp, pix5, IFF_PNG); /* 9 */
pixaAddPix(pixa, pix5, L_INSERT);
pix1 = pixaDisplayTiledInColumns(pixa, 2, 1.0, 20, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 10 */
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 9 */
pixaDestroy(&pixa);
pixDestroy(&pix1);

/* Test arithmetic operations; add in a fraction rotated by 180 */
pixa = pixaCreate(0);
pixs3 = pixRotate180(NULL, pixs);
regTestWritePixAndCheck(rp, pixs3, IFF_JFIF_JPEG); /* 11 */
regTestWritePixAndCheck(rp, pixs3, IFF_JFIF_JPEG); /* 10 */
pixaAddPix(pixa, pixs3, L_INSERT);
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); /* 12 */
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 11 */
pixaAddPix(pixa, pixd, L_INSERT);
fpixDestroy(&fpixs3);
fpixDestroy(&fpixd);
Expand All @@ -187,7 +181,7 @@ L_REGPARAMS *rp;

/* Display results */
pixd = pixaDisplayTiledInColumns(pixa, 2, 1.0, 20, 2);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 13 */
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 12 */
pixDisplayWithTitle(pixd, 100, 100, NULL, rp->display);
pixDestroy(&pixd);
pixaDestroy(&pixa);
Expand All @@ -198,36 +192,36 @@ L_REGPARAMS *rp;
pixg = pixConvertTo8(pixs, 0);
l_setConvolveSampling(5, 5);
pix1 = pixConvolve(pixg, kel, 8, 1);
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 14 */
regTestWritePixAndCheck(rp, pix1, IFF_JFIF_JPEG); /* 13 */
pixaAddPix(pixa, pix1, L_INSERT);
pix2 = pixConvolveSep(pixg, kelx, kely, 8, 1);
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 15 */
regTestWritePixAndCheck(rp, pix2, IFF_JFIF_JPEG); /* 14 */
pixaAddPix(pixa, pix2, L_INSERT);
pix3 = pixConvolveRGB(pixs, kel);
regTestWritePixAndCheck(rp, pix3, IFF_JFIF_JPEG); /* 16 */
regTestWritePixAndCheck(rp, pix3, IFF_JFIF_JPEG); /* 15 */
pixaAddPix(pixa, pix3, L_INSERT);
pix4 = pixConvolveRGBSep(pixs, kelx, kely);
regTestWritePixAndCheck(rp, pix4, IFF_JFIF_JPEG); /* 17 */
regTestWritePixAndCheck(rp, pix4, IFF_JFIF_JPEG); /* 16 */
pixaAddPix(pixa, pix4, L_INSERT);

/* Then on fpix */
fpixg = pixConvertToFPix(pixg, 1);
fpix1 = fpixConvolve(fpixg, kel, 1);
pix5 = fpixConvertToPix(fpix1, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pix5, IFF_JFIF_JPEG); /* 18 */
regTestWritePixAndCheck(rp, pix5, IFF_JFIF_JPEG); /* 17 */
pixaAddPix(pixa, pix5, L_INSERT);
fpix2 = fpixConvolveSep(fpixg, kelx, kely, 1);
pix6 = fpixConvertToPix(fpix2, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pix6, IFF_JFIF_JPEG); /* 19 */
regTestWritePixAndCheck(rp, pix6, IFF_JFIF_JPEG); /* 18 */
pixaAddPix(pixa, pix6, L_INSERT);
regTestCompareSimilarPix(rp, pix1, pix5, 2, 0.00, 0); /* 20 */
regTestCompareSimilarPix(rp, pix2, pix6, 2, 0.00, 0); /* 21 */
regTestCompareSimilarPix(rp, pix1, pix5, 2, 0.00, 0); /* 19 */
regTestCompareSimilarPix(rp, pix2, pix6, 2, 0.00, 0); /* 20 */
fpixDestroy(&fpixg);
fpixDestroy(&fpix1);
fpixDestroy(&fpix2);

pixd = pixaDisplayTiledInColumns(pixa, 2, 1.0, 20, 2);
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 22 */
regTestWritePixAndCheck(rp, pixd, IFF_JFIF_JPEG); /* 21 */
pixDisplayWithTitle(pixd, 600, 100, NULL, rp->display);
pixDestroy(&pixs);
pixDestroy(&pixg);
Expand Down Expand Up @@ -262,14 +256,14 @@ L_REGPARAMS *rp;
pix5 = pixRead("karen8.jpg");
dpix2 = pixConvertToDPix(pix5, 1);
pix6 = dpixConvertToPix(dpix2, 8, L_CLIP_TO_ZERO, 0);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 23 */
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 22 */
pixDisplayWithTitle(pix1, 0, 100, NULL, rp->display);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 24 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 23 */
pixDisplayWithTitle(pix2, 470, 100, NULL, rp->display);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 25 */
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 24 */
pixDisplayWithTitle(pix3, 1035, 100, NULL, rp->display);
regTestComparePix(rp, pix3, pix4); /* 26 */
regTestComparePix(rp, pix5, pix6); /* 27 */
regTestComparePix(rp, pix3, pix4); /* 25 */
regTestComparePix(rp, pix5, pix6); /* 26 */
pixDestroy(&pixs);
pixDestroy(&pixn);
pixDestroy(&pixg);
Expand All @@ -290,14 +284,14 @@ L_REGPARAMS *rp;
fpixWrite("/tmp/lept/regout/fpix1.fp", dew->fullvdispar);
fpix1 = fpixRead("/tmp/lept/regout/fpix1.fp");
pix1 = fpixAutoRenderContours(fpix1, 40);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 28 */
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 27 */
pixDisplayWithTitle(pix1, 0, 500, NULL, rp->display);
pixDestroy(&pix1);

MakePtasAffine(1, &ptas, &ptad);
fpix2 = fpixAffinePta(fpix1, ptad, ptas, 200, 0.0);
pix2 = fpixAutoRenderContours(fpix2, 40);
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 29 */
regTestWritePixAndCheck(rp, pix2, IFF_PNG); /* 28 */
pixDisplayWithTitle(pix2, 400, 500, NULL, rp->display);
fpixDestroy(&fpix2);
pixDestroy(&pix2);
Expand All @@ -307,7 +301,7 @@ L_REGPARAMS *rp;
MakePtas(1, &ptas, &ptad);
fpix2 = fpixProjectivePta(fpix1, ptad, ptas, 200, 0.0);
pix3 = fpixAutoRenderContours(fpix2, 40);
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 30 */
regTestWritePixAndCheck(rp, pix3, IFF_PNG); /* 29 */
pixDisplayWithTitle(pix3, 400, 500, NULL, rp->display);
fpixDestroy(&fpix1);
fpixDestroy(&fpix2);
Expand Down
151 changes: 73 additions & 78 deletions prog/kernel_reg.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -49,8 +49,7 @@ l_int32 i, j, same, ok, plottype;
l_float32 sum, avediff, rmsdiff;
L_KERNEL *kel1, *kel2, *kel3, *kel4, *kelx, *kely;
BOX *box;
PIX *pix, *pixs, *pixb, *pixg, *pixd, *pixp, *pixt;
PIX *pixt1, *pixt2, *pixt3;
PIX *pix, *pix1, *pix2, *pix3, *pixs, *pixb, *pixg, *pixd;
PIXA *pixa;
PIXAA *paa;
SARRAY *sa;
Expand Down Expand Up @@ -110,29 +109,29 @@ L_REGPARAMS *rp;
kernelDestroy(&kel2);

/* Test creating from a pix */
pixt = pixCreate(5, 3, 8);
pixSetPixel(pixt, 0, 0, 20);
pixSetPixel(pixt, 1, 0, 50);
pixSetPixel(pixt, 2, 0, 80);
pixSetPixel(pixt, 3, 0, 50);
pixSetPixel(pixt, 4, 0, 20);
pixSetPixel(pixt, 0, 1, 80);
pixSetPixel(pixt, 1, 1, 120);
pixSetPixel(pixt, 2, 1, 180);
pixSetPixel(pixt, 3, 1, 120);
pixSetPixel(pixt, 4, 1, 80);
pixSetPixel(pixt, 0, 0, 20);
pixSetPixel(pixt, 1, 2, 50);
pixSetPixel(pixt, 2, 2, 80);
pixSetPixel(pixt, 3, 2, 50);
pixSetPixel(pixt, 4, 2, 20);
kel3 = kernelCreateFromPix(pixt, 1, 2);
pix1 = pixCreate(5, 3, 8);
pixSetPixel(pix1, 0, 0, 20);
pixSetPixel(pix1, 1, 0, 50);
pixSetPixel(pix1, 2, 0, 80);
pixSetPixel(pix1, 3, 0, 50);
pixSetPixel(pix1, 4, 0, 20);
pixSetPixel(pix1, 0, 1, 80);
pixSetPixel(pix1, 1, 1, 120);
pixSetPixel(pix1, 2, 1, 180);
pixSetPixel(pix1, 3, 1, 120);
pixSetPixel(pix1, 4, 1, 80);
pixSetPixel(pix1, 0, 0, 20);
pixSetPixel(pix1, 1, 2, 50);
pixSetPixel(pix1, 2, 2, 80);
pixSetPixel(pix1, 3, 2, 50);
pixSetPixel(pix1, 4, 2, 20);
kel3 = kernelCreateFromPix(pix1, 1, 2);
pixd = kernelDisplayInPix(kel3, 41, 2);
pixWrite("/tmp/lept/regout/ker2.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/lept/regout/ker2.png"); /* 5 */
pixaAddPix(pixa, pixd, L_INSERT);
pixaaAddPixa(paa, pixa, L_INSERT);
pixDestroy(&pixt);
pixDestroy(&pix1);
kernelDestroy(&kel3);

/* Test convolution with kel1 */
Expand All @@ -159,30 +158,30 @@ L_REGPARAMS *rp;
pixaAddPix(pixa, pixd, L_COPY);
pixWrite("/tmp/lept/regout/ker4.png", pixd, IFF_PNG);
regTestCheckFile(rp, "/tmp/lept/regout/ker4.png"); /* 7 */
pixt = pixBlockconv(pixg, 5, 5);
pixaAddPix(pixa, pixt, L_COPY);
pixWrite("/tmp/lept/regout/ker5.png", pixt, IFF_PNG);
pix1 = pixBlockconv(pixg, 5, 5);
pixaAddPix(pixa, pix1, L_COPY);
pixWrite("/tmp/lept/regout/ker5.png", pix1, IFF_PNG);
regTestCheckFile(rp, "/tmp/lept/regout/ker5.png"); /* 8 */
if (rp->display)
pixCompareGray(pixd, pixt, L_COMPARE_ABS_DIFF, GPLOT_PNG, NULL,
pixCompareGray(pixd, pix1, L_COMPARE_ABS_DIFF, GPLOT_PNG, NULL,
NULL, NULL, NULL);
pixt2 = pixBlockconvTiled(pixg, 5, 5, 3, 6);
pixaAddPix(pixa, pixt2, L_INSERT);
pix2 = pixBlockconvTiled(pixg, 5, 5, 3, 6);
pixaAddPix(pixa, pix2, L_INSERT);
pixaaAddPixa(paa, pixa, L_INSERT);
pixWrite("/tmp/lept/regout/ker5a.png", pixt2, IFF_PNG);
pixWrite("/tmp/lept/regout/ker5a.png", pix2, IFF_PNG);
regTestCheckFile(rp, "/tmp/lept/regout/ker5a.png"); /* 9 */

ok = TRUE;
for (i = 1; i <= 7; i++) {
for (j = 1; j <= 7; j++) {
if (i == 1 && j == 1) continue;
pixt2 = pixBlockconvTiled(pixg, 5, 5, j, i);
pixEqual(pixt2, pixd, &same);
pix2 = pixBlockconvTiled(pixg, 5, 5, j, i);
pixEqual(pix2, pixd, &same);
if (!same) {
lept_stderr("Error for nx = %d, ny = %d\n", j, i);
ok = FALSE;
}
pixDestroy(&pixt2);
pixDestroy(&pix2);
}
}
if (ok)
Expand All @@ -193,7 +192,7 @@ L_REGPARAMS *rp;
pixDestroy(&pixs);
pixDestroy(&pixg);
pixDestroy(&pixd);
pixDestroy(&pixt);
pixDestroy(&pix1);
kernelDestroy(&kel2);

/* Do another flat rectangular test; this time with white at edge.
Expand All @@ -209,27 +208,23 @@ L_REGPARAMS *rp;
pixa = pixaCreate(0);
kel3 = makeFlatKernel(7, 7, 3, 3);
startTimer();
pixt = pixConvolve(pixs, kel3, 8, 1);
pix1 = pixConvolve(pixs, kel3, 8, 1);
lept_stderr("Generic convolution time: %5.3f sec\n", stopTimer());
pixaAddPix(pixa, pixt, L_INSERT);
pixWrite("/tmp/lept/regout/conv1.png", pixt, IFF_PNG);
pixaAddPix(pixa, pix1, L_INSERT);
pixWrite("/tmp/lept/regout/conv1.png", pix1, IFF_PNG);
regTestCheckFile(rp, "/tmp/lept/regout/conv1.png"); /* 10 */

startTimer();
pixt2 = pixBlockconv(pixs, 3, 3);
pix2 = pixBlockconv(pixs, 3, 3);
lept_stderr("Flat block convolution time: %5.3f sec\n", stopTimer());
pixaAddPix(pixa, pixt2, L_INSERT);
pixWrite("/tmp/lept/regout/conv2.png", pixt2, IFF_PNG); /* ditto */
pixaAddPix(pixa, pix2, L_INSERT);
pixWrite("/tmp/lept/regout/conv2.png", pix2, IFF_PNG); /* ditto */
regTestCheckFile(rp, "/tmp/lept/regout/conv2.png"); /* 11 */

plottype = (rp->display) ? GPLOT_PNG : 0;
pixCompareGray(pixt, pixt2, L_COMPARE_ABS_DIFF, plottype, NULL,
pixCompareGray(pix1, pix2, L_COMPARE_ABS_DIFF, plottype, NULL,
&avediff, &rmsdiff, NULL);
pixp = pixRead("/tmp/lept/comp/compare_gray0.png");
pixaAddPix(pixa, pixp, L_INSERT);
pixaaAddPixa(paa, pixa, L_INSERT);
pixWrite("/tmp/lept/regout/conv3.png", pixp, IFF_PNG);
regTestCheckFile(rp, "/tmp/lept/regout/conv3.png"); /* 12 */
lept_stderr("Ave diff = %6.4f, RMS diff = %6.4f\n", avediff, rmsdiff);
if (avediff <= 0.01)
lept_stderr("OK: avediff = %6.4f <= 0.01\n", avediff);
Expand All @@ -247,31 +242,31 @@ L_REGPARAMS *rp;
pixs = pixRead("test24.jpg");
kel4 = makeFlatKernel(7, 7, 3, 3);
startTimer();
pixt1 = pixConvolveRGB(pixs, kel4);
pix1 = pixConvolveRGB(pixs, kel4);
lept_stderr("Time 7x7 non-separable: %7.3f sec\n", stopTimer());
pixWrite("/tmp/lept/regout/conv4.jpg", pixt1, IFF_JFIF_JPEG);
pixWrite("/tmp/lept/regout/conv4.jpg", pix1, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/lept/regout/conv4.jpg"); /* 13 */

kelx = makeFlatKernel(1, 7, 0, 3);
kely = makeFlatKernel(7, 1, 3, 0);
startTimer();
pixt2 = pixConvolveRGBSep(pixs, kelx, kely);
pix2 = pixConvolveRGBSep(pixs, kelx, kely);
lept_stderr("Time 7x1,1x7 separable: %7.3f sec\n", stopTimer());
pixWrite("/tmp/lept/regout/conv5.jpg", pixt2, IFF_JFIF_JPEG);
pixWrite("/tmp/lept/regout/conv5.jpg", pix2, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/lept/regout/conv5.jpg"); /* 14 */

startTimer();
pixt3 = pixBlockconv(pixs, 3, 3);
pix3 = pixBlockconv(pixs, 3, 3);
lept_stderr("Time 7x7 blockconv: %7.3f sec\n", stopTimer());
pixWrite("/tmp/lept/regout/conv6.jpg", pixt3, IFF_JFIF_JPEG);
pixWrite("/tmp/lept/regout/conv6.jpg", pix3, IFF_JFIF_JPEG);
regTestCheckFile(rp, "/tmp/lept/regout/conv6.jpg"); /* 15 */
regTestComparePix(rp, pixt1, pixt2); /* 16 */
regTestCompareSimilarPix(rp, pixt2, pixt3, 15, 0.0005, 0); /* 17 */
regTestComparePix(rp, pix1, pix2); /* 16 */
regTestCompareSimilarPix(rp, pix2, pix3, 15, 0.0005, 0); /* 17 */

pixDestroy(&pixs);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
kernelDestroy(&kel4);
kernelDestroy(&kelx);
kernelDestroy(&kely);
Expand All @@ -284,15 +279,15 @@ L_REGPARAMS *rp;
kernelGetSum(kel1, &sum);
lept_stderr("Sum for gaussian kernel = %f\n", sum);
kernelWrite("/tmp/lept/regout/gauss.kel", kel1);
pixt = pixConvolve(pixs, kel1, 8, 1);
pixt2 = pixConvolve(pixs, kel1, 16, 0);
pixaAddPix(pixa, pixt, L_INSERT);
pixaAddPix(pixa, pixt2, L_INSERT);
pixWrite("/tmp/lept/regout/ker6.png", pixt, IFF_PNG);
pix1 = pixConvolve(pixs, kel1, 8, 1);
pix2 = pixConvolve(pixs, kel1, 16, 0);
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
pixWrite("/tmp/lept/regout/ker6.png", pix1, IFF_PNG);
regTestCheckFile(rp, "/tmp/lept/regout/ker6.png"); /* 18 */

pixt = kernelDisplayInPix(kel1, 25, 2);
pixaAddPix(pixa, pixt, L_INSERT);
pix1 = kernelDisplayInPix(kel1, 25, 2);
pixaAddPix(pixa, pix1, L_INSERT);
pixaaAddPixa(paa, pixa, L_INSERT);
kernelDestroy(&kel1);
pixDestroy(&pixs);
Expand All @@ -309,40 +304,40 @@ L_REGPARAMS *rp;
kernelWrite("/tmp/lept/regout/gauss.kelx", kelx);
kernelWrite("/tmp/lept/regout/gauss.kely", kely);

pixt = pixConvolveSep(pixs, kelx, kely, 8, 1);
pixt2 = pixConvolveSep(pixs, kelx, kely, 16, 0);
pixaAddPix(pixa, pixt, L_INSERT);
pixaAddPix(pixa, pixt2, L_INSERT);
pixWrite("/tmp/lept/regout/ker7.png", pixt, IFF_PNG);
pix1 = pixConvolveSep(pixs, kelx, kely, 8, 1);
pix2 = pixConvolveSep(pixs, kelx, kely, 16, 0);
pixaAddPix(pixa, pix1, L_INSERT);
pixaAddPix(pixa, pix2, L_INSERT);
pixWrite("/tmp/lept/regout/ker7.png", pix1, IFF_PNG);
regTestCheckFile(rp, "/tmp/lept/regout/ker7.png"); /* 19 */

pixt = kernelDisplayInPix(kelx, 25, 2);
pixaAddPix(pixa, pixt, L_INSERT);
pixt = kernelDisplayInPix(kely, 25, 2);
pixaAddPix(pixa, pixt, L_INSERT);
pix1 = kernelDisplayInPix(kelx, 25, 2);
pixaAddPix(pixa, pix1, L_INSERT);
pix1 = kernelDisplayInPix(kely, 25, 2);
pixaAddPix(pixa, pix1, L_INSERT);
pixaaAddPixa(paa, pixa, L_INSERT);
kernelDestroy(&kelx);
kernelDestroy(&kely);

/* Test generation and convolution with diff of gaussians kernel */
/* pixt = pixRead("marge.jpg");
pixs = pixConvertRGBToLuminance(pixt);
pixDestroy(&pixt); */
/* pix1 = pixRead("marge.jpg");
pixs = pixConvertRGBToLuminance(pix1);
pixDestroy(&pix1); */
pixa = pixaCreate(0);
pixs = pixRead("test8.jpg");
pixaAddPix(pixa, pixs, L_INSERT);
kel1 = makeDoGKernel(7, 7, 1.5, 2.7);
kernelGetSum(kel1, &sum);
lept_stderr("Sum for DoG kernel = %f\n", sum);
kernelWrite("/tmp/lept/regout/dog.kel", kel1);
pixt = pixConvolve(pixs, kel1, 8, 0);
/* pixInvert(pixt, pixt); */
pixaAddPix(pixa, pixt, L_INSERT);
pixWrite("/tmp/lept/regout/ker8.png", pixt, IFF_PNG);
pix1 = pixConvolve(pixs, kel1, 8, 0);
/* pixInvert(pix1, pix1); */
pixaAddPix(pixa, pix1, L_INSERT);
pixWrite("/tmp/lept/regout/ker8.png", pix1, IFF_PNG);
regTestCheckFile(rp, "/tmp/lept/regout/ker8.png"); /* 20 */

pixt = kernelDisplayInPix(kel1, 20, 2);
pixaAddPix(pixa, pixt, L_INSERT);
pix1 = kernelDisplayInPix(kel1, 20, 2);
pixaAddPix(pixa, pix1, L_INSERT);
pixaaAddPixa(paa, pixa, L_INSERT);
kernelDestroy(&kel1);

Expand Down
Loading

0 comments on commit fd5da1c

Please sign in to comment.