main(int argc,
char **argv)
{
l_int32 i;
l_float32 pi, scale, angle;
PIX *pixc, *pixm, *pix1, *pix2, *pix3;
PIXA *pixa;
PTA *pta1, *pta2, *pta3, *pta4;
static char mainName[] = "smallpix_reg";
/* Make a small test image, the hard way! */
pi = 3.1415926535;
pixc = pixCreate(9, 9, 32);
pixm = pixCreate(9, 9, 1);
pta1 = generatePtaLineFromPt(4, 4, 3.1, 0.0);
pta2 = generatePtaLineFromPt(4, 4, 3.1, 0.5 * pi);
pta3 = generatePtaLineFromPt(4, 4, 3.1, pi);
pta4 = generatePtaLineFromPt(4, 4, 3.1, 1.5 * pi);
ptaJoin(pta1, pta2, 0, 0);
ptaJoin(pta1, pta3, 0, 0);
ptaJoin(pta1, pta4, 0, 0);
pixRenderPta(pixm, pta1, L_SET_PIXELS);
pixPaintThroughMask(pixc, pixm, 0, 0, 0x00ff0000);
ptaDestroy(&pta1);
ptaDestroy(&pta2);
ptaDestroy(&pta3);
ptaDestroy(&pta4);
pixDestroy(&pixm);
/* Results differ for scaleSmoothLow() w/ and w/out + 0.5.
* Neither is properly symmetric (with symm pattern on odd-sized
* pix, because the smoothing is destroying the symmetry. */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 2);
for (i = 0; i < 11; i++) {
scale = 0.30 + 0.035 * (l_float32)i;
pix2 = pixScaleSmooth(pix1, scale, scale);
pix3 = pixExpandReplicate(pix2, 6);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 100, NULL);
/* Results same for pixScaleAreaMap w/ and w/out + 0.5 */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 2);
for (i = 0; i < 11; i++) {
scale = 0.30 + 0.035 * (l_float32)i;
pix2 = pixScaleAreaMap(pix1, scale, scale);
pix3 = pixExpandReplicate(pix2, 6);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 200, NULL);
/* Results better for pixScaleBySampling with + 0.5, for small,
* odd-dimension pix. */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 2);
for (i = 0; i < 11; i++) {
scale = 0.30 + 0.035 * (l_float32)i;
pix2 = pixScaleBySampling(pix1, scale, scale);
pix3 = pixExpandReplicate(pix2, 6);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 300, NULL);
/* Results same for pixRotateAM w/ and w/out + 0.5 */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 1);
for (i = 0; i < 11; i++) {
angle = 0.10 + 0.05 * (l_float32)i;
pix2 = pixRotateAM(pix1, angle, L_BRING_IN_BLACK);
pix3 = pixExpandReplicate(pix2, 8);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 400, NULL);
/* If the size is odd, we express the center exactly, and the
* results are better for pixRotateBySampling() w/out 0.5
* However, if the size is even, the center value is not
* exact, and if we choose it 0.5 smaller than the actual
* center, we get symmetrical results with +0.5.
* So we choose not to include + 0.5. */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 1);
for (i = 0; i < 11; i++) {
angle = 0.10 + 0.05 * (l_float32)i;
pix2 = pixRotateBySampling(pix1, 4, 4, angle, L_BRING_IN_BLACK);
pix3 = pixExpandReplicate(pix2, 8);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 500, NULL);
/* Results same for pixRotateAMCorner w/ and w/out + 0.5 */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 1);
for (i = 0; i < 11; i++) {
angle = 0.10 + 0.05 * (l_float32)i;
pix2 = pixRotateAMCorner(pix1, angle, L_BRING_IN_BLACK);
pix3 = pixExpandReplicate(pix2, 8);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 600, NULL);
/* Results better for pixRotateAMColorFast without + 0.5 */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 1);
for (i = 0; i < 11; i++) {
angle = 0.10 + 0.05 * (l_float32)i;
pix2 = pixRotateAMColorFast(pix1, angle, 0);
pix3 = pixExpandReplicate(pix2, 8);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 700, NULL);
/* Results slightly better for pixScaleColorLI() w/out + 0.5 */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 1);
for (i = 0; i < 11; i++) {
scale = 1.0 + 0.2 * (l_float32)i;
pix2 = pixScaleColorLI(pix1, scale, scale);
pix3 = pixExpandReplicate(pix2, 4);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 800, NULL);
/* Results slightly better for pixScaleColorLI() w/out + 0.5 */
pixa = pixaCreate(11);
pix1 = pixExpandReplicate(pixc, 1);
for (i = 0; i < 11; i++) {
scale = 1.0 + 0.2 * (l_float32)i;
pix2 = pixScaleLI(pix1, scale, scale);
pix3 = pixExpandReplicate(pix2, 4);
pixSaveTiled(pix3, pixa, 1, (i == 0), 20, 32);
pixDestroy(&pix2);
pixDestroy(&pix3);
}
pixDestroy(&pix1);
DisplayPix(&pixa, 100, 940, NULL);
pixDestroy(&pixc);
return 0;
}
/*!
* 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;
}
/*!
* \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;
}