Mercurial > hgrepos > Python2 > PyMuPDF
view mupdf-source/thirdparty/leptonica/src/pageseg.c @ 32:72c1b70d4f5c
Also apply -Werror=implicit-function-declaration
| author | Franz Glasner <fzglas.hg@dom66.de> |
|---|---|
| date | Sun, 21 Sep 2025 15:10:12 +0200 |
| parents | b50eed0cc0ef |
| children |
line wrap: on
line source
/*====================================================================* - Copyright (C) 2001 Leptonica. All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions - are met: - 1. Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - 2. Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following - disclaimer in the documentation and/or other materials - provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ANY - CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY - OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *====================================================================*/ /*! * \file pageseg.c * <pre> * * Top level page segmentation * l_int32 pixGetRegionsBinary() * * Halftone region extraction * PIX *pixGenHalftoneMask() **Deprecated wrapper** * PIX *pixGenerateHalftoneMask() * * Textline extraction * PIX *pixGenTextlineMask() * * Textblock extraction * PIX *pixGenTextblockMask() * * Location and extraction of page foreground; cleaning pages * PIX *pixCropImage() * static l_int32 pixMaxCompAfterVClosing() * static l_int32 pixFindPageInsideBlackBorder() * static PIX *pixRescaleForCropping() * PIX *pixCleanImage() * BOX *pixFindPageForeground() * * Extraction of characters from image with only text * l_int32 pixSplitIntoCharacters() * BOXA *pixSplitComponentWithProfile() * * Extraction of lines of text * PIXA *pixExtractTextlines() * PIXA *pixExtractRawTextlines() * * How many text columns * l_int32 pixCountTextColumns() * * Decision: text vs photo * l_int32 pixDecideIfText() * l_int32 pixFindThreshFgExtent() * * Decision: table vs text * l_int32 pixDecideIfTable() * Pix *pixPrepare1bpp() * * Estimate the grayscale background value * l_int32 pixEstimateBackground() * * Largest white or black rectangles in an image * l_int32 pixFindLargeRectangles() * l_int32 pixFindLargestRectangle() * * Generate rectangle inside connected component * BOX *pixFindRectangleInCC() * * Automatic photoinvert for OCR * PIX *pixAutoPhotoinvert() * </pre> */ #ifdef HAVE_CONFIG_H #include <config_auto.h> #endif /* HAVE_CONFIG_H */ #include <math.h> #include "allheaders.h" #include "pix_internal.h" /* These functions are not intended to work on very low-res images */ static const l_int32 MinWidth = 100; static const l_int32 MinHeight = 100; static l_ok pixMaxCompAfterVClosing(PIX *pixs, BOX **pbox); static l_ok pixFindPageInsideBlackBorder(PIX *pixs, BOX **pbox); static PIX *pixRescaleForCropping(PIX *pixs, l_int32 w, l_int32 h, l_int32 lr_border, l_int32 tb_border, l_float32 maxwiden, PIX **ppixsc); /*------------------------------------------------------------------* * Top level page segmentation * *------------------------------------------------------------------*/ /*! * \brief pixGetRegionsBinary() * * \param[in] pixs 1 bpp, assumed to be 300 to 400 ppi * \param[out] ppixhm [optional] halftone mask * \param[out] ppixtm [optional] textline mask * \param[out] ppixtb [optional] textblock mask * \param[in] pixadb input for collecting debug pix; use NULL to skip * \return 0 if OK, 1 on error * * <pre> * Notes: * (1) It is best to deskew the image before segmenting. * (2) Passing in %pixadb enables debug output. * </pre> */ l_ok pixGetRegionsBinary(PIX *pixs, PIX **ppixhm, PIX **ppixtm, PIX **ppixtb, PIXA *pixadb) { l_int32 w, h, htfound, tlfound; PIX *pixr, *pix1, *pix2; PIX *pixtext; /* text pixels only */ PIX *pixhm2; /* halftone mask; 2x reduction */ PIX *pixhm; /* halftone mask; */ PIX *pixtm2; /* textline mask; 2x reduction */ PIX *pixtm; /* textline mask */ PIX *pixvws; /* vertical white space mask */ PIX *pixtb2; /* textblock mask; 2x reduction */ PIX *pixtbf2; /* textblock mask; 2x reduction; small comps filtered */ PIX *pixtb; /* textblock mask */ if (ppixhm) *ppixhm = NULL; if (ppixtm) *ppixtm = NULL; if (ppixtb) *ppixtb = NULL; if (!pixs || pixGetDepth(pixs) != 1) return ERROR_INT("pixs undefined or not 1 bpp", __func__, 1); pixGetDimensions(pixs, &w, &h, NULL); if (w < MinWidth || h < MinHeight) { L_ERROR("pix too small: w = %d, h = %d\n", __func__, w, h); return 1; } /* 2x reduce, to 150 -200 ppi */ pixr = pixReduceRankBinaryCascade(pixs, 1, 0, 0, 0); if (pixadb) pixaAddPix(pixadb, pixr, L_COPY); /* Get the halftone mask */ pixhm2 = pixGenerateHalftoneMask(pixr, &pixtext, &htfound, pixadb); /* Get the textline mask from the text pixels */ pixtm2 = pixGenTextlineMask(pixtext, &pixvws, &tlfound, pixadb); /* Get the textblock mask from the textline mask */ pixtb2 = pixGenTextblockMask(pixtm2, pixvws, pixadb); pixDestroy(&pixr); pixDestroy(&pixtext); pixDestroy(&pixvws); /* Remove small components from the mask, where a small * component is defined as one with both width and height < 60 */ pixtbf2 = NULL; if (pixtb2) { pixtbf2 = pixSelectBySize(pixtb2, 60, 60, 4, L_SELECT_IF_EITHER, L_SELECT_IF_GTE, NULL); pixDestroy(&pixtb2); if (pixadb) pixaAddPix(pixadb, pixtbf2, L_COPY); } /* Expand all masks to full resolution, and do filling or * small dilations for better coverage. */ pixhm = pixExpandReplicate(pixhm2, 2); pix1 = pixSeedfillBinary(NULL, pixhm, pixs, 8); pixOr(pixhm, pixhm, pix1); pixDestroy(&pixhm2); pixDestroy(&pix1); if (pixadb) pixaAddPix(pixadb, pixhm, L_COPY); pix1 = pixExpandReplicate(pixtm2, 2); pixtm = pixDilateBrick(NULL, pix1, 3, 3); pixDestroy(&pixtm2); pixDestroy(&pix1); if (pixadb) pixaAddPix(pixadb, pixtm, L_COPY); if (pixtbf2) { pix1 = pixExpandReplicate(pixtbf2, 2); pixtb = pixDilateBrick(NULL, pix1, 3, 3); pixDestroy(&pixtbf2); pixDestroy(&pix1); if (pixadb) pixaAddPix(pixadb, pixtb, L_COPY); } else { pixtb = pixCreateTemplate(pixs); /* empty mask */ } /* Debug: identify objects that are neither text nor halftone image */ if (pixadb) { pix1 = pixSubtract(NULL, pixs, pixtm); /* remove text pixels */ pix2 = pixSubtract(NULL, pix1, pixhm); /* remove halftone pixels */ pixaAddPix(pixadb, pix2, L_INSERT); pixDestroy(&pix1); } /* Debug: display textline components with random colors */ if (pixadb) { l_int32 w, h; BOXA *boxa; PIXA *pixa; boxa = pixConnComp(pixtm, &pixa, 8); pixGetDimensions(pixtm, &w, &h, NULL); pix1 = pixaDisplayRandomCmap(pixa, w, h); pixcmapResetColor(pixGetColormap(pix1), 0, 255, 255, 255); pixaAddPix(pixadb, pix1, L_INSERT); pixaDestroy(&pixa); boxaDestroy(&boxa); } /* Debug: identify the outlines of each textblock */ if (pixadb) { PIXCMAP *cmap; PTAA *ptaa; ptaa = pixGetOuterBordersPtaa(pixtb); lept_mkdir("lept/pageseg"); ptaaWriteDebug("/tmp/lept/pageseg/tb_outlines.ptaa", ptaa, 1); pix1 = pixRenderRandomCmapPtaa(pixtb, ptaa, 1, 16, 1); cmap = pixGetColormap(pix1); pixcmapResetColor(cmap, 0, 130, 130, 130); pixaAddPix(pixadb, pix1, L_INSERT); ptaaDestroy(&ptaa); } /* Debug: get b.b. for all mask components */ if (pixadb) { BOXA *bahm, *batm, *batb; bahm = pixConnComp(pixhm, NULL, 4); batm = pixConnComp(pixtm, NULL, 4); batb = pixConnComp(pixtb, NULL, 4); boxaWriteDebug("/tmp/lept/pageseg/htmask.boxa", bahm); boxaWriteDebug("/tmp/lept/pageseg/textmask.boxa", batm); boxaWriteDebug("/tmp/lept/pageseg/textblock.boxa", batb); boxaDestroy(&bahm); boxaDestroy(&batm); boxaDestroy(&batb); } if (pixadb) { pixaConvertToPdf(pixadb, 0, 1.0, 0, 0, "Debug page segmentation", "/tmp/lept/pageseg/debug.pdf"); L_INFO("Writing debug pdf to /tmp/lept/pageseg/debug.pdf\n", __func__); } if (ppixhm) *ppixhm = pixhm; else pixDestroy(&pixhm); if (ppixtm) *ppixtm = pixtm; else pixDestroy(&pixtm); if (ppixtb) *ppixtb = pixtb; else pixDestroy(&pixtb); return 0; } /*------------------------------------------------------------------* * Halftone region extraction * *------------------------------------------------------------------*/ /*! * \brief pixGenHalftoneMask() * * <pre> * Deprecated: * This wrapper avoids an ABI change with tesseract 3.0.4. * It should be removed when we no longer need to support 3.0.4. * The debug parameter is ignored (assumed 0). * </pre> */ PIX * pixGenHalftoneMask(PIX *pixs, PIX **ppixtext, l_int32 *phtfound, l_int32 debug) { return pixGenerateHalftoneMask(pixs, ppixtext, phtfound, NULL); } /*! * \brief pixGenerateHalftoneMask() * * \param[in] pixs 1 bpp, assumed to be 150 to 200 ppi * \param[out] ppixtext [optional] text part of pixs * \param[out] phtfound [optional] 1 if the mask is not empty * \param[in] pixadb input for collecting debug pix; use NULL to skip * \return pixd halftone mask, or NULL on error * * <pre> * Notes: * (1) This is not intended to work on small thumbnails. The * dimensions of pixs must be at least MinWidth x MinHeight. * </pre> */ PIX * pixGenerateHalftoneMask(PIX *pixs, PIX **ppixtext, l_int32 *phtfound, PIXA *pixadb) { l_int32 w, h, empty; PIX *pix1, *pix2, *pixhs, *pixhm, *pixd; if (ppixtext) *ppixtext = NULL; if (phtfound) *phtfound = 0; if (!pixs || pixGetDepth(pixs) != 1) return (PIX *)ERROR_PTR("pixs undefined or not 1 bpp", __func__, NULL); pixGetDimensions(pixs, &w, &h, NULL); if (w < MinWidth || h < MinHeight) { L_ERROR("pix too small: w = %d, h = %d\n", __func__, w, h); return NULL; } /* Compute seed for halftone parts at 8x reduction */ pix1 = pixReduceRankBinaryCascade(pixs, 4, 4, 0, 0); pix2 = pixOpenBrick(NULL, pix1, 5, 5); pixhs = pixExpandReplicate(pix2, 4); /* back to 2x reduction */ pixDestroy(&pix1); pixDestroy(&pix2); if (pixadb) pixaAddPix(pixadb, pixhs, L_COPY); /* Compute mask for connected regions */ pixhm = pixCloseSafeBrick(NULL, pixs, 4, 4); if (pixadb) pixaAddPix(pixadb, pixhm, L_COPY); /* Fill seed into mask to get halftone mask */ pixd = pixSeedfillBinary(NULL, pixhs, pixhm, 4); if (pixadb) pixaAddPix(pixadb, pixd, L_COPY); #if 0 pixOpenBrick(pixd, pixd, 9, 9); #endif /* Check if mask is empty */ pixZero(pixd, &empty); if (phtfound && !empty) *phtfound = 1; /* Optionally, get all pixels that are not under the halftone mask */ if (ppixtext) { if (empty) *ppixtext = pixCopy(NULL, pixs); else *ppixtext = pixSubtract(NULL, pixs, pixd); if (pixadb) pixaAddPix(pixadb, *ppixtext, L_COPY); } pixDestroy(&pixhs); pixDestroy(&pixhm); return pixd; } /*------------------------------------------------------------------* * Textline extraction * *------------------------------------------------------------------*/ /*! * \brief pixGenTextlineMask() * * \param[in] pixs 1 bpp, assumed to be 150 to 200 ppi * \param[out] ppixvws vertical whitespace mask * \param[out] ptlfound [optional] 1 if the mask is not empty * \param[in] pixadb input for collecting debug pix; use NULL to skip * \return pixd textline mask, or NULL on error * * <pre> * Notes: * (1) The input pixs should be deskewed. * (2) pixs should have no halftone pixels. * (3) This is not intended to work on small thumbnails. The * dimensions of pixs must be at least MinWidth x MinHeight. * (4) Both the input image and the returned textline mask * are at the same resolution. * </pre> */ PIX * pixGenTextlineMask(PIX *pixs, PIX **ppixvws, l_int32 *ptlfound, PIXA *pixadb) { l_int32 w, h, empty; PIX *pix1, *pix2, *pixvws, *pixd; if (ptlfound) *ptlfound = 0; if (!ppixvws) return (PIX *)ERROR_PTR("&pixvws not defined", __func__, NULL); *ppixvws = NULL; if (!pixs || pixGetDepth(pixs) != 1) return (PIX *)ERROR_PTR("pixs undefined or not 1 bpp", __func__, NULL); pixGetDimensions(pixs, &w, &h, NULL); if (w < MinWidth || h < MinHeight) { L_ERROR("pix too small: w = %d, h = %d\n", __func__, w, h); return NULL; } /* First we need a vertical whitespace mask. Invert the image. */ pix1 = pixInvert(NULL, pixs); /* The whitespace mask will break textlines where there * is a large amount of white space below or above. * This can be prevented by identifying regions of the * inverted image that have large horizontal extent (bigger than * the separation between columns) and significant * vertical extent (bigger than the separation between * textlines), and subtracting this from the bg. */ pix2 = pixMorphCompSequence(pix1, "o80.60", 0); pixSubtract(pix1, pix1, pix2); if (pixadb) pixaAddPix(pixadb, pix1, L_COPY); pixDestroy(&pix2); /* Identify vertical whitespace by opening the remaining bg. * o5.1 removes thin vertical bg lines and o1.200 extracts * long vertical bg lines. */ pixvws = pixMorphCompSequence(pix1, "o5.1 + o1.200", 0); *ppixvws = pixvws; if (pixadb) pixaAddPix(pixadb, pixvws, L_COPY); pixDestroy(&pix1); /* Three steps to getting text line mask: * (1) close the characters and words in the textlines * (2) open the vertical whitespace corridors back up * (3) small opening to remove noise */ pix1 = pixMorphSequence(pixs, "c30.1", 0); if (pixadb) pixaAddPix(pixadb, pix1, L_COPY); pixd = pixSubtract(NULL, pix1, pixvws); pixOpenBrick(pixd, pixd, 3, 3); if (pixadb) pixaAddPix(pixadb, pixd, L_COPY); pixDestroy(&pix1); /* Check if text line mask is empty */ if (ptlfound) { pixZero(pixd, &empty); if (!empty) *ptlfound = 1; } return pixd; } /*------------------------------------------------------------------* * Textblock extraction * *------------------------------------------------------------------*/ /*! * \brief pixGenTextblockMask() * * \param[in] pixs 1 bpp, textline mask, assumed to be 150 to 200 ppi * \param[in] pixvws vertical white space mask * \param[in] pixadb input for collecting debug pix; use NULL to skip * \return pixd textblock mask, or NULL if empty or on error * * <pre> * Notes: * (1) Both the input masks (textline and vertical white space) and * the returned textblock mask are at the same resolution. * (2) This is not intended to work on small thumbnails. The * dimensions of pixs must be at least MinWidth x MinHeight. * (3) The result is somewhat noisy, in that small "blocks" of * text may be included. These can be removed by post-processing, * using, e.g., * pixSelectBySize(pix, 60, 60, 4, L_SELECT_IF_EITHER, * L_SELECT_IF_GTE, NULL); * </pre> */ PIX * pixGenTextblockMask(PIX *pixs, PIX *pixvws, PIXA *pixadb) { l_int32 w, h, empty; PIX *pix1, *pix2, *pix3, *pixd; if (!pixs || pixGetDepth(pixs) != 1) return (PIX *)ERROR_PTR("pixs undefined or not 1 bpp", __func__, NULL); pixGetDimensions(pixs, &w, &h, NULL); if (w < MinWidth || h < MinHeight) { L_ERROR("pix too small: w = %d, h = %d\n", __func__, w, h); return NULL; } if (!pixvws) return (PIX *)ERROR_PTR("pixvws not defined", __func__, NULL); /* Join pixels vertically to make a textblock mask */ pix1 = pixMorphSequence(pixs, "c1.10 + o4.1", 0); pixZero(pix1, &empty); if (empty) { pixDestroy(&pix1); L_INFO("no fg pixels in textblock mask\n", __func__); return NULL; } if (pixadb) pixaAddPix(pixadb, pix1, L_COPY); /* Solidify the textblock mask and remove noise: * (1) For each cc, close the blocks and dilate slightly * to form a solid mask. * (2) Small horizontal closing between components. * (3) Open the white space between columns, again. * (4) Remove small components. */ pix2 = pixMorphSequenceByComponent(pix1, "c30.30 + d3.3", 8, 0, 0, NULL); pixCloseSafeBrick(pix2, pix2, 10, 1); if (pixadb) pixaAddPix(pixadb, pix2, L_COPY); pix3 = pixSubtract(NULL, pix2, pixvws); if (pixadb) pixaAddPix(pixadb, pix3, L_COPY); pixd = pixSelectBySize(pix3, 25, 5, 8, L_SELECT_IF_BOTH, L_SELECT_IF_GTE, NULL); if (pixadb) pixaAddPix(pixadb, pixd, L_COPY); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); return pixd; } /*------------------------------------------------------------------* * Location and extraction of page foreground; cleaning pages * *------------------------------------------------------------------*/ /*! * \brief pixCropImage() * * \param[in] pixs full resolution (any type or depth) * \param[in] lr_clear full res pixels cleared at left and right sides * \param[in] tb_clear full res pixels cleared at top and bottom sides * \param[in] edgeclean parameter for removing edge noise (-1 to 15) * default = 0 (no removal); * 15 is maximally aggressive for random noise * -1 for aggressively removing side noise * -2 to extract page embedded in black background * \param[in] lr_border full res final "added" pixels on left and right * \param[in] tb_border full res final "added" pixels on top and bottom * \param[in] maxwiden max fractional horizontal stretch allowed * \param[in] printwiden 0 to skip, 1 for 8.5x11, 2 for A4 * \param[in] *debugfile [optional] usually is NULL * \param[out] *pcropbox [optional] crop box at full resolution * \return cropped pix, or NULL on error * * <pre> * Notes: * (1) This binarizes and crops a page image. * (a) Binarizes if necessary and does 2x reduction. * (b) Clears near the border by %lr_clear and %tb_clear full * resolution pixels. (This is done at 2x reduction.) * (c) If %edgeclean > 0, it removes isolated sets of pixels, * using a close/open operation of size %edgeclean + 1. * If %edgeclean == -1, it uses a large vertical morphological * close/open and the extraction of either the largest * resulting connected component (or the largest two components * if the page has 2 columns), to eliminate noise on left * and right sides. * If %edgeclean == -2, it extracts the page region from a * possible exterior black surround. * (d) Find the bounding box of remaining fg pixels and scales * the box up 2x back to full resolution. * (e) Crops the binarized image to the bounding box. * (f) Slightly thickens long horizontal lines. * (g) Rescales this image to fit within the original image, * less lr_border on the sides and tb_border above and below. * The rescaling is done isomorphically with a (possible) * optional additional widening. Suggest the additional * widening factor not exceed 1.15. * (h) Optionally do additional horizontal stretch if needed to * better fill a printed page. Default is 0 to skip; 1 to * widen for 8.5x11 page, 2 for A4 page. * Note that (b) - (d) are done at 2x reduction for efficiency. * (2) Side clearing must not exceed 1/6 of the dimension on that side. * (3) The clear and border pixel parameters must be >= 0. * (4) The "clear" parameters act on the input image, whereas the * "border" parameters act to give a white border to the final * image. They are not literally added, because the input and final * images are the same size. If the resulting images are to be * printed, it is useful to have border pixel parameters of at * least 60 at 300 ppi, to avoid losing content at the edges. * (5) This is not intended to work on small thumbnails. The * dimensions of pixs must be at least MinWidth x MinHeight. * (6) Step (f) above helps with orthographically-produced music notation, * where the horizontal staff lines can be very thin and thus * subject to printer alias. * (7) If you are not concerned with printing on paper, use the * default value 0 for %printwiden. Widening only takes place * if the ratio h/w exceeds the specified paper size by 3%, * and the horizontal scaling factor will not exceed 1.25. * </pre> */ PIX * pixCropImage(PIX *pixs, l_int32 lr_clear, l_int32 tb_clear, l_int32 edgeclean, l_int32 lr_border, l_int32 tb_border, l_float32 maxwiden, l_int32 printwiden, const char *debugfile, BOX **pcropbox) { char cmd[64]; l_int32 w, h, val, ret; l_float32 r1, r2; BOX *box1, *box2; PIX *pix1, *pix2, *pix3, *pix4; PIXA *pixa1; if (pcropbox) *pcropbox = NULL; if (!pixs) return (PIX *)ERROR_PTR("pixs not defined", __func__, NULL); if (edgeclean > 15) { L_WARNING("edgeclean > 15; setting to 15\n", __func__); edgeclean = 15; } if (edgeclean < -1) { lept_stderr("Using edgeclean = -2\n"); edgeclean = -2; } pixGetDimensions(pixs, &w, &h, NULL); if (w < MinWidth || h < MinHeight) { L_ERROR("pix too small: w = %d, h = %d\n", __func__, w, h); return NULL; } if (lr_clear < 0) lr_clear = 0; if (tb_clear < 0) tb_clear = 0; if (lr_border < 0) lr_border = 0; if (tb_border < 0) tb_border = 0; if (lr_clear > w / 6 || tb_clear > h / 6) { L_ERROR("lr_clear or tb_clear too large; must be <= %d and %d\n", __func__, w / 6, h / 6); return NULL; } if (maxwiden > 1.15) L_WARNING("maxwiden = %f > 1.15; suggest between 1.0 and 1.15\n", __func__, maxwiden); if (printwiden < 0 || printwiden > 2) printwiden = 0; pixa1 = (debugfile) ? pixaCreate(5) : NULL; if (pixa1) pixaAddPix(pixa1, pixs, L_COPY); /* Binarize if necessary and 2x reduction */ pix1 = pixBackgroundNormTo1MinMax(pixs, 1, 1); pix2 = pixReduceRankBinary2(pix1, 2, NULL); /* Clear out pixels near the image edges */ pixSetOrClearBorder(pix2, lr_clear / 2, lr_clear / 2, tb_clear / 2, tb_clear / 2, PIX_CLR); if (pixa1) pixaAddPix(pixa1, pixScale(pix2, 2.0, 2.0), L_INSERT); /* Choose one of three methods for extracting foreground pixels: * (1) Include all foreground pixels * (2) Do a morphological close/open to remove noise throughout * the image before finding a b.b. for remaining f.g. pixels * (3) Do a large vertical closing and choose the largest (by area) * component to avoid foreground noise on left and right sides */ if (edgeclean == 0) { ret = pixClipToForeground(pix2, NULL, &box1); } else if (edgeclean > 0) { val = edgeclean + 1; snprintf(cmd, 64, "c%d.%d + o%d.%d", val, val, val, val); pix3 = pixMorphSequence(pix2, cmd, 0); ret = pixClipToForeground(pix3, NULL, &box1); pixDestroy(&pix3); } else if (edgeclean == -1) { ret = pixMaxCompAfterVClosing(pix2, &box1); } else { /* edgeclean == -2 */ ret = pixFindPageInsideBlackBorder(pix2, &box1); } pixDestroy(&pix2); if (ret) { L_ERROR("no returned b.b. for foreground\n", __func__); boxDestroy(&box1); pixDestroy(&pix1); pixaDestroy(&pixa1); return NULL; } /* Transform to full resolution */ box2 = boxTransform(box1, 0, 0, 2.0, 2.0); /* full res */ boxDestroy(&box1); if (pixa1) { pix2 = pixCopy(NULL, pix1); pixRenderBoxArb(pix2, box2, 5, 255, 0, 0); pixaAddPix(pixa1, pix2, L_INSERT); } /* Grab the foreground region */ pix2 = pixClipRectangle(pix1, box2, NULL); pixDestroy(&pix1); /* Slightly thicken long horizontal lines. This prevents loss of * printed thin music staff lines due to aliasing. */ pix3 = pixMorphSequence(pix2, "o80.1 + d1.2", 0); pixOr(pix2, pix2, pix3); pixDestroy(&pix3); /* Rescale the fg and paste into the input-sized image */ pix3 = pixRescaleForCropping(pix2, w, h, lr_border, tb_border, maxwiden, NULL); pixDestroy(&pix2); if (pixa1) { pix2 = pixCopy(NULL, pix3); pixaAddPix(pixa1, pix2, L_INSERT); } /* Optionally widen image if possible, for printing on 8.5 x 11 inch * or A4 paper. Specifically, widen the image if the h/w asperity * ratio of the input image exceeds that of the selected paper by * more than 3%. Do not widen by more than 20%. */ r1 = (l_float32)h / (l_float32)w; r2 = 0.0; /* for default case */ if (printwiden == 1) /* standard */ r2 = r1 / 1.294; else if (printwiden == 2) /* A4 */ r2 = r1 / 1.414; if (r2 > 1.03) { r2 = L_MIN(r2, 1.20); lept_stderr("oversize h/w ratio by factor %6.3f\n", r2); pix4 = pixScale(pix3, r2, 1.0); } else { pix4 = pixClone(pix3); } pixDestroy(&pix3); if (pcropbox) *pcropbox = box2; else boxDestroy(&box2); if (pixa1) { pixaAddPix(pixa1, pix4, L_COPY); lept_stderr("Writing debug file: %s\n", debugfile); pixaConvertToPdf(pixa1, 0, 1.0, L_DEFAULT_ENCODE, 0, NULL, debugfile); pixaDestroy(&pixa1); } return pix4; } /*! * \brief pixMaxCompAfterVClosing() * * \param[in] pixs 1 bpp (input at 2x reduction) * \param[out] **pbox main region at input resolution (2x reduction) * \return 0 if OK, 1 on error * * <pre> * Notes: * (1) This removes foreground noise along left and right edges, * returning a bounding box for the remaining foreground pixels * at the input resolution. * (2) The input %pixs should be at a resolution 100 - 150 ppi. * (3) It does two 2x level1 rank binary reductions, followed * by a large vertical close/open, with a very small horizontal * close/oopen, and then a 4x expansion back to the input resolution. * (4) To work properly with 2-column layout, if the largest and * second-largest regions are comparable in size, both are included. * (5) This is used as an option to pixCropImage(), when given * an %edgecrop parameter of -1. * </pre> */ static l_ok pixMaxCompAfterVClosing(PIX *pixs, BOX **pbox) { l_int32 w1, h1, w2, h2, n, empty; BOX *box1, *box2; BOXA *boxa1, *boxa2; PIX *pix1; if (!pbox) return ERROR_INT("pbox not defined", __func__, 1); *pbox = NULL; if (!pixs || pixGetDepth(pixs) != 1) return ERROR_INT("pixs undefined or not 1 bpp", __func__, 1); /* Strong vertical closing */ pix1 = pixMorphSequence(pixs, "r11 + c3.80 + o3.80 + x4", 0); pixZero(pix1, &empty); if (empty) { pixDestroy(&pix1); return ERROR_INT("pix1 is empty", __func__, 1); } /* Find the two c.c. with largest area. If they are not comparable * in area, return the bounding box of the largest; otherwise, * return the bounding box of both regions. */ boxa1 = pixConnCompBB(pix1, 8); pixDestroy(&pix1); boxa2 = boxaSort(boxa1, L_SORT_BY_AREA, L_SORT_DECREASING, NULL); if ((n = boxaGetCount(boxa2)) == 1) { *pbox = boxaGetBox(boxa2, 0, L_COPY); } else { /* 2 or more */ box1 = boxaGetBox(boxa2, 0, L_COPY); box2 = boxaGetBox(boxa2, 1, L_COPY); boxGetGeometry(box1, NULL, NULL, &w1, &h1); boxGetGeometry(box2, NULL, NULL, &w2, &h2); if (((l_float32)(w2 * h2) / (l_float32)(w1 * h1)) > 0.7) { *pbox = boxBoundingRegion(box1, box2); boxDestroy(&box1); } else { *pbox = box1; } boxDestroy(&box2); } boxaDestroy(&boxa1); boxaDestroy(&boxa2); return 0; } /*! * \brief pixFindPageInsideBlackBorder() * * \param[in] pixs 1 bpp (input at 2x reduction) * \param[out] **pbox page region at input resolution (2x reduction) * \return 0 if OK, 1 on error * * <pre> * Notes: * (1) This extracts the page region from the image. It is designed * to work when the page is within a fairly solid black border. * (2) It returns a bounding box for the page region at the input res. * (3) The input %pixs is expected to be at a resolution 100 - 150 ppi. * (4) This is used as an option to pixCropImage(), when given an * %edgecrop parameter of -2. * </pre> */ static l_ok pixFindPageInsideBlackBorder(PIX *pixs, BOX **pbox) { l_int32 empty; BOX *box1; BOXA *boxa1, *boxa2; PIX *pix1, *pix2; if (!pbox) return ERROR_INT("pbox not defined", __func__, 1); *pbox = NULL; if (!pixs || pixGetDepth(pixs) != 1) return ERROR_INT("pixs undefined or not 1 bpp", __func__, 1); /* Reduce 4x and remove some remaining small foreground */ pix1 = pixMorphSequence(pixs, "r22 + c5.5 + o7.7", 0); pixZero(pix1, &empty); if (empty) { pixDestroy(&pix1); return ERROR_INT("pix1 is empty", __func__, 1); } /* Photoinvert image and Find the c.c. with largest area. */ pixInvert(pix1, pix1); pix2 = pixMorphSequence(pix1, "c11.11 + o11.11", 0); pixDestroy(&pix1); boxa1 = pixConnCompBB(pix2, 8); pixDestroy(&pix2); boxa2 = boxaSort(boxa1, L_SORT_BY_AREA, L_SORT_DECREASING, NULL); box1 = boxaGetBox(boxa2, 0, L_COPY); /* largest by area */ boxAdjustSides(box1, box1, 5, -5, 5, -5); *pbox = boxTransform(box1, 0, 0, 4.0, 4.0); boxaDestroy(&boxa1); boxaDestroy(&boxa2); boxDestroy(&box1); return 0; } /*! * \brief pixRescaleForCropping() * * \param[in] pixs 1 bpp * \param[in] w width of output lmage * \param[in] h height of output lmage * \param[in] lr_border cleared final border pixels on left and right * \param[in] tb_border cleared final border pixels on top and bottom * \param[in] maxwiden max fractional horizontal stretch allowed; >= 1.0 * \param[out] *ppixsc [optional] rescaled foreground region * \return pixd output image, or NULL on error * * <pre> * Notes: * (1) This rescales %pixs to fit maximally within an image of * size (w x h), under two conditions: * (a) the final image has cleared border regions given by the * input parameters %lr_border and %tb_border, and * (b) the input image is first isotropically scaled to fit * maximally within the allowed final region, and then further * maxiximally widened, subject to the constraints of the * cleared border and the %maxwiden parameter. * (2) The cleared border pixel parameters must be >= 0. * (3) If there is extra horizontal stretching by a factor * %maxwiden larger than about 1.15, the appearance may be * unpleasingly distorted; hence the suggestion not to exceed it. * </pre> */ static PIX * pixRescaleForCropping(PIX *pixs, l_int32 w, l_int32 h, l_int32 lr_border, l_int32 tb_border, l_float32 maxwiden, PIX **ppixsc) { static l_int32 first_time = TRUE; l_int32 wi, hi, wmax, hmax, wn, wf, hf, xf; l_float32 ratio, scaleh, scalew, scalewid; PIX *pix1, *pixd; if (ppixsc) *ppixsc = NULL; if (!pixs || pixGetDepth(pixs) != 1) return (PIX *)ERROR_PTR("pixs undefined or not 1 bpp", __func__, NULL); if (lr_border < 0) lr_border = 0; if (tb_border < 0) tb_border = 0; maxwiden = L_MAX(1.0, maxwiden); if (maxwiden > 1.15) L_WARNING("maxwiden = %f > 1.15; suggest between 1.0 and 1.15\n", __func__, maxwiden); /* Rescale the foreground region. * First, decide if scaling is to full width or full height. * If scaling to full height, determine how much additional * width widening is possible, given the maxwiden constraint. * If scaling to full width, both width and height are * scaled isotropically. Scaling is done so that the resulting * foreground is maximally widened, so it can be horizontally * centered in an image of size (w x h), less %lr_border * on each side. */ pixGetDimensions(pixs, &wi, &hi, NULL); wmax = w - 2 * lr_border; hmax = h - 2 * tb_border; ratio = (l_float32)(wmax * hi) / (l_float32)(hmax * wi); if (ratio >= 1) { /* width can be widened after isotropic scaling */ scaleh = (l_float32)hmax / (l_float32)hi; wn = scaleh * wi; /* scaled but not widened */ scalewid = L_MIN(maxwiden, (l_float32)wmax / (l_float32)wn); scalew = scaleh * scalewid; wf = scalew * wi; hf = hmax; /* scale to full height */ pix1 = pixScale(pixs, scalew, scaleh); if (first_time == TRUE) { lept_stderr("Width stretched by factor %5.3f\n", scalewid); first_time = FALSE; } xf = (w - wf) / 2.0; } else { /* width cannot be widened after isotropic scaling */ scalew = (l_float32)wmax / (l_float32)wi; pix1 = pixScale(pixs, scalew, scalew); wf = wmax; /* scale to full width */ hf = scalew * hi; /* no extra vertical stretching allowed */ xf = lr_border; } /* Paste it, horizontally centered and vertically placed as * high as allowed (by %tb_border) into the final page image. */ pixd = pixCreate(w, h, 1); pixRasterop(pixd, xf, tb_border, wf, hf, PIX_SRC, pix1, 0, 0); if (ppixsc) *ppixsc = pix1; else pixDestroy(&pix1); return pixd; } /*! * \brief pixCleanImage() * * \param[in] pixs full resolution (any type or depth) * \param[in] contrast vary contrast: 1 = lightest; 10 = darkest; * suggest 1 unless light features are being lost * \param[in] rotation cw by 90 degrees: {0,1,2,3} represent * 0, 90, 180 and 270 degree cw rotations * \param[in] scale 1 (no scaling) or 2 (2x upscaling) * \param[in] opensize opening size of structuring element for noise * removal: {0 or 1 to skip; 2, 3 for opening} * \return cleaned pix, or NULL on error * * <pre> * Notes: * (1) This deskews, optionally rotates and darkens, cleans background * to white, binarizes and optionally removes small noise. * (2) For color and grayscale input, local background normalization is * done to 200, and a threshold of 180 sets the maximum foreground * value in the normalized image. * (3) The %contrast parameter adjusts the binarization to avoid losing * lighter input pixels. Contrast is increased as %contrast increases * from 1 to 10. * (4) The %scale parameter controls the thresholding to 1 bpp. Two values: * 1 = threshold * 2 = linear interpolated 2x upscaling before threshold. * (5) The #opensize parameter is the size of a square SEL used with * opening to remove small speckle noise. Allowed open sizes are 2,3. * If this is to be used, try 2 before 3. * (6) This does the image processing for cleanTo1bppFilesToPdf() and * prog/cleanpdf.c. * </pre> */ PIX * pixCleanImage(PIX *pixs, l_int32 contrast, l_int32 rotation, l_int32 scale, l_int32 opensize) { char sequence[32]; PIX *pix1, *pix2, *pix3, *pix4, *pix5; if (!pixs) return (PIX *)ERROR_PTR("pixs not defined", __func__, NULL); if (rotation < 0 || rotation > 3) { L_ERROR("invalid rotation = %d; rotation must be in {0,1,2,3}\n", __func__, rotation); return NULL; } if (contrast < 1 || contrast > 10) { L_ERROR("invalid contrast = %d; contrast must be in [1...10]\n", __func__, contrast); return NULL; } if (scale != 1 && scale != 2) { L_ERROR("invalid scale = %d; scale must be 1 or 2\n", __func__, opensize); return NULL; } if (opensize > 3) { L_ERROR("invalid opensize = %d; opensize must be <= 3\n", __func__, opensize); return NULL; } if (pixGetDepth(pixs) == 1) { if (rotation > 0) pix1 = pixRotateOrth(pixs, rotation); else pix1 = pixClone(pixs); pix2 = pixFindSkewAndDeskew(pix1, 2, NULL, NULL); if (scale == 2) pix4 = pixExpandBinaryReplicate(pix2, 2, 2); else /* scale == 1 */ pix4 = pixClone(pix2); } else { pix1 = pixConvertTo8MinMax(pixs); if (rotation > 0) pix2 = pixRotateOrth(pix1, rotation); else pix2 = pixClone(pix1); pix3 = pixFindSkewAndDeskew(pix2, 2, NULL, NULL); pix4 = pixBackgroundNormTo1MinMax(pix3, contrast, scale); pixDestroy(&pix3); } if (opensize == 2 || opensize == 3) { snprintf(sequence, sizeof(sequence), "o%d.%d", opensize, opensize); pix5 = pixMorphSequence(pix4, sequence, 0); } else { pix5 = pixClone(pix4); } pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix4); return pix5; } /*! * \brief pixFindPageForeground() * * \param[in] pixs full resolution (any type or depth) * \param[in] threshold for binarization; typically about 128 * \param[in] mindist min distance of text from border to allow * cleaning near border; at 2x reduction, this * should be larger than 50; typically about 70 * \param[in] erasedist when conditions are satisfied, erase anything * within this distance of the edge; * typically 20-30 at 2x reduction * \param[in] showmorph debug: set to a negative integer to show steps * in generating masks; this is typically used * for debugging region extraction * \param[in] pixac debug: allocate outside and pass this in to * accumulate results of each call to this function, * which can be displayed in a mosaic or a pdf. * \return box region including foreground, with some pixel noise * removed, or NULL if not found * * <pre> * Notes: * (1) This doesn't simply crop to the fg. It attempts to remove * pixel noise and junk at the edge of the image before cropping. * The input %threshold is used if pixs is not 1 bpp. * (2) This is not intended to work on small thumbnails. The * dimensions of pixs must be at least MinWidth x MinHeight. * (3) Debug: set showmorph to display the intermediate image in * the morphological operations on this page. * (4) Debug: to get pdf output of results when called repeatedly, * call with an existing pixac, which will add an image of this page, * with the fg outlined. If no foreground is found, there is * no output for this page image. * </pre> */ BOX * pixFindPageForeground(PIX *pixs, l_int32 threshold, l_int32 mindist, l_int32 erasedist, l_int32 showmorph, PIXAC *pixac) { l_int32 flag, nbox, intersects; l_int32 w, h, bx, by, bw, bh, left, right, top, bottom; PIX *pixb, *pixb2, *pixseed, *pixsf, *pixm, *pix1, *pixg2; BOX *box, *boxfg, *boxin, *boxd; BOXA *ba1, *ba2; if (!pixs) return (BOX *)ERROR_PTR("pixs not defined", __func__, NULL); pixGetDimensions(pixs, &w, &h, NULL); if (w < MinWidth || h < MinHeight) { L_ERROR("pix too small: w = %d, h = %d\n", __func__, w, h); return NULL; } /* Binarize, downscale by 0.5, remove the noise to generate a seed, * and do a seedfill back from the seed into those 8-connected * components of the binarized image for which there was at least * one seed pixel. */ flag = (showmorph) ? 100 : 0; pixb = pixConvertTo1(pixs, threshold); pixb2 = pixScale(pixb, 0.5, 0.5); pixseed = pixMorphSequence(pixb2, "o1.2 + c9.9 + o3.3", flag); pix1 = pixMorphSequence(pixb2, "o50.1", 0); pixOr(pixseed, pixseed, pix1); pixDestroy(&pix1); pix1 = pixMorphSequence(pixb2, "o1.50", 0); pixOr(pixseed, pixseed, pix1); pixDestroy(&pix1); pixsf = pixSeedfillBinary(NULL, pixseed, pixb2, 8); pixm = pixRemoveBorderConnComps(pixsf, 8); /* Now, where is the main block of text? We want to remove noise near * the edge of the image, but to do that, we have to be convinced that * (1) there is noise and (2) it is far enough from the text block * and close enough to the edge. For each edge, if the block * is more than mindist from that edge, then clean 'erasedist' * pixels from the edge. */ pix1 = pixMorphSequence(pixm, "c50.50", flag); ba1 = pixConnComp(pix1, NULL, 8); ba2 = boxaSort(ba1, L_SORT_BY_AREA, L_SORT_DECREASING, NULL); pixGetDimensions(pix1, &w, &h, NULL); nbox = boxaGetCount(ba2); if (nbox > 1) { box = boxaGetBox(ba2, 0, L_CLONE); boxGetGeometry(box, &bx, &by, &bw, &bh); left = (bx > mindist) ? erasedist : 0; right = (w - bx - bw > mindist) ? erasedist : 0; top = (by > mindist) ? erasedist : 0; bottom = (h - by - bh > mindist) ? erasedist : 0; pixSetOrClearBorder(pixm, left, right, top, bottom, PIX_CLR); boxDestroy(&box); } pixDestroy(&pix1); boxaDestroy(&ba1); boxaDestroy(&ba2); /* Locate the foreground region; don't bother cropping */ pixClipToForeground(pixm, NULL, &boxfg); /* Sanity check the fg region. Make sure it's not confined * to a thin boundary on the left and right sides of the image, * in which case it is likely to be noise. */ if (boxfg) { boxin = boxCreate(0.1 * w, 0, 0.8 * w, h); boxIntersects(boxfg, boxin, &intersects); boxDestroy(&boxin); if (!intersects) boxDestroy(&boxfg); } boxd = NULL; if (boxfg) { boxAdjustSides(boxfg, boxfg, -2, 2, -2, 2); /* tiny expansion */ boxd = boxTransform(boxfg, 0, 0, 2.0, 2.0); /* Save the debug image showing the box for this page */ if (pixac) { pixg2 = pixConvert1To4Cmap(pixb); pixRenderBoxArb(pixg2, boxd, 3, 255, 0, 0); pixacompAddPix(pixac, pixg2, IFF_DEFAULT); pixDestroy(&pixg2); } } pixDestroy(&pixb); pixDestroy(&pixb2); pixDestroy(&pixseed); pixDestroy(&pixsf); pixDestroy(&pixm); boxDestroy(&boxfg); return boxd; } /*------------------------------------------------------------------* * Extraction of characters from image with only text * *------------------------------------------------------------------*/ /*! * \brief pixSplitIntoCharacters() * * \param[in] pixs 1 bpp, contains only deskewed text * \param[in] minw min component width for initial filtering; typ. 4 * \param[in] minh min component height for initial filtering; typ. 4 * \param[out] pboxa [optional] character bounding boxes * \param[out] ppixa [optional] character images * \param[out] ppixdebug [optional] showing splittings * * \return 0 if OK, 1 on error * * <pre> * Notes: * (1) This is a simple function that attempts to find split points * based on vertical pixel profiles. * (2) It should be given an image that has an arbitrary number * of text characters. * (3) The returned pixa includes the boxes from which the * (possibly split) components are extracted. * </pre> */ l_ok pixSplitIntoCharacters(PIX *pixs, l_int32 minw, l_int32 minh, BOXA **pboxa, PIXA **ppixa, PIX **ppixdebug) { l_int32 ncomp, i, xoff, yoff; BOXA *boxa1, *boxa2, *boxat1, *boxat2, *boxad; BOXAA *baa; PIX *pix, *pix1, *pix2, *pixdb; PIXA *pixa1, *pixadb; if (pboxa) *pboxa = NULL; if (ppixa) *ppixa = NULL; if (ppixdebug) *ppixdebug = NULL; if (!pixs || pixGetDepth(pixs) != 1) return ERROR_INT("pixs not defined or not 1 bpp", __func__, 1); /* Remove the small stuff */ pix1 = pixSelectBySize(pixs, minw, minh, 8, L_SELECT_IF_BOTH, L_SELECT_IF_GT, NULL); /* Small vertical close for consolidation */ pix2 = pixMorphSequence(pix1, "c1.10", 0); pixDestroy(&pix1); /* Get the 8-connected components */ boxa1 = pixConnComp(pix2, &pixa1, 8); pixDestroy(&pix2); boxaDestroy(&boxa1); /* Split the components if obvious */ ncomp = pixaGetCount(pixa1); boxa2 = boxaCreate(ncomp); pixadb = (ppixdebug) ? pixaCreate(ncomp) : NULL; for (i = 0; i < ncomp; i++) { pix = pixaGetPix(pixa1, i, L_CLONE); if (ppixdebug) { boxat1 = pixSplitComponentWithProfile(pix, 10, 7, &pixdb); if (pixdb) pixaAddPix(pixadb, pixdb, L_INSERT); } else { boxat1 = pixSplitComponentWithProfile(pix, 10, 7, NULL); } pixaGetBoxGeometry(pixa1, i, &xoff, &yoff, NULL, NULL); boxat2 = boxaTransform(boxat1, xoff, yoff, 1.0, 1.0); boxaJoin(boxa2, boxat2, 0, -1); pixDestroy(&pix); boxaDestroy(&boxat1); boxaDestroy(&boxat2); } pixaDestroy(&pixa1); /* Generate the debug image */ if (ppixdebug) { if (pixaGetCount(pixadb) > 0) { *ppixdebug = pixaDisplayTiledInRows(pixadb, 32, 1500, 1.0, 0, 20, 1); } pixaDestroy(&pixadb); } /* Do a 2D sort on the bounding boxes, and flatten the result to 1D */ baa = boxaSort2d(boxa2, NULL, 0, 0, 5); boxad = boxaaFlattenToBoxa(baa, NULL, L_CLONE); boxaaDestroy(&baa); boxaDestroy(&boxa2); /* Optionally extract the pieces from the input image */ if (ppixa) *ppixa = pixClipRectangles(pixs, boxad); if (pboxa) *pboxa = boxad; else boxaDestroy(&boxad); return 0; } /*! * \brief pixSplitComponentWithProfile() * * \param[in] pixs 1 bpp, exactly one connected component * \param[in] delta distance used in extrema finding in a numa; typ. 10 * \param[in] mindel minimum required difference between profile * minimum and profile values +2 and -2 away; typ. 7 * \param[out] ppixdebug [optional] debug image of splitting * \return boxa of c.c. after splitting, or NULL on error * * <pre> * Notes: * (1) This will split the most obvious cases of touching characters. * The split points it is searching for are narrow and deep * minimima in the vertical pixel projection profile, after a * large vertical closing has been applied to the component. * </pre> */ BOXA * pixSplitComponentWithProfile(PIX *pixs, l_int32 delta, l_int32 mindel, PIX **ppixdebug) { l_int32 w, h, n2, i, firstmin, xmin, xshift; l_int32 nmin, nleft, nright, nsplit, isplit, ncomp; l_int32 *array1, *array2; BOX *box; BOXA *boxad; NUMA *na1, *na2, *nasplit; PIX *pix1, *pixdb; if (ppixdebug) *ppixdebug = NULL; if (!pixs || pixGetDepth(pixs) != 1) return (BOXA *)ERROR_PTR("pixa undefined or not 1 bpp", __func__, NULL); pixGetDimensions(pixs, &w, &h, NULL); /* Closing to consolidate characters vertically */ pix1 = pixCloseSafeBrick(NULL, pixs, 1, 100); /* Get extrema of column projections */ boxad = boxaCreate(2); na1 = pixCountPixelsByColumn(pix1); /* w elements */ pixDestroy(&pix1); na2 = numaFindExtrema(na1, delta, NULL); n2 = numaGetCount(na2); if (n2 < 3) { /* no split possible */ box = boxCreate(0, 0, w, h); boxaAddBox(boxad, box, L_INSERT); numaDestroy(&na1); numaDestroy(&na2); return boxad; } /* Look for sufficiently deep and narrow minima. * All minima of of interest must be surrounded by max on each * side. firstmin is the index of first possible minimum. */ array1 = numaGetIArray(na1); array2 = numaGetIArray(na2); if (ppixdebug) numaWriteStderr(na2); firstmin = (array1[array2[0]] > array1[array2[1]]) ? 1 : 2; nasplit = numaCreate(n2); /* will hold split locations */ for (i = firstmin; i < n2 - 1; i+= 2) { xmin = array2[i]; nmin = array1[xmin]; if (xmin + 2 >= w) break; /* no more splits possible */ nleft = array1[xmin - 2]; nright = array1[xmin + 2]; if (ppixdebug) { lept_stderr( "Splitting: xmin = %d, w = %d; nl = %d, nmin = %d, nr = %d\n", xmin, w, nleft, nmin, nright); } if (nleft - nmin >= mindel && nright - nmin >= mindel) /* split */ numaAddNumber(nasplit, xmin); } nsplit = numaGetCount(nasplit); #if 0 if (ppixdebug && nsplit > 0) { lept_mkdir("lept/split"); gplotSimple1(na1, GPLOT_PNG, "/tmp/lept/split/split", NULL); } #endif numaDestroy(&na1); numaDestroy(&na2); LEPT_FREE(array1); LEPT_FREE(array2); if (nsplit == 0) { /* no splitting */ numaDestroy(&nasplit); box = boxCreate(0, 0, w, h); boxaAddBox(boxad, box, L_INSERT); return boxad; } /* Use split points to generate b.b. after splitting */ for (i = 0, xshift = 0; i < nsplit; i++) { numaGetIValue(nasplit, i, &isplit); box = boxCreate(xshift, 0, isplit - xshift, h); boxaAddBox(boxad, box, L_INSERT); xshift = isplit + 1; } box = boxCreate(xshift, 0, w - xshift, h); boxaAddBox(boxad, box, L_INSERT); numaDestroy(&nasplit); if (ppixdebug) { pixdb = pixConvertTo32(pixs); ncomp = boxaGetCount(boxad); for (i = 0; i < ncomp; i++) { box = boxaGetBox(boxad, i, L_CLONE); pixRenderBoxBlend(pixdb, box, 1, 255, 0, 0, 0.5); boxDestroy(&box); } *ppixdebug = pixdb; } return boxad; } /*------------------------------------------------------------------* * Extraction of lines of text * *------------------------------------------------------------------*/ /*! * \brief pixExtractTextlines() * * \param[in] pixs any depth, assumed to have nearly horizontal text * \param[in] maxw, maxh initial filtering: remove any components in pixs * with components larger than maxw or maxh * \param[in] minw, minh final filtering: remove extracted 'lines' * with sizes smaller than minw or minh; use * 0 for default. * \param[in] adjw, adjh final adjustment of boxes representing each * text line. If > 0, these increase the box * size at each edge by this amount. * \param[in] pixadb pixa for saving intermediate steps; NULL to omit * \return pixa of textline images, including bounding boxes, or * NULL on error * * <pre> * Notes: * (1) This function assumes that textline fragments have sufficient * vertical separation and small enough skew so that a * horizontal dilation sufficient to join words will not join * textlines. It does not guarantee that horizontally adjacent * textline fragments on the same line will be joined. * (2) For images with multiple columns, it attempts to avoid joining * textlines across the space between columns. If that is not * a concern, you can also use pixExtractRawTextlines(), * which will join them with alacrity. * (3) This first removes components from pixs that are either * wide (> %maxw) or tall (> %maxh). * (4) A final filtering operation removes small components, such * that width < %minw or height < %minh. * (5) For reasonable accuracy, the resolution of pixs should be * at least 100 ppi. For reasonable efficiency, the resolution * should not exceed 600 ppi. * (6) This can be used to determine if some region of a scanned * image is horizontal text. * (7) As an example, for a pix with resolution 300 ppi, a reasonable * set of parameters is: * pixExtractTextlines(pix, 150, 150, 36, 20, 5, 5, NULL); * The defaults minw and minh for 300 ppi are about 36 and 20, * so the same result is obtained with: * pixExtractTextlines(pix, 150, 150, 0, 0, 5, 5, NULL); * (8) The output pixa is composed of subimages, one for each textline, * and the boxa in the pixa tells where in %pixs each textline goes. * </pre> */ PIXA * pixExtractTextlines(PIX *pixs, l_int32 maxw, l_int32 maxh, l_int32 minw, l_int32 minh, l_int32 adjw, l_int32 adjh, PIXA *pixadb) { char buf[64]; l_int32 res, csize, empty; BOXA *boxa1, *boxa2, *boxa3; PIX *pix1, *pix2, *pix3; PIXA *pixa1, *pixa2, *pixa3; if (!pixs) return (PIXA *)ERROR_PTR("pixs not defined", __func__, NULL); /* Binarize carefully, if necessary */ if (pixGetDepth(pixs) > 1) { pix2 = pixConvertTo8(pixs, FALSE); pix3 = pixCleanBackgroundToWhite(pix2, NULL, NULL, 1.0, 70, 190); pix1 = pixThresholdToBinary(pix3, 150); pixDestroy(&pix2); pixDestroy(&pix3); } else { pix1 = pixClone(pixs); } pixZero(pix1, &empty); if (empty) { pixDestroy(&pix1); L_INFO("no fg pixels in input image\n", __func__); return NULL; } if (pixadb) pixaAddPix(pixadb, pix1, L_COPY); /* Remove any very tall or very wide connected components */ pix2 = pixSelectBySize(pix1, maxw, maxh, 8, L_SELECT_IF_BOTH, L_SELECT_IF_LT, NULL); if (pixadb) pixaAddPix(pixadb, pix2, L_COPY); pixDestroy(&pix1); /* Filter to solidify the text lines within the x-height region. * The closing (csize) bridges gaps between words. The opening * removes isolated bridges between textlines. */ if ((res = pixGetXRes(pixs)) == 0) { L_INFO("Resolution is not set: setting to 300 ppi\n", __func__); res = 300; } csize = L_MIN(120., 60.0 * res / 300.0); snprintf(buf, sizeof(buf), "c%d.1 + o%d.1", csize, csize / 3); pix3 = pixMorphCompSequence(pix2, buf, 0); if (pixadb) pixaAddPix(pixadb, pix3, L_COPY); /* Extract the connected components. These should be dilated lines */ boxa1 = pixConnComp(pix3, &pixa1, 4); if (pixadb) { pix1 = pixaDisplayRandomCmap(pixa1, 0, 0); pixcmapResetColor(pixGetColormap(pix1), 0, 255, 255, 255); pixaAddPix(pixadb, pix1, L_INSERT); } /* Set minw, minh if default is requested */ minw = (minw != 0) ? minw : (l_int32)(0.12 * res); minh = (minh != 0) ? minh : (l_int32)(0.07 * res); /* Remove line components that are too small */ pixa2 = pixaSelectBySize(pixa1, minw, minh, L_SELECT_IF_BOTH, L_SELECT_IF_GTE, NULL); if (pixadb) { pix1 = pixaDisplayRandomCmap(pixa2, 0, 0); pixcmapResetColor(pixGetColormap(pix1), 0, 255, 255, 255); pixaAddPix(pixadb, pix1, L_INSERT); pix1 = pixConvertTo32(pix2); pixRenderBoxaArb(pix1, pixa2->boxa, 2, 255, 0, 0); pixaAddPix(pixadb, pix1, L_INSERT); } /* Selectively AND with the version before dilation, and save */ boxa2 = pixaGetBoxa(pixa2, L_CLONE); boxa3 = boxaAdjustSides(boxa2, -adjw, adjw, -adjh, adjh); pixa3 = pixClipRectangles(pix2, boxa3); if (pixadb) { pix1 = pixaDisplayRandomCmap(pixa3, 0, 0); pixcmapResetColor(pixGetColormap(pix1), 0, 255, 255, 255); pixaAddPix(pixadb, pix1, L_INSERT); } pixDestroy(&pix2); pixDestroy(&pix3); pixaDestroy(&pixa1); pixaDestroy(&pixa2); boxaDestroy(&boxa1); boxaDestroy(&boxa2); boxaDestroy(&boxa3); return pixa3; } /*! * \brief pixExtractRawTextlines() * * \param[in] pixs any depth, assumed to have nearly horizontal text * \param[in] maxw, maxh initial filtering: remove any components in pixs * with components larger than maxw or maxh; * use 0 for default values. * \param[in] adjw, adjh final adjustment of boxes representing each * text line. If > 0, these increase the box * size at each edge by this amount. * \param[in] pixadb pixa for saving intermediate steps; NULL to omit * \return pixa of textline images, including bounding boxes, or * NULL on error * * <pre> * Notes: * (1) This function assumes that textlines have sufficient * vertical separation and small enough skew so that a * horizontal dilation sufficient to join words will not join * textlines. It aggressively joins textlines across multiple * columns, so if that is not desired, you must either (a) make * sure that %pixs is a single column of text or (b) use instead * pixExtractTextlines(), which is more conservative * about joining text fragments that have vertical overlap. * (2) This first removes components from pixs that are either * very wide (> %maxw) or very tall (> %maxh). * (3) For reasonable accuracy, the resolution of pixs should be * at least 100 ppi. For reasonable efficiency, the resolution * should not exceed 600 ppi. * (4) This can be used to determine if some region of a scanned * image is horizontal text. * (5) As an example, for a pix with resolution 300 ppi, a reasonable * set of parameters is: * pixExtractRawTextlines(pix, 150, 150, 0, 0, NULL); * (6) The output pixa is composed of subimages, one for each textline, * and the boxa in the pixa tells where in %pixs each textline goes. * </pre> */ PIXA * pixExtractRawTextlines(PIX *pixs, l_int32 maxw, l_int32 maxh, l_int32 adjw, l_int32 adjh, PIXA *pixadb) { char buf[64]; l_int32 res, csize, empty; BOXA *boxa1, *boxa2, *boxa3; BOXAA *baa1; PIX *pix1, *pix2, *pix3; PIXA *pixa1, *pixa2; if (!pixs) return (PIXA *)ERROR_PTR("pixs not defined", __func__, NULL); /* Set maxw, maxh if default is requested */ if ((res = pixGetXRes(pixs)) == 0) { L_INFO("Resolution is not set: setting to 300 ppi\n", __func__); res = 300; } maxw = (maxw != 0) ? maxw : (l_int32)(0.5 * res); maxh = (maxh != 0) ? maxh : (l_int32)(0.5 * res); /* Binarize carefully, if necessary */ if (pixGetDepth(pixs) > 1) { pix2 = pixConvertTo8(pixs, FALSE); pix3 = pixCleanBackgroundToWhite(pix2, NULL, NULL, 1.0, 70, 190); pix1 = pixThresholdToBinary(pix3, 150); pixDestroy(&pix2); pixDestroy(&pix3); } else { pix1 = pixClone(pixs); } pixZero(pix1, &empty); if (empty) { pixDestroy(&pix1); L_INFO("no fg pixels in input image\n", __func__); return NULL; } if (pixadb) pixaAddPix(pixadb, pix1, L_COPY); /* Remove any very tall or very wide connected components */ pix2 = pixSelectBySize(pix1, maxw, maxh, 8, L_SELECT_IF_BOTH, L_SELECT_IF_LT, NULL); if (pixadb) pixaAddPix(pixadb, pix2, L_COPY); pixDestroy(&pix1); /* Filter to solidify the text lines within the x-height region. * The closing (csize) bridges gaps between words. */ csize = L_MIN(120., 60.0 * res / 300.0); snprintf(buf, sizeof(buf), "c%d.1", csize); pix3 = pixMorphCompSequence(pix2, buf, 0); if (pixadb) pixaAddPix(pixadb, pix3, L_COPY); /* Extract the connected components. These should be dilated lines */ boxa1 = pixConnComp(pix3, &pixa1, 4); if (pixadb) { pix1 = pixaDisplayRandomCmap(pixa1, 0, 0); pixcmapResetColor(pixGetColormap(pix1), 0, 255, 255, 255); pixaAddPix(pixadb, pix1, L_INSERT); } /* Do a 2-d sort, and generate a bounding box for each set of text * line segments that is aligned horizontally (i.e., has vertical * overlap) into a box representing a single text line. */ baa1 = boxaSort2d(boxa1, NULL, -1, -1, 5); boxaaGetExtent(baa1, NULL, NULL, NULL, &boxa2); if (pixadb) { pix1 = pixConvertTo32(pix2); pixRenderBoxaArb(pix1, boxa2, 2, 255, 0, 0); pixaAddPix(pixadb, pix1, L_INSERT); } /* Optionally adjust the sides of each text line box, and then * use the boxes to generate a pixa of the text lines. */ boxa3 = boxaAdjustSides(boxa2, -adjw, adjw, -adjh, adjh); pixa2 = pixClipRectangles(pix2, boxa3); if (pixadb) { pix1 = pixaDisplayRandomCmap(pixa2, 0, 0); pixcmapResetColor(pixGetColormap(pix1), 0, 255, 255, 255); pixaAddPix(pixadb, pix1, L_INSERT); } pixDestroy(&pix2); pixDestroy(&pix3); pixaDestroy(&pixa1); boxaDestroy(&boxa1); boxaDestroy(&boxa2); boxaDestroy(&boxa3); boxaaDestroy(&baa1); return pixa2; } /*------------------------------------------------------------------* * How many text columns * *------------------------------------------------------------------*/ /*! * \brief pixCountTextColumns() * * \param[in] pixs 1 bpp * \param[in] deltafract fraction of (max - min) to be used in the delta * for extrema finding; typ 0.3 * \param[in] peakfract fraction of (max - min) to be used to threshold * the peak value; typ. 0.5 * \param[in] clipfract fraction of image dimension removed on each side; * typ. 0.1, which leaves w and h reduced by 0.8 * \param[out] pncols number of columns; -1 if not determined * \param[in] pixadb [optional] pre-allocated, for showing * intermediate computation; use null to skip * \return 0 if OK, 1 on error * * <pre> * Notes: * (1) It is assumed that pixs has the correct resolution set. * If the resolution is 0, we set to 300 and issue a warning. * (2) If necessary, the image is scaled to between 37 and 75 ppi; * most of the processing is done at this resolution. * (3) If no text is found (essentially a blank page), * this returns ncols = 0. * (4) For debug output, input a pre-allocated pixa. * </pre> */ l_ok pixCountTextColumns(PIX *pixs, l_float32 deltafract, l_float32 peakfract, l_float32 clipfract, l_int32 *pncols, PIXA *pixadb) { l_int32 w, h, res, i, n, npeak; l_float32 scalefact, redfact, minval, maxval, val4, val5, fract; BOX *box; NUMA *na1, *na2, *na3, *na4, *na5; PIX *pix1, *pix2, *pix3, *pix4, *pix5; if (!pncols) return ERROR_INT("&ncols not defined", __func__, 1); *pncols = -1; /* init */ if (!pixs || pixGetDepth(pixs) != 1) return ERROR_INT("pixs not defined or not 1 bpp", __func__, 1); if (deltafract < 0.15 || deltafract > 0.75) L_WARNING("deltafract not in [0.15 ... 0.75]\n", __func__); if (peakfract < 0.25 || peakfract > 0.9) L_WARNING("peakfract not in [0.25 ... 0.9]\n", __func__); if (clipfract < 0.0 || clipfract >= 0.5) return ERROR_INT("clipfract not in [0.0 ... 0.5)\n", __func__, 1); if (pixadb) pixaAddPix(pixadb, pixs, L_COPY); /* Scale to between 37.5 and 75 ppi */ if ((res = pixGetXRes(pixs)) == 0) { L_WARNING("resolution undefined; set to 300\n", __func__); pixSetResolution(pixs, 300, 300); res = 300; } if (res < 37) { L_WARNING("resolution %d very low\n", __func__, res); scalefact = 37.5 / res; pix1 = pixScale(pixs, scalefact, scalefact); } else { redfact = (l_float32)res / 37.5; if (redfact < 2.0) pix1 = pixClone(pixs); else if (redfact < 4.0) pix1 = pixReduceRankBinaryCascade(pixs, 1, 0, 0, 0); else if (redfact < 8.0) pix1 = pixReduceRankBinaryCascade(pixs, 1, 2, 0, 0); else if (redfact < 16.0) pix1 = pixReduceRankBinaryCascade(pixs, 1, 2, 2, 0); else pix1 = pixReduceRankBinaryCascade(pixs, 1, 2, 2, 2); } if (pixadb) pixaAddPix(pixadb, pix1, L_COPY); /* Crop inner 80% of image */ pixGetDimensions(pix1, &w, &h, NULL); box = boxCreate(clipfract * w, clipfract * h, (1.0 - 2 * clipfract) * w, (1.0 - 2 * clipfract) * h); pix2 = pixClipRectangle(pix1, box, NULL); pixGetDimensions(pix2, &w, &h, NULL); boxDestroy(&box); if (pixadb) pixaAddPix(pixadb, pix2, L_COPY); /* Deskew */ pix3 = pixDeskew(pix2, 0); if (pixadb) pixaAddPix(pixadb, pix3, L_COPY); /* Close to increase column counts for text */ pix4 = pixCloseSafeBrick(NULL, pix3, 5, 21); if (pixadb) pixaAddPix(pixadb, pix4, L_COPY); pixInvert(pix4, pix4); na1 = pixCountByColumn(pix4, NULL); if (pixadb) { gplotSimple1(na1, GPLOT_PNG, "/tmp/lept/plot", NULL); pix5 = pixRead("/tmp/lept/plot.png"); pixaAddPix(pixadb, pix5, L_INSERT); } /* Analyze the column counts. na4 gives the locations of * the extrema in normalized units (0.0 to 1.0) across the * cropped image. na5 gives the magnitude of the * extrema, normalized to the dynamic range. The peaks * are values that are at least peakfract of (max - min). */ numaGetMax(na1, &maxval, NULL); numaGetMin(na1, &minval, NULL); fract = (l_float32)(maxval - minval) / h; /* is there much at all? */ if (fract < 0.05) { L_INFO("very little content on page; 0 text columns\n", __func__); *pncols = 0; } else { na2 = numaFindExtrema(na1, deltafract * (maxval - minval), &na3); na4 = numaTransform(na2, 0, 1.0 / w); na5 = numaTransform(na3, -minval, 1.0 / (maxval - minval)); n = numaGetCount(na4); for (i = 0, npeak = 0; i < n; i++) { numaGetFValue(na4, i, &val4); numaGetFValue(na5, i, &val5); if (val4 > 0.3 && val4 < 0.7 && val5 >= peakfract) { npeak++; L_INFO("Peak(loc,val) = (%5.3f,%5.3f)\n", __func__, val4, val5); } } *pncols = npeak + 1; numaDestroy(&na2); numaDestroy(&na3); numaDestroy(&na4); numaDestroy(&na5); } pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); numaDestroy(&na1); return 0; } /*------------------------------------------------------------------* * Decision text vs photo * *------------------------------------------------------------------*/ /*! * \brief pixDecideIfText() * * \param[in] pixs any depth * \param[in] box [optional] if null, use entire pixs * \param[out] pistext 1 if text; 0 if photo; -1 if not determined or empty * \param[in] pixadb [optional] pre-allocated, for showing intermediate * computation; use NULL to skip * \return 0 if OK, 1 on error * * <pre> * Notes: * (1) It is assumed that pixs has the correct resolution set. * If the resolution is 0, we set to 300 and issue a warning. * (2) If necessary, the image is scaled to 300 ppi; most of the * processing is done at this resolution. * (3) Text is assumed to be in horizontal lines. * (4) Because thin vertical lines are removed before filtering for * text lines, this should identify tables as text. * (5) If %box is null and pixs contains both text lines and line art, * this function might return %istext == true. * (6) If the input pixs is empty, or for some other reason the * result can not be determined, return -1. * (7) For debug output, input a pre-allocated pixa. * </pre> */ l_ok pixDecideIfText(PIX *pixs, BOX *box, l_int32 *pistext, PIXA *pixadb) { l_int32 i, empty, maxw, w, h, n1, n2, n3, minlines, big_comp; l_float32 ratio1, ratio2; L_BMF *bmf; BOXA *boxa1, *boxa2, *boxa3, *boxa4, *boxa5; PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7; PIXA *pixa1; SEL *sel1; if (!pistext) return ERROR_INT("&istext not defined", __func__, 1); *pistext = -1; if (!pixs) return ERROR_INT("pixs not defined", __func__, 1); /* Crop, convert to 1 bpp, 300 ppi */ if ((pix1 = pixPrepare1bpp(pixs, box, 0.1, 300)) == NULL) return ERROR_INT("pix1 not made", __func__, 1); pixZero(pix1, &empty); if (empty) { pixDestroy(&pix1); L_INFO("pix is empty\n", __func__); return 0; } w = pixGetWidth(pix1); /* Identify and remove tall, thin vertical lines (as found in tables) * that are up to 9 pixels wide. Make a hit-miss sel with an * 81 pixel vertical set of hits and with 3 pairs of misses that * are 10 pixels apart horizontally. It is necessary to use a * hit-miss transform; if we only opened with a vertical line of * hits, we would remove solid regions of pixels that are not * text or vertical lines. */ pix2 = pixCreate(11, 81, 1); for (i = 0; i < 81; i++) pixSetPixel(pix2, 5, i, 1); sel1 = selCreateFromPix(pix2, 40, 5, NULL); selSetElement(sel1, 20, 0, SEL_MISS); selSetElement(sel1, 20, 10, SEL_MISS); selSetElement(sel1, 40, 0, SEL_MISS); selSetElement(sel1, 40, 10, SEL_MISS); selSetElement(sel1, 60, 0, SEL_MISS); selSetElement(sel1, 60, 10, SEL_MISS); pix3 = pixHMT(NULL, pix1, sel1); pix4 = pixSeedfillBinaryRestricted(NULL, pix3, pix1, 8, 5, 1000); pix5 = pixXor(NULL, pix1, pix4); pixDestroy(&pix2); selDestroy(&sel1); /* Convert the text lines to separate long horizontal components */ pix6 = pixMorphCompSequence(pix5, "c30.1 + o15.1 + c60.1 + o2.2", 0); /* Estimate the distance to the bottom of the significant region */ if (box) { /* use full height */ pixGetDimensions(pix6, NULL, &h, NULL); } else { /* use height of region that has text lines */ pixFindThreshFgExtent(pix6, 400, NULL, &h); } if (pixadb) { bmf = bmfCreate(NULL, 6); pixaAddPixWithText(pixadb, pix1, 1, bmf, "threshold/crop to binary", 0x0000ff00, L_ADD_BELOW); pixaAddPixWithText(pixadb, pix3, 2, bmf, "hit-miss for vertical line", 0x0000ff00, L_ADD_BELOW); pixaAddPixWithText(pixadb, pix4, 2, bmf, "restricted seed-fill", 0x0000ff00, L_ADD_BELOW); pixaAddPixWithText(pixadb, pix5, 2, bmf, "remove using xor", 0x0000ff00, L_ADD_BELOW); pixaAddPixWithText(pixadb, pix6, 2, bmf, "make long horiz components", 0x0000ff00, L_ADD_BELOW); } /* Extract the connected components */ if (pixadb) { boxa1 = pixConnComp(pix6, &pixa1, 8); pix7 = pixaDisplayRandomCmap(pixa1, 0, 0); pixcmapResetColor(pixGetColormap(pix7), 0, 255, 255, 255); pixaAddPixWithText(pixadb, pix7, 2, bmf, "show connected components", 0x0000ff00, L_ADD_BELOW); pixDestroy(&pix7); pixaDestroy(&pixa1); bmfDestroy(&bmf); } else { boxa1 = pixConnComp(pix6, NULL, 8); } /* Analyze the connected components. The following conditions * at 300 ppi must be satisfied if the image is text: * (1) There are no components that are wider than 400 pixels and * taller than 175 pixels. * (2) The second longest component is at least 60% of the * (possibly cropped) image width. This catches images * that don't have any significant content. * (3) Of the components that are at least 40% of the length * of the longest (n2), at least 80% of them must not exceed * 60 pixels in height. * (4) The number of those long, thin components (n3) must * equal or exceed a minimum that scales linearly with the * image height. * Most images that are not text fail more than one of these * conditions. */ boxa2 = boxaSort(boxa1, L_SORT_BY_WIDTH, L_SORT_DECREASING, NULL); boxaGetBoxGeometry(boxa2, 1, NULL, NULL, &maxw, NULL); /* 2nd longest */ boxa3 = boxaSelectBySize(boxa1, 0.4 * maxw, 0, L_SELECT_WIDTH, L_SELECT_IF_GTE, NULL); boxa4 = boxaSelectBySize(boxa3, 0, 60, L_SELECT_HEIGHT, L_SELECT_IF_LTE, NULL); boxa5 = boxaSelectBySize(boxa1, 400, 175, L_SELECT_IF_BOTH, L_SELECT_IF_GT, NULL); big_comp = (boxaGetCount(boxa5) == 0) ? 0 : 1; n1 = boxaGetCount(boxa1); n2 = boxaGetCount(boxa3); n3 = boxaGetCount(boxa4); ratio1 = (l_float32)maxw / (l_float32)w; ratio2 = (l_float32)n3 / (l_float32)n2; minlines = L_MAX(2, h / 125); if (big_comp || ratio1 < 0.6 || ratio2 < 0.8 || n3 < minlines) *pistext = 0; else *pistext = 1; if (pixadb) { if (*pistext == 1) { L_INFO("This is text: \n n1 = %d, n2 = %d, n3 = %d, " "minlines = %d\n maxw = %d, ratio1 = %4.2f, h = %d, " "big_comp = %d\n", __func__, n1, n2, n3, minlines, maxw, ratio1, h, big_comp); } else { L_INFO("This is not text: \n n1 = %d, n2 = %d, n3 = %d, " "minlines = %d\n maxw = %d, ratio1 = %4.2f, h = %d, " "big_comp = %d\n", __func__, n1, n2, n3, minlines, maxw, ratio1, h, big_comp); } } boxaDestroy(&boxa1); boxaDestroy(&boxa2); boxaDestroy(&boxa3); boxaDestroy(&boxa4); boxaDestroy(&boxa5); pixDestroy(&pix1); pixDestroy(&pix3); pixDestroy(&pix4); pixDestroy(&pix5); pixDestroy(&pix6); return 0; } /*! * \brief pixFindThreshFgExtent() * * \param[in] pixs 1 bpp * \param[in] thresh threshold number of pixels in row * \param[out] ptop [optional] location of top of region * \param[out] pbot [optional] location of bottom of region * \return 0 if OK, 1 on error */ l_ok pixFindThreshFgExtent(PIX *pixs, l_int32 thresh, l_int32 *ptop, l_int32 *pbot) { l_int32 i, n; l_int32 *array; NUMA *na; if (ptop) *ptop = 0; if (pbot) *pbot = 0; if (!ptop && !pbot) return ERROR_INT("nothing to determine", __func__, 1); if (!pixs || pixGetDepth(pixs) != 1) return ERROR_INT("pixs not defined or not 1 bpp", __func__, 1); na = pixCountPixelsByRow(pixs, NULL); n = numaGetCount(na); array = numaGetIArray(na); if (ptop) { for (i = 0; i < n; i++) { if (array[i] >= thresh) { *ptop = i; break; } } } if (pbot) { for (i = n - 1; i >= 0; i--) { if (array[i] >= thresh) { *pbot = i; break; } } } LEPT_FREE(array); numaDestroy(&na); return 0; } /*------------------------------------------------------------------* * Decision: table vs text * *------------------------------------------------------------------*/ /*! * \brief pixDecideIfTable() * * \param[in] pixs any depth, any resolution >= 75 ppi * \param[in] box [optional] if null, use entire pixs * \param[in] orient L_PORTRAIT_MODE, L_LANDSCAPE_MODE * \param[out] pscore 0 - 4; -1 if not determined * \param[in] pixadb [optional] pre-allocated, for showing intermediate * computation; use NULL to skip * \return 0 if OK, 1 on error * * <pre> * Notes: * (1) It is assumed that pixs has the correct resolution set. * If the resolution is 0, we assume it is 300 ppi and issue a warning. * (2) If %orient == L_LANDSCAPE_MODE, the image is rotated 90 degrees * clockwise before being analyzed. * (3) The interpretation of the returned score: * -1 undetermined * 0 no table * 1 unlikely to have a table * 2 likely to have a table * 3 even more likely to have a table * 4 extremely likely to have a table * * Setting the condition for finding a table at score >= 2 works * well, except for false positives on kanji and landscape text. * * These false positives can be removed by setting the condition * at score >= 3, but recall is lowered because it will not find * tables without either horizontal or vertical lines. * (4) Most of the processing takes place at 75 ppi. * (5) Internally, three numbers are determined, for horizontal and * vertical fg lines, and for vertical bg lines. From these, * four tests are made to decide if there is a table occupying * a significant part of the image. * (6) Images have arbitrary content and would be likely to trigger * this detector, so they are checked for first, and if found, * return with a 0 (no table) score. * (7) Musical scores (tablature) are likely to trigger the detector. * (8) Tables of content with more than 2 columns are likely to * trigger the detector. * (9) For debug output, input a pre-allocated pixa. * </pre> */ l_ok pixDecideIfTable(PIX *pixs, BOX *box, l_int32 orient, l_int32 *pscore, PIXA *pixadb) { l_int32 empty, nhb, nvb, nvw, score, htfound; PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7, *pix8, *pix9; if (!pscore) return ERROR_INT("&score not defined", __func__, 1); *pscore = -1; if (!pixs) return ERROR_INT("pixs not defined", __func__, 1); /* Check if there is an image region. First convert to 1 bpp * at 175 ppi. If an image is found, assume there is no table. */ pix1 = pixPrepare1bpp(pixs, box, 0.1f, 175); pix2 = pixGenerateHalftoneMask(pix1, NULL, &htfound, NULL); if (htfound && pixadb) pixaAddPix(pixadb, pix2, L_COPY); pixDestroy(&pix1); pixDestroy(&pix2); if (htfound) { *pscore = 0; L_INFO("pix has an image region\n", __func__); return 0; } /* Crop, convert to 1 bpp, 75 ppi */ if ((pix1 = pixPrepare1bpp(pixs, box, 0.05, 75)) == NULL) return ERROR_INT("pix1 not made", __func__, 1); pixZero(pix1, &empty); if (empty) { *pscore = 0; pixDestroy(&pix1); L_INFO("pix is empty\n", __func__); return 0; } /* The 2x2 dilation on 75 ppi makes these two approaches very similar: * (1) pix1 = pixPrepare1bpp(..., 300); // 300 ppi resolution * pix2 = pixReduceRankBinaryCascade(pix1, 1, 1, 0, 0); * (2) pix1 = pixPrepare1bpp(..., 75); // 75 ppi resolution * pix2 = pixDilateBrick(NULL, pix1, 2, 2); * But (2) is more efficient if the input image to pixPrepare1bpp() * is not at 300 ppi. */ pix2 = pixDilateBrick(NULL, pix1, 2, 2); /* Deskew both horizontally and vertically; rotate by 90 * degrees if in landscape mode. */ pix3 = pixDeskewBoth(pix2, 1); if (pixadb) { pixaAddPix(pixadb, pix2, L_COPY); pixaAddPix(pixadb, pix3, L_COPY); } if (orient == L_LANDSCAPE_MODE) pix4 = pixRotate90(pix3, 1); else pix4 = pixClone(pix3); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pix1 = pixClone(pix4); pixDestroy(&pix4); /* Look for horizontal and vertical lines */ pix2 = pixMorphSequence(pix1, "o100.1 + c1.4", 0); pix3 = pixSeedfillBinary(NULL, pix2, pix1, 8); pix4 = pixMorphSequence(pix1, "o1.100 + c4.1", 0); pix5 = pixSeedfillBinary(NULL, pix4, pix1, 8); pix6 = pixOr(NULL, pix3, pix5); if (pixadb) { pixaAddPix(pixadb, pix2, L_COPY); pixaAddPix(pixadb, pix4, L_COPY); pixaAddPix(pixadb, pix3, L_COPY); pixaAddPix(pixadb, pix5, L_COPY); pixaAddPix(pixadb, pix6, L_COPY); } pixCountConnComp(pix2, 8, &nhb); /* number of horizontal black lines */ pixCountConnComp(pix4, 8, &nvb); /* number of vertical black lines */ /* Remove the lines */ pixSubtract(pix1, pix1, pix6); if (pixadb) pixaAddPix(pixadb, pix1, L_COPY); /* Remove noise pixels */ pix7 = pixMorphSequence(pix1, "c4.1 + o8.1", 0); if (pixadb) pixaAddPix(pixadb, pix7, L_COPY); /* Look for vertical white space. Invert to convert white bg * to fg. Use a single rank-1 2x reduction, which closes small * fg holes, for the final processing at 37.5 ppi. * The vertical opening is then about 3 inches on a 300 ppi image. * We also remove vertical whitespace that is less than 5 pixels * wide at this resolution (about 0.1 inches) */ pixInvert(pix7, pix7); pix8 = pixMorphSequence(pix7, "r1 + o1.100", 0); pix9 = pixSelectBySize(pix8, 5, 0, 8, L_SELECT_WIDTH, L_SELECT_IF_GTE, NULL); pixCountConnComp(pix9, 8, &nvw); /* number of vertical white lines */ if (pixadb) { pixaAddPix(pixadb, pixScale(pix8, 2.0, 2.0), L_INSERT); pixaAddPix(pixadb, pixScale(pix9, 2.0, 2.0), L_INSERT); } /* Require at least 2 of the following 4 conditions for a table. * Some tables do not have black (fg) lines, and for those we * require more than 6 long vertical whitespace (bg) lines. */ score = 0; if (nhb > 1) score++; if (nvb > 2) score++; if (nvw > 3) score++; if (nvw > 6) score++; *pscore = score; pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pix3); pixDestroy(&pix4); pixDestroy(&pix5); pixDestroy(&pix6); pixDestroy(&pix7); pixDestroy(&pix8); pixDestroy(&pix9); return 0; } /*! * \brief pixPrepare1bpp() * * \param[in] pixs any depth * \param[in] box [optional] if null, use entire pixs * \param[in] cropfract fraction to be removed from the boundary; * use 0.0 to retain the entire image * \param[in] outres desired resolution of output image; if the * input image resolution is not set, assume * 300 ppi; use 0 to skip scaling. * \return pixd if OK, NULL on error * * <pre> * Notes: * (1) This handles some common pre-processing operations, * where the page segmentation algorithm takes a 1 bpp image. * </pre> */ PIX * pixPrepare1bpp(PIX *pixs, BOX *box, l_float32 cropfract, l_int32 outres) { l_int32 w, h, res; l_float32 factor; BOX *box1; PIX *pix1, *pix2, *pix3, *pix4, *pix5; if (!pixs) return (PIX *)ERROR_PTR("pixs not defined", __func__, NULL); /* Crop the image. If no box is given, use %cropfract to remove * pixels near the image boundary; this helps avoid false * negatives from noise that is often found there. */ if (box) { pix1 = pixClipRectangle(pixs, box, NULL); } else { pixGetDimensions(pixs, &w, &h, NULL); box1 = boxCreate((l_int32)(cropfract * w), (l_int32)(cropfract * h), (l_int32)((1.0 - 2 * cropfract) * w), (l_int32)((1.0 - 2 * cropfract) * h)); pix1 = pixClipRectangle(pixs, box1, NULL); boxDestroy(&box1); } /* Convert to 1 bpp with adaptive background cleaning */ if (pixGetDepth(pixs) > 1) { pix2 = pixConvertTo8(pix1, 0); pix3 = pixCleanBackgroundToWhite(pix2, NULL, NULL, 1.0, 70, 160); pixDestroy(&pix1); pixDestroy(&pix2); if (!pix3) { L_INFO("pix cleaning failed\n", __func__); return NULL; } pix4 = pixThresholdToBinary(pix3, 200); pixDestroy(&pix3); } else { pix4 = pixClone(pix1); pixDestroy(&pix1); } /* Scale the image to the requested output resolution; do not scale if %outres <= 0 */ if (outres <= 0) return pix4; if ((res = pixGetXRes(pixs)) == 0) { L_WARNING("Resolution is not set: using 300 ppi\n", __func__); res = 300; } if (res != outres) { factor = (l_float32)outres / (l_float32)res; pix5 = pixScale(pix4, factor, factor); } else { pix5 = pixClone(pix4); } pixDestroy(&pix4); return pix5; } /*------------------------------------------------------------------* * Estimate the grayscale background value * *------------------------------------------------------------------*/ /*! * \brief pixEstimateBackground() * * \param[in] pixs 8 bpp, with or without colormap * \param[in] darkthresh pixels below this value are never considered * part of the background; typ. 70; use 0 to skip * \param[in] edgecrop fraction of half-width on each side, and of * half-height at top and bottom, that are cropped * \param[out] pbg estimated background, or 0 on error * \return 0 if OK, 1 on error * * <pre> * Notes: * (1) Caller should check that return bg value is > 0. * </pre> */ l_ok pixEstimateBackground(PIX *pixs, l_int32 darkthresh, l_float32 edgecrop, l_int32 *pbg) { l_int32 w, h, sampling; l_float32 fbg; BOX *box; PIX *pix1, *pix2, *pixm; if (!pbg) return ERROR_INT("&bg not defined", __func__, 1); *pbg = 0; if (!pixs || pixGetDepth(pixs) != 8) return ERROR_INT("pixs not defined or not 8 bpp", __func__, 1); if (darkthresh > 128) L_WARNING("darkthresh unusually large\n", __func__); if (edgecrop < 0.0 || edgecrop >= 1.0) return ERROR_INT("edgecrop not in [0.0 ... 1.0)", __func__, 1); pix1 = pixRemoveColormap(pixs, REMOVE_CMAP_TO_GRAYSCALE); pixGetDimensions(pix1, &w, &h, NULL); /* Optionally crop inner part of image */ if (edgecrop > 0.0) { box = boxCreate(0.5 * edgecrop * w, 0.5 * edgecrop * h, (1.0 - edgecrop) * w, (1.0 - edgecrop) * h); pix2 = pixClipRectangle(pix1, box, NULL); boxDestroy(&box); } else { pix2 = pixClone(pix1); } /* We will use no more than 50K samples */ sampling = L_MAX(1, (l_int32)sqrt((l_float64)(w * h) / 50000. + 0.5)); /* Optionally make a mask over all pixels lighter than %darkthresh */ pixm = NULL; if (darkthresh > 0) { pixm = pixThresholdToBinary(pix2, darkthresh); pixInvert(pixm, pixm); } pixGetRankValueMasked(pix2, pixm, 0, 0, sampling, 0.5, &fbg, NULL); *pbg = (l_int32)(fbg + 0.5); pixDestroy(&pix1); pixDestroy(&pix2); pixDestroy(&pixm); return 0; } /*---------------------------------------------------------------------* * Largest white or black rectangles in an image * *---------------------------------------------------------------------*/ /*! * \brief pixFindLargeRectangles() * * \param[in] pixs 1 bpp * \param[in] polarity 0 within background, 1 within foreground * \param[in] nrect number of rectangles to be found * \param[out] pboxa largest rectangles, sorted by decreasing area * \param[in,out] ppixdb optional return output with rectangles drawn on it * \return 0 if OK, 1 on error * * <pre> * Notes: * (1) This does a greedy search to find the largest rectangles, * either black or white and without overlaps, in %pix. * (2) See pixFindLargestRectangle(), which is called multiple * times, for details. On each call, the largest rectangle * found is painted, so that none of its pixels can be * used later, before calling it again. * (3) This function is surprisingly fast. Although * pixFindLargestRectangle() runs at about 50 MPix/sec, when it * is run multiple times by pixFindLargeRectangles(), it processes * at 150 - 250 MPix/sec, and the time is approximately linear * in %nrect. For example, for a 1 MPix image, searching for * the largest 50 boxes takes about 0.2 seconds. * </pre> */ l_ok pixFindLargeRectangles(PIX *pixs, l_int32 polarity, l_int32 nrect, BOXA **pboxa, PIX **ppixdb) { l_int32 i, op, bx, by, bw, bh; BOX *box; BOXA *boxa; PIX *pix; if (ppixdb) *ppixdb = NULL; if (!pboxa) return ERROR_INT("&boxa not defined", __func__, 1); *pboxa = NULL; if (!pixs || pixGetDepth(pixs) != 1) return ERROR_INT("pixs not defined or not 1 bpp", __func__, 1); if (polarity != 0 && polarity != 1) return ERROR_INT("invalid polarity", __func__, 1); if (nrect > 1000) { L_WARNING("large num rectangles = %d requested; using 1000\n", __func__, nrect); nrect = 1000; } pix = pixCopy(NULL, pixs); boxa = boxaCreate(nrect); *pboxa = boxa; /* Sequentially find largest rectangle and fill with opposite color */ for (i = 0; i < nrect; i++) { if (pixFindLargestRectangle(pix, polarity, &box, NULL) == 1) { boxDestroy(&box); L_ERROR("failure in pixFindLargestRectangle\n", __func__); break; } boxaAddBox(boxa, box, L_INSERT); op = (polarity == 0) ? PIX_SET : PIX_CLR; boxGetGeometry(box, &bx, &by, &bw, &bh); pixRasterop(pix, bx, by, bw, bh, op, NULL, 0, 0); } if (ppixdb) *ppixdb = pixDrawBoxaRandom(pixs, boxa, 3); pixDestroy(&pix); return 0; } /*! * \brief pixFindLargestRectangle() * * \param[in] pixs 1 bpp * \param[in] polarity 0 within background, 1 within foreground * \param[out] pbox largest area rectangle * \param[in,out] ppixdb optional return output with rectangle drawn on it * \return 0 if OK, 1 on error * * <pre> * Notes: * (1) This is a simple and elegant solution to a problem in * computational geometry that at first appears to be quite * difficult: what is the largest rectangle that can be * placed in the image, covering only pixels of one polarity * (bg or fg)? The solution is O(n), where n is the number * of pixels in the image, and it requires nothing more than * using a simple recursion relation in a single sweep of the image. * (2) In a sweep from UL to LR with left-to-right being the fast * direction, calculate the largest white rectangle at (x, y), * using previously calculated values at pixels #1 and #2: * #1: (x, y - 1) * #2: (x - 1, y) * We also need the most recent "black" pixels that were seen * in the current row and column. * Consider the largest area. There are only two possibilities: * (a) Min(w(1), horizdist) * (h(1) + 1) * (b) Min(h(2), vertdist) * (w(2) + 1) * where * horizdist: the distance from the rightmost "black" pixel seen * in the current row across to the current pixel * vertdist: the distance from the lowest "black" pixel seen * in the current column down to the current pixel * and we choose the Max of (a) and (b). * (3) To convince yourself that these recursion relations are correct, * it helps to draw the maximum rectangles at #1 and #2. * Then for #1, you try to extend the rectangle down one line, * so that the height is h(1) + 1. Do you get the full * width of #1, w(1)? It depends on where the black pixels are * in the current row. You know the final width is bounded by w(1) * and w(2) + 1, but the actual value depends on the distribution * of black pixels in the current row that are at a distance * from the current pixel that is between these limits. * We call that value "horizdist", and the area is then given * by the expression (a) above. Using similar reasoning for #2, * where you attempt to extend the rectangle to the right * by 1 pixel, you arrive at (b). The largest rectangle is * then found by taking the Max. * </pre> */ l_ok pixFindLargestRectangle(PIX *pixs, l_int32 polarity, BOX **pbox, PIX **ppixdb) { l_int32 i, j, w, h, d, wpls, val; l_int32 wp, hp, w1, w2, h1, h2, wmin, hmin, area1, area2; l_int32 xmax, ymax; /* LR corner of the largest rectangle */ l_int32 maxarea, wmax, hmax, vertdist, horizdist, prevfg; l_int32 *lowestfg; l_uint32 *datas, *lines; l_uint32 **linew, **lineh; BOX *box; PIX *pixw, *pixh; /* keeps the width and height for the largest */ /* rectangles whose LR corner is located there. */ if (ppixdb) *ppixdb = NULL; if (!pbox) return ERROR_INT("&box not defined", __func__, 1); *pbox = NULL; if (!pixs) return ERROR_INT("pixs not defined", __func__, 1); pixGetDimensions(pixs, &w, &h, &d); if (d != 1) return ERROR_INT("pixs not 1 bpp", __func__, 1); if (polarity != 0 && polarity != 1) return ERROR_INT("invalid polarity", __func__, 1); /* Initialize lowest "fg" seen so far for each column */ lowestfg = (l_int32 *)LEPT_CALLOC(w, sizeof(l_int32)); for (i = 0; i < w; i++) lowestfg[i] = -1; /* The combination (val ^ polarity) is the color for which we * are searching for the maximum rectangle. For polarity == 0, * we search in the bg (white). */ pixw = pixCreate(w, h, 32); /* stores width */ pixh = pixCreate(w, h, 32); /* stores height */ linew = (l_uint32 **)pixGetLinePtrs(pixw, NULL); lineh = (l_uint32 **)pixGetLinePtrs(pixh, NULL); datas = pixGetData(pixs); wpls = pixGetWpl(pixs); maxarea = xmax = ymax = wmax = hmax = 0; for (i = 0; i < h; i++) { lines = datas + i * wpls; prevfg = -1; for (j = 0; j < w; j++) { val = GET_DATA_BIT(lines, j); if ((val ^ polarity) == 0) { /* bg (0) if polarity == 0, etc. */ if (i == 0 && j == 0) { wp = hp = 1; } else if (i == 0) { wp = linew[i][j - 1] + 1; hp = 1; } else if (j == 0) { wp = 1; hp = lineh[i - 1][j] + 1; } else { /* Expand #1 prev rectangle down */ w1 = linew[i - 1][j]; h1 = lineh[i - 1][j]; horizdist = j - prevfg; wmin = L_MIN(w1, horizdist); /* width of new rectangle */ area1 = wmin * (h1 + 1); /* Expand #2 prev rectangle to right */ w2 = linew[i][j - 1]; h2 = lineh[i][j - 1]; vertdist = i - lowestfg[j]; hmin = L_MIN(h2, vertdist); /* height of new rectangle */ area2 = hmin * (w2 + 1); if (area1 > area2) { wp = wmin; hp = h1 + 1; } else { wp = w2 + 1; hp = hmin; } } } else { /* fg (1) if polarity == 0; bg (0) if polarity == 1 */ prevfg = j; lowestfg[j] = i; wp = hp = 0; } linew[i][j] = wp; lineh[i][j] = hp; if (wp * hp > maxarea) { maxarea = wp * hp; xmax = j; ymax = i; wmax = wp; hmax = hp; } } } /* Translate from LR corner to Box coords (UL corner, w, h) */ box = boxCreate(xmax - wmax + 1, ymax - hmax + 1, wmax, hmax); *pbox = box; if (ppixdb) { *ppixdb = pixConvertTo8(pixs, TRUE); pixRenderHashBoxArb(*ppixdb, box, 6, 2, L_NEG_SLOPE_LINE, 1, 255, 0, 0); } LEPT_FREE(linew); LEPT_FREE(lineh); LEPT_FREE(lowestfg); pixDestroy(&pixw); pixDestroy(&pixh); return 0; } /*---------------------------------------------------------------------* * Generate rectangle inside connected component * *---------------------------------------------------------------------*/ /*! * \brief pixFindRectangleInCC() * * \param[in] pixs 1 bpp, with sufficient closings to make the fg be * a single c.c. that is a convex hull * \param[in] boxs [optional] if NULL, %pixs should be a minimum * container of a single c.c. * \param[in] fract first and all consecutive lines found must be at * least this fraction of the fast scan dimension * \param[in] dir L_SCAN_HORIZONTAL, L_SCAN_VERTICAL; direction of * fast scan * \param[in] select L_GEOMETRIC_UNION, L_GEOMETRIC_INTERSECTION, * L_LARGEST_AREA, L_SMALEST_AREA * \param[in] debug if 1, generates output pdf showing intermediate * computation and final result * \return box of included rectangle, or NULL on error * * <pre> * Notes: * (1) Computation is similar to pixFindLargestRectangle(), but allows * a different set of results to choose from. * (2) Select the fast scan direction. Then, scanning in the slow * direction, find the longest run of ON pixels in the fast * scan direction and look for the first run that is longer * than %fract of the dimension. Continue until a shorter run * is found. This generates a box of ON pixels fitting into the c.c. * (3) Do this from both slow scan directions and use %select to get * a resulting box from these two. * (4) The extracted rectangle is not necessarily the largest that * can fit in the c.c. To get that, use pixFindLargestRectangle(). */ BOX * pixFindRectangleInCC(PIX *pixs, BOX *boxs, l_float32 fract, l_int32 dir, l_int32 select, l_int32 debug) { l_int32 x, y, i, w, h, w1, h1, w2, h2, found, res; l_int32 xfirst, xlast, xstart, yfirst, ylast, length; BOX *box1, *box2, *box3, *box4, *box5; PIX *pix1, *pix2, *pixdb1, *pixdb2; PIXA *pixadb; if (!pixs || pixGetDepth(pixs) != 1) return (BOX *)ERROR_PTR("pixs undefined or not 1 bpp", __func__, NULL); if (fract <= 0.0 || fract > 1.0) return (BOX *)ERROR_PTR("invalid fraction", __func__, NULL); if (dir != L_SCAN_VERTICAL && dir != L_SCAN_HORIZONTAL) return (BOX *)ERROR_PTR("invalid scan direction", __func__, NULL); if (select != L_GEOMETRIC_UNION && select != L_GEOMETRIC_INTERSECTION && select != L_LARGEST_AREA && select != L_SMALLEST_AREA) return (BOX *)ERROR_PTR("invalid select", __func__, NULL); /* Extract the c.c. if necessary */ x = y = 0; if (boxs) { pix1 = pixClipRectangle(pixs, boxs, NULL); boxGetGeometry(boxs, &x, &y, NULL, NULL); } else { pix1 = pixClone(pixs); } /* All fast scans are horizontal; rotate 90 deg cw if necessary */ if (dir == L_SCAN_VERTICAL) pix2 = pixRotate90(pix1, 1); else /* L_SCAN_HORIZONTAL */ pix2 = pixClone(pix1); pixGetDimensions(pix2, &w, &h, NULL); pixadb = (debug) ? pixaCreate(0) : NULL; pixdb1 = NULL; if (pixadb) { lept_mkdir("lept/rect"); pixaAddPix(pixadb, pix1, L_CLONE); pixdb1 = pixConvertTo32(pix2); } pixDestroy(&pix1); /* Scanning down, find the first scanline with a long enough run. * That run goes from (xfirst, yfirst) to (xlast, yfirst). */ found = FALSE; for (i = 0; i < h; i++) { pixFindMaxHorizontalRunOnLine(pix2, i, &xstart, &length); if (length >= (l_int32)(fract * w + 0.5)) { yfirst = i; xfirst = xstart; xlast = xfirst + length - 1; found = TRUE; break; } } if (!found) { L_WARNING("no run of sufficient size was found\n", __func__); pixDestroy(&pix2); pixDestroy(&pixdb1); pixaDestroy(&pixadb); return NULL; } /* Continue down until the condition fails */ w1 = xlast - xfirst + 1; h1 = h - yfirst; /* init */ ylast = h - 1; /* init */ for (i = yfirst + 1; i < h; i++) { pixFindMaxHorizontalRunOnLine(pix2, i, &xstart, &length); if (xstart > xfirst || (xstart + length - 1 < xlast) || i == h - 1) { ylast = i - 1; h1 = ylast - yfirst + 1; break; } } box1 = boxCreate(xfirst, yfirst, w1, h1); /* Scanning up, find the first scanline with a long enough run. * That run goes from (xfirst, ylast) to (xlast, ylast). */ for (i = h - 1; i >= 0; i--) { pixFindMaxHorizontalRunOnLine(pix2, i, &xstart, &length); if (length >= (l_int32)(fract * w + 0.5)) { ylast = i; xfirst = xstart; xlast = xfirst + length - 1; break; } } /* Continue up until the condition fails */ w2 = xlast - xfirst + 1; h2 = ylast + 1; /* initialize */ for (i = ylast - 1; i >= 0; i--) { pixFindMaxHorizontalRunOnLine(pix2, i, &xstart, &length); if (xstart > xfirst || (xstart + length - 1 < xlast) || i == 0) { yfirst = i + 1; h2 = ylast - yfirst + 1; break; } } box2 = boxCreate(xfirst, yfirst, w2, h2); pixDestroy(&pix2); if (pixadb) { pixRenderBoxArb(pixdb1, box1, 2, 255, 0, 0); pixRenderBoxArb(pixdb1, box2, 2, 0, 255, 0); pixaAddPix(pixadb, pixdb1, L_INSERT); } /* Select the final result from the two boxes */ if (select == L_GEOMETRIC_UNION) box3 = boxBoundingRegion(box1, box2); else if (select == L_GEOMETRIC_INTERSECTION) box3 = boxOverlapRegion(box1, box2); else if (select == L_LARGEST_AREA) box3 = (w1 * h1 >= w2 * h2) ? boxCopy(box1) : boxCopy(box2); else /* select == L_SMALLEST_AREA) */ box3 = (w1 * h1 <= w2 * h2) ? boxCopy(box1) : boxCopy(box2); boxDestroy(&box1); boxDestroy(&box2); /* Rotate the box 90 degrees ccw if necessary */ box4 = NULL; if (box3) { if (dir == L_SCAN_VERTICAL) box4 = boxRotateOrth(box3, w, h, 3); else box4 = boxCopy(box3); } /* Transform back to global coordinates if %boxs exists */ box5 = (box4) ? boxTransform(box4, x, y, 1.0, 1.0) : NULL; boxDestroy(&box3); boxDestroy(&box4); /* Debug output */ if (pixadb) { pixdb1 = pixConvertTo8(pixs, 0); pixAddConstantGray(pixdb1, 190); pixdb2 = pixConvertTo32(pixdb1); if (box5) pixRenderBoxArb(pixdb2, box5, 4, 0, 0, 255); pixaAddPix(pixadb, pixdb2, L_INSERT); res = pixGetXRes(pixs); L_INFO("Writing debug files to /tmp/lept/rect/\n", __func__); pixaConvertToPdf(pixadb, res, 1.0, L_DEFAULT_ENCODE, 75, NULL, "/tmp/lept/rect/fitrect.pdf"); pix1 = pixaDisplayTiledAndScaled(pixadb, 32, 800, 1, 0, 40, 2); pixWrite("/tmp/lept/rect/fitrect.png", pix1, IFF_PNG); pixDestroy(&pix1); pixDestroy(&pixdb1); pixaDestroy(&pixadb); } return box5; } /*------------------------------------------------------------------* * Automatic photoinvert for OCR * *------------------------------------------------------------------*/ /*! * \brief pixAutoPhotoinvert() * * \param[in] pixs any depth, colormap ok * \param[in] thresh binarization threshold; use 0 for default * \param[out] ppixm [optional] image regions to be inverted * \param[out] pixadb [optional] debug; input NULL to skip * \return pixd 1 bpp image to be sent to OCR, or NULL on error * * <pre> * Notes: * (1) A 1 bpp image is returned, where pixels in image regions are * photo-inverted. * (2) If there is light text with a dark background, this will * identify the region and photoinvert the pixels there if * there are at least 60% fg pixels in the region. * (3) For debug output, input a (typically empty) %pixadb. * </pre> */ PIX * pixAutoPhotoinvert(PIX *pixs, l_int32 thresh, PIX **ppixm, PIXA *pixadb) { l_int32 i, n, empty, x, y, w, h; l_float32 fgfract; BOX *box1; BOXA *boxa1; PIX *pix1, *pix2, *pix3, *pix4, *pix5; if (ppixm) *ppixm = NULL; if (!pixs) return (PIX *)ERROR_PTR("pixs not defined", __func__, NULL); if (thresh == 0) thresh = 128; if ((pix1 = pixConvertTo1(pixs, thresh)) == NULL) return (PIX *)ERROR_PTR("pix1 not made", __func__, NULL); if (pixadb) pixaAddPix(pixadb, pix1, L_COPY); /* Identify regions for photo-inversion: * (1) Start with the halftone mask. * (2) Eliminate ordinary text and halftones in the mask. * (3) Some regions of inverted text may have been removed in * steps (1) and (2). Conditionally fill holes in the mask, * but do not fill out to the bounding rect. */ pix2 = pixGenerateHalftoneMask(pix1, NULL, NULL, pixadb); pix3 = pixMorphSequence(pix2, "o15.15 + c25.25", 0); /* remove noise */ pix4 = pixFillHolesToBoundingRect(pix3, 1, 0.5, 1.0); if (pixadb) { pixaAddPix(pixadb, pix2, L_CLONE); pixaAddPix(pixadb, pix3, L_CLONE); pixaAddPix(pixadb, pix4, L_COPY); } pixDestroy(&pix2); pixDestroy(&pix3); pixZero(pix4, &empty); if (empty) { pixDestroy(&pix4); return pix1; } /* Examine each component and validate the inversion. * Require at least 60% of pixels under each component to be FG. */ boxa1 = pixConnCompBB(pix4, 8); n = boxaGetCount(boxa1); for (i = 0; i < n; i++) { box1 = boxaGetBox(boxa1, i, L_COPY); pix5 = pixClipRectangle(pix1, box1, NULL); pixForegroundFraction(pix5, &fgfract); if (pixadb) lept_stderr("fg fraction: %5.3f\n", fgfract); boxGetGeometry(box1, &x, &y, &w, &h); if (fgfract < 0.6) /* erase from the mask */ pixRasterop(pix4, x, y, w, h, PIX_CLR, NULL, 0, 0); pixDestroy(&pix5); boxDestroy(&box1); } boxaDestroy(&boxa1); pixZero(pix4, &empty); if (empty) { pixDestroy(&pix4); return pix1; } /* Combine pixels of the photo-inverted pix with the binarized input */ pix5 = pixInvert(NULL, pix1); pixCombineMasked(pix1, pix5, pix4); if (pixadb) { pixaAddPix(pixadb, pix5, L_CLONE); pixaAddPix(pixadb, pix1, L_COPY); } pixDestroy(&pix5); if (ppixm) *ppixm = pix4; else pixDestroy(&pix4); return pix1; }