node-native-win-utils 2.1.3 → 2.1.5

package/README.md

@@ -1,6 +1,6 @@
 
 [![License][license-src]][license-href] 
-![Node-API v8 Badge](assets/Node-API%20v8%20Badge.svg)
+![Node-API v8 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v8%20Badge.svg)
 
 #### USDT TRC20 - TYAJ3K3MZraJhWimxxeCKcJ2SYABkVsrzi
 ####  USDT TON - UQDokuYZXr4OHvfslDqUoFYcp1_F8tcjQPk_TvqSSDk7SIa7

package/dist/index.cjs

@@ -176,6 +176,8 @@ class OpenCV {
      * @returns The result of the template matching operation.
      */
     matchTemplate(template, method, mask) {
+        if (typeof method !== "number")
+            method = TemplateMatchModes.TM_CCOEFF_NORMED;
         return matchTemplate(this.imageData, template, method, mask);
     }
     /**

package/dist/index.d.mts

@@ -79,6 +79,8 @@ export type MatchTemplate = (image: ImageData, template: ImageData, method?: num
 export type Blur = (image: ImageData, sizeX: number, sizeY: number) => ImageData;
 export type BgrToGray = (image: ImageData) => ImageData;
 export type EqualizeHist = (image: ImageData) => ImageData;
+export type ColorBound = [number, number, number];
+export type DarkenColor = (image: ImageData, lowerBound: ColorBound, upperBound: ColorBound, darkenFactor: number) => ImageData;
 export type DrawRectangle = (image: ImageData, start: Point, end: Point, rgb: Color, thickness: number) => ImageData;
 export type GetRegion = (image: ImageData, region: ROI) => ImageData;
 export type TextRecognition = (trainedDataPath: string, dataLang: string, imagePath: string) => string;
@@ -250,6 +252,8 @@ declare class OpenCV {
       * @returns A new OpenCV instance with the equalized image data.
       */
     equalizeHist(): OpenCV;
+    rgbToHsv(rgb: ColorBound): number[];
+    darkenColor(lowerBound: ColorBound, upperBound: ColorBound, darkenFactor: number): OpenCV;
     /**
      * Draws a rectangle on the image.
      * @param start - The starting point of the rectangle.

package/dist/index.mjs

@@ -8,7 +8,7 @@ const nodeGypBuild = __require("node-gyp-build");
 import { keyCodes, KeyCodeHelper } from "./keyCodes.mjs";
 import { __dirnameLocal } from "./dirnameLocal.mjs";
 const bindings = nodeGypBuild(path.resolve(__dirnameLocal, ".."));
-const { setKeyDownCallback, setKeyUpCallback, unsetKeyDownCallback, unsetKeyUpCallback, getWindowData, captureWindowN, captureScreenAsync, mouseMove, mouseClick, mouseDrag, typeString, pressKey, imread, imwrite, matchTemplate, blur, bgrToGray, drawRectangle, getRegion, textRecognition, equalizeHist } = bindings;
+const { setKeyDownCallback, setKeyUpCallback, unsetKeyDownCallback, unsetKeyUpCallback, getWindowData, captureWindowN, captureScreenAsync, mouseMove, mouseClick, mouseDrag, typeString, pressKey, imread, imwrite, matchTemplate, blur, bgrToGray, drawRectangle, getRegion, textRecognition, equalizeHist, darkenColor } = bindings;
 const rawPressKey = pressKey;
 /**
  * Captures a window and saves it to a file.
@@ -157,6 +157,8 @@ class OpenCV {
      * @returns The result of the template matching operation.
      */
     matchTemplate(template, method, mask) {
+        if (typeof method !== "number")
+            method = TemplateMatchModes.TM_CCOEFF_NORMED;
         return matchTemplate(this.imageData, template, method, mask);
     }
     /**
@@ -182,6 +184,41 @@ class OpenCV {
     equalizeHist() {
         return new OpenCV(equalizeHist(this.imageData));
     }
+    rgbToHsv(rgb) {
+        const r_norm = rgb[0] / 255;
+        const g_norm = rgb[1] / 255;
+        const b_norm = rgb[2] / 255;
+        const Cmax = Math.max(r_norm, g_norm, b_norm);
+        const Cmin = Math.min(r_norm, g_norm, b_norm);
+        const delta = Cmax - Cmin;
+        let Hue = 0;
+        if (delta !== 0) {
+            switch (Cmax) {
+                case r_norm:
+                    Hue = 60 * (((g_norm - b_norm) / delta) % 6);
+                    break;
+                case g_norm:
+                    Hue = 60 * (((b_norm - r_norm) / delta) + 2);
+                    break;
+                case b_norm:
+                    Hue = 60 * (((r_norm - g_norm) / delta) + 4);
+                    break;
+            }
+        }
+        let Saturation = 0.0 * 100;
+        if (Cmax !== 0)
+            Saturation = (delta / Cmax) * 100;
+        let Value = Cmax * 100;
+        // 🛠 Convert to OpenCV format
+        return [
+            Math.round((Hue / 360) * 179), // Scale H from [0, 360] → [0, 179]
+            Math.round((Saturation / 100) * 255), // Scale S from [0, 100] → [0, 255]
+            Math.round((Value / 100) * 255) // Scale V from [0, 100] → [0, 255]
+        ];
+    }
+    darkenColor(lowerBound, upperBound, darkenFactor) {
+        return new OpenCV(darkenColor(this.imageData, lowerBound, upperBound, darkenFactor));
+    }
     /**
      * Draws a rectangle on the image.
      * @param start - The starting point of the rectangle.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-native-win-utils",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "author": "Andrew K.",
   "license": "MIT",
   "repository": "https://github.com/T-Rumibul/node-native-win-utils.git",

package/src/cpp/main.cpp

@@ -27,6 +27,7 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
     exports.Set("blur", Napi::Function::New(env, Blur));
     exports.Set("bgrToGray", Napi::Function::New(env, BgrToGray));
     exports.Set("equalizeHist", Napi::Function::New(env, EqualizeHist));
+    exports.Set("darkenColor", Napi::Function::New(env, DarkenColor));
     exports.Set("drawRectangle", Napi::Function::New(env, DrawRectangle));
     exports.Set("getRegion", Napi::Function::New(env, GetRegion));
     exports.Set("textRecognition", Napi::Function::New(env, TextRecognition));

package/src/cpp/opencv.cpp

@@ -234,6 +234,9 @@ Napi::Value BgrToGray(const Napi::CallbackInfo &info)
     return result;
 }
 
+
+
+
 Napi::Value EqualizeHist(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -453,20 +456,90 @@ Napi::Value GetRegion(const Napi::CallbackInfo &info)
     return result;
 }
 
-// Napi::Value ReadImage(const Napi::CallbackInfo &info)
-// {
-//     Napi::Env env = info.Env();
-//     std::string imagePath = info[0].As<Napi::String>();
 
-//     cv::Mat image = cv::imread(imagePath, cv::IMREAD_COLOR);
-//     if (image.empty())
-//     {
-//         Napi::TypeError::New(env, "Could not read the image").ThrowAsJavaScriptException();
-//         return env.Null();
-//     }
 
-//     cv::Mat grayImage;
-//     cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);
 
-//     return Napi::Number::New(env, grayImage.rows * grayImage.cols);
-// }
+
+Napi::Value DarkenColor(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    // Validate arguments: (imageData: Object, lowerBound: Array, upperBound: Array, number darkFactor)
+    if (info.Length() < 4 ||
+        !info[0].IsObject() ||
+        !info[1].IsArray() ||
+        !info[2].IsArray() ||
+        !info[3].IsNumber()) {
+        Napi::TypeError::New(env, "Invalid arguments. Expected: (object, array, array, number)")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object imageData = info[0].As<Napi::Object>();
+    Napi::Array lowerArray = info[1].As<Napi::Array>();
+    Napi::Array upperArray = info[2].As<Napi::Array>();
+    double darkFactor = info[3].ToNumber().DoubleValue();
+
+    // Validate imageData object properties
+    if (!imageData.Has("width") || !imageData.Has("height") || !imageData.Has("data")) {
+        Napi::TypeError::New(env, "Invalid image data object. Expected properties: 'width', 'height', 'data'")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Validate bounds arrays length
+    if (lowerArray.Length() != 3 || upperArray.Length() != 3) {
+        Napi::TypeError::New(env, "Lower and upper color bounds must be arrays of length 3")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    int width = imageData.Get("width").ToNumber().Int32Value();
+    int height = imageData.Get("height").ToNumber().Int32Value();
+
+    if (!imageData.Get("data").IsTypedArray()) {
+        Napi::TypeError::New(env, "'data' property must be a TypedArray")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Uint8Array uint8Array = imageData.Get("data").As<Napi::Uint8Array>();
+    // Account for potential byteOffset in the typed array.
+    uint8_t* dataPtr = reinterpret_cast<uint8_t*>(uint8Array.ArrayBuffer().Data()) + uint8Array.ByteOffset();
+
+    // Create a cv::Mat using the underlying data of the Uint8Array.
+    cv::Mat inputImage(height, width, CV_8UC3, dataPtr);
+    cv::Mat image;
+    cv::cvtColor(inputImage, image, cv::COLOR_BGR2RGB);
+    // Create lower and upper bounds from the provided arrays.
+    cv::Scalar lower_bound(
+        lowerArray.Get((uint32_t)0).ToNumber().DoubleValue(),
+        lowerArray.Get((uint32_t)1).ToNumber().DoubleValue(),
+        lowerArray.Get((uint32_t)2).ToNumber().DoubleValue()
+    );
+    cv::Scalar upper_bound(
+        upperArray.Get((uint32_t)0).ToNumber().DoubleValue(),
+        upperArray.Get((uint32_t)1).ToNumber().DoubleValue(),
+        upperArray.Get((uint32_t)2).ToNumber().DoubleValue()
+    );
+
+    // Loop through the image pixels and darken the ones within the color range
+    for (int y = 0; y < image.rows; y++) {
+        for (int x = 0; x < image.cols; x++) {
+            cv::Vec3b& color = image.at<cv::Vec3b>(y, x);
+
+            // Check if the pixel is within the color range
+            if (color[0] >= lower_bound[0] && color[0] <= upper_bound[0] &&
+                color[1] >= lower_bound[1] && color[1] <= upper_bound[1] &&
+                color[2] >= lower_bound[2] && color[2] <= upper_bound[2]) {
+
+                // Darken the pixel by scaling down its color values
+                color[0] = std::max(0, int(color[0] * darkFactor));
+                color[1] = std::max(0, int(color[1] * darkFactor));
+                color[2] = std::max(0, int(color[2] * darkFactor));
+            }
+        }
+    }
+    cv::cvtColor(image, inputImage, cv::COLOR_RGB2BGR);
+    // Return the modified imageData (which shares the same underlying data).
+    return imageData;
+}

package/src/index.mts

@@ -121,6 +121,9 @@ export type Blur = (
 ) => ImageData;
 export type BgrToGray = (image: ImageData) => ImageData;
 export type EqualizeHist = (image: ImageData) => ImageData;
+
+export type ColorBound = [number, number, number]
+export type DarkenColor = (image: ImageData, lowerBound: ColorBound, upperBound: ColorBound, darkenFactor: number) => ImageData;
 export type DrawRectangle = (
   image: ImageData,
   start: Point,
@@ -154,7 +157,8 @@ const {
   drawRectangle,
   getRegion,
   textRecognition,
-  equalizeHist
+  equalizeHist,
+  darkenColor
 }: {
   setKeyDownCallback: SetKeyCallback;
   setKeyUpCallback: SetKeyCallback;
@@ -176,7 +180,8 @@ const {
   getRegion: GetRegion;
   textRecognition: TextRecognition;
   captureScreenAsync: CaptureScreenAsync;
-  equalizeHist: EqualizeHist
+  equalizeHist: EqualizeHist;
+  darkenColor: DarkenColor;
 } = bindings;
 
 const rawPressKey = pressKey;
@@ -405,6 +410,7 @@ class OpenCV {
    * @returns The result of the template matching operation.
    */
   matchTemplate(template: ImageData, method?: number | null, mask?: ImageData) {
+    if(typeof method !== "number") method = TemplateMatchModes.TM_CCOEFF_NORMED;
     return matchTemplate(this.imageData, template, method, mask);
   }
 
@@ -433,7 +439,38 @@ class OpenCV {
  equalizeHist() {
   return new OpenCV(equalizeHist(this.imageData));
 }
-
+rgbToHsv(rgb: ColorBound) {
+ const r_norm = rgb[0] / 255;
+ const g_norm = rgb[1] / 255;
+ const b_norm = rgb[2] / 255;
+ const Cmax = Math.max(r_norm, g_norm, b_norm);
+ const Cmin = Math.min(r_norm, g_norm, b_norm);
+ const delta = Cmax - Cmin;
+
+ let Hue = 0;
+ if (delta !== 0) {
+  switch (Cmax) {
+    case r_norm:
+      Hue = 60 * (((g_norm - b_norm) / delta) % 6);
+      break;
+    case g_norm:
+      Hue = 60 * (((b_norm - r_norm) / delta) + 2);
+      break;
+    case b_norm:
+      Hue = 60 * (((r_norm - g_norm) / delta) + 4);
+      break;
+  }
+}
+ let Saturation = 0.0 * 100;
+ if(Cmax !== 0) Saturation = (delta / Cmax) * 100;
+ let Value = Cmax * 100;
+ return [
+  [Hue, Saturation, Value]
+];
+}
+darkenColor(lowerBound: ColorBound, upperBound: ColorBound, darkenFactor: number) {
+  return new OpenCV(darkenColor(this.imageData, lowerBound, upperBound, darkenFactor));
+}
 
   /**
    * Draws a rectangle on the image.