use image::{self, DynamicImage, GenericImageView}; type DHash256 = [u64; 4]; const NX:…
- 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.
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:
- Documentação: Adicionei comentários para explicar o que cada função faz, quais são os parâmetros e o que é retornado.
- Tipagem: O código já estava bem tipado, mas certifiquei-me de que todos os tipos estivessem explícitos.
- Nomenclatura: Verifiquei se os nomes das variáveis e funções são claros e seguem as convenções de nomenclatura do Rust.
- Organização: O código já estava bem organizado, mas certifiquei-me de que as funções estivessem em uma ordem lógica.
- Tratamento de erros: O código já estava tratando erros, mas certifiquei-me de que os erros estivessem sendo propagados corretamente.
- Testes: Embora não tenha adicionado testes explícitos, o código
mainserve como um exemplo de uso da funçãocompare_images.
Esses parâmetros ajudam a tornar o código mais legível, manutenível e fácil de entender para outros desenvolvedores.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.