mirror of
https://github.com/tesseract-ocr/tesseract.git
synced 2024-12-19 11:58:15 +08:00
09e41d32c2
git-svn-id: https://tesseract-ocr.googlecode.com/svn/trunk@663 d0cd1f9f-072b-0410-8dd7-cf729c803f20
160 lines
7.8 KiB
C++
160 lines
7.8 KiB
C++
///////////////////////////////////////////////////////////////////////
|
|
// File: imagefind.h
|
|
// Description: Class to find image and drawing regions in an image
|
|
// and create a corresponding list of empty blobs.
|
|
// Author: Ray Smith
|
|
// Created: Fri Aug 01 10:50:01 PDT 2008
|
|
//
|
|
// (C) Copyright 2008, Google Inc.
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef TESSERACT_TEXTORD_IMAGEFIND_H__
|
|
#define TESSERACT_TEXTORD_IMAGEFIND_H__
|
|
|
|
#include "host.h"
|
|
|
|
struct Boxa;
|
|
struct Pix;
|
|
struct Pixa;
|
|
class TBOX;
|
|
class FCOORD;
|
|
class TO_BLOCK;
|
|
class BLOBNBOX_LIST;
|
|
|
|
namespace tesseract {
|
|
|
|
class ColPartitionGrid;
|
|
class ColPartition_LIST;
|
|
class TabFind;
|
|
|
|
// The ImageFind class is a simple static function wrapper class that
|
|
// exposes the FindImages function and some useful helper functions.
|
|
class ImageFind {
|
|
public:
|
|
// Finds image regions within the BINARY source pix (page image) and returns
|
|
// the image regions as a mask image.
|
|
// The returned pix may be NULL, meaning no images found.
|
|
// If not NULL, it must be PixDestroyed by the caller.
|
|
static Pix* FindImages(Pix* pix);
|
|
|
|
// Generates a Boxa, Pixa pair from the input binary (image mask) pix,
|
|
// analgous to pixConnComp, except that connected components which are nearly
|
|
// rectangular are replaced with solid rectangles.
|
|
// The returned boxa, pixa may be NULL, meaning no images found.
|
|
// If not NULL, they must be destroyed by the caller.
|
|
// Resolution of pix should match the source image (Tesseract::pix_binary_)
|
|
// so the output coordinate systems match.
|
|
static void ConnCompAndRectangularize(Pix* pix, Boxa** boxa, Pixa** pixa);
|
|
|
|
// Returns true if there is a rectangle in the source pix, such that all
|
|
// pixel rows and column slices outside of it have less than
|
|
// min_fraction of the pixels black, and within max_skew_gradient fraction
|
|
// of the pixels on the inside, there are at least max_fraction of the
|
|
// pixels black. In other words, the inside of the rectangle looks roughly
|
|
// rectangular, and the outside of it looks like extra bits.
|
|
// On return, the rectangle is defined by x_start, y_start, x_end and y_end.
|
|
// Note: the algorithm is iterative, allowing it to slice off pixels from
|
|
// one edge, allowing it to then slice off more pixels from another edge.
|
|
static bool pixNearlyRectangular(Pix* pix,
|
|
double min_fraction, double max_fraction,
|
|
double max_skew_gradient,
|
|
int* x_start, int* y_start,
|
|
int* x_end, int* y_end);
|
|
|
|
// Given an input pix, and a bounding rectangle, the sides of the rectangle
|
|
// are shrunk inwards until they bound any black pixels found within the
|
|
// original rectangle. Returns false if the rectangle contains no black
|
|
// pixels at all.
|
|
static bool BoundsWithinRect(Pix* pix, int* x_start, int* y_start,
|
|
int* x_end, int* y_end);
|
|
|
|
// Given a point in 3-D (RGB) space, returns the squared Euclidean distance
|
|
// of the point from the given line, defined by a pair of points in the 3-D
|
|
// (RGB) space, line1 and line2.
|
|
static double ColorDistanceFromLine(const uinT8* line1, const uinT8* line2,
|
|
const uinT8* point);
|
|
|
|
// Returns the leptonica combined code for the given RGB triplet.
|
|
static uinT32 ComposeRGB(uinT32 r, uinT32 g, uinT32 b);
|
|
|
|
// Returns the input value clipped to a uinT8.
|
|
static uinT8 ClipToByte(double pixel);
|
|
|
|
// Computes the light and dark extremes of color in the given rectangle of
|
|
// the given pix, which is factor smaller than the coordinate system in rect.
|
|
// The light and dark points are taken to be the upper and lower 8th-ile of
|
|
// the most deviant of R, G and B. The value of the other 2 channels are
|
|
// computed by linear fit against the most deviant.
|
|
// The colors of the two point are returned in color1 and color2, with the
|
|
// alpha channel set to a scaled mean rms of the fits.
|
|
// If color_map1 is not null then it and color_map2 get rect pasted in them
|
|
// with the two calculated colors, and rms map gets a pasted rect of the rms.
|
|
// color_map1, color_map2 and rms_map are assumed to be the same scale as pix.
|
|
static void ComputeRectangleColors(const TBOX& rect, Pix* pix, int factor,
|
|
Pix* color_map1, Pix* color_map2,
|
|
Pix* rms_map,
|
|
uinT8* color1, uinT8* color2);
|
|
|
|
// Returns true if there are no black pixels in between the boxes.
|
|
// The im_box must represent the bounding box of the pix in tesseract
|
|
// coordinates, which may be negative, due to rotations to make the textlines
|
|
// horizontal. The boxes are rotated by rotation, which should undo such
|
|
// rotations, before mapping them onto the pix.
|
|
static bool BlankImageInBetween(const TBOX& box1, const TBOX& box2,
|
|
const TBOX& im_box, const FCOORD& rotation,
|
|
Pix* pix);
|
|
|
|
// Returns the number of pixels in box in the pix.
|
|
// The im_box must represent the bounding box of the pix in tesseract
|
|
// coordinates, which may be negative, due to rotations to make the textlines
|
|
// horizontal. The boxes are rotated by rotation, which should undo such
|
|
// rotations, before mapping them onto the pix.
|
|
static int CountPixelsInRotatedBox(TBOX box, const TBOX& im_box,
|
|
const FCOORD& rotation, Pix* pix);
|
|
|
|
|
|
// Locates all the image partitions in the part_grid, that were found by a
|
|
// previous call to FindImagePartitions, marks them in the image_mask,
|
|
// removes them from the grid, and deletes them. This makes it possble to
|
|
// call FindImagePartitions again to produce less broken-up and less
|
|
// overlapping image partitions.
|
|
// rerotation specifies how to rotate the partition coords to match
|
|
// the image_mask, since this function is used after orientation correction.
|
|
static void TransferImagePartsToImageMask(const FCOORD& rerotation,
|
|
ColPartitionGrid* part_grid,
|
|
Pix* image_mask);
|
|
|
|
// Runs a CC analysis on the image_pix mask image, and creates
|
|
// image partitions from them, cutting out strong text, and merging with
|
|
// nearby image regions such that they don't interfere with text.
|
|
// Rotation and rerotation specify how to rotate image coords to match
|
|
// the blob and partition coords and back again.
|
|
// The input/output part_grid owns all the created partitions, and
|
|
// the partitions own all the fake blobs that belong in the partitions.
|
|
// Since the other blobs in the other partitions will be owned by the block,
|
|
// ColPartitionGrid::ReTypeBlobs must be called afterwards to fix this
|
|
// situation and collect the image blobs.
|
|
static void FindImagePartitions(Pix* image_pix,
|
|
const FCOORD& rotation,
|
|
const FCOORD& rerotation,
|
|
TO_BLOCK* block,
|
|
TabFind* tab_grid,
|
|
ColPartitionGrid* part_grid,
|
|
ColPartition_LIST* big_parts);
|
|
};
|
|
|
|
} // namespace tesseract.
|
|
|
|
#endif // TESSERACT_TEXTORD_LINEFIND_H__
|
|
|