fprint-r303t/libfprint.js

Install:

//file for node 8.x version (without using finaly)
const Jimp = require('jimp');
const fprint = require("bindings")("fingerprint")

module.exports.getImage = async (timeout = 10000, binarize = false) => {
    if (fprint.init()) {
        var deviceHandle;
        var enrolStarted;
        return await new Promise((resolve, reject) => {
            let devices = fprint.discoverDevices();
            if (devices.length > 0) {
                deviceHandle = fprint.openDevice(devices[0]);
                console.log("Opened dev handle:" + deviceHandle);
                return resolve(deviceHandle)
            } else {
                fprint.exit();
                return reject(new Error('supported devices not found'));
            }
        }).then(async function (deviceHandle) {
            var stage = 1;
            return await new Promise((resolve, reject) => {
                enrolStarted = fprint.enrollStart(deviceHandle, binarize, async (state, message, fingerprint, fingerprintImage, imgWidth, imgHeight) => {
                    console.log("state " + state);
                    if (state == 3) {
                        console.log("stage " + stage++);
                    } else if (state == 1) {
                        fprint.enrollStop(deviceHandle, () => {
                            console.log("Enroll stopped");
                            enrolStarted = false;
                            fprint.closeDevice(deviceHandle);
                            fprint.exit();
                            return resolve({
                                data: fingerprintImage,
                                width: imgWidth,
                                height: imgHeight
                            });
                        });
                    } else if (state < 0 || state == 2) {
                        return reject(new Error(message));
                    }
                });
                setTimeout(function () {
                    reject('Enroll timeout')
                }, timeout);
            }).then(
                async function (rawImage) {
                console.log("RawImage done");
                return await new Promise((resolve, reject) => {
                    new Jimp(rawImage.width, rawImage.height, (err, image) => {
                        if (err) {
                            console.log("Jimp err:" + err);
                            return reject(err);
                        }

                        if (binarize) sharpenPixels(image, rawImage);
                        else setPixels(image, rawImage);
                        console.log("Jimp done");
                        return resolve(image);
                    });
                });
            }
            );
        }).catch(async function (error) {
            console.log("Get error:" + error);
            await new Promise((resolve, reject) => {

                if (enrolStarted) {
                    console.log("Try to stop enroll after error");
                    setTimeout(function () {
                        return reject(error + ' Enroll stop timeout')
                    }, 1000);
                    fprint.enrollStop(deviceHandle, () => {
                        console.log("Enroll stopped - dev handle:" + deviceHandle);
                        fprint.closeDevice(deviceHandle);
                        fprint.exit();
                        return resolve();
                    });
                } else {
                    console.log("Nothing to stop - dev handle:" + deviceHandle);
                    return resolve();
                }
            });
            throw new Error(error);
        }); // then
    } else {
        throw new Error('Initialization failed');
    }
};

module.exports.saveImage = async (path = './finger.png', timeout = 10000, binarize) => {
    let bitmap = await module.exports.getImage(timeout, binarize);
    bitmap.write(path);
};

module.exports.getBMP = async (timeout, binarize) => {
    let image = await module.exports.getImage(timeout, binarize);
    image = await new Promise((resolve, reject) => image.getBuffer(Jimp.MIME_BMP, (err, buffer) => err ? reject(err) : resolve(buffer)));
    return image;
}

module.exports.getPNG = async (timeout, binarize) => {
    let image = await module.exports.getImage(timeout, binarize);
    image = await new Promise((resolve, reject) => image.getBuffer(Jimp.MIME_PNG, (err, buffer) => err ? reject(err) : resolve(buffer)));
    return image;
}


let setPixels = (image, raw) => {
    for (let y = 0; y < raw.height; y++) {
        for (let x = 0; x < raw.width; x++) {
            let color = raw.data[y * raw.width + x];
            image.setPixelColor(Jimp.rgbaToInt(color, color, color, 255), x, y);
        }
    }
}

let sharpenPixels = (image, raw, treshold = 50, force = false, inerator = 0) => {
    let black = 0;
    let white = 0;

    if (!force) {
        for (let y = 0; y < raw.height; y++) {
            for (let x = 0; x < raw.width; x++) {
                if (raw.data[y * raw.width + x] >= treshold) white++;
                else black++;
            }
        }

        if (white == 0) return sharpenPixels(image, raw, treshold - 30, true, ++inerator);
        if ((black / white) > 2 && inerator < 10) return sharpenPixels(image, raw, treshold - 30, false, ++inerator);
        if ((black / white) < 0.8) return sharpenPixels(image, raw, treshold + 30, false, ++inerator);
    }

    for (let y = 0; y < raw.height; y++) {
        for (let x = 0; x < raw.width; x++) {
            let sharp = false;
            if (raw.data[y * raw.width + x] >= treshold) sharp = true;
            let color = sharp ? 255 : 0;
            let alpha = sharp ? 0 : 255;
            image.setPixelColor(Jimp.rgbaToInt(color, color, color, alpha), x, y);
        }
    }
}