trainingsample 0.2.18__tar.gz → 0.3.0__tar.gz

{trainingsample-0.2.18 → trainingsample-0.3.0}/Cargo.lock

@@ -1835,7 +1835,7 @@ dependencies = [
 
 [[package]]
 name = "trainingsample"
-version = "0.2.18"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "criterion",

{trainingsample-0.2.18 → trainingsample-0.3.0}/Cargo.toml

@@ -39,7 +39,7 @@ description = "High-performance Rust reimplementation of GIL-blocking video/imag
 edition = "2021"
 license = "MIT"
 name = "trainingsample"
-version = "0.2.18"
+version = "0.3.0"
 readme = "README.md"
 
 [profile.release]

{trainingsample-0.2.18 → trainingsample-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trainingsample
-Version: 0.2.18
+Version: 0.3.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{trainingsample-0.2.18 → trainingsample-0.3.0}/pyproject.toml

@@ -17,7 +17,7 @@ description = "High-performance Rust reimplementation of GIL-blocking video/imag
 license = {text = "MIT"}
 name = "trainingsample"
 requires-python = ">=3.11"
-version = "0.2.18"
+version = "0.3.0"
 
 [project.optional-dependencies]
 dev = ["pytest>=6.0", "pytest-benchmark", "maturin>=1.0,<2.0", "pre-commit"]

{trainingsample-0.2.18 → trainingsample-0.3.0}/src/cropping.rs

@@ -8,19 +8,47 @@ pub fn crop_image_array(
     width: usize,
     height: usize,
 ) -> Result<Array3<u8>> {
-    let (img_height, img_width, _channels) = image.dim();
+    let (img_height, img_width, channels) = image.dim();
 
     if width == 0 || height == 0 {
         return Err(anyhow::anyhow!("Crop dimensions must be greater than zero"));
     }
 
-    if x + width > img_width || y + height > img_height {
+    let end_x = x
+        .checked_add(width)
+        .ok_or_else(|| anyhow::anyhow!("Crop bounds exceed image dimensions"))?;
+    let end_y = y
+        .checked_add(height)
+        .ok_or_else(|| anyhow::anyhow!("Crop bounds exceed image dimensions"))?;
+
+    if end_x > img_width || end_y > img_height {
         return Err(anyhow::anyhow!("Crop bounds exceed image dimensions"));
     }
 
-    // Use assign to avoid allocation where possible, but still return owned array
-    let slice = image.slice(s![y..y + height, x..x + width, ..]);
-    // Only allocate when we need to return an owned array
+    if let Some(src) = image.as_slice() {
+        let output_len = height
+            .checked_mul(width)
+            .and_then(|pixels| pixels.checked_mul(channels))
+            .ok_or_else(|| anyhow::anyhow!("Crop dimensions are too large"))?;
+        let mut output = Vec::with_capacity(output_len);
+
+        // Every byte in the reserved output is initialized by crop_raw_buffer
+        // before the Vec length is exposed to safe Rust.
+        unsafe {
+            crop_raw_buffer(
+                src.as_ptr(),
+                (img_height, img_width, channels),
+                output.as_mut_ptr(),
+                (y, x, height, width),
+            );
+            output.set_len(output_len);
+        }
+
+        return Array3::from_shape_vec((height, width, channels), output).map_err(Into::into);
+    }
+
+    // Preserve support for non-contiguous ndarray views with the generic path.
+    let slice = image.slice(s![y..end_y, x..end_x, ..]);
     Ok(slice.to_owned())
 }
 
@@ -111,16 +139,7 @@ pub fn batch_center_crop_arrays(
         let actual_width = target_width.min(img_width);
         let actual_height = target_height.min(img_height);
 
-        // Validate bounds
-        if x + actual_width > img_width || y + actual_height > img_height {
-            return Err(anyhow::anyhow!("Crop bounds exceed image dimensions"));
-        }
-
-        // Direct slice and copy - optimized for speed
-        let cropped = image
-            .slice(s![y..y + actual_height, x..x + actual_width, ..])
-            .to_owned();
-        results.push(cropped);
+        results.push(crop_image_array(image, x, y, actual_width, actual_height)?);
     }
 
     Ok(results)

{trainingsample-0.2.18 → trainingsample-0.3.0}/src/opencv_ops.rs

@@ -65,47 +65,81 @@ impl OpenCVBatchProcessor {
             anyhow::bail!("Number of videos and target sizes must match");
         }
 
-        // ULTRA-OPTIMIZED: Flatten all frames from all videos into one massive batch
-        let mut all_frames = Vec::new();
-        let mut all_target_sizes = Vec::new();
-        let mut video_frame_counts = Vec::new();
+        let mut results = Vec::with_capacity(videos.len());
 
-        for (video, &target_size) in videos.iter().zip(target_sizes.iter()) {
-            let (frames, _, _, _) = video.dim();
-            video_frame_counts.push(frames);
-
-            // Collect all frames from this video
-            for frame_idx in 0..frames {
-                let frame = video.index_axis(ndarray::Axis(0), frame_idx);
-                all_frames.push(frame);
-                all_target_sizes.push(target_size);
+        for (video, &(target_width, target_height)) in videos.iter().zip(target_sizes.iter()) {
+            let (frames, src_height, src_width, channels) = video.dim();
+            if channels != 3 {
+                anyhow::bail!("Only 3-channel RGB videos are supported");
             }
-        }
 
-        // Process ALL frames in one giant batch operation - maximum efficiency!
-        let resized_frames = self.batch_resize_images(&all_frames, &all_target_sizes)?;
-
-        // Reconstruct video structure from flattened results
-        let mut results = Vec::new();
-        let mut frame_idx = 0;
-
-        for (video_idx, frame_count) in video_frame_counts.iter().enumerate() {
-            let (target_width, target_height) = target_sizes[video_idx];
-            let result_shape = (
-                *frame_count,
+            let src_height = i32::try_from(src_height)?;
+            let src_width = i32::try_from(src_width)?;
+            let dst_height = i32::try_from(target_height)?;
+            let dst_width = i32::try_from(target_width)?;
+            let mut video_result = ndarray::Array4::<u8>::zeros((
+                frames,
                 target_height as usize,
                 target_width as usize,
-                3,
-            );
-            let mut video_result = ndarray::Array4::<u8>::zeros(result_shape);
-
-            // Copy frames for this video
-            for local_frame_idx in 0..*frame_count {
-                let global_frame = &resized_frames[frame_idx];
-                video_result
-                    .index_axis_mut(ndarray::Axis(0), local_frame_idx)
-                    .assign(global_frame);
-                frame_idx += 1;
+                channels,
+            ));
+            let output = video_result
+                .as_slice_mut()
+                .ok_or_else(|| anyhow::anyhow!("Output video is not contiguous"))?;
+            let output_frame_len = (target_height as usize)
+                .checked_mul(target_width as usize)
+                .and_then(|pixels| pixels.checked_mul(channels))
+                .ok_or_else(|| anyhow::anyhow!("Target video dimensions are too large"))?;
+
+            for frame_idx in 0..frames {
+                let frame = video.index_axis(ndarray::Axis(0), frame_idx);
+                let input = frame
+                    .as_slice()
+                    .ok_or_else(|| anyhow::anyhow!("Video frame data is not contiguous"))?;
+                let output_offset = frame_idx
+                    .checked_mul(output_frame_len)
+                    .ok_or_else(|| anyhow::anyhow!("Target video dimensions are too large"))?;
+                let output_end = output_offset
+                    .checked_add(output_frame_len)
+                    .ok_or_else(|| anyhow::anyhow!("Target video dimensions are too large"))?;
+                let output_len = output.len();
+                let output_frame = output.get_mut(output_offset..output_end).ok_or_else(|| {
+                    anyhow::anyhow!(
+                        "Output frame {} range {}..{} exceeds the video buffer length {}",
+                        frame_idx,
+                        output_offset,
+                        output_end,
+                        output_len
+                    )
+                })?;
+
+                let src_mat = unsafe {
+                    Mat::new_rows_cols_with_data_unsafe(
+                        src_height,
+                        src_width,
+                        opencv::core::CV_8UC3,
+                        input.as_ptr() as *mut std::ffi::c_void,
+                        opencv::core::Mat_AUTO_STEP,
+                    )?
+                };
+                let mut dst_mat = unsafe {
+                    Mat::new_rows_cols_with_data_unsafe(
+                        dst_height,
+                        dst_width,
+                        opencv::core::CV_8UC3,
+                        output_frame.as_mut_ptr() as *mut std::ffi::c_void,
+                        opencv::core::Mat_AUTO_STEP,
+                    )?
+                };
+
+                resize(
+                    &src_mat,
+                    &mut dst_mat,
+                    opencv::core::Size::new(dst_width, dst_height),
+                    0.0,
+                    0.0,
+                    INTER_LINEAR,
+                )?;
             }
 
             results.push(video_result);
@@ -131,28 +165,60 @@ impl OpenCVBatchProcessor {
         target_height: u32,
         interpolation: i32,
     ) -> Result<Array3<u8>> {
-        let (_height, _width, channels) = image.dim();
+        let (height, width, channels) = image.dim();
 
         if channels != 3 {
             anyhow::bail!("Only 3-channel RGB images are supported");
         }
 
-        // Convert ndarray to OpenCV Mat
-        let src_mat = self.ndarray_to_mat(image)?;
+        let data_slice = image
+            .as_slice()
+            .ok_or_else(|| anyhow::anyhow!("Image data is not contiguous"))?;
+        let src_height = i32::try_from(height)
+            .map_err(|_| anyhow::anyhow!("Source height {} exceeds OpenCV's limit", height))?;
+        let src_width = i32::try_from(width)
+            .map_err(|_| anyhow::anyhow!("Source width {} exceeds OpenCV's limit", width))?;
+        let dst_height = i32::try_from(target_height).map_err(|_| {
+            anyhow::anyhow!("Target height {} exceeds OpenCV's limit", target_height)
+        })?;
+        let dst_width = i32::try_from(target_width)
+            .map_err(|_| anyhow::anyhow!("Target width {} exceeds OpenCV's limit", target_width))?;
+
+        // OpenCV only needs lightweight Mat headers here. Point them at the
+        // ndarray storage so resize can read the input and write the final
+        // output without copying either full image through an intermediate Mat.
+        let src_mat = unsafe {
+            Mat::new_rows_cols_with_data_unsafe(
+                src_height,
+                src_width,
+                opencv::core::CV_8UC3,
+                data_slice.as_ptr() as *mut std::ffi::c_void,
+                opencv::core::Mat_AUTO_STEP,
+            )?
+        };
+
+        let mut result =
+            Array3::<u8>::zeros((target_height as usize, target_width as usize, channels));
+        let mut dst_mat = unsafe {
+            Mat::new_rows_cols_with_data_unsafe(
+                dst_height,
+                dst_width,
+                opencv::core::CV_8UC3,
+                result.as_mut_ptr() as *mut std::ffi::c_void,
+                opencv::core::Mat_AUTO_STEP,
+            )?
+        };
 
-        // Perform OpenCV resize
-        let mut dst_mat = Mat::default();
         resize(
             &src_mat,
             &mut dst_mat,
-            opencv::core::Size::new(target_width as i32, target_height as i32),
+            opencv::core::Size::new(dst_width, dst_height),
             0.0,
             0.0,
             interpolation,
         )?;
 
-        // Convert back to ndarray
-        self.mat_to_ndarray(&dst_mat)
+        Ok(result)
     }
 
     // Single video resize function removed - now using batch_resize_videos for all operations
@@ -218,28 +284,6 @@ impl OpenCVBatchProcessor {
 
         Ok(mat)
     }
-
-    /// Convert OpenCV Mat back to ndarray (optimized for performance)
-    fn mat_to_ndarray(&self, mat: &Mat) -> Result<Array3<u8>> {
-        let height = mat.rows() as usize;
-        let width = mat.cols() as usize;
-        let channels = mat.channels() as usize;
-
-        if channels != 3 {
-            anyhow::bail!("Expected 3-channel image");
-        }
-
-        let mut result = Array3::<u8>::zeros((height, width, channels));
-
-        // Optimized bulk memory copy from OpenCV Mat to ndarray
-        unsafe {
-            let src_ptr = mat.ptr(0)?;
-            let dst_ptr = result.as_mut_ptr();
-            std::ptr::copy_nonoverlapping(src_ptr, dst_ptr, height * width * channels);
-        }
-
-        Ok(result)
-    }
 }
 
 // HIGH-PERFORMANCE RESIZE WRAPPERS (REPLACE METAL GPU FUNCTIONS)

{trainingsample-0.2.18 → trainingsample-0.3.0}/src/python_bindings.rs

@@ -599,10 +599,8 @@ fn is_tuple_or_list_of_two(obj: &Bound<PyAny>) -> bool {
 #[cfg(feature = "opencv")]
 #[pyclass]
 pub struct ResizeIterator {
-    /// Raw buffer pointers and their dimensions
-    buffers: Vec<(Vec<u8>, (usize, usize, usize))>, // (buffer, (height, width, channels))
-    /// Current iteration index
-    index: usize,
+    /// Completed buffers waiting to be transferred to NumPy.
+    buffers: std::collections::VecDeque<(Vec<u8>, (usize, usize, usize))>,
 }
 
 #[cfg(feature = "opencv")]
@@ -613,17 +611,13 @@ impl ResizeIterator {
     }
 
     fn __next__<'py>(&mut self, py: Python<'py>) -> Option<Bound<'py, PyArray3<u8>>> {
-        if self.index >= self.buffers.len() {
-            return None;
-        }
-
-        let (buffer, (height, width, channels)) = &self.buffers[self.index];
-        self.index += 1;
+        let (buffer, (height, width, channels)) = self.buffers.pop_front()?;
 
-        // Convert raw buffer directly to PyArray3 - ZERO intermediate steps!
-        match ndarray::Array3::from_shape_vec((*height, *width, *channels), buffer.clone()) {
+        // Transfer the completed allocation directly into the ndarray instead
+        // of cloning the full resized image during iteration.
+        match ndarray::Array3::from_shape_vec((height, width, channels), buffer) {
             Ok(array) => Some(PyArray3::from_owned_array_bound(py, array)),
-            Err(_) => None, // Skip malformed arrays
+            Err(_) => None, // Malformed buffer; end iteration (StopIteration)
         }
     }
 
@@ -677,8 +671,7 @@ pub fn batch_resize_images_iterator<'py>(
         return Bound::new(
             py,
             ResizeIterator {
-                buffers: Vec::new(),
-                index: 0,
+                buffers: std::collections::VecDeque::new(),
             },
         );
     }
@@ -856,7 +849,12 @@ pub fn batch_resize_images_iterator<'py>(
         .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("Resize failed: {}", e)))?;
 
     // Return iterator with raw buffers - conversion happens on-demand!
-    Bound::new(py, ResizeIterator { buffers, index: 0 })
+    Bound::new(
+        py,
+        ResizeIterator {
+            buffers: buffers.into(),
+        },
+    )
 }
 
 // TSR CROPPING OPERATIONS (BENCHMARK WINNERS)
@@ -1204,7 +1202,7 @@ pub fn resize_lanczos4_opencv<'py>(
 #[pyfunction]
 pub fn imdecode_py<'py>(
     py: Python<'py>,
-    buf: &[u8],
+    buf: pyo3::pybacked::PyBackedBytes,
     flags: i32,
 ) -> PyResult<Bound<'py, PyArray3<u8>>> {
     use crate::cv_compat::{imdecode, ImreadFlags};
@@ -1220,7 +1218,6 @@ pub fn imdecode_py<'py>(
         }
     };
 
-    let buf = buf.to_vec();
     let decoded = py.allow_threads(move || imdecode(&buf, imread_flags));
 
     match decoded {

{trainingsample-0.2.18 → trainingsample-0.3.0}/src/tests.rs

@@ -78,6 +78,17 @@ mod cropping_tests {
         assert!(result.is_err());
     }
 
+    #[test]
+    fn test_crop_non_contiguous_view() {
+        let img = create_test_image();
+        let strided = img.slice(ndarray::s![.., ..;2, ..]);
+        let result = crop_image_array(&strided, 5, 10, 20, 30).unwrap();
+
+        assert_eq!(result.dim(), (30, 20, 3));
+        assert_eq!(result[[0, 0, 0]], img[[10, 10, 0]]);
+        assert_eq!(result[[29, 19, 2]], img[[39, 48, 2]]);
+    }
+
     #[test]
     fn test_center_crop_image_array() {
         let img = create_test_image();

{trainingsample-0.2.18 → trainingsample-0.3.0}/tests/comprehensive_tests.rs

@@ -598,45 +598,59 @@ mod performance_validation_tests {
 
     #[test]
     fn test_batch_operations_scale_appropriately() {
+        use std::hint::black_box;
         use std::time::Instant;
 
         let base_img = create_gradient_image();
+        let crop = (10, 10, 30, 20);
+        let batch_size = 50;
+        let batch_imgs = vec![base_img.clone(); batch_size];
+        let batch_crops = vec![crop; batch_size];
 
-        // Warm up - run a few operations to ensure consistent timing
+        // Warm both Rayon paths before measuring.
         for _ in 0..3 {
-            let _ = batch_crop_image_arrays(std::slice::from_ref(&base_img), &[(10, 10, 30, 20)]);
+            black_box(batch_crop_image_arrays(
+                std::slice::from_ref(&base_img),
+                &[crop],
+            ));
+            black_box(batch_crop_image_arrays(&batch_imgs, &batch_crops));
         }
 
-        // Single operation - run multiple times and take average
-        let mut single_total = std::time::Duration::new(0, 0);
-        for _ in 0..5 {
+        // Each sample performs enough work to keep microsecond-scale timer
+        // noise from dominating the comparison.
+        let mut single_samples = Vec::with_capacity(11);
+        let mut batch_samples = Vec::with_capacity(11);
+        for _ in 0..11 {
             let start = Instant::now();
-            let _single =
-                batch_crop_image_arrays(std::slice::from_ref(&base_img), &[(10, 10, 30, 20)]);
-            single_total += start.elapsed();
-        }
-        let single_duration = single_total / 5;
-
-        // Batch of 50 (larger batch for better parallelism benefits)
-        let batch_imgs = vec![base_img.clone(); 50];
-        let batch_crops = vec![(10, 10, 30, 20); 50];
+            for _ in 0..100 {
+                black_box(batch_crop_image_arrays(
+                    std::slice::from_ref(&base_img),
+                    &[crop],
+                ));
+            }
+            single_samples.push(start.elapsed().as_nanos() / 100);
 
-        // Run batch operation multiple times and take average
-        let mut batch_total = std::time::Duration::new(0, 0);
-        for _ in 0..3 {
             let start = Instant::now();
-            let _batch = batch_crop_image_arrays(&batch_imgs, &batch_crops);
-            batch_total += start.elapsed();
+            for _ in 0..10 {
+                black_box(batch_crop_image_arrays(&batch_imgs, &batch_crops));
+            }
+            batch_samples.push(start.elapsed().as_nanos() / (10 * batch_size as u128));
         }
-        let batch_duration = batch_total / 3;
 
-        // Batch should not be more than 75x slower (more reasonable for 50x operations)
-        // Allow for system variance and parallelism overhead
-        let slowdown_ratio = batch_duration.as_nanos() as f64 / single_duration.as_nanos() as f64;
+        single_samples.sort_unstable();
+        batch_samples.sort_unstable();
+        let single_per_image = single_samples[single_samples.len() / 2];
+        let batch_per_image = batch_samples[batch_samples.len() / 2];
+        let per_image_ratio = batch_per_image as f64 / single_per_image as f64;
+
+        // Small crops may not amortize Rayon scheduling, so this is a broad
+        // regression guard rather than an assertion that batching must win.
         assert!(
-            slowdown_ratio < 75.0,
-            "Batch processing should benefit from parallelism: ratio {:.2}, single: {:?}, batch: {:?}",
-            slowdown_ratio, single_duration, batch_duration
+            per_image_ratio < 20.0,
+            "Batch crop per-image cost regressed: ratio {:.2}, single: {}ns, batch: {}ns",
+            per_image_ratio,
+            single_per_image,
+            batch_per_image
         );
     }
 }

{trainingsample-0.2.18 → trainingsample-0.3.0}/tests/test_performance_benchmarks.py

@@ -258,8 +258,8 @@ class TestBasicPerformance:
         )
 
     @pytest.mark.skipif(not HAS_OPENCV, reason="OpenCV not available")
-    def test_resize_batch_vs_individual_opencv(self, performance_test_images):
-        """Show TSR batch advantage: batch processing vs individual OpenCV calls."""
+    def test_resize_batch_vs_direct_opencv(self, performance_test_images):
+        """Compare TSR batching with equivalent direct OpenCV resize calls."""
         images = performance_test_images["mixed_sizes"][:8]  # Mix of different sizes
         target_size = (224, 224)
         target_sizes = [target_size] * len(images)
@@ -269,35 +269,29 @@ class TestBasicPerformance:
         tsr_results = tsr.batch_resize_images(images, target_sizes)
         tsr_time = time.perf_counter() - start
 
-        # OpenCV: Individual calls (the old way)
+        # OpenCV: equivalent individual resize calls. Resize is channel-order
+        # agnostic, so RGB/BGR conversions would add unrelated work.
         start = time.perf_counter()
-        opencv_results = []
-        for img in images:
-            # Convert to BGR for OpenCV, then back to RGB
-            bgr_img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-            resized_bgr = cv2.resize(
-                bgr_img, target_size, interpolation=cv2.INTER_LINEAR
-            )
-            resized_rgb = cv2.cvtColor(resized_bgr, cv2.COLOR_BGR2RGB)
-            opencv_results.append(resized_rgb)
+        opencv_results = [
+            cv2.resize(img, target_size, interpolation=cv2.INTER_LINEAR)
+            for img in images
+        ]
         opencv_time = time.perf_counter() - start
 
-        speedup = opencv_time / tsr_time if tsr_time > 0 else float("inf")
+        relative_time = opencv_time / tsr_time if tsr_time > 0 else float("inf")
 
         # Validate results
         assert len(tsr_results) == len(opencv_results) == len(images)
         for i, (tsr_img, cv_img) in enumerate(zip(tsr_results, opencv_results)):
             expected_shape = (target_size[1], target_size[0], 3)
             assert tsr_img.shape == cv_img.shape == expected_shape
-            # Results should be reasonably close (different algorithms may differ)
-            # TSR uses OpenCV internally but may have different interpolation settings
+            # Separate OpenCV builds can differ slightly in interpolation rounding.
             tsr_float = tsr_img.astype(float)
             cv_float = cv_img.astype(float)
             diff = np.mean(np.abs(tsr_float - cv_float))
-            # More lenient comparison since different resize implementations can vary
-            assert diff < 25.0, f"Image {i}: Results too different (mean diff: {diff})"
+            assert diff < 1.0, f"Image {i}: Results too different (mean diff: {diff})"
 
-        print(f"🚀 Resize Performance Comparison (batch size {len(images)}):")
+        print(f"Resize performance comparison (batch size {len(images)}):")
         print(f"  Input shapes: {[img.shape[:2] for img in images]}")
         tsr_imgs_per_sec = len(images) / tsr_time
         print(f"  TSR (batch):      {tsr_time:.4f}s ({tsr_imgs_per_sec:.1f} imgs/sec)")
@@ -306,14 +300,11 @@ class TestBasicPerformance:
             f"  OpenCV (individual): {opencv_time:.4f}s "
             f"({cv_imgs_per_sec:.1f} imgs/sec)"
         )
-        print(f"  🎯 TSR Advantage: {speedup:.2f}x faster")
-        print("  💡 Why TSR exists: Batch processing beats " "individual OpenCV calls")
+        print(f"  Relative time (OpenCV / TSR): {relative_time:.2f}x")
 
     @pytest.mark.skipif(not HAS_OPENCV, reason="OpenCV not available")
     def test_luminance_batch_vs_individual_opencv(self, performance_test_images):
-        """
-        Show TSR batch advantage: luminance calculation vs individual OpenCV calls.
-        """
+        """Compare TSR luminance with equivalent individual OpenCV calls."""
         images = performance_test_images["mixed_sizes"][:12]  # Mix of different sizes
 
         # TSR: Single batch call handles mixed shapes
@@ -321,32 +312,29 @@ class TestBasicPerformance:
         tsr_results = tsr.batch_calculate_luminance(images)
         tsr_time = time.perf_counter() - start
 
-        # OpenCV: Individual calls (the old way)
+        # OpenCV accepts RGB input directly for grayscale conversion.
         start = time.perf_counter()
         opencv_results = []
         for img in images:
-            # Convert RGB to BGR for OpenCV
-            bgr_img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-            # Convert to grayscale using OpenCV
-            gray = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2GRAY)
+            gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
             # Calculate mean luminance
             luminance = np.mean(gray)
             opencv_results.append(luminance)
         opencv_time = time.perf_counter() - start
 
-        speedup = opencv_time / tsr_time if tsr_time > 0 else float("inf")
+        relative_time = opencv_time / tsr_time if tsr_time > 0 else float("inf")
 
         # Validate results
         assert len(tsr_results) == len(opencv_results) == len(images)
         for i, (tsr_lum, cv_lum) in enumerate(zip(tsr_results, opencv_results)):
-            # Results should be close (small differences due to RGB vs BGR conversion)
+            # Results should be close despite implementation rounding differences.
             diff = abs(tsr_lum - cv_lum)
             assert diff < 2.0, (
                 f"Image {i}: Results too different: "
                 f"TSR {tsr_lum:.2f} vs OpenCV {cv_lum:.2f}"
             )
 
-        print(f"🚀 Luminance Performance Comparison (batch size {len(images)}):")
+        print(f"Luminance performance comparison (batch size {len(images)}):")
         print(f"  Input shapes: {[img.shape[:2] for img in images]}")
         tsr_imgs_per_sec = len(images) / tsr_time
         print(
@@ -357,14 +345,11 @@ class TestBasicPerformance:
             f"  OpenCV (individual): {opencv_time:.4f}s "
             f"({cv_imgs_per_sec:.1f} imgs/sec)"
         )
-        print(f"  🎯 TSR Advantage: {speedup:.2f}x faster")
-        print("  💡 Why TSR exists: Batch SIMD processing beats individual calls")
+        print(f"  Relative time (OpenCV / TSR): {relative_time:.2f}x")
 
     @pytest.mark.skipif(not HAS_OPENCV, reason="OpenCV not available")
     def test_complete_pipeline_batch_vs_individual(self, performance_test_images):
-        """
-        Show TSR's ultimate advantage: complete pipeline in batch vs individual ops.
-        """
+        """Compare equivalent resize-and-luminance pipelines."""
         images = performance_test_images["mixed_sizes"][:8]  # Mix of different sizes
         target_size = (224, 224)
         target_sizes = [target_size] * len(images)
@@ -377,22 +362,17 @@ class TestBasicPerformance:
         luminances = tsr.batch_calculate_luminance(resized)
         tsr_time = time.perf_counter() - start
 
-        # OpenCV: Individual operations (the painful old way)
+        # OpenCV: equivalent individual operations on RGB data.
         start = time.perf_counter()
         opencv_luminances = []
         for img in images:
-            # Individual resize with color space conversions
-            bgr_img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-            resized_bgr = cv2.resize(
-                bgr_img, target_size, interpolation=cv2.INTER_LINEAR
-            )
-            # Individual luminance calculation
-            gray = cv2.cvtColor(resized_bgr, cv2.COLOR_BGR2GRAY)
+            resized_rgb = cv2.resize(img, target_size, interpolation=cv2.INTER_LINEAR)
+            gray = cv2.cvtColor(resized_rgb, cv2.COLOR_RGB2GRAY)
             luminance = np.mean(gray)
             opencv_luminances.append(luminance)
         opencv_time = time.perf_counter() - start
 
-        speedup = opencv_time / tsr_time if tsr_time > 0 else float("inf")
+        relative_time = opencv_time / tsr_time if tsr_time > 0 else float("inf")
 
         # Validate results
         assert len(luminances) == len(opencv_luminances) == len(images)
@@ -404,7 +384,7 @@ class TestBasicPerformance:
             )
 
         print(
-            f"🚀 Complete Pipeline Performance (resize + luminance, "
+            f"Complete pipeline performance (resize + luminance, "
             f"batch size {len(images)}):"
         )
         input_shapes = [img.shape[:2] for img in images]
@@ -419,12 +399,8 @@ class TestBasicPerformance:
             f"  OpenCV (individual):     {opencv_time:.4f}s "
             f"({cv_imgs_per_sec:.1f} imgs/sec)"
         )
-        print(f"  🎯 TSR Advantage: {speedup:.2f}x faster")
-        print("  💡 Key Benefits:")
-        print(f"    • 2 batch calls vs {len(images)} individual operations")
-        print("    • Mixed-shape handling in single API calls")
-        print("    • No color space conversion overhead")
-        print("    • SIMD parallelization across entire batches")
+        print(f"  Relative time (OpenCV / TSR): {relative_time:.2f}x")
+        print("  TSR uses two extension calls; OpenCV uses an explicit Python loop")
 
     @pytest.mark.skipif(not HAS_OPENCV, reason="OpenCV not available")
     def test_mixed_shapes_batch_functionality(self, performance_test_images):
@@ -635,8 +611,8 @@ class TestBasicPerformance:
         print("  🎯 Key advantages:")
         print(f"    - Single API call handles {unique_input_shapes} input shapes")
         print(f"    - Produces {unique_output_shapes} different output shapes")
-        print("    - No loops needed: tsr.batch_crop_images(mixed_images, mixed_crops)")
-        print("    - vs NumPy: Must write loop for each different shape combination")
+        print("    - One Python call: tsr.batch_crop_images(mixed_images, mixed_crops)")
+        print("    - NumPy requires an explicit Python loop for mixed crop shapes")
 
 
 class TestMemoryEfficiency:

{trainingsample-0.2.18 → trainingsample-0.3.0}/tests/test_python_bindings.py

@@ -1,9 +1,11 @@
 """Tests for Python bindings of training_sample_rust."""
 
 import importlib.util
+import io
 
 import numpy as np
 import pytest
+from PIL import Image
 
 try:
     import trainingsample as tsr
@@ -34,6 +36,17 @@ def sample_video():
 class TestImageOperations:
     """Test image processing operations."""
 
+    @pytest.mark.parametrize("buffer_type", [bytes, bytearray])
+    def test_imdecode_owned_buffer(self, buffer_type):
+        """Decode buffers that remain valid while the GIL is released."""
+        image = np.arange(4 * 5 * 3, dtype=np.uint8).reshape((4, 5, 3))
+        encoded = io.BytesIO()
+        Image.fromarray(image).save(encoded, format="PNG")
+
+        decoded = tsr.imdecode_py(buffer_type(encoded.getvalue()), 1)
+
+        np.testing.assert_array_equal(decoded, image)
+
     def test_batch_crop_images(self, sample_images):
         """Test batch cropping with custom coordinates."""
         crop_boxes = [(10, 10, 50, 50), (20, 20, 40, 40), (5, 5, 60, 60)]
@@ -156,6 +169,31 @@ class TestZeroCopyBindings:
         with pytest.raises(ValueError, match="C-contiguous"):
             tsr.batch_resize_images_iterator([strided], [(16, 16)])
 
+    def test_zero_copy_resize_iterator_transfers_each_result(self):
+        """Iterator should yield owned results once and report remaining length."""
+        if not hasattr(tsr, "batch_resize_images_iterator"):
+            pytest.skip("OpenCV resize iterator bindings not available")
+
+        images = [
+            np.full((32, 48, 3), 17, dtype=np.uint8),
+            np.full((24, 40, 3), 231, dtype=np.uint8),
+        ]
+        iterator = tsr.batch_resize_images_iterator(images, [(12, 8), (10, 6)])
+
+        assert len(iterator) == 2
+        first = next(iterator)
+        assert first.shape == (8, 12, 3)
+        assert np.all(first == 17)
+        assert len(iterator) == 1
+
+        second = next(iterator)
+        assert second.shape == (6, 10, 3)
+        assert np.all(second == 231)
+        assert len(iterator) == 0
+
+        with pytest.raises(StopIteration):
+            next(iterator)
+
 
 class TestErrorHandling:
     """Test error handling and edge cases."""