image::load_from_memory goes wrong while image::save_buffer works about image HOT 11 CLOSED

let img = image::open(r"D:\MEDIA\PICTURE\girl.jpg").unwrap();
let resized_image = img.resize(width, height, filter_type);

let image_buff = Vec::<u8>::from(&rgb_image_t);
let revert_image = image::RgbImage::from_raw(width, height, image_buff).unwrap();
    // way 1
    // let revert_image = image::imageops::resize(
    //     &revert_image,
    //     width + 10,
    //     height + 10,
    //     image::imageops::FilterType::Nearest,
    // );

    // way 2
    let revert_image = DynamicImage::ImageRgb8(revert_image);
    let revert_image = revert_image.resize(
        width + 10,
        height + 10,
        image::imageops::FilterType::Nearest,
    );

 // save
  revert_image.save("revert_image.png").unwrap();
  // revert_image
  //     .save_with_format("revert_image.png", image::ImageFormat::Png)
  //     .unwrap();

use image::{DynamicImage, GenericImageView};
use tch::Tensor;

fn main() {
    let width = 40;
    let height = 50;
    let filter_type = image::imageops::FilterType::Triangle;
    let img = image::open(r"D:\MEDIA\PICTURE\iamge.png").unwrap();
    println!("dimensions {:?}", img.dimensions());
    println!("{:?}", img.color());

    // open image from disk
    let grey_img = img.grayscale();
    println!("dimensions {:?}", img.dimensions());
    println!("{:?}", grey_img.color());

    // TODO: refractor try resizing by image crate from tensor
    let resized_image = img.resize(width, height, filter_type);

    // get image tensor
    let rgb_image_t = Tensor::from_image(&img);
    let resize_image_t1 = Tensor::from_image(&resized_image);
    let gray_image_t = Tensor::from_image(&grey_img);

    // test revert to image from tensor
    println!("orig image size:{:?}", rgb_image_t.size());
    let trans_image = rgb_image_t.permute(&[1, 2, 0]);
    let shape = trans_image.size();
    println!("trans image shape：{shape:?}");
    let image_buff = Vec::<u8>::from(&trans_image);
    let revert_image = image::RgbImage::from_raw(width, height, image_buff).unwrap();
    // way 1
    // let revert_image = image::imageops::resize(
    //     &revert_image,
    //     width + 10,
    //     height + 10,
    //     filter_type,
    // );

    // way 2
    let revert_image = DynamicImage::ImageRgb8(revert_image);
    // let revert_image = revert_image.resize_exact(width + 10, height + 10, filter_type);
    // let revert_image = revert_image.resize(width + 10, height + 10, filter_type);
    // let revert_image_t = Tensor::from_image(&revert_image);
    // println!("revert_image dimensions {:?}", revert_image.dimensions());

    // save tensor image
    img.save("orig_image.png").unwrap();
    rgb_image_t.save_image("recover_image.png");
    resize_image_t1.save_image("resize_image1.png");
    // revert_image_t.save_image("revert_image.png");

    revert_image.save("revert_image.png").unwrap();
    // revert_image
    //     .save_with_format("revert_image.", image::ImageFormat::Png)
    //     .unwrap();png
    gray_image_t.save_image("gray_image.png");
}

pub trait TensorExt {
    fn from_image(image: &image::DynamicImage) -> Self;
    fn save_image(&self, path: &str);
}

impl TensorExt for tch::Tensor {
    fn from_image(image: &image::DynamicImage) -> Self {
        let dimensions = image.dimensions();
        let color_type = image.color();
        match color_type {
            image::ColorType::L8 => {
                return tch::Tensor::of_data_size(
                    image.as_bytes(),
                    &[1, dimensions.1 as i64, dimensions.0 as i64],
                    tch::Kind::Uint8,
                )
                .to_kind(tch::Kind::Float);
            }
            image::ColorType::La8 => {
                let new_image = image.to_luma8();
                let dimensions = new_image.dimensions();
                return tch::Tensor::of_data_size(
                    image.as_bytes(),
                    &[2, dimensions.1 as i64, dimensions.0 as i64],
                    tch::Kind::Uint8,
                )
                .to_kind(tch::Kind::Float);
            }
            image::ColorType::Rgb8 => {
                return tch::Tensor::of_data_size(
                    image.as_bytes(),
                    &[3, dimensions.1 as i64, dimensions.0 as i64],
                    tch::Kind::Uint8,
                )
                .to_kind(tch::Kind::Float);
            }
            image::ColorType::Rgba8 => {
                let new_image = image.to_rgb8(); //TODO:need or not?
                let dimensions = new_image.dimensions();
                return tch::Tensor::of_data_size(
                    image.as_bytes(),
                    &[4, dimensions.1 as i64, dimensions.0 as i64],
                    tch::Kind::Uint8,
                )
                .to_kind(tch::Kind::Float);
            }
            _ => panic!(""),
        }
    }

    fn save_image(&self, path: &str) {
        let shape = self.size();
        let (height, width, color_type) = match shape {
            shape if shape.len() == 2 => (shape[0], shape[1], image::ColorType::L8),
            shape if shape.len() == 3 => {
                let channel_size = shape[0];
                match channel_size {
                    size if size == 1 => (shape[1], shape[2], image::ColorType::L8),
                    size if size == 2 => (shape[1], shape[2], image::ColorType::La8),
                    size if size == 3 => (shape[1], shape[2], image::ColorType::Rgb8),
                    size if size == 4 => (shape[1], shape[2], image::ColorType::Rgba8),
                    _ => panic!(),
                }
            }
            _ => panic!(),
        };

        image::save_buffer(
            path,
            &Vec::<u8>::from(self),
            width as u32,
            height as u32,
            color_type,
        )
        .unwrap();
    }
}