Merge branch 'main' of ssh://github.com/bghira/TrainingSample into bugfix/fix-imdecode-conversion

Author: bghira

src/cv_compat.rs

@@ -230,7 +230,7 @@ pub mod cvtcolor {
         let h = if delta == 0.0 {
             0.0
         } else if max == r {
-            60.0 * (((g - b) / delta) % 6.0)
+            60.0 * (((g - b) / delta).rem_euclid(6.0))
         } else if max == g {
             60.0 * ((b - r) / delta + 2.0)
         } else {

src/opencv_ops.rs

@@ -4,7 +4,7 @@ use ndarray::{Array3, ArrayView3};
 #[cfg(feature = "opencv")]
 use opencv::{
     core::{AlgorithmHint, Mat},
-    imgproc::{cvt_color, resize, COLOR_RGB2GRAY, INTER_LANCZOS4},
+    imgproc::{cvt_color, resize, COLOR_RGB2GRAY, INTER_LANCZOS4, INTER_LINEAR},
     prelude::*,
 };
 
@@ -30,6 +30,15 @@ impl OpenCVBatchProcessor {
         &self,
         images: &[ArrayView3<u8>],
         target_sizes: &[(u32, u32)], // (width, height)
+    ) -> Result<Vec<Array3<u8>>> {
+        self.batch_resize_images_with_interpolation(images, target_sizes, INTER_LINEAR)
+    }
+
+    fn batch_resize_images_with_interpolation(
+        &self,
+        images: &[ArrayView3<u8>],
+        target_sizes: &[(u32, u32)], // (width, height)
+        interpolation: i32,
     ) -> Result<Vec<Array3<u8>>> {
         if images.len() != target_sizes.len() {
             anyhow::bail!("Number of images and target sizes must match");
@@ -39,7 +48,7 @@ impl OpenCVBatchProcessor {
             .iter()
             .zip(target_sizes.iter())
             .map(|(image, &(target_width, target_height))| {
-                self.resize_single_opencv(image, target_width, target_height)
+                self.resize_single_opencv(image, target_width, target_height, interpolation)
             })
             .collect::<Result<Vec<_>>>()?;
 
@@ -111,8 +120,7 @@ impl OpenCVBatchProcessor {
         images: &[ArrayView3<u8>],
         target_sizes: &[(u32, u32)], // (width, height)
     ) -> Result<Vec<Array3<u8>>> {
-        // Use the same implementation as batch_resize_images but with Lanczos4
-        self.batch_resize_images(images, target_sizes)
+        self.batch_resize_images_with_interpolation(images, target_sizes, INTER_LANCZOS4)
     }
 
     /// Single image resize using OpenCV
@@ -121,6 +129,7 @@ impl OpenCVBatchProcessor {
         image: &ArrayView3<u8>,
         target_width: u32,
         target_height: u32,
+        interpolation: i32,
     ) -> Result<Array3<u8>> {
         let (_height, _width, channels) = image.dim();
 
@@ -139,7 +148,7 @@ impl OpenCVBatchProcessor {
             opencv::core::Size::new(target_width as i32, target_height as i32),
             0.0,
             0.0,
-            INTER_LANCZOS4,
+            interpolation,
         )?;
 
         // Convert back to ndarray
@@ -243,7 +252,7 @@ pub fn resize_bilinear_opencv(
     target_height: u32,
 ) -> Result<Array3<u8>> {
     let processor = OpenCVBatchProcessor::new();
-    processor.resize_single_opencv(image, target_width, target_height)
+    processor.resize_single_opencv(image, target_width, target_height, INTER_LINEAR)
 }
 
 #[cfg(feature = "opencv")]
@@ -253,7 +262,7 @@ pub fn resize_lanczos4_opencv(
     target_height: u32,
 ) -> Result<Array3<u8>> {
     let processor = OpenCVBatchProcessor::new();
-    processor.resize_single_opencv(image, target_width, target_height)
+    processor.resize_single_opencv(image, target_width, target_height, INTER_LANCZOS4)
 }
 
 #[cfg(not(feature = "opencv"))]

src/python_bindings.rs

@@ -952,17 +952,20 @@ pub fn batch_random_crop_images<'py>(
 
 #[cfg(feature = "python-bindings")]
 #[pyfunction]
-pub fn batch_calculate_luminance(images: Vec<PyReadonlyArray3<u8>>) -> PyResult<Vec<f64>> {
-    // Keep original sequential implementation for fair comparison
-    let mut luminances = Vec::with_capacity(images.len());
+pub fn batch_calculate_luminance(
+    py: Python<'_>,
+    images: Vec<PyReadonlyArray3<u8>>,
+) -> PyResult<Vec<f64>> {
+    use rayon::prelude::*;
 
-    for image in images.iter() {
-        let img_view = image.as_array();
-        let luminance = crate::luminance::calculate_luminance_array(&img_view);
-        luminances.push(luminance);
-    }
+    let image_views: Vec<_> = images.iter().map(|image| image.as_array()).collect();
 
-    Ok(luminances)
+    Ok(py.allow_threads(|| {
+        image_views
+            .par_iter()
+            .map(crate::luminance::calculate_luminance_array_sequential)
+            .collect()
+    }))
 }
 
 // TSR FORMAT CONVERSION OPERATIONS (BENCHMARK WINNERS)

src/tests.rs

@@ -332,8 +332,9 @@ mod edge_case_tests {
 
 #[cfg(test)]
 mod cv_compat_tests {
-    use crate::cv_compat::{imdecode, ImreadFlags};
+    use crate::cv_compat::{cvt_color, imdecode, ColorConversionCode, ImreadFlags};
     use image::{DynamicImage, ImageBuffer, ImageFormat, Luma, LumaA, Rgb, Rgba};
+    use ndarray::Array3;
     use std::io::Cursor;
 
     #[test]
@@ -420,6 +421,20 @@ mod cv_compat_tests {
         assert_eq!(decoded[[1, 1, 0]], 23);
         assert_eq!(decoded[[1, 1, 1]], 32);
     }
+
+    #[test]
+    fn test_rgb_to_hsv_wraps_negative_red_sector_hues() {
+        let src =
+            Array3::from_shape_vec((1, 1, 3), vec![255, 0, 128]).expect("shape should be valid");
+
+        let hsv = cvt_color(&src.view(), ColorConversionCode::ColorRgb2Hsv).unwrap();
+
+        // This color sits in the red sector with g < b, so hue should wrap near 330 degrees.
+        // OpenCV stores hue in [0, 179], so we expect approximately 165 instead of clamping to 0.
+        assert!(hsv[[0, 0, 0]] >= 160);
+        assert_eq!(hsv[[0, 0, 1]], 255);
+        assert_eq!(hsv[[0, 0, 2]], 255);
+    }
 }
 
 // OpenCV specific tests
@@ -429,7 +444,7 @@ mod opencv_tests {
     use super::*;
 
     #[cfg(feature = "opencv")]
-    use crate::opencv_ops::OpenCVBatchProcessor;
+    use crate::opencv_ops::{resize_bilinear_opencv, resize_lanczos4_opencv, OpenCVBatchProcessor};
 
     #[test]
     #[cfg(feature = "opencv")]
@@ -448,6 +463,40 @@ mod opencv_tests {
         assert_eq!(resized[0].dim(), (128, 128, 3));
     }
 
+    #[test]
+    #[cfg(feature = "opencv")]
+    fn test_opencv_resize_interpolation_contract() {
+        let processor = OpenCVBatchProcessor::new();
+        let high_frequency =
+            Array3::from_shape_fn(
+                (4, 4, 3),
+                |(y, x, c)| {
+                    if (x + y + c) % 2 == 0 {
+                        0
+                    } else {
+                        255
+                    }
+                },
+            );
+
+        let bilinear = resize_bilinear_opencv(&high_frequency.view(), 7, 7).unwrap();
+        let lanczos = resize_lanczos4_opencv(&high_frequency.view(), 7, 7).unwrap();
+        assert_ne!(
+            bilinear, lanczos,
+            "bilinear and lanczos paths should use different OpenCV interpolation modes"
+        );
+
+        let batch_linear = processor
+            .batch_resize_images(&[high_frequency.view()], &[(7, 7)])
+            .unwrap();
+        let batch_lanczos = processor
+            .batch_resize_lanczos4(&[high_frequency.view()], &[(7, 7)])
+            .unwrap();
+
+        assert_eq!(batch_linear[0], bilinear);
+        assert_eq!(batch_lanczos[0], lanczos);
+    }
+
     #[test]
     #[cfg(feature = "opencv")]
     fn test_opencv_batch_luminance() {