nbis-wrapper-js 0.0.1

package/dist/src/jpegtran.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Jpegtran = void 0;
+const nbis_runtime_1 = require("./nbis-runtime");
+class Jpegtran {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('jpegtran', ['-version']);
+        if (result.error) {
+            throw result.error;
+        }
+        return result.stdout + result.stderr;
+    }
+    transform(inputPath, options = {}) {
+        const args = [];
+        if (options.optimize) {
+            args.push('-optimize');
+        }
+        if (options.progressive) {
+            args.push('-progressive');
+        }
+        if (options.restart != null) {
+            args.push('-restart', String(options.restart));
+        }
+        if (options.scansFile) {
+            args.push('-scans', options.scansFile);
+        }
+        if (options.transform) {
+            switch (options.transform) {
+                case 'flip-horizontal':
+                    args.push('-flip', 'horizontal');
+                    break;
+                case 'flip-vertical':
+                    args.push('-flip', 'vertical');
+                    break;
+                case 'rotate-90':
+                    args.push('-rotate', '90');
+                    break;
+                case 'rotate-180':
+                    args.push('-rotate', '180');
+                    break;
+                case 'rotate-270':
+                    args.push('-rotate', '270');
+                    break;
+                case 'transpose':
+                    args.push('-transpose');
+                    break;
+                case 'transverse':
+                    args.push('-transverse');
+                    break;
+                default:
+                    break;
+            }
+        }
+        if (options.trim) {
+            args.push('-trim');
+        }
+        if (options.grayscale) {
+            args.push('-grayscale');
+        }
+        if (options.copy) {
+            args.push('-copy', options.copy);
+        }
+        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.extraArgs) {
+            args.push(...options.extraArgs);
+        }
+        args.push(inputPath);
+        const result = (0, nbis_runtime_1.runNbis)('jpegtran', args);
+        (0, nbis_runtime_1.assertSuccess)(result, 'jpegtran');
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            outputPath: options.outputPath
+        };
+    }
+}
+exports.Jpegtran = Jpegtran;

package/dist/src/mindtct.d.ts

@@ -0,0 +1,24 @@
+export type MindtctDetectOptions = {
+    enhanceLowContrast?: boolean;
+    useM1?: boolean;
+};
+export type MindtctDetectResult = {
+    outputs: {
+        mdt: string;
+        xyt: string;
+        brw: string;
+        dm: string;
+        hcm: string;
+        lcm: string;
+        lfm: string;
+        qm: string;
+        min: string;
+    };
+    outputRoot: string;
+    stdout: string;
+    stderr: string;
+};
+export declare class Mindtct {
+    version(): string;
+    detect(fingerImagePath: string, outputRoot: string, options?: MindtctDetectOptions): MindtctDetectResult;
+}

package/dist/src/mindtct.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mindtct = void 0;
+const path_1 = __importDefault(require("path"));
+const nbis_runtime_1 = require("./nbis-runtime");
+class Mindtct {
+    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');
+        }
+        if (options.useM1) {
+            args.push('-m1');
+        }
+        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
+        };
+    }
+}
+exports.Mindtct = Mindtct;

package/dist/src/nbis-runtime.d.ts

@@ -0,0 +1,23 @@
+import type { SpawnSyncOptionsWithBufferEncoding, SpawnSyncOptionsWithStringEncoding } from 'child_process';
+export declare function getNbisRoot(): string;
+export declare function getNbisDataPath(): string;
+export declare function resolveBinPath(binaryName: string): string;
+type NbisOutput = string | Buffer;
+type NbisResultBase = {
+    status: number | null;
+    stdout: NbisOutput;
+    stderr: NbisOutput;
+    error?: Error;
+};
+export type NbisResult = NbisResultBase & {
+    stdout: string;
+    stderr: string;
+};
+export type NbisBinaryResult = NbisResultBase & {
+    stdout: Buffer;
+    stderr: Buffer;
+};
+export declare function runNbis(binaryName: string, args?: string[], options?: SpawnSyncOptionsWithStringEncoding): NbisResult;
+export declare function runNbisBinary(binaryName: string, args?: string[], options?: SpawnSyncOptionsWithBufferEncoding): NbisBinaryResult;
+export declare function assertSuccess(result: NbisResultBase, context: string): void;
+export {};

package/dist/src/nbis-runtime.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNbisRoot = getNbisRoot;
+exports.getNbisDataPath = getNbisDataPath;
+exports.resolveBinPath = resolveBinPath;
+exports.runNbis = runNbis;
+exports.runNbisBinary = runNbisBinary;
+exports.assertSuccess = assertSuccess;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const SUPPORTED = {
+    'darwin-arm64': 'nbis_arm64_darwin',
+    'linux-x64': 'nbis_x86-64_linux'
+};
+function getPlatformKey() {
+    return `${process.platform}-${process.arch}`;
+}
+function getNbisRoot() {
+    const key = getPlatformKey();
+    const folder = SUPPORTED[key];
+    if (!folder) {
+        throw new Error(`Unsupported platform: ${key}`);
+    }
+    const packageRoot = findPackageRoot(__dirname);
+    return path_1.default.resolve(packageRoot, 'libnbis', folder);
+}
+function getNbisDataPath() {
+    return path_1.default.join(getNbisRoot(), 'nbis');
+}
+function resolveBinPath(binaryName) {
+    return path_1.default.join(getNbisRoot(), 'bin', binaryName);
+}
+function findPackageRoot(startDir) {
+    let current = startDir;
+    for (let i = 0; i < 6; i += 1) {
+        if (fs_1.default.existsSync(path_1.default.join(current, 'libnbis'))) {
+            return current;
+        }
+        const parent = path_1.default.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return path_1.default.resolve(__dirname, '..');
+}
+function runNbis(binaryName, args = [], options = { encoding: 'utf8' }) {
+    const binPath = resolveBinPath(binaryName);
+    const env = {
+        ...process.env,
+        NBIS: getNbisDataPath()
+    };
+    const result = (0, child_process_1.spawnSync)(binPath, args, {
+        ...options,
+        env,
+        encoding: options.encoding || 'utf8'
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout || '',
+        stderr: result.stderr || '',
+        error: result.error
+    };
+}
+function runNbisBinary(binaryName, args = [], options = { encoding: 'buffer' }) {
+    const binPath = resolveBinPath(binaryName);
+    const env = {
+        ...process.env,
+        NBIS: getNbisDataPath()
+    };
+    const result = (0, child_process_1.spawnSync)(binPath, args, {
+        ...options,
+        env,
+        encoding: options.encoding || 'buffer'
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout || Buffer.alloc(0),
+        stderr: result.stderr || Buffer.alloc(0),
+        error: result.error
+    };
+}
+function outputToString(output) {
+    if (Buffer.isBuffer(output)) {
+        return output.toString('utf8');
+    }
+    return output;
+}
+function assertSuccess(result, context) {
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const stderrText = outputToString(result.stderr).trim();
+        const message = [
+            `${context} failed with exit code ${result.status}.`,
+            stderrText
+        ]
+            .filter(Boolean)
+            .join(' ');
+        const error = new Error(message);
+        error.stdout = outputToString(result.stdout);
+        error.stderr = outputToString(result.stderr);
+        error.status = result.status;
+        throw error;
+    }
+}

package/dist/src/nfiq.d.ts

@@ -0,0 +1,36 @@
+export type NfiqRecordSelectors = {
+    fingerPosition?: string[];
+    impressionType?: string[];
+    imageDesignation?: number[];
+    logicalRecordType?: string[];
+    nqm?: string[];
+    readFile?: string;
+    writeFile?: string;
+};
+export type NfiqOptions = {
+    mode?: 'default' | 'verbose';
+    oldBehavior?: boolean;
+    raw?: {
+        width: number;
+        height: number;
+        depth: number;
+        ppi?: number;
+    };
+    selectors?: NfiqRecordSelectors;
+    ansiNistOutputPath?: string;
+};
+export type NfiqScoreLine = {
+    quality?: number;
+    record?: number;
+    fgp?: number;
+    raw: string;
+};
+export type NfiqResult = {
+    scores: NfiqScoreLine[];
+    stdout: string;
+    stderr: string;
+};
+export declare class Nfiq {
+    version(): string;
+    score(imagePath: string, options?: NfiqOptions): NfiqResult;
+}

package/dist/src/nfiq.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Nfiq = void 0;
+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 addSelectors(args, selectors) {
+    if (!selectors) {
+        return;
+    }
+    if (selectors.fingerPosition) {
+        selectors.fingerPosition.forEach((value) => args.push('-f', value));
+    }
+    if (selectors.impressionType) {
+        selectors.impressionType.forEach((value) => args.push('-i', value));
+    }
+    if (selectors.imageDesignation) {
+        selectors.imageDesignation.forEach((value) => args.push('-n', String(value)));
+    }
+    if (selectors.logicalRecordType) {
+        selectors.logicalRecordType.forEach((value) => args.push('-t', value));
+    }
+    if (selectors.nqm) {
+        selectors.nqm.forEach((value) => args.push('-q', value));
+    }
+    if (selectors.readFile) {
+        args.push('-r', selectors.readFile);
+    }
+    if (selectors.writeFile) {
+        args.push('-w', selectors.writeFile);
+    }
+}
+function parseScores(output) {
+    const lines = output.split(/\r?\n/).filter(Boolean);
+    return lines.map((line) => {
+        const tokens = line.trim().split(/\s+/);
+        const last = tokens[tokens.length - 1];
+        const quality = last ? Number(last) : NaN;
+        const score = { raw: line };
+        if (!Number.isNaN(quality)) {
+            score.quality = quality;
+        }
+        if (tokens.length >= 3) {
+            const record = Number(tokens[tokens.length - 3]);
+            const fgp = Number(tokens[tokens.length - 2]);
+            if (!Number.isNaN(record)) {
+                score.record = record;
+            }
+            if (!Number.isNaN(fgp)) {
+                score.fgp = fgp;
+            }
+        }
+        return score;
+    });
+}
+class Nfiq {
+    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));
+        }
+        addSelectors(args, options.selectors);
+        args.push(imagePath);
+        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
+        };
+    }
+}
+exports.Nfiq = Nfiq;

package/dist/src/not2intr.d.ts

@@ -0,0 +1,22 @@
+export type Not2intrOptions = {
+    rawOut?: boolean;
+    yCbCr?: {
+        y: [number, number];
+        cb: [number, number];
+        cr: [number, number];
+    };
+};
+export type Not2intrResult = {
+    outputPath: string;
+    stdout: string;
+    stderr: string;
+};
+export declare class Not2intr {
+    version(): string;
+    convert(outputExtension: string, imagePath: string, rawIn: {
+        width: number;
+        height: number;
+        depth: number;
+        ppi?: number;
+    }, options?: Not2intrOptions): Not2intrResult;
+}

package/dist/src/not2intr.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Not2intr = 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 buildYCbCr(components) {
+    const { y, cb, cr } = components;
+    return `${y[0]},${y[1]}:${cb[0]},${cb[1]}:${cr[0]},${cr[1]}`;
+}
+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 Not2intr {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('not2intr', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'not2intr -version');
+        return result.stdout + result.stderr;
+    }
+    convert(outputExtension, imagePath, rawIn, options = {}) {
+        const args = [outputExtension, imagePath, buildRawAttr(rawIn)];
+        if (options.rawOut) {
+            args.push('-raw_out');
+        }
+        if (options.yCbCr) {
+            args.push('-YCbCr', buildYCbCr(options.yCbCr));
+        }
+        const result = (0, nbis_runtime_1.runNbis)('not2intr', args);
+        (0, nbis_runtime_1.assertSuccess)(result, 'not2intr');
+        return {
+            outputPath: replaceExtension(imagePath, outputExtension),
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Not2intr = Not2intr;

package/dist/src/rdjpgcom.d.ts

@@ -0,0 +1,11 @@
+export type RdjpgcomOptions = {
+    verbose?: boolean;
+};
+export type RdjpgcomResult = {
+    stdout: string;
+    stderr: string;
+};
+export declare class Rdjpgcom {
+    version(): string;
+    read(imagePath: string, options?: RdjpgcomOptions): RdjpgcomResult;
+}

package/dist/src/rdjpgcom.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rdjpgcom = void 0;
+const nbis_runtime_1 = require("./nbis-runtime");
+class Rdjpgcom {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('rdjpgcom', ['-version']);
+        if (result.error) {
+            throw result.error;
+        }
+        return result.stdout + result.stderr;
+    }
+    read(imagePath, options = {}) {
+        const args = [];
+        if (options.verbose) {
+            args.push('-verbose');
+        }
+        args.push(imagePath);
+        const result = (0, nbis_runtime_1.runNbis)('rdjpgcom', args);
+        (0, nbis_runtime_1.assertSuccess)(result, 'rdjpgcom');
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Rdjpgcom = Rdjpgcom;

package/dist/src/rdwsqcom.d.ts

@@ -0,0 +1,8 @@
+export type RdwsqcomResult = {
+    stdout: string;
+    stderr: string;
+};
+export declare class Rdwsqcom {
+    version(): string;
+    read(imagePath: string): RdwsqcomResult;
+}

package/dist/src/rdwsqcom.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rdwsqcom = void 0;
+const nbis_runtime_1 = require("./nbis-runtime");
+class Rdwsqcom {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('rdwsqcom', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'rdwsqcom -version');
+        return result.stdout + result.stderr;
+    }
+    read(imagePath) {
+        const result = (0, nbis_runtime_1.runNbis)('rdwsqcom', [imagePath]);
+        (0, nbis_runtime_1.assertSuccess)(result, 'rdwsqcom');
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Rdwsqcom = Rdwsqcom;

package/dist/src/rgb2ycc.d.ts

@@ -0,0 +1,23 @@
+export type Rgb2yccOptions = {
+    rawIn?: {
+        width: number;
+        height: number;
+        depth: number;
+        ppi?: number;
+    };
+    nonInterleaved?: boolean;
+    yCbCr?: {
+        y: [number, number];
+        cb: [number, number];
+        cr: [number, number];
+    };
+};
+export type Rgb2yccResult = {
+    outputPath: string;
+    stdout: string;
+    stderr: string;
+};
+export declare class Rgb2ycc {
+    version(): string;
+    convert(outputExtension: string, imagePath: string, options?: Rgb2yccOptions): Rgb2yccResult;
+}

package/dist/src/rgb2ycc.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rgb2ycc = 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 buildYCbCr(components) {
+    const { y, cb, cr } = components;
+    return `${y[0]},${y[1]}:${cb[0]},${cb[1]}:${cr[0]},${cr[1]}`;
+}
+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 Rgb2ycc {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('rgb2ycc', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'rgb2ycc -version');
+        return result.stdout + result.stderr;
+    }
+    convert(outputExtension, imagePath, options = {}) {
+        const args = [outputExtension, imagePath];
+        if (options.rawIn) {
+            args.push('-raw_in', buildRawAttr(options.rawIn));
+        }
+        if (options.nonInterleaved) {
+            args.push('-nonintrlv');
+        }
+        if (options.yCbCr) {
+            args.push('-YCbCr', buildYCbCr(options.yCbCr));
+        }
+        const result = (0, nbis_runtime_1.runNbis)('rgb2ycc', args);
+        (0, nbis_runtime_1.assertSuccess)(result, 'rgb2ycc');
+        return {
+            outputPath: replaceExtension(imagePath, outputExtension),
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Rgb2ycc = Rgb2ycc;

package/dist/src/wrjpgcom.d.ts

@@ -0,0 +1,20 @@
+export type WrjpgcomOptions = {
+    replace?: boolean;
+    commentFile: string;
+    commentText?: never;
+    outputPath?: string;
+} | {
+    replace?: boolean;
+    commentFile?: never;
+    commentText: string;
+    outputPath?: string;
+};
+export type WrjpgcomResult = {
+    output?: Buffer;
+    outputPath?: string;
+    stderr: string;
+};
+export declare class Wrjpgcom {
+    version(): string;
+    write(imagePath: string, options: WrjpgcomOptions): WrjpgcomResult;
+}