node-native-win-utils 1.3.3 → 1.4.0

package/include/tesseract/ltrresultiterator.h

@@ -0,0 +1,235 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        ltrresultiterator.h
+// Description: Iterator for tesseract results in strict left-to-right
+//              order that avoids using tesseract internal data structures.
+// Author:      Ray Smith
+//
+// (C) Copyright 2010, 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_LTR_RESULT_ITERATOR_H_
+#define TESSERACT_CCMAIN_LTR_RESULT_ITERATOR_H_
+
+#include "export.h"       // for TESS_API
+#include "pageiterator.h" // for PageIterator
+#include "publictypes.h"  // for PageIteratorLevel
+#include "unichar.h"      // for StrongScriptDirection
+
+namespace tesseract {
+
+class BLOB_CHOICE_IT;
+class PAGE_RES;
+class WERD_RES;
+
+class Tesseract;
+
+// Class to iterate over tesseract results, providing access to all levels
+// of the page hierarchy, without including any tesseract headers or having
+// to handle any tesseract structures.
+// WARNING! This class points to data held within the TessBaseAPI class, and
+// therefore can only be used while the TessBaseAPI class still exists and
+// has not been subjected to a call of Init, SetImage, Recognize, Clear, End
+// DetectOS, or anything else that changes the internal PAGE_RES.
+// See tesseract/publictypes.h for the definition of PageIteratorLevel.
+// See also base class PageIterator, which contains the bulk of the interface.
+// LTRResultIterator adds text-specific methods for access to OCR output.
+
+class TESS_API LTRResultIterator : public PageIterator {
+  friend class ChoiceIterator;
+
+public:
+  // page_res and tesseract come directly from the BaseAPI.
+  // The rectangle parameters are copied indirectly from the Thresholder,
+  // via the BaseAPI. They represent the coordinates of some rectangle in an
+  // original image (in top-left-origin coordinates) and therefore the top-left
+  // needs to be added to any output boxes in order to specify coordinates
+  // in the original image. See TessBaseAPI::SetRectangle.
+  // The scale and scaled_yres are in case the Thresholder scaled the image
+  // rectangle prior to thresholding. Any coordinates in tesseract's image
+  // must be divided by scale before adding (rect_left, rect_top).
+  // The scaled_yres indicates the effective resolution of the binary image
+  // that tesseract has been given by the Thresholder.
+  // After the constructor, Begin has already been called.
+  LTRResultIterator(PAGE_RES *page_res, Tesseract *tesseract, int scale,
+                    int scaled_yres, int rect_left, int rect_top,
+                    int rect_width, int rect_height);
+
+  ~LTRResultIterator() override;
+
+  // LTRResultIterators may be copied! This makes it possible to iterate over
+  // all the objects at a lower level, while maintaining an iterator to
+  // objects at a higher level. These constructors DO NOT CALL Begin, so
+  // iterations will continue from the location of src.
+  // TODO: For now the copy constructor and operator= only need the base class
+  // versions, but if new data members are added, don't forget to add them!
+
+  // ============= Moving around within the page ============.
+
+  // See PageIterator.
+
+  // ============= Accessing data ==============.
+
+  // Returns the null terminated UTF-8 encoded text string for the current
+  // object at the given level. Use delete [] to free after use.
+  char *GetUTF8Text(PageIteratorLevel level) const;
+
+  // Set the string inserted at the end of each text line. "\n" by default.
+  void SetLineSeparator(const char *new_line);
+
+  // Set the string inserted at the end of each paragraph. "\n" by default.
+  void SetParagraphSeparator(const char *new_para);
+
+  // Returns the mean confidence of the current object at the given level.
+  // The number should be interpreted as a percent probability. (0.0f-100.0f)
+  float Confidence(PageIteratorLevel level) const;
+
+  // ============= Functions that refer to words only ============.
+
+  // Returns the font attributes of the current word. If iterating at a higher
+  // level object than words, eg textlines, then this will return the
+  // attributes of the first word in that textline.
+  // The actual return value is a string representing a font name. It points
+  // to an internal table and SHOULD NOT BE DELETED. Lifespan is the same as
+  // the iterator itself, ie rendered invalid by various members of
+  // TessBaseAPI, including Init, SetImage, End or deleting the TessBaseAPI.
+  // Pointsize is returned in printers points (1/72 inch.)
+  const char *WordFontAttributes(bool *is_bold, bool *is_italic,
+                                 bool *is_underlined, bool *is_monospace,
+                                 bool *is_serif, bool *is_smallcaps,
+                                 int *pointsize, int *font_id) const;
+
+  // Return the name of the language used to recognize this word.
+  // On error, nullptr.  Do not delete this pointer.
+  const char *WordRecognitionLanguage() const;
+
+  // Return the overall directionality of this word.
+  StrongScriptDirection WordDirection() const;
+
+  // Returns true if the current word was found in a dictionary.
+  bool WordIsFromDictionary() const;
+
+  // Returns the number of blanks before the current word.
+  int BlanksBeforeWord() const;
+
+  // Returns true if the current word is numeric.
+  bool WordIsNumeric() const;
+
+  // Returns true if the word contains blamer information.
+  bool HasBlamerInfo() const;
+
+  // Returns the pointer to ParamsTrainingBundle stored in the BlamerBundle
+  // of the current word.
+  const void *GetParamsTrainingBundle() const;
+
+  // Returns a pointer to the string with blamer information for this word.
+  // Assumes that the word's blamer_bundle is not nullptr.
+  const char *GetBlamerDebug() const;
+
+  // Returns a pointer to the string with misadaption information for this word.
+  // Assumes that the word's blamer_bundle is not nullptr.
+  const char *GetBlamerMisadaptionDebug() const;
+
+  // Returns true if a truth string was recorded for the current word.
+  bool HasTruthString() const;
+
+  // Returns true if the given string is equivalent to the truth string for
+  // the current word.
+  bool EquivalentToTruth(const char *str) const;
+
+  // Returns a null terminated UTF-8 encoded truth string for the current word.
+  // Use delete [] to free after use.
+  char *WordTruthUTF8Text() const;
+
+  // Returns a null terminated UTF-8 encoded normalized OCR string for the
+  // current word. Use delete [] to free after use.
+  char *WordNormedUTF8Text() const;
+
+  // Returns a pointer to serialized choice lattice.
+  // Fills lattice_size with the number of bytes in lattice data.
+  const char *WordLattice(int *lattice_size) const;
+
+  // ============= Functions that refer to symbols only ============.
+
+  // Returns true if the current symbol is a superscript.
+  // If iterating at a higher level object than symbols, eg words, then
+  // this will return the attributes of the first symbol in that word.
+  bool SymbolIsSuperscript() const;
+  // Returns true if the current symbol is a subscript.
+  // If iterating at a higher level object than symbols, eg words, then
+  // this will return the attributes of the first symbol in that word.
+  bool SymbolIsSubscript() const;
+  // Returns true if the current symbol is a dropcap.
+  // If iterating at a higher level object than symbols, eg words, then
+  // this will return the attributes of the first symbol in that word.
+  bool SymbolIsDropcap() const;
+
+protected:
+  const char *line_separator_;
+  const char *paragraph_separator_;
+};
+
+// Class to iterate over the classifier choices for a single RIL_SYMBOL.
+class TESS_API ChoiceIterator {
+public:
+  // Construction is from a LTRResultIterator that points to the symbol of
+  // interest. The ChoiceIterator allows a one-shot iteration over the
+  // choices for this symbol and after that it is useless.
+  explicit ChoiceIterator(const LTRResultIterator &result_it);
+  ~ChoiceIterator();
+
+  // Moves to the next choice for the symbol and returns false if there
+  // are none left.
+  bool Next();
+
+  // ============= Accessing data ==============.
+
+  // Returns the null terminated UTF-8 encoded text string for the current
+  // choice.
+  // NOTE: Unlike LTRResultIterator::GetUTF8Text, the return points to an
+  // internal structure and should NOT be delete[]ed to free after use.
+  const char *GetUTF8Text() const;
+
+  // Returns the confidence of the current choice depending on the used language
+  // data. If only LSTM traineddata is used the value range is 0.0f - 1.0f. All
+  // choices for one symbol should roughly add up to 1.0f.
+  // If only traineddata of the legacy engine is used, the number should be
+  // interpreted as a percent probability. (0.0f-100.0f) In this case
+  // probabilities won't add up to 100. Each one stands on its own.
+  float Confidence() const;
+
+  // Returns a vector containing all timesteps, which belong to the currently
+  // selected symbol. A timestep is a vector containing pairs of symbols and
+  // floating point numbers. The number states the probability for the
+  // corresponding symbol.
+  std::vector<std::vector<std::pair<const char *, float>>> *Timesteps() const;
+
+private:
+  // clears the remaining spaces out of the results and adapt the probabilities
+  void filterSpaces();
+  // Pointer to the WERD_RES object owned by the API.
+  WERD_RES *word_res_;
+  // Iterator over the blob choices.
+  BLOB_CHOICE_IT *choice_it_;
+  std::vector<std::pair<const char *, float>> *LSTM_choices_ = nullptr;
+  std::vector<std::pair<const char *, float>>::iterator LSTM_choice_it_;
+
+  const int *tstep_index_;
+  // regulates the rating granularity
+  double rating_coefficient_;
+  // leading blanks
+  int blanks_before_word_;
+  // true when there is lstm engine related trained data
+  bool oemLSTM_;
+};
+
+} // namespace tesseract.
+
+#endif // TESSERACT_CCMAIN_LTR_RESULT_ITERATOR_H_

package/include/tesseract/ocrclass.h

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: Apache-2.0
+/**********************************************************************
+ * File:        ocrclass.h
+ * Description: Class definitions and constants for the OCR API.
+ * Author:      Hewlett-Packard Co
+ *
+ * (C) Copyright 1996, Hewlett-Packard Co.
+ ** 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.
+ *
+ **********************************************************************/
+
+/**********************************************************************
+ * This file contains typedefs for all the structures used by
+ * the HP OCR interface.
+ * The structures are designed to allow them to be used with any
+ * structure alignment up to 8.
+ **********************************************************************/
+
+#ifndef CCUTIL_OCRCLASS_H_
+#define CCUTIL_OCRCLASS_H_
+
+#include <chrono>
+#include <ctime>
+
+namespace tesseract {
+
+/**********************************************************************
+ * EANYCODE_CHAR
+ * Description of a single character. The character code is defined by
+ * the character set of the current font.
+ * Output text is sent as an array of these structures.
+ * Spaces and line endings in the output are represented in the
+ * structures of the surrounding characters. They are not directly
+ * represented as characters.
+ * The first character in a word has a positive value of blanks.
+ * Missing information should be set to the defaults in the comments.
+ * If word bounds are known, but not character bounds, then the top and
+ * bottom of each character should be those of the word. The left of the
+ * first and right of the last char in each word should be set. All other
+ * lefts and rights should be set to -1.
+ * If set, the values of right and bottom are left+width and top+height.
+ * Most of the members come directly from the parameters to ocr_append_char.
+ * The formatting member uses the enhancement parameter and combines the
+ * line direction stuff into the top 3 bits.
+ * The coding is 0=RL char, 1=LR char, 2=DR NL, 3=UL NL, 4=DR Para,
+ * 5=UL Para, 6=TB char, 7=BT char. API users do not need to know what
+ * the coding is, only that it is backwards compatible with the previous
+ * version.
+ **********************************************************************/
+
+struct EANYCODE_CHAR { /*single character */
+  // It should be noted that the format for char_code for version 2.0 and beyond
+  // is UTF8 which means that ASCII characters will come out as one structure
+  // but other characters will be returned in two or more instances of this
+  // structure with a single byte of the  UTF8 code in each, but each will have
+  // the same bounding box. Programs which want to handle languages with
+  // different characters sets will need to handle extended characters
+  // appropriately, but *all* code needs to be prepared to receive UTF8 coded
+  // characters for characters such as bullet and fancy quotes.
+  uint16_t char_code; /*character itself */
+  int16_t left;       /*of char (-1) */
+  int16_t right;      /*of char (-1) */
+  int16_t top;        /*of char (-1) */
+  int16_t bottom;     /*of char (-1) */
+  int16_t font_index; /*what font (0) */
+  uint8_t confidence; /*0=perfect, 100=reject (0/100) */
+  uint8_t point_size; /*of char, 72=i inch, (10) */
+  int8_t blanks;      /*no of spaces before this char (1) */
+  uint8_t formatting; /*char formatting (0) */
+};
+
+/**********************************************************************
+ * ETEXT_DESC
+ * Description of the output of the OCR engine.
+ * This structure is used as both a progress monitor and the final
+ * output header, since it needs to be a valid progress monitor while
+ * the OCR engine is storing its output to shared memory.
+ * During progress, all the buffer info is -1.
+ * Progress starts at 0 and increases to 100 during OCR. No other constraint.
+ * Additionally the progress callback contains the bounding box of the word that
+ * is currently being processed.
+ * Every progress callback, the OCR engine must set ocr_alive to 1.
+ * The HP side will set ocr_alive to 0. Repeated failure to reset
+ * to 1 indicates that the OCR engine is dead.
+ * If the cancel function is not null then it is called with the number of
+ * user words found. If it returns true then operation is cancelled.
+ **********************************************************************/
+class ETEXT_DESC;
+
+using CANCEL_FUNC = bool (*)(void *, int);
+using PROGRESS_FUNC = bool (*)(int, int, int, int, int);
+using PROGRESS_FUNC2 = bool (*)(ETEXT_DESC *, int, int, int, int);
+
+class ETEXT_DESC { // output header
+public:
+  int16_t count{0};    /// chars in this buffer(0)
+  int16_t progress{0}; /// percent complete increasing (0-100)
+  /** Progress monitor covers word recognition and it does not cover layout
+   * analysis.
+   * See Ray comment in https://github.com/tesseract-ocr/tesseract/pull/27 */
+  int8_t more_to_come{0};       /// true if not last
+  volatile int8_t ocr_alive{0}; /// ocr sets to 1, HP 0
+  int8_t err_code{0};           /// for errcode use
+  CANCEL_FUNC cancel{nullptr};  /// returns true to cancel
+  PROGRESS_FUNC progress_callback{
+      nullptr};                      /// called whenever progress increases
+  PROGRESS_FUNC2 progress_callback2; /// monitor-aware progress callback
+  void *cancel_this{nullptr};        /// this or other data for cancel
+  std::chrono::steady_clock::time_point end_time;
+  /// Time to stop. Expected to be set only
+  /// by call to set_deadline_msecs().
+  EANYCODE_CHAR text[1]{}; /// character data
+
+  ETEXT_DESC() : progress_callback2(&default_progress_func) {
+    end_time = std::chrono::time_point<std::chrono::steady_clock,
+                                       std::chrono::milliseconds>();
+  }
+
+  // Sets the end time to be deadline_msecs milliseconds from now.
+  void set_deadline_msecs(int32_t deadline_msecs) {
+    if (deadline_msecs > 0) {
+      end_time = std::chrono::steady_clock::now() +
+                 std::chrono::milliseconds(deadline_msecs);
+    }
+  }
+
+  // Returns false if we've not passed the end_time, or have not set a deadline.
+  bool deadline_exceeded() const {
+    if (end_time.time_since_epoch() ==
+        std::chrono::steady_clock::duration::zero()) {
+      return false;
+    }
+    auto now = std::chrono::steady_clock::now();
+    return (now > end_time);
+  }
+
+private:
+  static bool default_progress_func(ETEXT_DESC *ths, int left, int right,
+                                    int top, int bottom) {
+    if (ths->progress_callback != nullptr) {
+      return (*(ths->progress_callback))(ths->progress, left, right, top,
+                                         bottom);
+    }
+    return true;
+  }
+};
+
+} // namespace tesseract
+
+#endif // CCUTIL_OCRCLASS_H_

package/include/tesseract/osdetect.h

@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: Apache-2.0
+// File:        osdetect.h
+// Description: Orientation and script detection.
+// Author:      Samuel Charron
+//              Ranjith Unnikrishnan
+//
+// (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_OSDETECT_H_
+#define TESSERACT_CCMAIN_OSDETECT_H_
+
+#include "export.h" // for TESS_API
+
+#include <vector> // for std::vector
+
+namespace tesseract {
+
+class BLOBNBOX;
+class BLOBNBOX_CLIST;
+class BLOB_CHOICE_LIST;
+class TO_BLOCK_LIST;
+class UNICHARSET;
+
+class Tesseract;
+
+// Max number of scripts in ICU + "NULL" + Japanese and Korean + Fraktur
+const int kMaxNumberOfScripts = 116 + 1 + 2 + 1;
+
+struct OSBestResult {
+  OSBestResult()
+      : orientation_id(0), script_id(0), sconfidence(0.0), oconfidence(0.0) {}
+  int orientation_id;
+  int script_id;
+  float sconfidence;
+  float oconfidence;
+};
+
+struct OSResults {
+  OSResults() : unicharset(nullptr) {
+    for (int i = 0; i < 4; ++i) {
+      for (int j = 0; j < kMaxNumberOfScripts; ++j) {
+        scripts_na[i][j] = 0;
+      }
+      orientations[i] = 0;
+    }
+  }
+  void update_best_orientation();
+  // Set the estimate of the orientation to the given id.
+  void set_best_orientation(int orientation_id);
+  // Update/Compute the best estimate of the script assuming the given
+  // orientation id.
+  void update_best_script(int orientation_id);
+  // Return the index of the script with the highest score for this orientation.
+  TESS_API int get_best_script(int orientation_id) const;
+  // Accumulate scores with given OSResults instance and update the best script.
+  void accumulate(const OSResults &osr);
+
+  // Print statistics.
+  void print_scores(void) const;
+  void print_scores(int orientation_id) const;
+
+  // Array holding scores for each orientation id [0,3].
+  // Orientation ids [0..3] map to [0, 270, 180, 90] degree orientations of the
+  // page respectively, where the values refer to the amount of clockwise
+  // rotation to be applied to the page for the text to be upright and readable.
+  float orientations[4];
+  // Script confidence scores for each of 4 possible orientations.
+  float scripts_na[4][kMaxNumberOfScripts];
+
+  UNICHARSET *unicharset;
+  OSBestResult best_result;
+};
+
+class OrientationDetector {
+public:
+  OrientationDetector(const std::vector<int> *allowed_scripts,
+                      OSResults *results);
+  bool detect_blob(BLOB_CHOICE_LIST *scores);
+  int get_orientation();
+
+private:
+  OSResults *osr_;
+  const std::vector<int> *allowed_scripts_;
+};
+
+class ScriptDetector {
+public:
+  ScriptDetector(const std::vector<int> *allowed_scripts, OSResults *osr,
+                 tesseract::Tesseract *tess);
+  void detect_blob(BLOB_CHOICE_LIST *scores);
+  bool must_stop(int orientation) const;
+
+private:
+  OSResults *osr_;
+  static const char *korean_script_;
+  static const char *japanese_script_;
+  static const char *fraktur_script_;
+  int korean_id_;
+  int japanese_id_;
+  int katakana_id_;
+  int hiragana_id_;
+  int han_id_;
+  int hangul_id_;
+  int latin_id_;
+  int fraktur_id_;
+  tesseract::Tesseract *tess_;
+  const std::vector<int> *allowed_scripts_;
+};
+
+int orientation_and_script_detection(const char *filename, OSResults *,
+                                     tesseract::Tesseract *);
+
+int os_detect(TO_BLOCK_LIST *port_blocks, OSResults *osr,
+              tesseract::Tesseract *tess);
+
+int os_detect_blobs(const std::vector<int> *allowed_scripts,
+                    BLOBNBOX_CLIST *blob_list, OSResults *osr,
+                    tesseract::Tesseract *tess);
+
+bool os_detect_blob(BLOBNBOX *bbox, OrientationDetector *o, ScriptDetector *s,
+                    OSResults *, tesseract::Tesseract *tess);
+
+// Helper method to convert an orientation index to its value in degrees.
+// The value represents the amount of clockwise rotation in degrees that must be
+// applied for the text to be upright (readable).
+TESS_API int OrientationIdToValue(const int &id);
+
+} // namespace tesseract
+
+#endif // TESSERACT_CCMAIN_OSDETECT_H_