/*!
* wshedRenderColors()
*
* Input: wshed
* Return: pixd (initial image with all basins filled), or null on error
*/
PIX *
wshedRenderColors(L_WSHED *wshed) {
l_int32 w, h;
PIX *pixg, *pixt, *pixc, *pixm, *pixd;
PIXA *pixa;
PROCNAME("wshedRenderColors");
if (!wshed)
return (PIX *) ERROR_PTR("wshed not defined", procName, NULL);
wshedBasins(wshed, &pixa, NULL);
pixg = pixCopy(NULL, wshed->pixs);
pixGetDimensions(wshed->pixs, &w, &h, NULL);
pixd = pixConvertTo32(pixg);
pixt = pixaDisplayRandomCmap(pixa, w, h);
pixc = pixConvertTo32(pixt);
pixm = pixaDisplay(pixa, w, h);
pixCombineMasked(pixd, pixc, pixm);
pixDestroy(&pixg);
pixDestroy(&pixt);
pixDestroy(&pixc);
pixDestroy(&pixm);
pixaDestroy(&pixa);
return pixd;
}
static PIX *
QuantizeNonImageRegion(PIX *pixs,
PIX *pixm,
l_int32 levels) {
PIX *pix1, *pix2, *pixd;
pix1 = pixConvertTo8(pixs, 0);
pix2 = pixThresholdOn8bpp(pix1, levels, 1);
pixd = pixConvertTo32(pix2); /* save in rgb */
pixCombineMasked(pixd, pixs, pixm); /* rgb result */
pixDestroy(&pix1);
pixDestroy(&pix2);
return pixd;
}
/*!
* pixMaskedThreshOnBackgroundNorm()
*
* Input: pixs (8 bpp grayscale; not colormapped)
* pixim (<optional> 1 bpp 'image' mask; can be null)
* sx, sy (tile size in pixels)
* thresh (threshold for determining foreground)
* mincount (min threshold on counts in a tile)
* smoothx (half-width of block convolution kernel width)
* smoothy (half-width of block convolution kernel height)
* scorefract (fraction of the max Otsu score; typ. ~ 0.1)
* &thresh (<optional return> threshold value that was
* used on the normalized image)
* Return: pixd (1 bpp thresholded image), or null on error
*
* Notes:
* (1) This begins with a standard background normalization.
* Additionally, there is a flexible background norm, that
* will adapt to a rapidly varying background, and this
* puts white pixels in the background near regions with
* significant foreground. The white pixels are turned into
* a 1 bpp selection mask by binarization followed by dilation.
* Otsu thresholding is performed on the input image to get an
* estimate of the threshold in the non-mask regions.
* The background normalized image is thresholded with two
* different values, and the result is combined using
* the selection mask.
* (2) Note that the numbers 255 (for bgval target) and 190 (for
* thresholding on pixn) are tied together, and explicitly
* defined in this function.
* (3) See pixBackgroundNorm() for meaning and typical values
* of input parameters. For a start, you can try:
* sx, sy = 10, 15
* thresh = 100
* mincount = 50
* smoothx, smoothy = 2
*/
PIX *
pixMaskedThreshOnBackgroundNorm(PIX *pixs,
PIX *pixim,
l_int32 sx,
l_int32 sy,
l_int32 thresh,
l_int32 mincount,
l_int32 smoothx,
l_int32 smoothy,
l_float32 scorefract,
l_int32 *pthresh)
{
l_int32 w, h;
l_uint32 val;
PIX *pixn, *pixm, *pixd, *pixt1, *pixt2, *pixt3, *pixt4;
PROCNAME("pixMaskedThreshOnBackgroundNorm");
if (pthresh) *pthresh = 0;
if (!pixs || pixGetDepth(pixs) != 8)
return (PIX *)ERROR_PTR("pixs undefined or not 8 bpp", procName, NULL);
if (pixGetColormap(pixs))
return (PIX *)ERROR_PTR("pixs is colormapped", procName, NULL);
if (sx < 4 || sy < 4)
return (PIX *)ERROR_PTR("sx and sy must be >= 4", procName, NULL);
if (mincount > sx * sy) {
L_WARNING("mincount too large for tile size\n", procName);
mincount = (sx * sy) / 3;
}
/* Standard background normalization */
pixn = pixBackgroundNorm(pixs, pixim, NULL, sx, sy, thresh,
mincount, 255, smoothx, smoothy);
if (!pixn)
return (PIX *)ERROR_PTR("pixn not made", procName, NULL);
/* Special background normalization for adaptation to quickly
* varying background. Threshold on the very light parts,
* which tend to be near significant edges, and dilate to
* form a mask over regions that are typically text. The
* dilation size is chosen to cover the text completely,
* except for very thick fonts. */
pixt1 = pixBackgroundNormFlex(pixs, 7, 7, 1, 1, 20);
pixt2 = pixThresholdToBinary(pixt1, 240);
pixInvert(pixt2, pixt2);
pixm = pixMorphSequence(pixt2, "d21.21", 0);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
/* Use Otsu to get a global threshold estimate for the image,
* which is stored as a single pixel in pixt3. */
pixGetDimensions(pixs, &w, &h, NULL);
pixOtsuAdaptiveThreshold(pixs, w, h, 0, 0, scorefract, &pixt3, NULL);
if (pixt3 && pthresh) {
pixGetPixel(pixt3, 0, 0, &val);
*pthresh = val;
}
pixDestroy(&pixt3);
/* Threshold the background normalized images differentially,
* using a high value correlated with the background normalization
* for the part of the image under the mask (i.e., near the
* darker, thicker foreground), and a value that depends on the Otsu
* threshold for the rest of the image. This gives a solid
* (high) thresholding for the foreground parts of the image,
* while allowing the background and light foreground to be
* reasonably well cleaned using a threshold adapted to the
* input image. */
pixd = pixThresholdToBinary(pixn, val + 30); /* for bg and light fg */
pixt4 = pixThresholdToBinary(pixn, 190); /* for heavier fg */
pixCombineMasked(pixd, pixt4, pixm);
pixDestroy(&pixt4);
pixDestroy(&pixm);
pixDestroy(&pixn);
if (!pixd)
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
else
return pixd;
}
/*!
* Note: this method is generally inferior to pixHasColorRegions(); it
* is retained as a reference only
*
* \brief pixFindColorRegionsLight()
*
* \param[in] pixs 32 bpp rgb
* \param[in] pixm [optional] 1 bpp mask image
* \param[in] factor subsample factor; integer >= 1
* \param[in] darkthresh threshold to eliminate dark pixels (e.g., text)
* from consideration; typ. 70; -1 for default.
* \param[in] lightthresh threshold for minimum gray value at 95% rank
* near white; typ. 220; -1 for default
* \param[in] mindiff minimum difference from 95% rank value, used
* to count darker pixels; typ. 50; -1 for default
* \param[in] colordiff minimum difference in (max - min) component to
* qualify as a color pixel; typ. 40; -1 for default
* \param[out] pcolorfract fraction of 'color' pixels found
* \param[out] pcolormask1 [optional] mask over background color, if any
* \param[out] pcolormask2 [optional] filtered mask over background color
* \param[out] pixadb [optional] debug intermediate results
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) This function tries to determine if there is a significant
* color or darker region on a scanned page image where part
* of the image is very close to "white". It will also allow
* extraction of small regions of lightly colored pixels.
* If the background is darker (and reddish), use instead
* pixHasColorRegions2().
* (2) If %pixm exists, only pixels under fg are considered. Typically,
* the inverse of %pixm would have fg pixels over a photograph.
* (3) There are four thresholds.
* * %darkthresh: ignore pixels darker than this (typ. fg text).
* We make a 1 bpp mask of these pixels, and then dilate it to
* remove all vestiges of fg from their vicinity.
* * %lightthresh: let val95 be the pixel value for which 95%
* of the non-masked pixels have a lower value (darker) of
* their min component. Then if val95 is darker than
* %lightthresh, the image is not considered to have a
* light bg, and this returns 0.0 for %colorfract.
* * %mindiff: we are interested in the fraction of pixels that
* have two conditions. The first is that their min component
* is at least %mindiff darker than val95.
* * %colordiff: the second condition is that the max-min diff
* of the pixel components exceeds %colordiff.
* (4) This returns in %pcolorfract the fraction of pixels that have
* both a min component that is at least %mindiff below that at the
* 95% rank value (where 100% rank is the lightest value), and
* a max-min diff that is at least %colordiff. Without the
* %colordiff constraint, gray pixels of intermediate value
* could get flagged by this function.
* (5) No masks are returned unless light color pixels are found.
* If colorfract > 0.0 and %pcolormask1 is defined, this returns
* a 1 bpp mask with fg pixels over the color background.
* This mask may have some holes in it.
* (6) If colorfract > 0.0 and %pcolormask2 is defined, this returns
* a filtered version of colormask1. The two changes are
* (a) small holes have been filled
* (b) components near the border have been removed.
* The latter insures that dark pixels near the edge of the
* image are not included.
* (7) To generate a boxa of rectangular regions from the overlap
* of components in the filtered mask:
* boxa1 = pixConnCompBB(colormask2, 8);
* boxa2 = boxaCombineOverlaps(boxa1);
* This is done here in debug mode.
* </pre>
*/
static l_int32
pixFindColorRegionsLight(PIX *pixs,
PIX *pixm,
l_int32 factor,
l_int32 darkthresh,
l_int32 lightthresh,
l_int32 mindiff,
l_int32 colordiff,
l_float32 *pcolorfract,
PIX **pcolormask1,
PIX **pcolormask2,
PIXA *pixadb)
{
l_int32 lightbg, w, h, count;
l_float32 ratio, val95, rank;
BOXA *boxa1, *boxa2;
NUMA *nah;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pixm1, *pixm2, *pixm3;
PROCNAME("pixFindColorRegionsLight");
if (pcolormask1) *pcolormask1 = NULL;
if (pcolormask2) *pcolormask2 = NULL;
if (!pcolorfract)
return ERROR_INT("&colorfract not defined", procName, 1);
*pcolorfract = 0.0;
if (!pixs || pixGetDepth(pixs) != 32)
return ERROR_INT("pixs not defined or not 32 bpp", procName, 1);
if (factor < 1) factor = 1;
if (darkthresh < 0) darkthresh = 70; /* defaults */
if (lightthresh < 0) lightthresh = 220;
if (mindiff < 0) mindiff = 50;
if (colordiff < 0) colordiff = 40;
/* Check if pixm covers most of the image. If so, just return. */
pixGetDimensions(pixs, &w, &h, NULL);
if (pixm) {
pixCountPixels(pixm, &count, NULL);
ratio = (l_float32)count / ((l_float32)(w) * h);
if (ratio > 0.7) {
if (pixadb) L_INFO("pixm has big fg: %f5.2\n", procName, ratio);
return 0;
}
}
/* Make a mask pixm1 over the dark pixels in the image:
* convert to gray using the average of the components;
* threshold using %darkthresh; do a small dilation;
* combine with pixm. */
pix1 = pixConvertRGBToGray(pixs, 0.33, 0.34, 0.33);
if (pixadb) pixaAddPix(pixadb, pixs, L_COPY);
if (pixadb) pixaAddPix(pixadb, pix1, L_COPY);
pixm1 = pixThresholdToBinary(pix1, darkthresh);
pixDilateBrick(pixm1, pixm1, 7, 7);
if (pixadb) pixaAddPix(pixadb, pixm1, L_COPY);
if (pixm) {
pixOr(pixm1, pixm1, pixm);
if (pixadb) pixaAddPix(pixadb, pixm1, L_COPY);
}
pixDestroy(&pix1);
/* Convert to gray using the minimum component value and
* find the gray value at rank 0.95, that represents the light
* pixels in the image. If it is too dark, quit. */
pix1 = pixConvertRGBToGrayMinMax(pixs, L_SELECT_MIN);
pix2 = pixInvert(NULL, pixm1); /* pixels that are not dark */
pixGetRankValueMasked(pix1, pix2, 0, 0, factor, 0.95, &val95, &nah);
pixDestroy(&pix2);
if (pixadb) {
L_INFO("val at 0.95 rank = %5.1f\n", procName, val95);
gplotSimple1(nah, GPLOT_PNG, "/tmp/lept/histo1", "gray histo");
pix3 = pixRead("/tmp/lept/histo1.png");
pix4 = pixExpandReplicate(pix3, 2);
pixaAddPix(pixadb, pix4, L_INSERT);
pixDestroy(&pix3);
}
lightbg = (l_int32)val95 >= lightthresh;
numaDestroy(&nah);
if (!lightbg) {
pixDestroy(&pix1);
pixDestroy(&pixm1);
return 0;
}
/* Make mask pixm2 over pixels that are darker than val95 - mindiff. */
pixm2 = pixThresholdToBinary(pix1, val95 - mindiff);
if (pixadb) pixaAddPix(pixadb, pixm2, L_COPY);
pixDestroy(&pix1);
/* Make a mask pixm3 over pixels that have some color saturation,
* with a (max - min) component difference >= %colordiff,
* and combine using AND with pixm2. */
pix2 = pixConvertRGBToGrayMinMax(pixs, L_CHOOSE_MAXDIFF);
pixm3 = pixThresholdToBinary(pix2, colordiff);
pixDestroy(&pix2);
pixInvert(pixm3, pixm3); /* need pixels above threshold */
if (pixadb) pixaAddPix(pixadb, pixm3, L_COPY);
pixAnd(pixm2, pixm2, pixm3);
if (pixadb) pixaAddPix(pixadb, pixm2, L_COPY);
pixDestroy(&pixm3);
/* Subtract the dark pixels represented by pixm1.
* pixm2 now holds all the color pixels of interest */
pixSubtract(pixm2, pixm2, pixm1);
pixDestroy(&pixm1);
if (pixadb) pixaAddPix(pixadb, pixm2, L_COPY);
/* But we're not quite finished. Remove pixels from any component
* that is touching the image border. False color pixels can
* sometimes be found there if the image is much darker near
* the border, due to oxidation or reduced illumination. */
pixm3 = pixRemoveBorderConnComps(pixm2, 8);
pixDestroy(&pixm2);
if (pixadb) pixaAddPix(pixadb, pixm3, L_COPY);
/* Get the fraction of light color pixels */
pixCountPixels(pixm3, &count, NULL);
*pcolorfract = (l_float32)count / (w * h);
if (pixadb) {
if (count == 0)
L_INFO("no light color pixels found\n", procName);
else
L_INFO("fraction of light color pixels = %5.3f\n", procName,
*pcolorfract);
}
/* Debug: extract the color pixels from pixs */
if (pixadb && count > 0) {
/* Use pixm3 to extract the color pixels */
pix3 = pixCreateTemplate(pixs);
pixSetAll(pix3);
pixCombineMasked(pix3, pixs, pixm3);
pixaAddPix(pixadb, pix3, L_INSERT);
/* Use additional filtering to extract the color pixels */
pix3 = pixCloseSafeBrick(NULL, pixm3, 15, 15);
pixaAddPix(pixadb, pix3, L_INSERT);
pix5 = pixCreateTemplate(pixs);
pixSetAll(pix5);
pixCombineMasked(pix5, pixs, pix3);
pixaAddPix(pixadb, pix5, L_INSERT);
/* Get the combined bounding boxes of the mask components
* in pix3, and extract those pixels from pixs. */
boxa1 = pixConnCompBB(pix3, 8);
boxa2 = boxaCombineOverlaps(boxa1, NULL);
pix4 = pixCreateTemplate(pix3);
pixMaskBoxa(pix4, pix4, boxa2, L_SET_PIXELS);
pixaAddPix(pixadb, pix4, L_INSERT);
pix5 = pixCreateTemplate(pixs);
pixSetAll(pix5);
pixCombineMasked(pix5, pixs, pix4);
pixaAddPix(pixadb, pix5, L_INSERT);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
pixaAddPix(pixadb, pixs, L_COPY);
}
/* Optional colormask returns */
if (pcolormask2 && count > 0)
*pcolormask2 = pixCloseSafeBrick(NULL, pixm3, 15, 15);
if (pcolormask1 && count > 0)
*pcolormask1 = pixm3;
else
pixDestroy(&pixm3);
return 0;
}
/*!
* \brief pixItalicWords()
*
* \param[in] pixs 1 bpp
* \param[in] boxaw [optional] word bounding boxes; can be NULL
* \param[in] pixw [optional] word box mask; can be NULL
* \param[out] pboxa boxa of italic words
* \param[in] debugflag 1 for debug output; 0 otherwise
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) You can input the bounding boxes for the words in one of
* two forms: as bounding boxes (%boxaw) or as a word mask with
* the word bounding boxes filled (%pixw). For example,
* to compute %pixw, you can use pixWordMaskByDilation().
* (2) Alternatively, you can set both of these inputs to NULL,
* in which case the word mask is generated here. This is
* done by dilating and closing the input image to connect
* letters within a word, while leaving the words separated.
* The parameters are chosen under the assumption that the
* input is 10 to 12 pt text, scanned at about 300 ppi.
* (3) sel_ital1 and sel_ital2 detect the right edges that are
* nearly vertical, at approximately the angle of italic
* strokes. We use the right edge to avoid getting seeds
* from lower-case 'y'. The typical italic slant has a smaller
* angle with the vertical than the 'W', so in most cases we
* will not trigger on the slanted lines in the 'W'.
* (4) Note that sel_ital2 is shorter than sel_ital1. It is
* more appropriate for a typical font scanned at 200 ppi.
* </pre>
*/
l_int32
pixItalicWords(PIX *pixs,
BOXA *boxaw,
PIX *pixw,
BOXA **pboxa,
l_int32 debugflag)
{
char opstring[32];
l_int32 size;
BOXA *boxa;
PIX *pixsd, *pixm, *pixd;
SEL *sel_ital1, *sel_ital2, *sel_ital3;
PROCNAME("pixItalicWords");
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (!pboxa)
return ERROR_INT("&boxa not defined", procName, 1);
if (boxaw && pixw)
return ERROR_INT("both boxaw and pixw are defined", procName, 1);
sel_ital1 = selCreateFromString(str_ital1, 13, 6, NULL);
sel_ital2 = selCreateFromString(str_ital2, 10, 6, NULL);
sel_ital3 = selCreateFromString(str_ital3, 4, 2, NULL);
/* Make the italic seed: extract with HMT; remove noise.
* The noise removal close/open is important to exclude
* situations where a small slanted line accidentally
* matches sel_ital1. */
pixsd = pixHMT(NULL, pixs, sel_ital1);
pixClose(pixsd, pixsd, sel_ital3);
pixOpen(pixsd, pixsd, sel_ital3);
/* Make the word mask. Use input boxes or mask if given. */
size = 0; /* init */
if (boxaw) {
pixm = pixCreateTemplate(pixs);
pixMaskBoxa(pixm, pixm, boxaw, L_SET_PIXELS);
} else if (pixw) {
pixm = pixClone(pixw);
} else {
pixWordMaskByDilation(pixs, NULL, &size, NULL);
L_INFO("dilation size = %d\n", procName, size);
snprintf(opstring, sizeof(opstring), "d1.5 + c%d.1", size);
pixm = pixMorphSequence(pixs, opstring, 0);
}
/* Binary reconstruction to fill in those word mask
* components for which there is at least one seed pixel. */
pixd = pixSeedfillBinary(NULL, pixsd, pixm, 8);
boxa = pixConnComp(pixd, NULL, 8);
*pboxa = boxa;
if (debugflag) {
/* Save results at at 2x reduction */
lept_mkdir("lept/ital");
l_int32 res, upper;
BOXA *boxat;
GPLOT *gplot;
NUMA *na;
PIXA *pad;
PIX *pix1, *pix2, *pix3;
pad = pixaCreate(0);
boxat = pixConnComp(pixm, NULL, 8);
boxaWrite("/tmp/lept/ital/ital.ba", boxat);
pixSaveTiledOutline(pixs, pad, 0.5, 1, 20, 2, 32); /* orig */
pixSaveTiledOutline(pixsd, pad, 0.5, 1, 20, 2, 0); /* seed */
pix1 = pixConvertTo32(pixm);
pixRenderBoxaArb(pix1, boxat, 3, 255, 0, 0);
pixSaveTiledOutline(pix1, pad, 0.5, 1, 20, 2, 0); /* mask + outline */
pixDestroy(&pix1);
pixSaveTiledOutline(pixd, pad, 0.5, 1, 20, 2, 0); /* ital mask */
pix1 = pixConvertTo32(pixs);
pixRenderBoxaArb(pix1, boxa, 3, 255, 0, 0);
pixSaveTiledOutline(pix1, pad, 0.5, 1, 20, 2, 0); /* orig + outline */
pixDestroy(&pix1);
pix1 = pixCreateTemplate(pixs);
pix2 = pixSetBlackOrWhiteBoxa(pix1, boxa, L_SET_BLACK);
pixCopy(pix1, pixs);
pix3 = pixDilateBrick(NULL, pixs, 3, 3);
pixCombineMasked(pix1, pix3, pix2);
pixSaveTiledOutline(pix1, pad, 0.5, 1, 20, 2, 0); /* ital bolded */
pixDestroy(&pix1);
pixDestroy(&pix2);
pixDestroy(&pix3);
pix2 = pixaDisplay(pad, 0, 0);
pixWrite("/tmp/lept/ital/ital.png", pix2, IFF_PNG);
pixDestroy(&pix2);
/* Assuming the image represents 6 inches of actual page width,
* the pixs resolution is approximately
* (width of pixs in pixels) / 6
* and the images have been saved at half this resolution. */
res = pixGetWidth(pixs) / 12;
L_INFO("resolution = %d\n", procName, res);
l_pdfSetDateAndVersion(0);
pixaConvertToPdf(pad, res, 1.0, L_FLATE_ENCODE, 75, "Italic Finder",
"/tmp/lept/ital/ital.pdf");
l_pdfSetDateAndVersion(1);
pixaDestroy(&pad);
boxaDestroy(&boxat);
/* Plot histogram of horizontal white run sizes. A small
* initial vertical dilation removes most runs that are neither
* inter-character nor inter-word. The larger first peak is
* from inter-character runs, and the smaller second peak is
* from inter-word runs. */
pix1 = pixDilateBrick(NULL, pixs, 1, 15);
upper = L_MAX(30, 3 * size);
na = pixRunHistogramMorph(pix1, L_RUN_OFF, L_HORIZ, upper);
pixDestroy(&pix1);
gplot = gplotCreate("/tmp/lept/ital/runhisto", GPLOT_PNG,
"Histogram of horizontal runs of white pixels, vs length",
"run length", "number of runs");
gplotAddPlot(gplot, NULL, na, GPLOT_LINES, "plot1");
gplotMakeOutput(gplot);
gplotDestroy(&gplot);
numaDestroy(&na);
}
selDestroy(&sel_ital1);
selDestroy(&sel_ital2);
selDestroy(&sel_ital3);
pixDestroy(&pixsd);
pixDestroy(&pixm);
pixDestroy(&pixd);
return 0;
}
int main(int argc,
char **argv) {
char *filein;
l_float32 angle, conf, deg2rad;
PIX *pixs, *pix1, *pix2, *pix3, *pix4, *pix5;
PIX *pix6, *pix7, *pix8, *pix9;
static char mainName[] = "lineremoval";
if (argc != 2)
return ERROR_INT(" Syntax: lineremoval filein", mainName, 1);
filein = argv[1];
deg2rad = 3.14159 / 180.;
if ((pixs = pixRead(filein)) == NULL)
return ERROR_INT("pix not made", mainName, 1);
/* threshold to binary, extracting much of the lines */
pix1 = pixThresholdToBinary(pixs, 170);
pixWrite("/tmp/dave-proc1.png", pix1, IFF_PNG);
pixDisplayWrite(pix1, 1);
/* find the skew angle and deskew using an interpolated
* rotator for anti-aliasing (to avoid jaggies) */
pixFindSkew(pix1, &angle, &conf);
pix2 = pixRotateAMGray(pixs, deg2rad * angle, 255);
pixWrite("/tmp/dave-proc2.png", pix2, IFF_PNG);
pixDisplayWrite(pix2, 1);
/* extract the lines to be removed */
pix3 = pixCloseGray(pix2, 51, 1);
pixWrite("/tmp/dave-proc3.png", pix3, IFF_PNG);
pixDisplayWrite(pix3, 1);
/* solidify the lines to be removed */
pix4 = pixErodeGray(pix3, 1, 5);
pixWrite("/tmp/dave-proc4.png", pix4, IFF_PNG);
pixDisplayWrite(pix4, 1);
/* clean the background of those lines */
pix5 = pixThresholdToValue(NULL, pix4, 210, 255);
pixWrite("/tmp/dave-proc5.png", pix5, IFF_PNG);
pixDisplayWrite(pix5, 1);
pix6 = pixThresholdToValue(NULL, pix5, 200, 0);
pixWrite("/tmp/dave-proc6.png", pix6, IFF_PNG);
pixDisplayWrite(pix6, 1);
/* get paint-through mask for changed pixels */
pix7 = pixThresholdToBinary(pix6, 210);
pixWrite("/tmp/dave-proc7.png", pix7, IFF_PNG);
pixDisplayWrite(pix7, 1);
/* add the inverted, cleaned lines to orig. Because
* the background was cleaned, the inversion is 0,
* so when you add, it doesn't lighten those pixels.
* It only lightens (to white) the pixels in the lines! */
pixInvert(pix6, pix6);
pix8 = pixAddGray(NULL, pix2, pix6);
pixWrite("/tmp/dave-proc8.png", pix8, IFF_PNG);
pixDisplayWrite(pix8, 1);
pix9 = pixOpenGray(pix8, 1, 9);
pixWrite("/tmp/dave-proc9.png", pix9, IFF_PNG);
pixDisplayWrite(pix9, 1);
pixCombineMasked(pix8, pix9, pix7);
pixWrite("/tmp/dave-result.png", pix8, IFF_PNG);
pixDisplayWrite(pix8, 1);
pixDisplayMultiple("/tmp/display/file*");
return 0;
}
main(int argc,
char **argv)
{
l_int32 i, j, same;
PIX *pixm, *pixmi, *pixs1, *pixs1_8;
PIX *pixs2, *pixs2_8, *pixs3, *pixs3_8;
PIX *pixb1, *pixb2, *pixb3, *pixmin, *pixd;
PIXA *pixac;
static char mainName[] = "grayfill_reg";
pixDisplayWrite(NULL, -1);
pixac = pixaCreate(0);
/* Mask */
pixm = pixCreate(200, 200, 8);
for (i = 0; i < 200; i++)
for (j = 0; j < 200; j++)
pixSetPixel(pixm, j, i, 20 + L_ABS((100 - i) * (100 - j)) / 50);
pixmi = pixInvert(NULL, pixm);
/* Seed1 */
pixs1 = pixCreate(200, 200, 8);
for (i = 99; i <= 101; i++)
for (j = 99; j <= 101; j++)
pixSetPixel(pixs1, j, i, 50 - i/100 - j/100);
pixs1_8 = pixCopy(NULL, pixs1);
/* Seed2 */
pixs2 = pixCreate(200, 200, 8);
for (i = 99; i <= 101; i++)
for (j = 99; j <= 101; j++)
pixSetPixel(pixs2, j, i, 205 - i/100 - j/100);
pixs2_8 = pixCopy(NULL, pixs2);
/* Inverse grayscale fill */
pixSaveTiled(pixm, pixac, 1, 1, 10, 8);
pixSaveTiled(pixs1, pixac, 1, 0, 10, 0);
pixSeedfillGrayInv(pixs1, pixm, 4);
pixSeedfillGrayInv(pixs1_8, pixm, 8);
pixSaveTiled(pixs1, pixac, 1, 0, 10, 0);
pixSaveTiled(pixs1_8, pixac, 1, 0, 10, 0);
pixb1 = pixThresholdToBinary(pixs1, 20);
pixSaveTiled(pixb1, pixac, 1, 0, 10, 0);
pixCombineMasked(pixs1, pixm, pixb1);
pixSaveTiled(pixs1, pixac, 1, 0, 10, 0);
pixDestroy(&pixs1);
pixDestroy(&pixs1_8);
pixDestroy(&pixb1);
/* Standard grayscale fill */
pixSaveTiled(pixmi, pixac, 1, 1, 10, 0);
pixSaveTiled(pixs2, pixac, 1, 0, 10, 0);
pixSeedfillGray(pixs2, pixmi, 4);
pixSeedfillGray(pixs2_8, pixmi, 8);
pixSaveTiled(pixs2, pixac, 1, 0, 10, 0);
pixSaveTiled(pixs2_8, pixac, 1, 0, 10, 0);
pixb2 = pixThresholdToBinary(pixs2, 205);
pixSaveTiled(pixb2, pixac, 1, 0, 10, 0);
pixDestroy(&pixs2);
pixDestroy(&pixs2_8);
pixDestroy(&pixb2);
/* Basin fill from minima as seed */
pixSaveTiled(pixm, pixac, 1, 1, 10, 8);
pixLocalExtrema(pixm, 0, 0, &pixmin, NULL);
pixSaveTiled(pixmin, pixac, 1, 0, 10, 0);
pixs3 = pixSeedfillGrayBasin(pixmin, pixm, 30, 4);
pixs3_8 = pixSeedfillGrayBasin(pixmin, pixm, 30, 8);
pixSaveTiled(pixs3, pixac, 1, 0, 10, 0);
pixSaveTiled(pixs3_8, pixac, 1, 0, 10, 0);
pixb3 = pixThresholdToBinary(pixs3, 60);
pixSaveTiled(pixb3, pixac, 1, 0, 10, 0);
pixDestroy(&pixs3);
pixDestroy(&pixs3_8);
pixDestroy(&pixb3);
pixd = pixaDisplay(pixac, 0, 0);
pixDisplay(pixd, 100, 100);
pixWrite("/tmp/junkfill.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixac);
/* Compare hybrid and iterative gray seedfills */
pixs1 = pixCopy(NULL, pixm);
pixs2 = pixCopy(NULL, pixm);
pixAddConstantGray(pixs1, -30);
pixAddConstantGray(pixs2, 60);
PixTestEqual(pixs1, pixs2, pixm, 1, 4);
PixTestEqual(pixs1, pixs2, pixm, 2, 8);
PixTestEqual(pixs2, pixs1, pixm, 3, 4);
PixTestEqual(pixs2, pixs1, pixm, 4, 8);
pixDestroy(&pixs1);
pixDestroy(&pixs2);
pixDestroy(&pixm);
pixDestroy(&pixmi);
pixDestroy(&pixmin);
return 0;
}
main(int argc,
char **argv)
{
l_int32 w, h;
BOXA *boxa;
PIX *pixs, *pixt1, *pixt2, *pixg, *pixb, *pixd, *pixc;
PIX *pixm, *pixm2, *pixd2, *pixs2;
PIXA *pixa, *pixac;
PIXCMAP *cmap, *cmapg;
static char mainName[] = "misctest1";
pixac = pixaCreate(0);
/* Combine two grayscale images using a mask */
pixd = pixRead("feyn.tif");
pixs = pixRead("rabi.png");
pixm = pixRead("pageseg2-seed.png");
pixd2 = pixScaleToGray2(pixd);
pixs2 = pixScaleToGray2(pixs);
pixSaveTiled(pixd2, pixac, 2, 1, 40, 32);
pixSaveTiled(pixs2, pixac, 2, 0, 40, 0);
pixSaveTiled(pixm, pixac, 2, 0, 40, 0);
pixCombineMaskedGeneral(pixd2, pixs2, pixm, 100, 100);
pixSaveTiled(pixd2, pixac, 2, 1, 40, 0);
pixDisplayWithTitle(pixd2, 100, 100, NULL, SHOW);
pixDestroy(&pixd2);
pixDestroy(&pixs2);
/* Combine two binary images using a mask */
pixm2 = pixExpandBinaryReplicate(pixm, 2);
pixt1 = pixCopy(NULL, pixd);
pixCombineMaskedGeneral(pixd, pixs, pixm2, 200, 200);
pixSaveTiled(pixd, pixac, 4, 0, 40, 0);
pixDisplayWithTitle(pixd, 700, 100, NULL, SHOW);
pixCombineMasked(pixt1, pixs, pixm2);
pixSaveTiled(pixt1, pixac, 4, 0, 40, 0);
pixDestroy(&pixd);
pixDestroy(&pixt1);
pixDestroy(&pixs);
pixDestroy(&pixm);
pixDestroy(&pixm2);
/* Do a restricted seedfill */
pixs = pixRead("pageseg2-seed.png");
pixm = pixRead("pageseg2-mask.png");
pixd = pixSeedfillBinaryRestricted(NULL, pixs, pixm, 8, 50, 175);
pixSaveTiled(pixs, pixac, 2, 1, 40, 0);
pixSaveTiled(pixm, pixac, 2, 0, 40, 0);
pixSaveTiled(pixd, pixac, 2, 0, 40, 0);
pixDestroy(&pixs);
pixDestroy(&pixm);
pixDestroy(&pixd);
/* Colorize a grayscale image */
pixs = pixRead("lucasta.150.jpg");
pixGetDimensions(pixs, &w, &h, NULL);
pixb = pixThresholdToBinary(pixs, 128);
boxa = pixConnComp(pixb, &pixa, 8);
pixSaveTiled(pixs, pixac, 1, 1, 40, 0);
cmap = pixcmapGrayToColor(0x6f90c0);
pixSetColormap(pixs, cmap);
pixSaveTiled(pixs, pixac, 1, 0, 40, 0);
pixc = pixaDisplayRandomCmap(pixa, w, h);
pixcmapResetColor(pixGetColormap(pixc), 0, 255, 255, 255);
pixSaveTiled(pixc, pixac, 1, 0, 40, 0);
pixDestroy(&pixs);
pixDestroy(&pixb);
pixDestroy(&pixc);
boxaDestroy(&boxa);
pixaDestroy(&pixa);
/* Convert color to gray */
pixs = pixRead("weasel4.16c.png");
pixSaveTiled(pixs, pixac, 1, 1, 20, 0);
pixc = pixConvertTo32(pixs);
pixt1 = pixConvertRGBToGray(pixc, 3., 7., 5.);
pixSaveTiled(pixt1, pixac, 1, 0, 20, 0);
pixt2 = pixConvertRGBToGrayFast(pixc);
pixSaveTiled(pixt2, pixac, 1, 0, 20, 0);
pixg = pixCopy(NULL, pixs);
cmap = pixGetColormap(pixs);
cmapg = pixcmapColorToGray(cmap, 4., 6., 3.);
pixSetColormap(pixg, cmapg);
pixSaveTiled(pixg, pixac, 1, 0, 20, 0);
pixDestroy(&pixs);
pixDestroy(&pixc);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
pixDestroy(&pixg);
pixd = pixaDisplay(pixac, 0, 0);
pixDisplayWithTitle(pixd, 100, 100, NULL, 1);
pixWrite("junkmisc1.png", pixd, IFF_PNG);
pixDestroy(&pixd);
pixaDestroy(&pixac);
return 0;
}
int main_line_removal() {
PIX* pixs_source = pixRead("dave-start.png");
if (!pixs_source) {
printf("Error opening file");
return 1;
}
double deg2rad = 3.1415926535 / 180.;
l_float32 angle, conf, score;
PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8, *pix9;
pix1 = pixThresholdToBinary(pixs_source, 160);
printf("Create line removal image\n");
pixWrite("line-removal/result.line-removal-1.tif", pix1, IFF_TIFF_G4);
pixFindSkew(pix1, &angle, &conf);
pix2 = pixRotateAMGray(pixs_source, deg2rad * angle, 160);
printf("Create line removal image\n");
pixWrite("line-removal/result.line-removal-2.tif", pix2, IFF_TIFF_G4);
l_int32 HORIZ = 1;
l_int32 VERT = 3;
pix3 = pixCloseGray(pix2, 51, HORIZ); //k?p?c 51?
printf("Create line removal image\n");
pixWrite("line-removal/result.line-removal-3.tif", pix3, IFF_TIFF_G4);
pix4 = pixErodeGray(pix3, 5, VERT); //k?p?c 5?
printf("Create line removal image\n");
pixWrite("line-removal/result.line-removal-4.tif", pix4, IFF_TIFF_G4);
pix5 = pix4;
pix5 = pixThresholdToValue(pix5, pix4, 230, 255);
printf("Create line removal image\n");
pixWrite("line-removal/result.line-removal-5.tif", pix5, IFF_TIFF_G4);
pix6 = pix5;
pix6 = pixThresholdToValue(pix5, pix5, 210, 0);
printf("Create line removal image\n");
pixWrite("line-removal/result.line-removal-6.tif", pix6, IFF_TIFF_G4);
pix7 = pixThresholdToBinary(pix6, 230);
printf("Create line removal image\n");
pixWrite("line-removal/result.line-removal-7.tif", pix7, IFF_TIFF_G4);
pixInvert(pix6, pix6);
pix8 = pixAddGray(NULL, pix2, pix6);
printf("Create line removal image\n");
pixWrite("line-removal/result.line-removal-8.tif", pix8, IFF_TIFF_G4);
VERT = 7;
pix9 = pixOpenGray(pix8, 3, VERT);
printf("Create line removal image\n");
pixWrite("line-removal/result.line-removal-9.tif", pix9, IFF_TIFF_G4);
if (pixCombineMasked(pix8, pix9, pix7)) {
printf("!!!Error while combining pixs!!!\n");
}
printf("Create line removal image\n");
pixWrite("line-removal/result.line-removal-final.tif", pix8, IFF_TIFF_G4);
printf("\n---\nEnd\n");
getchar();
return 0;
}
