thresholder.h

Go to the documentation of this file.

 
// File:        thresholder.h
// Description: Base API for thresholding images in tesseract.
// Author:      Ray Smith
//
// (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_CCMAIN_THRESHOLDER_H_
#define TESSERACT_CCMAIN_THRESHOLDER_H_
 
#include <tesseract/export.h>
 
#include <vector> // for std::vector
 
struct Pix;
 
namespace tesseract {
 
enum class ThresholdMethod {
  Otsu,          // Tesseract's legacy Otsu
  LeptonicaOtsu, // Leptonica's Otsu
  Sauvola,       // Leptonica's Sauvola
  Max,           // Number of Thresholding methods
};
 
class TessBaseAPI;
 
class TESS_API ImageThresholder {
public:
  ImageThresholder();
  virtual ~ImageThresholder();
 
  virtual void Clear();
 
  bool IsEmpty() const;
 
  void SetImage(const unsigned char *imagedata, int width, int height, int bytes_per_pixel,
                int bytes_per_line);
 
  void SetRectangle(int left, int top, int width, int height);
 
  virtual void GetImageSizes(int *left, int *top, int *width, int *height, int *imagewidth,
                             int *imageheight);
 
  bool IsColor() const {
    return pix_channels_ >= 3;
  }
 
  bool IsBinary() const {
    return pix_channels_ == 0;
  }
 
  int GetScaleFactor() const {
    return scale_;
  }
 
  // Set the resolution of the source image in pixels per inch.
  // This should be called right after SetImage(), and will let us return
  // appropriate font sizes for the text.
  void SetSourceYResolution(int ppi) {
    yres_ = ppi;
    estimated_res_ = ppi;
  }
  int GetSourceYResolution() const {
    return yres_;
  }
  int GetScaledYResolution() const {
    return scale_ * yres_;
  }
  // Set the resolution of the source image in pixels per inch, as estimated
  // by the thresholder from the text size found during thresholding.
  // This value will be used to set internal size thresholds during recognition
  // and will not influence the output "point size." The default value is
  // the same as the source resolution. (yres_)
  void SetEstimatedResolution(int ppi) {
    estimated_res_ = ppi;
  }
  // Returns the estimated resolution, including any active scaling.
  // This value will be used to set internal size thresholds during recognition.
  int GetScaledEstimatedResolution() const {
    return scale_ * estimated_res_;
  }
 
  void SetImage(const Image pix);
 
  virtual bool ThresholdToPix(Image *pix);
 
  virtual std::tuple<bool, Image, Image, Image> Threshold(TessBaseAPI *api,
                                                          ThresholdMethod method);
 
  // Gets a pix that contains an 8 bit threshold value at each pixel. The
  // returned pix may be an integer reduction of the binary image such that
  // the scale factor may be inferred from the ratio of the sizes, even down
  // to the extreme of a 1x1 pixel thresholds image.
  // Ideally the 8 bit threshold should be the exact threshold used to generate
  // the binary image in ThresholdToPix, but this is not a hard constraint.
  // Returns nullptr if the input is binary. PixDestroy after use.
  virtual Image GetPixRectThresholds();
 
  Image GetPixRect();
 
  // Get a clone/copy of the source image rectangle, reduced to greyscale,
  // and at the same resolution as the output binary.
  // The returned Pix must be pixDestroyed.
  // Provided to the classifier to extract features from the greyscale image.
  virtual Image GetPixRectGrey();
 
protected:
  // ----------------------------------------------------------------------
  // Utility functions that may be useful components for other thresholders.
 
  virtual void Init();
 
  bool IsFullImage() const {
    return rect_left_ == 0 && rect_top_ == 0 && rect_width_ == image_width_ &&
           rect_height_ == image_height_;
  }
 
  // Otsu thresholds the rectangle, taking the rectangle from *this.
  void OtsuThresholdRectToPix(Image src_pix, Image *out_pix) const;
 
  // arrays and also the bytes per pixel in src_pix.
  void ThresholdRectToPix(Image src_pix, int num_channels, const std::vector<int> &thresholds,
                          const std::vector <int> &hi_values, Image *pix) const;
 
protected:
  Image pix_;
 
  int image_width_;  
  int image_height_; 
  int pix_channels_; 
  int pix_wpl_;      
  // Limits of image rectangle to be processed.
  int scale_;         
  int yres_;          
  int estimated_res_; 
  int rect_left_;
  int rect_top_;
  int rect_width_;
  int rect_height_;
};
 
} // namespace tesseract.
 
#endif // TESSERACT_CCMAIN_THRESHOLDER_H_