@luii/node-tesseract-ocr 1.0.19 → 2.0.0

package/src/handle.cpp

@@ -1,174 +0,0 @@
-/*
- * Copyright 2025 Philipp Czarnetzki
- *
- * 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.
- */
-
-#include "handle.h"
-#include "napi.h"
-#include "ocr_worker.h"
-#include <tesseract/pageiterator.h>
-#include <tesseract/publictypes.h>
-
-Napi::Object Handle::GetClass(Napi::Env env, Napi::Object exports) {
-  Napi::Function funcs = DefineClass(
-      env, "Tesseract", {InstanceMethod("recognize", &Handle::Recognize)});
-
-  Napi::FunctionReference *constructor = new Napi::FunctionReference();
-
-  *constructor = Napi::Persistent(funcs);
-  exports.Set("Tesseract", funcs);
-  env.SetInstanceData<Napi::FunctionReference>(constructor);
-
-  return exports;
-};
-
-Handle::Handle(const Napi::CallbackInfo &info)
-    : Napi::ObjectWrap<Handle>(info) {
-
-  Napi::Env env = info.Env();
-
-  if (info.Length() == 1 && info[0].IsObject()) {
-    auto ctorOptions = info[0].As<Napi::Object>();
-
-    const Napi::Value skipOcrOption = ctorOptions.Get("skipOcr");
-    if (!skipOcrOption.IsUndefined() && skipOcrOption.IsBoolean()) {
-      skipOcr_ = skipOcrOption.As<Napi::Boolean>().Value();
-    }
-
-    const Napi::Value dataPathOption = ctorOptions.Get("dataPath");
-    if (!dataPathOption.IsUndefined() && dataPathOption.IsString()) {
-      dataPath_ = dataPathOption.As<Napi::String>().Utf8Value();
-    }
-
-    const Napi::Value langOption = ctorOptions.Get("lang");
-    if (!langOption.IsUndefined() && langOption.IsString()) {
-      lang_ = langOption.As<Napi::String>().Utf8Value();
-    }
-
-    const Napi::Value engineModeOption = ctorOptions.Get("engineMode");
-    if (!engineModeOption.IsUndefined() && engineModeOption.IsNumber()) {
-      oemMode_ = static_cast<tesseract::OcrEngineMode>(
-          engineModeOption.As<Napi::Number>().Int32Value());
-    }
-
-    const Napi::Value psmOption = ctorOptions.Get("psm");
-    if (!psmOption.IsUndefined() && psmOption.IsNumber()) {
-      psm_ = static_cast<tesseract::PageSegMode>(
-          psmOption.As<Napi::Number>().Int32Value());
-    }
-
-    if (oemMode_ < 0 || oemMode_ >= tesseract::OEM_COUNT) {
-      Napi::TypeError::New(env, "Unsupported OCR Engine Mode")
-          .ThrowAsJavaScriptException();
-      return;
-    }
-
-    if (psm_ < 0 || psm_ >= tesseract::PSM_COUNT) {
-      Napi::TypeError::New(env, "Unsupported Page Segmentation Mode")
-          .ThrowAsJavaScriptException();
-      return;
-    }
-  }
-}
-
-Handle::~Handle() {}
-
-std::unique_ptr<tesseract::TessBaseAPI> Handle::CreateApi() {
-  auto api = std::make_unique<tesseract::TessBaseAPI>();
-  if (skipOcr_) {
-    api->InitForAnalysePage();
-  } else {
-    if (api->Init(dataPath_.c_str(), lang_.c_str(), oemMode_) == -1) {
-      api->End();
-      return nullptr;
-    }
-  }
-
-  api->SetPageSegMode(static_cast<tesseract::PageSegMode>(psm_));
-  return api;
-}
-
-Napi::Value Handle::Recognize(const Napi::CallbackInfo &info) {
-  const Napi::Env env = info.Env();
-  const Napi::Promise::Deferred deffered = Napi::Promise::Deferred::New(env);
-
-  if (skipOcr_) {
-    deffered.Reject(Napi::Error::New(env, "OCR not available when handle was "
-                                          "created with `skipOcr` turned on")
-                        .Value());
-    return deffered.Promise();
-  }
-
-  if (info.Length() <= 0 || !info[0].IsBuffer()) {
-    deffered.Reject(
-        Napi::TypeError::New(env, "Expected image buffer to be of type Buffer")
-            .Value());
-    return deffered.Promise();
-  }
-
-  Napi::Function progressCallback = Napi::Function();
-  if (info.Length() == 2 && info[1].IsObject()) {
-    const Napi::Object recognizeOptions = info[1].As<Napi::Object>();
-    const Napi::Value progressChangedOption =
-        recognizeOptions.Get("progressChanged");
-    if (!progressChangedOption.IsUndefined() &&
-        progressChangedOption.IsFunction()) {
-      progressCallback = progressChangedOption.As<Napi::Function>();
-    } else if (!progressChangedOption.IsFunction()) {
-      Napi::TypeError::New(
-          env, "Expected `progressChanged` callback to be a function")
-          .ThrowAsJavaScriptException();
-    }
-  }
-
-  auto imageBuffer = info[0].As<Napi::Buffer<uint8_t>>();
-  auto *pWorker = new OCRWorker(this, info.This().As<Napi::Object>(),
-                                imageBuffer, deffered, progressCallback);
-
-  pWorker->Queue();
-
-  return deffered.Promise();
-}
-
-// Napi::Value Handle::AnalyzeLayout(const Napi::CallbackInfo &info) {
-//   const Napi::Env env = info.Env();
-//   ArgParser args(info);
-//
-//   const Napi::Promise::Deferred deffered = Napi::Promise::Deferred::New(env);
-//
-//   if (!skipOcr_) {
-//     deffered.Reject(
-//         Napi::Error::New(
-//             env, "Page analysis not available unless `skipOcr` is turned on")
-//             .Value());
-//
-//     return deffered.Promise();
-//   }
-//
-//   if (info.Length() < 1 || !info[0].IsBoolean()) {
-//     deffered.Reject(Napi::TypeError::New(
-//                         info.Env(), "Expected first argument to be a
-//                         boolean") .Value());
-//     return deffered.Promise();
-//   }
-//
-//   bool merge_similar_words = info[0].As<Napi::Boolean>().Value();
-//
-//   api_->SetImage();
-//
-//   tesseract::PageIterator *iterator =
-//   api_->AnalyseLayout(merge_similar_words); return;
-// }
-
-std::mutex &Handle::Mutex() { return mutex_; }

package/src/handle.h

@@ -1,57 +0,0 @@
-/*
- * Copyright 2025 Philipp Czarnetzki
- *
- * 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 HANDLE_H
-#define HANDLE_H
-
-#include "napi.h"
-#include <cstdint>
-#include <cstdlib>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <tesseract/baseapi.h>
-#include <tesseract/ocrclass.h>
-#include <tesseract/publictypes.h>
-
-using Napi::CallbackInfo;
-
-class Handle : public Napi::ObjectWrap<Handle> {
-public:
-  static Napi::Object GetClass(Napi::Env env, Napi::Object exports);
-  Handle(const Napi::CallbackInfo &info);
-  ~Handle();
-
-  std::unique_ptr<tesseract::TessBaseAPI> CreateApi();
-  std::mutex &Mutex();
-  tesseract::ETEXT_DESC *Monitor();
-
-private:
-  bool skipOcr_ = false;
-
-  std::string dataPath_ = std::getenv("NODE_TESSERACT_DATAPATH");
-  std::string lang_ = "eng";
-  tesseract::OcrEngineMode oemMode_ = tesseract::OEM_DEFAULT;
-  tesseract::PageSegMode psm_ = tesseract::PSM_SINGLE_BLOCK;
-
-  std::unique_ptr<tesseract::TessBaseAPI> api_;
-  std::mutex mutex_;
-
-  Napi::Value Recognize(const CallbackInfo &info);
-  Napi::Value AnalyzeLayout(const CallbackInfo &info);
-};
-
-#endif // HANDLE_H

package/src/ocr_result.cpp

@@ -1,99 +0,0 @@
-/*
- * Copyright 2025 Philipp Czarnetzki
- *
- * 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.
- */
-
-#include "ocr_result.h"
-#include "napi.h"
-#include <mutex>
-#include <tesseract/baseapi.h>
-#include <tesseract/ocrclass.h>
-
-Napi::Function OCRResult::GetClass(Napi::Env env) {
-  return DefineClass(env, "OCRResult",
-                     {
-                         InstanceMethod("getText", &OCRResult::GetText),
-                         InstanceMethod("getHOCR", &OCRResult::GetHOCR),
-                         InstanceMethod("getTSV", &OCRResult::GetTSV),
-                         InstanceMethod("getALTO", &OCRResult::GetALTO),
-                     });
-}
-
-OCRResult::OCRResult(const Napi::CallbackInfo &info)
-    : Napi::ObjectWrap<OCRResult>(info), handle_(nullptr) {
-  // Expect constructor args: text, hocr, tsv (all strings)
-  if (info.Length() >= 1 && info[0].IsString()) {
-    text_ = info[0].As<Napi::String>().Utf8Value();
-  }
-  if (info.Length() >= 2 && info[1].IsString()) {
-    hocr_ = info[1].As<Napi::String>().Utf8Value();
-  }
-  if (info.Length() >= 3 && info[2].IsString()) {
-    tsv_ = info[2].As<Napi::String>().Utf8Value();
-  }
-  if (info.Length() >= 4 && info[3].IsString()) {
-    alto_ = info[3].As<Napi::String>().Utf8Value();
-  }
-}
-
-Napi::Object OCRResult::NewInstance(Napi::Env env, const std::string &text,
-                                    const std::string &hocr,
-                                    const std::string &tsv,
-                                    const std::string &alto) {
-  Napi::EscapableHandleScope scope(env);
-
-  Napi::Function ctor = OCRResult::GetClass(env);
-  Napi::Object obj =
-      ctor.New({Napi::String::New(env, text), Napi::String::New(env, hocr),
-                Napi::String::New(env, tsv), Napi::String::New(env, alto)});
-
-  return scope.Escape(obj).As<Napi::Object>();
-}
-
-void OCRResult::Cancel(const Napi::CallbackInfo &info) {
-  // Napi::Env env = info.Env();
-
-  {
-    std::lock_guard<std::mutex> lock(handle_->Mutex());
-    tesseract::ETEXT_DESC *monitor = handle_->Monitor();
-
-    monitor->cancel = [](void *should_cancel, int wordcount) -> bool {
-      return true;
-    };
-    monitor->cancel_this = (void *)true;
-    monitor->cancel(monitor->cancel_this, monitor->count);
-  }
-
-  return;
-}
-
-Napi::Value OCRResult::GetText(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  return Napi::String::New(env, text_);
-}
-
-Napi::Value OCRResult::GetHOCR(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  return Napi::String::New(env, hocr_);
-}
-
-Napi::Value OCRResult::GetTSV(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  return Napi::String::New(env, tsv_);
-}
-
-Napi::Value OCRResult::GetALTO(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  return Napi::String::New(env, alto_);
-}

package/src/ocr_result.h

@@ -1,47 +0,0 @@
-/*
- * Copyright 2025 Philipp Czarnetzki
- *
- * 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 OCRRESULT_H
-#define OCRRESULT_H
-
-#include "handle.h"
-#include <napi.h>
-
-class OCRResult : public Napi::ObjectWrap<OCRResult> {
-
-public:
-  OCRResult(const Napi::CallbackInfo &info);
-  static Napi::Function GetClass(Napi::Env env);
-  static Napi::Object NewInstance(Napi::Env env, const std::string &text,
-                                  const std::string &hocr,
-                                  const std::string &tsv,
-                                  const std::string &alto);
-
-private:
-  void Cancel(const CallbackInfo &info);
-  Napi::Value GetText(const CallbackInfo &info);
-  Napi::Value GetHOCR(const CallbackInfo &info);
-  Napi::Value GetTSV(const CallbackInfo &info);
-  Napi::Value GetALTO(const CallbackInfo &info);
-
-  Handle *handle_;
-  std::string text_;
-  std::string hocr_;
-  std::string tsv_;
-  std::string alto_;
-};
-
-#endif // OCRRESULT_H

package/src/ocr_worker.cpp

@@ -1,191 +0,0 @@
-/*
- * Copyright 2025 Philipp Czarnetzki
- *
- * 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.
- */
-
-#include "ocr_worker.h"
-#include "napi.h"
-#include "ocr_result.h"
-#include <cstddef>
-#include <cstdio>
-#include <tesseract/baseapi.h>
-#include <tesseract/ocrclass.h>
-
-OCRWorker::OCRWorker(Handle *handle, Napi::Object handleObject,
-                     Napi::Buffer<uint8_t> buffer,
-                     Napi::Promise::Deferred deffered,
-                     Napi::Function &progressCallback)
-    : Napi::AsyncProgressWorker<ProgressPayload>{handle->Env(), "OCRWorker"},
-      handle_(handle), data_(buffer.Data()), length_(buffer.Length()),
-      deffered_{deffered} {
-
-  this->progressCallback_.Reset(progressCallback, 1);
-
-  // Hold a persistent reference to the JS Buffer.
-  // So its memory isn't freed while the async worker is running.
-  this->bufferRef_.Reset(buffer, 1);
-  // Hold a persistent reference to the JS Handle object.
-  // So it isn't GC'd while this worker is active.
-  this->handleRef_.Reset(handleObject, 1);
-
-  // allocate and zero-init the monitor to avoid uninitialized fields
-  monitor_ = new tesseract::ETEXT_DESC();
-
-  monitor_->progress_callback2 = [](tesseract::ETEXT_DESC *monitor, int left,
-                                    int right, int top, int bottom) -> bool {
-    ProgressPayload payload{monitor->more_to_come,
-                            monitor->progress,
-                            monitor->ocr_alive,
-                            top,
-                            right,
-                            bottom,
-                            left};
-    auto *executionProgress =
-        static_cast<OCRWorker::ExecutionProgress *>(monitor->cancel_this);
-    if (executionProgress == nullptr) {
-      return false;
-    }
-    executionProgress->Send(&payload, 1);
-    return false;
-  };
-  monitor_->ocr_alive = 1;
-};
-
-OCRWorker::~OCRWorker() {
-  // release the persistent buffer reference
-  if (!this->bufferRef_.IsEmpty()) {
-    this->bufferRef_.Reset();
-  }
-
-  // free monitor
-  if (monitor_) {
-    delete monitor_;
-    monitor_ = nullptr;
-  }
-  if (!this->handleRef_.IsEmpty()) {
-    this->handleRef_.Reset();
-  }
-}
-
-void OCRWorker::Execute(const ExecutionProgress &executionProgress) {
-
-  Pix *pPix = pixReadMem(data_, length_);
-
-  if (!pPix) {
-    SetError("Could not read image from buffer");
-    return;
-  }
-
-  // determine image depth and normalize to 8-bit grayscale (if needed)
-  int depth = pixGetDepth(pPix);
-  if (depth != 8) {
-    Pix *pGray = pixConvertTo8(pPix, 0); /* 0 = no colormap */
-    if (pGray) {
-      pixDestroy(&pPix);
-      pPix = pGray;
-    }
-  }
-
-  std::unique_ptr<tesseract::TessBaseAPI> localApi;
-  {
-    std::lock_guard<std::mutex> lock(handle_->Mutex());
-
-    // Create a thread-local TessBaseAPI to avoid sharing across threads;
-    localApi = handle_->CreateApi();
-
-    if (!localApi) {
-      pixDestroy(&pPix);
-      SetError("Could not initialize thread-local Tesseract API");
-      return;
-    }
-
-    localApi->SetImage(pPix);
-    monitor_->cancel_this = (void *)&executionProgress;
-
-    if (localApi->Recognize(monitor_) != 0) {
-      pixDestroy(&pPix);
-      monitor_->cancel_this = nullptr;
-      SetError("Recognize failed");
-      return;
-    }
-  }
-
-  // retrieve results from the local API
-  {
-    char *t = nullptr;
-    t = localApi->GetUTF8Text();
-    if (t) {
-      resultText_.assign(t);
-      delete[] t;
-    }
-
-    t = localApi->GetHOCRText(0);
-    if (t) {
-      resultHOCR_.assign(t);
-      delete[] t;
-    }
-
-    t = localApi->GetTSVText(0);
-    if (t) {
-      resultTSV_.assign(t);
-      delete[] t;
-    }
-
-    t = localApi->GetAltoText(0);
-    if (t) {
-      resultALTO_.assign(t);
-      delete[] t;
-    }
-  }
-
-  monitor_->cancel_this = nullptr;
-  pixDestroy(&pPix);
-}
-
-void OCRWorker::OnOK() {
-  Napi::Env env = Env();
-  Napi::HandleScope scope(env);
-
-  Napi::Object resultObj = OCRResult::NewInstance(env, resultText_, resultHOCR_,
-                                                  resultTSV_, resultALTO_);
-  // Attach a reference to the Handle JS object on the result.
-  // So the Handle stays alive as long as the OCRResult is reachable from JS.
-  if (!handleRef_.IsEmpty()) {
-    resultObj.Set("_handle", handleRef_.Value());
-  }
-
-  this->deffered_.Resolve(resultObj);
-}
-
-void OCRWorker::OnError(const Napi::Error &error) {
-  Napi::HandleScope scope(Env());
-  this->deffered_.Reject(error.Value());
-}
-
-void OCRWorker::OnProgress(const ProgressPayload *payload, size_t count) {
-  Napi::HandleScope scope(Env());
-  Napi::Object progress = Napi::Object::New(Env());
-
-  progress.Set("percent", payload->percent);
-  progress.Set("progress", payload->progress);
-  progress.Set("ocr_alive", payload->ocr_alive);
-  progress.Set("top", payload->top);
-  progress.Set("right", payload->right);
-  progress.Set("bottom", payload->bottom);
-  progress.Set("left", payload->left);
-
-  if (!this->progressCallback_.IsEmpty()) {
-    progressCallback_.Call(Env().Undefined(), {progress});
-  }
-}

package/src/ocr_worker.h

@@ -1,67 +0,0 @@
-/*
- * Copyright 2025 Philipp Czarnetzki
- *
- * 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 OCRWORKER_H
-#define OCRWORKER_H
-
-#include "handle.h"
-#include "leptonica/allheaders.h"
-#include "napi.h"
-#include <cstddef>
-#include <memory>
-#include <tesseract/baseapi.h>
-#include <tesseract/ocrclass.h>
-
-struct ProgressPayload {
-  int percent;
-  int progress;
-  int ocr_alive;
-  int top;
-  int right;
-  int bottom;
-  int left;
-};
-
-class OCRWorker : public Napi::AsyncProgressWorker<ProgressPayload> {
-public:
-  OCRWorker(Handle *handle, Napi::Object handleObject,
-            Napi::Buffer<uint8_t> buffer, Napi::Promise::Deferred deffered,
-            Napi::Function &progressCallback);
-  ~OCRWorker();
-
-protected:
-  void Execute(const ExecutionProgress &executionProgress) override;
-
-  void OnOK() override;
-  void OnError(const Napi::Error &error) override;
-  void OnProgress(const ProgressPayload *payload, size_t count) override;
-
-private:
-  Handle *handle_;
-  Napi::Reference<Napi::Object> handleRef_;
-  uint8_t *data_;
-  size_t length_;
-  Napi::Reference<Napi::Buffer<uint8_t>> bufferRef_;
-  Napi::Promise::Deferred deffered_;
-  tesseract::ETEXT_DESC *monitor_ = nullptr;
-  Napi::FunctionReference progressCallback_;
-  std::string resultText_;
-  std::string resultHOCR_;
-  std::string resultTSV_;
-  std::string resultALTO_;
-};
-
-#endif // OCRWORKER_H