monocr 0.1.1 → 0.1.2

package/README.md

@@ -13,21 +13,22 @@ npm install monocr
 ```javascript
 const { read_image } = require("monocr");
 
-const text = await read_image("path/to/image.jpg", "model.onnx", "charset.txt");
+// Auto-downloads model on first run
+const text = await read_image("path/to/image.jpg");
 console.log(text);
 ```
 
 ## API
 
-### read_image(imagePath, modelPath, charsetPath)
+### 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`)
+- `modelPath` - (Optional) Path to ONNX model. Defaults to auto-downloaded model.
+- `charsetPath` - (Optional) Path to charset file. Defaults to auto-downloaded file.
 
 **Returns:** `Promise<string>` - Recognized text
 
@@ -104,11 +105,15 @@ node examples/simple.js
 
 ## Model Files
 
-This package requires the ONNX model and charset files. Download them from:
+Models are **automatically downloaded** on first use to `~/.monocr/models/`.
 
-- [GitHub Releases](https://github.com/janakh/monocr-onnx/releases)
+You can also trigger a manual download:
 
-Place them in a `model/` directory or specify custom paths in the API calls.
+```bash
+monocr download
+```
+
+Can also specify custom model paths if you prefer offline usage without the default cache.
 
 ## License
 

package/bin/monocr.js

@@ -13,8 +13,8 @@ program
 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')
+    .option('-m, --model <path>', 'Path to ONNX model (optional, auto-downloads)')
+    .option('-c, --charset <path>', 'Path to charset file (optional, auto-downloads)')
     .action(async (imagePath, options) => {
         try {
             const text = await read_image(imagePath, options.model, options.charset);
@@ -28,8 +28,8 @@ program
 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')
+    .option('-m, --model <path>', 'Path to ONNX model (optional, auto-downloads)')
+    .option('-c, --charset <path>', 'Path to charset file (optional, auto-downloads)')
     .action(async (pdfPath, options) => {
         try {
             const pages = await read_pdf(pdfPath, options.model, options.charset);
@@ -47,8 +47,8 @@ program
 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('-m, --model <path>', 'Path to ONNX model (optional, auto-downloads)')
+    .option('-c, --charset <path>', 'Path to charset file (optional, auto-downloads)')
     .option('-o, --output <path>', 'Output file for results (optional)')
     .action(async (directory, options) => {
         try {
@@ -82,4 +82,18 @@ program
         }
     });
 
+program
+    .command('download')
+    .description('Download model files to local cache')
+    .action(async () => {
+        try {
+            const { MonOCR } = require('../src/index');
+            const ocr = new MonOCR();
+            await ocr.modelManager.downloadModels();
+        } catch (err) {
+            console.error('Error:', err.message);
+            process.exit(1);
+        }
+    });
+
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monocr",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Cross-platform Mon (mnw) language OCR using ONNX Runtime. Supports Node.js.",
   "main": "src/index.js",
   "bin": {

package/src/index.js

@@ -12,11 +12,11 @@ module.exports = {
 /**
  * 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
+ * @param {string} modelPath - Path to ONNX model (optional, auto-downloads if not provided)
+ * @param {string} charsetPath - Path to charset file (optional, auto-downloads if not provided)
  * @returns {Promise<string>} Recognized text
  */
-async function read_image(imagePath, modelPath = '../model/monocr.onnx', charsetPath = '../model/charset.txt') {
+async function read_image(imagePath, modelPath = null, charsetPath = null) {
     const ocr = new MonOCR(modelPath, charsetPath);
     await ocr.init();
     const results = await ocr.predictPage(imagePath);
@@ -26,11 +26,11 @@ async function read_image(imagePath, modelPath = '../model/monocr.onnx', charset
 /**
  * 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
+ * @param {string} modelPath - Path to ONNX model (optional, auto-downloads if not provided)
+ * @param {string} charsetPath - Path to charset file (optional, auto-downloads if not provided)
  * @returns {Promise<string[]>} Array of text per page
  */
-async function read_pdf(pdfPath, modelPath = '../model/monocr.onnx', charsetPath = '../model/charset.txt') {
+async function read_pdf(pdfPath, modelPath = null, charsetPath = null) {
     const { fromPath } = require('pdf2pic');
     const path = require('path');
     const fs = require('fs');
@@ -76,11 +76,11 @@ async function read_pdf(pdfPath, modelPath = '../model/monocr.onnx', charsetPath
  * 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
+ * @param {string} modelPath - Path to ONNX model (optional, auto-downloads if not provided)
+ * @param {string} charsetPath - Path to charset file (optional, auto-downloads if not provided)
  * @returns {Promise<{text: string, accuracy: number}>}
  */
-async function read_image_with_accuracy(imagePath, groundTruth, modelPath = '../model/monocr.onnx', charsetPath = '../model/charset.txt') {
+async function read_image_with_accuracy(imagePath, groundTruth, modelPath = null, charsetPath = null) {
     const text = await read_image(imagePath, modelPath, charsetPath);
     const accuracy = calculateAccuracy(text, groundTruth);
     return { text, accuracy: parseFloat(accuracy) };

package/src/model-manager.js

@@ -0,0 +1,138 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const { pipeline } = require('stream/promises');
+
+class ModelManager {
+    constructor() {
+        // Default cache directory in user's home
+        this.cacheDir = path.join(os.homedir(), '.monocr', 'models');
+        
+        // HuggingFace model URLs
+        this.baseUrl = 'https://huggingface.co/janakhpon/monocr/resolve/main';
+        this.modelFiles = {
+            model: 'onnx/monocr.onnx',
+            charset: 'charset.txt'
+        };
+    }
+
+    /**
+     * Ensure cache directory exists
+     */
+    ensureCacheDir() {
+        if (!fs.existsSync(this.cacheDir)) {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+        }
+    }
+
+    /**
+     * Get local path for a model file
+     */
+    getLocalPath(fileKey) {
+        return path.join(this.cacheDir, path.basename(this.modelFiles[fileKey]));
+    }
+
+    /**
+     * Check if model files exist locally
+     */
+    hasModels() {
+        const modelPath = this.getLocalPath('model');
+        const charsetPath = this.getLocalPath('charset');
+        return fs.existsSync(modelPath) && fs.existsSync(charsetPath);
+    }
+
+    /**
+     * Download a file from HuggingFace
+     */
+    async downloadFile(url, destPath) {
+        return new Promise((resolve, reject) => {
+            const file = fs.createWriteStream(destPath);
+            
+            https.get(url, { headers: { 'User-Agent': 'monocr-npm' } }, (response) => {
+                if (response.statusCode === 302 || response.statusCode === 301) {
+                    // Follow redirect
+                    https.get(response.headers.location, (redirectResponse) => {
+                        const totalSize = parseInt(redirectResponse.headers['content-length'], 10);
+                        let downloadedSize = 0;
+                        
+                        redirectResponse.on('data', (chunk) => {
+                            downloadedSize += chunk.length;
+                            const progress = ((downloadedSize / totalSize) * 100).toFixed(1);
+                            process.stdout.write(`\r  Progress: ${progress}% (${(downloadedSize / 1024 / 1024).toFixed(2)} MB)`);
+                        });
+                        
+                        redirectResponse.pipe(file);
+                        
+                        file.on('finish', () => {
+                            file.close();
+                            process.stdout.write('\n');
+                            resolve();
+                        });
+                    }).on('error', (err) => {
+                        fs.unlink(destPath, () => {});
+                        reject(err);
+                    });
+                } else if (response.statusCode === 200) {
+                    response.pipe(file);
+                    file.on('finish', () => {
+                        file.close();
+                        resolve();
+                    });
+                } else {
+                    reject(new Error(`Failed to download: ${response.statusCode}`));
+                }
+            }).on('error', (err) => {
+                fs.unlink(destPath, () => {});
+                reject(err);
+            });
+            
+            file.on('error', (err) => {
+                fs.unlink(destPath, () => {});
+                reject(err);
+            });
+        });
+    }
+
+    /**
+     * Download all model files
+     */
+    async downloadModels() {
+        this.ensureCacheDir();
+        
+        console.log('Downloading monocr models from HuggingFace...');
+        console.log(`Cache directory: ${this.cacheDir}\n`);
+        
+        // Download model
+        const modelUrl = `${this.baseUrl}/${this.modelFiles.model}`;
+        const modelPath = this.getLocalPath('model');
+        console.log('Downloading monocr.onnx...');
+        await this.downloadFile(modelUrl, modelPath);
+        console.log('✓ Model downloaded\n');
+        
+        // Download charset
+        const charsetUrl = `${this.baseUrl}/${this.modelFiles.charset}`;
+        const charsetPath = this.getLocalPath('charset');
+        console.log('Downloading charset.txt...');
+        await this.downloadFile(charsetUrl, charsetPath);
+        console.log('✓ Charset downloaded\n');
+        
+        console.log('All models downloaded successfully!');
+    }
+
+    /**
+     * Get model paths, downloading if needed
+     */
+    async getModelPaths() {
+        if (!this.hasModels()) {
+            await this.downloadModels();
+        }
+        
+        return {
+            modelPath: this.getLocalPath('model'),
+            charsetPath: this.getLocalPath('charset')
+        };
+    }
+}
+
+module.exports = ModelManager;

package/src/monocr.js

@@ -2,14 +2,16 @@ const ort = require('onnxruntime-node');
 const sharp = require('sharp');
 const fs = require('fs');
 const LineSegmenter = require('./segmenter');
+const ModelManager = require('./model-manager');
 
 class MonOCR {
-    constructor(modelPath, charsetPath) {
+    constructor(modelPath = null, charsetPath = null) {
         this.modelPath = modelPath;
         this.charsetPath = charsetPath;
         this.session = null;
         this.charset = "";
         this.segmenter = new LineSegmenter();
+        this.modelManager = new ModelManager();
         
         // Metadata
         this.targetHeight = 64;
@@ -18,6 +20,14 @@ class MonOCR {
 
     async init() {
         if (this.session) return;
+        
+        // If paths not provided, use auto-download
+        if (!this.modelPath || !this.charsetPath) {
+            const paths = await this.modelManager.getModelPaths();
+            this.modelPath = this.modelPath || paths.modelPath;
+            this.charsetPath = this.charsetPath || paths.charsetPath;
+        }
+        
         this.session = await ort.InferenceSession.create(this.modelPath);
         if (this.charsetPath) {
             this.charset = fs.readFileSync(this.charsetPath, 'utf-8').trim();