ppu-ocv 0.0.1

package/README.md

@@ -0,0 +1,218 @@
+# ppu-ocv
+
+A type-safe, modular, chainable image processing library built on top of OpenCV.js with a fluent API leveraging pipeline processing.
+
+![ppu-ocv pipeline demo](https://raw.githubusercontent.com/PT-Perkasa-Pilar-Utama/ppu-ocv/refs/heads/main/assets/ppu-ocv-demo.jpg)
+
+Image manipulation as easy as:
+
+```ts
+const processor = new ImageProcessor(canvas);
+
+const result = processor
+  .grayscale()
+  .blur({ size: 5 })
+  .threshold()
+  .invert()
+  .dilate({ size: [20, 20], iter: 5 })
+  .toCanvas();
+
+// Memory cleanup
+processor.destroy();
+```
+
+This work is based on https://github.com/TechStark/opencv-js.
+
+## Why use this library?
+
+OpenCV is powerful but can be cumbersome to use directly. This library provides:
+
+1. **Simplified API**: Transform complex OpenCV calls into simple chainable methods
+2. **Reduced Boilerplate**: No need to manage memory, conversions, or dimensions manually
+3. **Development Speed**: Add image processing to your app in minutes, not hours
+4. **Extensibility**: Custom operations for your specific needs without library modifications
+5. **TypeScript Integration**: Full IntelliSense support with parameter validation
+
+## Installation
+
+Install using your preferred package manager:
+
+```bash
+npm install ppu-ocv
+yarn add ppu-ocv
+bun add ppu-ocv
+```
+
+> [!NOTE]
+> This project is developed and tested primarily with Bun.  
+> Support for Node.js, Deno, or browser environments is **not guaranteed**.  
+> If you choose to use it outside of Bun and encounter any issues, feel free to report them.  
+> I'm open to fixing bugs for other runtimes with community help.
+
+## Usage
+
+Note that Operation order is matter, you should atleast know some basic in using OpenCV. See the operations table below this.
+
+```ts
+import { ImageProcessor } from "ppu-ocv";
+
+const file = Bun.file("./assets/receipt.jpg");
+const image = await file.arrayBuffer();
+
+const canvas = await ImageProcessor.prepareCanvas(image);
+await ImageProcessor.initRuntime();
+
+const processor = new ImageProcessor(canvas);
+processor.grayscale().blur({ size: 5 }).threshold();
+
+const resultCanvas = processor.toCanvas();
+processor.destroy();
+```
+
+Or you can do directly via execute api:
+
+```ts
+import { CanvasToolkit, ImageProcessor, cv } from "ppu-ocv";
+
+const file = Bun.file("./assets/receipt.jpg");
+const image = await file.arrayBuffer();
+
+const canvasToolkit = new CanvasToolkit();
+const canvas = await ImageProcessor.prepareCanvas(image);
+await ImageProcessor.initRuntime();
+
+const processor = new ImageProcessor(canvas);
+const grayscaleImg = processor.execute("grayscale").toCanvas();
+
+// the pipeline operation continued from grayscaled image
+const thresholdImg = processor
+  .execute("blur")
+  .execute("threshold", {
+    type: cv.THRESH_BINARY_INV + cv.THRESH_OTSU,
+  })
+  .toCanvas();
+
+await canvasToolkit.saveImage({
+  canvas: thresholdImg,
+  filename: "threshold",
+  path: "out",
+});
+```
+
+For more advanced usage, see: [Example usage of ppu-ocv](./examples)
+
+## Built-in pipeline operations
+
+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.                                   |
+
+## Extending operations
+
+You can easily add your own by creating a prototype method or extend the class of `ImageProcessor`.
+
+See: [How to extend ppu-ocv operations](./docs/how-to-extend-ppu-ocv-operations.md)
+
+## Class documentation
+
+#### `ImageProcessor`
+
+| Method                 | Args             | Description                                                                 |
+| ---------------------- | ---------------- | --------------------------------------------------------------------------- |
+| constructor            | cv.Mat or Canvas | Instantiate processor with initial image                                    |
+| static `prepareCanvas` | ArrayBuffer      | Utility to load image from file buffer to canvas                            |
+| static `initRuntime`   |                  | Important open-cv runtime initialization, required to call once per runtime |
+| operations             | depends          | Chainable operations like `blur`, `grayscale`, `resize` and so on           |
+| `execute`              | name, options    | Chainable operations directly via `execute` api                             |
+| outputs                |                  | Non-chainable & non-interupting method for output like `toMat`, `toCanvas`  |
+| `destroy`              |                  | Non-chainable clean-up memory to destroy the object and the state           |
+
+#### `CanvasToolkit`
+
+| Method        | Args                   | Description                                                                               |
+| ------------- | ---------------------- | ----------------------------------------------------------------------------------------- |
+| `crop`        | BoundingBox, Canvas    | Crop a part of source canvas and return a new canvas of the cropped part                  |
+| `isDirty`     | Canvas, threshold      | Check whether a binary canvas is dirty (full of major color either black or white) or not |
+| `saveImage`   | Canvas, filename, path | Save a canvas to an image file                                                            |
+| `clearOutput` | path                   | Clear the output folder                                                                   |
+| `drawLine`    | ctx, coordinate, style | Draw a non-filled rectangle outline on the canvas                                         |
+| `drawContour` | ctx, contour, style    | Draw a contour on the canvas                                                              |
+
+#### `Contours`
+
+| Method                  | Args            | Description                                                                               |
+| ----------------------- | --------------- | ----------------------------------------------------------------------------------------- |
+| constructor             | cv.Mat, options | Instantiate Contours and automatically find & store contour list from args                |
+| `getAll`                |                 | Crop a part of source canvas and return a new canvas of the cropped part                  |
+| `getFromIndex`          | index           | Get contour at a specific index                                                           |
+| `getRect`               |                 | Get the rectangle that bounds the contour                                                 |
+| `iterate`               | callback        | Iterate over all contours and call the callback function for each contour                 |
+| `getLargestContourArea` |                 | Get the largest contour area                                                              |
+| `getCornerPoints`       | Canvas, contour | Get four corner points for a given contour. Useful for perspective transformation (warp). |
+| `destroy`               |                 | Destroy & clean-up the memory from the contours                                           |
+
+#### `ImageAnalysis`
+
+Just a collection of utility functions for analyzing image properties.
+
+- `calculateMeanNormalizedLabLightness`: 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.
+
+- `calculateMeanGrayscaleValue`: Calculates the mean pixel value of the image after converting it to grayscale.
+
+## Contributing
+
+Contributions are welcome! If you would like to contribute, please follow these steps:
+
+1. **Fork the Repository:** Create your own fork of the project.
+2. **Create a Feature Branch:** Use a descriptive branch name for your changes.
+3. **Implement Changes:** Make your modifications, add tests, and ensure everything passes.
+4. **Submit a Pull Request:** Open a pull request to discuss your changes and get feedback.
+
+### Running Tests
+
+This project uses Bun for testing. To run the tests locally, execute:
+
+```bash
+bun test
+```
+
+Ensure that all tests pass before submitting your pull request.
+
+## Scripts
+
+Recommended development environment is in linux-based environment.
+
+Library template: https://github.com/aquapi/lib-template
+
+All script sources and usage.
+
+### [Build](./scripts/build.ts)
+
+Emit `.js` and `.d.ts` files to [`lib`](./lib).
+
+### [Publish](./scripts/publish.ts)
+
+Move [`package.json`](./package.json), [`README.md`](./README.md) to [`lib`](./lib) and publish the package.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Support
+
+If you encounter any issues or have suggestions, please open an issue in the repository.
+
+Happy coding!

package/canvas-toolkit.d.ts

@@ -0,0 +1,98 @@
+import type { BoundingBox, SKRSContext2D } from "@/index";
+import { Canvas, cv } from "@/index";
+export declare class CanvasToolkit {
+    private step;
+    /**
+     * Crop a part of source canvas and return a new canvas of the cropped part
+     * @param options
+     * @param options.bbox Bounding box of the cropped part
+     * @param options.canvas Source canvas
+     * @returns A new canvas of the cropped part
+     * @example
+     * const croppedCanvas = canvasToolkit.crop({
+     *   bbox: { x0: 10, y0: 10, x1: 100, y1: 100 },
+     *   canvas: sourceCanvas,
+     * });
+     */
+    crop(options: {
+        bbox: BoundingBox;
+        canvas: Canvas;
+    }): Canvas;
+    /**
+     * Check whether a binary canvas is dirty (full of major color either black or white) or not
+     * @param options
+     * @param options.canvas Source canvas
+     * @param options.threshold Threshold for color detection (default: 127.5)
+     * @param options.majorColorThreshold Major color threshold (default: 0.97)
+     * @returns true if the canvas is dirty, false otherwise
+     * @example
+     * const isDirty = canvasToolkit.isDirty({
+     *   canvas: sourceCanvas,
+     *   threshold: 127.5,
+     *   majorColorThreshold: 0.97,
+     * });
+     * console.log(isDirty); // true or false
+     */
+    isDirty(options: {
+        canvas: Canvas;
+        threshold?: number;
+        majorColorThreshold?: number;
+    }): boolean;
+    /**
+     * Save a canvas to an image file
+     * @param options
+     * @param options.canvas Source canvas
+     * @param options.filename Filename of the image file
+     * @param options.path Path to save the image file (default: "out")
+     * @returns A promise that resolves when the image is saved
+     * @example
+     * await canvasToolkit.saveImage({
+     *   canvas: sourceCanvas,
+     *   filename: "output.png",
+     * });
+     */
+    saveImage(options: {
+        canvas: Canvas;
+        filename: string;
+        path: string;
+    }): Promise<void>;
+    /**
+     * Clear the output folder
+     * @param path Path to the output folder (default: "out")
+     */
+    clearOutput(path?: string): void;
+    /**
+     * Draw a non-filled rectangle on the canvas
+     * @param options
+     * @param options.ctx Canvas rendering context
+     * @param options.x X coordinate of the top-left corner
+     * @param options.y Y coordinate of the top-left corner
+     * @param options.width Width of the rectangle
+     * @param options.height Height of the rectangle
+     * @param options.lineWidth Line width (default: 2)
+     * @param options.color Color of the rectangle (default: "blue")
+     */
+    drawLine(options: {
+        ctx: SKRSContext2D;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        lineWidth?: number;
+        color?: string;
+    }): void;
+    /**
+     * Draw a contour on the canvas
+     * @param options
+     * @param options.ctx Canvas rendering context
+     * @param options.contour Contour to be drawn
+     * @param options.strokeStyle Stroke color (default: "red")
+     * @param options.lineWidth Line width (default: 2)
+     */
+    drawContour(options: {
+        ctx: SKRSContext2D;
+        contour: cv.Mat;
+        strokeStyle?: string;
+        lineWidth?: number;
+    }): void;
+}

package/canvas-toolkit.js

@@ -0,0 +1 @@
+export class CanvasToolkit{step=0;crop(options){const{bbox,canvas}=options;let croppedCanvas=createCanvas(bbox.x1-bbox.x0,bbox.y1-bbox.y0);let croppedCtx=croppedCanvas.getContext("2d");croppedCtx.drawImage(canvas,bbox.x0,bbox.y0,bbox.x1-bbox.x0,bbox.y1-bbox.y0,0,0,croppedCanvas.width,croppedCanvas.height);return croppedCanvas}isDirty(options){const{canvas,threshold=127.5,majorColorThreshold=0.97}=options;let whiteCount=0;let blackCount=0;let borderlessCanvas=this.crop({bbox:{x0:canvas.width*0.1,y0:canvas.height*0.1,x1:canvas.width*0.9,y1:canvas.height*0.9},canvas});let ctx=borderlessCanvas.getContext("2d");let colorData=ctx.getImageData(0,0,borderlessCanvas.width,borderlessCanvas.height).data;for(let i=0;i<colorData.length;i+=4){let red=colorData[i];let green=colorData[i+1];let blue=colorData[i+2];if(red>=threshold&&green>=threshold&&blue>=threshold){whiteCount++}else{blackCount++}}let majorColorRatio=Math.max(whiteCount,blackCount)/(blackCount+whiteCount);return majorColorRatio<majorColorThreshold}saveImage(options){const{canvas,filename,path="out"}=options;let folderPath=join(process.cwd(),path);if(!existsSync(folderPath)){mkdirSync(folderPath,{recursive:true})}let filePath=join(folderPath,`${this.step++}. ${filename}.png`);let out=createWriteStream(filePath);let buffer=canvas.toBuffer("image/png");return new Promise((res,rej)=>{out.write(buffer,(err)=>{if(err){rej(err)}else{res()}})})}clearOutput(path="out"){let folderPath=join(process.cwd(),path);if(existsSync(folderPath)){let files=readdirSync(folderPath);for(let file of files){if(file===".gitignore")continue;let filePath=join(folderPath,file);unlinkSync(filePath)}}}drawLine(options){const{ctx,x,y,width,height,lineWidth=2,color="blue"}=options;ctx.beginPath();ctx.strokeStyle=color;ctx.lineWidth=lineWidth;ctx.strokeRect(x,y,width,height);ctx.closePath()}drawContour(options){const{ctx,contour,strokeStyle="red",lineWidth=2}=options;let pts=contour.data32S;if(pts.length<4)return;ctx.strokeStyle=strokeStyle;ctx.lineWidth=lineWidth;ctx.beginPath();ctx.moveTo(pts[0],pts[1]);for(let i=2;i<pts.length;i+=2){ctx.lineTo(pts[i],pts[i+1])}ctx.closePath();ctx.stroke()}}import{createCanvas}from"@/index";import{createWriteStream,existsSync,mkdirSync,readdirSync,unlinkSync}from"fs";import{join}from"path";

package/contours.d.ts

@@ -0,0 +1,70 @@
+import type { BoundingBox, Canvas, Points } from "@/index";
+import { cv } from "@/index";
+export interface ContoursOptions {
+    /** The contour retrieval mode. (cv.RETR_...) */
+    mode: cv.RetrievalModes;
+    /** The contour approximation method. (cv.CHAIN_...) */
+    method: cv.ContourApproximationModes;
+}
+export declare class Contours {
+    private contours;
+    /** The constructor for the Contours class. It takes an image and options as parameters. */
+    /**
+     * @param img - The image to find contours in.
+     * @param options.mode - The contour retrieval mode. (cv.RETR_...)
+     * @param options.method - The contour approximation method. (cv.CHAIN_...)
+     * @example
+     * const contours = new Contours(image, {
+     *   mode: cv.RETR_EXTERNAL,
+     *   method: cv.CHAIN_APPROX_SIMPLE,
+     * });
+     */
+    constructor(img: cv.Mat, options?: Partial<ContoursOptions>);
+    /**
+     *  Get the all of contours found in the image.
+     * @returns The number of contours found in the image (cv.MatVector).
+     */
+    getAll(): cv.MatVector;
+    /**
+     * Get contour at a specific index.
+     * @param index - The index of the contour to get.
+     * @returns The contour at the specified index (cv.Mat).
+     */
+    getFromIndex(index: number): cv.Mat;
+    /**
+     * Get the rectangle that bounds the contour.
+     * @param contour - The contour to get the bounding rectangle for.
+     * @returns The bounding rectangle for the contour (cv.Rect).
+     */
+    getRect(contour: cv.Mat): cv.Rect;
+    /**
+     * Iterate over all contours and call the callback function for each contour.
+     * @param callback - The callback function to call for each contour.
+     * The callback function takes a contour as a parameter.
+     * @returns void
+     */
+    iterate(callback: (contour: cv.Mat) => any): Contours;
+    /**
+     * Get the largest contour area.
+     * @returns The largest contour area (cv.Mat).
+     */
+    getLargestContourArea(): cv.Mat | null;
+    /**
+     * Get four corner points for a given contour.
+     * Useful for perspective transformation (warp).
+     * @param options.canvas - The canvas to get the corner points for.
+     * @param options.contour - The contour to get the corner points for. If not provided, the largest contour area will be used.
+     * @returns The four corner points of the contour (topLeft, topRight, bottomLeft, bottomRight) and the bounding box.
+     */
+    getCornerPoints(options: {
+        canvas: Canvas;
+        contour?: cv.Mat;
+    }): {
+        points: Points;
+        bbox: BoundingBox;
+    };
+    /**
+     * Delete the contours object.
+     */
+    destroy(): void;
+}

package/contours.js

@@ -0,0 +1 @@
+export class Contours{contours;constructor(img,options={}){let opts={...defaultOptions(),...options};if(img instanceof cv.Mat){let contours=new cv.MatVector;let hierarchy=new cv.Mat;try{cv.findContours(img,contours,hierarchy,opts.mode,opts.method)}catch(error){throw error}hierarchy.delete();this.contours=contours}else{throw new Error("Invalid img type. Must be cv.Mat.")}}getAll(){return this.contours}getFromIndex(index){if(index<this.contours.size()){return this.contours.get(index)}return new cv.Mat}getRect(contour){return cv.boundingRect(contour)}iterate(callback){for(let i=0,len=this.contours.size();i<len;i++){let contour=this.contours.get(i);callback(contour)}return this}getLargestContourArea(){let maxArea=0;let largestContour=null;this.iterate((contour)=>{let area=cv.contourArea(contour);if(area>maxArea){maxArea=area;largestContour=contour}});return largestContour}getCornerPoints(options){const{canvas,contour=this.getLargestContourArea()}=options;let bbox={x0:0,y0:0,x1:canvas.width,y1:canvas.height};if(!contour){return{points:{topLeft:{x:bbox.x0,y:bbox.y0},topRight:{x:bbox.x1,y:bbox.y0},bottomLeft:{x:bbox.x0,y:bbox.y1},bottomRight:{x:bbox.x1,y:bbox.y1}},bbox}}let rect=cv.minAreaRect(contour);let vertices=cv.RotatedRect.points(rect);let points={topLeft:{x:0,y:0},topRight:{x:0,y:0},bottomRight:{x:0,y:0},bottomLeft:{x:0,y:0}};let sums=vertices.map((pt)=>pt.x+pt.y);let diffs=vertices.map((pt)=>pt.y-pt.x);let topLeftIdx=sums.indexOf(Math.min(...sums));let topRightIdx=diffs.indexOf(Math.min(...diffs));let bottomRightIdx=sums.indexOf(Math.max(...sums));let bottomLeftIdx=diffs.indexOf(Math.max(...diffs));if(!vertices[topLeftIdx]||!vertices[topRightIdx]||!vertices[bottomRightIdx]||!vertices[bottomLeftIdx]){return{points:{topLeft:{x:bbox.x0,y:bbox.y0},topRight:{x:bbox.x1,y:bbox.y0},bottomLeft:{x:bbox.x0,y:bbox.y1},bottomRight:{x:bbox.x1,y:bbox.y1}},bbox}}points.topLeft={x:vertices[topLeftIdx].x,y:vertices[topLeftIdx].y};points.topRight={x:vertices[topRightIdx].x,y:vertices[topRightIdx].y};points.bottomRight={x:vertices[bottomRightIdx].x,y:vertices[bottomRightIdx].y};points.bottomLeft={x:vertices[bottomLeftIdx].x,y:vertices[bottomLeftIdx].y};contour.delete();let ensureInBounds=(p)=>{p.x=Math.max(0,Math.min(canvas.width,p.x));p.y=Math.max(0,Math.min(canvas.height,p.y));return p};points.topLeft=ensureInBounds(points.topLeft);points.topRight=ensureInBounds(points.topRight);points.bottomLeft=ensureInBounds(points.bottomLeft);points.bottomRight=ensureInBounds(points.bottomRight);return{points,bbox}}destroy(){try{this.contours.delete()}catch(error){}}}import{cv}from"@/index";function defaultOptions(){return{mode:cv.RETR_EXTERNAL,method:cv.CHAIN_APPROX_SIMPLE}}

package/image-analysis.d.ts

@@ -0,0 +1,35 @@
+/**
+ * This module provides utility functions for analyzing image properties.
+ * !IMPORTANT: Ensure ImageProcessor.initRuntime() has been called successfully
+ * once before using any functions from this module.
+ */
+import type { Canvas } from "@/index";
+/**
+ * Options for calculating mean Lab lightness.
+ */
+export interface CalculateMeanLightnessOptions {
+    /** The canvas containing the image to be processed. */
+    canvas: Canvas;
+    /** The target dimensions for analysis (resizes internally). */
+    dimension: {
+        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.
+ *
+ * @param options - Configuration options.
+ * @returns A promise resolving to the mean normalized lightness (0-1).
+ * @throws Error if OpenCV operations fail.
+ */
+export declare function calculateMeanNormalizedLabLightness(options: CalculateMeanLightnessOptions): Promise<number>;
+/**
+ * Calculates the mean pixel value of the image after converting it to grayscale.
+ *
+ * @param canvas - The source canvas to be processed.
+ * @returns A promise resolving to the mean grayscale value (typically 0-255).
+ * @throws Error if OpenCV operations fail.
+ */
+export declare function calculateMeanGrayscaleValue(canvas: Canvas): Promise<number>;

package/image-analysis.js

@@ -0,0 +1 @@
+import{ImageProcessor,cv}from"@/index";export async function calculateMeanNormalizedLabLightness(options){const{canvas,dimension}=options;let processor=null;let resized=null;let labImg=null;let channels=null;let L=null;let mask=null;let scalarMat=null;try{processor=new ImageProcessor(canvas);resized=processor.execute("resize",{width:dimension.width,height:dimension.height}).toMat();labImg=new cv.Mat;cv.cvtColor(resized,labImg,cv.COLOR_BGR2Lab);channels=new cv.MatVector;cv.split(labImg,channels);L=channels.get(0);mask=new cv.Mat;let maxLocResult=cv.minMaxLoc(L,mask);let maxPixelValue=maxLocResult.maxVal;if(maxPixelValue===0){return 0}scalarMat=new cv.Mat(L.rows,L.cols,L.type(),new cv.Scalar(maxPixelValue));cv.divide(L,scalarMat,L,1,-1);let meanL=cv.mean(L)[0];return meanL??0}finally{processor?.destroy();labImg?.delete();channels?.delete();L?.delete();mask?.delete();scalarMat?.delete()}}export async function calculateMeanGrayscaleValue(canvas){let processor=null;let grayscaleImg=null;try{processor=new ImageProcessor(canvas);grayscaleImg=processor.blur().grayscale().toMat();let mean=cv.mean(grayscaleImg)[0];return mean??0}finally{processor?.destroy()}}

package/image-processor.d.ts

@@ -0,0 +1,122 @@
+import { Canvas, cv } from "@/index";
+import type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, DilateOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationName, OperationOptions, RequiredOptions, ResizeOptions, ThresholdOptions, WarpOptions } from "@/index";
+type NameWithRequiredOptions = {
+    [N in OperationName]: OperationOptions<N> extends RequiredOptions ? N : never;
+}[OperationName];
+type NameWithOptionalOptions = Exclude<OperationName, NameWithRequiredOptions>;
+export declare class ImageProcessor {
+    img: cv.Mat;
+    width: number;
+    height: number;
+    /**
+     * Create an ImageProcessor instance from a Canvas or cv.Mat
+     * @param source Source image as Canvas or cv.Mat
+     */
+    constructor(source: Canvas | cv.Mat);
+    static prepareCanvas(file: ArrayBuffer): Promise<Canvas>;
+    /**
+     * Initialize OpenCV runtime, this is recommended to be called before any image processing
+     */
+    static initRuntime(): Promise<void>;
+    /**
+     * Execute a registered pipeline operation that requires options.
+     * @param operationName Name of the operation (e.g., "resize")
+     * @param options Required options for the operation
+     */
+    execute<Name extends NameWithRequiredOptions>(operationName: Name, options: OperationOptions<Name>): this;
+    /**
+     * Execute a registered pipeline operation where options are optional or have defaults.
+     * @param operationName Name of the operation (e.g., "blur", "grayscale")
+     * @param options Optional or partial options for the operation
+     */
+    execute<Name extends NameWithOptionalOptions>(operationName: Name, options?: Partial<OperationOptions<Name>>): this;
+    /**
+     * Convert image to grayscale
+     * @description Usage order: independent
+     * @param options Optional configuration for grayscale conversion
+     */
+    grayscale(options?: Partial<GrayscaleOptions>): this;
+    /**
+     * Invert image colors
+     * @description Usage order: ideally (after) threshold or adaptiveThreshold
+     * @param options Optional configuration for inversion
+     */
+    invert(options?: Partial<InvertOptions>): this;
+    /**
+     * Add border to image
+     * @description Usage order: independent
+     * @param options Border configuration options
+     */
+    border(options?: Partial<BorderOptions>): this;
+    /**
+     * Bluring image to reduce noise using Gaussian Blur
+     * @description Usage order: (ideally after) grayscale
+     * @param options Blur configuration options
+     */
+    blur(options?: Partial<BlurOptions>): this;
+    /** Thresholding to convert image to binary
+     * @description Usage order: (after) grayscale (and optionally blur)
+     * @param options Thresholding configuration options
+     */
+    threshold(options?: Partial<ThresholdOptions>): this;
+    /** Adaptive thresholding to convert image to binary
+     * @description Usage order: (after) grayscale (and optionally blur)
+     * @param options Adaptive thresholding configuration options
+     */
+    adaptiveThreshold(options?: Partial<AdaptiveThresholdOptions>): this;
+    /**
+     * Canny edge detection to detect edges in the image
+     * @description Usage order: (after) grayscale + blur
+     * @param options Canny edge detection configuration options
+     */
+    canny(options?: Partial<CannyOptions>): this;
+    /**
+     * Morphological gradient to highlight the edges in the image
+     * @description Usage order: (after) dilation + erosion (or threshold)
+     * @param options Morphological gradient configuration options
+     */
+    morphologicalGradient(options?: Partial<MorphologicalGradientOptions>): this;
+    /**
+     * Erode image to reduce noise
+     * @description Usage order: (after) threshold or edge detection
+     * @param options Erosion configuration options
+     */
+    erode(options?: Partial<ErodeOptions>): this;
+    /**
+     * Dilate image to increase the size of the foreground object
+     * @description Usage order: (after) threshold or edge detection
+     * @param options Dilation configuration options
+     */
+    dilate(options?: Partial<DilateOptions>): this;
+    /**
+     * Resize image to a new width and height
+     * @description Usage order: independent
+     *  @param options Resize configuration options
+     */
+    resize(options: ResizeOptions): this;
+    /**
+     * Warp image to a new perspective
+     * @description Usage order: independent
+     * @param options Warp configuration options
+     */
+    warp(options: WarpOptions): this;
+    /**
+     * Destroy the image (cv.Mat) stored in image processor state
+     * @kind non-chainable
+     * @returns void
+     */
+    destroy(): void;
+    /**
+     * Convert image to cv.Mat
+     * @kind non-chainable
+     * @returns cv.Mat
+     */
+    toMat(): cv.Mat;
+    /**
+     * Convert image (cv.Mat) to Canvas
+     * @kind non-chainable
+     * @returns Canvas
+     */
+    toCanvas(): Canvas;
+}
+export {};

package/image-processor.js

@@ -0,0 +1 @@
+export class ImageProcessor{img;width;height;constructor(source){if(source instanceof Canvas){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 prepareCanvas(file){let img=await loadImage(file);let canvas=createCanvas(img.width,img.height);let ctx=canvas.getContext("2d");ctx.drawImage(img,0,0);return canvas}static async initRuntime(){return new Promise((res)=>{if(cv&&cv.Mat){res()}else{cv["onRuntimeInitialized"]=()=>{res()}}})}execute(operationName,options){if(!registry.hasOperation(operationName)){throw new Error(`Operation "${operationName}" not found`)}try{let result=executeOperation(operationName,this.img,options);this.img=result.img;this.width=result.width;this.height=result.height}catch(error){console.error(`Error executing operation "${operationName}":`,error);throw error}return this}grayscale(options={}){return this.execute("grayscale",options)}invert(options={}){return this.execute("invert",options)}border(options={}){return this.execute("border",options)}blur(options={}){return this.execute("blur",options)}threshold(options={}){return this.execute("threshold",options)}adaptiveThreshold(options={}){return this.execute("adaptiveThreshold",options)}canny(options={}){return this.execute("canny",options)}morphologicalGradient(options={}){return this.execute("morphologicalGradient",options)}erode(options={}){return this.execute("erode",options)}dilate(options={}){return this.execute("dilate",options)}resize(options){return this.execute("resize",options)}warp(options){return this.execute("warp",options)}destroy(){this.img.delete()}toMat(){return this.img}toCanvas(){let canvas=createCanvas(this.width,this.height);let ctx=canvas.getContext("2d");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}}import{Canvas,createCanvas,cv,loadImage}from"@/index";import{executeOperation,registry}from"@/index";

package/index.d.ts

@@ -0,0 +1,11 @@
+import cv from "@techstark/opencv-js";
+export { cv };
+export type { BoundingBox, Coordinate, Points } from "@/index.interface";
+export { executeOperation, OperationRegistry, registry } from "@/pipeline";
+export { Canvas, createCanvas, loadImage } from "@napi-rs/canvas";
+export type { SKRSContext2D } from "@napi-rs/canvas";
+export { CanvasToolkit } from "@/canvas-toolkit";
+export { Contours } from "@/contours";
+export { calculateMeanGrayscaleValue, calculateMeanNormalizedLabLightness, type CalculateMeanLightnessOptions, } from "@/image-analysis";
+export { ImageProcessor } from "@/image-processor";
+export type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, DilateOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationFunction, OperationName, OperationOptions, OperationResult, PartialOptions, RegisteredOperations, RequiredOptions, ResizeOptions, ThresholdOptions, WarpOptions, } from "@/pipeline";

package/index.interface.d.ts

@@ -0,0 +1,16 @@
+export interface Coordinate {
+    x: number;
+    y: number;
+}
+export interface Points {
+    topLeft: Coordinate;
+    topRight: Coordinate;
+    bottomLeft: Coordinate;
+    bottomRight: Coordinate;
+}
+export interface BoundingBox {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}

package/index.js

@@ -0,0 +1 @@
+import cv from"@techstark/opencv-js";export{cv};export{executeOperation,OperationRegistry,registry}from"@/pipeline";export{Canvas,createCanvas,loadImage}from"@napi-rs/canvas";export{CanvasToolkit}from"@/canvas-toolkit";export{Contours}from"@/contours";export{calculateMeanGrayscaleValue,calculateMeanNormalizedLabLightness}from"@/image-analysis";export{ImageProcessor}from"@/image-processor";

package/operations/adaptive-threshold.d.ts

@@ -0,0 +1,20 @@
+import type { OperationResult, PartialOptions } from "@/index";
+import { cv } from "@/index";
+declare module "@/pipeline/types" {
+    interface RegisteredOperations {
+        adaptiveThreshold: AdaptiveThresholdOptions;
+    }
+}
+export interface AdaptiveThresholdOptions extends PartialOptions {
+    /** Upper threshold value (0-255) */
+    upper: number;
+    /** Adaptive threshold method (cv.ADAPTIVE_THRESH_...) */
+    method: cv.AdaptiveThresholdTypes;
+    /** Type of thresholding (cv.THRESH_...) */
+    type: cv.ThresholdTypes;
+    /** Block size for adaptive thresholding (must be odd) */
+    size: number;
+    /** Constant subtracted from the mean or weighted mean */
+    constant: number;
+}
+export declare function adaptiveThreshold(img: cv.Mat, options: AdaptiveThresholdOptions): OperationResult;

package/operations/adaptive-threshold.js

@@ -0,0 +1 @@
+import{cv,registry}from"@/index";function defaultOptions(){return{upper:255,method:cv.ADAPTIVE_THRESH_GAUSSIAN_C,type:cv.THRESH_BINARY_INV,size:7,constant:2}}export function adaptiveThreshold(img,options){let imgAdaptiveThreshold=new cv.Mat;cv.adaptiveThreshold(img,imgAdaptiveThreshold,options.upper,options.method,options.type,options.size,options.constant);img.delete();return{img:imgAdaptiveThreshold,width:imgAdaptiveThreshold.cols,height:imgAdaptiveThreshold.rows}}registry.register("adaptiveThreshold",adaptiveThreshold,defaultOptions);

package/operations/blur.d.ts

@@ -0,0 +1,14 @@
+import type { OperationResult, PartialOptions } from "@/index";
+import { cv } from "@/index";
+declare module "@/pipeline/types" {
+    interface RegisteredOperations {
+        blur: BlurOptions;
+    }
+}
+export interface BlurOptions extends PartialOptions {
+    /** Size of the blur [x, y] */
+    size: [number, number];
+    /** Gaussian kernel standard deviation on x axis */
+    sigma: number;
+}
+export declare function blur(img: cv.Mat, options: BlurOptions): OperationResult;

package/operations/blur.js

@@ -0,0 +1 @@
+import{cv,registry}from"@/index";function defaultOptions(){return{size:[5,5],sigma:0}}export function blur(img,options){let imgBlur=new cv.Mat;cv.GaussianBlur(img,imgBlur,new cv.Size(options.size[0],options.size[1]),options.sigma);img.delete();return{img:imgBlur,width:imgBlur.cols,height:imgBlur.rows}}registry.register("blur",blur,defaultOptions);

package/operations/border.d.ts

@@ -0,0 +1,16 @@
+import type { OperationResult, PartialOptions } from "@/index";
+import { cv } from "@/index";
+declare module "@/pipeline/types" {
+    interface RegisteredOperations {
+        border: BorderOptions;
+    }
+}
+export interface BorderOptions extends 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];
+}
+export declare function border(img: cv.Mat, options: BorderOptions): OperationResult;

package/operations/border.js

@@ -0,0 +1 @@
+import{cv,registry}from"@/index";function defaultOptions(){return{size:10,borderType:cv.BORDER_CONSTANT,borderColor:[255,255,255,255]}}export function border(img,options){let imgBorder=new cv.Mat;cv.copyMakeBorder(img,imgBorder,options.size,options.size,options.size,options.size,options.borderType,options.borderColor);img.delete();return{img:imgBorder,width:imgBorder.cols,height:imgBorder.rows}}registry.register("border",border,defaultOptions);

package/operations/canny.d.ts

@@ -0,0 +1,14 @@
+import type { OperationResult, PartialOptions } from "@/index";
+import { cv } from "@/index";
+declare module "@/pipeline/types" {
+    interface RegisteredOperations {
+        canny: CannyOptions;
+    }
+}
+export interface CannyOptions extends PartialOptions {
+    /** Lower threshold for the hysteresis procedure (0-255) */
+    lower: number;
+    /** Upper threshold for the hysteresis procedure (0-255) */
+    upper: number;
+}
+export declare function canny(img: cv.Mat, options: CannyOptions): OperationResult;

package/operations/canny.js

@@ -0,0 +1 @@
+import{cv,registry}from"@/index";function defaultOptions(){return{lower:50,upper:150}}export function canny(img,options){let imgCanny=new cv.Mat;cv.Canny(img,imgCanny,options.lower,options.upper);img.delete();return{img:imgCanny,width:imgCanny.cols,height:imgCanny.rows}}registry.register("canny",canny,defaultOptions);

package/operations/dilate.d.ts

@@ -0,0 +1,14 @@
+import type { OperationResult, PartialOptions } from "@/index";
+import { cv } from "@/index";
+declare module "@/pipeline/types" {
+    interface RegisteredOperations {
+        dilate: DilateOptions;
+    }
+}
+export interface DilateOptions extends PartialOptions {
+    /** Size of the block [x, y] */
+    size: [number, number];
+    /** Number of iterations for the dilation operation */
+    iter: number;
+}
+export declare function dilate(img: cv.Mat, options: DilateOptions): OperationResult;

package/operations/dilate.js

@@ -0,0 +1 @@
+import{cv,registry}from"@/index";function defaultOptions(){return{size:[5,5],iter:1}}export function dilate(img,options){let imgDilate=new cv.Mat;let kernel=cv.getStructuringElement(cv.MORPH_RECT,new cv.Size(options.size[0],options.size[1]));cv.dilate(img,imgDilate,kernel,new cv.Point(-1,-1),options.iter);img.delete();return{img:imgDilate,width:imgDilate.cols,height:imgDilate.rows}}registry.register("dilate",dilate,defaultOptions);

package/operations/erode.d.ts

@@ -0,0 +1,14 @@
+import type { OperationResult, PartialOptions } from "@/index";
+import { cv } from "@/index";
+declare module "@/pipeline/types" {
+    interface RegisteredOperations {
+        erode: ErodeOptions;
+    }
+}
+export interface ErodeOptions extends PartialOptions {
+    /** Size of the block [x, y] */
+    size: [number, number];
+    /** Number of iterations for the erosion operation */
+    iter: number;
+}
+export declare function erode(img: cv.Mat, options: ErodeOptions): OperationResult;

package/operations/erode.js

@@ -0,0 +1 @@
+import{cv,registry}from"@/index";function defaultOptions(){return{size:[5,5],iter:1}}export function erode(img,options){let imgErode=new cv.Mat;let kernel=cv.getStructuringElement(cv.MORPH_RECT,new cv.Size(options.size[0],options.size[1]));cv.erode(img,imgErode,kernel,new cv.Point(-1,-1),options.iter);img.delete();return{img:imgErode,width:imgErode.cols,height:imgErode.rows}}registry.register("erode",erode,defaultOptions);

package/operations/grayscale.d.ts

@@ -0,0 +1,10 @@
+import type { OperationResult, PartialOptions } from "@/index";
+import { cv } from "@/index";
+declare module "@/pipeline/types" {
+    interface RegisteredOperations {
+        grayscale: GrayscaleOptions;
+    }
+}
+export interface GrayscaleOptions extends PartialOptions {
+}
+export declare function grayscale(img: cv.Mat, options: GrayscaleOptions): OperationResult;

package/operations/grayscale.js

@@ -0,0 +1 @@
+import{cv,registry}from"@/index";function defaultOptions(){return{}}export function grayscale(img,options){let imgGrayscale=new cv.Mat;cv.cvtColor(img,imgGrayscale,cv.COLOR_RGBA2GRAY);img.delete();return{img:imgGrayscale,width:imgGrayscale.cols,height:imgGrayscale.rows}}registry.register("grayscale",grayscale,defaultOptions);

package/operations/invert.d.ts

@@ -0,0 +1,10 @@
+import type { OperationResult, PartialOptions } from "@/index";
+import { cv } from "@/index";
+declare module "@/pipeline/types" {
+    interface RegisteredOperations {
+        invert: InvertOptions;
+    }
+}
+export interface InvertOptions extends PartialOptions {
+}
+export declare function invert(img: cv.Mat, options: InvertOptions): OperationResult;

package/operations/invert.js

@@ -0,0 +1 @@
+import{cv,registry}from"@/index";function defaultOptions(){return{}}export function invert(img,options){let imgInvert=new cv.Mat;cv.bitwise_not(img,imgInvert);img.delete();return{img:imgInvert,width:imgInvert.cols,height:imgInvert.rows}}registry.register("invert",invert,defaultOptions);

package/operations/morphological-gradient.d.ts

@@ -0,0 +1,12 @@
+import type { OperationResult, PartialOptions } from "@/index";
+import { cv } from "@/index";
+declare module "@/pipeline/types" {
+    interface RegisteredOperations {
+        morphologicalGradient: MorphologicalGradientOptions;
+    }
+}
+export interface MorphologicalGradientOptions extends PartialOptions {
+    /** Kernel size for the morphological gradient operation [x, y] */
+    size: [number, number];
+}
+export declare function morphologicalGradient(img: cv.Mat, options: MorphologicalGradientOptions): OperationResult;

package/operations/morphological-gradient.js

@@ -0,0 +1 @@
+import{cv,registry}from"@/index";function defaultOptions(){return{size:[3,3]}}export function morphologicalGradient(img,options){let imgMorphologicalGradient=new cv.Mat;let kernel=cv.getStructuringElement(cv.MORPH_RECT,new cv.Size(options.size[0],options.size[1]));cv.morphologyEx(img,imgMorphologicalGradient,cv.MORPH_GRADIENT,kernel);img.delete();return{img:imgMorphologicalGradient,width:imgMorphologicalGradient.cols,height:imgMorphologicalGradient.rows}}registry.register("morphologicalGradient",morphologicalGradient,defaultOptions);

package/operations/resize.d.ts

@@ -0,0 +1,14 @@
+import type { OperationResult, RequiredOptions } from "@/index";
+import { cv } from "@/index";
+declare module "@/pipeline/types" {
+    interface RegisteredOperations {
+        resize: ResizeOptions;
+    }
+}
+export interface ResizeOptions extends RequiredOptions {
+    /** Width of the resized image */
+    width: number;
+    /** Height of the resized image */
+    height: number;
+}
+export declare function resize(img: cv.Mat, options: ResizeOptions): OperationResult;

package/operations/resize.js

@@ -0,0 +1 @@
+import{cv,registry}from"@/index";export function resize(img,options){if(!options.width||!options.height){throw new Error("Invalid options: width and height are required")}let imgResize=new cv.Mat;cv.resize(img,imgResize,new cv.Size(options.width,options.height));img.delete();return{img:imgResize,width:imgResize.cols,height:imgResize.rows}}registry.register("resize",resize);

package/operations/threshold.d.ts

@@ -0,0 +1,16 @@
+import type { OperationResult, PartialOptions } from "@/index";
+import { cv } from "@/index";
+declare module "@/pipeline/types" {
+    interface RegisteredOperations {
+        threshold: ThresholdOptions;
+    }
+}
+export interface ThresholdOptions extends PartialOptions {
+    /** Lower threshold value (0-255) */
+    lower: number;
+    /** Upper threshold value (0-255) */
+    upper: number;
+    /** Type of thresholding (cv.THRESH_...) */
+    type: cv.ThresholdTypes;
+}
+export declare function threshold(img: cv.Mat, options: ThresholdOptions): OperationResult;

package/operations/threshold.js

@@ -0,0 +1 @@
+import{cv,registry}from"@/index";function defaultOptions(){return{lower:0,upper:255,type:cv.THRESH_BINARY_INV+cv.THRESH_OTSU}}export function threshold(img,options){let imgThreshold=new cv.Mat;cv.threshold(img,imgThreshold,options.lower,options.upper,options.type);img.delete();return{img:imgThreshold,width:imgThreshold.cols,height:imgThreshold.rows}}registry.register("threshold",threshold,defaultOptions);

package/operations/warp.d.ts

@@ -0,0 +1,17 @@
+import type { BoundingBox, OperationResult, Points, RequiredOptions } from "@/index";
+import { cv } from "@/index";
+declare module "@/pipeline/types" {
+    interface RegisteredOperations {
+        warp: WarpOptions;
+    }
+}
+export interface WarpOptions extends 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
+     */
+    points: Points;
+    /** A destination canvas bounding box for cropping the original canvas */
+    bbox: BoundingBox;
+}
+export declare function warp(img: cv.Mat, options: WarpOptions): OperationResult;

package/operations/warp.js

@@ -0,0 +1 @@
+import{cv,registry}from"@/index";export function warp(img,options){if(!options.points||!options.bbox){throw new Error("Invalid options: points and bbox are required")}const{points,bbox}=options;let imgWarp=new cv.Mat;let targetWidth=bbox.x1-bbox.x0;let targetHeight=bbox.y1-bbox.y0;let destArray=[0,0,targetWidth-1,0,targetWidth-1,targetHeight-1,0,targetHeight-1];let srcArray=[points.topLeft.x,points.topLeft.y,points.topRight.x,points.topRight.y,points.bottomRight.x,points.bottomRight.y,points.bottomLeft.x,points.bottomLeft.y];let dest=cv.matFromArray(4,1,cv.CV_32FC2,destArray);let src=cv.matFromArray(4,1,cv.CV_32FC2,srcArray);let M=cv.getPerspectiveTransform(src,dest);let dsize=new cv.Size(targetWidth,targetHeight);cv.warpPerspective(img,imgWarp,M,dsize);M.delete();src.delete();dest.delete();img.delete();return{img:imgWarp,width:imgWarp.cols,height:imgWarp.rows}}registry.register("warp",warp);

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "ppu-ocv",
+  "version": "0.0.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",
+    "image-processor",
+    "canvas",
+    "threshold",
+    "computer-vision",
+    "opencv-js",
+    "perspective-transformation",
+    "edge-detection",
+    "contours",
+    "pipeline",
+    "type-safe",
+    "modular",
+    "chainable",
+    "bun"
+  ],
+  "author": "snowfluke",
+  "license": "MIT",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "scripts": {
+    "task": "bun scripts/task.ts",
+    "build:test": "bun task build && bun test",
+    "build:publish": "bun task build && bun task report-size && bun task publish",
+    "lint": "eslint ./src",
+    "lint:fix": "eslint ./src --fix"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "latest",
+    "@types/bun": "latest",
+    "@types/uglify-js": "latest",
+    "eslint": "latest",
+    "eslint-plugin-jsdoc": "latest",
+    "mitata": "latest",
+    "tsx": "latest",
+    "typescript": "latest",
+    "typescript-eslint": "latest",
+    "uglify-js": ">=2.4.24"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PT-Perkasa-Pilar-Utama/ppu-ocv.git"
+  },
+  "dependencies": {
+    "@napi-rs/canvas": "^0.1.69",
+    "@techstark/opencv-js": "^4.10.0-release.1"
+  }
+}

package/pipeline/index.d.ts

@@ -0,0 +1,26 @@
+export { executeOperation, OperationRegistry, registry } from "./registry";
+export type { OperationFunction, OperationName, OperationOptions, OperationResult, PartialOptions, RegisteredOperations, RequiredOptions, } from "./types";
+import "@/operations/adaptive-threshold";
+import "@/operations/blur";
+import "@/operations/border";
+import "@/operations/canny";
+import "@/operations/dilate";
+import "@/operations/erode";
+import "@/operations/grayscale";
+import "@/operations/invert";
+import "@/operations/morphological-gradient";
+import "@/operations/resize";
+import "@/operations/threshold";
+import "@/operations/warp";
+export type { AdaptiveThresholdOptions } from "@/operations/adaptive-threshold";
+export type { BlurOptions } from "@/operations/blur";
+export type { BorderOptions } from "@/operations/border";
+export type { CannyOptions } from "@/operations/canny";
+export type { DilateOptions } from "@/operations/dilate";
+export type { ErodeOptions } from "@/operations/erode";
+export type { GrayscaleOptions } from "@/operations/grayscale";
+export type { InvertOptions } from "@/operations/invert";
+export type { MorphologicalGradientOptions } from "@/operations/morphological-gradient";
+export type { ResizeOptions } from "@/operations/resize";
+export type { ThresholdOptions } from "@/operations/threshold";
+export type { WarpOptions } from "@/operations/warp";

package/pipeline/index.js

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

package/pipeline/registry.d.ts

@@ -0,0 +1,13 @@
+import type { OperationFunction, OperationName, OperationOptions, OperationResult } from "@/index";
+import cv from "@techstark/opencv-js";
+export declare class OperationRegistry {
+    private operations;
+    private defaultOptions;
+    register<Name extends OperationName>(name: Name, operation: OperationFunction<OperationOptions<Name>>, defaultOptions?: () => Partial<OperationOptions<Name>>): void;
+    getOperation(name: string): OperationFunction<any> | undefined;
+    getDefaultOptionsGenerator(name: string): any;
+    hasOperation(name: string): boolean;
+    getOperationNames(): OperationName[];
+}
+export declare const registry: OperationRegistry;
+export declare function executeOperation<Name extends OperationName>(operationName: Name, img: cv.Mat, options?: Partial<OperationOptions<Name>>): OperationResult;

package/pipeline/registry.js

@@ -0,0 +1 @@
+export class OperationRegistry{operations=new Map;defaultOptions=new Map;register(name,operation,defaultOptions){this.operations.set(name,operation);if(defaultOptions){this.defaultOptions.set(name,defaultOptions)}}getOperation(name){return this.operations.get(name)}getDefaultOptionsGenerator(name){return this.defaultOptions.get(name)||{}}hasOperation(name){return this.operations.has(name)}getOperationNames(){return Array.from(this.operations.keys())}}export let registry=new OperationRegistry;export function executeOperation(operationName,img,options){let operation=registry.getOperation(operationName);if(!operation){throw new Error(`Operation "${operationName}" not found in registry`)}let maybeGenerator=registry.getDefaultOptionsGenerator(operationName);let defaultOptionsGenerator=typeof maybeGenerator==="function"?maybeGenerator:()=>({});let mergedOptions={...defaultOptionsGenerator(),...options};return operation(img,mergedOptions)}

package/pipeline/types.d.ts

@@ -0,0 +1,25 @@
+import cv from "@techstark/opencv-js";
+export interface OperationResult {
+    img: cv.Mat;
+    width: number;
+    height: number;
+}
+declare const RequiredBrand: unique symbol;
+export interface RequiredOptions {
+    [RequiredBrand]?: never;
+}
+declare const PartialBrand: unique symbol;
+export interface PartialOptions {
+    [PartialBrand]?: never;
+}
+export type OperationFunction<T> = (img: cv.Mat, options: T) => OperationResult;
+/**
+ * @description
+ * Central registry mapping operation names to their specific option types.
+ * Operation modules MUST augment this interface.
+ */
+export interface RegisteredOperations {
+}
+export type OperationName = keyof RegisteredOperations;
+export type OperationOptions<N extends OperationName> = RegisteredOperations[N];
+export {};