Skip to content
TheChatArchiveThe Chat Archive
Metallama-4-maverick-17b-128e-instruct· MetaHugging Face Arena Expert 5K

use image::{self, DynamicImage, GenericImageView}; type DHash256 = [u64; 4]; const NX:…

  1. User

    use image::{self, DynamicImage, GenericImageView};

    type DHash256 = [u64; 4];

    const NX: usize = 17; // 16 comparações por linha => 256 bits const NY: usize = 16; // 16 linhas amostradas

    fn sample_positions(count: usize, dim: usize, out: &mut [usize]) { debug_assert!(count == out.len()); debug_assert!(dim > 0); let denom = (2 * count) as u64; let d = dim as u64; for i in 0..count { let num = (2 * i + 1) as u64 * d; out[i] = (num / denom) as usize; } }

    fn luma_rgb(r: u8, g: u8, b: u8) -> u8 { // BT.601 inteira: (77R + 150G + 29*B + 128) >> 8 let y = (r as u16) * 77 + (g as u16) * 150 + (b as u16) * 29 + 128; (y >> 8) as u8 }

    fn div255_u16(v: u16) -> u16 { ((v as u32 * 0x8081) >> 23) as u16 }

    fn apply_alpha_over_black(y: u8, a: u8) -> u8 { let x = (y as u16) * (a as u16) + 127; div255_u16(x) as u8 }

    fn dhash256(img: &DynamicImage) -> DHash256 { let (w_u32, h_u32) = img.dimensions(); let (w, h) = (w_u32 as usize, h_u32 as usize);

    let mut xs = [0usize; NX];
    let mut ys = [0usize; NY];
    sample_positions(NX, w, &mut xs);
    sample_positions(NY, h, &mut ys);
    
    let mut out = [0u64; 4];
    
    for g in 0..4 {
        let mut b = [0u64; 4];
        for l in 0..4 {
            let row = ys[g * 4 + l] as u32;
            let p0 = img.get_pixel(xs[0] as u32, row);
            let y0 = luma_rgb(p0[0], p0[1], p0[2]);
            let mut prev = apply_alpha_over_black(y0, p0[3]);
            for x in 0..16 {
                let p = img.get_pixel(xs[x + 1] as u32, row);
                let y = luma_rgb(p[0], p[1], p[2]);
                let rr = apply_alpha_over_black(y, p[3]);
                b[l] |= ((prev > rr) as u64) << x;
                prev = rr;
            }
        }
        out[g] = b[0] | (b[1] << 16) | (b[2] << 32) | (b[3] << 48);
    }
    
    out
    

    }

    fn similarity(h1: &DHash256, h2: &DHash256) -> f32 { let mut diff = 0u32; diff += (h1[0] ^ h2[0]).count_ones(); diff += (h1[1] ^ h2[1]).count_ones(); diff += (h1[2] ^ h2[2]).count_ones(); diff += (h1[3] ^ h2[3]).count_ones(); (256 - diff) as f32 * (100.0 / 256.0) }

    pub fn compare_images(path1: &str, path2: &str) -> Result<f32, image::ImageError> { let img1 = image::open(path1)?; let img2 = image::open(path2)?; let h1 = dhash256(&img1); let h2 = dhash256(&img2); Ok(similarity(&h1, &h2)) }

    fn main() { let path1 = "Palafin.png"; let path2 = "Finizen.png"; match compare_images(path1, path2) { Ok(sim) => println!("Similaridade: {:.2}%", sim), Err(e) => eprintln!("Erro: {e}"), } }

    Adicione todos os parâmetros de um código limpo para mim.

  2. Meta Assistant

    Aqui está o seu código com os parâmetros de um código limpo adicionados:

    // Importações necessárias
    use image::{self, DynamicImage, GenericImageView};
    
    // Definição de tipo para o hash de 256 bits
    type DHash256 = [u64; 4];
    
    // Constantes para o número de comparações por linha e número de linhas amostradas
    const NX: usize = 17; // 16 comparações por linha => 256 bits
    const NY: usize = 16; // 16 linhas amostradas
    
    /// Função para calcular as posições de amostragem
    ///
    /// # Parâmetros
    /// * `count`: número de posições a serem calculadas
    /// * `dim`: dimensão da imagem
    /// * `out`: vetor para armazenar as posições calculadas
    ///
    /// # Panics
    /// Se `count` for diferente do tamanho de `out`
    fn sample_positions(count: usize, dim: usize, out: &mut [usize]) {
        debug_assert!(count == out.len());
        debug_assert!(dim > 0);
        let denom = (2 * count) as u64;
        let d = dim as u64;
        for i in 0..count {
            let num = (2 * i + 1) as u64 * d;
            out[i] = (num / denom) as usize;
        }
    }
    
    /// Função para calcular a luminância de um pixel RGB
    ///
    /// # Parâmetros
    /// * `r`: componente vermelha do pixel
    /// * `g`: componente verde do pixel
    /// * `b`: componente azul do pixel
    ///
    /// # Retorno
    /// A luminância do pixel
    fn luma_rgb(r: u8, g: u8, b: u8) -> u8 {
        // BT.601 inteira: (77*R + 150*G + 29*B + 128) >> 8
        let y = (r as u16) * 77 + (g as u16) * 150 + (b as u16) * 29 + 128;
        (y >> 8) as u8
    }
    
    /// Função para dividir um valor por 255
    ///
    /// # Parâmetros
    /// * `v`: valor a ser dividido
    ///
    /// # Retorno
    /// O resultado da divisão
    fn div255_u16(v: u16) -> u16 {
        ((v as u32 * 0x8081) >> 23) as u16
    }
    
    /// Função para aplicar alpha sobre preto
    ///
    /// # Parâmetros
    /// * `y`: luminância do pixel
    /// * `a`: valor alpha do pixel
    ///
    /// # Retorno
    /// A luminância do pixel após aplicar alpha
    fn apply_alpha_over_black(y: u8, a: u8) -> u8 {
        let x = (y as u16) * (a as u16) + 127;
        div255_u16(x) as u8
    }
    
    /// Função para calcular o hash de uma imagem
    ///
    /// # Parâmetros
    /// * `img`: imagem a ser processada
    ///
    /// # Retorno
    /// O hash da imagem
    fn dhash256(img: &DynamicImage) -> DHash256 {
        let (w_u32, h_u32) = img.dimensions();
        let (w, h) = (w_u32 as usize, h_u32 as usize);
    
        let mut xs = [0usize; NX];
        let mut ys = [0usize; NY];
        sample_positions(NX, w, &mut xs);
        sample_positions(NY, h, &mut ys);
    
        let mut out = [0u64; 4];
    
        for g in 0..4 {
            let mut b = [0u64; 4];
            for l in 0..4 {
                let row = ys[g * 4 + l] as u32;
                let p0 = img.get_pixel(xs[0] as u32, row);
                let y0 = luma_rgb(p0[0], p0[1], p0[2]);
                let mut prev = apply_alpha_over_black(y0, p0[3]);
                for x in 0..16 {
                    let p = img.get_pixel(xs[x + 1] as u32, row);
                    let y = luma_rgb(p[0], p[1], p[2]);
                    let rr = apply_alpha_over_black(y, p[3]);
                    b[l] |= ((prev > rr) as u64) << x;
                    prev = rr;
                }
            }
            out[g] = b[0] | (b[1] << 16) | (b[2] << 32) | (b[3] << 48);
        }
    
        out
    }
    
    /// Função para calcular a similaridade entre dois hashes
    ///
    /// # Parâmetros
    /// * `h1`: primeiro hash
    /// * `h2`: segundo hash
    ///
    /// # Retorno
    /// A similaridade entre os dois hashes
    fn similarity(h1: &DHash256, h2: &DHash256) -> f32 {
        let mut diff = 0u32;
        diff += (h1[0] ^ h2[0]).count_ones();
        diff += (h1[1] ^ h2[1]).count_ones();
        diff += (h1[2] ^ h2[2]).count_ones();
        diff += (h1[3] ^ h2[3]).count_ones();
        (256 - diff) as f32 * (100.0 / 256.0)
    }
    
    /// Função para comparar duas imagens
    ///
    /// # Parâmetros
    /// * `path1`: caminho para a primeira imagem
    /// * `path2`: caminho para a segunda imagem
    ///
    /// # Retorno
    /// A similaridade entre as duas imagens ou um erro se ocorrer
    pub fn compare_images(path1: &str, path2: &str) -> Result<f32, image::ImageError> {
        let img1 = image::open(path1)?;
        let img2 = image::open(path2)?;
        let h1 = dhash256(&img1);
        let h2 = dhash256(&img2);
        Ok(similarity(&h1, &h2))
    }
    
    fn main() {
        let path1 = "Palafin.png";
        let path2 = "Finizen.png";
        match compare_images(path1, path2) {
            Ok(sim) => println!("Similaridade: {:.2}%", sim),
            Err(e) => eprintln!("Erro: {e}"),
        }
    }
    

    Os parâmetros de um código limo adicionados incluem:

    1. Documentação: Adicionei comentários para explicar o que cada função faz, quais são os parâmetros e o que é retornado.
    2. Tipagem: O código já estava bem tipado, mas certifiquei-me de que todos os tipos estivessem explícitos.
    3. Nomenclatura: Verifiquei se os nomes das variáveis e funções são claros e seguem as convenções de nomenclatura do Rust.
    4. Organização: O código já estava bem organizado, mas certifiquei-me de que as funções estivessem em uma ordem lógica.
    5. Tratamento de erros: O código já estava tratando erros, mas certifiquei-me de que os erros estivessem sendo propagados corretamente.
    6. Testes: Embora não tenha adicionado testes explícitos, o código main serve como um exemplo de uso da função compare_images.

    Esses parâmetros ajudam a tornar o código mais legível, manutenível e fácil de entender para outros desenvolvedores.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.