Bugfixes and improvements

awxkee · Sep 25, 2024 · cc34e1b · cc34e1b
1 parent bbb45c2
commit cc34e1b
Show file tree

Hide file tree

Showing 16 changed files with 950 additions and 40 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -2,9 +2,9 @@ workspace = { members = ["app"] }
 
 [package]
 name = "fast_morphology"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
-description = "Fast morphology for images"
+description = "Fast morphological operations for images"
 readme = "README.md"
 keywords = ["morph", "morphology", "dilate", "erode"]
 license = "Apache-2.0 OR BSD-3-Clause"

diff --git a/README.md b/README.md
@@ -1,8 +1,14 @@
 # Fast morphology in pure Rust
 
 This crate provides fast 2D arbitrary shaped structuring element for planar, RGB and RGBA images.
+Library provides high performance erosion, dilation, closing and opening.
+
 In most cases performance when implemented fully in hardware faster than OpenCV.
 
+If you are not familiar read the [OpenCV doc](https://docs.opencv.org/4.x/d9/d61/tutorial_py_morphological_ops.html)
+
+### Example
+
 ```rust
 dilate_rgb(
     &src,

diff --git a/app/Cargo.toml b/app/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2021"
 image = "0.25.2"
 fast_morphology = {path = "../", features = ["image"]}
 imageproc = "0.25.0"
-opencv = {version = "0.93.0", features = ["imgproc", "clang-runtime"]}
+opencv = {version = "0.93.0", features = ["imgproc"]}
 
 [dev-dependencies]
 criterion = {version = "0.5.1", features = ["html_reports"]}

diff --git a/app/src/main.rs b/app/src/main.rs
@@ -2,7 +2,7 @@ use fast_morphology::{
     dilate, dilate_rgb, dilate_rgba, erode, erode_rgba, morphology_image, BorderMode, ImageSize,
     KernelShape, MorphExOp, MorphologyThreadingPolicy,
 };
-use image::{EncodableLayout, GenericImageView, ImageReader};
+use image::{DynamicImage, EncodableLayout, GenericImageView, ImageReader};
 use opencv::core::{
     Mat, MatTrait, MatTraitConstManual, Point, Scalar, BORDER_REPLICATE, CV_8U, CV_8UC3,
 };
@@ -66,7 +66,7 @@ fn gaussian_kernel(size: usize, sigma: f32) -> Vec<Vec<f32>> {
 }
 
 fn main() {
-    let radius_size = 10;
+    let radius_size = 35;
     let mut structuring_element = circle_se(radius_size);
 
     opencv::core::set_use_opencl(false).expect("Failed to disable OpenCL");
@@ -223,17 +223,23 @@ fn main() {
 
     println!("opencv exec time {:?}", exec_time.elapsed());
 
+    let exec_time = Instant::now();
+
     let new_image = morphology_image(
         img,
-        MorphExOp::Erode,
+        MorphExOp::Closing,
         &structuring_element,
         KernelShape::new(se_size, se_size),
         BorderMode::default(),
         MorphologyThreadingPolicy::default(),
     )
     .unwrap();
 
-    new_image.save("dilated.jpg").unwrap();
+    println!("morphology_image exec time {:?}", exec_time.elapsed());
+
+    let rollback_img = DynamicImage::ImageRgb8(new_image.to_rgb8());
+
+    rollback_img.save("dilated.jpg").unwrap();
 
     image::save_buffer(
         "converted.png",

diff --git a/src/arena_roi.rs b/src/arena_roi.rs
@@ -110,6 +110,62 @@ unsafe fn copy_row_sse(dst: &mut [u8], src: &[u8], start: usize, stride: usize)
     _cx
 }
 
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+#[target_feature(enable = "avx2")]
+unsafe fn copy_row_avx(dst: &mut [u8], src: &[u8], start: usize, stride: usize) -> usize {
+    let mut _cx = start;
+
+    while _cx + 128 < stride {
+        let offset_ptr = src.as_ptr().add(_cx);
+        let row0 = _mm256_loadu_si256(offset_ptr as *const __m256i);
+        let row1 = _mm256_loadu_si256(offset_ptr.add(32) as *const __m256i);
+        let row2 = _mm256_loadu_si256(offset_ptr.add(64) as *const __m256i);
+        let row3 = _mm256_loadu_si256(offset_ptr.add(96) as *const __m256i);
+        let dst_offset_ptr = dst.as_mut_ptr().add(_cx);
+        _mm256_storeu_si256(dst_offset_ptr as *mut __m256i, row0);
+        _mm256_storeu_si256(dst_offset_ptr.add(32) as *mut __m256i, row1);
+        _mm256_storeu_si256(dst_offset_ptr.add(64) as *mut __m256i, row2);
+        _mm256_storeu_si256(dst_offset_ptr.add(96) as *mut __m256i, row3);
+        _cx += 128;
+    }
+
+    while _cx + 64 < stride {
+        let offset_ptr = src.as_ptr().add(_cx);
+        let row0 = _mm256_loadu_si256(offset_ptr as *const __m256i);
+        let row1 = _mm256_loadu_si256(offset_ptr.add(32) as *const __m256i);
+        let dst_offset_ptr = dst.as_mut_ptr().add(_cx);
+        _mm256_storeu_si256(dst_offset_ptr as *mut __m256i, row0);
+        _mm256_storeu_si256(dst_offset_ptr.add(32) as *mut __m256i, row1);
+        _cx += 64;
+    }
+
+    while _cx + 32 < stride {
+        let offset_ptr = src.as_ptr().add(_cx);
+        let row0 = _mm256_loadu_si256(offset_ptr as *const __m256i);
+        let dst_offset_ptr = dst.as_mut_ptr().add(_cx);
+        _mm256_storeu_si256(dst_offset_ptr as *mut __m256i, row0);
+        _cx += 32;
+    }
+
+    while _cx + 16 < stride {
+        let offset_ptr = src.as_ptr().add(_cx);
+        let row0 = _mm_loadu_si128(offset_ptr as *const __m128i);
+        let dst_offset_ptr = dst.as_mut_ptr().add(_cx);
+        _mm_storeu_si128(dst_offset_ptr as *mut __m128i, row0);
+        _cx += 16;
+    }
+
+    while _cx + 8 < stride {
+        let offset_ptr = src.as_ptr().add(_cx);
+        let row0 = _mm_loadu_si64(offset_ptr);
+        let dst_offset_ptr = dst.as_mut_ptr().add(_cx);
+        std::ptr::copy_nonoverlapping(&row0 as *const _ as *const u8, dst_offset_ptr, 8);
+        _cx += 8;
+    }
+
+    _cx
+}
+
 /// Copies ROI from one image to another
 #[allow(clippy::type_complexity)]
 pub fn copy_roi<T>(arena: &mut [T], roi: &[T], arena_stride: usize, stride: usize, height: usize)
@@ -129,6 +185,9 @@ where
             if std::arch::is_x86_feature_detected!("sse4.1") {
                 _row_handle = Some(copy_row_sse);
             }
+            if std::arch::is_x86_feature_detected!("avx2") {
+                _row_handle = Some(copy_row_avx);
+            }
         }
         unsafe {
             for _ in 0..height {

diff --git a/src/filter.rs b/src/filter.rs
@@ -30,7 +30,7 @@ use crate::filter_op_declare::{Arena, MorthOpFilterFlat2DRow};
 use crate::flat_se::AnalyzedSe;
 use crate::op_type::MorphOp;
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-use crate::ops::avx::MorphOpFilterAvx2DRow;
+use crate::ops::avx::{MorphOpFilterAvx2DRow, MorphOpFilterAvx2DRowF32, MorphOpFilterAvx2DRowU16};
 #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
 use crate::ops::neon::{
     MorphOpFilterNeon2DRow, MorphOpFilterNeon2DRowF32, MorphOpFilterNeon2DRowU16,
@@ -136,6 +136,11 @@ impl Row2DFilter<f32> for f32 {
                                 MorphOpFilterSse2DRowF32::<{ MorphOp::Dilate as u8 }>::default(),
                             );
                         }
+                        if std::arch::is_x86_feature_detected!("avx2") {
+                            _result = Box::new(
+                                MorphOpFilterAvx2DRowF32::<{ MorphOp::Dilate as u8 }>::default(),
+                            );
+                        }
                     }
                     #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
                     {
@@ -155,6 +160,11 @@ impl Row2DFilter<f32> for f32 {
                                 MorphOpFilterSse2DRowF32::<{ MorphOp::Erode as u8 }>::default(),
                             );
                         }
+                        if std::arch::is_x86_feature_detected!("avx2") {
+                            _result = Box::new(
+                                MorphOpFilterAvx2DRowF32::<{ MorphOp::Erode as u8 }>::default(),
+                            );
+                        }
                     }
                     #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
                     {
@@ -183,6 +193,11 @@ impl Row2DFilter<u16> for u16 {
                                 MorphOpFilterSse2DRowU16::<{ MorphOp::Dilate as u8 }>::default(),
                             );
                         }
+                        if std::arch::is_x86_feature_detected!("avx2") {
+                            _result = Box::new(
+                                MorphOpFilterAvx2DRowU16::<{ MorphOp::Dilate as u8 }>::default(),
+                            );
+                        }
                     }
                     #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
                     {
@@ -202,6 +217,11 @@ impl Row2DFilter<u16> for u16 {
                                 MorphOpFilterSse2DRowU16::<{ MorphOp::Erode as u8 }>::default(),
                             );
                         }
+                        if std::arch::is_x86_feature_detected!("avx2") {
+                            _result = Box::new(
+                                MorphOpFilterAvx2DRowU16::<{ MorphOp::Erode as u8 }>::default(),
+                            );
+                        }
                     }
                     #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
                     {