/*!
* selaAddDwaCombs()
*
* Input: sela (<optional>)
* Return: sela with additional sels, or null on error
*
* Notes:
* (1) Adds all comb (horizontal, vertical) Sels that are
* used in composite linear morphological operations
* up to 63 pixels in length, which are the sizes over
* which dwa code can be generated.
*/
SELA *
selaAddDwaCombs(SELA *sela)
{
char name[L_BUF_SIZE];
l_int32 i, f1, f2, prevsize, size;
SEL *selh, *selv;
PROCNAME("selaAddDwaCombs");
if (!sela) {
if ((sela = selaCreate(0)) == NULL)
return (SELA *)ERROR_PTR("sela not made", procName, NULL);
}
prevsize = 0;
for (i = 4; i < 64; i++) {
selectComposableSizes(i, &f1, &f2);
size = f1 * f2;
if (size == prevsize)
continue;
selectComposableSels(i, L_HORIZ, NULL, &selh);
selectComposableSels(i, L_VERT, NULL, &selv);
snprintf(name, L_BUF_SIZE, "sel_comb_%dh", size);
selaAddSel(sela, selh, name, 0);
snprintf(name, L_BUF_SIZE, "sel_comb_%dv", size);
selaAddSel(sela, selv, name, 0);
prevsize = size;
}
return sela;
}
main(int argc,
char **argv)
{
char *str;
char buffer1[256];
char buffer2[256];
l_int32 i, same, same2, factor1, factor2, diff, success;
PIX *pixs, *pixsd, *pixt1, *pixt2, *pixt3;
SEL *sel1, *sel2;
static char mainName[] = "binmorph2_reg";
#if 1
pixs = pixRead("rabi.png");
pixsd = pixMorphCompSequence(pixs, "d5.5", 0);
success = TRUE;
for (i = 1; i < MAX_SEL_SIZE; i++) {
/* Check if the size is exactly decomposable */
selectComposableSizes(i, &factor1, &factor2);
diff = factor1 * factor2 - i;
fprintf(stderr, "%d: (%d, %d): %d\n", i, factor1, factor2, diff);
/* Carry out operations on identical sized Sels: dilation */
sprintf(buffer1, "d%d.%d", i + diff, i + diff);
sprintf(buffer2, "d%d.%d", i, i);
pixt1 = pixMorphSequence(pixsd, buffer1, 0);
pixt2 = pixMorphCompSequence(pixsd, buffer2, 0);
pixEqual(pixt1, pixt2, &same);
if (i < 64) {
pixt3 = pixMorphCompSequenceDwa(pixsd, buffer2, 0);
pixEqual(pixt1, pixt3, &same2);
} else {
pixt3 = NULL;
same2 = TRUE;
}
if (same && same2)
writeResult(buffer1, 1);
else {
writeResult(buffer1, 0);
success = FALSE;
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
/* ... erosion */
sprintf(buffer1, "e%d.%d", i + diff, i + diff);
sprintf(buffer2, "e%d.%d", i, i);
pixt1 = pixMorphSequence(pixsd, buffer1, 0);
pixt2 = pixMorphCompSequence(pixsd, buffer2, 0);
pixEqual(pixt1, pixt2, &same);
if (i < 64) {
pixt3 = pixMorphCompSequenceDwa(pixsd, buffer2, 0);
pixEqual(pixt1, pixt3, &same2);
} else {
pixt3 = NULL;
same2 = TRUE;
}
if (same && same2)
writeResult(buffer1, 1);
else {
writeResult(buffer1, 0);
success = FALSE;
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
/* ... opening */
sprintf(buffer1, "o%d.%d", i + diff, i + diff);
sprintf(buffer2, "o%d.%d", i, i);
pixt1 = pixMorphSequence(pixsd, buffer1, 0);
pixt2 = pixMorphCompSequence(pixsd, buffer2, 0);
pixEqual(pixt1, pixt2, &same);
if (i < 64) {
pixt3 = pixMorphCompSequenceDwa(pixsd, buffer2, 0);
pixEqual(pixt1, pixt3, &same2);
} else {
pixt3 = NULL;
same2 = TRUE;
}
if (same && same2)
writeResult(buffer1, 1);
else {
writeResult(buffer1, 0);
success = FALSE;
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
/* ... closing */
sprintf(buffer1, "c%d.%d", i + diff, i + diff);
sprintf(buffer2, "c%d.%d", i, i);
pixt1 = pixMorphSequence(pixsd, buffer1, 0);
pixt2 = pixMorphCompSequence(pixsd, buffer2, 0);
pixEqual(pixt1, pixt2, &same);
if (i < 64) {
pixt3 = pixMorphCompSequenceDwa(pixsd, buffer2, 0);
pixEqual(pixt1, pixt3, &same2);
} else {
pixt3 = NULL;
same2 = TRUE;
}
if (same && same2)
writeResult(buffer1, 1);
else {
writeResult(buffer1, 0);
success = FALSE;
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
}
pixDestroy(&pixs);
pixDestroy(&pixsd);
if (success)
fprintf(stderr, "\n---------- Success: no errors ----------\n");
else
fprintf(stderr, "\n---------- Failure: error(s) found -----------\n");
#endif
#if 0
for (i = 1; i < 400; i++) {
selectComposableSizes(i, &factor1, &factor2);
diff = factor1 * factor2 - i;
fprintf(stderr, "%d: (%d, %d): %d\n",
i, factor1, factor2, diff);
selectComposableSels(i, L_HORIZ, &sel1, &sel2);
selDestroy(&sel1);
selDestroy(&sel2);
}
#endif
#if 0
selectComposableSels(68, L_HORIZ, &sel1, &sel2); /* 17, 4 */
str = selPrintToString(sel2);
fprintf(stderr, str);
selDestroy(&sel1);
selDestroy(&sel2);
FREE(str);
selectComposableSels(70, L_HORIZ, &sel1, &sel2); /* 10, 7 */
str = selPrintToString(sel2);
selDestroy(&sel1);
selDestroy(&sel2);
fprintf(stderr, str);
FREE(str);
selectComposableSels(85, L_HORIZ, &sel1, &sel2); /* 17, 5 */
str = selPrintToString(sel2);
selDestroy(&sel1);
selDestroy(&sel2);
fprintf(stderr, str);
FREE(str);
selectComposableSels(96, L_HORIZ, &sel1, &sel2); /* 12, 8 */
str = selPrintToString(sel2);
selDestroy(&sel1);
selDestroy(&sel2);
fprintf(stderr, str);
FREE(str);
{ SELA *sela;
sela = selaAddBasic(NULL);
selaWrite("/tmp/junksela.sela", sela);
selaDestroy(&sela);
}
#endif
return 0;
}
void
TestAll(L_REGPARAMS *rp,
PIX *pixs,
l_int32 symmetric)
{
l_int32 i, n, rsize, fact1, fact2, extra;
l_int32 size, lastsize;
l_int32 dwasize[256];
l_int32 ropsize[256];
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
if (symmetric) {
/* This works properly with an added border of 128 */
resetMorphBoundaryCondition(SYMMETRIC_MORPH_BC);
pix1 = pixAddBorder(pixs, 128, 0);
pixTransferAllData(pixs, &pix1, 0, 0);
fprintf(stderr, "Testing with symmetric boundary conditions\n");
} else {
resetMorphBoundaryCondition(ASYMMETRIC_MORPH_BC);
fprintf(stderr, "Testing with asymmetric boundary conditions\n");
}
pix1 = pixCreateTemplateNoInit(pixs);
pix2 = pixCreateTemplateNoInit(pixs);
pix3 = pixCreateTemplateNoInit(pixs);
pix4 = pixCreateTemplateNoInit(pixs);
pix5 = pixCreateTemplateNoInit(pixs);
pix6 = pixCreateTemplateNoInit(pixs);
/* ---------------------------------------------------------------- *
* Faster test; testing fewer sizes *
* ---------------------------------------------------------------- */
#if FASTER_TEST
/* Compute the actual sizes used for each input size 'i' */
for (i = 0; i < 256; i++) {
dwasize[i] = 0;
ropsize[i] = 0;
}
for (i = 65; i < 256; i++) {
selectComposableSizes(i, &fact1, &fact2);
rsize = fact1 * fact2;
ropsize[i] = rsize;
getExtendedCompositeParameters(i, &n, &extra, &dwasize[i]);
}
/* Use only values where the resulting sizes are equal */
for (i = 65; i < 240; i++) {
n = 1 + (l_int32)((i - 63) / 62);
extra = i - 63 - (n - 1) * 62 + 1;
if (extra == 2) continue; /* don't use this one (e.g., i == 126) */
if (ropsize[i] == dwasize[i])
DoComparisonDwa1(rp, pixs, pix1, pix2, pix3, pix4, pix5, pix6, i);
}
#endif /* FASTER_TEST */
/* ---------------------------------------------------------------- *
* Slower test; testing maximum number of sizes *
* ---------------------------------------------------------------- */
#if SLOWER_TEST
lastsize = 0;
for (i = 65; i < 199; i++) {
getExtendedCompositeParameters(i, &n, &extra, &size);
if (size == lastsize) continue;
if (size == 126 || size == 188) continue; /* deliberately off by one */
lastsize = size;
DoComparisonDwa2(rp, pixs, pix1, pix2, pix3, pix4, pix5, pix6, size);
}
#endif /* SLOWER_TEST */
fprintf(stderr, "\n");
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
pixDestroy(&pix6);
}
l_int32
DoComparisonDwa1(L_REGPARAMS *rp,
PIX *pixs,
PIX *pix1,
PIX *pix2,
PIX *pix3,
PIX *pix4,
PIX *pix5,
PIX *pix6,
l_int32 isize)
{
l_int32 fact1, fact2, size;
selectComposableSizes(isize, &fact1, &fact2);
size = fact1 * fact2;
fprintf(stderr, "..%d..", size);
if (TIMING) startTimer();
pixDilateCompBrickExtendDwa(pix1, pixs, size, 1);
pixDilateCompBrickExtendDwa(pix3, pixs, 1, size);
pixDilateCompBrickExtendDwa(pix5, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Dwa: %7.3f sec\n", stopTimer());
if (TIMING) startTimer();
pixDilateCompBrick(pix2, pixs, size, 1);
pixDilateCompBrick(pix4, pixs, 1, size);
pixDilateCompBrick(pix6, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Rop: %7.3f sec\n", stopTimer());
PixCompareDwa(rp, size, "dilate", pix1, pix2, pix3, pix4, pix5, pix6);
if (TIMING) startTimer();
pixErodeCompBrickExtendDwa(pix1, pixs, size, 1);
pixErodeCompBrickExtendDwa(pix3, pixs, 1, size);
pixErodeCompBrickExtendDwa(pix5, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Dwa: %7.3f sec\n", stopTimer());
if (TIMING) startTimer();
pixErodeCompBrick(pix2, pixs, size, 1);
pixErodeCompBrick(pix4, pixs, 1, size);
pixErodeCompBrick(pix6, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Rop: %7.3f sec\n", stopTimer());
PixCompareDwa(rp, size, "erode", pix1, pix2, pix3, pix4, pix5, pix6);
if (TIMING) startTimer();
pixOpenCompBrickExtendDwa(pix1, pixs, size, 1);
pixOpenCompBrickExtendDwa(pix3, pixs, 1, size);
pixOpenCompBrickExtendDwa(pix5, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Dwa: %7.3f sec\n", stopTimer());
if (TIMING) startTimer();
pixOpenCompBrick(pix2, pixs, size, 1);
pixOpenCompBrick(pix4, pixs, 1, size);
pixOpenCompBrick(pix6, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Rop: %7.3f sec\n", stopTimer());
PixCompareDwa(rp, size, "open", pix1, pix2, pix3, pix4, pix5, pix6);
if (TIMING) startTimer();
pixCloseCompBrickExtendDwa(pix1, pixs, size, 1);
pixCloseCompBrickExtendDwa(pix3, pixs, 1, size);
pixCloseCompBrickExtendDwa(pix5, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Dwa: %7.3f sec\n", stopTimer());
if (TIMING) startTimer();
pixCloseSafeCompBrick(pix2, pixs, size, 1);
pixCloseSafeCompBrick(pix4, pixs, 1, size);
pixCloseSafeCompBrick(pix6, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Rop: %7.3f sec\n", stopTimer());
PixCompareDwa(rp, size, "close", pix1, pix2, pix3, pix4, pix5, pix6);
return 0;
}
int main(int argc,
char **argv) {
char buffer1[256];
char buffer2[256];
l_int32 i, same, same2, factor1, factor2, diff, success;
PIX *pixs, *pixsd, *pixt1, *pixt2, *pixt3;
static char mainName[] = "binmorph2_reg";
if (argc != 1)
return ERROR_INT(" Syntax: binmorph2_reg", mainName, 1);
pixs = pixRead("rabi.png");
pixsd = pixMorphCompSequence(pixs, "d5.5", 0);
success = TRUE;
for (i = 1; i < MAX_SEL_SIZE; i++) {
/* Check if the size is exactly decomposable */
selectComposableSizes(i, &factor1, &factor2);
diff = factor1 * factor2 - i;
fprintf(stderr, "%d: (%d, %d): %d\n", i, factor1, factor2, diff);
/* Carry out operations on identical sized Sels: dilation */
sprintf(buffer1, "d%d.%d", i + diff, i + diff);
sprintf(buffer2, "d%d.%d", i, i);
pixt1 = pixMorphSequence(pixsd, buffer1, 0);
pixt2 = pixMorphCompSequence(pixsd, buffer2, 0);
pixEqual(pixt1, pixt2, &same);
if (i < 64) {
pixt3 = pixMorphCompSequenceDwa(pixsd, buffer2, 0);
pixEqual(pixt1, pixt3, &same2);
} else {
pixt3 = NULL;
same2 = TRUE;
}
if (same && same2)
writeResult(buffer1, 1);
else {
writeResult(buffer1, 0);
success = FALSE;
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
/* ... erosion */
sprintf(buffer1, "e%d.%d", i + diff, i + diff);
sprintf(buffer2, "e%d.%d", i, i);
pixt1 = pixMorphSequence(pixsd, buffer1, 0);
pixt2 = pixMorphCompSequence(pixsd, buffer2, 0);
pixEqual(pixt1, pixt2, &same);
if (i < 64) {
pixt3 = pixMorphCompSequenceDwa(pixsd, buffer2, 0);
pixEqual(pixt1, pixt3, &same2);
} else {
pixt3 = NULL;
same2 = TRUE;
}
if (same && same2)
writeResult(buffer1, 1);
else {
writeResult(buffer1, 0);
success = FALSE;
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
/* ... opening */
sprintf(buffer1, "o%d.%d", i + diff, i + diff);
sprintf(buffer2, "o%d.%d", i, i);
pixt1 = pixMorphSequence(pixsd, buffer1, 0);
pixt2 = pixMorphCompSequence(pixsd, buffer2, 0);
pixEqual(pixt1, pixt2, &same);
if (i < 64) {
pixt3 = pixMorphCompSequenceDwa(pixsd, buffer2, 0);
pixEqual(pixt1, pixt3, &same2);
} else {
pixt3 = NULL;
same2 = TRUE;
}
if (same && same2)
writeResult(buffer1, 1);
else {
writeResult(buffer1, 0);
success = FALSE;
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
/* ... closing */
sprintf(buffer1, "c%d.%d", i + diff, i + diff);
sprintf(buffer2, "c%d.%d", i, i);
pixt1 = pixMorphSequence(pixsd, buffer1, 0);
pixt2 = pixMorphCompSequence(pixsd, buffer2, 0);
pixEqual(pixt1, pixt2, &same);
if (i < 64) {
pixt3 = pixMorphCompSequenceDwa(pixsd, buffer2, 0);
pixEqual(pixt1, pixt3, &same2);
} else {
pixt3 = NULL;
same2 = TRUE;
}
if (same && same2)
writeResult(buffer1, 1);
else {
writeResult(buffer1, 0);
success = FALSE;
}
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
}
pixDestroy(&pixs);
pixDestroy(&pixsd);
if (success)
fprintf(stderr, "\n---------- Success: no errors ----------\n");
else
fprintf(stderr, "\n---------- Failure: error(s) found -----------\n");
return 0;
}
main(int argc,
char **argv)
{
l_int32 i, n, rsize, fact1, fact2, extra;
l_int32 size, lastsize;
l_int32 dwasize[256];
l_int32 ropsize[256];
PIX *pixs, *pixt0, *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6;
static char mainName[] = "binmorph5_reg";
pixs = pixRead("feyn.tif");
#if TEST_SYMMETRIC
/* This works properly if there's an added border */
resetMorphBoundaryCondition(SYMMETRIC_MORPH_BC);
#if 1
pixt1 = pixAddBorder(pixs, 64, 0);
pixTransferAllData(pixs, &pixt1, 0, 0);
#endif
#endif /* TEST_SYMMETRIC */
pixt1 = pixCreateTemplateNoInit(pixs);
pixt2 = pixCreateTemplateNoInit(pixs);
pixt3 = pixCreateTemplateNoInit(pixs);
pixt4 = pixCreateTemplateNoInit(pixs);
pixt5 = pixCreateTemplateNoInit(pixs);
pixt6 = pixCreateTemplateNoInit(pixs);
/* ---------------------------------------------------------------- *
* Faster test; testing fewer sizes *
* ---------------------------------------------------------------- */
#if FASTER_TEST
/* Compute the actual sizes used for each input size 'i' */
for (i = 0; i < 256; i++) {
dwasize[i] = 0;
ropsize[i] = 0;
}
for (i = 65; i < 256; i++) {
selectComposableSizes(i, &fact1, &fact2);
rsize = fact1 * fact2;
ropsize[i] = rsize;
getExtendedCompositeParameters(i, &n, &extra, &dwasize[i]);
}
/* Use only values where the resulting sizes are equal */
for (i = 65; i < 240; i++) {
n = 1 + (l_int32)((i - 63) / 62);
extra = i - 63 - (n - 1) * 62 + 1;
if (extra == 2) continue; /* don't use this one (e.g., i == 126) */
if (ropsize[i] == dwasize[i])
DoComparisonDwa1(pixs, pixt1, pixt2, pixt3, pixt4,
pixt5, pixt6, i);
}
#endif /* FASTER_TEST */
/* ---------------------------------------------------------------- *
* Slower test; testing maximum number of sizes *
* ---------------------------------------------------------------- */
#if SLOWER_TEST
lastsize = 0;
for (i = 65; i < 199; i++) {
getExtendedCompositeParameters(i, &n, &extra, &size);
if (size == lastsize) continue;
if (size == 126 || size == 188) continue; /* deliberately off by one */
lastsize = size;
DoComparisonDwa2(pixs, pixt1, pixt2, pixt3, pixt4,
pixt5, pixt6, size);
}
#endif /* SLOWER_TEST */
pixDestroy(&pixs);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
return 0;
}
l_int32
DoComparisonDwa1(PIX *pixs,
PIX *pixt1,
PIX *pixt2,
PIX *pixt3,
PIX *pixt4,
PIX *pixt5,
PIX *pixt6,
l_int32 isize)
{
l_int32 fact1, fact2, size;
selectComposableSizes(isize, &fact1, &fact2);
size = fact1 * fact2;
fprintf(stderr, "..%d..", size);
if (TIMING) startTimer();
pixDilateCompBrickExtendDwa(pixt1, pixs, size, 1);
pixDilateCompBrickExtendDwa(pixt3, pixs, 1, size);
pixDilateCompBrickExtendDwa(pixt5, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Dwa: %7.3f sec\n", stopTimer());
if (TIMING) startTimer();
pixDilateCompBrick(pixt2, pixs, size, 1);
pixDilateCompBrick(pixt4, pixs, 1, size);
pixDilateCompBrick(pixt6, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Rop: %7.3f sec\n", stopTimer());
PixCompareDwa(size, "dilate", pixt1, pixt2, pixt3, pixt4, pixt5, pixt6);
if (TIMING) startTimer();
pixErodeCompBrickExtendDwa(pixt1, pixs, size, 1);
pixErodeCompBrickExtendDwa(pixt3, pixs, 1, size);
pixErodeCompBrickExtendDwa(pixt5, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Dwa: %7.3f sec\n", stopTimer());
if (TIMING) startTimer();
pixErodeCompBrick(pixt2, pixs, size, 1);
pixErodeCompBrick(pixt4, pixs, 1, size);
pixErodeCompBrick(pixt6, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Rop: %7.3f sec\n", stopTimer());
PixCompareDwa(size, "erode", pixt1, pixt2, pixt3, pixt4, pixt5, pixt6);
if (TIMING) startTimer();
pixOpenCompBrickExtendDwa(pixt1, pixs, size, 1);
pixOpenCompBrickExtendDwa(pixt3, pixs, 1, size);
pixOpenCompBrickExtendDwa(pixt5, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Dwa: %7.3f sec\n", stopTimer());
if (TIMING) startTimer();
pixOpenCompBrick(pixt2, pixs, size, 1);
pixOpenCompBrick(pixt4, pixs, 1, size);
pixOpenCompBrick(pixt6, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Rop: %7.3f sec\n", stopTimer());
PixCompareDwa(size, "open", pixt1, pixt2, pixt3, pixt4, pixt5, pixt6);
if (TIMING) startTimer();
pixCloseCompBrickExtendDwa(pixt1, pixs, size, 1);
pixCloseCompBrickExtendDwa(pixt3, pixs, 1, size);
pixCloseCompBrickExtendDwa(pixt5, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Dwa: %7.3f sec\n", stopTimer());
if (TIMING) startTimer();
pixCloseSafeCompBrick(pixt2, pixs, size, 1);
pixCloseSafeCompBrick(pixt4, pixs, 1, size);
pixCloseSafeCompBrick(pixt6, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Rop: %7.3f sec\n", stopTimer());
PixCompareDwa(size, "close", pixt1, pixt2, pixt3, pixt4, pixt5, pixt6);
#if 0
pixWrite("/tmp/junkpixt3.png", pixt3, IFF_PNG);
pixWrite("/tmp/junkpixt4.png", pixt4, IFF_PNG);
pixXor(pixt3, pixt3, pixt4);
pixWrite("/tmp/junkxor.png", pixt3, IFF_PNG);
#endif
return 0;
}
/* dwa composite with morph non-composite */
l_int32
DoComparisonDwa5(PIX *pixs,
PIX *pixt1,
PIX *pixt2,
PIX *pixt3,
PIX *pixt4,
PIX *pixt5,
PIX *pixt6,
l_int32 isize) {
l_int32 fact1, fact2, size;
selectComposableSizes(isize, &fact1, &fact2);
size = fact1 * fact2;
fprintf(stderr, "..%d..", size);
if (TIMING) startTimer();
pixDilateCompBrickDwa(pixt1, pixs, size, 1);
pixDilateCompBrickDwa(pixt3, pixs, 1, size);
pixDilateCompBrickDwa(pixt5, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Dwa: %7.3f sec\n", stopTimer());
if (TIMING) startTimer();
pixDilateBrick(pixt2, pixs, size, 1);
pixDilateBrick(pixt4, pixs, 1, size);
pixDilateBrick(pixt6, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Rop: %7.3f sec\n", stopTimer());
PixCompareDwa(size, "dilate", pixt1, pixt2, pixt3, pixt4, pixt5, pixt6);
/* pixDisplay(pixt1, 100, 100); */
/* pixDisplay(pixt2, 800, 100); */
if (TIMING) startTimer();
pixErodeCompBrickDwa(pixt1, pixs, size, 1);
pixErodeCompBrickDwa(pixt3, pixs, 1, size);
pixErodeCompBrickDwa(pixt5, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Dwa: %7.3f sec\n", stopTimer());
if (TIMING) startTimer();
pixErodeBrick(pixt2, pixs, size, 1);
pixErodeBrick(pixt4, pixs, 1, size);
pixErodeBrick(pixt6, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Rop: %7.3f sec\n", stopTimer());
PixCompareDwa(size, "erode", pixt1, pixt2, pixt3, pixt4, pixt5, pixt6);
if (TIMING) startTimer();
pixOpenCompBrickDwa(pixt1, pixs, size, 1);
pixOpenCompBrickDwa(pixt3, pixs, 1, size);
pixOpenCompBrickDwa(pixt5, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Dwa: %7.3f sec\n", stopTimer());
if (TIMING) startTimer();
pixOpenBrick(pixt2, pixs, size, 1);
pixOpenBrick(pixt4, pixs, 1, size);
pixOpenBrick(pixt6, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Rop: %7.3f sec\n", stopTimer());
PixCompareDwa(size, "open", pixt1, pixt2, pixt3, pixt4, pixt5, pixt6);
if (TIMING) startTimer();
pixCloseCompBrickDwa(pixt1, pixs, size, 1);
pixCloseCompBrickDwa(pixt3, pixs, 1, size);
pixCloseCompBrickDwa(pixt5, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Dwa: %7.3f sec\n", stopTimer());
if (TIMING) startTimer();
pixCloseSafeBrick(pixt2, pixs, size, 1);
pixCloseSafeBrick(pixt4, pixs, 1, size);
pixCloseSafeBrick(pixt6, pixs, size, size);
if (TIMING) fprintf(stderr, "Time Rop: %7.3f sec\n", stopTimer());
PixCompareDwa(size, "close", pixt1, pixt2, pixt3, pixt4, pixt5, pixt6);
return 0;
}