fmt/clippy

Author: kornelski

examples/basic.rs

@@ -26,5 +26,9 @@ fn main() {
     // You can reuse the result to generate several images with the same palette
     let (palette, pixels) = res.remapped(&mut img).unwrap();
 
-    println!("Done! Got palette {palette:?} and {} pixels with {}% quality", pixels.len(), res.quantization_quality().unwrap());
+    println!(
+        "Done! Got palette {palette:?} and {} pixels with {}% quality",
+        pixels.len(),
+        res.quantization_quality().unwrap()
+    );
 }

imagequant-sys/src/ffi.rs

@@ -612,17 +612,17 @@ pub unsafe extern "C" fn liq_histogram_add_colors(input_hist: &mut liq_histogram
     if bad_object!(attr, LIQ_ATTR_MAGIC) ||
        bad_object!(input_hist, LIQ_HISTOGRAM_MAGIC) { return Error::InvalidPointer; }
     let input_hist = &mut input_hist.inner;
-
-    if num_entries < 0 {
-        return Error::ValueOutOfRange;
-    }
     if num_entries == 0 {
         return LIQ_OK;
     }
 
+    let Ok(num_entries) = num_entries.try_into() else {
+        return Error::ValueOutOfRange;
+    };
+
     if liq_received_invalid_pointer(entries.cast()) { return Error::InvalidPointer; }
 
-    let entries = std::slice::from_raw_parts(entries, num_entries as usize);
+    let entries = std::slice::from_raw_parts(entries, num_entries);
 
     input_hist.add_colors(entries, gamma).err().unwrap_or(LIQ_OK)
 }

src/capi.rs

@@ -3,14 +3,10 @@
 #![allow(missing_docs)]
 #![allow(clippy::missing_safety_doc)]
 
-use crate::rows::RowCallback;
-use crate::Attributes;
-use crate::Error;
-use crate::Image;
 use crate::pal::Palette;
-use crate::QuantizationResult;
-use crate::RGBA;
+use crate::rows::RowCallback;
 use crate::seacow::{Pointer, RowBitmapMut, SeaCow};
+use crate::{Attributes, Error, Image, QuantizationResult, RGBA};
 use std::mem::MaybeUninit;
 
 pub const LIQ_VERSION: u32 = 40202;

src/hist.rs

@@ -240,7 +240,7 @@ impl Histogram {
         self.posterize_bits = posterize_bits;
         let new_posterize_mask = self.posterize_mask();
 
-        let new_size = (self.hashmap.len()/3).max(self.hashmap.capacity()/5);
+        let new_size = (self.hashmap.len() / 3).max(self.hashmap.capacity() / 5);
         let old_hashmap = std::mem::replace(&mut self.hashmap, HashMap::with_capacity_and_hasher(new_size, U32Hasher(0)));
         self.hashmap.extend(old_hashmap.into_iter().map(move |(k, v)| {
             (k & new_posterize_mask, v)

src/image.rs

@@ -4,9 +4,8 @@ use crate::error::*;
 use crate::pal::{f_pixel, PalF, PalIndexRemap, MAX_COLORS, MIN_OPAQUE_A, RGBA};
 use crate::remap::DitherMapMode;
 use crate::rows::{DynamicRows, PixelsSource};
-use crate::PushInCapacity;
-use crate::LIQ_HIGH_MEMORY_LIMIT;
 use crate::seacow::{RowBitmap, SeaCow};
+use crate::{PushInCapacity, LIQ_HIGH_MEMORY_LIMIT};
 use rgb::prelude::*;
 use std::mem::MaybeUninit;
 
@@ -148,11 +147,11 @@ impl<'pixels> Image<'pixels> {
                     while i < col {
                         if let Some(prev_row) = prev_row {
                             let pixelabove = prev_row[i];
-                            if pixelabove == lastpixel { neighbor_count += 15; };
+                            if pixelabove == lastpixel { neighbor_count += 15; }
                         }
                         if let Some((next_row, _)) = rows.peek() {
                             let pixelbelow = next_row[i];
-                            if pixelbelow == lastpixel { neighbor_count += 15; };
+                            if pixelbelow == lastpixel { neighbor_count += 15; }
                         }
                         i += 1;
                     }

src/kmeans.rs

@@ -1,11 +1,10 @@
-use crate::CacheLineAlign;
 use crate::hist::{HistItem, HistogramInternal};
 use crate::nearest::Nearest;
 use crate::pal::{f_pixel, PalF, PalIndex, PalPop};
 use crate::rayoff::*;
-use crate::Error;
-use rgb::Argb;
+use crate::{CacheLineAlign, Error};
 use rgb::prelude::*;
+use rgb::Argb;
 use std::cell::RefCell;
 
 /// K-Means iteration: new palette color is computed from weighted average of colors that map best to that palette entry.

src/mediancut.rs

@@ -116,7 +116,7 @@ impl<'hist> MBox<'hist> {
 
     fn median_color(&mut self) -> f_pixel {
         let len = self.colors.len();
-        let (_, mid_item, _) = self.colors.select_nth_unstable_by_key(len/2, |a| a.mc_sort_value());
+        let (_, mid_item, _) = self.colors.select_nth_unstable_by_key(len / 2, |a| a.mc_sort_value());
         mid_item.color
     }
 
@@ -172,7 +172,9 @@ fn qsort_partition(base: &mut [HistItem]) -> usize {
             l += 1;
         } else {
             r -= 1;
-            while l < r && base[r].mc_sort_value() <= pivot_value { r -= 1; }
+            while l < r && base[r].mc_sort_value() <= pivot_value {
+                r -= 1;
+            }
             base.swap(l, r);
         }
     }
@@ -186,7 +188,9 @@ fn qsort_partition(base: &mut [HistItem]) -> usize {
 #[inline(never)]
 fn hist_item_sort_half(mut base: &mut [HistItem], mut weight_half_sum: f64) -> usize {
     let mut base_index = 0;
-    if base.is_empty() { return 0; }
+    if base.is_empty() {
+        return 0;
+    }
     loop {
         let partition = qsort_partition(base);
         let (left, right) = base.split_at_mut(partition + 1); // +1, because pivot stays on the left side
@@ -248,7 +252,7 @@ impl<'hist> MedianCutter<'hist> {
             }
         } else {
             boxes.push_in_cap(MBox::new(hist_items));
-        };
+        }
 
         Ok(Self {
             boxes,

src/nearest.rs

@@ -20,7 +20,9 @@ impl<'pal> Nearest<'pal> {
         };
         for (i, color) in palette.as_slice().iter().enumerate() {
             let mut best = Visitor {
-                idx: 0, distance: f32::MAX, distance_squared: f32::MAX,
+                idx: 0,
+                distance: f32::MAX,
+                distance_squared: f32::MAX,
                 exclude: Some(i as PalIndex),
             };
             vp_search_node(&handle.root, color, &mut best);
@@ -46,7 +48,12 @@ impl Nearest<'_> {
                 exclude: None,
             }
         } else {
-            Visitor { distance: f32::INFINITY, distance_squared: f32::INFINITY, idx: 0, exclude: None, }
+            Visitor {
+                distance: f32::INFINITY,
+                distance_squared: f32::INFINITY,
+                idx: 0,
+                exclude: None,
+            }
         };
 
         vp_search_node(&self.root, px, &mut best_candidate);

src/quant.rs

@@ -4,9 +4,8 @@ use crate::hist::HistogramInternal;
 use crate::image::Image;
 use crate::kmeans::Kmeans;
 use crate::mediancut::mediancut;
-use crate::pal::{PalIndexRemap, PalF, PalLen, PalPop, Palette, LIQ_WEIGHT_MSE, MAX_COLORS, MAX_TRANSP_A, RGBA};
-use crate::remap::{mse_to_standard_mse, DitherMapMode, Remapped};
-use crate::remap::{remap_to_palette, remap_to_palette_floyd};
+use crate::pal::{PalF, PalIndexRemap, PalLen, PalPop, Palette, LIQ_WEIGHT_MSE, MAX_COLORS, MAX_TRANSP_A, RGBA};
+use crate::remap::{mse_to_standard_mse, remap_to_palette, remap_to_palette_floyd, DitherMapMode, Remapped};
 use crate::seacow::RowBitmapMut;
 use crate::OrdFloat;
 use arrayvec::ArrayVec;
@@ -455,7 +454,7 @@ pub(crate) fn quality_to_mse(quality: u8) -> f64 {
 
 pub(crate) fn mse_to_quality(mse: f64) -> u8 {
     for i in (1..101).rev() {
-        if mse <= quality_to_mse(i) + 0.000001 { return i; };
+        if mse <= quality_to_mse(i) + 0.000001 { return i; }
     }
     0
 }

src/seacow.rs

@@ -1,6 +1,6 @@
+use std::mem::MaybeUninit;
 #[cfg(feature = "_internal_c_ffi")]
 use std::os::raw::c_void;
-use std::mem::MaybeUninit;
 
 #[derive(Clone)]
 pub struct SeaCow<'a, T> {