Method preprocess_image

src/common/AutoModel/modeling_qwen2vl_image.cpp:165–293

@brief: preprocess the image for Qwen2VL model @note: Converts uint8 image to BF16 format, data is already in (3, H, W) CHW layout @param: image: the image to preprocess (already in CHW format) @return: the preprocessed image in BF16 format

///@param: image: the image to preprocess (already in CHW format)
///@return: the preprocessed image in BF16 format
void Qwen2VL::preprocess_image(qwen2vl_image_t& image, std::vector<bf16> &pixel_values) {
    const int width = image.width;
    const int height = image.height;
    const int channels = 3; // RGB
    int resized_height; 
    int resized_width;    
    // do the automatically resizing in here 
    smart_resize(
        height, width,
        resized_height, resized_width,
        QWEN2_PATCH_SIZE * QWEN2_IMAGE_MERGE_SIZE,
        QWEN2_SHORTEST_EDGE,
        QWEN2_LONGEST_EDGE
    );
    // std::cout << "resized_height "<< resized_height << " resized_width " << resized_width <<std::endl;

    // Use non-optimized path for consistent results across platforms
    auto resize_image =  imgproc::avx512::resize_bicubic_antialias_rgb_planar_avx512(
        image._data.data(), width, height, resized_width, resized_height, true
    );

    // Padding Logic (Align to Window Size)
    const int target_window_size = 112; 
    const int vit_merger_window_size = target_window_size / QWEN2_IMAGE_MERGE_SIZE / QWEN2_PATCH_SIZE;
    const int align_unit = QWEN2_PATCH_SIZE * QWEN2_IMAGE_MERGE_SIZE * vit_merger_window_size;
    
    int pad_h = (align_unit - (resized_height % align_unit)) % align_unit;
    int pad_w = (align_unit - (resized_width % align_unit)) % align_unit;

    if (pad_h > 0 || pad_w > 0) {
        const int padded_width = resized_width + pad_w;
        const int padded_height = resized_height + pad_h;

        const size_t src_plane_size = static_cast<size_t>(resized_width) * resized_height;
        const size_t dst_plane_size = static_cast<size_t>(padded_width) * padded_height;

        resize_image.resize(dst_plane_size * channels);

        // Expand each plane in-place from back to front to avoid extra temporary allocations.
        for (int c = channels - 1; c >= 0; --c) {
            uint8_t* src_plane = resize_image.data() + static_cast<size_t>(c) * src_plane_size;
            uint8_t* dst_plane = resize_image.data() + static_cast<size_t>(c) * dst_plane_size;

            for (int y = resized_height - 1; y >= 0; --y) {
                std::memmove(dst_plane + static_cast<size_t>(y) * padded_width,
                    src_plane + static_cast<size_t>(y) * resized_width,
                    resized_width);
                if (pad_w > 0) {
                    std::memset(dst_plane + static_cast<size_t>(y) * padded_width + resized_width, 0, pad_w);
                }
            }

            if (pad_h > 0) {
                std::memset(dst_plane + static_cast<size_t>(resized_height) * padded_width,
                    0,
                    static_cast<size_t>(pad_h) * padded_width);
            }
        }