ppu-ocv 3.1.5 → 3.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 PT. Perkasa Pilar Utama
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # ppu-ocv
 
-[![NPM](https://img.shields.io/npm/dw/ppu-ocv)](https://www.npmjs.com/package/ppu-ocv) [![JSR](https://jsr.io/badges/@snowfluke/ppu-ocv)](https://jsr.io/@snowfluke/ppu-ocv)
+[![NPM](https://img.shields.io/npm/dw/ppu-ocv)](https://www.npmjs.com/package/ppu-ocv) [![JSR](https://jsr.io/badges/@snowfluke/ppu-ocv)](https://jsr.io/@snowfluke/ppu-ocv) [![npm version](https://img.shields.io/npm/v/ppu-ocv)](https://www.npmjs.com/package/ppu-ocv) [![Provenance](https://img.shields.io/badge/npm-signed%20provenance-blue?logo=npm)](https://www.npmjs.com/package/ppu-ocv#provenance) [![License: MIT](https://img.shields.io/npm/l/ppu-ocv)](./LICENSE) [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/PT-Perkasa-Pilar-Utama/ppu-ocv/badge)](https://scorecard.dev/viewer/?uri=github.com/PT-Perkasa-Pilar-Utama/ppu-ocv) [![Socket Badge](https://socket.dev/api/badge/npm/package/ppu-ocv)](https://socket.dev/npm/package/ppu-ocv) [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12961/badge)](https://www.bestpractices.dev/projects/12961)
 
 A type-safe, modular, chainable image processing library built on top of OpenCV.js with a fluent API leveraging pipeline processing. Decoupled canvas utilities run anywhere — Node, Bun, browsers, browser extensions, and service workers — with or without OpenCV.
 
@@ -168,14 +168,24 @@ processor.destroy();
 
 ### Vanilla HTML (no bundler)
 
-`initRuntime()` automatically loads `@techstark/opencv-js` from the npm CDN if it's not already available. No extra script tags or import maps needed:
+The web build does not bundle OpenCV — load `opencv.js` yourself so it is on
+`globalThis.cv`, then `initRuntime()` waits for the WASM to finish initializing:
 
 ```html
+<!-- Load OpenCV; sets globalThis.cv (WASM initializes asynchronously). -->
+<script async src="https://docs.opencv.org/4.10.0/opencv.js"></script>
 <script type="module">
   import {
     CanvasProcessor,
     ImageProcessor,
   } from "https://cdn.jsdelivr.net/npm/ppu-ocv@3/index.web.js";
+
+  // Wait until the opencv.js script tag is present, then for the runtime.
+  await new Promise((resolve) => {
+    const ready = () => globalThis.cv && globalThis.cv.Mat;
+    const tick = () => (ready() ? resolve() : setTimeout(tick, 30));
+    tick();
+  });
   await ImageProcessor.initRuntime();
 
   const response = await fetch("/my-image.jpg");
@@ -192,6 +202,9 @@ processor.destroy();
 </script>
 ```
 
+> With a bundler, importing `@techstark/opencv-js` once (it self-registers on
+> `globalThis.cv`) is enough — no script tag needed.
+
 > **Note:** ES modules require HTTP/HTTPS — use a local server (`npx serve .`) for dev, or deploy to GitHub Pages.
 
 See the [interactive demo](./index.html) for a full working example.
@@ -231,21 +244,22 @@ setPlatform(myPlatform);
 
 To avoid bloat, we only ship essential operations for chaining. Currently shipped operations are:
 
-| Operation                 | Depends on…                                 | Why                                                             |
-| ------------------------- | ------------------------------------------- | --------------------------------------------------------------- |
-| **grayscale**             | –                                           | Converts to single‐channel; many ops expect a gray image first. |
-| **blur**                  | _(ideally after)_ grayscale                 | Noise reduction works best on 1-channel data.                   |
-| **threshold**             | _(after)_ grayscale                         | Produces a binary image; needs gray levels.                     |
-| **adaptiveThreshold**     | _(after)_ grayscale (and optionally blur)   | Local thresholding on gray values (smoother if blurred first).  |
-| **invert**                | _(after)_ threshold or adaptiveThreshold    | Inverting a binary mask flips foreground/background.            |
-| **canny**                 | _(after)_ grayscale + blur                  | Edge detection expects a smoothed gray image.                   |
-| **dilate**                | _(after)_ threshold or edge detection       | Expands foreground regions—usually on a binary mask.            |
-| **erode**                 | _(after)_ threshold or edge detection       | Shrinks or cleans up binary regions.                            |
-| **morphologicalGradient** | _(after)_ dilation + erosion (or threshold) | Highlights boundaries by subtracting eroded from dilated image. |
-| **warp**                  | –                                           | Geometric transform; can be applied at any point.               |
-| **resize**                | –                                           | Also independent; purely geometry.                              |
-| **border**                | –                                           | Independent; purely geometry.                                   |
-| **rotate**                | –                                           | Independent.                                                    |
+| Operation                 | Depends on…                                 | Why                                                                                      |
+| ------------------------- | ------------------------------------------- | ---------------------------------------------------------------------------------------- |
+| **grayscale**             | –                                           | Converts to single‐channel; many ops expect a gray image first.                          |
+| **blur**                  | _(ideally after)_ grayscale                 | Noise reduction works best on 1-channel data.                                            |
+| **equalize**              | _(after)_ grayscale                         | Histogram equalisation (CLAHE or global) for contrast normalisation before thresholding. |
+| **threshold**             | _(after)_ grayscale                         | Produces a binary image; needs gray levels.                                              |
+| **adaptiveThreshold**     | _(after)_ grayscale (and optionally blur)   | Local thresholding on gray values (smoother if blurred first).                           |
+| **invert**                | _(after)_ threshold or adaptiveThreshold    | Inverting a binary mask flips foreground/background.                                     |
+| **canny**                 | _(after)_ grayscale + blur                  | Edge detection expects a smoothed gray image.                                            |
+| **dilate**                | _(after)_ threshold or edge detection       | Expands foreground regions—usually on a binary mask.                                     |
+| **erode**                 | _(after)_ threshold or edge detection       | Shrinks or cleans up binary regions.                                                     |
+| **morphologicalGradient** | _(after)_ dilation + erosion (or threshold) | Highlights boundaries by subtracting eroded from dilated image.                          |
+| **warp**                  | –                                           | Geometric transform; can be applied at any point.                                        |
+| **resize**                | –                                           | Also independent; purely geometry.                                                       |
+| **border**                | –                                           | Independent; purely geometry.                                                            |
+| **rotate**                | –                                           | Independent.                                                                             |
 
 ## Extending operations
 

package/canvas-factory.d.ts

@@ -3,7 +3,7 @@
  * Allows ppu-ocv to work with both @napi-rs/canvas (Node) and browser canvas APIs.
  */
 /** Structural type satisfied by both @napi-rs/canvas Canvas and HTMLCanvasElement/OffscreenCanvas. */
-export interface CanvasLike {
+export type CanvasLike = {
     /** Canvas width in pixels. */
     width: number;
     /** Canvas height in pixels. */
@@ -14,9 +14,16 @@ export interface CanvasLike {
     toBuffer?: (...args: any[]) => Buffer;
     /** Serialize the canvas to a data-URL string (browser canvases). Absent on Node-side `@napi-rs/canvas`. */
     toDataURL?: (...args: any[]) => string;
-}
+    /** Asynchronously serialize to a `Blob` via callback (browser `HTMLCanvasElement`). */
+    toBlob?: (callback: (blob: Blob | null) => void, type?: string, quality?: number) => void;
+    /** Asynchronously serialize to a `Blob` (`OffscreenCanvas`, used in workers and extensions). */
+    convertToBlob?: (options?: {
+        type?: string;
+        quality?: number;
+    }) => Promise<Blob>;
+};
 /** Structural type for 2D rendering context, matching the cross-runtime subset used by ppu-ocv. */
-export interface Context2DLike {
+export type Context2DLike = {
     /** The canvas this context is bound to. */
     canvas: any;
     /** Draw an image, canvas, or bitmap onto the context. Signature follows the standard Canvas2D `drawImage`. */
@@ -59,17 +66,28 @@ export interface Context2DLike {
     translate(x: number, y: number): void;
     /** Rotate the coordinate system clockwise by `angle` radians. */
     rotate(angle: number): void;
-}
+};
 /** Platform-specific canvas operations. Each runtime entry point registers an implementation via {@link setPlatform}. */
-export interface CanvasPlatform {
+export type CanvasPlatform = {
     /** Create a blank canvas of the given width and height. */
     createCanvas(width: number, height: number): CanvasLike;
     /** Decode an image from a buffer or URL and draw it onto a fresh canvas. */
     loadImage(source: ArrayBuffer | string): Promise<CanvasLike>;
     /** Type guard for "is this value a canvas of this platform?". */
     isCanvas(value: unknown): value is CanvasLike;
-}
+};
 /** Register the platform-specific canvas implementation */
 export declare function setPlatform(platform: CanvasPlatform): void;
 /** Get the registered platform. Throws if none has been set. */
 export declare function getPlatform(): CanvasPlatform;
+/**
+ * Structural ("duck-typed") canvas check, independent of the registered
+ * platform. A value is canvas-like if it exposes `width`/`height` numbers and a
+ * `getContext` function — true for both `@napi-rs/canvas` (Node) and browser
+ * `HTMLCanvasElement`/`OffscreenCanvas`.
+ *
+ * Unlike {@link CanvasPlatform.isCanvas}, this does not depend on which platform
+ * is globally registered, so it stays correct when the Node and web entry
+ * points are loaded in the same process (e.g. a dual-target test suite).
+ */
+export declare function isCanvasLike(value: unknown): value is CanvasLike;

package/canvas-factory.js

@@ -1 +1 @@
-let _platform=null;export function setPlatform(platform){_platform=platform}export function getPlatform(){if(!_platform){throw new Error("No canvas platform registered. "+'Import "ppu-ocv" (Node), "ppu-ocv/web" (browser), '+'"ppu-ocv/canvas" (Node canvas-only), or "ppu-ocv/canvas-web" (browser canvas-only) to auto-register.')}return _platform}
+let _platform=null;export function setPlatform(platform){_platform=platform}export function getPlatform(){if(!_platform){throw new Error("No canvas platform registered. "+'Import "ppu-ocv" (Node), "ppu-ocv/web" (browser), '+'"ppu-ocv/canvas" (Node canvas-only), or "ppu-ocv/canvas-web" (browser canvas-only) to auto-register.')}return _platform}export function isCanvasLike(value){return typeof value==="object"&&value!==null&&typeof value.getContext==="function"&&typeof value.width==="number"&&typeof value.height==="number"}

package/canvas-io.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Canvas <-> ArrayBuffer conversion helpers, shared by `CanvasProcessor`'s
+ * static `prepareCanvas` / `prepareBuffer`. Kept separate so the processor
+ * class stays focused on the pixel pipeline.
+ */
+import type { CanvasLike } from "./canvas-factory.js";
+/**
+ * Convert an ArrayBuffer (image file bytes) to a CanvasLike. If the value is
+ * already a CanvasLike it is returned as-is.
+ */
+export declare function bufferToCanvas(file: ArrayBuffer): Promise<CanvasLike>;
+/**
+ * Convert a CanvasLike to an ArrayBuffer (PNG bytes). If the value is already
+ * an ArrayBuffer it is returned as-is.
+ */
+export declare function canvasToBuffer(canvas: CanvasLike): Promise<ArrayBuffer>;

package/canvas-io.js

@@ -0,0 +1 @@
+import{getPlatform,isCanvasLike}from"./canvas-factory.js";export async function bufferToCanvas(file){if(isCanvasLike(file))return file;return getPlatform().loadImage(file)}export async function canvasToBuffer(canvas){if(canvas instanceof ArrayBuffer)return canvas;if(typeof canvas.toBuffer==="function"){let buffer=canvas.toBuffer("image/png");let arrayBuffer=new ArrayBuffer(buffer.byteLength);new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));return arrayBuffer}let toBlob=canvas.toBlob;if(typeof toBlob==="function"){let blob=await new Promise((resolve,reject)=>{toBlob.call(canvas,(b)=>b?resolve(b):reject(new Error("toBlob returned null")),"image/png")});return blob.arrayBuffer()}if(typeof canvas.convertToBlob==="function"){let blob=await canvas.convertToBlob({type:"image/png"});return blob.arrayBuffer()}if(typeof canvas.toDataURL==="function"){let dataURL=canvas.toDataURL("image/png");let base64Data=dataURL.replace(/^data:image\/png;base64,/,"");let binaryString=atob(base64Data);let arrayBuffer=new ArrayBuffer(binaryString.length);let bytes=new Uint8Array(arrayBuffer);for(let i=0;i<binaryString.length;i++){bytes[i]=binaryString.charCodeAt(i)}return arrayBuffer}let ctx=canvas.getContext("2d");let imageData=ctx.getImageData(0,0,canvas.width,canvas.height);let canvasBuffer=new ArrayBuffer(imageData.data.byteLength);new Uint8Array(canvasBuffer).set(new Uint8Array(imageData.data.buffer,imageData.data.byteOffset,imageData.data.byteLength));return canvasBuffer}

package/canvas-processor.d.ts

@@ -1,14 +1,6 @@
-import type { BoundingBox } from "./index.interface.js";
 import type { CanvasLike } from "./canvas-factory.js";
-/**
- * A detected region returned by {@link CanvasProcessor.findRegions}.
- */
-export interface DetectedRegion {
-    /** Axis-aligned bounding box of the region (x1/y1 are exclusive). */
-    bbox: BoundingBox;
-    /** Number of foreground pixels in the region. */
-    area: number;
-}
+import type { DetectedRegion, FindRegionsOptions } from "./canvas-regions.js";
+export type { DetectedRegion } from "./canvas-regions.js";
 /**
  * Canvas-native image processing with no OpenCV dependency.
  *
@@ -175,17 +167,7 @@ export declare class CanvasProcessor {
      * });
      * ```
      */
-    findRegions(options?: {
-        foreground?: "light" | "dark";
-        thresh?: number;
-        minArea?: number;
-        maxArea?: number;
-        padding?: {
-            vertical?: number;
-            horizontal?: number;
-        };
-        scale?: number;
-    }): DetectedRegion[];
+    findRegions(options?: FindRegionsOptions): DetectedRegion[];
     /**
      * Return the current canvas state.
      */

package/canvas-processor.js

@@ -1 +1 @@
-export class CanvasProcessor{_canvas;constructor(source){this._canvas=source}get width(){return this._canvas.width}get height(){return this._canvas.height}resize(options){const{width,height}=options;let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").drawImage(this._canvas,0,0,width,height);this._canvas=dst;return this}grayscale(){const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){let luma=Math.round(0.299*(d[i]??0)+0.587*(d[i+1]??0)+0.114*(d[i+2]??0));d[i]=luma;d[i+1]=luma;d[i+2]=luma}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}convert(options={}){const{alpha=1,beta=0}=options;if(alpha===1&&beta===0)return this;const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){d[i]=Math.round((d[i]??0)*alpha+beta);d[i+1]=Math.round((d[i+1]??0)*alpha+beta);d[i+2]=Math.round((d[i+2]??0)*alpha+beta)}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}invert(){const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){d[i]=255-(d[i]??0);d[i+1]=255-(d[i+1]??0);d[i+2]=255-(d[i+2]??0)}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}threshold(options={}){const{thresh=127,maxValue=255}=options;const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){let luma=d[i]===d[i+1]&&d[i+1]===d[i+2]?d[i]??0:Math.round(0.299*(d[i]??0)+0.587*(d[i+1]??0)+0.114*(d[i+2]??0));let val=luma>thresh?maxValue:0;d[i]=val;d[i+1]=val;d[i+2]=val}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}border(options={}){const{size=10,color="white"}=options;const{width,height}=this._canvas;let dst=getPlatform().createCanvas(width+size*2,height+size*2);let ctx=dst.getContext("2d");ctx.fillStyle=color;ctx.fillRect(0,0,dst.width,dst.height);ctx.drawImage(this._canvas,size,size);this._canvas=dst;return this}rotate(options){const{angle,cx=this._canvas.width/2,cy=this._canvas.height/2}=options;if(angle===0)return this;const{width,height}=this._canvas;let dst=getPlatform().createCanvas(width,height);let ctx=dst.getContext("2d");ctx.save();ctx.translate(cx,cy);ctx.rotate(-angle*Math.PI/180);ctx.drawImage(this._canvas,-cx,-cy);ctx.restore();this._canvas=dst;return this}findRegions(options={}){const{foreground="light",thresh=127,minArea=1,maxArea=1/0,padding,scale=1}=options;const{width,height}=this._canvas;let data=this._canvas.getContext("2d").getImageData(0,0,width,height).data;let visited=new Uint8Array(width*height);let regions=[];let neighbours=[[-1,-1],[0,-1],[1,-1],[-1,0],[1,0],[-1,1],[0,1],[1,1]];let isForeground=(pixelIdx)=>{let r=data[pixelIdx]??0;return foreground==="light"?r>thresh:r<=thresh};for(let startY=0;startY<height;startY++){for(let startX=0;startX<width;startX++){let startFlat=startY*width+startX;if(visited[startFlat])continue;visited[startFlat]=1;if(!isForeground(startFlat*4))continue;let stack=[startFlat];let minX=startX,maxX=startX;let minY=startY,maxY=startY;let area=0;while(stack.length>0){let flat=stack.pop();if(flat===undefined)break;area++;let x=flat%width;let y=(flat-x)/width;if(x<minX)minX=x;else if(x>maxX)maxX=x;if(y<minY)minY=y;else if(y>maxY)maxY=y;for(const[dx,dy]of neighbours){let nx=x+dx;let ny=y+dy;if(nx<0||nx>=width||ny<0||ny>=height)continue;let nFlat=ny*width+nx;if(visited[nFlat])continue;visited[nFlat]=1;if(isForeground(nFlat*4))stack.push(nFlat)}}if(area>=minArea&&area<=maxArea){let x0=minX;let y0=minY;let x1=maxX+1;let y1=maxY+1;if(padding){let bboxH=y1-y0;let vPad=Math.round(bboxH*(padding.vertical??0));let hPad=Math.round(bboxH*(padding.horizontal??0));x0=Math.max(0,x0-hPad);y0=Math.max(0,y0-vPad);x1=Math.min(width,x1+hPad);y1=Math.min(height,y1+vPad)}if(scale!==1){x0=Math.max(0,Math.round(x0*scale));y0=Math.max(0,Math.round(y0*scale));x1=Math.round(x1*scale);y1=Math.round(y1*scale)}regions.push({bbox:{x0,y0,x1,y1},area})}}}return regions}toCanvas(){return this._canvas}static async prepareCanvas(file){if(getPlatform().isCanvas(file))return file;return getPlatform().loadImage(file)}static async prepareBuffer(canvas){if(canvas instanceof ArrayBuffer)return canvas;if(typeof canvas.toBuffer==="function"){let buffer=canvas.toBuffer("image/png");let arrayBuffer=new ArrayBuffer(buffer.byteLength);new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));return arrayBuffer}if(typeof canvas.toDataURL==="function"){let dataURL=canvas.toDataURL("image/png");let base64Data=dataURL.replace(/^data:image\/png;base64,/,"");let binaryString=atob(base64Data);let arrayBuffer=new ArrayBuffer(binaryString.length);let bytes=new Uint8Array(arrayBuffer);for(let i=0;i<binaryString.length;i++){bytes[i]=binaryString.charCodeAt(i)}return arrayBuffer}let ctx=canvas.getContext("2d");let imageData=ctx.getImageData(0,0,canvas.width,canvas.height);let canvasBuffer=new ArrayBuffer(imageData.data.byteLength);new Uint8Array(canvasBuffer).set(new Uint8Array(imageData.data.buffer,imageData.data.byteOffset,imageData.data.byteLength));return canvasBuffer}}import{getPlatform}from"./canvas-factory.js";
+export class CanvasProcessor{_canvas;constructor(source){this._canvas=source}get width(){return this._canvas.width}get height(){return this._canvas.height}resize(options){const{width,height}=options;let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").drawImage(this._canvas,0,0,width,height);this._canvas=dst;return this}grayscale(){const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){let luma=Math.round(0.299*(d[i]??0)+0.587*(d[i+1]??0)+0.114*(d[i+2]??0));d[i]=luma;d[i+1]=luma;d[i+2]=luma}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}convert(options={}){const{alpha=1,beta=0}=options;if(alpha===1&&beta===0)return this;const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){d[i]=Math.round((d[i]??0)*alpha+beta);d[i+1]=Math.round((d[i+1]??0)*alpha+beta);d[i+2]=Math.round((d[i+2]??0)*alpha+beta)}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}invert(){const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){d[i]=255-(d[i]??0);d[i+1]=255-(d[i+1]??0);d[i+2]=255-(d[i+2]??0)}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}threshold(options={}){const{thresh=127,maxValue=255}=options;const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){let luma=d[i]===d[i+1]&&d[i+1]===d[i+2]?d[i]??0:Math.round(0.299*(d[i]??0)+0.587*(d[i+1]??0)+0.114*(d[i+2]??0));let val=luma>thresh?maxValue:0;d[i]=val;d[i+1]=val;d[i+2]=val}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}border(options={}){const{size=10,color="white"}=options;const{width,height}=this._canvas;let dst=getPlatform().createCanvas(width+size*2,height+size*2);let ctx=dst.getContext("2d");ctx.fillStyle=color;ctx.fillRect(0,0,dst.width,dst.height);ctx.drawImage(this._canvas,size,size);this._canvas=dst;return this}rotate(options){const{angle,cx=this._canvas.width/2,cy=this._canvas.height/2}=options;if(angle===0)return this;const{width,height}=this._canvas;let dst=getPlatform().createCanvas(width,height);let ctx=dst.getContext("2d");ctx.save();ctx.translate(cx,cy);ctx.rotate(-angle*Math.PI/180);ctx.drawImage(this._canvas,-cx,-cy);ctx.restore();this._canvas=dst;return this}findRegions(options={}){const{width,height}=this._canvas;let data=this._canvas.getContext("2d").getImageData(0,0,width,height).data;return detectRegions(data,width,height,options)}toCanvas(){return this._canvas}static async prepareCanvas(file){return bufferToCanvas(file)}static async prepareBuffer(canvas){return canvasToBuffer(canvas)}}import{getPlatform}from"./canvas-factory.js";import{bufferToCanvas,canvasToBuffer}from"./canvas-io.js";import{detectRegions}from"./canvas-regions.js";

package/canvas-regions.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Canvas-native region detection: 8-connected flood-fill bounding-box
+ * extraction on a binary image's raw RGBA pixels. Extracted from
+ * `CanvasProcessor.findRegions` so the processor stays a thin wrapper over this
+ * pure algorithm.
+ */
+import type { BoundingBox } from "./index.interface.js";
+/** A detected region: its bounding box and foreground-pixel count. */
+export type DetectedRegion = {
+    /** Axis-aligned bounding box of the region (x1/y1 are exclusive). */
+    bbox: BoundingBox;
+    /** Number of foreground pixels in the region. */
+    area: number;
+};
+/** Options for {@link detectRegions} / `CanvasProcessor.findRegions`. */
+export type FindRegionsOptions = {
+    /** Which pixels count as foreground relative to `thresh`. @default "light" */
+    foreground?: "light" | "dark";
+    /** Grayscale threshold separating foreground from background. @default 127 */
+    thresh?: number;
+    /** Discard regions with fewer than this many pixels. @default 1 */
+    minArea?: number;
+    /** Discard regions with more than this many pixels. @default Infinity */
+    maxArea?: number;
+    /** Padding per box as a fraction of its height (vertical/horizontal). */
+    padding?: {
+        vertical?: number;
+        horizontal?: number;
+    };
+    /** Multiply all bbox coordinates by this factor after padding. @default 1 */
+    scale?: number;
+};
+/**
+ * Detect foreground regions in raw RGBA pixel data via 8-connected flood fill.
+ *
+ * @param data - RGBA pixel data (`width * height * 4` bytes).
+ * @param width - Image width in pixels.
+ * @param height - Image height in pixels.
+ * @param options - See {@link FindRegionsOptions}.
+ */
+export declare function detectRegions(data: Uint8ClampedArray, width: number, height: number, options?: FindRegionsOptions): DetectedRegion[];

package/canvas-regions.js

@@ -0,0 +1 @@
+export function detectRegions(data,width,height,options={}){const{foreground="light",thresh=127,minArea=1,maxArea=1/0,padding,scale=1}=options;let visited=new Uint8Array(width*height);let regions=[];let neighbours=[[-1,-1],[0,-1],[1,-1],[-1,0],[1,0],[-1,1],[0,1],[1,1]];let isForeground=(pixelIdx)=>{let r=data[pixelIdx]??0;return foreground==="light"?r>thresh:r<=thresh};for(let startY=0;startY<height;startY++){for(let startX=0;startX<width;startX++){let startFlat=startY*width+startX;if(visited[startFlat])continue;visited[startFlat]=1;if(!isForeground(startFlat*4))continue;let stack=[startFlat];let minX=startX,maxX=startX;let minY=startY,maxY=startY;let area=0;while(stack.length>0){let flat=stack.pop();if(flat===undefined)break;area++;let x=flat%width;let y=(flat-x)/width;if(x<minX)minX=x;else if(x>maxX)maxX=x;if(y<minY)minY=y;else if(y>maxY)maxY=y;for(const[dx,dy]of neighbours){let nx=x+dx;let ny=y+dy;if(nx<0||nx>=width||ny<0||ny>=height)continue;let nFlat=ny*width+nx;if(visited[nFlat])continue;visited[nFlat]=1;if(isForeground(nFlat*4))stack.push(nFlat)}}if(area>=minArea&&area<=maxArea){let x0=minX;let y0=minY;let x1=maxX+1;let y1=maxY+1;if(padding){let bboxH=y1-y0;let vPad=Math.round(bboxH*(padding.vertical??0));let hPad=Math.round(bboxH*(padding.horizontal??0));x0=Math.max(0,x0-hPad);y0=Math.max(0,y0-vPad);x1=Math.min(width,x1+hPad);y1=Math.min(height,y1+vPad)}if(scale!==1){x0=Math.max(0,Math.round(x0*scale));y0=Math.max(0,Math.round(y0*scale));x1=Math.round(x1*scale);y1=Math.round(y1*scale)}regions.push({bbox:{x0,y0,x1,y1},area})}}}return regions}

package/canvas-toolkit.base.d.ts

@@ -1,10 +1,10 @@
 import type { BoundingBox } from "./index.interface.js";
 import type { CanvasLike, Context2DLike } from "./canvas-factory.js";
-/** Structural interface for contour-like objects with 32-bit signed integer point data. */
-export interface ContourLike {
+/** Structural type for contour-like objects with 32-bit signed integer point data. */
+export type ContourLike = {
     /** Flat `[x0, y0, x1, y1, ...]` point array. Matches `cv.Mat.data32S` for contour Mats. */
     data32S: Int32Array | number[];
-}
+};
 /**
  * Cross-platform base class for canvas manipulation utilities.
  * Contains only methods that work in both Node and browser environments.

package/contours.d.ts

@@ -2,12 +2,12 @@ import type { CanvasLike } from "./canvas-factory.js";
 import { cv } from "./cv-provider.js";
 import type { BoundingBox, Points } from "./index.interface.js";
 /** Options for configuring contour detection. */
-export interface ContoursOptions {
+export type ContoursOptions = {
     /** The contour retrieval mode. (cv.RETR_...) */
     mode: cv.RetrievalModes;
     /** The contour approximation method. (cv.CHAIN_...) */
     method: cv.ContourApproximationModes;
-}
+};
 /**
  * Wrapper around OpenCV's `findContours` that provides convenient accessors
  * for iterating, filtering, and analyzing contours in a binary image.

package/deskew-angles.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Skew-angle estimators used by {@link DeskewService}. Pure helpers extracted
+ * from `deskew.ts`: each takes detected text regions (or a binary Mat) and
+ * returns candidate angles with weights, plus a consensus reducer. Methods that
+ * log accept a `log` callback so they stay free of service state.
+ */
+import { cv } from "./cv-provider.js";
+/** A candidate skew angle with its confidence weight. */
+export type WeightedAngle = {
+    angle: number;
+    weight: number;
+};
+/** A detected text region: its contour and basic shape metrics. */
+export type TextRegion = {
+    contour: cv.Mat;
+    area: number;
+    aspectRatio: number;
+};
+/** Least-squares slope of a point set, as an angle in degrees clamped to ±45°. */
+export declare function calculateLineAngle(points: Array<{
+    x: number;
+    y: number;
+}>): number;
+/** Angles from each region's minimum-area rectangle, weighted by area and aspect. */
+export declare function calculateMinRectAngles(textRegions: TextRegion[]): WeightedAngle[];
+/** Angles from each region's text baseline (line fit through bottom points). */
+export declare function calculateBaselineAngles(textRegions: TextRegion[]): WeightedAngle[];
+/** Angles from a probabilistic Hough line transform of the morphed binary Mat. */
+export declare function calculateHoughAngles(mat: cv.Mat, minAngle: number, maxAngle: number, log: (message: string) => void): WeightedAngle[];
+/** Robust consensus over all candidate angles: IQR outlier rejection + weighted mean. */
+export declare function calculateConsensusAngle(angles: Array<WeightedAngle & {
+    method: string;
+}>, minAngle: number, maxAngle: number, log: (message: string) => void): number;

package/deskew-angles.js

@@ -0,0 +1 @@
+import{cv}from"./cv-provider.js";export function calculateLineAngle(points){if(points.length<2)return 0;let n=points.length;let sumX=points.reduce((sum,p)=>sum+p.x,0);let sumY=points.reduce((sum,p)=>sum+p.y,0);let sumXY=points.reduce((sum,p)=>sum+p.x*p.y,0);let sumXX=points.reduce((sum,p)=>sum+p.x*p.x,0);let denominator=n*sumXX-sumX*sumX;if(Math.abs(denominator)<0.0000000001)return 0;let slope=(n*sumXY-sumX*sumY)/denominator;let angle=Math.atan(slope)*180/Math.PI;if(angle>45)angle-=90;if(angle<-45)angle+=90;return angle}export function calculateMinRectAngles(textRegions){let angles=[];for(let region of textRegions){try{let minRect=cv.minAreaRect(region.contour);if(!minRect)continue;let angle=minRect.angle;if(angle>45){angle-=90}else if(angle<-45){angle+=90}let areaWeight=Math.log(region.area+1);let aspectWeight=Math.min(region.aspectRatio,1/region.aspectRatio)*2;let weight=areaWeight*aspectWeight;angles.push({angle,weight})}catch{continue}}return angles}export function calculateBaselineAngles(textRegions){let angles=[];for(let region of textRegions){try{let points=region.contour.data32S;if(!points||points.length<8)continue;let bottomPoints=[];for(let i=0;i<points.length;i+=2){let x=points[i];let y=points[i+1];if(x!==undefined&&y!==undefined){bottomPoints.push({x,y})}}if(bottomPoints.length<3)continue;bottomPoints.sort((a,b)=>a.x-b.x);let segments=3;let segmentSize=Math.floor(bottomPoints.length/segments);let baselinePoints=[];for(let seg=0;seg<segments;seg++){let start=seg*segmentSize;let end=seg===segments-1?bottomPoints.length:(seg+1)*segmentSize;let segmentPoints=bottomPoints.slice(start,end);if(segmentPoints.length>0){let maxYPoint=segmentPoints.reduce((max,point)=>point.y>max.y?point:max);baselinePoints.push(maxYPoint)}}if(baselinePoints.length>=2){let angle=calculateLineAngle(baselinePoints);let weight=region.area*Math.min(region.aspectRatio,1/region.aspectRatio);angles.push({angle,weight})}}catch{continue}}return angles}export function calculateHoughAngles(mat,minAngle,maxAngle,log){let angles=[];try{let kernel=cv.getStructuringElement(cv.MORPH_RECT,new cv.Size(3,1));let morphed=new cv.Mat;cv.morphologyEx(mat,morphed,cv.MORPH_CLOSE,kernel);let lines=new cv.Mat;cv.HoughLinesP(morphed,lines,1,Math.PI/180,30,50,10);for(let i=0;i<lines.rows;i++){let line=lines.data32S.subarray(i*4,(i+1)*4);const[x1,y1,x2,y2]=line;if(x1!==undefined&&y1!==undefined&&x2!==undefined&&y2!==undefined){let dx=x2-x1;let dy=y2-y1;if(Math.abs(dx)>1){let angle=Math.atan2(dy,dx)*180/Math.PI;if(angle>45)angle-=90;if(angle<-45)angle+=90;if(angle>=minAngle&&angle<=maxAngle){let lineLength=Math.sqrt(dx*dx+dy*dy);angles.push({angle,weight:lineLength})}}}}morphed.delete();lines.delete();kernel.delete()}catch{log("Hough transform failed, skipping this method.")}return angles}export function calculateConsensusAngle(angles,minAngle,maxAngle,log){if(angles.length===0)return 0;let sortedAngles=[...angles].sort((a,b)=>a.angle-b.angle);let q1Index=Math.floor(sortedAngles.length*0.25);let q3Index=Math.floor(sortedAngles.length*0.75);let q1=sortedAngles[q1Index]?.angle||0;let q3=sortedAngles[q3Index]?.angle||0;let iqr=q3-q1;let lowerBound=q1-1.5*iqr;let upperBound=q3+1.5*iqr;let filteredAngles=angles.filter((a)=>a.angle>=lowerBound&&a.angle<=upperBound&&a.angle>=minAngle&&a.angle<=maxAngle);if(filteredAngles.length===0){log("All angles filtered out as outliers, using median of original set.");let medianIndex=Math.floor(sortedAngles.length/2);return sortedAngles[medianIndex]?.angle||0}let totalWeight=filteredAngles.reduce((sum,a)=>sum+a.weight,0);if(totalWeight===0){let average=filteredAngles.reduce((sum,a)=>sum+a.angle,0)/filteredAngles.length;return average}let weightedSum=filteredAngles.reduce((sum,a)=>sum+a.angle*a.weight,0);let weightedAverage=weightedSum/totalWeight;let methodCounts=filteredAngles.reduce((counts,a)=>{counts[a.method]=(counts[a.method]||0)+1;return counts},{});log(`Angle methods used: ${Object.entries(methodCounts).map(([method,count])=>`${method}:${count}`).join(", ")}`);return Math.max(minAngle,Math.min(maxAngle,weightedAverage))}

package/deskew.d.ts

@@ -2,7 +2,7 @@ import type { CanvasLike } from "./canvas-factory.js";
 /**
  * Options for configuring the deskew service
  */
-export interface DeskewOptions {
+export type DeskewOptions = {
     /**
      * Enable detailed logging of each processing step.
      * @default false
@@ -14,7 +14,7 @@ export interface DeskewOptions {
      * @default 20
      */
     minimumAreaThreshold?: number;
-}
+};
 /**
  * Service for calculating the skew angle of an image containing text.
  *
@@ -64,9 +64,4 @@ export declare class DeskewService {
      * @returns A new canvas with the deskewed image
      */
     deskewImage(canvas: CanvasLike): Promise<CanvasLike>;
-    private calculateMinRectAngles;
-    private calculateBaselineAngles;
-    private calculateHoughAngles;
-    private calculateLineAngle;
-    private calculateConsensusAngle;
 }

package/deskew.js

@@ -1 +1 @@
-export class DeskewService{verbose;minimumAreaThreshold;constructor(options={}){this.verbose=options.verbose??false;this.minimumAreaThreshold=options.minimumAreaThreshold??20}log(message){if(this.verbose){console.log(`[DeskewService] ${message}`)}}async calculateSkewAngle(canvas){let processor=new ImageProcessor(canvas);let mat=processor.grayscale().threshold({lower:0,upper:255,type:cv.THRESH_BINARY+cv.THRESH_OTSU}).toMat();let contours=new Contours(mat,{mode:cv.RETR_LIST,method:cv.CHAIN_APPROX_SIMPLE});processor.destroy();let minAngle=-20;let maxAngle=20;let minArea=this.minimumAreaThreshold;let textRegions=[];contours.iterate((contour)=>{let rect=contours.getRect(contour);let area=rect.width*rect.height;if(area<minArea)return;let aspectRatio=rect.width/rect.height;if(aspectRatio>0.2&&aspectRatio<10){textRegions.push({rect,contour,area,aspectRatio})}});if(textRegions.length===0){this.log("No valid text regions found for skew calculation.");contours.destroy();return 0}let averageHeight=textRegions.reduce((sum,region)=>sum+region.rect.height,0)/textRegions.length;let filteredRegions=textRegions.filter((region)=>{return region.rect.height<=averageHeight*1.5});this.log(`Found ${filteredRegions.length} text regions for skew analysis.`);let minRectAngles=this.calculateMinRectAngles(filteredRegions,contours);let baselineAngles=this.calculateBaselineAngles(filteredRegions);let houghAngles=this.calculateHoughAngles(mat,minAngle,maxAngle);contours.destroy();let allAngles=[...minRectAngles.map((a)=>({...a,method:"minRect"})),...baselineAngles.map((a)=>({...a,method:"baseline"})),...houghAngles.map((a)=>({...a,method:"hough"}))];if(allAngles.length===0){this.log("No angles detected from any method.");return 0}let consensusAngle=this.calculateConsensusAngle(allAngles,minAngle,maxAngle);this.log(`Calculated skew angle: ${consensusAngle.toFixed(3)}° (from ${allAngles.length} measurements)`);return consensusAngle}async deskewImage(canvas){this.log("Starting image deskewing process");let angle=await this.calculateSkewAngle(canvas);this.log(`Detected skew angle: ${angle.toFixed(2)}°. Rotating image by ${-angle.toFixed(2)}°...`);let processor=new ImageProcessor(canvas);try{let rotatedCanvas=processor.rotate({angle}).toCanvas();return rotatedCanvas}finally{processor.destroy()}}calculateMinRectAngles(textRegions,_contours){let angles=[];for(let region of textRegions){try{let minRect=cv.minAreaRect(region.contour);if(!minRect)continue;let angle=minRect.angle;if(angle>45){angle-=90}else if(angle<-45){angle+=90}let areaWeight=Math.log(region.area+1);let aspectWeight=Math.min(region.aspectRatio,1/region.aspectRatio)*2;let weight=areaWeight*aspectWeight;angles.push({angle,weight})}catch{continue}}return angles}calculateBaselineAngles(textRegions){let angles=[];for(let region of textRegions){try{let points=region.contour.data32S;if(!points||points.length<8)continue;let bottomPoints=[];for(let i=0;i<points.length;i+=2){let x=points[i];let y=points[i+1];if(x!==undefined&&y!==undefined){bottomPoints.push({x,y})}}if(bottomPoints.length<3)continue;bottomPoints.sort((a,b)=>a.x-b.x);let segments=3;let segmentSize=Math.floor(bottomPoints.length/segments);let baselinePoints=[];for(let seg=0;seg<segments;seg++){let start=seg*segmentSize;let end=seg===segments-1?bottomPoints.length:(seg+1)*segmentSize;let segmentPoints=bottomPoints.slice(start,end);if(segmentPoints.length>0){let maxYPoint=segmentPoints.reduce((max,point)=>point.y>max.y?point:max);baselinePoints.push(maxYPoint)}}if(baselinePoints.length>=2){let angle=this.calculateLineAngle(baselinePoints);let weight=region.area*Math.min(region.aspectRatio,1/region.aspectRatio);angles.push({angle,weight})}}catch{continue}}return angles}calculateHoughAngles(mat,minAngle,maxAngle){let angles=[];try{let kernel=cv.getStructuringElement(cv.MORPH_RECT,new cv.Size(3,1));let morphed=new cv.Mat;cv.morphologyEx(mat,morphed,cv.MORPH_CLOSE,kernel);let lines=new cv.Mat;cv.HoughLinesP(morphed,lines,1,Math.PI/180,30,50,10);for(let i=0;i<lines.rows;i++){let line=lines.data32S.subarray(i*4,(i+1)*4);const[x1,y1,x2,y2]=line;if(x1!==undefined&&y1!==undefined&&x2!==undefined&&y2!==undefined){let dx=x2-x1;let dy=y2-y1;if(Math.abs(dx)>1){let angle=Math.atan2(dy,dx)*180/Math.PI;if(angle>45)angle-=90;if(angle<-45)angle+=90;if(angle>=minAngle&&angle<=maxAngle){let lineLength=Math.sqrt(dx*dx+dy*dy);angles.push({angle,weight:lineLength})}}}}morphed.delete();lines.delete();kernel.delete()}catch{this.log("Hough transform failed, skipping this method.")}return angles}calculateLineAngle(points){if(points.length<2)return 0;let n=points.length;let sumX=points.reduce((sum,p)=>sum+p.x,0);let sumY=points.reduce((sum,p)=>sum+p.y,0);let sumXY=points.reduce((sum,p)=>sum+p.x*p.y,0);let sumXX=points.reduce((sum,p)=>sum+p.x*p.x,0);let denominator=n*sumXX-sumX*sumX;if(Math.abs(denominator)<0.0000000001)return 0;let slope=(n*sumXY-sumX*sumY)/denominator;let angle=Math.atan(slope)*180/Math.PI;if(angle>45)angle-=90;if(angle<-45)angle+=90;return angle}calculateConsensusAngle(angles,minAngle,maxAngle){if(angles.length===0)return 0;let sortedAngles=[...angles].sort((a,b)=>a.angle-b.angle);let q1Index=Math.floor(sortedAngles.length*0.25);let q3Index=Math.floor(sortedAngles.length*0.75);let q1=sortedAngles[q1Index]?.angle||0;let q3=sortedAngles[q3Index]?.angle||0;let iqr=q3-q1;let lowerBound=q1-1.5*iqr;let upperBound=q3+1.5*iqr;let filteredAngles=angles.filter((a)=>a.angle>=lowerBound&&a.angle<=upperBound&&a.angle>=minAngle&&a.angle<=maxAngle);if(filteredAngles.length===0){this.log("All angles filtered out as outliers, using median of original set.");let medianIndex=Math.floor(sortedAngles.length/2);return sortedAngles[medianIndex]?.angle||0}let totalWeight=filteredAngles.reduce((sum,a)=>sum+a.weight,0);if(totalWeight===0){let average=filteredAngles.reduce((sum,a)=>sum+a.angle,0)/filteredAngles.length;return average}let weightedSum=filteredAngles.reduce((sum,a)=>sum+a.angle*a.weight,0);let weightedAverage=weightedSum/totalWeight;let methodCounts=filteredAngles.reduce((counts,a)=>{counts[a.method]=(counts[a.method]||0)+1;return counts},{});this.log(`Angle methods used: ${Object.entries(methodCounts).map(([method,count])=>`${method}:${count}`).join(", ")}`);return Math.max(minAngle,Math.min(maxAngle,weightedAverage))}}import{Contours}from"./contours.js";import{cv}from"./cv-provider.js";import{ImageProcessor}from"./image-processor.js";
+export class DeskewService{verbose;minimumAreaThreshold;constructor(options={}){this.verbose=options.verbose??false;this.minimumAreaThreshold=options.minimumAreaThreshold??20}log(message){if(this.verbose){console.log(`[DeskewService] ${message}`)}}async calculateSkewAngle(canvas){let processor=new ImageProcessor(canvas);let mat=processor.grayscale().threshold({lower:0,upper:255,type:cv.THRESH_BINARY+cv.THRESH_OTSU}).toMat();let contours=new Contours(mat,{mode:cv.RETR_LIST,method:cv.CHAIN_APPROX_SIMPLE});processor.destroy();let minAngle=-20;let maxAngle=20;let minArea=this.minimumAreaThreshold;let textRegions=[];contours.iterate((contour)=>{let rect=contours.getRect(contour);let area=rect.width*rect.height;if(area<minArea)return;let aspectRatio=rect.width/rect.height;if(aspectRatio>0.2&&aspectRatio<10){textRegions.push({rect,contour,area,aspectRatio})}});if(textRegions.length===0){this.log("No valid text regions found for skew calculation.");contours.destroy();return 0}let averageHeight=textRegions.reduce((sum,region)=>sum+region.rect.height,0)/textRegions.length;let filteredRegions=textRegions.filter((region)=>{return region.rect.height<=averageHeight*1.5});this.log(`Found ${filteredRegions.length} text regions for skew analysis.`);let minRectAngles=calculateMinRectAngles(filteredRegions);let baselineAngles=calculateBaselineAngles(filteredRegions);let houghAngles=calculateHoughAngles(mat,minAngle,maxAngle,(m)=>this.log(m));contours.destroy();let allAngles=[...minRectAngles.map((a)=>({...a,method:"minRect"})),...baselineAngles.map((a)=>({...a,method:"baseline"})),...houghAngles.map((a)=>({...a,method:"hough"}))];if(allAngles.length===0){this.log("No angles detected from any method.");return 0}let consensusAngle=calculateConsensusAngle(allAngles,minAngle,maxAngle,(m)=>this.log(m));this.log(`Calculated skew angle: ${consensusAngle.toFixed(3)}° (from ${allAngles.length} measurements)`);return consensusAngle}async deskewImage(canvas){this.log("Starting image deskewing process");let angle=await this.calculateSkewAngle(canvas);this.log(`Detected skew angle: ${angle.toFixed(2)}°. Rotating image by ${-angle.toFixed(2)}°...`);let processor=new ImageProcessor(canvas);try{let rotatedCanvas=processor.rotate({angle}).toCanvas();return rotatedCanvas}finally{processor.destroy()}}}import{Contours}from"./contours.js";import{cv}from"./cv-provider.js";import{calculateBaselineAngles,calculateConsensusAngle,calculateHoughAngles,calculateMinRectAngles}from"./deskew-angles.js";import{ImageProcessor}from"./image-processor.js";

package/image-analysis.d.ts

@@ -7,7 +7,7 @@ import type { CanvasLike } from "./canvas-factory.js";
 /**
  * Options for calculating mean Lab lightness.
  */
-export interface CalculateMeanLightnessOptions {
+export type CalculateMeanLightnessOptions = {
     /** The canvas containing the image to be processed. */
     canvas: CanvasLike;
     /** The target dimensions for analysis (resizes internally). */
@@ -15,7 +15,7 @@ export interface CalculateMeanLightnessOptions {
         width: number;
         height: number;
     };
-}
+};
 /**
  * Calculates the mean normalized lightness of an image using the L channel of the Lab color space.
  * Lightness is normalized based on the image's own maximum lightness value before averaging.

package/image-processor.d.ts

@@ -1,6 +1,6 @@
 import type { CanvasLike } from "./canvas-factory.js";
 import { cv } from "./cv-provider.js";
-import type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, ConvertOptions, DilateOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationName, OperationOptions, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions } from "./pipeline/index.js";
+import type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, ConvertOptions, DilateOptions, EqualizeOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationName, OperationOptions, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions } from "./pipeline/index.js";
 type NameWithRequiredOptions = {
     [N in OperationName]: OperationOptions<N> extends RequiredOptions ? N : never;
 }[OperationName];
@@ -83,6 +83,12 @@ export declare class ImageProcessor {
      * @param options Optional configuration for inversion
      */
     invert(options?: Partial<InvertOptions>): this;
+    /**
+     * Equalise image contrast using histogram equalization
+     * @description Usage order: (after) grayscale — input must be single-channel
+     * @param options Equalization configuration options
+     */
+    equalize(options?: Partial<EqualizeOptions>): this;
     /**
      * Canny edge detection to detect edges in the image
      * @description Usage order: (after) grayscale + blur

package/image-processor.js

@@ -1 +1 @@
-export class ImageProcessor{img;width;height;constructor(source){if(getPlatform().isCanvas(source)){let ctx=source.getContext("2d");let imageData=ctx.getImageData(0,0,source.width,source.height);this.img=cv.matFromImageData(imageData);this.width=source.width;this.height=source.height}else if(source instanceof cv.Mat){this.img=source;this.width=source.cols;this.height=source.rows}else{throw new Error("Invalid source type. Must be either Canvas or cv.Mat.")}}static async initRuntime(){return new Promise((res)=>{if(cv&&cv.Mat){res()}else{cv["onRuntimeInitialized"]=()=>{res()}}})}execute(operationName,options){let result=executeOperation(operationName,this.img,options);this.img=result.img;this.width=result.width;this.height=result.height;return this}grayscale(options){return this.execute("grayscale",options)}blur(options){return this.execute("blur",options)}threshold(options){return this.execute("threshold",options)}adaptiveThreshold(options){return this.execute("adaptiveThreshold",options)}invert(options){return this.execute("invert",options)}canny(options){return this.execute("canny",options)}dilate(options){return this.execute("dilate",options)}erode(options){return this.execute("erode",options)}border(options){return this.execute("border",options)}resize(options){return this.execute("resize",options)}rotate(options){return this.execute("rotate",options)}warp(options){return this.execute("warp",options)}convert(options){return this.execute("convert",options)}morphologicalGradient(options){return this.execute("morphologicalGradient",options)}toMat(){return this.img}toCanvas(){let platform=getPlatform();let canvas=platform.createCanvas(this.width,this.height);try{cv.imshow(canvas,this.img)}catch{let ctx=canvas.getContext("2d");if(!ctx)throw new Error("Could not get 2d context from canvas");let imgData=ctx.createImageData(this.width,this.height);if(this.img.channels()===1){let data=imgData.data;let gray=new Uint8Array(this.img.data);for(let i=0;i<gray.length;i++){data[i*4]=gray[i];data[i*4+1]=gray[i];data[i*4+2]=gray[i];data[i*4+3]=255}}else{imgData.data.set(new Uint8ClampedArray(this.img.data))}ctx.putImageData(imgData,0,0)}return canvas}destroy(){try{this.img.delete()}catch{}}}import{getPlatform}from"./canvas-factory.js";import{cv}from"./cv-provider.js";import{executeOperation}from"./pipeline/index.js";
+export class ImageProcessor{img;width;height;constructor(source){if(isCanvasLike(source)){let ctx=source.getContext("2d");let imageData=ctx.getImageData(0,0,source.width,source.height);this.img=cv.matFromImageData(imageData);this.width=source.width;this.height=source.height}else if(source instanceof cv.Mat){this.img=source;this.width=source.cols;this.height=source.rows}else{throw new Error("Invalid source type. Must be either Canvas or cv.Mat.")}}static async initRuntime(){return new Promise((res)=>{if(cv&&cv.Mat){res()}else{cv["onRuntimeInitialized"]=()=>{res()}}})}execute(operationName,options){let result=executeOperation(operationName,this.img,options);this.img=result.img;this.width=result.width;this.height=result.height;return this}grayscale(options){return this.execute("grayscale",options)}blur(options){return this.execute("blur",options)}threshold(options){return this.execute("threshold",options)}adaptiveThreshold(options){return this.execute("adaptiveThreshold",options)}invert(options){return this.execute("invert",options)}equalize(options){return this.execute("equalize",options)}canny(options){return this.execute("canny",options)}dilate(options){return this.execute("dilate",options)}erode(options){return this.execute("erode",options)}border(options){return this.execute("border",options)}resize(options){return this.execute("resize",options)}rotate(options){return this.execute("rotate",options)}warp(options){return this.execute("warp",options)}convert(options){return this.execute("convert",options)}morphologicalGradient(options){return this.execute("morphologicalGradient",options)}toMat(){return this.img}toCanvas(){let platform=getPlatform();let canvas=platform.createCanvas(this.width,this.height);try{cv.imshow(canvas,this.img)}catch{let ctx=canvas.getContext("2d");if(!ctx)throw new Error("Could not get 2d context from canvas");let imgData=ctx.createImageData(this.width,this.height);if(this.img.channels()===1){let data=imgData.data;let gray=new Uint8Array(this.img.data);for(let i=0;i<gray.length;i++){data[i*4]=gray[i];data[i*4+1]=gray[i];data[i*4+2]=gray[i];data[i*4+3]=255}}else{imgData.data.set(new Uint8ClampedArray(this.img.data))}ctx.putImageData(imgData,0,0)}return canvas}destroy(){try{this.img.delete()}catch{}}}import{getPlatform,isCanvasLike}from"./canvas-factory.js";import{cv}from"./cv-provider.js";import{executeOperation}from"./pipeline/index.js";

package/index.d.ts

@@ -13,4 +13,4 @@ export { Contours } from "./contours.js";
 export { calculateMeanGrayscaleValue, calculateMeanNormalizedLabLightness, type CalculateMeanLightnessOptions, } from "./image-analysis.js";
 export { ImageProcessor } from "./image-processor.js";
 export { DeskewService, type DeskewOptions } from "./deskew.js";
-export type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, DilateOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationFunction, OperationName, OperationOptions, OperationResult, PartialOptions, RegisteredOperations, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions, } from "./pipeline/index.js";
+export type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, DilateOptions, EqualizeOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationFunction, OperationName, OperationOptions, OperationResult, PartialOptions, RegisteredOperations, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions, } from "./pipeline/index.js";

package/index.interface.d.ts

@@ -1,12 +1,12 @@
 /** A 2D point in canvas pixel coordinates. */
-export interface Coordinate {
+export type Coordinate = {
     /** X coordinate in pixels, measured from the left edge. */
     x: number;
     /** Y coordinate in pixels, measured from the top edge. */
     y: number;
-}
+};
 /** The four corner points of an axis-aligned rectangle, e.g. a contour bounding box. */
-export interface Points {
+export type Points = {
     /** Top-left corner. */
     topLeft: Coordinate;
     /** Top-right corner. */
@@ -15,12 +15,12 @@ export interface Points {
     bottomLeft: Coordinate;
     /** Bottom-right corner. */
     bottomRight: Coordinate;
-}
+};
 /**
  * An axis-aligned bounding box with exclusive `x1` / `y1`.
  * Width is `x1 - x0`; height is `y1 - y0`.
  */
-export interface BoundingBox {
+export type BoundingBox = {
     /** Left edge, inclusive. */
     x0: number;
     /** Top edge, inclusive. */
@@ -29,4 +29,4 @@ export interface BoundingBox {
     x1: number;
     /** Bottom edge, exclusive. */
     y1: number;
-}
+};

package/index.web.d.ts

@@ -35,4 +35,4 @@ export { Contours } from "./contours.js";
 export { calculateMeanGrayscaleValue, calculateMeanNormalizedLabLightness, type CalculateMeanLightnessOptions, } from "./image-analysis.js";
 export { ImageProcessor } from "./image-processor.js";
 export { DeskewService, type DeskewOptions } from "./deskew.js";
-export type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, DilateOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationFunction, OperationName, OperationOptions, OperationResult, PartialOptions, RegisteredOperations, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions, } from "./pipeline/index.js";
+export type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, DilateOptions, EqualizeOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationFunction, OperationName, OperationOptions, OperationResult, PartialOptions, RegisteredOperations, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions, } from "./pipeline/index.js";

package/operations/adaptive-threshold.d.ts

@@ -1,7 +1,7 @@
 import { cv } from "../cv-provider.js";
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 /** Options for the adaptive threshold operation. */
-export interface AdaptiveThresholdOptions extends PartialOptions {
+export type AdaptiveThresholdOptions = PartialOptions & {
     /** Upper threshold value (0-255) */
     upper: number;
     /** Adaptive threshold method (cv.ADAPTIVE_THRESH_...) */
@@ -12,6 +12,6 @@ export interface AdaptiveThresholdOptions extends PartialOptions {
     size: number;
     /** Constant subtracted from the mean or weighted mean */
     constant: number;
-}
+};
 /** Apply adaptive thresholding to convert a grayscale image to binary. */
 export declare function adaptiveThreshold(img: cv.Mat, options: AdaptiveThresholdOptions): OperationResult;

package/operations/blur.d.ts

@@ -1,11 +1,11 @@
 import { cv } from "../cv-provider.js";
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 /** Options for the Gaussian blur operation. */
-export interface BlurOptions extends PartialOptions {
+export type BlurOptions = PartialOptions & {
     /** Size of the blur [x, y] */
     size: [number, number];
     /** Gaussian kernel standard deviation on x axis */
     sigma: number;
-}
+};
 /** Apply Gaussian blur to reduce noise. */
 export declare function blur(img: cv.Mat, options: BlurOptions): OperationResult;

package/operations/border.d.ts

@@ -1,13 +1,13 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for adding a constant-color border around the image. */
-export interface BorderOptions extends PartialOptions {
+export type BorderOptions = PartialOptions & {
     /** Size of the border in pixels */
     size: number;
     /** Border type (e.g., cv.BORDER_CONSTANT) */
     borderType: cv.BorderTypes;
     /** Border color in [B, G, R, A] format */
     borderColor: [cv.int, cv.int, cv.int, cv.int];
-}
+};
 /** Add a uniform border around the image using `cv.copyMakeBorder`. */
 export declare function border(img: cv.Mat, options: BorderOptions): OperationResult;

package/operations/canny.d.ts

@@ -1,11 +1,11 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the Canny edge-detection operation. */
-export interface CannyOptions extends PartialOptions {
+export type CannyOptions = PartialOptions & {
     /** Lower threshold for the hysteresis procedure (0-255) */
     lower: number;
     /** Upper threshold for the hysteresis procedure (0-255) */
     upper: number;
-}
+};
 /** Detect edges using the Canny algorithm. */
 export declare function canny(img: cv.Mat, options: CannyOptions): OperationResult;

package/operations/convert.d.ts

@@ -1,9 +1,9 @@
 import type { OperationResult, RequiredOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for converting a Mat to a different depth/channel type. */
-export interface ConvertOptions extends RequiredOptions {
+export type ConvertOptions = RequiredOptions & {
     /** Desired matrix type (cv.CV_...) if negative, it will be the same as input */
     rtype: number;
-}
+};
 /** Convert the image matrix to a new type via `Mat.convertTo`. */
 export declare function convert(img: cv.Mat, options: ConvertOptions): OperationResult;

package/operations/dilate.d.ts

@@ -1,11 +1,11 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the morphological dilation operation. */
-export interface DilateOptions extends PartialOptions {
+export type DilateOptions = PartialOptions & {
     /** Size of the block [x, y] */
     size: [number, number];
     /** Number of iterations for the dilation operation */
     iter: number;
-}
+};
 /** Dilate the image to expand foreground regions. */
 export declare function dilate(img: cv.Mat, options: DilateOptions): OperationResult;

package/operations/equalize.d.ts

@@ -0,0 +1,34 @@
+import type { OperationResult, PartialOptions } from "../pipeline/types.js";
+import { cv } from "../cv-provider.js";
+/** Options for the histogram equalization operation. */
+export type EqualizeOptions = PartialOptions & {
+    /**
+     * Equalization algorithm to use.
+     * - `"clahe"` (default) — Contrast Limited Adaptive Histogram Equalization;
+     *   preserves local contrast and avoids over-amplification in bright regions.
+     * - `"global"` — Standard global histogram equalization via `cv.equalizeHist`;
+     *   faster but may blow out highlights.
+     */
+    method: "clahe" | "global";
+    /**
+     * CLAHE only — clip limit for contrast limiting (default `2.0`).
+     * Higher values allow more contrast; lower values are closer to global equalization.
+     */
+    clipLimit: number;
+    /**
+     * CLAHE only — tile grid size in pixels (default `8` → 8×8 tiles).
+     * The image is divided into this many tiles in each dimension.
+     */
+    tileGridSize: number;
+};
+/**
+ * Equalise histogram contrast on a single-channel (grayscale) image.
+ *
+ * Supports two algorithms selectable via {@link EqualizeOptions.method}:
+ * - `"clahe"` (default) — locally adaptive, clip-limited equalization.
+ * - `"global"` — standard whole-image histogram spreading.
+ *
+ * Input `img` must be an 8-bit single-channel `cv.Mat` (run `.grayscale()` first).
+ * The input Mat is deleted by this operation.
+ */
+export declare function equalize(img: cv.Mat, options: EqualizeOptions): OperationResult;

package/operations/equalize.js

@@ -0,0 +1 @@
+import{cv}from"../cv-provider.js";import{registry}from"../pipeline/registry.js";function defaultOptions(){return{method:"clahe",clipLimit:2,tileGridSize:8}}export function equalize(img,options){let dst=new cv.Mat;if(options.method==="global"){cv.equalizeHist(img,dst)}else{let tileSize=new cv.Size(options.tileGridSize,options.tileGridSize);let clahe=new cv.CLAHE(options.clipLimit,tileSize);clahe.apply(img,dst);clahe.delete()}img.delete();return{img:dst,width:dst.cols,height:dst.rows}}registry.register("equalize",equalize,defaultOptions);

package/operations/erode.d.ts

@@ -1,11 +1,11 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the morphological erosion operation. */
-export interface ErodeOptions extends PartialOptions {
+export type ErodeOptions = PartialOptions & {
     /** Size of the block [x, y] */
     size: [number, number];
     /** Number of iterations for the erosion operation */
     iter: number;
-}
+};
 /** Erode the image to shrink foreground regions and remove small noise. */
 export declare function erode(img: cv.Mat, options: ErodeOptions): OperationResult;

package/operations/grayscale.d.ts

@@ -1,7 +1,6 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the grayscale conversion operation (no configurable fields). */
-export interface GrayscaleOptions extends PartialOptions {
-}
+export type GrayscaleOptions = PartialOptions;
 /** Convert the image to grayscale using `COLOR_RGBA2GRAY`. */
 export declare function grayscale(img: cv.Mat, _options: GrayscaleOptions): OperationResult;

package/operations/invert.d.ts

@@ -1,7 +1,6 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the bitwise-NOT color inversion operation (no configurable fields). */
-export interface InvertOptions extends PartialOptions {
-}
+export type InvertOptions = PartialOptions;
 /** Invert all pixel values using `cv.bitwise_not`. */
 export declare function invert(img: cv.Mat, _options: InvertOptions): OperationResult;

package/operations/morphological-gradient.d.ts

@@ -1,9 +1,9 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the morphological gradient operation. */
-export interface MorphologicalGradientOptions extends PartialOptions {
+export type MorphologicalGradientOptions = PartialOptions & {
     /** Kernel size for the morphological gradient operation [x, y] */
     size: [number, number];
-}
+};
 /** Apply morphological gradient to highlight edges (dilation minus erosion). */
 export declare function morphologicalGradient(img: cv.Mat, options: MorphologicalGradientOptions): OperationResult;

package/operations/resize.d.ts

@@ -1,11 +1,11 @@
 import type { OperationResult, RequiredOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for resizing the image to exact pixel dimensions. */
-export interface ResizeOptions extends RequiredOptions {
+export type ResizeOptions = RequiredOptions & {
     /** Width of the resized image */
     width: number;
     /** Height of the resized image */
     height: number;
-}
+};
 /** Resize the image to the given width and height. */
 export declare function resize(img: cv.Mat, options: ResizeOptions): OperationResult;

package/operations/rotate.d.ts

@@ -1,11 +1,11 @@
 import type { OperationResult, RequiredOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for rotating the image around a pivot point. */
-export interface RotateOptions extends RequiredOptions {
+export type RotateOptions = RequiredOptions & {
     /** Angle of rotation in degrees (positive for counter-clockwise) */
     angle: number;
     /** Optional center of rotation. Defaults to the image center. */
     center?: cv.Point;
-}
+};
 /** Rotate the image by the given angle around its centre (or a custom pivot). */
 export declare function rotate(img: cv.Mat, options: RotateOptions): OperationResult;

package/operations/threshold.d.ts

@@ -1,13 +1,13 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the global threshold operation. */
-export interface ThresholdOptions extends PartialOptions {
+export type ThresholdOptions = PartialOptions & {
     /** Lower threshold value (0-255) */
     lower: number;
     /** Upper threshold value (0-255) */
     upper: number;
     /** Type of thresholding (cv.THRESH_...) */
     type: cv.ThresholdTypes;
-}
+};
 /** Apply a global threshold to convert a grayscale image to binary. */
 export declare function threshold(img: cv.Mat, options: ThresholdOptions): OperationResult;

package/operations/warp.d.ts

@@ -2,7 +2,7 @@ import { cv } from "../cv-provider.js";
 import type { BoundingBox, Points } from "../index.interface.js";
 import type { OperationResult, RequiredOptions } from "../pipeline/types.js";
 /** Options for the perspective warp (four-point transform) operation. */
-export interface WarpOptions extends RequiredOptions {
+export type WarpOptions = RequiredOptions & {
     /** Four points of the source image containing x and y point in
      * topLeft, topRight, bottomLeft and BottomRight.
      * Use Contours class instance to get the points
@@ -10,6 +10,6 @@ export interface WarpOptions extends RequiredOptions {
     points: Points;
     /** A destination canvas bounding box for cropping the original canvas */
     bbox: BoundingBox;
-}
+};
 /** Apply a perspective warp using four source/destination corner points. */
 export declare function warp(img: cv.Mat, options: WarpOptions): OperationResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ppu-ocv",
-  "version": "3.1.5",
+  "version": "3.2.1",
   "description": "A type-safe, modular, chainable image processing library built on top of OpenCV.js with a fluent API leveraging pipeline processing.",
   "keywords": [
     "open-cv",
@@ -43,34 +43,6 @@
       "default": "./index.canvas-web.js"
     }
   },
-  "scripts": {
-    "task": "bun scripts/task.ts",
-    "build": "bun task build",
-    "build:test": "bun task build && bun test",
-    "build:publish": "bun task build && bun task report-size && bun task publish",
-    "type-check": "bunx tsgo --noEmit",
-    "test": "bun test --parallel=$(ls tests/*.test.ts | wc -l | tr -d ' ')",
-    "lint": "oxlint",
-    "lint:fix": "oxlint --fix",
-    "fmt": "oxfmt --check",
-    "fmt:fix": "oxfmt .",
-    "demo": "bunx -y serve -l 4567 .",
-    "prepare": "husky"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "@types/uglify-js": "latest",
-    "@typescript/native-preview": "^7.0.0-dev.20260513.1",
-    "canvas": "^3.2.3",
-    "husky": "^9.1.7",
-    "lint-staged": "^17.0.4",
-    "mitata": "latest",
-    "oxfmt": "^0.49.0",
-    "oxlint": "^1.63.0",
-    "tsx": "latest",
-    "typescript": "latest",
-    "uglify-js": ">=2.4.24"
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/PT-Perkasa-Pilar-Utama/ppu-ocv.git"

package/pipeline/index.d.ts

@@ -7,6 +7,7 @@ import "../operations/canny.js";
 import "../operations/convert.js";
 import "../operations/dilate.js";
 import "../operations/erode.js";
+import "../operations/equalize.js";
 import "../operations/grayscale.js";
 import "../operations/invert.js";
 import "../operations/morphological-gradient.js";
@@ -21,6 +22,7 @@ export type { CannyOptions } from "../operations/canny.js";
 export type { ConvertOptions } from "../operations/convert.js";
 export type { DilateOptions } from "../operations/dilate.js";
 export type { ErodeOptions } from "../operations/erode.js";
+export type { EqualizeOptions } from "../operations/equalize.js";
 export type { GrayscaleOptions } from "../operations/grayscale.js";
 export type { InvertOptions } from "../operations/invert.js";
 export type { MorphologicalGradientOptions } from "../operations/morphological-gradient.js";

package/pipeline/index.js

@@ -1 +1 @@
-export{executeOperation,OperationRegistry,registry}from"./registry.js";import"../operations/adaptive-threshold.js";import"../operations/blur.js";import"../operations/border.js";import"../operations/canny.js";import"../operations/convert.js";import"../operations/dilate.js";import"../operations/erode.js";import"../operations/grayscale.js";import"../operations/invert.js";import"../operations/morphological-gradient.js";import"../operations/resize.js";import"../operations/rotate.js";import"../operations/threshold.js";import"../operations/warp.js";
+export{executeOperation,OperationRegistry,registry}from"./registry.js";import"../operations/adaptive-threshold.js";import"../operations/blur.js";import"../operations/border.js";import"../operations/canny.js";import"../operations/convert.js";import"../operations/dilate.js";import"../operations/erode.js";import"../operations/equalize.js";import"../operations/grayscale.js";import"../operations/invert.js";import"../operations/morphological-gradient.js";import"../operations/resize.js";import"../operations/rotate.js";import"../operations/threshold.js";import"../operations/warp.js";

package/pipeline/types.d.ts

@@ -6,6 +6,7 @@ import type { CannyOptions } from "../operations/canny.js";
 import type { ConvertOptions } from "../operations/convert.js";
 import type { DilateOptions } from "../operations/dilate.js";
 import type { ErodeOptions } from "../operations/erode.js";
+import type { EqualizeOptions } from "../operations/equalize.js";
 import type { GrayscaleOptions } from "../operations/grayscale.js";
 import type { InvertOptions } from "../operations/invert.js";
 import type { MorphologicalGradientOptions } from "../operations/morphological-gradient.js";
@@ -14,31 +15,31 @@ import type { RotateOptions } from "../operations/rotate.js";
 import type { ThresholdOptions } from "../operations/threshold.js";
 import type { WarpOptions } from "../operations/warp.js";
 /** The output produced by every pipeline operation: the transformed Mat plus its dimensions. */
-export interface OperationResult {
+export type OperationResult = {
     /** Resulting OpenCV Mat after the operation. The caller is responsible for deleting it. */
     img: cv.Mat;
     /** Width of the resulting image in pixels. */
     width: number;
     /** Height of the resulting image in pixels. */
     height: number;
-}
+};
 declare const RequiredBrand: unique symbol;
 /**
- * Marker interface for operation options that have no usable defaults and
- * must be supplied by the caller. Operation option types that extend this
+ * Marker type for operation options that have no usable defaults and
+ * must be supplied by the caller. Operation option types that intersect this
  * cannot be omitted when calling {@link ImageProcessor.execute}.
  */
-export interface RequiredOptions {
+export type RequiredOptions = {
     [RequiredBrand]?: never;
-}
+};
 declare const PartialBrand: unique symbol;
 /**
- * Marker interface for operation options that have sensible defaults.
- * Operation option types that extend this may be omitted or partially supplied.
+ * Marker type for operation options that have sensible defaults.
+ * Operation option types that intersect this may be omitted or partially supplied.
  */
-export interface PartialOptions {
+export type PartialOptions = {
     [PartialBrand]?: never;
-}
+};
 /** Signature every registered operation function must conform to. */
 export type OperationFunction<T> = (img: cv.Mat, options: T) => OperationResult;
 /**
@@ -66,6 +67,8 @@ export interface RegisteredOperations {
     convert: ConvertOptions;
     /** Morphological dilation. See {@link DilateOptions}. */
     dilate: DilateOptions;
+    /** Histogram equalisation (CLAHE or global). See {@link EqualizeOptions}. */
+    equalize: EqualizeOptions;
     /** Morphological erosion. See {@link ErodeOptions}. */
     erode: ErodeOptions;
     /** Convert to grayscale via `COLOR_RGBA2GRAY`. See {@link GrayscaleOptions}. */