monocr 0.1.1

package/README.md

@@ -0,0 +1,115 @@
+# monocr (JavaScript/Node.js)
+
+Mon language OCR using ONNX Runtime for Node.js applications.
+
+## Installation
+
+```bash
+npm install monocr
+```
+
+## Quick Start
+
+```javascript
+const { read_image } = require("monocr");
+
+const text = await read_image("path/to/image.jpg", "model.onnx", "charset.txt");
+console.log(text);
+```
+
+## API
+
+### read_image(imagePath, modelPath, charsetPath)
+
+Recognize text from an image file.
+
+**Parameters:**
+
+- `imagePath` - Path to image file (jpg, png)
+- `modelPath` - Path to ONNX model (optional, defaults to `../model/monocr.onnx`)
+- `charsetPath` - Path to charset file (optional, defaults to `../model/charset.txt`)
+
+**Returns:** `Promise<string>` - Recognized text
+
+### read_pdf(pdfPath, modelPath, charsetPath)
+
+Recognize text from a PDF file.
+
+**Parameters:**
+
+- `pdfPath` - Path to PDF file
+- `modelPath` - Path to ONNX model (optional)
+- `charsetPath` - Path to charset file (optional)
+
+**Returns:** `Promise<string[]>` - Array of text per page
+
+### read_image_with_accuracy(imagePath, groundTruth, modelPath, charsetPath)
+
+Recognize text with accuracy measurement.
+
+**Parameters:**
+
+- `imagePath` - Path to image file
+- `groundTruth` - Expected text for accuracy calculation
+- `modelPath` - Path to ONNX model (optional)
+- `charsetPath` - Path to charset file (optional)
+
+**Returns:** `Promise<{text: string, accuracy: number}>` - Text and accuracy percentage
+
+### MonOCR Class
+
+For advanced usage, use the `MonOCR` class directly:
+
+```javascript
+const { MonOCR } = require("monocr");
+
+const ocr = new MonOCR("model.onnx", "charset.txt");
+await ocr.init();
+
+// Single line
+const text = await ocr.predictLine(imageSource);
+
+// Full page (with line segmentation)
+const results = await ocr.predictPage(imagePath);
+```
+
+## CLI
+
+The package includes a command-line tool:
+
+```bash
+# Single image
+monocr image path/to/image.jpg
+
+# PDF файл
+monocr pdf path/to/document.pdf
+
+# Batch processing
+monocr batch path/to/images/ -o results.json
+```
+
+## Examples
+
+See the `examples/` directory for detailed usage examples:
+
+- `simple.js` - Basic image OCR
+- `with-accuracy.js` - OCR with accuracy measurement
+- `batch.js` - Batch processing
+
+Run examples:
+
+```bash
+node examples/simple.js
+```
+
+## Model Files
+
+This package requires the ONNX model and charset files. Download them from:
+
+- [GitHub Releases](https://github.com/janakh/monocr-onnx/releases)
+
+Place them in a `model/` directory or specify custom paths in the API calls.
+
+## License
+
+MIT

package/bin/monocr.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const { read_image, read_pdf } = require('../src/index');
+const fs = require('fs');
+const path = require('path');
+
+program
+    .name('monocr')
+    .description('Mon language OCR using ONNX Runtime')
+    .version('0.1.0');
+
+program
+    .command('image <path>')
+    .description('Recognize text from an image file')
+    .option('-m, --model <path>', 'Path to ONNX model', '../model/monocr.onnx')
+    .option('-c, --charset <path>', 'Path to charset file', '../model/charset.txt')
+    .action(async (imagePath, options) => {
+        try {
+            const text = await read_image(imagePath, options.model, options.charset);
+            console.log(text);
+        } catch (err) {
+            console.error('Error:', err.message);
+            process.exit(1);
+        }
+    });
+
+program
+    .command('pdf <path>')
+    .description('Recognize text from a PDF file')
+    .option('-m, --model <path>', 'Path to ONNX model', '../model/monocr.onnx')
+    .option('-c, --charset <path>', 'Path to charset file', '../model/charset.txt')
+    .action(async (pdfPath, options) => {
+        try {
+            const pages = await read_pdf(pdfPath, options.model, options.charset);
+            pages.forEach((pageText, i) => {
+                console.log(`--- Page ${i + 1} ---`);
+                console.log(pageText);
+                console.log();
+            });
+        } catch (err) {
+            console.error('Error:', err.message);
+            process.exit(1);
+        }
+    });
+
+program
+    .command('batch <directory>')
+    .description('Process all images in a directory')
+    .option('-m, --model <path>', 'Path to ONNX model', '../model/monocr.onnx')
+    .option('-c, --charset <path>', 'Path to charset file', '../model/charset.txt')
+    .option('-o, --output <path>', 'Output file for results (optional)')
+    .action(async (directory, options) => {
+        try {
+            const files = fs.readdirSync(directory)
+                .filter(f => /\.(jpg|jpeg|png)$/i.test(f))
+                .sort();
+            
+            const results = [];
+            
+            for (const file of files) {
+                const filePath = path.join(directory, file);
+                console.error(`Processing: ${file}...`);
+                
+                try {
+                    const text = await read_image(filePath, options.model, options.charset);
+                    results.push({ file, text, success: true });
+                } catch (err) {
+                    results.push({ file, error: err.message, success: false });
+                }
+            }
+            
+            if (options.output) {
+                fs.writeFileSync(options.output, JSON.stringify(results, null, 2));
+                console.error(`Results written to ${options.output}`);
+            } else {
+                console.log(JSON.stringify(results, null, 2));
+            }
+        } catch (err) {
+            console.error('Error:', err.message);
+            process.exit(1);
+        }
+    });
+
+program.parse();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "monocr",
+  "version": "0.1.1",
+  "description": "Cross-platform Mon (mnw) language OCR using ONNX Runtime. Supports Node.js.",
+  "main": "src/index.js",
+  "bin": {
+    "monocr": "bin/monocr.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/janakh/monocr-onnx.git",
+    "directory": "js"
+  },
+  "keywords": [
+    "ocr",
+    "mon",
+    "mnw",
+    "onnx",
+    "machine-learning"
+  ],
+  "author": "Janakh",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/janakh/monocr-onnx/issues"
+  },
+  "homepage": "https://github.com/janakh/monocr-onnx/tree/main/js#readme",
+  "files": [
+    "src/",
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "commander": "^11.1.0",
+    "onnxruntime-node": "^1.15.0",
+    "pdf2pic": "^3.2.0",
+    "sharp": "^0.32.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/index.js

@@ -0,0 +1,87 @@
+const MonOCR = require('./monocr');
+const { calculateAccuracy } = require('./utils');
+
+module.exports = {
+    MonOCR,
+    calculateAccuracy,
+    read_image,
+    read_pdf,
+    read_image_with_accuracy
+};
+
+/**
+ * Read text from an image file
+ * @param {string} imagePath - Path to image file
+ * @param {string} modelPath - Path to ONNX model
+ * @param {string} charsetPath - Path to charset file
+ * @returns {Promise<string>} Recognized text
+ */
+async function read_image(imagePath, modelPath = '../model/monocr.onnx', charsetPath = '../model/charset.txt') {
+    const ocr = new MonOCR(modelPath, charsetPath);
+    await ocr.init();
+    const results = await ocr.predictPage(imagePath);
+    return results.map(r => r.text).join('\n');
+}
+
+/**
+ * Read text from a PDF file
+ * @param {string} pdfPath - Path to PDF file
+ * @param {string} modelPath - Path to ONNX model
+ * @param {string} charsetPath - Path to charset file
+ * @returns {Promise<string[]>} Array of text per page
+ */
+async function read_pdf(pdfPath, modelPath = '../model/monocr.onnx', charsetPath = '../model/charset.txt') {
+    const { fromPath } = require('pdf2pic');
+    const path = require('path');
+    const fs = require('fs');
+    const os = require('os');
+    
+    const ocr = new MonOCR(modelPath, charsetPath);
+    await ocr.init();
+    
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'monocr-'));
+    
+    const converter = fromPath(pdfPath, {
+        density: 300,
+        format: 'png',
+        width: 2480,
+        height: 3508,
+        saveFilename: 'page',
+        savePath: tempDir
+    });
+    
+    const pages = [];
+    let pageNum = 1;
+    
+    while (true) {
+        try {
+            const result = await converter(pageNum, { responseType: 'image' });
+            const imagePath = result.path;
+            const results = await ocr.predictPage(imagePath);
+            const pageText = results.map(r => r.text).join('\n');
+            pages.push(pageText);
+            pageNum++;
+        } catch (err) {
+            break;
+        }
+    }
+    
+    // Cleanup temp directory
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    
+    return pages;
+}
+
+/**
+ * Read text from an image with accuracy measurement
+ * @param {string} imagePath - Path to image file
+ * @param {string} groundTruth - Expected text for accuracy calculation
+ * @param {string} modelPath - Path to ONNX model
+ * @param {string} charsetPath - Path to charset file
+ * @returns {Promise<{text: string, accuracy: number}>}
+ */
+async function read_image_with_accuracy(imagePath, groundTruth, modelPath = '../model/monocr.onnx', charsetPath = '../model/charset.txt') {
+    const text = await read_image(imagePath, modelPath, charsetPath);
+    const accuracy = calculateAccuracy(text, groundTruth);
+    return { text, accuracy: parseFloat(accuracy) };
+}

package/src/monocr.js

@@ -0,0 +1,153 @@
+const ort = require('onnxruntime-node');
+const sharp = require('sharp');
+const fs = require('fs');
+const LineSegmenter = require('./segmenter');
+
+class MonOCR {
+    constructor(modelPath, charsetPath) {
+        this.modelPath = modelPath;
+        this.charsetPath = charsetPath;
+        this.session = null;
+        this.charset = "";
+        this.segmenter = new LineSegmenter();
+        
+        // Metadata
+        this.targetHeight = 64;
+        this.targetWidth = 1024;
+    }
+
+    async init() {
+        if (this.session) return;
+        this.session = await ort.InferenceSession.create(this.modelPath);
+        if (this.charsetPath) {
+            this.charset = fs.readFileSync(this.charsetPath, 'utf-8').trim();
+        }
+    }
+
+    /**
+     * Replicates Python's resize_and_pad:
+     * 1. Resize height to 64, maintain aspect ratio.
+     * 2. Pad width to 1024 (white background).
+     * 3. Normalize to [-1, 1].
+     */
+    async preprocess(imageSource) {
+        let sharpImg;
+        if (typeof imageSource.metadata === 'function') {
+            sharpImg = imageSource;
+        } else {
+            sharpImg = sharp(imageSource);
+        }
+        const metadata = await sharpImg.metadata();
+        
+        const scale = this.targetHeight / metadata.height;
+        const newWidth = Math.min(this.targetWidth, Math.round(metadata.width * scale));
+
+        // Create the grayscale resized image
+        const resizedBuffer = await sharpImg
+            .grayscale()
+            .resize({
+                height: this.targetHeight,
+                width: newWidth,
+                fit: 'fill'
+            })
+            .raw()
+            .toBuffer();
+
+        // Create target canvas (1024 width, white background = 255)
+        const totalSize = this.targetHeight * this.targetWidth;
+        const canvas = new Float32Array(totalSize).fill(1.0);
+
+        // Fill canvas with resized image and normalize
+        // Python: canvas = canvas.astype(np.float32) / 127.5 - 1.0
+        // 255 -> 1.0
+        // 0 -> -1.0
+        
+        for (let y = 0; y < this.targetHeight; y++) {
+            for (let x = 0; x < this.targetWidth; x++) {
+                const canvasIdx = y * this.targetWidth + x;
+                if (x < newWidth) {
+                    const imgIdx = y * newWidth + x;
+                    const pixelValue = resizedBuffer[imgIdx];
+                    canvas[canvasIdx] = (pixelValue / 127.5) - 1.0;
+                } else {
+                    // Padding is white
+                    canvas[canvasIdx] = (255 / 127.5) - 1.0; // 1.0
+                }
+            }
+        }
+        
+        return new ort.Tensor('float32', canvas, [1, 1, this.targetHeight, this.targetWidth]); 
+    }
+
+    /**
+     * CTC Greedy Decoding
+     * Ignores blank (0) and contracts repeats.
+     */
+    decode(outputTensor) {
+        const data = outputTensor.data;
+        const dims = outputTensor.dims; // [Batch, Time, Classes]
+        const numClasses = dims[2];
+        const sequenceLength = dims[1];
+
+        const idx2char = {};
+        for (let i = 0; i < this.charset.length; i++) {
+            idx2char[i + 1] = this.charset[i];
+        }
+
+        let decodedText = "";
+        let prevIdx = -1;
+
+        for (let t = 0; t < sequenceLength; t++) {
+             let maxVal = -Infinity;
+             let maxIdx = 0;
+             for (let c = 0; c < numClasses; c++) {
+                 const val = data[t * numClasses + c];
+                 if (val > maxVal) {
+                     maxVal = val;
+                     maxIdx = c;
+                 }
+             }
+             
+             // CTC logic: 0 is blank, ignore repeats
+             if (maxIdx !== 0 && maxIdx !== prevIdx) {
+                 decodedText += idx2char[maxIdx] || "";
+             }
+             prevIdx = maxIdx;
+        }
+
+        return decodedText;
+    }
+
+    async predictLine(imageSource) {
+        if (!this.session) await this.init();
+        
+        const inputTensor = await this.preprocess(imageSource);
+        const feeds = {};
+        feeds[this.session.inputNames[0]] = inputTensor;
+        
+        const results = await this.session.run(feeds);
+        const outputTensor = results[this.session.outputNames[0]];
+        
+        return this.decode(outputTensor);
+    }
+
+    /**
+     * Processes full page: segments into lines and predicts each.
+     */
+    async predictPage(imagePath) {
+        const lines = await this.segmenter.segment(imagePath);
+        const results = [];
+        
+        for (const line of lines) {
+            const text = await this.predictLine(line.img);
+            results.push({
+                text,
+                bbox: line.bbox
+            });
+        }
+        
+        return results;
+    }
+}
+
+module.exports = MonOCR;

package/src/segmenter.js

@@ -0,0 +1,136 @@
+const sharp = require('sharp');
+
+class LineSegmenter {
+    /**
+     * @param {number} minLineH Minimum height of a line to be considered valid.
+     * @param {number} smoothWindow Smoothing window for projection profile.
+     */
+    constructor(minLineH = 10, smoothWindow = 3) {
+        this.minLineH = minLineH;
+        this.smoothWindow = smoothWindow;
+    }
+
+    /**
+     * Segment a document image into text lines.
+     * @param {string|Buffer} imagePath Path to image or Buffer.
+     * @returns {Promise<Array<{img: sharp.Sharp, bbox: {x: number, y: number, w: number, h: number}}>>}
+     */
+    async segment(imagePath) {
+        const image = sharp(imagePath);
+        const { width, height } = await image.metadata();
+        
+        // 1. Get raw grayscale data for thresholding
+        const grayBuffer = await image
+            .grayscale()
+            .raw()
+            .toBuffer();
+
+        // 2. Simple Adaptive-ish Thresholding
+        // Since we don't have CV2's adaptiveThreshold easily, we'll do a simple threshold 
+        // or just use sharp's threshold if we can get the mask.
+        // Actually, to replicate Horizontal Projection, we need the sum of "text" pixels.
+        // We'll treat dark pixels (< 128) as text (since background is white).
+        const binary = new Uint8Array(grayBuffer.length);
+        const hist = new Float32Array(height).fill(0);
+
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const idx = y * width + x;
+                // Threshold: 128 is a safe bet for black text on white paper.
+                // Inverted so text is "high" (1) and background is 0.
+                if (grayBuffer[idx] < 128) {
+                    binary[idx] = 1;
+                    hist[y]++;
+                } else {
+                    binary[idx] = 0;
+                }
+            }
+        }
+
+        // 3. Smoothing projection profile
+        let smoothedHist = hist;
+        if (this.smoothWindow > 1) {
+            smoothedHist = new Float32Array(height);
+            const half = Math.floor(this.smoothWindow / 2);
+            for (let i = 0; i < height; i++) {
+                let sum = 0;
+                let count = 0;
+                for (let j = i - half; j <= i + half; j++) {
+                    if (j >= 0 && j < height) {
+                        sum += hist[j];
+                        count++;
+                    }
+                }
+                smoothedHist[i] = sum / count;
+            }
+        }
+
+        // 4. Gap Detection
+        const nonZeroVals = smoothedHist.filter(v => v > 0);
+        if (nonZeroVals.length === 0) return [];
+
+        const meanDensity = nonZeroVals.reduce((a, b) => a + b, 0) / nonZeroVals.length;
+        const gapThreshold = meanDensity * 0.05;
+
+        const results = [];
+        let start = null;
+
+        for (let y = 0; y < height; y++) {
+            const isText = smoothedHist[y] > gapThreshold;
+            if (isText && start === null) {
+                start = y;
+            } else if (!isText && start !== null) {
+                const end = y;
+                if (end - start >= this.minLineH) {
+                    await this._extractLine(image, grayBuffer, width, height, start, end, results);
+                }
+                start = null;
+            }
+        }
+
+        if (start !== null && (height - start) >= this.minLineH) {
+            await this._extractLine(image, grayBuffer, width, height, start, height, results);
+        }
+
+        return results;
+    }
+
+    async _extractLine(image, grayBuffer, width, height, rStart, rEnd, results) {
+        // Find horizontal bounds within this vertical strip
+        let xMin = width;
+        let xMax = 0;
+        let hasPixels = false;
+
+        for (let y = rStart; y < rEnd; y++) {
+            for (let x = 0; x < width; x++) {
+                if (grayBuffer[y * width + x] < 128) {
+                    if (x < xMin) xMin = x;
+                    if (x > xMax) xMax = x;
+                    hasPixels = true;
+                }
+            }
+        }
+
+        if (!hasPixels) return;
+
+        // Add padding
+        const pad = 4;
+        const y1 = Math.max(0, rStart - pad);
+        const y2 = Math.min(height, rEnd + pad);
+        const x1 = Math.max(0, xMin - pad);
+        const x2 = Math.min(width, xMax + pad);
+
+        const w = x2 - x1;
+        const h = y2 - y1;
+
+        // Crop the line
+        const crop = image.clone().extract({ left: x1, top: y1, width: w, height: h });
+        
+        results.push({
+            img: crop,
+            bbox: { x: x1, y: y1, w, h }
+        });
+    }
+}
+
+module.exports = LineSegmenter;

package/src/utils.js

@@ -0,0 +1,25 @@
+/**
+ * Calculate character error rate between predicted and ground truth text
+ * @param {string} predicted - Predicted text
+ * @param {string} groundTruth - Ground truth text
+ * @returns {number} Accuracy percentage (0-100)
+ */
+function calculateAccuracy(predicted, groundTruth) {
+    if (!groundTruth) return 0;
+    
+    const len = Math.max(predicted.length, groundTruth.length);
+    if (len === 0) return 100;
+    
+    let errors = 0;
+    for (let i = 0; i < len; i++) {
+        if (predicted[i] !== groundTruth[i]) {
+            errors++;
+        }
+    }
+    
+    return ((1 - errors / len) * 100).toFixed(2);
+}
+
+module.exports = {
+    calculateAccuracy
+};