main(int argc,
char **argv)
{
PIX *pixd;
SEL *sel1, *sel2, *sel3, *sel4;
SELA *sela;
static char mainName[] = "livre_orient";
sel1 = selCreateFromString(textsel1, 5, 6, NULL);
sel2 = selCreateFromString(textsel2, 5, 6, NULL);
sel3 = selCreateFromString(textsel3, 5, 6, NULL);
sel4 = selCreateFromString(textsel4, 5, 6, NULL);
sela = selaCreate(4);
selaAddSel(sela, sel1, "textsel1", L_INSERT);
selaAddSel(sela, sel2, "textsel2", L_INSERT);
selaAddSel(sela, sel3, "textsel3", L_INSERT);
selaAddSel(sela, sel4, "textsel4", L_INSERT);
pixd = selaDisplayInPix(sela, 28, 3, 30, 4);
pixWrite("/tmp/orient.png", pixd, IFF_PNG);
pixDisplay(pixd, 100, 100);
pixDestroy(&pixd);
selaDestroy(&sela);
return 0;
}
main(int argc,
char **argv)
{
PIX *pix;
SEL *sel;
SELA *sela1, *sela2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
/* selaRead() / selaWrite() */
sela1 = selaAddBasic(NULL);
selaWrite("/tmp/sel.0.sela", sela1);
regTestCheckFile(rp, "/tmp/sel.0.sela"); /* 0 */
sela2 = selaRead("/tmp/sel.0.sela");
selaWrite("/tmp/sel.1.sela", sela2);
regTestCheckFile(rp, "/tmp/sel.1.sela"); /* 1 */
regTestCompareFiles(rp, 0, 1); /* 2 */
selaDestroy(&sela1);
selaDestroy(&sela2);
/* Create from file and display result */
sela1 = selaCreateFromFile("flipsels.txt");
pix = selaDisplayInPix(sela1, 31, 3, 15, 4);
regTestWritePixAndCheck(rp, pix, IFF_PNG); /* 3 */
pixDisplayWithTitle(pix, 100, 100, NULL, rp->display);
selaWrite("/tmp/sel.3.sela", sela1);
regTestCheckFile(rp, "/tmp/sel.3.sela"); /* 4 */
pixDestroy(&pix);
selaDestroy(&sela1);
/* Create the same set of Sels from compiled strings and compare */
sela2 = selaCreate(4);
sel = selCreateFromString(textsel1, 5, 6, "textsel1");
selaAddSel(sela2, sel, NULL, 0);
sel = selCreateFromString(textsel2, 5, 6, "textsel2");
selaAddSel(sela2, sel, NULL, 0);
sel = selCreateFromString(textsel3, 5, 6, "textsel3");
selaAddSel(sela2, sel, NULL, 0);
sel = selCreateFromString(textsel4, 5, 6, "textsel4");
selaAddSel(sela2, sel, NULL, 0);
selaWrite("/tmp/sel.4.sela", sela2);
regTestCheckFile(rp, "/tmp/sel.4.sela"); /* 5 */
regTestCompareFiles(rp, 4, 5); /* 6 */
selaDestroy(&sela2);
return regTestCleanup(rp);
}
/*!
* pixThinExamples()
*
* Input: pixs (1 bpp)
* type (L_THIN_FG, L_THIN_BG)
* index (into specific examples; valid 1-9; see notes)
* maxiters (max number of iters allowed; use 0 to iterate
* until completion)
* selfile (<optional> filename for output sel display)
* Return: pixd, or null on error
*
* Notes:
* (1) See notes in pixThin(). The examples are taken from
* the paper referenced there.
* (2) Here we allow specific sets of HMTs to be used in
* parallel for thinning from each of four directions.
* One iteration consists of four such parallel thins.
* (3) The examples are indexed as follows:
* Thinning (e.g., run to completion):
* index = 1 sel_4_1, sel_4_5, sel_4_6
* index = 2 sel_4_1, sel_4_7, sel_4_7_rot
* index = 3 sel_48_1, sel_48_1_rot, sel_48_2
* index = 4 sel_8_2, sel_8_3, sel_48_2
* index = 5 sel_8_1, sel_8_5, sel_8_6
* index = 6 sel_8_2, sel_8_3, sel_8_8, sel_8_9
* index = 7 sel_8_5, sel_8_6, sel_8_7, sel_8_7_rot
* Thickening:
* index = 8 sel_4_2, sel_4_3 (e.g,, do just a few iterations)
* index = 9 sel_8_4 (e.g., do just a few iterations)
*/
PIX *
pixThinExamples(PIX *pixs,
l_int32 type,
l_int32 index,
l_int32 maxiters,
const char *selfile)
{
PIX *pixd, *pixt;
SEL *sel;
SELA *sela;
PROCNAME("pixThinExamples");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (pixGetDepth(pixs) != 1)
return (PIX *)ERROR_PTR("pixs not 1 bpp", procName, NULL);
if (type != L_THIN_FG && type != L_THIN_BG)
return (PIX *)ERROR_PTR("invalid fg/bg type", procName, NULL);
if (index < 1 || index > 9)
return (PIX *)ERROR_PTR("invalid index", procName, NULL);
if (maxiters == 0) maxiters = 10000;
switch(index)
{
case 1:
sela = selaCreate(3);
sel = selCreateFromString(sel_4_1, 3, 3, "sel_4_1");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_4_5, 3, 3, "sel_4_5");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_4_6, 3, 3, "sel_4_6");
selaAddSel(sela, sel, NULL, 0);
break;
case 2:
sela = selaCreate(3);
sel = selCreateFromString(sel_4_1, 3, 3, "sel_4_1");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_4_7, 3, 3, "sel_4_7");
selaAddSel(sela, sel, NULL, 0);
sel = selRotateOrth(sel, 1);
selaAddSel(sela, sel, "sel_4_7_rot", 0);
break;
case 3:
sela = selaCreate(3);
sel = selCreateFromString(sel_48_1, 3, 3, "sel_48_1");
selaAddSel(sela, sel, NULL, 0);
sel = selRotateOrth(sel, 1);
selaAddSel(sela, sel, "sel_48_1_rot", 0);
sel = selCreateFromString(sel_48_2, 3, 3, "sel_48_2");
selaAddSel(sela, sel, NULL, 0);
break;
case 4:
sela = selaCreate(3);
sel = selCreateFromString(sel_8_2, 3, 3, "sel_8_2");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_8_3, 3, 3, "sel_8_3");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_48_2, 3, 3, "sel_48_2");
selaAddSel(sela, sel, NULL, 0);
break;
case 5:
sela = selaCreate(3);
sel = selCreateFromString(sel_8_1, 3, 3, "sel_8_1");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_8_5, 3, 3, "sel_8_5");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_8_6, 3, 3, "sel_8_6");
selaAddSel(sela, sel, NULL, 0);
break;
case 6:
sela = selaCreate(4);
sel = selCreateFromString(sel_8_2, 3, 3, "sel_8_2");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_8_3, 3, 3, "sel_8_3");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_8_8, 3, 3, "sel_8_8");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_8_9, 3, 3, "sel_8_9");
selaAddSel(sela, sel, NULL, 0);
break;
case 7:
sela = selaCreate(4);
sel = selCreateFromString(sel_8_5, 3, 3, "sel_8_5");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_8_6, 3, 3, "sel_8_6");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_8_7, 3, 3, "sel_8_7");
selaAddSel(sela, sel, NULL, 0);
sel = selRotateOrth(sel, 1);
selaAddSel(sela, sel, "sel_8_7_rot", 0);
break;
case 8: /* thicken for this one; just a few iterations */
sela = selaCreate(2);
sel = selCreateFromString(sel_4_2, 3, 3, "sel_4_2");
selaAddSel(sela, sel, NULL, 0);
sel = selCreateFromString(sel_4_3, 3, 3, "sel_4_3");
selaAddSel(sela, sel, NULL, 0);
pixt = pixThinGeneral(pixs, type, sela, maxiters);
pixd = pixRemoveBorderConnComps(pixt, 4);
pixDestroy(&pixt);
break;
case 9: /* thicken for this one; just a few iterations */
sela = selaCreate(1);
sel = selCreateFromString(sel_8_4, 3, 3, "sel_8_4");
selaAddSel(sela, sel, NULL, 0);
pixt = pixThinGeneral(pixs, type, sela, maxiters);
pixd = pixRemoveBorderConnComps(pixt, 4);
pixDestroy(&pixt);
break;
default:
return (PIX *)ERROR_PTR("invalid index", procName, NULL);
}
if (index <= 7)
pixd = pixThinGeneral(pixs, type, sela, maxiters);
/* Optionally display the sels */
if (selfile) {
pixt = selaDisplayInPix(sela, 35, 3, 15, 4);
pixWrite(selfile, pixt, IFF_PNG);
pixDestroy(&pixt);
}
selaDestroy(&sela);
return pixd;
}
/*!
* pixThinGeneral()
*
* Input: pixs (1 bpp)
* type (L_THIN_FG, L_THIN_BG)
* sela (of Sels for parallel composite HMTs)
* maxiters (max number of iters allowed; use 0 to iterate
* until completion)
* Return: pixd, or null on error
*
* Notes:
* (1) See notes in pixThin(). That function chooses among
* the best of the Sels for thinning.
* (2) This is a general function that takes a Sela of HMTs
* that are used in parallel for thinning from each
* of four directions. One iteration consists of four
* such parallel thins.
*/
PIX *
pixThinGeneral(PIX *pixs,
l_int32 type,
SELA *sela,
l_int32 maxiters)
{
l_int32 i, j, r, nsels, same;
PIXA *pixahmt;
PIX **pixhmt; /* array owned by pixahmt; do not destroy! */
PIX *pixd, *pixt;
SEL *sel, *selr;
PROCNAME("pixThinGeneral");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (pixGetDepth(pixs) != 1)
return (PIX *)ERROR_PTR("pixs not 1 bpp", procName, NULL);
if (type != L_THIN_FG && type != L_THIN_BG)
return (PIX *)ERROR_PTR("invalid fg/bg type", procName, NULL);
if (!sela)
return (PIX *)ERROR_PTR("sela not defined", procName, NULL);
if (maxiters == 0) maxiters = 10000;
/* Set up array of temp pix to hold hmts */
nsels = selaGetCount(sela);
pixahmt = pixaCreate(nsels);
for (i = 0; i < nsels; i++) {
pixt = pixCreateTemplate(pixs);
pixaAddPix(pixahmt, pixt, L_INSERT);
}
pixhmt = pixaGetPixArray(pixahmt);
if (!pixhmt)
return (PIX *)ERROR_PTR("pixhmt array not made", procName, NULL);
#if DEBUG_SELS
pixt = selaDisplayInPix(sela, 35, 3, 15, 4);
pixDisplayWithTitle(pixt, 100, 100, "allsels", 1);
pixDestroy(&pixt);
#endif /* DEBUG_SELS */
/* Set up initial image for fg thinning */
if (type == L_THIN_FG)
pixd = pixCopy(NULL, pixs);
else /* bg thinning */
pixd = pixInvert(NULL, pixs);
/* Thin the fg, with up to maxiters iterations */
for (i = 0; i < maxiters; i++) {
pixt = pixCopy(NULL, pixd); /* test for completion */
for (r = 0; r < 4; r++) { /* over 90 degree rotations of Sels */
for (j = 0; j < nsels; j++) { /* over individual sels in sela */
sel = selaGetSel(sela, j); /* not a copy */
selr = selRotateOrth(sel, r);
pixHMT(pixhmt[j], pixd, selr);
selDestroy(&selr);
if (j > 0)
pixOr(pixhmt[0], pixhmt[0], pixhmt[j]); /* accum result */
}
pixSubtract(pixd, pixd, pixhmt[0]); /* remove result */
}
pixEqual(pixd, pixt, &same);
pixDestroy(&pixt);
if (same) {
L_INFO("%d iterations to completion\n", procName, i);
break;
}
}
if (type == L_THIN_BG)
pixInvert(pixd, pixd);
pixaDestroy(&pixahmt);
return pixd;
}
/*!
* selaAddTJunctions()
*
* Input: sela (<optional>)
* hlsize (length of each line of hits from origin)
* mdist (distance of misses from the origin)
* norient (number of orientations; max of 8)
* debugflag (1 for debug output)
* Return: sela with additional sels, or null on error
*
* Notes:
* (1) Adds hitmiss Sels for the T-junction of two lines.
* If the lines are very thin, they must be nearly orthogonal
* to register.
* (2) The number of Sels generated is 4 * @norient.
* (3) It is suggested that @hlsize be chosen at least 1 greater
* than @mdist. Try values of (@hlsize, @mdist) such as
* (6,5), (7,6), (8,7), (9,7), etc.
*/
SELA *
selaAddTJunctions(SELA *sela,
l_float32 hlsize,
l_float32 mdist,
l_int32 norient,
l_int32 debugflag)
{
char name[L_BUF_SIZE];
l_int32 i, j, k, w, xc, yc;
l_float64 pi, halfpi, radincr, jang, radang;
l_float64 angle[3], dist[3];
PIX *pixc, *pixm, *pixt;
PIXA *pixa;
PTA *pta1, *pta2, *pta3;
SEL *sel;
PROCNAME("selaAddTJunctions");
if (hlsize <= 2)
return (SELA *)ERROR_PTR("hlsizel not > 1", procName, NULL);
if (norient < 1 || norient > 8)
return (SELA *)ERROR_PTR("norient not in [1, ... 8]", procName, NULL);
if (!sela) {
if ((sela = selaCreate(0)) == NULL)
return (SELA *)ERROR_PTR("sela not made", procName, NULL);
}
pi = 3.1415926535;
halfpi = 3.1415926535 / 2.0;
radincr = halfpi / (l_float32)norient;
w = (l_int32)(2.4 * (L_MAX(hlsize, mdist) + 0.5));
if (w % 2 == 0)
w++;
xc = w / 2;
yc = w / 2;
pixa = pixaCreate(4 * norient);
for (i = 0; i < norient; i++) {
for (j = 0; j < 4; j++) { /* 4 orthogonal orientations */
jang = (l_float32)j * halfpi;
/* Set the don't cares */
pixc = pixCreate(w, w, 32);
pixSetAll(pixc);
/* Add the green lines of hits */
pixm = pixCreate(w, w, 1);
radang = (l_float32)i * radincr;
pta1 = generatePtaLineFromPt(xc, yc, hlsize + 1, jang + radang);
pta2 = generatePtaLineFromPt(xc, yc, hlsize + 1,
jang + radang + halfpi);
pta3 = generatePtaLineFromPt(xc, yc, hlsize + 1,
jang + radang + pi);
ptaJoin(pta1, pta2, 0, -1);
ptaJoin(pta1, pta3, 0, -1);
pixRenderPta(pixm, pta1, L_SET_PIXELS);
pixPaintThroughMask(pixc, pixm, 0, 0, 0x00ff0000);
ptaDestroy(&pta1);
ptaDestroy(&pta2);
ptaDestroy(&pta3);
/* Add red misses between the lines */
angle[0] = radang + jang - halfpi;
angle[1] = radang + jang + 0.5 * halfpi;
angle[2] = radang + jang + 1.5 * halfpi;
dist[0] = 0.8 * mdist;
dist[1] = dist[2] = mdist;
for (k = 0; k < 3; k++) {
pixSetPixel(pixc, xc + (l_int32)(dist[k] * cos(angle[k])),
yc + (l_int32)(dist[k] * sin(angle[k])),
0xff000000);
}
/* Add dark green for origin */
pixSetPixel(pixc, xc, yc, 0x00550000);
/* Generate the sel */
sel = selCreateFromColorPix(pixc, NULL);
sprintf(name, "sel_cross_%d", 4 * i + j);
selaAddSel(sela, sel, name, 0);
if (debugflag) {
pixt = pixScaleBySampling(pixc, 10.0, 10.0);
pixaAddPix(pixa, pixt, L_INSERT);
}
pixDestroy(&pixm);
pixDestroy(&pixc);
}
}
if (debugflag) {
l_int32 w;
pixaGetPixDimensions(pixa, 0, &w, NULL, NULL);
pixt = pixaDisplayTiledAndScaled(pixa, 32, w, 4, 0, 10, 2);
pixWriteTempfile("/tmp", "tsel1.png", pixt, IFF_PNG, 0);
pixDisplay(pixt, 0, 100);
pixDestroy(&pixt);
pixt = selaDisplayInPix(sela, 15, 2, 20, 4);
pixWriteTempfile("/tmp", "tsel2.png", pixt, IFF_PNG, 0);
pixDisplay(pixt, 500, 100);
pixDestroy(&pixt);
selaWriteStream(stderr, sela);
}
pixaDestroy(&pixa);
return sela;
}
int main(int argc,
char **argv)
{
BOX *box;
PIX *pix, *pixs, *pixd, *pixt;
PIXA *pixa;
SEL *sel, *sel1, *sel2, *sel3;
SELA *sela4, *sela8, *sela48;
static char mainName[] = "ccthin1_reg";
if (argc != 1)
return ERROR_INT(" Syntax: ccthin1_reg", mainName, 1);
/* Generate and display all of the 4-cc sels */
sela4 = selaCreate(9);
sel = selCreateFromString(sel_4_1, 3, 3, "sel_4_1");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_2, 3, 3, "sel_4_2");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_3, 3, 3, "sel_4_3");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_4, 3, 3, "sel_4_4");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_5, 3, 3, "sel_4_5");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_6, 3, 3, "sel_4_6");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_7, 3, 3, "sel_4_7");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_8, 3, 3, "sel_4_8");
selaAddSel(sela4, sel, NULL, 0);
sel = selCreateFromString(sel_4_9, 3, 3, "sel_4_9");
selaAddSel(sela4, sel, NULL, 0);
pixt = selaDisplayInPix(sela4, 35, 3, 15, 3);
pixWrite("/tmp/junkallsel4.png", pixt, IFF_PNG);
pixDestroy(&pixt);
selaDestroy(&sela4);
/* Generate and display all of the 8-cc sels */
sela8 = selaCreate(9);
sel = selCreateFromString(sel_8_1, 3, 3, "sel_8_1");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_2, 3, 3, "sel_8_2");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_3, 3, 3, "sel_8_3");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_4, 3, 3, "sel_8_4");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_5, 3, 3, "sel_8_5");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_6, 3, 3, "sel_8_6");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_7, 3, 3, "sel_8_7");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_8, 3, 3, "sel_8_8");
selaAddSel(sela8, sel, NULL, 0);
sel = selCreateFromString(sel_8_9, 3, 3, "sel_8_9");
selaAddSel(sela8, sel, NULL, 0);
pixt = selaDisplayInPix(sela8, 35, 3, 15, 3);
pixWrite("/tmp/junkallsel8.png", pixt, IFF_PNG);
pixDestroy(&pixt);
selaDestroy(&sela8);
/* Generate and display all of the 4 and 8-cc preserving sels */
sela48 = selaCreate(3);
sel = selCreateFromString(sel_48_1, 3, 3, "sel_48_1");
selaAddSel(sela48, sel, NULL, 0);
sel = selCreateFromString(sel_48_2, 3, 3, "sel_48_2");
selaAddSel(sela48, sel, NULL, 0);
pixt = selaDisplayInPix(sela48, 35, 3, 15, 4);
pixWrite("/tmp/junkallsel48.png", pixt, IFF_PNG);
pixDestroy(&pixt);
selaDestroy(&sela48);
/* Generate and display three of the 4-cc sels and their rotations */
sela4 = selaCreate(3);
sel = selCreateFromString(sel_4_1, 3, 3, "sel_4_1");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela4, sel, NULL, 0);
selaAddSel(sela4, sel1, "sel_4_1_90", 0);
selaAddSel(sela4, sel2, "sel_4_1_180", 0);
selaAddSel(sela4, sel3, "sel_4_1_270", 0);
sel = selCreateFromString(sel_4_2, 3, 3, "sel_4_2");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela4, sel, NULL, 0);
selaAddSel(sela4, sel1, "sel_4_2_90", 0);
selaAddSel(sela4, sel2, "sel_4_2_180", 0);
selaAddSel(sela4, sel3, "sel_4_2_270", 0);
sel = selCreateFromString(sel_4_3, 3, 3, "sel_4_3");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela4, sel, NULL, 0);
selaAddSel(sela4, sel1, "sel_4_3_90", 0);
selaAddSel(sela4, sel2, "sel_4_3_180", 0);
selaAddSel(sela4, sel3, "sel_4_3_270", 0);
pixt = selaDisplayInPix(sela4, 35, 3, 15, 4);
pixWrite("/tmp/junksel4.png", pixt, IFF_PNG);
pixDestroy(&pixt);
selaDestroy(&sela4);
/* Generate and display four of the 8-cc sels and their rotations */
sela8 = selaCreate(4);
sel = selCreateFromString(sel_8_2, 3, 3, "sel_8_2");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela8, sel, NULL, 0);
selaAddSel(sela8, sel1, "sel_8_2_90", 0);
selaAddSel(sela8, sel2, "sel_8_2_180", 0);
selaAddSel(sela8, sel3, "sel_8_2_270", 0);
sel = selCreateFromString(sel_8_3, 3, 3, "sel_8_3");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela8, sel, NULL, 0);
selaAddSel(sela8, sel1, "sel_8_3_90", 0);
selaAddSel(sela8, sel2, "sel_8_3_180", 0);
selaAddSel(sela8, sel3, "sel_8_3_270", 0);
sel = selCreateFromString(sel_8_5, 3, 3, "sel_8_5");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela8, sel, NULL, 0);
selaAddSel(sela8, sel1, "sel_8_5_90", 0);
selaAddSel(sela8, sel2, "sel_8_5_180", 0);
selaAddSel(sela8, sel3, "sel_8_5_270", 0);
sel = selCreateFromString(sel_8_6, 3, 3, "sel_8_6");
sel1 = selRotateOrth(sel, 1);
sel2 = selRotateOrth(sel, 2);
sel3 = selRotateOrth(sel, 3);
selaAddSel(sela8, sel, NULL, 0);
selaAddSel(sela8, sel1, "sel_8_6_90", 0);
selaAddSel(sela8, sel2, "sel_8_6_180", 0);
selaAddSel(sela8, sel3, "sel_8_6_270", 0);
pixt = selaDisplayInPix(sela8, 35, 3, 15, 4);
pixWrite("/tmp/junksel8.png", pixt, IFF_PNG);
pixDestroy(&pixt);
selaDestroy(&sela8);
/* Test the best 4 and 8 cc thinning */
pixDisplayWrite(NULL, 0);
pix = pixRead("feyn.tif");
box = boxCreate(683, 799, 970, 479);
pixs = pixClipRectangle(pix, box, NULL);
pixDisplayWrite(pixs, 1);
pixt = pixThin(pixs, L_THIN_FG, 4, 0);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThin(pixs, L_THIN_BG, 4, 0);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThin(pixs, L_THIN_FG, 8, 0);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
pixt = pixThin(pixs, L_THIN_BG, 8, 0);
pixDisplayWrite(pixt, 1);
pixDestroy(&pixt);
/* Display tiled */
pixa = pixaReadFiles("/tmp/display", "file");
pixd = pixaDisplayTiledAndScaled(pixa, 8, 500, 1, 0, 25, 2);
pixWrite("/tmp/junktiles.jpg", pixd, IFF_JFIF_JPEG);
pixDestroy(&pixd);
pixaDestroy(&pixa);
pixDestroy(&pix);
pixDestroy(&pixs);
boxDestroy(&box);
pixDisplayMultiple("/tmp/display/file*");
return 0;
}
/*!
* \brief selaAddCrossJunctions()
*
* \param[in] sela [optional]
* \param[in] hlsize length of each line of hits from origin
* \param[in] mdist distance of misses from the origin
* \param[in] norient number of orientations; max of 8
* \param[in] debugflag 1 for debug output
* \return sela with additional sels, or NULL on error
*
* <pre>
* Notes:
* (1) Adds hitmiss Sels for the intersection of two lines.
* If the lines are very thin, they must be nearly orthogonal
* to register.
* (2) The number of Sels generated is equal to %norient.
* (3) If %norient == 2, this generates 2 Sels of crosses, each with
* two perpendicular lines of hits. One Sel has horizontal and
* vertical hits; the other has hits along lines at +-45 degrees.
* Likewise, if %norient == 3, this generates 3 Sels of crosses
* oriented at 30 degrees with each other.
* (4) It is suggested that %hlsize be chosen at least 1 greater
* than %mdist. Try values of (%hlsize, %mdist) such as
* (6,5), (7,6), (8,7), (9,7), etc.
* </pre>
*/
SELA *
selaAddCrossJunctions(SELA *sela,
l_float32 hlsize,
l_float32 mdist,
l_int32 norient,
l_int32 debugflag)
{
char name[L_BUF_SIZE];
l_int32 i, j, w, xc, yc;
l_float64 pi, halfpi, radincr, radang;
l_float64 angle;
PIX *pixc, *pixm, *pixt;
PIXA *pixa;
PTA *pta1, *pta2, *pta3, *pta4;
SEL *sel;
PROCNAME("selaAddCrossJunctions");
if (hlsize <= 0)
return (SELA *)ERROR_PTR("hlsize not > 0", procName, NULL);
if (norient < 1 || norient > 8)
return (SELA *)ERROR_PTR("norient not in [1, ... 8]", procName, NULL);
if (!sela) {
if ((sela = selaCreate(0)) == NULL)
return (SELA *)ERROR_PTR("sela not made", procName, NULL);
}
pi = 3.1415926535;
halfpi = 3.1415926535 / 2.0;
radincr = halfpi / (l_float64)norient;
w = (l_int32)(2.2 * (L_MAX(hlsize, mdist) + 0.5));
if (w % 2 == 0)
w++;
xc = w / 2;
yc = w / 2;
pixa = pixaCreate(norient);
for (i = 0; i < norient; i++) {
/* Set the don't cares */
pixc = pixCreate(w, w, 32);
pixSetAll(pixc);
/* Add the green lines of hits */
pixm = pixCreate(w, w, 1);
radang = (l_float32)i * radincr;
pta1 = generatePtaLineFromPt(xc, yc, hlsize + 1, radang);
pta2 = generatePtaLineFromPt(xc, yc, hlsize + 1, radang + halfpi);
pta3 = generatePtaLineFromPt(xc, yc, hlsize + 1, radang + pi);
pta4 = generatePtaLineFromPt(xc, yc, hlsize + 1, radang + pi + halfpi);
ptaJoin(pta1, pta2, 0, -1);
ptaJoin(pta1, pta3, 0, -1);
ptaJoin(pta1, pta4, 0, -1);
pixRenderPta(pixm, pta1, L_SET_PIXELS);
pixPaintThroughMask(pixc, pixm, 0, 0, 0x00ff0000);
ptaDestroy(&pta1);
ptaDestroy(&pta2);
ptaDestroy(&pta3);
ptaDestroy(&pta4);
/* Add red misses between the lines */
for (j = 0; j < 4; j++) {
angle = radang + (j - 0.5) * halfpi;
pixSetPixel(pixc, xc + (l_int32)(mdist * cos(angle)),
yc + (l_int32)(mdist * sin(angle)), 0xff000000);
}
/* Add dark green for origin */
pixSetPixel(pixc, xc, yc, 0x00550000);
/* Generate the sel */
sel = selCreateFromColorPix(pixc, NULL);
sprintf(name, "sel_cross_%d", i);
selaAddSel(sela, sel, name, 0);
if (debugflag) {
pixt = pixScaleBySampling(pixc, 10.0, 10.0);
pixaAddPix(pixa, pixt, L_INSERT);
}
pixDestroy(&pixm);
pixDestroy(&pixc);
}
if (debugflag) {
l_int32 w;
lept_mkdir("lept/sel");
pixaGetPixDimensions(pixa, 0, &w, NULL, NULL);
pixt = pixaDisplayTiledAndScaled(pixa, 32, w, 1, 0, 10, 2);
pixWrite("/tmp/lept/sel/xsel1.png", pixt, IFF_PNG);
pixDisplay(pixt, 0, 100);
pixDestroy(&pixt);
pixt = selaDisplayInPix(sela, 15, 2, 20, 1);
pixWrite("/tmp/lept/sel/xsel2.png", pixt, IFF_PNG);
pixDisplay(pixt, 500, 100);
pixDestroy(&pixt);
selaWriteStream(stderr, sela);
}
pixaDestroy(&pixa);
return sela;
}