ppu-ocv 1.7.0 → 3.0.0

package/cv-provider.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Lazy OpenCV accessor.
+ *
+ * In Node (with @techstark/opencv-js installed), `cv` is available after
+ * `import cv from "@techstark/opencv-js"`.
+ *
+ * In the browser, `cv` is set on `globalThis` after OpenCV.js is loaded
+ * (either via a <script> tag or dynamically by `initRuntime()`).
+ *
+ * This module re-exports `cv` as a lazy proxy so that static `import`
+ * resolution does NOT require `@techstark/opencv-js` to be present
+ * as a resolvable bare specifier at module-load time.
+ */
+import type _cvType from "@techstark/opencv-js";
+type CV = typeof _cvType;
+/**
+ * Set the cv instance (called by platform entry points).
+ */
+export declare function setCv(instance: CV): void;
+/**
+ * TypeScript Declaration Merging:
+ * By exporting both a `namespace cv` and a `const cv`, consumers importing `{ cv }`
+ * get BOTH the types (e.g. `cv.Mat`) AND the runtime Proxy object.
+ */
+export declare namespace cv {
+    type Mat = _cvType.Mat;
+    type MatVector = _cvType.MatVector;
+    type Point = _cvType.Point;
+    type Rect = _cvType.Rect;
+    type Size = _cvType.Size;
+    type Scalar = _cvType.Scalar;
+    type AdaptiveThresholdTypes = _cvType.AdaptiveThresholdTypes;
+    type ThresholdTypes = _cvType.ThresholdTypes;
+    type LineTypes = _cvType.LineTypes;
+    type RetrievalModes = _cvType.RetrievalModes;
+    type ContourApproximationModes = _cvType.ContourApproximationModes;
+    type BorderTypes = _cvType.BorderTypes;
+    type InterpolationFlags = _cvType.InterpolationFlags;
+    type ColorConversionCodes = _cvType.ColorConversionCodes;
+    type MorphShapes = _cvType.MorphShapes;
+    type MorphTypes = _cvType.MorphTypes;
+    type int = number;
+}
+export declare const cv: CV;
+export {};

package/cv-provider.js

@@ -0,0 +1 @@
+let _cv=null;function getCv(){if(_cv)return _cv;if(typeof globalThis!=="undefined"&&globalThis.cv){_cv=globalThis.cv||null;return _cv}throw new Error("OpenCV is not loaded. Call ImageProcessor.initRuntime() first.")}export function setCv(instance){_cv=instance;if(typeof globalThis!=="undefined"){globalThis.cv=instance}}export let cv=new Proxy({},{get(_target,prop){if(prop===Symbol.toPrimitive||prop===Symbol.toStringTag){return}return getCv()[prop]},set(_target,prop,value){getCv()[prop]=value;return true},has(_target,prop){try{return prop in getCv()}catch{return false}}});

package/deskew.d.ts

@@ -0,0 +1,68 @@
+import type { CanvasLike } from "./canvas-factory.js";
+/**
+ * Options for configuring the deskew service
+ */
+export interface DeskewOptions {
+    /**
+     * Enable detailed logging of each processing step.
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Remove detected boxes with area below this threshold, in pixels.
+     * Used to filter out noise when detecting text regions.
+     * @default 20
+     */
+    minimumAreaThreshold?: number;
+}
+/**
+ * Service for calculating the skew angle of an image containing text.
+ *
+ * This service analyzes text regions in an image to determine its skew angle
+ * using multiple methods (minAreaRect, baseline analysis, and Hough transform)
+ * to robustly calculate the average text orientation.
+ *
+ * @example
+ * ```ts
+ * import { DeskewService } from 'ppu-ocv';
+ *
+ * const service = new DeskewService({ verbose: true });
+ * const canvas = ...; // your canvas with text
+ * const angle = await service.calculateSkewAngle(canvas);
+ * console.log(`Skew angle: ${angle}°`);
+ *
+ * // Or deskew the image directly
+ * const deskewed = await service.deskewImage(canvas);
+ * ```
+ */
+export declare class DeskewService {
+    private readonly verbose;
+    private readonly minimumAreaThreshold;
+    constructor(options?: DeskewOptions);
+    private log;
+    /**
+     * Calculate the skew angle of text in a probability map or binary image.
+     *
+     * This method processes the input image to detect text regions and calculates
+     * the average skew angle using multiple robust methods.
+     *
+     * @param canvas - Canvas containing a probability map or binary image of text regions
+     * @returns The calculated skew angle in degrees (positive = clockwise, negative = counter-clockwise)
+     */
+    calculateSkewAngle(canvas: CanvasLike): Promise<number>;
+    /**
+     * Deskew an image by detecting its skew angle and rotating it.
+     *
+     * This is a convenience method that combines `calculateSkewAngle()`
+     * with rotation to produce a straightened image.
+     *
+     * @param canvas - Canvas containing the image to deskew
+     * @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

@@ -0,0 +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(error){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(error){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(error){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";

package/image-analysis.d.ts

@@ -3,13 +3,13 @@
  * !IMPORTANT: Ensure ImageProcessor.initRuntime() has been called successfully
  * once before using any functions from this module.
  */
-import type { Canvas } from "./index.js";
+import type { CanvasLike } from "./canvas-factory.js";
 /**
  * Options for calculating mean Lab lightness.
  */
 export interface CalculateMeanLightnessOptions {
     /** The canvas containing the image to be processed. */
-    canvas: Canvas;
+    canvas: CanvasLike;
     /** The target dimensions for analysis (resizes internally). */
     dimension: {
         width: number;
@@ -32,4 +32,4 @@ export declare function calculateMeanNormalizedLabLightness(options: CalculateMe
  * @returns Mean grayscale value (typically 0-255).
  * @throws Error if OpenCV operations fail.
  */
-export declare function calculateMeanGrayscaleValue(canvas: Canvas): number;
+export declare function calculateMeanGrayscaleValue(canvas: CanvasLike): number;

package/image-analysis.js

@@ -1 +1 @@
-import{ImageProcessor,cv}from"./index.js";export 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 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()}}
+import{cv}from"./cv-provider.js";import{ImageProcessor}from"./image-processor.js";export 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 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

@@ -1,6 +1,6 @@
-import { Canvas, cv } from "./index.js";
-import type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, DilateOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationName, OperationOptions, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions } from "./index.js";
-import type { ConvertOptions } from "./pipeline/index.js";
+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";
 type NameWithRequiredOptions = {
     [N in OperationName]: OperationOptions<N> extends RequiredOptions ? N : never;
 }[OperationName];
@@ -11,19 +11,15 @@ export declare class ImageProcessor {
     height: number;
     /**
      * Create an ImageProcessor instance from a Canvas or cv.Mat
-     * @param source Source image as Canvas or cv.Mat
+     * @param source Source image as CanvasLike or cv.Mat
      */
-    constructor(source: Canvas | cv.Mat);
+    constructor(source: CanvasLike | cv.Mat);
     /**
-     * Convert array buffer to canvas
-     */
-    static prepareCanvas(file: ArrayBuffer): Promise<Canvas>;
-    /**
-     * Convert canvas to array buffer
-     */
-    static prepareBuffer(canvas: Canvas): Promise<ArrayBuffer>;
-    /**
-     * Initialize OpenCV runtime, this is recommended to be called before any image processing
+     * Initialize OpenCV runtime. Must be called before any image processing.
+     *
+     * - **Node.js**: Uses `@techstark/opencv-js` from node_modules (loaded by entry point).
+     * - **Browser with bundler**: Resolves `@techstark/opencv-js` via the bundler.
+     * - **Browser without bundler**: Falls back to loading `@techstark/opencv-js` from npm CDN.
      */
     static initRuntime(): Promise<void>;
     /**
@@ -31,47 +27,43 @@ export declare class ImageProcessor {
      * @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<N extends NameWithRequiredOptions>(operationName: N, options: OperationOptions<N>): 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 a registered pipeline operation that has default options.
+     * @param operationName Name of the operation (e.g., "blur")
+     * @param options Optional override of the default options
      */
-    execute<Name extends NameWithOptionalOptions>(operationName: Name, options?: Partial<OperationOptions<Name>>): this;
+    execute<N extends NameWithOptionalOptions>(operationName: N, options?: Partial<OperationOptions<N>>): 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
+    /**
+     * 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
+    /**
+     * 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;
+    /**
+     * Invert image colors
+     * @description Usage order: ideally (after) threshold or adaptiveThreshold
+     * @param options Optional configuration for inversion
+     */
+    invert(options?: Partial<InvertOptions>): this;
     /**
      * Canny edge detection to detect edges in the image
      * @description Usage order: (after) grayscale + blur
@@ -79,11 +71,11 @@ export declare class ImageProcessor {
      */
     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
+     * Dilate image to increase the size of the foreground object
+     * @description Usage order: (after) threshold or edge detection
+     * @param options Dilation configuration options
      */
-    morphologicalGradient(options?: Partial<MorphologicalGradientOptions>): this;
+    dilate(options?: Partial<DilateOptions>): this;
     /**
      * Erode image to reduce noise
      * @description Usage order: (after) threshold or edge detection
@@ -91,29 +83,29 @@ export declare class ImageProcessor {
      */
     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
+     * Add border to image
+     * @description Usage order: independent
+     * @param options Border configuration options
      */
-    dilate(options?: Partial<DilateOptions>): this;
+    border(options?: Partial<BorderOptions>): this;
     /**
      * Resize image to a new width and height
      * @description Usage order: independent
-     *  @param options Resize configuration options
+     * @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;
     /**
      * Rotate image by a given angle
      * @description Usage order: independent
      * @param options Rotate configuration options
      */
     rotate(options: RotateOptions): this;
+    /**
+     * Warp image to a new perspective
+     * @description Usage order: independent
+     * @param options Warp configuration options
+     */
+    warp(options: WarpOptions): this;
     /**
      * Convert image matrix into new matrix type
      * @description Usage order: independent
@@ -121,22 +113,22 @@ export declare class ImageProcessor {
      */
     convert(options: ConvertOptions): this;
     /**
-     * Destroy the image (cv.Mat) stored in image processor state
-     * @kind non-chainable
-     * @returns void
+     * Morphological gradient to highlight the edges in the image
+     * @description Usage order: (after) dilation + erosion (or threshold)
+     * @param options Morphological gradient configuration options
      */
-    destroy(): void;
+    morphologicalGradient(options?: Partial<MorphologicalGradientOptions>): this;
     /**
-     * Convert image to cv.Mat
-     * @kind non-chainable
-     * @returns cv.Mat
+     * Get the result as a cv.Mat
      */
     toMat(): cv.Mat;
     /**
-     * Convert image (cv.Mat) to Canvas
-     * @kind non-chainable
-     * @returns Canvas
+     * Get the result canvas
      */
-    toCanvas(): Canvas;
+    toCanvas(): CanvasLike;
+    /**
+     * Clean up cv.Mat to free memory
+     */
+    destroy(): void;
 }
 export {};

package/image-processor.js

@@ -1 +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){if(file instanceof Canvas)return 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 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 buffer=Buffer.from(base64Data,"base64");let arrayBuffer=new ArrayBuffer(buffer.byteLength);new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));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}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)}rotate(options){return this.execute("rotate",options)}convert(options){return this.execute("convert",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.js";import{executeOperation,registry}from"./index.js";
+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(){if(globalThis.cv?.Mat){setCv(globalThis.cv);return}try{let mod=await import("@techstark/opencv-js");let _cv=mod.default||mod;setCv(_cv);if(!_cv.Mat){await new Promise((res)=>{_cv["onRuntimeInitialized"]=()=>res()})}return}catch{}if(typeof document!=="undefined"){await new Promise((resolve,reject)=>{let script=document.createElement("script");script.src="https://cdn.jsdelivr.net/npm/@techstark/opencv-js@4.10.0-release.1/dist/opencv.js";script.async=true;script.onload=()=>{let g=globalThis;if(g.cv?.Mat){setCv(g.cv);resolve()}else if(g.cv){g.cv["onRuntimeInitialized"]=()=>{setCv(g.cv);resolve()}}else{reject(new Error("OpenCV.js loaded but cv not found on globalThis"))}};script.onerror=()=>reject(new Error("Failed to load @techstark/opencv-js from CDN"));document.head.appendChild(script)});return}throw new Error("Cannot initialize OpenCV runtime. Install @techstark/opencv-js or run in a browser.")}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(e){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,setCv}from"./cv-provider.js";import{executeOperation}from"./pipeline/index.js";

package/index.canvas-web.d.ts

@@ -0,0 +1,6 @@
+export type { BoundingBox, Coordinate, Points } from "./index.interface.js";
+export { getPlatform, setPlatform } from "./canvas-factory.js";
+export type { CanvasLike, CanvasPlatform, Context2DLike, } from "./canvas-factory.js";
+export { webPlatform } from "./platform/web.js";
+export { CanvasToolkitBase as CanvasToolkit, CanvasToolkitBase, type ContourLike, } from "./canvas-toolkit.base.js";
+export { CanvasProcessor } from "./canvas-processor.js";

package/index.canvas-web.js

@@ -0,0 +1 @@
+import{setPlatform}from"./canvas-factory.js";import{webPlatform}from"./platform/web.js";setPlatform(webPlatform);export{getPlatform,setPlatform}from"./canvas-factory.js";export{webPlatform}from"./platform/web.js";export{CanvasToolkitBase as CanvasToolkit,CanvasToolkitBase}from"./canvas-toolkit.base.js";export{CanvasProcessor}from"./canvas-processor.js";

package/index.canvas.d.ts

@@ -0,0 +1,8 @@
+export { Canvas, createCanvas, ImageData, loadImage } from "@napi-rs/canvas";
+export type { SKRSContext2D } from "@napi-rs/canvas";
+export type { BoundingBox, Coordinate, Points } from "./index.interface.js";
+export { getPlatform, setPlatform } from "./canvas-factory.js";
+export type { CanvasLike, CanvasPlatform, Context2DLike, } from "./canvas-factory.js";
+export { CanvasToolkitBase, type ContourLike } from "./canvas-toolkit.base.js";
+export { CanvasToolkit } from "./canvas-toolkit.js";
+export { CanvasProcessor } from "./canvas-processor.js";

package/index.canvas.js

@@ -0,0 +1 @@
+import{setPlatform}from"./canvas-factory.js";import{nodePlatform}from"./platform/node.js";setPlatform(nodePlatform);export{Canvas,createCanvas,ImageData,loadImage}from"@napi-rs/canvas";export{getPlatform,setPlatform}from"./canvas-factory.js";export{CanvasToolkitBase}from"./canvas-toolkit.base.js";export{CanvasToolkit}from"./canvas-toolkit.js";export{CanvasProcessor}from"./canvas-processor.js";

package/index.d.ts

@@ -1,11 +1,16 @@
-import cv from "@techstark/opencv-js";
+import { cv } from "./cv-provider.js";
 export { cv };
 export { Canvas, createCanvas, ImageData, loadImage } from "@napi-rs/canvas";
 export type { SKRSContext2D } from "@napi-rs/canvas";
 export type { BoundingBox, Coordinate, Points } from "./index.interface.js";
 export { executeOperation, OperationRegistry, registry, } from "./pipeline/index.js";
+export { getPlatform, setPlatform } from "./canvas-factory.js";
+export type { CanvasLike, CanvasPlatform, Context2DLike, } from "./canvas-factory.js";
+export { CanvasToolkitBase, type ContourLike } from "./canvas-toolkit.base.js";
 export { CanvasToolkit } from "./canvas-toolkit.js";
+export { CanvasProcessor } from "./canvas-processor.js";
 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";

package/index.js

@@ -1 +1 @@
-import cv from"@techstark/opencv-js";export{cv};export{Canvas,createCanvas,ImageData,loadImage}from"@napi-rs/canvas";export{executeOperation,OperationRegistry,registry}from"./pipeline/index.js";export{CanvasToolkit}from"./canvas-toolkit.js";export{Contours}from"./contours.js";export{calculateMeanGrayscaleValue,calculateMeanNormalizedLabLightness}from"./image-analysis.js";export{ImageProcessor}from"./image-processor.js";
+import _cv from"@techstark/opencv-js";import{cv,setCv}from"./cv-provider.js";setCv(_cv);export{cv};import{setPlatform}from"./canvas-factory.js";import{nodePlatform}from"./platform/node.js";setPlatform(nodePlatform);export{Canvas,createCanvas,ImageData,loadImage}from"@napi-rs/canvas";export{executeOperation,OperationRegistry,registry}from"./pipeline/index.js";export{getPlatform,setPlatform}from"./canvas-factory.js";export{CanvasToolkitBase}from"./canvas-toolkit.base.js";export{CanvasToolkit}from"./canvas-toolkit.js";export{CanvasProcessor}from"./canvas-processor.js";export{Contours}from"./contours.js";export{calculateMeanGrayscaleValue,calculateMeanNormalizedLabLightness}from"./image-analysis.js";export{ImageProcessor}from"./image-processor.js";export{DeskewService}from"./deskew.js";

package/index.web.d.ts

@@ -0,0 +1,14 @@
+import { cv } from "./cv-provider.js";
+export { cv };
+export { getPlatform, setPlatform } from "./canvas-factory.js";
+export type { CanvasLike, CanvasPlatform, Context2DLike, } from "./canvas-factory.js";
+export { webPlatform } from "./platform/web.js";
+export type { BoundingBox, Coordinate, Points } from "./index.interface.js";
+export { executeOperation, OperationRegistry, registry, } from "./pipeline/index.js";
+export { CanvasToolkitBase as CanvasToolkit, CanvasToolkitBase, type ContourLike, } from "./canvas-toolkit.base.js";
+export { CanvasProcessor } from "./canvas-processor.js";
+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";

package/index.web.js

@@ -0,0 +1 @@
+import{cv}from"./cv-provider.js";export{cv};import{setPlatform}from"./canvas-factory.js";import{webPlatform}from"./platform/web.js";setPlatform(webPlatform);export{getPlatform,setPlatform}from"./canvas-factory.js";export{webPlatform}from"./platform/web.js";export{executeOperation,OperationRegistry,registry}from"./pipeline/index.js";export{CanvasToolkitBase as CanvasToolkit,CanvasToolkitBase}from"./canvas-toolkit.base.js";export{CanvasProcessor}from"./canvas-processor.js";export{Contours}from"./contours.js";export{calculateMeanGrayscaleValue,calculateMeanNormalizedLabLightness}from"./image-analysis.js";export{ImageProcessor}from"./image-processor.js";export{DeskewService}from"./deskew.js";

package/operations/adaptive-threshold.d.ts

@@ -1,6 +1,6 @@
-import type { OperationResult, PartialOptions } from "../index.js";
-import { cv } from "../index.js";
-declare module "../index" {
+import { cv } from "../cv-provider.js";
+import type { OperationResult, PartialOptions } from "../pipeline/types.js";
+declare module "../pipeline/types" {
     interface RegisteredOperations {
         adaptiveThreshold: AdaptiveThresholdOptions;
     }

package/operations/adaptive-threshold.js

@@ -1 +1 @@
-import{cv,registry}from"../index.js";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);
+import{cv}from"../cv-provider.js";import{registry}from"../pipeline/registry.js";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

@@ -1,6 +1,6 @@
-import type { OperationResult, PartialOptions } from "../index.js";
-import { cv } from "../index.js";
-declare module "../index" {
+import { cv } from "../cv-provider.js";
+import type { OperationResult, PartialOptions } from "../pipeline/types.js";
+declare module "../pipeline/types" {
     interface RegisteredOperations {
         blur: BlurOptions;
     }

package/operations/blur.js

@@ -1 +1 @@
-import{cv,registry}from"../index.js";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);
+import{cv}from"../cv-provider.js";import{registry}from"../pipeline/registry.js";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

@@ -1,6 +1,6 @@
-import type { OperationResult, PartialOptions } from "../index.js";
-import { cv } from "../index.js";
-declare module "../index" {
+import type { OperationResult, PartialOptions } from "../pipeline/types.js";
+import { cv } from "../cv-provider.js";
+declare module "../pipeline/types" {
     interface RegisteredOperations {
         border: BorderOptions;
     }

package/operations/border.js

@@ -1 +1 @@
-import{cv,registry}from"../index.js";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);
+import{cv}from"../cv-provider.js";import{registry}from"../pipeline/registry.js";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

@@ -1,6 +1,6 @@
-import type { OperationResult, PartialOptions } from "../index.js";
-import { cv } from "../index.js";
-declare module "../index" {
+import type { OperationResult, PartialOptions } from "../pipeline/types.js";
+import { cv } from "../cv-provider.js";
+declare module "../pipeline/types" {
     interface RegisteredOperations {
         canny: CannyOptions;
     }

package/operations/canny.js

@@ -1 +1 @@
-import{cv,registry}from"../index.js";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);
+import{cv}from"../cv-provider.js";import{registry}from"../pipeline/registry.js";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/convert.d.ts

@@ -1,6 +1,6 @@
-import type { OperationResult, RequiredOptions } from "../index.js";
-import { cv } from "../index.js";
-declare module "../index" {
+import type { OperationResult, RequiredOptions } from "../pipeline/types.js";
+import { cv } from "../cv-provider.js";
+declare module "../pipeline/types" {
     interface RegisteredOperations {
         convert: ConvertOptions;
     }

package/operations/convert.js

@@ -1 +1 @@
-import{cv,registry}from"../index.js";export function convert(img,options){if(options.rtype===undefined){throw new Error("Invalid options: rtype is required")}let imgConvert=new cv.Mat;img.convertTo(imgConvert,options.rtype);img.delete();return{img:imgConvert,width:imgConvert.cols,height:imgConvert.rows}}registry.register("convert",convert);
+import{cv}from"../cv-provider.js";import{registry}from"../pipeline/registry.js";export function convert(img,options){if(options.rtype===undefined){throw new Error("Invalid options: rtype is required")}let imgConvert=new cv.Mat;img.convertTo(imgConvert,options.rtype);img.delete();return{img:imgConvert,width:imgConvert.cols,height:imgConvert.rows}}registry.register("convert",convert);

package/operations/dilate.d.ts

@@ -1,6 +1,6 @@
-import type { OperationResult, PartialOptions } from "../index.js";
-import { cv } from "../index.js";
-declare module "../index" {
+import type { OperationResult, PartialOptions } from "../pipeline/types.js";
+import { cv } from "../cv-provider.js";
+declare module "../pipeline/types" {
     interface RegisteredOperations {
         dilate: DilateOptions;
     }

package/operations/dilate.js

@@ -1 +1 @@
-import{cv,registry}from"../index.js";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);
+import{cv}from"../cv-provider.js";import{registry}from"../pipeline/registry.js";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

@@ -1,6 +1,6 @@
-import type { OperationResult, PartialOptions } from "../index.js";
-import { cv } from "../index.js";
-declare module "../index" {
+import type { OperationResult, PartialOptions } from "../pipeline/types.js";
+import { cv } from "../cv-provider.js";
+declare module "../pipeline/types" {
     interface RegisteredOperations {
         erode: ErodeOptions;
     }

package/operations/erode.js

@@ -1 +1 @@
-import{cv,registry}from"../index.js";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);
+import{cv}from"../cv-provider.js";import{registry}from"../pipeline/registry.js";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

@@ -1,6 +1,6 @@
-import type { OperationResult, PartialOptions } from "../index.js";
-import { cv } from "../index.js";
-declare module "../index" {
+import type { OperationResult, PartialOptions } from "../pipeline/types.js";
+import { cv } from "../cv-provider.js";
+declare module "../pipeline/types" {
     interface RegisteredOperations {
         grayscale: GrayscaleOptions;
     }

package/operations/grayscale.js

@@ -1 +1 @@
-import{cv,registry}from"../index.js";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);
+import{cv}from"../cv-provider.js";import{registry}from"../pipeline/registry.js";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

@@ -1,6 +1,6 @@
-import type { OperationResult, PartialOptions } from "../index.js";
-import { cv } from "../index.js";
-declare module "../index" {
+import type { OperationResult, PartialOptions } from "../pipeline/types.js";
+import { cv } from "../cv-provider.js";
+declare module "../pipeline/types" {
     interface RegisteredOperations {
         invert: InvertOptions;
     }

package/operations/invert.js

@@ -1 +1 @@
-import{cv,registry}from"../index.js";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);
+import{cv}from"../cv-provider.js";import{registry}from"../pipeline/registry.js";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

@@ -1,6 +1,6 @@
-import type { OperationResult, PartialOptions } from "../index.js";
-import { cv } from "../index.js";
-declare module "../index" {
+import type { OperationResult, PartialOptions } from "../pipeline/types.js";
+import { cv } from "../cv-provider.js";
+declare module "../pipeline/types" {
     interface RegisteredOperations {
         morphologicalGradient: MorphologicalGradientOptions;
     }