nbis-wrapper-js 0.0.1

package/README.md

@@ -0,0 +1,102 @@
+# nbis-wrapper-js
+
+Node.js wrappers for NBIS 5.0.0 binaries.
+
+This package bundles NBIS binaries and runtime data for macOS arm64 and
+exposes them as TypeScript-friendly classes.
+
+## Install
+
+```bash
+npm install nbis-wrapper-js
+```
+
+## Platform Support
+
+- macOS (darwin) arm64
+- Linux x86_64
+
+## Usage
+
+```ts
+import { Mindtct, Bozorth3, Nfiq } from 'nbis-wrapper-js';
+
+const mindtct = new Mindtct();
+const bozorth3 = new Bozorth3();
+const nfiq = new Nfiq();
+
+// Minutiae extraction
+mindtct.detect('sample.wsq', 'out/sample', { enhanceLowContrast: true });
+
+// Match two xyt files
+const match = bozorth3.matchPair('out/a.xyt', 'out/b.xyt', { m1: false });
+console.log(match.results);
+
+// Quality score
+const score = nfiq.score('sample.wsq');
+console.log(score.scores);
+```
+
+## API Overview
+
+### Fingerprint
+
+- `Mindtct`
+  - `version()`
+  - `detect(fingerImagePath, outputRoot, options)`
+- `Bozorth3`
+  - `version()`
+  - `matchPair(...)`
+  - `matchMatesList(...)`
+  - `matchProbeList(...)`
+  - `matchGalleryList(...)`
+  - `matchWithFixedProbe(...)`
+  - `matchWithFixedProbeList(...)`
+  - `matchWithFixedGallery(...)`
+  - `matchWithFixedGalleryList(...)`
+- `Nfiq`
+  - `version()`
+  - `score(imagePath, options)`
+
+### WSQ
+
+- `Cwsq` / `Dwsq`
+- `Rdwsqcom` / `Wrwsqcom`
+
+### JPEG/JPEG2000
+
+- `Cjpeg` / `Djpeg`
+- `Cjpegb` / `Djpegb`
+- `Cjpegl` / `Djpegl`
+- `Jpegtran`
+- `Cjp2k` / `Djp2k`
+- `Rdjpgcom` / `Wrjpgcom`
+
+### Color/Interleave Helpers
+
+- `Rgb2ycc` / `Ycc2rgb`
+- `Intr2not` / `Not2intr`
+
+### ANSI/NIST Tools
+
+- `An2kTool`
+- `Chkan2k`
+- `Datainfo`
+
+## Notes
+
+- Binaries are invoked directly; NBIS runtime data is bundled and set via `NBIS`.
+- Some IJG/OpenJPEG tools do not exit with `-version` cleanly; the wrapper
+  returns their help output for `version()`.
+
+## Development
+
+```bash
+npm install
+npm run build
+npm run test
+```
+
+## License
+
+Unlicense (see `package.json`).

package/dist/scripts/test-nbis-versions.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../src/index");
+function requireOutput(label, output) {
+    if (!output || !output.trim()) {
+        console.error(`Expected ${label} output.`);
+        process.exit(1);
+    }
+}
+const mindtct = new index_1.Mindtct();
+const bozorth3 = new index_1.Bozorth3();
+const mindtctVersion = mindtct.version();
+requireOutput('mindtct version', mindtctVersion);
+console.log(mindtctVersion.split('\n').slice(0, 2).join('\n'));
+const bozorth3Version = bozorth3.version();
+requireOutput('bozorth3 version', bozorth3Version);
+console.log(bozorth3Version.split('\n').slice(0, 2).join('\n'));

package/dist/src/an2ktool.d.ts

@@ -0,0 +1,14 @@
+export type An2kToolResult = {
+    stdout: string;
+    stderr: string;
+};
+export declare class An2kTool {
+    version(): string;
+    printAll(fileIn: string, fileOut?: string): An2kToolResult;
+    printSelection(selection: string, fileIn: string, fileOut?: string): An2kToolResult;
+    deleteSelection(selection: string, fileIn: string, fileOut?: string): An2kToolResult;
+    substituteValue(selection: string, newValue: string, fileIn: string, fileOut?: string): An2kToolResult;
+    substituteFormatted(selection: string, fmtFile: string, fileIn: string, fileOut?: string): An2kToolResult;
+    insertValue(selection: string, newValue: string, fileIn: string, fileOut?: string): An2kToolResult;
+    insertFormatted(selection: string, fmtFile: string, fileIn: string, fileOut?: string): An2kToolResult;
+}

package/dist/src/an2ktool.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.An2kTool = void 0;
+const nbis_runtime_1 = require("./nbis-runtime");
+function runAn2kTool(args, context) {
+    const result = (0, nbis_runtime_1.runNbis)('an2ktool', args);
+    (0, nbis_runtime_1.assertSuccess)(result, context);
+    return {
+        stdout: result.stdout,
+        stderr: result.stderr
+    };
+}
+function buildFileArgs(fileIn, fileOut) {
+    const args = [fileIn];
+    if (fileOut) {
+        args.push(fileOut);
+    }
+    return args;
+}
+class An2kTool {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('an2ktool', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'an2ktool -version');
+        return result.stdout + result.stderr;
+    }
+    printAll(fileIn, fileOut) {
+        return runAn2kTool(['-print', 'all', ...buildFileArgs(fileIn, fileOut)], 'an2ktool print');
+    }
+    printSelection(selection, fileIn, fileOut) {
+        return runAn2kTool(['-print', selection, ...buildFileArgs(fileIn, fileOut)], 'an2ktool print');
+    }
+    deleteSelection(selection, fileIn, fileOut) {
+        return runAn2kTool(['-delete', selection, ...buildFileArgs(fileIn, fileOut)], 'an2ktool delete');
+    }
+    substituteValue(selection, newValue, fileIn, fileOut) {
+        return runAn2kTool(['-substitute', selection, newValue, ...buildFileArgs(fileIn, fileOut)], 'an2ktool substitute');
+    }
+    substituteFormatted(selection, fmtFile, fileIn, fileOut) {
+        return runAn2kTool(['-substitute', selection, fmtFile, ...buildFileArgs(fileIn, fileOut)], 'an2ktool substitute');
+    }
+    insertValue(selection, newValue, fileIn, fileOut) {
+        return runAn2kTool(['-insert', selection, newValue, ...buildFileArgs(fileIn, fileOut)], 'an2ktool insert');
+    }
+    insertFormatted(selection, fmtFile, fileIn, fileOut) {
+        return runAn2kTool(['-insert', selection, fmtFile, ...buildFileArgs(fileIn, fileOut)], 'an2ktool insert');
+    }
+}
+exports.An2kTool = An2kTool;

package/dist/src/bozorth3.d.ts

@@ -0,0 +1,43 @@
+export type BozorthOptions = {
+    m1?: boolean;
+    maxMinutiae?: number;
+    threshold?: number;
+    quitOnThreshold?: boolean;
+    verbose?: boolean;
+    verboseSection?: string;
+    minMinutiae?: number;
+    maxFiles?: number;
+    probeLines?: string;
+    galleryLines?: string;
+    dryRun?: boolean;
+    noOutput?: boolean;
+    outFormat?: string;
+    outputDir?: string;
+    outputFile?: string;
+    stderrFile?: string;
+    buffered?: boolean;
+    lineBuffered?: boolean;
+};
+export type BozorthResult = {
+    results: Array<{
+        score?: number;
+        probe?: string;
+        gallery?: string;
+        raw: string;
+    }>;
+    stdout: string;
+    stderr: string;
+};
+export declare class Bozorth3 {
+    version(): string;
+    matchPair(probeFile: string, galleryFile: string, options?: BozorthOptions): BozorthResult;
+    matchMatesList(matesListFile: string, options?: BozorthOptions): BozorthResult;
+    matchProbeList(probeListFile: string, galleryFiles?: string[], options?: BozorthOptions): BozorthResult;
+    matchGalleryList(galleryListFile: string, probeFiles?: string[], options?: BozorthOptions): BozorthResult;
+    matchWithFixedProbe(probeFile: string, galleryFiles?: string[], options?: BozorthOptions): BozorthResult;
+    matchWithFixedProbeList(probeFile: string, galleryListFile: string, options?: BozorthOptions): BozorthResult;
+    matchWithFixedGallery(galleryFile: string, probeFiles?: string[], options?: BozorthOptions): BozorthResult;
+    matchWithFixedGalleryList(galleryFile: string, probeListFile: string, options?: BozorthOptions): BozorthResult;
+    private withDefaultFormat;
+    private runMatch;
+}

package/dist/src/bozorth3.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bozorth3 = void 0;
+const nbis_runtime_1 = require("./nbis-runtime");
+function buildBozorthArgs(options = {}) {
+    const args = [];
+    if (options.m1) {
+        args.push('-m1');
+    }
+    if (options.maxMinutiae != null) {
+        args.push('-n', String(options.maxMinutiae));
+    }
+    if (options.threshold != null) {
+        args.push('-T', String(options.threshold));
+    }
+    if (options.quitOnThreshold) {
+        args.push('-q');
+    }
+    if (options.verbose) {
+        args.push('-v');
+    }
+    if (options.verboseSection) {
+        args.push('-A', `verbose=${options.verboseSection}`);
+    }
+    if (options.minMinutiae != null) {
+        args.push('-A', `minminutiae=${options.minMinutiae}`);
+    }
+    if (options.maxFiles != null) {
+        args.push('-A', `maxfiles=${options.maxFiles}`);
+    }
+    if (options.probeLines) {
+        args.push('-A', `plines=${options.probeLines}`);
+    }
+    if (options.galleryLines) {
+        args.push('-A', `glines=${options.galleryLines}`);
+    }
+    if (options.dryRun) {
+        args.push('-A', 'dryrun');
+    }
+    if (options.noOutput) {
+        args.push('-A', 'nooutput');
+    }
+    if (options.outFormat) {
+        args.push('-A', `outfmt=${options.outFormat}`);
+    }
+    if (options.outputDir) {
+        args.push('-O', options.outputDir);
+    }
+    if (options.outputFile) {
+        args.push('-o', options.outputFile);
+    }
+    if (options.stderrFile) {
+        args.push('-e', options.stderrFile);
+    }
+    if (options.buffered) {
+        args.push('-b');
+    }
+    if (options.lineBuffered) {
+        args.push('-l');
+    }
+    return args;
+}
+function parseBozorthOutput(output, outFormat) {
+    const trimmed = output.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const format = outFormat || 's';
+    return trimmed
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .map((line) => {
+        const tokens = line.trim().split(/\s+/);
+        const entry = { raw: line };
+        let index = 0;
+        for (const tokenType of format) {
+            const token = tokens[index++];
+            if (token == null) {
+                break;
+            }
+            if (tokenType === 's') {
+                const score = Number(token);
+                entry.score = Number.isNaN(score) ? undefined : score;
+            }
+            else if (tokenType === 'p') {
+                entry.probe = token;
+            }
+            else if (tokenType === 'g') {
+                entry.gallery = token;
+            }
+        }
+        return entry;
+    });
+}
+class Bozorth3 {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('bozorth3', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'bozorth3 -version');
+        return result.stdout + result.stderr;
+    }
+    matchPair(probeFile, galleryFile, options = {}) {
+        return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), probeFile, galleryFile], options);
+    }
+    matchMatesList(matesListFile, options = {}) {
+        return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-M', matesListFile], options);
+    }
+    matchProbeList(probeListFile, galleryFiles = [], options = {}) {
+        return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-P', probeListFile, ...galleryFiles], options);
+    }
+    matchGalleryList(galleryListFile, probeFiles = [], options = {}) {
+        return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-G', galleryListFile, ...probeFiles], options);
+    }
+    matchWithFixedProbe(probeFile, galleryFiles = [], options = {}) {
+        return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-p', probeFile, ...galleryFiles], options);
+    }
+    matchWithFixedProbeList(probeFile, galleryListFile, options = {}) {
+        return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-p', probeFile, '-G', galleryListFile], options);
+    }
+    matchWithFixedGallery(galleryFile, probeFiles = [], options = {}) {
+        return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-g', galleryFile, ...probeFiles], options);
+    }
+    matchWithFixedGalleryList(galleryFile, probeListFile, options = {}) {
+        return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-g', galleryFile, '-P', probeListFile], options);
+    }
+    withDefaultFormat(options) {
+        if (options.outFormat) {
+            return options;
+        }
+        return {
+            ...options,
+            outFormat: 'spg'
+        };
+    }
+    runMatch(args, options) {
+        const result = (0, nbis_runtime_1.runNbis)('bozorth3', args);
+        (0, nbis_runtime_1.assertSuccess)(result, 'bozorth3');
+        const format = options.outFormat || 'spg';
+        return {
+            results: parseBozorthOutput(result.stdout, format),
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Bozorth3 = Bozorth3;

package/dist/src/chkan2k.d.ts

@@ -0,0 +1,14 @@
+export type Chkan2kOptions = {
+    baseConfigFile?: string;
+    extraConfigFiles?: string[];
+    logLevel?: 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR' | 'FATAL';
+    help?: boolean;
+};
+export type Chkan2kResult = {
+    stdout: string;
+    stderr: string;
+};
+export declare class Chkan2k {
+    version(): string;
+    check(files: string[], options?: Chkan2kOptions): Chkan2kResult;
+}

package/dist/src/chkan2k.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chkan2k = void 0;
+const nbis_runtime_1 = require("./nbis-runtime");
+class Chkan2k {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('chkan2k', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'chkan2k -version');
+        return result.stdout + result.stderr;
+    }
+    check(files, options = {}) {
+        const args = [];
+        if (options.baseConfigFile) {
+            args.push('-b', options.baseConfigFile);
+        }
+        if (options.extraConfigFiles) {
+            options.extraConfigFiles.forEach((file) => args.push('-c', file));
+        }
+        if (options.logLevel) {
+            args.push('-l', options.logLevel);
+        }
+        if (options.help) {
+            args.push('-h');
+        }
+        args.push(...files);
+        const result = (0, nbis_runtime_1.runNbis)('chkan2k', args);
+        (0, nbis_runtime_1.assertSuccess)(result, 'chkan2k');
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Chkan2k = Chkan2k;

package/dist/src/cjp2k.d.ts

@@ -0,0 +1,21 @@
+export type Cjp2kOptions = {
+    inputPath?: string;
+    outputPath?: string;
+    imageDir?: string;
+    outputFormat?: string;
+    rawFormat?: string;
+    nistLossy?: boolean;
+    nistLossless?: boolean;
+    compressionRatios?: number[];
+    psnr?: number[];
+    ppi?: number;
+    extraArgs?: string[];
+};
+export type Cjp2kResult = {
+    stdout: string;
+    stderr: string;
+};
+export declare class Cjp2k {
+    version(): string;
+    compress(options: Cjp2kOptions): Cjp2kResult;
+}

package/dist/src/cjp2k.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cjp2k = void 0;
+const nbis_runtime_1 = require("./nbis-runtime");
+class Cjp2k {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('cjp2k', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'cjp2k -version');
+        return result.stdout + result.stderr;
+    }
+    compress(options) {
+        const args = [];
+        if (options.inputPath) {
+            args.push('-i', options.inputPath);
+        }
+        if (options.outputPath) {
+            args.push('-o', options.outputPath);
+        }
+        if (options.imageDir) {
+            args.push('-ImgDir', options.imageDir);
+        }
+        if (options.outputFormat) {
+            args.push('-OutFor', options.outputFormat);
+        }
+        if (options.rawFormat) {
+            args.push('-F', options.rawFormat);
+        }
+        if (options.nistLossy) {
+            args.push('-NIST-fingerprint-lossy');
+        }
+        if (options.nistLossless) {
+            args.push('-NIST-fingerprint-lossless');
+        }
+        if (options.compressionRatios && options.compressionRatios.length) {
+            args.push('-r', options.compressionRatios.join(','));
+        }
+        if (options.psnr && options.psnr.length) {
+            args.push('-q', options.psnr.join(','));
+        }
+        if (options.ppi != null) {
+            args.push('-PPI', String(options.ppi));
+        }
+        if (options.extraArgs) {
+            args.push(...options.extraArgs);
+        }
+        const result = (0, nbis_runtime_1.runNbis)('cjp2k', args);
+        (0, nbis_runtime_1.assertSuccess)(result, 'cjp2k');
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Cjp2k = Cjp2k;

package/dist/src/cjpeg.d.ts

@@ -0,0 +1,24 @@
+export type CjpegOptions = {
+    quality?: number;
+    grayscale?: boolean;
+    optimize?: boolean;
+    progressive?: boolean;
+    targa?: boolean;
+    dct?: 'int' | 'fast' | 'float';
+    restart?: string | number;
+    smooth?: number;
+    maxMemory?: string;
+    outputPath?: string;
+    verbose?: boolean;
+    debug?: boolean;
+    baseline?: boolean;
+    extraArgs?: string[];
+};
+export type CjpegResult = {
+    stdout: string;
+    stderr: string;
+    outputPath?: string;
+};
+export declare class Cjpeg {
+    compress(inputPath: string, options?: CjpegOptions): CjpegResult;
+}

package/dist/src/cjpeg.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cjpeg = void 0;
+const nbis_runtime_1 = require("./nbis-runtime");
+class Cjpeg {
+    compress(inputPath, options = {}) {
+        const args = [];
+        if (options.quality != null) {
+            args.push('-quality', String(options.quality));
+        }
+        if (options.grayscale) {
+            args.push('-grayscale');
+        }
+        if (options.optimize) {
+            args.push('-optimize');
+        }
+        if (options.progressive) {
+            args.push('-progressive');
+        }
+        if (options.targa) {
+            args.push('-targa');
+        }
+        if (options.dct) {
+            args.push('-dct', options.dct);
+        }
+        if (options.restart != null) {
+            args.push('-restart', String(options.restart));
+        }
+        if (options.smooth != null) {
+            args.push('-smooth', String(options.smooth));
+        }
+        if (options.maxMemory) {
+            args.push('-maxmemory', options.maxMemory);
+        }
+        if (options.outputPath) {
+            args.push('-outfile', options.outputPath);
+        }
+        if (options.verbose) {
+            args.push('-verbose');
+        }
+        if (options.debug) {
+            args.push('-debug');
+        }
+        if (options.baseline) {
+            args.push('-baseline');
+        }
+        if (options.extraArgs) {
+            args.push(...options.extraArgs);
+        }
+        args.push(inputPath);
+        const result = (0, nbis_runtime_1.runNbis)('cjpeg', args);
+        (0, nbis_runtime_1.assertSuccess)(result, 'cjpeg');
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            outputPath: options.outputPath
+        };
+    }
+}
+exports.Cjpeg = Cjpeg;

package/dist/src/cjpegb.d.ts

@@ -0,0 +1,19 @@
+export type CjpegbOptions = {
+    rawIn?: {
+        width: number;
+        height: number;
+        depth: number;
+        ppi?: number;
+    };
+    nonInterleaved?: boolean;
+    commentFile?: string;
+};
+export type CjpegbResult = {
+    outputPath: string;
+    stdout: string;
+    stderr: string;
+};
+export declare class Cjpegb {
+    version(): string;
+    compress(quality: number, outputExtension: string, imagePath: string, options?: CjpegbOptions): CjpegbResult;
+}

package/dist/src/cjpegb.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cjpegb = void 0;
+const path_1 = __importDefault(require("path"));
+const nbis_runtime_1 = require("./nbis-runtime");
+function buildRawAttr(raw) {
+    const attrs = [raw.width, raw.height, raw.depth];
+    if (raw.ppi != null) {
+        attrs.push(raw.ppi);
+    }
+    return attrs.join(',');
+}
+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}`);
+}
+class Cjpegb {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('cjpegb', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'cjpegb -version');
+        return result.stdout + result.stderr;
+    }
+    compress(quality, outputExtension, imagePath, options = {}) {
+        const args = [String(quality), outputExtension, imagePath];
+        if (options.rawIn) {
+            args.push('-raw_in', buildRawAttr(options.rawIn));
+        }
+        if (options.nonInterleaved) {
+            args.push('-nonintrlv');
+        }
+        if (options.commentFile) {
+            args.push(options.commentFile);
+        }
+        const result = (0, nbis_runtime_1.runNbis)('cjpegb', args);
+        (0, nbis_runtime_1.assertSuccess)(result, 'cjpegb');
+        return {
+            outputPath: replaceExtension(imagePath, outputExtension),
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Cjpegb = Cjpegb;

package/dist/src/cjpegl.d.ts

@@ -0,0 +1,24 @@
+export type CjpeglOptions = {
+    rawIn?: {
+        width: number;
+        height: number;
+        depth: number;
+        ppi?: number;
+    };
+    nonInterleaved?: boolean;
+    yCbCr?: {
+        y: [number, number];
+        cb: [number, number];
+        cr: [number, number];
+    };
+    commentFile?: string;
+};
+export type CjpeglResult = {
+    outputPath: string;
+    stdout: string;
+    stderr: string;
+};
+export declare class Cjpegl {
+    version(): string;
+    compress(outputExtension: string, imagePath: string, options?: CjpeglOptions): CjpeglResult;
+}