使用神经网络识别同济选课网的验证码

function loadImages(length_labels) {//这里的length_labels是指图片的个数
    return new Promise(function (resolve) {
        let files_typed_array = {};
        let promises = [];
        let promises_image = [];

        for(let i = 0; i < length_labels; i++) {
            //设置图片路径
            const img_path = `${image_folder_path}code_${i}.jpg`;

            //使用Jimp提供的promise读取图片接口
            promises_image.push(Jimp.read(img_path));
        }

        //使用Promise的all，等待所有promise结束。
        Promise.all(promises_image).then(function (images) {
            for (let index = 0;index < images.length; index++) {
                const img = images[index];

                //裁剪成4张
                let _imgs = splitImageTo4Parts(img);

                promises.push(...decodeImageToTypedArray(_imgs, index, files_typed_array));
            }

            Promise.all(promises).then(function () {
                console.log('Images Loaded.');
                resolve(files_typed_array);
            });
        }).catch(function (err) {
            console.error(err);
        });
    });

}

//提取单个图片的像素到矩阵
function extractPixel(typed_array) {//jpeg-js返回的rgba扁平数组
    if(typed_array.length % 4 !== 0) throw 'Pixel Not In RGBA Format';
    let pixels = [];
    //这里步长为4，是因为每个像素为rgba模式
    for(let i = 0; i < typed_array.length; i = i + 4) {
        let pixel = [typed_array[i], typed_array[i + 1], typed_array[i + 2], typed_array[i + 3]];
        pixels.push(pixel);
    }
    return pixels;
}

//将单个数字图片转换成扁平的二值化数组
//images是图片的Jimp实例对象数组,分别是4个数字,index是我读写文件用的索引,files_typed_array是转换结果写入的地方
function decodeImageToTypedArray(images, index, files_typed_array) {
    let promises = [];
    for (let _img = 0; _img < images.length; _img++) {
        let _promise_get_array =
            new Promise(function (__resolve) {
                images[_img].getBuffer(Jimp.MIME_JPEG, function (err, buffer) {
                    __resolve(buffer);
                });
            }).then(function (buffer) {
                return new Promise(function (_resolve) {
                    files_typed_array[`code_${index}_${_img}`] =
                        binarizeImage(extractPixel(jpeg.decode(buffer, true).data));
                    _resolve();
                });
            });

        promises.push(_promise_get_array);
    }
    return promises;
}

//一部分的主函数
function main() {
let labels = fs.readFileSync(`${image_folder_path}labels.txt`).toString();
    try {
        labels = JSON.parse(labels);
    }catch (err){
        console.error('labels file error');
        return null;
    }
}
//解析训练集和标签
function parseDataSet(typed_arrays, labels) {
    return new Promise(function (resolve) {
        if(Object.keys(typed_arrays).length !== labels.length * 4) {
            console.error(`${Object.keys(typed_arrays).length} & ${labels.length * 4}`);
            throw new Error('Length Not Equal');
        }

        //训练的输入
        let train_feature = [];
        //训练的标签
        let train_label = [];
        for(let i = 0; i < labels.length; i++) {

            for(let j = 0; j < labels[i].length; j++) {
                let digits_array = typed_arrays[`code_${i}_${j}`];

                train_feature.push(digits_array);

                //标签以一个10维的01数组表示
                let label_bool = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
                label_bool[labels[i][j]] = 1;

                train_label.push(label_bool);
            }
        }
        console.log(`训练数据总共${labels.length * 4}个数字`);
        resolve({train_feature, train_label});
    });
}

//将预测函数导出到文件，之后可以单独使用，不需要引用依赖包。
function storeNeuralNetworkModel(net) {
    let forecast = net.toFunction();

    fs.writeFileSync(`./parseCAPTCHA.js`, forecast.toString());
}

const forecast = require('./parseCAPTCHA');
//图片路径
let image_path = './xuanke_code/code_92.jpg';
//在回调函数中返回结果r
forecast(image_path, function (r) {
    console.log(r);
});