Method convertImage

tools/train/source/datasets/ImageDataset.cpp:110–215

}

VARP ImageDataset::convertImage(const std::string& imageName, const ImageConfig& mConfig, const MNN::CV::ImageProcess::Config& mProcessConfig) {
    int originalWidth, originalHeight, comp;
    auto bitmap32bits = stbi_load(imageName.c_str(), &originalWidth, &originalHeight, &comp, 4);
    if (bitmap32bits == nullptr) {
        MNN_PRINT("can not open image: %s\n", imageName.c_str());
        MNN_ASSERT(false);
        return nullptr;
    }
    
    // choose resize or crop
    // resize method
    int oh, ow, bpp;
    if (mConfig.resizeHeight > 0 && mConfig.resizeWidth > 0) {
        oh = mConfig.resizeHeight;
        ow = mConfig.resizeWidth;
    } else {
        oh = originalHeight;
        ow = originalWidth;
    }
    bpp = 0;
    switch (mConfig.destFormat) {
        case GRAY:
            bpp = 1;
            break;
        case RGB:
        case BGR:
            bpp = 3;
            break;
        case RGBA:
        case BGRA:
            bpp = 4;
            break;
        default:
            break;
    }
    MNN_ASSERT(bpp > 0);

    std::shared_ptr<MNN::CV::ImageProcess> process;
    process.reset(ImageProcess::create(mProcessConfig));

    if (abs(mConfig.cropFraction[0] - 1.) > 1e-6 || abs(mConfig.cropFraction[1] - 1.) > 1e-6) {
        const float cropFractionH = mConfig.cropFraction[0];
        const float cropFractionW = mConfig.cropFraction[1];

        const int hCropSize = int(originalHeight * cropFractionH);
        const int wCropSize = int(originalWidth * cropFractionW);
        MNN_ASSERT(hCropSize > 0 && wCropSize > 0);
        // default center crop
        int startH = (originalHeight - hCropSize) / 2;
        int startW = (originalWidth - wCropSize) / 2;

        if (mConfig.centerOrRandomCrop == true) {
            const int maxStartPointH = originalHeight - hCropSize;
            const int maxStartPointW = originalWidth - wCropSize;
            // generate a random number between (0, maxPoint)
            auto gen = RandomGenerator::generator();
            std::uniform_int_distribution<> disH(0, maxStartPointH);
            startH = disH(gen);