nbis-wrapper-js 0.1.0 → 0.3.0

package/README.md

@@ -52,6 +52,26 @@ Stream inputs also accept `inputName`/`inputExtension` (for tools that infer for
 from filenames). For `Bozorth3`, you can pass `{ input, label }` to keep stable
 `probe`/`gallery` identifiers in results.
 
+## Image Auto-Convert (default on)
+
+`Mindtct` and `Nfiq` can auto-convert PNG/JPEG inputs into WSQ before invoking NBIS.
+This is enabled by default and can be disabled via the constructor.
+
+```ts
+import { Mindtct } from 'nbis-wrapper-js';
+
+const mindtct = new Mindtct({ autoConvert: false });
+
+// Or tune WSQ conversion:
+const tuned = new Mindtct({
+  autoConvert: {
+    wsqBitrate: 0.75,
+    ppi: 500,
+    upscale: { enabled: true, minSize: 256 }
+  }
+});
+```
+
 ```ts
 import fs from 'fs';
 import { Cwsq } from 'nbis-wrapper-js';

package/dist/src/image-convert.d.ts

@@ -0,0 +1,26 @@
+export type AutoConvertConfig = {
+    enabled?: boolean;
+    wsqBitrate?: number;
+    ppi?: number;
+    upscale?: boolean | AutoConvertUpscaleConfig;
+};
+export type AutoConvertUpscaleConfig = {
+    enabled?: boolean;
+    minSize?: number;
+};
+export type NormalizedAutoConvertConfig = {
+    enabled: boolean;
+    wsqBitrate: number;
+    ppi?: number;
+    upscale: {
+        enabled: boolean;
+        minSize: number;
+    };
+};
+export type PreparedImage = {
+    path: string;
+    cleanup?: () => void;
+    converted?: boolean;
+};
+export declare function prepareFingerprintImageSync(inputPath: string, options?: boolean | AutoConvertConfig, tempDir?: string): PreparedImage;
+export declare function normalizeAutoConvertConfig(options?: boolean | AutoConvertConfig): NormalizedAutoConvertConfig;

package/dist/src/image-convert.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareFingerprintImageSync = prepareFingerprintImageSync;
+exports.normalizeAutoConvertConfig = normalizeAutoConvertConfig;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const pngjs_1 = require("pngjs");
+const jpeg_js_1 = __importDefault(require("jpeg-js"));
+const nbis_runtime_1 = require("./nbis-runtime");
+const SUPPORTED_ANSI_NIST_EXTENSIONS = new Set(['.an2', '.an2k', '.an2k7', '.eft']);
+function normalizeAutoConvert(config) {
+    const defaultUpscale = { enabled: false, minSize: 256 };
+    if (config == null) {
+        return { enabled: true, wsqBitrate: 0.75, upscale: defaultUpscale };
+    }
+    if (typeof config === 'boolean') {
+        return { enabled: config, wsqBitrate: 0.75, upscale: defaultUpscale };
+    }
+    const upscale = config.upscale == null
+        ? defaultUpscale
+        : typeof config.upscale === 'boolean'
+            ? { enabled: config.upscale, minSize: defaultUpscale.minSize }
+            : {
+                enabled: config.upscale.enabled ?? defaultUpscale.enabled,
+                minSize: config.upscale.minSize ?? defaultUpscale.minSize
+            };
+    return {
+        enabled: config.enabled ?? true,
+        wsqBitrate: config.wsqBitrate ?? 0.75,
+        ppi: config.ppi,
+        upscale
+    };
+}
+function detectFormat(inputPath) {
+    const ext = path_1.default.extname(inputPath).toLowerCase();
+    if (ext === '.wsq') {
+        return 'wsq';
+    }
+    if (SUPPORTED_ANSI_NIST_EXTENSIONS.has(ext)) {
+        return 'ansi-nist';
+    }
+    const fd = fs_1.default.openSync(inputPath, 'r');
+    try {
+        const header = Buffer.alloc(8);
+        const bytes = fs_1.default.readSync(fd, header, 0, header.length, 0);
+        if (bytes >= 8 && header.slice(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+            return 'png';
+        }
+        if (bytes >= 3 && header[0] === 0xff && header[1] === 0xd8 && header[2] === 0xff) {
+            return 'jpeg';
+        }
+    }
+    finally {
+        fs_1.default.closeSync(fd);
+    }
+    return 'unknown';
+}
+function toGrayscale(rgba) {
+    const pixelCount = Math.floor(rgba.length / 4);
+    const gray = Buffer.alloc(pixelCount);
+    for (let i = 0; i < pixelCount; i += 1) {
+        const idx = i * 4;
+        const r = rgba[idx];
+        const g = rgba[idx + 1];
+        const b = rgba[idx + 2];
+        gray[i] = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+    }
+    return gray;
+}
+function upscaleNearest(pixels, width, height, newWidth, newHeight) {
+    const scaled = Buffer.alloc(newWidth * newHeight);
+    for (let y = 0; y < newHeight; y += 1) {
+        const srcY = Math.min(height - 1, Math.floor((y * height) / newHeight));
+        for (let x = 0; x < newWidth; x += 1) {
+            const srcX = Math.min(width - 1, Math.floor((x * width) / newWidth));
+            scaled[y * newWidth + x] = pixels[srcY * width + srcX];
+        }
+    }
+    return scaled;
+}
+function decodeImage(inputPath, format) {
+    const data = fs_1.default.readFileSync(inputPath);
+    if (format === 'png') {
+        const decoded = pngjs_1.PNG.sync.read(data);
+        return { width: decoded.width, height: decoded.height, pixels: toGrayscale(decoded.data) };
+    }
+    const decoded = jpeg_js_1.default.decode(data, { useTArray: true });
+    if (!decoded || !decoded.data) {
+        throw new Error('jpeg decode failed.');
+    }
+    return { width: decoded.width, height: decoded.height, pixels: toGrayscale(Buffer.from(decoded.data)) };
+}
+function replaceExtension(inputPath, outputExtension) {
+    const parsed = path_1.default.parse(inputPath);
+    const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
+    return path_1.default.join(parsed.dir, `${parsed.name}${ext}`);
+}
+function convertToWsq(inputPath, tempDir, config) {
+    const format = detectFormat(inputPath);
+    if (format !== 'png' && format !== 'jpeg') {
+        return inputPath;
+    }
+    const decoded = decodeImage(inputPath, format);
+    let width = decoded.width;
+    let height = decoded.height;
+    let pixels = decoded.pixels;
+    if (config.upscale.enabled) {
+        const minSize = config.upscale.minSize;
+        if (width < minSize || height < minSize) {
+            const scale = Math.max(minSize / width, minSize / height);
+            const newWidth = Math.ceil(width * scale);
+            const newHeight = Math.ceil(height * scale);
+            pixels = upscaleNearest(pixels, width, height, newWidth, newHeight);
+            width = newWidth;
+            height = newHeight;
+        }
+    }
+    const rawPath = path_1.default.join(tempDir, 'input.raw');
+    fs_1.default.writeFileSync(rawPath, pixels);
+    const rawAttrs = [width, height, 8];
+    if (config.ppi != null) {
+        rawAttrs.push(config.ppi);
+    }
+    const args = [String(config.wsqBitrate), 'wsq', rawPath, '-raw_in', rawAttrs.join(',')];
+    const result = (0, nbis_runtime_1.runNbis)('cwsq', args);
+    (0, nbis_runtime_1.assertSuccess)(result, 'cwsq (auto-convert)');
+    return replaceExtension(rawPath, 'wsq');
+}
+function prepareFingerprintImageSync(inputPath, options, tempDir) {
+    const config = normalizeAutoConvert(options);
+    if (!config.enabled) {
+        return { path: inputPath };
+    }
+    const format = detectFormat(inputPath);
+    if (format === 'wsq' || format === 'ansi-nist' || format === 'unknown') {
+        return { path: inputPath };
+    }
+    const ownedTempDir = tempDir ?? fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'nbis-img-'));
+    const convertedPath = convertToWsq(inputPath, ownedTempDir, config);
+    const cleanup = tempDir
+        ? undefined
+        : () => {
+            fs_1.default.rmSync(ownedTempDir, { recursive: true, force: true });
+        };
+    return { path: convertedPath, cleanup, converted: convertedPath !== inputPath };
+}
+function normalizeAutoConvertConfig(options) {
+    return normalizeAutoConvert(options);
+}

package/dist/src/mindtct.d.ts

@@ -1,3 +1,4 @@
+import type { AutoConvertConfig } from './image-convert';
 import type { StreamInput, StreamInputOptions, StreamOutput } from './temp-io';
 export type MindtctDetectOptions = {
     enhanceLowContrast?: boolean;
@@ -19,6 +20,9 @@ export type MindtctDetectResult = {
     stdout: string;
     stderr: string;
 };
+export type MindtctConstructorOptions = {
+    autoConvert?: boolean | AutoConvertConfig;
+};
 export type MindtctStreamOutputs = Partial<Record<keyof MindtctDetectResult['outputs'], StreamOutput>>;
 export type MindtctStreamOptions = MindtctDetectOptions & StreamInputOptions & {
     outputs?: MindtctStreamOutputs;
@@ -30,6 +34,8 @@ export type MindtctStreamResult = {
     stderr: string;
 };
 export declare class Mindtct {
+    private autoConvert;
+    constructor(options?: MindtctConstructorOptions);
     version(): string;
     detect(fingerImagePath: string, outputRoot: string, options?: MindtctDetectOptions): MindtctDetectResult;
     detectStream(input: StreamInput, options?: MindtctStreamOptions): Promise<MindtctStreamResult>;

package/dist/src/mindtct.js

@@ -6,45 +6,56 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mindtct = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const image_convert_1 = require("./image-convert");
 const temp_io_1 = require("./temp-io");
 class Mindtct {
+    constructor(options = {}) {
+        this.autoConvert = (0, image_convert_1.normalizeAutoConvertConfig)(options.autoConvert);
+    }
     version() {
         const result = (0, nbis_runtime_1.runNbis)('mindtct', ['-version']);
         (0, nbis_runtime_1.assertSuccess)(result, 'mindtct -version');
         return result.stdout + result.stderr;
     }
     detect(fingerImagePath, outputRoot, options = {}) {
-        const args = [];
-        if (options.enhanceLowContrast) {
-            args.push('-b');
+        const prepared = (0, image_convert_1.prepareFingerprintImageSync)(fingerImagePath, this.autoConvert);
+        try {
+            const args = [];
+            if (options.enhanceLowContrast) {
+                args.push('-b');
+            }
+            if (options.useM1) {
+                args.push('-m1');
+            }
+            args.push(prepared.path, outputRoot);
+            const result = (0, nbis_runtime_1.runNbis)('mindtct', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'mindtct');
+            const outputs = {
+                mdt: `${outputRoot}.mdt`,
+                xyt: `${outputRoot}.xyt`,
+                brw: `${outputRoot}.brw`,
+                dm: `${outputRoot}.dm`,
+                hcm: `${outputRoot}.hcm`,
+                lcm: `${outputRoot}.lcm`,
+                lfm: `${outputRoot}.lfm`,
+                qm: `${outputRoot}.qm`,
+                min: `${outputRoot}.min`
+            };
+            return {
+                outputs,
+                outputRoot: path_1.default.resolve(outputRoot),
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
         }
-        if (options.useM1) {
-            args.push('-m1');
+        finally {
+            prepared.cleanup?.();
         }
-        args.push(fingerImagePath, outputRoot);
-        const result = (0, nbis_runtime_1.runNbis)('mindtct', args);
-        (0, nbis_runtime_1.assertSuccess)(result, 'mindtct');
-        const outputs = {
-            mdt: `${outputRoot}.mdt`,
-            xyt: `${outputRoot}.xyt`,
-            brw: `${outputRoot}.brw`,
-            dm: `${outputRoot}.dm`,
-            hcm: `${outputRoot}.hcm`,
-            lcm: `${outputRoot}.lcm`,
-            lfm: `${outputRoot}.lfm`,
-            qm: `${outputRoot}.qm`,
-            min: `${outputRoot}.min`
-        };
-        return {
-            outputs,
-            outputRoot: path_1.default.resolve(outputRoot),
-            stdout: result.stdout,
-            stderr: result.stderr
-        };
     }
     async detectStream(input, options = {}) {
         return (0, temp_io_1.withTempDir)(async (tempDir) => {
             const fingerImagePath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const prepared = (0, image_convert_1.prepareFingerprintImageSync)(fingerImagePath, this.autoConvert, tempDir);
             const outputRoot = path_1.default.join(tempDir, 'output');
             const outputToBuffer = options.outputToBuffer ?? false;
             const args = [];
@@ -54,7 +65,7 @@ class Mindtct {
             if (options.useM1) {
                 args.push('-m1');
             }
-            args.push(fingerImagePath, outputRoot);
+            args.push(prepared.path, outputRoot);
             const result = (0, nbis_runtime_1.runNbis)('mindtct', args);
             (0, nbis_runtime_1.assertSuccess)(result, 'mindtct');
             const outputs = {

package/dist/src/nfiq.d.ts

@@ -1,3 +1,4 @@
+import type { AutoConvertConfig } from './image-convert';
 import type { StreamInput, StreamInputOptions, StreamOutputOptions } from './temp-io';
 export type NfiqRecordSelectors = {
     fingerPosition?: string[];
@@ -31,6 +32,9 @@ export type NfiqResult = {
     stdout: string;
     stderr: string;
 };
+export type NfiqConstructorOptions = {
+    autoConvert?: boolean | AutoConvertConfig;
+};
 export type NfiqStreamOptions = Omit<NfiqOptions, 'ansiNistOutputPath'> & StreamInputOptions & {
     ansiNistOutput?: StreamOutputOptions;
 };
@@ -38,6 +42,8 @@ export type NfiqStreamResult = NfiqResult & {
     ansiNistBuffer?: Buffer;
 };
 export declare class Nfiq {
+    private autoConvert;
+    constructor(options?: NfiqConstructorOptions);
     version(): string;
     score(imagePath: string, options?: NfiqOptions): NfiqResult;
     scoreStream(input: StreamInput, options?: NfiqStreamOptions): Promise<NfiqStreamResult>;

package/dist/src/nfiq.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Nfiq = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const image_convert_1 = require("./image-convert");
 const temp_io_1 = require("./temp-io");
 function buildRawAttr(raw) {
     const attrs = [raw.width, raw.height, raw.depth];
@@ -64,39 +65,49 @@ function parseScores(output) {
     });
 }
 class Nfiq {
+    constructor(options = {}) {
+        this.autoConvert = (0, image_convert_1.normalizeAutoConvertConfig)(options.autoConvert);
+    }
     version() {
         const result = (0, nbis_runtime_1.runNbis)('nfiq', ['-version']);
         (0, nbis_runtime_1.assertSuccess)(result, 'nfiq -version');
         return result.stdout + result.stderr;
     }
     score(imagePath, options = {}) {
-        const args = [];
-        if (options.mode === 'verbose') {
-            args.push('-v');
-        }
-        if (options.oldBehavior) {
-            args.push('-o');
-        }
-        if (options.raw) {
-            args.push('-raw', buildRawAttr(options.raw));
+        const prepared = (0, image_convert_1.prepareFingerprintImageSync)(imagePath, this.autoConvert);
+        try {
+            const args = [];
+            if (options.mode === 'verbose') {
+                args.push('-v');
+            }
+            if (options.oldBehavior) {
+                args.push('-o');
+            }
+            if (options.raw) {
+                args.push('-raw', buildRawAttr(options.raw));
+            }
+            addSelectors(args, options.selectors);
+            args.push(prepared.path);
+            if (options.ansiNistOutputPath) {
+                args.push(options.ansiNistOutputPath);
+            }
+            const result = (0, nbis_runtime_1.runNbis)('nfiq', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'nfiq');
+            const output = result.stdout + result.stderr;
+            return {
+                scores: options.mode === 'verbose' ? [] : parseScores(output),
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
         }
-        addSelectors(args, options.selectors);
-        args.push(imagePath);
-        if (options.ansiNistOutputPath) {
-            args.push(options.ansiNistOutputPath);
+        finally {
+            prepared.cleanup?.();
         }
-        const result = (0, nbis_runtime_1.runNbis)('nfiq', args);
-        (0, nbis_runtime_1.assertSuccess)(result, 'nfiq');
-        const output = result.stdout + result.stderr;
-        return {
-            scores: options.mode === 'verbose' ? [] : parseScores(output),
-            stdout: result.stdout,
-            stderr: result.stderr
-        };
     }
     async scoreStream(input, options = {}) {
         return (0, temp_io_1.withTempDir)(async (tempDir) => {
             const imagePath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const prepared = (0, image_convert_1.prepareFingerprintImageSync)(imagePath, this.autoConvert, tempDir);
             const args = [];
             if (options.mode === 'verbose') {
                 args.push('-v');
@@ -108,7 +119,7 @@ class Nfiq {
                 args.push('-raw', buildRawAttr(options.raw));
             }
             addSelectors(args, options.selectors);
-            args.push(imagePath);
+            args.push(prepared.path);
             let ansiNistPath;
             if (options.ansiNistOutput) {
                 ansiNistPath = path_1.default.join(tempDir, 'output.an2k');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nbis-wrapper-js",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Node.js wrappers for NBIS 5.0.0 binaries",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -44,6 +44,10 @@
     "test:nbis-versions": "npm run build && node dist/scripts/test-nbis-versions.js",
     "test": "npm run build && node dist/test/nbis-versions.test.js"
   },
+  "dependencies": {
+    "jpeg-js": "^0.4.4",
+    "pngjs": "^7.0.0"
+  },
   "devDependencies": {
     "@types/node": "^20.14.10",
     "typescript": "^5.4.5"