@luii/node-tesseract-ocr 2.1.0 → 2.4.0

package/src/tesseract_wrapper.hpp

@@ -35,23 +35,48 @@ private:
   static Napi::FunctionReference constructor;
 
   // JS Methods
+  Napi::Value Version(const Napi::CallbackInfo &info);
+  Napi::Value IsInitialized(const Napi::CallbackInfo &info);
+  Napi::Value SetInputName(const Napi::CallbackInfo &info);
+  Napi::Value GetInputName(const Napi::CallbackInfo &info);
+  Napi::Value SetInputImage(const Napi::CallbackInfo &info);
+  Napi::Value GetInputImage(const Napi::CallbackInfo &info);
+  Napi::Value GetSourceYResolution(const Napi::CallbackInfo &info);
+  Napi::Value GetDataPath(const Napi::CallbackInfo &info);
+  Napi::Value SetOutputName(const Napi::CallbackInfo &info);
+  Napi::Value ClearPersistentCache(const Napi::CallbackInfo &info);
+  Napi::Value ClearAdaptiveClassifier(const Napi::CallbackInfo &info);
+  Napi::Value GetThresholdedImage(const Napi::CallbackInfo &info);
+  Napi::Value GetThresholdedImageScaleFactor(const Napi::CallbackInfo &info);
   Napi::Value Init(const Napi::CallbackInfo &info);
   Napi::Value InitForAnalysePage(const Napi::CallbackInfo &info);
-  Napi::Value AnalysePage(const Napi::CallbackInfo &info);
+  Napi::Value AnalyseLayout(const Napi::CallbackInfo &info);
+  Napi::Value BeginProcessPages(const Napi::CallbackInfo &info);
+  Napi::Value AddProcessPage(const Napi::CallbackInfo &info);
+  Napi::Value FinishProcessPages(const Napi::CallbackInfo &info);
+  Napi::Value AbortProcessPages(const Napi::CallbackInfo &info);
+  Napi::Value GetProcessPagesStatus(const Napi::CallbackInfo &info);
+  Napi::Value SetDebugVariable(const Napi::CallbackInfo &info);
   Napi::Value SetVariable(const Napi::CallbackInfo &info);
   Napi::Value GetVariable(const Napi::CallbackInfo &info);
   Napi::Value GetIntVariable(const Napi::CallbackInfo &info);
   Napi::Value GetBoolVariable(const Napi::CallbackInfo &info);
   Napi::Value GetDoubleVariable(const Napi::CallbackInfo &info);
   Napi::Value GetStringVariable(const Napi::CallbackInfo &info);
-  Napi::Value PrintVariables(const Napi::CallbackInfo &info);
   Napi::Value SetImage(const Napi::CallbackInfo &info);
+  // Napi::Value PrintVariables(const Napi::CallbackInfo &info);
   Napi::Value SetPageMode(const Napi::CallbackInfo &info);
   Napi::Value SetRectangle(const Napi::CallbackInfo &info);
   Napi::Value SetSourceResolution(const Napi::CallbackInfo &info);
   Napi::Value Recognize(const Napi::CallbackInfo &info);
   Napi::Value DetectOrientationScript(const Napi::CallbackInfo &info);
   Napi::Value MeanTextConf(const Napi::CallbackInfo &info);
+  Napi::Value AllWordConfidences(const Napi::CallbackInfo &info);
+  Napi::Value GetPAGEText(const Napi::CallbackInfo &info);
+  Napi::Value GetLSTMBoxText(const Napi::CallbackInfo &info);
+  Napi::Value GetBoxText(const Napi::CallbackInfo &info);
+  Napi::Value GetWordStrBoxText(const Napi::CallbackInfo &info);
+  Napi::Value getOSDText(const Napi::CallbackInfo &info);
   Napi::Value GetUTF8Text(const Napi::CallbackInfo &info);
   Napi::Value GetHOCRText(const Napi::CallbackInfo &info);
   Napi::Value GetTSVText(const Napi::CallbackInfo &info);

package/src/worker_thread.cpp

@@ -19,12 +19,125 @@
 #include <exception>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <queue>
 #include <stop_token>
 #include <thread>
+#include <type_traits>
 #include <variant>
 #include <vector>
 
+namespace {
+
+std::string CommandName(const Command &command) {
+  return std::visit(
+      [](const auto &c) -> std::string {
+        using T = std::decay_t<decltype(c)>;
+        if constexpr (std::is_same_v<T, CommandVersion>)
+          return "version";
+        if constexpr (std::is_same_v<T, CommandIsInitialized>)
+          return "isInitialized";
+        if constexpr (std::is_same_v<T, CommandInit>)
+          return "init";
+        if constexpr (std::is_same_v<T, CommandInitForAnalysePage>)
+          return "initForAnalysePage";
+        if constexpr (std::is_same_v<T, CommandSetVariable>)
+          return "setVariable";
+        if constexpr (std::is_same_v<T, CommandSetDebugVariable>)
+          return "setDebugVariable";
+        if constexpr (std::is_same_v<T, CommandGetIntVariable>)
+          return "getIntVariable";
+        if constexpr (std::is_same_v<T, CommandGetBoolVariable>)
+          return "getBoolVariable";
+        if constexpr (std::is_same_v<T, CommandGetDoubleVariable>)
+          return "getDoubleVariable";
+        if constexpr (std::is_same_v<T, CommandGetStringVariable>)
+          return "getStringVariable";
+        if constexpr (std::is_same_v<T, CommandSetInputName>)
+          return "setInputName";
+        if constexpr (std::is_same_v<T, CommandGetInputName>)
+          return "getInputName";
+        if constexpr (std::is_same_v<T, CommandSetOutputName>)
+          return "setOutputName";
+        if constexpr (std::is_same_v<T, CommandGetDataPath>)
+          return "getDataPath";
+        if constexpr (std::is_same_v<T, CommandSetInputImage>)
+          return "setInputImage";
+        if constexpr (std::is_same_v<T, CommandGetInputImage>)
+          return "getInputImage";
+        if constexpr (std::is_same_v<T, CommandSetPageMode>)
+          return "setPageMode";
+        if constexpr (std::is_same_v<T, CommandSetRectangle>)
+          return "setRectangle";
+        if constexpr (std::is_same_v<T, CommandSetSourceResolution>)
+          return "setSourceResolution";
+        if constexpr (std::is_same_v<T, CommandGetSourceYResolution>)
+          return "getSourceYResolution";
+        if constexpr (std::is_same_v<T, CommandSetImage>)
+          return "setImage";
+        if constexpr (std::is_same_v<T, CommandGetThresholdedImage>)
+          return "getThresholdedImage";
+        if constexpr (std::is_same_v<T, CommandGetThresholdedImageScaleFactor>)
+          return "getThresholdedImageScaleFactor";
+        if constexpr (std::is_same_v<T, CommandRecognize>)
+          return "recognize";
+        if constexpr (std::is_same_v<T, CommandAnalyseLayout>)
+          return "analyseLayout";
+        if constexpr (std::is_same_v<T, CommandDetectOrientationScript>)
+          return "detectOrientationScript";
+        if constexpr (std::is_same_v<T, CommandMeanTextConf>)
+          return "meanTextConf";
+        if constexpr (std::is_same_v<T, CommandAllWordConfidences>)
+          return "allWordConfidences";
+        if constexpr (std::is_same_v<T, CommandGetUTF8Text>)
+          return "getUTF8Text";
+        if constexpr (std::is_same_v<T, CommandGetHOCRText>)
+          return "getHOCRText";
+        if constexpr (std::is_same_v<T, CommandGetTSVText>)
+          return "getTSVText";
+        if constexpr (std::is_same_v<T, CommandGetUNLVText>)
+          return "getUNLVText";
+        if constexpr (std::is_same_v<T, CommandGetALTOText>)
+          return "getALTOText";
+        if constexpr (std::is_same_v<T, CommandGetPAGEText>)
+          return "getPAGEText";
+        if constexpr (std::is_same_v<T, CommandGetLSTMBoxText>)
+          return "getLSTMBoxText";
+        if constexpr (std::is_same_v<T, CommandGetBoxText>)
+          return "getBoxText";
+        if constexpr (std::is_same_v<T, CommandGetWordStrBoxText>)
+          return "getWordStrBoxText";
+        if constexpr (std::is_same_v<T, CommandGetOSDText>)
+          return "getOSDText";
+        if constexpr (std::is_same_v<T, CommandBeginProcessPages>)
+          return "beginProcessPages";
+        if constexpr (std::is_same_v<T, CommandAddProcessPage>)
+          return "addProcessPage";
+        if constexpr (std::is_same_v<T, CommandFinishProcessPages>)
+          return "finishProcessPages";
+        if constexpr (std::is_same_v<T, CommandAbortProcessPages>)
+          return "abortProcessPages";
+        if constexpr (std::is_same_v<T, CommandGetInitLanguages>)
+          return "getInitLanguages";
+        if constexpr (std::is_same_v<T, CommandGetLoadedLanguages>)
+          return "getLoadedLanguages";
+        if constexpr (std::is_same_v<T, CommandGetAvailableLanguages>)
+          return "getAvailableLanguages";
+        if constexpr (std::is_same_v<T, CommandClearPersistentCache>)
+          return "clearPersistentCache";
+        if constexpr (std::is_same_v<T, CommandClearAdaptiveClassifier>)
+          return "clearAdaptiveClassifier";
+        if constexpr (std::is_same_v<T, CommandClear>)
+          return "clear";
+        if constexpr (std::is_same_v<T, CommandEnd>)
+          return "end";
+        return "unknown";
+      },
+      command);
+}
+
+} // namespace
+
 WorkerThread::WorkerThread(Napi::Env env)
     : _env(env),
       _main_thread(Napi::ThreadSafeFunction::New(
@@ -51,7 +164,14 @@ void WorkerThread::MakeCallback(std::shared_ptr<Job> *p_job) {
         delete _job;
 
         if (job->error.has_value()) {
-          job->deffered.Reject(Napi::Error::New(env, *job->error).Value());
+          Napi::Error error = Napi::Error::New(env, *job->error);
+          if (job->error_code.has_value()) {
+            error.Set("code", Napi::String::New(env, *job->error_code));
+          }
+          if (job->error_method.has_value()) {
+            error.Set("method", Napi::String::New(env, *job->error_method));
+          }
+          job->deffered.Reject(error.Value());
           return;
         }
 
@@ -69,6 +189,7 @@ void WorkerThread::MakeCallback(std::shared_ptr<Job> *p_job) {
 }
 
 void WorkerThread::Run(std::stop_token token) {
+  std::optional<ProcessPagesSession> process_pages_session;
 
   auto drain_queue = [&](std::vector<std::shared_ptr<Job>> &pending_jobs) {
     while (!_request_queue.empty()) {
@@ -81,6 +202,8 @@ void WorkerThread::Run(std::stop_token token) {
           const std::vector<std::shared_ptr<Job>> &pending_jobs) {
         for (const auto &pending_job : pending_jobs) {
           pending_job->error = message;
+          pending_job->error_code = "ERR_WORKER_STOPPED";
+          pending_job->error_method = CommandName(pending_job->command);
           auto *sp_pending_job = new std::shared_ptr<Job>(pending_job);
           MakeCallback(sp_pending_job);
         }
@@ -113,12 +236,33 @@ void WorkerThread::Run(std::stop_token token) {
 
     try {
       job->result = std::visit(
-          [&](const auto &command) -> Result { return command.invoke(_api); },
+          [&](const auto &command) -> Result {
+            if constexpr (requires {
+                            command.invoke(_api, process_pages_session,
+                                           _initialized);
+                          }) {
+              return command.invoke(_api, process_pages_session, _initialized);
+            } else if constexpr (requires {
+                                   command.invoke(_api, _initialized);
+                                 }) {
+              return command.invoke(_api, _initialized);
+            } else if constexpr (requires {
+                                   command.invoke(_api, process_pages_session);
+                                 }) {
+              return command.invoke(_api, process_pages_session);
+            } else {
+              return command.invoke(_api);
+            }
+          },
           job->command);
     } catch (const std::exception &error) {
       job->error = error.what();
+      job->error_code = "ERR_TESSERACT_RUNTIME";
+      job->error_method = CommandName(job->command);
     } catch (...) {
       job->error = "Something unexpected happened";
+      job->error_code = "ERR_TESSERACT_RUNTIME";
+      job->error_method = CommandName(job->command);
     }
 
     auto *sp_job = new std::shared_ptr<Job>(job);

package/src/worker_thread.hpp

@@ -49,6 +49,7 @@ private:
   std::queue<std::shared_ptr<Job>> _request_queue;
 
   tesseract::TessBaseAPI _api;
+  std::atomic<bool> _initialized{false};
 
   std::jthread _worker_thread;
 };
@@ -63,7 +64,9 @@ template <typename C> Napi::Promise WorkerThread::Enqueue(C &&command) {
     std::stop_token token = _worker_thread.get_stop_token();
 
     if (_closing.load() || token.stop_requested()) {
-      deferred.Reject(Napi::Error::New(_env, "Worker is closing").Value());
+      Napi::Error error = Napi::Error::New(_env, "Worker is closing");
+      error.Set("code", Napi::String::New(_env, "ERR_WORKER_CLOSED"));
+      deferred.Reject(error.Value());
       return deferred.Promise();
     }