Postfix for #3418.

include/tesseract/publictypes.h

@@ -278,15 +278,16 @@ enum OcrEngineMode {
   OEM_COUNT                    // Number of OEMs
 };
 
-/** 
+/**
  * Except when Otsu is chosen
- * Leptonica is used for thresholding 
+ * Leptonica is used for thresholding
  */
-enum class ThreshMethod {
+enum class ThresholdMethod {
   Otsu,         // Legacy Tesseract's Otsu thresholding
   AdaptiveOtsu,
   TiledSauvola,
-  Count,        // Number of Thresholding methods
+
+  Max,        // Number of Thresholding methods
 };
 
 } // namespace tesseract.

src/api/baseapi.cpp

@@ -2113,14 +2113,14 @@ bool TessBaseAPI::Threshold(Pix **pix) {
   Image pix_grey;
   Image pix_thresholds;
 
-  auto thresholding_method = static_cast<ThreshMethod>(static_cast<int>(tesseract_->thresholding_method));
+  auto thresholding_method = static_cast<ThresholdMethod>(static_cast<int>(tesseract_->thresholding_method));
 
-  if (thresholding_method == ThreshMethod::Otsu) {
+  if (thresholding_method == ThresholdMethod::Otsu) {
     if (!thresholder_->ThresholdToPix(pageseg_mode, &pix_binary)) {
       return false;
     }
     *pix = pix_binary;
-  
+
     if (!thresholder_->IsBinary()) {
       tesseract_->set_pix_thresholds(thresholder_->GetPixRectThresholds());
       tesseract_->set_pix_grey(thresholder_->GetPixRectGrey());
@@ -2137,12 +2137,12 @@ bool TessBaseAPI::Threshold(Pix **pix) {
     *pix = pix_binary;
 
     tesseract_->set_pix_thresholds(pix_thresholds);
-    tesseract_->set_pix_grey(pix_grey); 
-  } 
-   
+    tesseract_->set_pix_grey(pix_grey);
+  }
+
   thresholder_->GetImageSizes(&rect_left_, &rect_top_, &rect_width_, &rect_height_, &image_width_,
                               &image_height_);
-  
+
   // Set the internal resolution that is used for layout parameters from the
   // estimated resolution, rather than the image resolution, which may be
   // fabricated, but we will use the image resolution, if there is one, to

src/ccmain/tesseractclass.cpp

@@ -75,8 +75,8 @@ Tesseract::Tesseract()
                " (Values from PageSegMode enum in tesseract/publictypes.h)",
                this->params())
     , INT_MEMBER(thresholding_method,
-                 static_cast<int>(tesseract::ThreshMethod::Otsu),                
-"Thresholding "
+                 static_cast<int>(tesseract::ThresholdMethod::Otsu),
+                 "Thresholding "
                  "method: 0 = Otsu, 1 = Adaptive Otsu, 2 = Sauvola",
                  this->params())
     , INT_INIT_MEMBER(tessedit_ocr_engine_mode, tesseract::OEM_DEFAULT,

src/ccmain/thresholder.cpp

@@ -16,12 +16,6 @@
 //
 ///////////////////////////////////////////////////////////////////////
 
-#include <allheaders.h>
-
-#include <cstdint> // for uint32_t
-#include <cstring>
-#include <tuple>
-
 #include "otsuthr.h"
 #include "thresholder.h"
 #include "tprintf.h" // for tprintf
@@ -30,6 +24,12 @@
 #  include "openclwrapper.h" // for OpenclDevice
 #endif
 
+#include <allheaders.h>
+
+#include <cstdint> // for uint32_t
+#include <cstring>
+#include <tuple>
+
 namespace tesseract {
 
 ImageThresholder::ImageThresholder()
@@ -186,7 +186,7 @@ void ImageThresholder::SetImage(const Image pix) {
 }
 
 std::tuple<bool, Image, Image, Image> ImageThresholder::Threshold(
-                                                         ThreshMethod method) {
+                                                         ThresholdMethod method) {
   Image pix_grey = nullptr;
   Image pix_binary = nullptr;
   Image pix_thresholds = nullptr;
@@ -195,7 +195,7 @@ std::tuple<bool, Image, Image, Image> ImageThresholder::Threshold(
     tprintf("Image too large: (%d, %d)\n", image_width_, image_height_);
     return std::make_tuple(false, nullptr, nullptr, nullptr);
   }
-  
+
   if (pix_channels_ == 0) {
     // We have a binary image, but it still has to be copied, as this API
     // allows the caller to modify the output.
@@ -207,19 +207,19 @@ std::tuple<bool, Image, Image, Image> ImageThresholder::Threshold(
 
   pix_grey = GetPixRectGrey();
 
-  if (method == ThreshMethod::Otsu || method >= ThreshMethod::Count) {
-    method = ThreshMethod::AdaptiveOtsu;
+  if (method == ThresholdMethod::Otsu || method >= ThresholdMethod::Max) {
+    method = ThresholdMethod::AdaptiveOtsu;
   }
 
   int r;
-  if (method == ThreshMethod::AdaptiveOtsu) {
-    r = pixOtsuAdaptiveThreshold(pix_grey, 300, 300, 0, 0, 0.1, 
-                                 pix_thresholds.a(), pix_binary.a());
-  } else if (method == ThreshMethod::TiledSauvola) {
-    r = pixSauvolaBinarizeTiled(pix_grey, 25, 0.40, 300, 300, pix_thresholds.a(), 
-                                pix_binary.a());
+  if (method == ThresholdMethod::AdaptiveOtsu) {
+    r = pixOtsuAdaptiveThreshold(pix_grey, 300, 300, 0, 0, 0.1,
+                                 pix_thresholds, pix_binary);
+  } else if (method == ThresholdMethod::TiledSauvola) {
+    r = pixSauvolaBinarizeTiled(pix_grey, 25, 0.40, 300, 300, pix_thresholds,
+                                pix_binary);
   }
-  
+
   bool ok = r == 0 ? true : false;
   return std::make_tuple(ok, pix_grey, pix_binary, pix_thresholds);
 }

src/ccmain/thresholder.h

@@ -122,7 +122,7 @@ public:
   virtual bool ThresholdToPix(PageSegMode pageseg_mode, Image *pix);
 
   virtual std::tuple<bool, Image, Image, Image> Threshold(
-                                                          ThreshMethod method);
+                                                          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

src/ccstruct/image.h

@@ -31,11 +31,12 @@ public:
   Image(Pix *pix) : pix_(pix) {}
 
   // service
+  bool operator==(decltype(nullptr)) const { return pix_ == nullptr; }
+  bool operator!=(decltype(nullptr)) const { return pix_ != nullptr; }
+  explicit operator bool() const { return pix_ != nullptr; }
   operator Pix *() const { return pix_; }
-  explicit operator Pix **() { return &pix_; }
+  operator Pix **() { return &pix_; }
   Pix *operator->() const { return pix_; }
-  Pix **a() { return &pix_; }
-
 
   // api
   Image clone() const; // increases refcount