// Helper to remove an enclosing circle from an image.
// If there isn't one, then the image will most likely get badly mangled.
// The returned pix must be pixDestroyed after use. NULL may be returned
// if the image doesn't meet the trivial conditions that it uses to determine
// success.
static Pix* RemoveEnclosingCircle(Pix* pixs) {
Pix* pixsi = pixInvert(NULL, pixs);
Pix* pixc = pixCreateTemplate(pixs);
pixSetOrClearBorder(pixc, 1, 1, 1, 1, PIX_SET);
pixSeedfillBinary(pixc, pixc, pixsi, 4);
pixInvert(pixc, pixc);
pixDestroy(&pixsi);
Pix* pixt = pixAnd(NULL, pixs, pixc);
l_int32 max_count;
pixCountConnComp(pixt, 8, &max_count);
// The count has to go up before we start looking for the minimum.
l_int32 min_count = MAX_INT32;
Pix* pixout = NULL;
for (int i = 1; i < kMaxCircleErosions; i++) {
pixDestroy(&pixt);
pixErodeBrick(pixc, pixc, 3, 3);
pixt = pixAnd(NULL, pixs, pixc);
l_int32 count;
pixCountConnComp(pixt, 8, &count);
if (i == 1 || count > max_count) {
max_count = count;
min_count = count;
} else if (i > 1 && count < min_count) {
min_count = count;
pixDestroy(&pixout);
pixout = pixCopy(NULL, pixt); // Save the best.
} else if (count >= min_count) {
break; // We have passed by the best.
}
}
pixDestroy(&pixt);
pixDestroy(&pixc);
return pixout;
}
/*!
* \brief recogShowPath()
*
* \param[in] recog with LUT's pre-computed
* \param[in] select 0 for Viterbi; 1 for rescored
* \return pix debug output), or NULL on error
*/
static PIX *
recogShowPath(L_RECOG *recog,
l_int32 select)
{
char textstr[16];
l_int32 i, n, index, xloc, dely;
l_float32 score;
L_BMF *bmf;
NUMA *natempl_s, *nascore_s, *naxloc_s, *nadely_s;
PIX *pixs, *pix0, *pix1, *pix2, *pix3, *pix4, *pix5;
L_RDID *did;
PROCNAME("recogShowPath");
if (!recog)
return (PIX *)ERROR_PTR("recog not defined", procName, NULL);
if ((did = recogGetDid(recog)) == NULL)
return (PIX *)ERROR_PTR("did not defined", procName, NULL);
bmf = bmfCreate(NULL, 8);
pixs = pixScale(did->pixs, 4.0, 4.0);
pix0 = pixAddBorderGeneral(pixs, 0, 0, 0, 40, 0);
pix1 = pixConvertTo32(pix0);
if (select == 0) { /* Viterbi */
natempl_s = did->natempl;
nascore_s = did->nascore;
naxloc_s = did->naxloc;
nadely_s = did->nadely;
} else { /* rescored */
natempl_s = did->natempl_r;
nascore_s = did->nascore_r;
naxloc_s = did->naxloc_r;
nadely_s = did->nadely_r;
}
n = numaGetCount(natempl_s);
for (i = 0; i < n; i++) {
numaGetIValue(natempl_s, i, &index);
pix2 = pixaGetPix(recog->pixa_u, index, L_CLONE);
pix3 = pixScale(pix2, 4.0, 4.0);
pix4 = pixErodeBrick(NULL, pix3, 5, 5);
pixXor(pix4, pix4, pix3);
numaGetFValue(nascore_s, i, &score);
snprintf(textstr, sizeof(textstr), "%5.3f", score);
pix5 = pixAddTextlines(pix4, bmf, textstr, 1, L_ADD_BELOW);
numaGetIValue(naxloc_s, i, &xloc);
numaGetIValue(nadely_s, i, &dely);
pixPaintThroughMask(pix1, pix5, 4 * xloc, 4 * dely, 0xff000000);
pixDestroy(&pix2);
pixDestroy(&pix3);
pixDestroy(&pix4);
pixDestroy(&pix5);
}
pixDestroy(&pixs);
pixDestroy(&pix0);
bmfDestroy(&bmf);
return pix1;
}
/*!
* pixMorphSequence()
*
* Input: pixs
* sequence (string specifying sequence)
* dispsep (horizontal separation in pixels between
* successive displays; use zero to suppress display)
* Return: pixd, or null on error
*
* Notes:
* (1) This does rasterop morphology on binary images.
* (2) This runs a pipeline of operations; no branching is allowed.
* (3) This only uses brick Sels, which are created on the fly.
* In the future this will be generalized to extract Sels from
* a Sela by name.
* (4) A new image is always produced; the input image is not changed.
* (5) This contains an interpreter, allowing sequences to be
* generated and run.
* (6) The format of the sequence string is defined below.
* (7) In addition to morphological operations, rank order reduction
* and replicated expansion allow operations to take place
* downscaled by a power of 2.
* (8) Intermediate results can optionally be displayed.
* (9) Thanks to Dar-Shyang Lee, who had the idea for this and
* built the first implementation.
* (10) The sequence string is formatted as follows:
* - An arbitrary number of operations, each separated
* by a '+' character. White space is ignored.
* - Each operation begins with a case-independent character
* specifying the operation:
* d or D (dilation)
* e or E (erosion)
* o or O (opening)
* c or C (closing)
* r or R (rank binary reduction)
* x or X (replicative binary expansion)
* b or B (add a border of 0 pixels of this size)
* - The args to the morphological operations are bricks of hits,
* and are formatted as a.b, where a and b are horizontal and
* vertical dimensions, rsp.
* - The args to the reduction are a sequence of up to 4 integers,
* each from 1 to 4.
* - The arg to the expansion is a power of two, in the set
* {2, 4, 8, 16}.
* (11) An example valid sequence is:
* "b32 + o1.3 + C3.1 + r23 + e2.2 + D3.2 + X4"
* In this example, the following operation sequence is carried out:
* * b32: Add a 32 pixel border around the input image
* * o1.3: Opening with vert sel of length 3 (e.g., 1 x 3)
* * C3.1: Closing with horiz sel of length 3 (e.g., 3 x 1)
* * r23: Two successive 2x2 reductions with rank 2 in the first
* and rank 3 in the second. The result is a 4x reduced pix.
* * e2.2: Erosion with a 2x2 sel (origin will be at x,y: 0,0)
* * d3.2: Dilation with a 3x2 sel (origin will be at x,y: 1,0)
* * X4: 4x replicative expansion, back to original resolution
* (12) The safe closing is used. However, if you implement a
* closing as separable dilations followed by separable erosions,
* it will not be safe. For that situation, you need to add
* a sufficiently large border as the first operation in
* the sequence. This will be removed automatically at the
* end. There are two cautions:
* - When computing what is sufficient, remember that if
* reductions are carried out, the border is also reduced.
* - The border is removed at the end, so if a border is
* added at the beginning, the result must be at the
* same resolution as the input!
*/
PIX *
pixMorphSequence(PIX *pixs,
const char *sequence,
l_int32 dispsep)
{
char *rawop, *op;
l_int32 nops, i, j, nred, fact, w, h, x, y, border;
l_int32 level[4];
PIX *pixt1, *pixt2;
SARRAY *sa;
PROCNAME("pixMorphSequence");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (!sequence)
return (PIX *)ERROR_PTR("sequence not defined", procName, NULL);
/* Split sequence into individual operations */
sa = sarrayCreate(0);
sarraySplitString(sa, sequence, "+");
nops = sarrayGetCount(sa);
if (!morphSequenceVerify(sa)) {
sarrayDestroy(&sa);
return (PIX *)ERROR_PTR("sequence not valid", procName, NULL);
}
/* Parse and operate */
border = 0;
pixt1 = pixCopy(NULL, pixs);
pixt2 = NULL;
x = y = 0;
for (i = 0; i < nops; i++) {
rawop = sarrayGetString(sa, i, 0);
op = stringRemoveChars(rawop, " \n\t");
switch (op[0])
{
case 'd':
case 'D':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixDilateBrick(NULL, pixt1, w, h);
pixDestroy(&pixt1);
pixt1 = pixClone(pixt2);
pixDestroy(&pixt2);
if (dispsep > 0) {
pixDisplay(pixt1, x, y);
x += dispsep;
}
break;
case 'e':
case 'E':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixErodeBrick(NULL, pixt1, w, h);
pixDestroy(&pixt1);
pixt1 = pixClone(pixt2);
pixDestroy(&pixt2);
if (dispsep > 0) {
pixDisplay(pixt1, x, y);
x += dispsep;
}
break;
case 'o':
case 'O':
sscanf(&op[1], "%d.%d", &w, &h);
pixOpenBrick(pixt1, pixt1, w, h);
if (dispsep > 0) {
pixDisplay(pixt1, x, y);
x += dispsep;
}
break;
case 'c':
case 'C':
sscanf(&op[1], "%d.%d", &w, &h);
pixCloseSafeBrick(pixt1, pixt1, w, h);
if (dispsep > 0) {
pixDisplay(pixt1, x, y);
x += dispsep;
}
break;
case 'r':
case 'R':
nred = strlen(op) - 1;
for (j = 0; j < nred; j++)
level[j] = op[j + 1] - '0';
for (j = nred; j < 4; j++)
level[j] = 0;
pixt2 = pixReduceRankBinaryCascade(pixt1, level[0], level[1],
level[2], level[3]);
pixDestroy(&pixt1);
pixt1 = pixClone(pixt2);
pixDestroy(&pixt2);
if (dispsep > 0) {
pixDisplay(pixt1, x, y);
x += dispsep;
}
break;
case 'x':
case 'X':
sscanf(&op[1], "%d", &fact);
pixt2 = pixExpandReplicate(pixt1, fact);
pixDestroy(&pixt1);
pixt1 = pixClone(pixt2);
pixDestroy(&pixt2);
if (dispsep > 0) {
pixDisplay(pixt1, x, y);
x += dispsep;
}
break;
case 'b':
case 'B':
sscanf(&op[1], "%d", &border);
pixt2 = pixAddBorder(pixt1, border, 0);
pixDestroy(&pixt1);
pixt1 = pixClone(pixt2);
pixDestroy(&pixt2);
if (dispsep > 0) {
pixDisplay(pixt1, x, y);
x += dispsep;
}
break;
default:
/* All invalid ops are caught in the first pass */
break;
}
FREE(op);
}
if (border > 0) {
pixt2 = pixRemoveBorder(pixt1, border);
pixDestroy(&pixt1);
pixt1 = pixClone(pixt2);
pixDestroy(&pixt2);
}
sarrayDestroy(&sa);
return pixt1;
}
l_int32
DoComparisonDwa2(L_REGPARAMS *rp,
PIX *pixs,
PIX *pix1,
PIX *pix2,
PIX *pix3,
PIX *pix4,
PIX *pix5,
PIX *pix6,
l_int32 size) /* exactly decomposable */
{
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();
pixDilateBrick(pix2, pixs, size, 1);
pixDilateBrick(pix4, pixs, 1, size);
pixDilateBrick(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();
pixErodeBrick(pix2, pixs, size, 1);
pixErodeBrick(pix4, pixs, 1, size);
pixErodeBrick(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();
pixOpenBrick(pix2, pixs, size, 1);
pixOpenBrick(pix4, pixs, 1, size);
pixOpenBrick(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();
pixCloseSafeBrick(pix2, pixs, size, 1);
pixCloseSafeBrick(pix4, pixs, 1, size);
pixCloseSafeBrick(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;
}
l_int32
DoComparisonDwa2(PIX *pixs,
PIX *pixt1,
PIX *pixt2,
PIX *pixt3,
PIX *pixt4,
PIX *pixt5,
PIX *pixt6,
l_int32 size) /* exactly decomposable */
{
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();
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);
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();
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();
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();
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();
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();
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);
#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;
}
/* morph composite with morph non-composite */
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();
pixDilateCompBrick(pixt1, pixs, size, 1);
pixDilateCompBrick(pixt3, pixs, 1, size);
pixDilateCompBrick(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);
if (TIMING) startTimer();
pixErodeCompBrick(pixt1, pixs, size, 1);
pixErodeCompBrick(pixt3, pixs, 1, size);
pixErodeCompBrick(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();
pixOpenCompBrick(pixt1, pixs, size, 1);
pixOpenCompBrick(pixt3, pixs, 1, size);
pixOpenCompBrick(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 1
pixWrite("/tmp/junko1.png", pixt1, IFF_PNG);
pixWrite("/tmp/junko2.png", pixt2, IFF_PNG);
pixXor(pixt1, pixt1, pixt2);
pixWrite("/tmp/junkoxor.png", pixt1, IFF_PNG);
#endif
#if 0
pixDisplay(pixt1, 100, 100);
pixDisplay(pixt2, 800, 100);
pixWrite("/tmp/junkpixt1.png", pixt1, IFF_PNG);
pixWrite("/tmp/junkpixt2.png", pixt2, IFF_PNG);
#endif
if (TIMING) startTimer();
pixCloseSafeCompBrick(pixt1, pixs, size, 1);
pixCloseSafeCompBrick(pixt3, pixs, 1, size);
pixCloseSafeCompBrick(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);
#if 1
pixWrite("/tmp/junkc1.png", pixt1, IFF_PNG);
pixWrite("/tmp/junkc2.png", pixt2, IFF_PNG);
pixXor(pixt1, pixt1, pixt2);
pixWrite("/tmp/junkcxor.png", pixt1, IFF_PNG);
#endif
return 0;
}
/*!
* \brief pixMorphSequence()
*
* \param[in] pixs
* \param[in] sequence string specifying sequence
* \param[in] dispsep controls debug display of each result in the sequence:
* 0: no output
* > 0: gives horizontal separation in pixels between
* successive displays
* < 0: pdf output; abs(dispsep) is used for naming
* \return pixd, or NULL on error
*
* <pre>
* Notes:
* (1) This does rasterop morphology on binary images.
* (2) This runs a pipeline of operations; no branching is allowed.
* (3) This only uses brick Sels, which are created on the fly.
* In the future this will be generalized to extract Sels from
* a Sela by name.
* (4) A new image is always produced; the input image is not changed.
* (5) This contains an interpreter, allowing sequences to be
* generated and run.
* (6) The format of the sequence string is defined below.
* (7) In addition to morphological operations, rank order reduction
* and replicated expansion allow operations to take place
* downscaled by a power of 2.
* (8) Intermediate results can optionally be displayed.
* (9) Thanks to Dar-Shyang Lee, who had the idea for this and
* built the first implementation.
* (10) The sequence string is formatted as follows:
* ~ An arbitrary number of operations, each separated
* by a '+' character. White space is ignored.
* ~ Each operation begins with a case-independent character
* specifying the operation:
* d or D (dilation)
* e or E (erosion)
* o or O (opening)
* c or C (closing)
* r or R (rank binary reduction)
* x or X (replicative binary expansion)
* b or B (add a border of 0 pixels of this size)
* ~ The args to the morphological operations are bricks of hits,
* and are formatted as a.b, where a and b are horizontal and
* vertical dimensions, rsp.
* ~ The args to the reduction are a sequence of up to 4 integers,
* each from 1 to 4.
* ~ The arg to the expansion is a power of two, in the set
* {2, 4, 8, 16}.
* (11) An example valid sequence is:
* "b32 + o1.3 + C3.1 + r23 + e2.2 + D3.2 + X4"
* In this example, the following operation sequence is carried out:
* * b32: Add a 32 pixel border around the input image
* * o1.3: Opening with vert sel of length 3 (e.g., 1 x 3)
* * C3.1: Closing with horiz sel of length 3 (e.g., 3 x 1)
* * r23: Two successive 2x2 reductions with rank 2 in the first
* and rank 3 in the second. The result is a 4x reduced pix.
* * e2.2: Erosion with a 2x2 sel (origin will be at x,y: 0,0)
* * d3.2: Dilation with a 3x2 sel (origin will be at x,y: 1,0)
* * X4: 4x replicative expansion, back to original resolution
* (12) The safe closing is used. However, if you implement a
* closing as separable dilations followed by separable erosions,
* it will not be safe. For that situation, you need to add
* a sufficiently large border as the first operation in
* the sequence. This will be removed automatically at the
* end. There are two cautions:
* ~ When computing what is sufficient, remember that if
* reductions are carried out, the border is also reduced.
* ~ The border is removed at the end, so if a border is
* added at the beginning, the result must be at the
* same resolution as the input!
* </pre>
*/
PIX *
pixMorphSequence(PIX *pixs,
const char *sequence,
l_int32 dispsep)
{
char *rawop, *op, *fname;
char buf[256];
l_int32 nops, i, j, nred, fact, w, h, x, y, border, pdfout;
l_int32 level[4];
PIX *pixt1, *pixt2;
PIXA *pixa;
SARRAY *sa;
PROCNAME("pixMorphSequence");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (!sequence)
return (PIX *)ERROR_PTR("sequence not defined", procName, NULL);
/* Split sequence into individual operations */
sa = sarrayCreate(0);
sarraySplitString(sa, sequence, "+");
nops = sarrayGetCount(sa);
pdfout = (dispsep < 0) ? 1 : 0;
if (!morphSequenceVerify(sa)) {
sarrayDestroy(&sa);
return (PIX *)ERROR_PTR("sequence not valid", procName, NULL);
}
/* Parse and operate */
pixa = NULL;
if (pdfout) {
pixa = pixaCreate(0);
pixaAddPix(pixa, pixs, L_CLONE);
snprintf(buf, sizeof(buf), "/tmp/seq_output_%d.pdf", L_ABS(dispsep));
fname = genPathname(buf, NULL);
}
border = 0;
pixt1 = pixCopy(NULL, pixs);
pixt2 = NULL;
x = y = 0;
for (i = 0; i < nops; i++) {
rawop = sarrayGetString(sa, i, L_NOCOPY);
op = stringRemoveChars(rawop, " \n\t");
switch (op[0])
{
case 'd':
case 'D':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixDilateBrick(NULL, pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'e':
case 'E':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixErodeBrick(NULL, pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'o':
case 'O':
sscanf(&op[1], "%d.%d", &w, &h);
pixOpenBrick(pixt1, pixt1, w, h);
break;
case 'c':
case 'C':
sscanf(&op[1], "%d.%d", &w, &h);
pixCloseSafeBrick(pixt1, pixt1, w, h);
break;
case 'r':
case 'R':
nred = strlen(op) - 1;
for (j = 0; j < nred; j++)
level[j] = op[j + 1] - '0';
for (j = nred; j < 4; j++)
level[j] = 0;
pixt2 = pixReduceRankBinaryCascade(pixt1, level[0], level[1],
level[2], level[3]);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'x':
case 'X':
sscanf(&op[1], "%d", &fact);
pixt2 = pixExpandReplicate(pixt1, fact);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'b':
case 'B':
sscanf(&op[1], "%d", &border);
pixt2 = pixAddBorder(pixt1, border, 0);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
default:
/* All invalid ops are caught in the first pass */
break;
}
LEPT_FREE(op);
/* Debug output */
if (dispsep > 0) {
pixDisplay(pixt1, x, y);
x += dispsep;
}
if (pdfout)
pixaAddPix(pixa, pixt1, L_COPY);
}
if (border > 0) {
pixt2 = pixRemoveBorder(pixt1, border);
pixSwapAndDestroy(&pixt1, &pixt2);
}
if (pdfout) {
pixaConvertToPdf(pixa, 0, 1.0, L_FLATE_ENCODE, 0, fname, fname);
LEPT_FREE(fname);
pixaDestroy(&pixa);
}
sarrayDestroy(&sa);
return pixt1;
}
//---------------------------------------------------------------------------
//Уменьшение в 2 раза
//Поиск угла
//Предварительное выпрямление
//Эрозия для удаления тонких линий
//Поиск box для обрезки белых полей изображения
//Обрезка предварительно выпрямленного изображения
//Получение трёх изображений:
//------------------------------------------------------------------------------
PIX* LeptPrepareFile::getClearImage(PIX *pix, l_float32 *angle, l_float32 *conf)
{
PIX *pixReduce2, *pixDeskew, *pixCrop, *pixErode;
PIXA *pixa1, *pixa2;
l_int32 result;
l_float32 _angle, _conf;
l_int32 XC_crop, YC_crop, XC_old, YC_old, XC_new, YC_new;
LEP_LOG("enter");
SetNULL(7, (void **)&pixReduce2, &pixDeskew, &pixCrop, &pixErode, &pixa1, &pixa2, &boxFirstCrop);
SetNULL(2, (void **)angle, conf);
try
{
LEP_STR_THROW(!pix, "Изображение не найдено");
//Уменьшение в 2 раза для ускорения (при DPI = 600)
if ((pix->xres == 600) && (pix->yres == 600)) //В дальнейшем переработать потому как в текущем варианте обрабатывает корректно только DPI300 и DPI600
pixReduce2 = pixReduceBinary2(pix, NULL);
else
{
pixReduce2 = pixCreateTemplateNoInit(pix);
LEP_STR_THROW(!pixReduce2, "Ошибка в pixReduceBinary2");
pixCopy(pixReduce2, pix);
}
LEP_STR_THROW(!pixReduce2, "Ошибка в pixReduceBinary2");
//Поиск угла наклона
result = pixFindSkewSweepAndSearch(pixReduce2, &_angle, &_conf,
4, //линеное уменьшение, DEFAULT_SWEEP_REDUCTION = 4
2, //бинарное уменьшение, DEFAULT_BS_REDUCTION = 2
10, //максимальный угол поиска
0.1, //дельта угла поиска
0.01);//конечная дельта угла поиска, DEFAULT_MINBS_DELTA = 0.01
LEP_STR_THROW(result != 0, "Ошибка поиска угла");
if (angle) *angle = _angle;
if (conf) *conf = _conf;
//Предварительное выпрямление
pixDeskew = pixRotate(pixReduce2, 3.1415926535 / 180. * _angle, L_ROTATE_AREA_MAP, L_BRING_IN_WHITE, 0, 0);
LEP_STR_THROW(!pixDeskew, "Ошибка при предварительном повороте изображения");
//Эрозия для удаления тонких линий
pixErode = pixCreateTemplateNoInit(pixDeskew);
LEP_STR_THROW(!pixErode, "Ошибка в pixCreateTemplateNoInit");
pixCopy(pixErode, pixDeskew);
pixErodeBrick(pixErode, pixErode, 3, 3);
//pixWrite("c:\\temp0_0.tif", pixErode, IFF_TIFF_ZIP);
//Поиск box для обрезки белых полей изображения
result = pixClipBoxToForeground(pixErode, NULL, NULL, &boxFirstCrop);
LEP_STR_THROW(result != 0, "Ошибка при поиске обрезки изображения");
//Получение точки вокруг которой происходило вращение, с учётом обрезки
XC_old = pixErode->w / 2; //точка вращения старого изображения на старом изображении
YC_old = pixErode->h / 2;
XC_new = boxFirstCrop->w / 2; //точка вращения нового изображения на новом изображении
YC_new = boxFirstCrop->h / 2;
XC_crop = boxFirstCrop->x + XC_new; //точка вращения нового изображения на старом изображении
YC_crop = boxFirstCrop->y + YC_new;
centerXRotate = XC_new - (XC_crop - XC_old); //точка вращения старого изображения на новом изображении
centerYRotate = YC_new - (YC_crop - YC_old);
//Обрезка предварительно выпрямленного изображения
pixCrop = pixClipRectangle(pixDeskew, boxFirstCrop, NULL);
LEP_STR_THROW(!pixCrop, "Ошибка при обрезке изображения");
//pixWrite("c:\\pixCrop.tif", pixCrop, IFF_TIFF_ZIP);
}catch (string error)
{
LEP_ERROR(error);
};
pixDestroy(&pixReduce2);
pixDestroy(&pixDeskew);
pixDestroy(&pixErode);
LEP_LOG("exit");
return pixCrop;
}
main(int argc,
char **argv)
{
l_int32 i, ok, same;
char sequence[512];
PIX *pixs, *pixref;
PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixt5, *pixt6;
PIX *pixt7, *pixt8, *pixt9, *pixt10, *pixt11;
PIX *pixt12, *pixt13, *pixt14;
SEL *sel;
static char mainName[] = "binmorph1_reg";
if (argc != 1)
exit(ERROR_INT(" Syntax: binmorph1_reg", mainName, 1));
if ((pixs = pixRead("feyn.tif")) == NULL)
exit(ERROR_INT("pix not made", mainName, 1));
#if TEST_SYMMETRIC
/* This works properly if there is an added border */
resetMorphBoundaryCondition(SYMMETRIC_MORPH_BC);
#if 1
pixt1 = pixAddBorder(pixs, 32, 0);
pixTransferAllData(pixs, &pixt1, 0, 0);
#endif
#endif /* TEST_SYMMETRIC */
/* This is our test sel */
sel = selCreateBrick(HEIGHT, WIDTH, HEIGHT / 2, WIDTH / 2, SEL_HIT);
/* Dilation */
fprintf(stderr, "Testing dilation\n");
ok = TRUE;
pixref = pixDilate(NULL, pixs, sel); /* new one */
pixt1 = pixCreateTemplate(pixs);
pixDilate(pixt1, pixs, sel); /* existing one */
pixEqual(pixref, pixt1, &same);
if (!same) {
fprintf(stderr, "pixref != pixt1 !\n"); ok = FALSE;
}
pixt2 = pixCopy(NULL, pixs);
pixDilate(pixt2, pixt2, sel); /* in-place */
pixEqual(pixref, pixt2, &same);
if (!same) {
fprintf(stderr, "pixref != pixt2 !\n"); ok = FALSE;
}
sprintf(sequence, "d%d.%d", WIDTH, HEIGHT);
pixt3 = pixMorphSequence(pixs, sequence, 0); /* sequence, atomic */
pixEqual(pixref, pixt3, &same);
if (!same) {
fprintf(stderr, "pixref != pixt3 !\n"); ok = FALSE;
}
sprintf(sequence, "d%d.1 + d1.%d", WIDTH, HEIGHT);
pixt4 = pixMorphSequence(pixs, sequence, 0); /* sequence, separable */
pixEqual(pixref, pixt4, &same);
if (!same) {
fprintf(stderr, "pixref != pixt4 !\n"); ok = FALSE;
}
pixt5 = pixDilateBrick(NULL, pixs, WIDTH, HEIGHT); /* new one */
pixEqual(pixref, pixt5, &same);
if (!same) {
fprintf(stderr, "pixref != pixt5 !\n"); ok = FALSE;
}
pixt6 = pixCreateTemplate(pixs);
pixDilateBrick(pixt6, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt6, &same);
if (!same) {
fprintf(stderr, "pixref != pixt6 !\n"); ok = FALSE;
}
pixt7 = pixCopy(NULL, pixs);
pixDilateBrick(pixt7, pixt7, WIDTH, HEIGHT); /* in-place */
pixEqual(pixref, pixt7, &same);
if (!same) {
fprintf(stderr, "pixref != pixt7 !\n"); ok = FALSE;
}
pixt8 = pixDilateBrickDwa(NULL, pixs, WIDTH, HEIGHT); /* new one */
pixEqual(pixref, pixt8, &same);
if (!same) {
fprintf(stderr, "pixref != pixt8 !\n"); ok = FALSE;
}
pixt9 = pixCreateTemplate(pixs);
pixDilateBrickDwa(pixt9, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt9, &same);
if (!same) {
fprintf(stderr, "pixref != pixt9 !\n"); ok = FALSE;
}
pixt10 = pixCopy(NULL, pixs);
pixDilateBrickDwa(pixt10, pixt10, WIDTH, HEIGHT); /* in-place */
pixEqual(pixref, pixt10, &same);
if (!same) {
fprintf(stderr, "pixref != pixt10 !\n"); ok = FALSE;
}
pixt11 = pixCreateTemplate(pixs);
pixDilateCompBrickDwa(pixt11, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt11, &same);
if (!same) {
fprintf(stderr, "pixref != pixt11 !\n"); ok = FALSE;
}
sprintf(sequence, "d%d.%d", WIDTH, HEIGHT);
pixt12 = pixMorphCompSequence(pixs, sequence, 0); /* comp sequence */
pixEqual(pixref, pixt12, &same);
if (!same) {
fprintf(stderr, "pixref != pixt12!\n"); ok = FALSE;
}
pixt13 = pixMorphSequenceDwa(pixs, sequence, 0); /* dwa sequence */
pixEqual(pixref, pixt13, &same);
if (!same) {
fprintf(stderr, "pixref != pixt13!\n"); ok = FALSE;
}
pixDestroy(&pixref);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
pixDestroy(&pixt7);
pixDestroy(&pixt8);
pixDestroy(&pixt9);
pixDestroy(&pixt10);
pixDestroy(&pixt11);
pixDestroy(&pixt12);
pixDestroy(&pixt13);
/* Erosion */
fprintf(stderr, "Testing erosion\n");
pixref = pixErode(NULL, pixs, sel); /* new one */
pixt1 = pixCreateTemplate(pixs);
pixErode(pixt1, pixs, sel); /* existing one */
pixEqual(pixref, pixt1, &same);
if (!same) {
fprintf(stderr, "pixref != pixt1 !\n"); ok = FALSE;
}
pixt2 = pixCopy(NULL, pixs);
pixErode(pixt2, pixt2, sel); /* in-place */
pixEqual(pixref, pixt2, &same);
if (!same) {
fprintf(stderr, "pixref != pixt2 !\n"); ok = FALSE;
}
sprintf(sequence, "e%d.%d", WIDTH, HEIGHT);
pixt3 = pixMorphSequence(pixs, sequence, 0); /* sequence, atomic */
pixEqual(pixref, pixt3, &same);
if (!same) {
fprintf(stderr, "pixref != pixt3 !\n"); ok = FALSE;
}
sprintf(sequence, "e%d.1 + e1.%d", WIDTH, HEIGHT);
pixt4 = pixMorphSequence(pixs, sequence, 0); /* sequence, separable */
pixEqual(pixref, pixt4, &same);
if (!same) {
fprintf(stderr, "pixref != pixt4 !\n"); ok = FALSE;
}
pixt5 = pixErodeBrick(NULL, pixs, WIDTH, HEIGHT); /* new one */
pixEqual(pixref, pixt5, &same);
if (!same) {
fprintf(stderr, "pixref != pixt5 !\n"); ok = FALSE;
}
pixt6 = pixCreateTemplate(pixs);
pixErodeBrick(pixt6, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt6, &same);
if (!same) {
fprintf(stderr, "pixref != pixt6 !\n"); ok = FALSE;
}
pixt7 = pixCopy(NULL, pixs);
pixErodeBrick(pixt7, pixt7, WIDTH, HEIGHT); /* in-place */
pixEqual(pixref, pixt7, &same);
if (!same) {
fprintf(stderr, "pixref != pixt7 !\n"); ok = FALSE;
}
pixt8 = pixErodeBrickDwa(NULL, pixs, WIDTH, HEIGHT); /* new one */
pixEqual(pixref, pixt8, &same);
if (!same) {
fprintf(stderr, "pixref != pixt8 !\n"); ok = FALSE;
}
pixt9 = pixCreateTemplate(pixs);
pixErodeBrickDwa(pixt9, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt9, &same);
if (!same) {
fprintf(stderr, "pixref != pixt9 !\n"); ok = FALSE;
}
pixt10 = pixCopy(NULL, pixs);
pixErodeBrickDwa(pixt10, pixt10, WIDTH, HEIGHT); /* in-place */
pixEqual(pixref, pixt10, &same);
if (!same) {
fprintf(stderr, "pixref != pixt10 !\n"); ok = FALSE;
}
pixt11 = pixCreateTemplate(pixs);
pixErodeCompBrickDwa(pixt11, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt11, &same);
if (!same) {
fprintf(stderr, "pixref != pixt11 !\n"); ok = FALSE;
}
sprintf(sequence, "e%d.%d", WIDTH, HEIGHT);
pixt12 = pixMorphCompSequence(pixs, sequence, 0); /* comp sequence */
pixEqual(pixref, pixt12, &same);
if (!same) {
fprintf(stderr, "pixref != pixt12!\n"); ok = FALSE;
}
pixt13 = pixMorphSequenceDwa(pixs, sequence, 0); /* dwa sequence */
pixEqual(pixref, pixt13, &same);
if (!same) {
fprintf(stderr, "pixref != pixt13!\n"); ok = FALSE;
}
pixDestroy(&pixref);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
pixDestroy(&pixt7);
pixDestroy(&pixt8);
pixDestroy(&pixt9);
pixDestroy(&pixt10);
pixDestroy(&pixt11);
pixDestroy(&pixt12);
pixDestroy(&pixt13);
/* Opening */
fprintf(stderr, "Testing opening\n");
pixref = pixOpen(NULL, pixs, sel); /* new one */
pixt1 = pixCreateTemplate(pixs);
pixOpen(pixt1, pixs, sel); /* existing one */
pixEqual(pixref, pixt1, &same);
if (!same) {
fprintf(stderr, "pixref != pixt1 !\n"); ok = FALSE;
}
pixt2 = pixCopy(NULL, pixs);
pixOpen(pixt2, pixt2, sel); /* in-place */
pixEqual(pixref, pixt2, &same);
if (!same) {
fprintf(stderr, "pixref != pixt2 !\n"); ok = FALSE;
}
sprintf(sequence, "o%d.%d", WIDTH, HEIGHT);
pixt3 = pixMorphSequence(pixs, sequence, 0); /* sequence, atomic */
pixEqual(pixref, pixt3, &same);
if (!same) {
fprintf(stderr, "pixref != pixt3 !\n"); ok = FALSE;
}
sprintf(sequence, "e%d.%d + d%d.%d", WIDTH, HEIGHT, WIDTH, HEIGHT);
pixt4 = pixMorphSequence(pixs, sequence, 0); /* sequence, separable */
pixEqual(pixref, pixt4, &same);
if (!same) {
fprintf(stderr, "pixref != pixt4 !\n"); ok = FALSE;
}
sprintf(sequence, "e%d.1 + e1.%d + d%d.1 + d1.%d", WIDTH, HEIGHT,
WIDTH, HEIGHT);
pixt5 = pixMorphSequence(pixs, sequence, 0); /* sequence, separable^2 */
pixEqual(pixref, pixt5, &same);
if (!same) {
fprintf(stderr, "pixref != pixt5 !\n"); ok = FALSE;
}
pixt6 = pixOpenBrick(NULL, pixs, WIDTH, HEIGHT); /* new one */
pixEqual(pixref, pixt6, &same);
if (!same) {
fprintf(stderr, "pixref != pixt6 !\n"); ok = FALSE;
}
pixt7 = pixCreateTemplate(pixs);
pixOpenBrick(pixt7, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt7, &same);
if (!same) {
fprintf(stderr, "pixref != pixt7 !\n"); ok = FALSE;
}
pixt8 = pixCopy(NULL, pixs); /* in-place */
pixOpenBrick(pixt8, pixt8, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt8, &same);
if (!same) {
fprintf(stderr, "pixref != pixt8 !\n"); ok = FALSE;
}
pixt9 = pixOpenBrickDwa(NULL, pixs, WIDTH, HEIGHT); /* new one */
pixEqual(pixref, pixt9, &same);
if (!same) {
fprintf(stderr, "pixref != pixt9 !\n"); ok = FALSE;
}
pixt10 = pixCreateTemplate(pixs);
pixOpenBrickDwa(pixt10, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt10, &same);
if (!same) {
fprintf(stderr, "pixref != pixt10 !\n"); ok = FALSE;
}
pixt11 = pixCopy(NULL, pixs);
pixOpenBrickDwa(pixt11, pixt11, WIDTH, HEIGHT); /* in-place */
pixEqual(pixref, pixt11, &same);
if (!same) {
fprintf(stderr, "pixref != pixt11 !\n"); ok = FALSE;
}
sprintf(sequence, "o%d.%d", WIDTH, HEIGHT);
pixt12 = pixMorphCompSequence(pixs, sequence, 0); /* comp sequence */
pixEqual(pixref, pixt12, &same);
if (!same) {
fprintf(stderr, "pixref != pixt12!\n"); ok = FALSE;
}
#if 0
pixWrite("/tmp/junkref.png", pixref, IFF_PNG);
pixWrite("/tmp/junk12.png", pixt12, IFF_PNG);
pixt13 = pixXor(NULL, pixref, pixt12);
pixWrite("/tmp/junk12a.png", pixt13, IFF_PNG);
pixDestroy(&pixt13);
#endif
pixt13 = pixMorphSequenceDwa(pixs, sequence, 0); /* dwa sequence */
pixEqual(pixref, pixt13, &same);
if (!same) {
fprintf(stderr, "pixref != pixt13!\n"); ok = FALSE;
}
pixt14 = pixCreateTemplate(pixs);
pixOpenCompBrickDwa(pixt14, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt14, &same);
if (!same) {
fprintf(stderr, "pixref != pixt14 !\n"); ok = FALSE;
}
pixDestroy(&pixref);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
pixDestroy(&pixt7);
pixDestroy(&pixt8);
pixDestroy(&pixt9);
pixDestroy(&pixt10);
pixDestroy(&pixt11);
pixDestroy(&pixt12);
pixDestroy(&pixt13);
pixDestroy(&pixt14);
/* Closing */
fprintf(stderr, "Testing closing\n");
pixref = pixClose(NULL, pixs, sel); /* new one */
pixt1 = pixCreateTemplate(pixs);
pixClose(pixt1, pixs, sel); /* existing one */
pixEqual(pixref, pixt1, &same);
if (!same) {
fprintf(stderr, "pixref != pixt1 !\n"); ok = FALSE;
}
pixt2 = pixCopy(NULL, pixs);
pixClose(pixt2, pixt2, sel); /* in-place */
pixEqual(pixref, pixt2, &same);
if (!same) {
fprintf(stderr, "pixref != pixt2 !\n"); ok = FALSE;
}
sprintf(sequence, "d%d.%d + e%d.%d", WIDTH, HEIGHT, WIDTH, HEIGHT);
pixt3 = pixMorphSequence(pixs, sequence, 0); /* sequence, separable */
pixEqual(pixref, pixt3, &same);
if (!same) {
fprintf(stderr, "pixref != pixt3 !\n"); ok = FALSE;
}
sprintf(sequence, "d%d.1 + d1.%d + e%d.1 + e1.%d", WIDTH, HEIGHT,
WIDTH, HEIGHT);
pixt4 = pixMorphSequence(pixs, sequence, 0); /* sequence, separable^2 */
pixEqual(pixref, pixt4, &same);
if (!same) {
fprintf(stderr, "pixref != pixt4 !\n"); ok = FALSE;
}
pixt5 = pixCloseBrick(NULL, pixs, WIDTH, HEIGHT); /* new one */
pixEqual(pixref, pixt5, &same);
if (!same) {
fprintf(stderr, "pixref != pixt5 !\n"); ok = FALSE;
}
pixt6 = pixCreateTemplate(pixs);
pixCloseBrick(pixt6, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt6, &same);
if (!same) {
fprintf(stderr, "pixref != pixt6 !\n"); ok = FALSE;
}
pixt7 = pixCopy(NULL, pixs); /* in-place */
pixCloseBrick(pixt7, pixt7, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt7, &same);
if (!same) {
fprintf(stderr, "pixref != pixt7 !\n"); ok = FALSE;
}
pixDestroy(&pixref);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
pixDestroy(&pixt7);
/* Safe closing (using pix, not pixs) */
fprintf(stderr, "Testing safe closing\n");
pixref = pixCloseSafe(NULL, pixs, sel); /* new one */
pixt1 = pixCreateTemplate(pixs);
pixCloseSafe(pixt1, pixs, sel); /* existing one */
pixEqual(pixref, pixt1, &same);
if (!same) {
fprintf(stderr, "pixref != pixt1 !\n"); ok = FALSE;
}
pixt2 = pixCopy(NULL, pixs);
pixCloseSafe(pixt2, pixt2, sel); /* in-place */
pixEqual(pixref, pixt2, &same);
if (!same) {
fprintf(stderr, "pixref != pixt2 !\n"); ok = FALSE;
}
sprintf(sequence, "c%d.%d", WIDTH, HEIGHT);
pixt3 = pixMorphSequence(pixs, sequence, 0); /* sequence, atomic */
pixEqual(pixref, pixt3, &same);
if (!same) {
fprintf(stderr, "pixref != pixt3 !\n"); ok = FALSE;
}
sprintf(sequence, "b32 + d%d.%d + e%d.%d", WIDTH, HEIGHT, WIDTH, HEIGHT);
pixt4 = pixMorphSequence(pixs, sequence, 0); /* sequence, separable */
pixEqual(pixref, pixt4, &same);
if (!same) {
fprintf(stderr, "pixref != pixt4 !\n"); ok = FALSE;
}
sprintf(sequence, "b32 + d%d.1 + d1.%d + e%d.1 + e1.%d", WIDTH, HEIGHT,
WIDTH, HEIGHT);
pixt5 = pixMorphSequence(pixs, sequence, 0); /* sequence, separable^2 */
pixEqual(pixref, pixt5, &same);
if (!same) {
fprintf(stderr, "pixref != pixt5 !\n"); ok = FALSE;
}
pixt6 = pixCloseSafeBrick(NULL, pixs, WIDTH, HEIGHT); /* new one */
pixEqual(pixref, pixt6, &same);
if (!same) {
fprintf(stderr, "pixref != pixt6 !\n"); ok = FALSE;
}
pixt7 = pixCreateTemplate(pixs);
pixCloseSafeBrick(pixt7, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt7, &same);
if (!same) {
fprintf(stderr, "pixref != pixt7 !\n"); ok = FALSE;
}
pixt8 = pixCopy(NULL, pixs); /* in-place */
pixCloseSafeBrick(pixt8, pixt8, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt8, &same);
if (!same) {
fprintf(stderr, "pixref != pixt8 !\n"); ok = FALSE;
}
pixt9 = pixCloseBrickDwa(NULL, pixs, WIDTH, HEIGHT); /* new one */
pixEqual(pixref, pixt9, &same);
if (!same) {
fprintf(stderr, "pixref != pixt9 !\n"); ok = FALSE;
}
pixt10 = pixCreateTemplate(pixs);
pixCloseBrickDwa(pixt10, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt10, &same);
if (!same) {
fprintf(stderr, "pixref != pixt10 !\n"); ok = FALSE;
}
pixt11 = pixCopy(NULL, pixs);
pixCloseBrickDwa(pixt11, pixt11, WIDTH, HEIGHT); /* in-place */
pixEqual(pixref, pixt11, &same);
if (!same) {
fprintf(stderr, "pixref != pixt11 !\n"); ok = FALSE;
}
sprintf(sequence, "c%d.%d", WIDTH, HEIGHT);
pixt12 = pixMorphCompSequence(pixs, sequence, 0); /* comp sequence */
pixEqual(pixref, pixt12, &same);
if (!same) {
fprintf(stderr, "pixref != pixt12!\n"); ok = FALSE;
}
pixt13 = pixMorphSequenceDwa(pixs, sequence, 0); /* dwa sequence */
pixEqual(pixref, pixt13, &same);
if (!same) {
fprintf(stderr, "pixref != pixt13!\n"); ok = FALSE;
}
pixt14 = pixCreateTemplate(pixs);
pixCloseCompBrickDwa(pixt14, pixs, WIDTH, HEIGHT); /* existing one */
pixEqual(pixref, pixt14, &same);
if (!same) {
fprintf(stderr, "pixref != pixt14 !\n"); ok = FALSE;
}
#if 0
pixWrite("/tmp/junkref.png", pixref, IFF_PNG);
pixWrite("/tmp/junk12.png", pixt12, IFF_PNG);
pixt13 = pixXor(NULL, pixref, pixt12);
pixWrite("/tmp/junk12a.png", pixt13, IFF_PNG);
pixDestroy(&pixt13);
#endif
pixDestroy(&pixref);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixt3);
pixDestroy(&pixt4);
pixDestroy(&pixt5);
pixDestroy(&pixt6);
pixDestroy(&pixt7);
pixDestroy(&pixt8);
pixDestroy(&pixt9);
pixDestroy(&pixt10);
pixDestroy(&pixt11);
pixDestroy(&pixt12);
pixDestroy(&pixt13);
pixDestroy(&pixt14);
if (ok)
fprintf(stderr, "All morph tests OK!\n");
pixDestroy(&pixs);
selDestroy(&sel);
exit(0);
}
