/*!
* pixGrayMorphSequence()
*
* Input: pixs
* sequence (string specifying sequence)
* dispsep (horizontal separation in pixels between
* successive displays; use zero to suppress display)
* dispy (if dispsep != 0, this gives the y-value of the
* UL corner for display; otherwise it is ignored)
* Return: pixd, or null on error
*
* Notes:
* (1) This works on 8 bpp grayscale images.
* (2) This runs a pipeline of operations; no branching is allowed.
* (3) This only uses brick SELs.
* (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, the composite
* morph/subtract tophat can be performed.
* (8) Sel sizes (width, height) must each be odd numbers.
* (9) Intermediate results can optionally be displayed
* (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)
* t or T (tophat)
* - 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. (each must be an odd number)
* - The args to the tophat are w or W (for white tophat)
* or b or B (for black tophat), followed by a.b as for
* the dilation, erosion, opening and closing.
* Example valid sequences are:
* "c5.3 + o7.5"
* "c9.9 + tw9.9"
*/
PIX *
pixGrayMorphSequence(PIX *pixs,
const char *sequence,
l_int32 dispsep,
l_int32 dispy)
{
char *rawop, *op;
l_int32 nops, i, valid, w, h, x;
PIX *pixt1, *pixt2;
SARRAY *sa;
PROCNAME("pixGrayMorphSequence");
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);
/* Verify that the operation sequence is valid */
valid = TRUE;
for (i = 0; i < nops; i++) {
rawop = sarrayGetString(sa, i, 0);
op = stringRemoveChars(rawop, " \n\t");
switch (op[0])
{
case 'd':
case 'D':
case 'e':
case 'E':
case 'o':
case 'O':
case 'c':
case 'C':
if (sscanf(&op[1], "%d.%d", &w, &h) != 2) {
fprintf(stderr, "*** op: %s invalid\n", op);
valid = FALSE;
break;
}
if (w < 1 || (w & 1) == 0 || h < 1 || (h & 1) == 0 ) {
fprintf(stderr,
"*** op: %s; w = %d, h = %d; must both be odd\n",
op, w, h);
valid = FALSE;
break;
}
/* fprintf(stderr, "op = %s; w = %d, h = %d\n", op, w, h); */
break;
case 't':
case 'T':
if (op[1] != 'w' && op[1] != 'W' &&
op[1] != 'b' && op[1] != 'B') {
fprintf(stderr,
"*** op = %s; arg %c must be 'w' or 'b'\n", op, op[1]);
valid = FALSE;
break;
}
sscanf(&op[2], "%d.%d", &w, &h);
if (w < 1 || (w & 1) == 0 || h < 1 || (h & 1) == 0 ) {
fprintf(stderr,
"*** op: %s; w = %d, h = %d; must both be odd\n",
op, w, h);
valid = FALSE;
break;
}
/* fprintf(stderr, "op = %s", op); */
break;
default:
fprintf(stderr, "*** nonexistent op = %s\n", op);
valid = FALSE;
}
FREE(op);
}
if (!valid) {
sarrayDestroy(&sa);
return (PIX *)ERROR_PTR("sequence invalid", procName, NULL);
}
/* Parse and operate */
pixt1 = pixCopy(NULL, pixs);
pixt2 = NULL;
x = 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 = pixDilateGray(pixt1, w, h);
pixDestroy(&pixt1);
pixt1 = pixClone(pixt2);
pixDestroy(&pixt2);
if (dispsep > 0) {
pixDisplay(pixt1, x, dispy);
x += dispsep;
}
break;
case 'e':
case 'E':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixErodeGray(pixt1, w, h);
pixDestroy(&pixt1);
pixt1 = pixClone(pixt2);
pixDestroy(&pixt2);
if (dispsep > 0) {
pixDisplay(pixt1, x, dispy);
x += dispsep;
}
break;
case 'o':
case 'O':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixOpenGray(pixt1, w, h);
pixDestroy(&pixt1);
pixt1 = pixClone(pixt2);
pixDestroy(&pixt2);
if (dispsep > 0) {
pixDisplay(pixt1, x, dispy);
x += dispsep;
}
break;
case 'c':
case 'C':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixCloseGray(pixt1, w, h);
pixDestroy(&pixt1);
pixt1 = pixClone(pixt2);
pixDestroy(&pixt2);
if (dispsep > 0) {
pixDisplay(pixt1, x, dispy);
x += dispsep;
}
break;
case 't':
case 'T':
sscanf(&op[2], "%d.%d", &w, &h);
if (op[1] == 'w' || op[1] == 'W')
pixt2 = pixTophat(pixt1, w, h, L_TOPHAT_WHITE);
else /* 'b' or 'B' */
pixt2 = pixTophat(pixt1, w, h, L_TOPHAT_BLACK);
pixDestroy(&pixt1);
pixt1 = pixClone(pixt2);
pixDestroy(&pixt2);
if (dispsep > 0) {
pixDisplay(pixt1, x, dispy);
x += dispsep;
}
break;
default:
/* All invalid ops are caught in the first pass */
break;
}
FREE(op);
}
sarrayDestroy(&sa);
return pixt1;
}
/*!
* morphSequenceVerify()
*
* Input: sarray (of operation sequence)
* Return: TRUE if valid; FALSE otherwise or on error
*
* Notes:
* (1) This does verification of valid binary morphological
* operation sequences.
* (2) See pixMorphSequence() for notes on valid operations
* in the sequence.
*/
l_int32
morphSequenceVerify(SARRAY *sa)
{
char *rawop, *op;
l_int32 nops, i, j, nred, fact, valid, w, h, netred, border;
l_int32 level[4];
l_int32 intlogbase2[5] = {1, 2, 3, 0, 4}; /* of arg/4 */
PROCNAME("morphSequenceVerify");
if (!sa)
return ERROR_INT("sa not defined", procName, FALSE);
nops = sarrayGetCount(sa);
valid = TRUE;
netred = 0;
border = 0;
for (i = 0; i < nops; i++) {
rawop = sarrayGetString(sa, i, 0);
op = stringRemoveChars(rawop, " \n\t");
switch (op[0])
{
case 'd':
case 'D':
case 'e':
case 'E':
case 'o':
case 'O':
case 'c':
case 'C':
if (sscanf(&op[1], "%d.%d", &w, &h) != 2) {
fprintf(stderr, "*** op: %s invalid\n", op);
valid = FALSE;
break;
}
if (w <= 0 || h <= 0) {
fprintf(stderr,
"*** op: %s; w = %d, h = %d; must both be > 0\n",
op, w, h);
valid = FALSE;
break;
}
/* fprintf(stderr, "op = %s; w = %d, h = %d\n", op, w, h); */
break;
case 'r':
case 'R':
nred = strlen(op) - 1;
netred += nred;
if (nred < 1 || nred > 4) {
fprintf(stderr,
"*** op = %s; num reduct = %d; must be in {1,2,3,4}\n",
op, nred);
valid = FALSE;
break;
}
for (j = 0; j < nred; j++) {
level[j] = op[j + 1] - '0';
if (level[j] < 1 || level[j] > 4) {
fprintf(stderr, "*** op = %s; level[%d] = %d is invalid\n",
op, j, level[j]);
valid = FALSE;
break;
}
}
if (!valid)
break;
/* fprintf(stderr, "op = %s", op); */
for (j = 0; j < nred; j++) {
level[j] = op[j + 1] - '0';
/* fprintf(stderr, ", level[%d] = %d", j, level[j]); */
}
/* fprintf(stderr, "\n"); */
break;
case 'x':
case 'X':
if (sscanf(&op[1], "%d", &fact) != 1) {
fprintf(stderr, "*** op: %s; fact invalid\n", op);
valid = FALSE;
break;
}
if (fact != 2 && fact != 4 && fact != 8 && fact != 16) {
fprintf(stderr, "*** op = %s; invalid fact = %d\n", op, fact);
valid = FALSE;
break;
}
netred -= intlogbase2[fact / 4];
/* fprintf(stderr, "op = %s; fact = %d\n", op, fact); */
break;
case 'b':
case 'B':
if (sscanf(&op[1], "%d", &fact) != 1) {
fprintf(stderr, "*** op: %s; fact invalid\n", op);
valid = FALSE;
break;
}
if (i > 0) {
fprintf(stderr, "*** op = %s; must be first op\n", op);
valid = FALSE;
break;
}
if (fact < 1) {
fprintf(stderr, "*** op = %s; invalid fact = %d\n", op, fact);
valid = FALSE;
break;
}
border = fact;
/* fprintf(stderr, "op = %s; fact = %d\n", op, fact); */
break;
default:
fprintf(stderr, "*** nonexistent op = %s\n", op);
valid = FALSE;
}
FREE(op);
}
if (border != 0 && netred != 0) {
fprintf(stderr,
"*** op = %s; border added but net reduction not 0\n", op);
valid = FALSE;
}
return valid;
}
/*!
* \brief pixGrayMorphSequence()
*
* \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
* \param[in] dispy if dispsep > 0, this gives the y-value of the
* UL corner for display; otherwise it is ignored
* \return pixd, or NULL on error
*
* <pre>
* Notes:
* (1) This works on 8 bpp grayscale images.
* (2) This runs a pipeline of operations; no branching is allowed.
* (3) This only uses brick SELs.
* (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, the composite
* morph/subtract tophat can be performed.
* (8) Sel sizes (width, height) must each be odd numbers.
* (9) Intermediate results can optionally be displayed
* (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)
* t or T (tophat)
* ~ 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. (each must be an odd number)
* ~ The args to the tophat are w or W (for white tophat)
* or b or B (for black tophat), followed by a.b as for
* the dilation, erosion, opening and closing.
* Example valid sequences are:
* "c5.3 + o7.5"
* "c9.9 + tw9.9"
* </pre>
*/
PIX *
pixGrayMorphSequence(PIX *pixs,
const char *sequence,
l_int32 dispsep,
l_int32 dispy)
{
char *rawop, *op, *fname;
char buf[256];
l_int32 nops, i, valid, w, h, x, pdfout;
PIX *pixt1, *pixt2;
PIXA *pixa;
SARRAY *sa;
PROCNAME("pixGrayMorphSequence");
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;
/* Verify that the operation sequence is valid */
valid = TRUE;
for (i = 0; i < nops; i++) {
rawop = sarrayGetString(sa, i, L_NOCOPY);
op = stringRemoveChars(rawop, " \n\t");
switch (op[0])
{
case 'd':
case 'D':
case 'e':
case 'E':
case 'o':
case 'O':
case 'c':
case 'C':
if (sscanf(&op[1], "%d.%d", &w, &h) != 2) {
fprintf(stderr, "*** op: %s invalid\n", op);
valid = FALSE;
break;
}
if (w < 1 || (w & 1) == 0 || h < 1 || (h & 1) == 0 ) {
fprintf(stderr,
"*** op: %s; w = %d, h = %d; must both be odd\n",
op, w, h);
valid = FALSE;
break;
}
/* fprintf(stderr, "op = %s; w = %d, h = %d\n", op, w, h); */
break;
case 't':
case 'T':
if (op[1] != 'w' && op[1] != 'W' &&
op[1] != 'b' && op[1] != 'B') {
fprintf(stderr,
"*** op = %s; arg %c must be 'w' or 'b'\n", op, op[1]);
valid = FALSE;
break;
}
sscanf(&op[2], "%d.%d", &w, &h);
if (w < 1 || (w & 1) == 0 || h < 1 || (h & 1) == 0 ) {
fprintf(stderr,
"*** op: %s; w = %d, h = %d; must both be odd\n",
op, w, h);
valid = FALSE;
break;
}
/* fprintf(stderr, "op = %s", op); */
break;
default:
fprintf(stderr, "*** nonexistent op = %s\n", op);
valid = FALSE;
}
LEPT_FREE(op);
}
if (!valid) {
sarrayDestroy(&sa);
return (PIX *)ERROR_PTR("sequence invalid", 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);
}
pixt1 = pixCopy(NULL, pixs);
pixt2 = NULL;
x = 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 = pixDilateGray(pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'e':
case 'E':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixErodeGray(pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'o':
case 'O':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixOpenGray(pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'c':
case 'C':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixCloseGray(pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 't':
case 'T':
sscanf(&op[2], "%d.%d", &w, &h);
if (op[1] == 'w' || op[1] == 'W')
pixt2 = pixTophat(pixt1, w, h, L_TOPHAT_WHITE);
else /* 'b' or 'B' */
pixt2 = pixTophat(pixt1, w, h, L_TOPHAT_BLACK);
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, dispy);
x += dispsep;
}
if (pdfout)
pixaAddPix(pixa, pixt1, L_COPY);
}
if (pdfout) {
pixaConvertToPdf(pixa, 0, 1.0, L_FLATE_ENCODE, 0, fname, fname);
LEPT_FREE(fname);
pixaDestroy(&pixa);
}
sarrayDestroy(&sa);
return pixt1;
}
/*!
* pixMorphCompSequenceDwa()
*
* 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 dwa morphology on binary images, using brick Sels.
* (2) This runs a pipeline of operations; no branching is allowed.
* (3) It implements all brick Sels that have dimensions up to 63
* on each side, using a composite (linear + comb) when useful.
* (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) See pixMorphSequence() for further information about usage.
*/
PIX *
pixMorphCompSequenceDwa(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("pixMorphCompSequenceDwa");
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 = pixDilateCompBrickDwa(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 = pixErodeCompBrickDwa(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);
pixOpenCompBrickDwa(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);
pixCloseCompBrickDwa(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;
}
/*!
* \brief pixMorphCompSequenceDwa()
*
* \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 dwa morphology on binary images, using brick Sels.
* (2) This runs a pipeline of operations; no branching is allowed.
* (3) It implements all brick Sels that have dimensions up to 63
* on each side, using a composite (linear + comb) when useful.
* (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) See pixMorphSequence() for further information about usage.
* </pre>
*/
PIX *
pixMorphCompSequenceDwa(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("pixMorphCompSequenceDwa");
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 = pixDilateCompBrickDwa(NULL, pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'e':
case 'E':
sscanf(&op[1], "%d.%d", &w, &h);
pixt2 = pixErodeCompBrickDwa(NULL, pixt1, w, h);
pixSwapAndDestroy(&pixt1, &pixt2);
break;
case 'o':
case 'O':
sscanf(&op[1], "%d.%d", &w, &h);
pixOpenCompBrickDwa(pixt1, pixt1, w, h);
break;
case 'c':
case 'C':
sscanf(&op[1], "%d.%d", &w, &h);
pixCloseCompBrickDwa(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;
}
