SciRS2 Vision

[]

Computer vision module for SciRS2, providing comprehensive functionality for image processing, feature detection, segmentation, and color transformations.

Production Status (0.1.0-beta.2)

✅ PRODUCTION READY - Final alpha release with complete functionality:

• 217 unit tests passing with zero warnings
• Comprehensive API covering all major computer vision operations
• Working examples demonstrating real-world usage
• Performance optimized with parallel processing support
• SciPy-compatible design for familiar scientific computing workflows

Overview

The scirs2-vision module provides a complete computer vision library for scientific computing applications. This production-ready module includes implementations of state-of-the-art algorithms for feature detection, image processing, segmentation, and geometric transformations.

Comprehensive Feature Set

🎯 Feature Detection and Description

• Edge Detection: Sobel, Canny, Prewitt, Laplacian operators with sub-pixel accuracy
• Corner Detection: Harris corners, Shi-Tomasi (Good Features to Track), FAST corners
• Blob Detection: DoG (Difference of Gaussians), LoG (Laplacian of Gaussian), MSER regions
• Feature Descriptors: ORB descriptors, BRIEF descriptors, HOG (Histogram of Oriented Gradients)
• Feature Matching: RANSAC-based robust matching, homography estimation
• Geometric Detection: Hough Circle Transform, Hough Line Transform
• Advanced Features: Sub-pixel corner refinement, non-maximum suppression

🖼️ Image Enhancement and Preprocessing

• Noise Reduction: Non-local means denoising, bilateral filtering, guided filtering
• Enhancement: Histogram equalization, CLAHE, gamma correction (auto/adaptive)
• Filtering: Gaussian blur, median filtering, unsharp masking
• Contrast Enhancement: Brightness/contrast normalization, Retinex algorithms
• Quality Analysis: Image quality assessment metrics

🎨 Color and Texture Analysis

• Color Space Conversions: RGB ↔ HSV, RGB ↔ LAB with proper gamma correction
• Color Processing: Channel splitting/merging, weighted grayscale conversion
• Color Quantization: K-means, median cut, octree quantization algorithms
• Texture Analysis: Gray-level co-occurrence matrix (GLCM), Local binary patterns (LBP)
• Advanced Texture: Gabor filters, Tamura texture features

✂️ Image Segmentation

• Thresholding: Binary, Otsu's automatic, adaptive (mean/Gaussian) methods
• Region Segmentation: SLIC superpixels, watershed algorithm, region growing
• Advanced Segmentation: Mean shift clustering, connected component analysis
• Interactive Segmentation: Multi-level thresholding, texture-based segmentation

🔄 Geometric Transformations

• Affine Transformations: Translation, rotation, scaling, shearing with multiple interpolation methods
• Perspective Transformations: Homography-based warping with robust estimation
• Non-rigid Transformations: Thin-plate spline deformation, elastic transformations
• Interpolation: Bilinear, bicubic, Lanczos, edge-preserving interpolation methods
• Image Registration: Feature-based and intensity-based alignment

🧮 Morphological Operations

• Basic Operations: Erosion, dilation with customizable structuring elements
• Advanced Operations: Opening, closing, morphological gradient
• Specialized Operations: Top-hat, black-hat transforms for feature enhancement

Examples

Feature Detection

use scirs2_vision::{
    sobel_edges, harris_corners, image_to_array, array_to_image
};
use scirs2_vision::{prewitt_edges, laplacian_edges, laplacian_of_gaussian};
use scirs2_vision::feature::{canny_simple, fast_corners, shi_tomasi_corners};
use scirs2_vision::gaussian_blur;

// Load an image and convert to array
let img = image::open("input.jpg")?;
let img_array = image_to_array(&img)?;

// Preprocess with Gaussian blur
let blurred = gaussian_blur(&img, 1.0)?;

// Detect edges using Sobel (available in public API)
let sobel = sobel_edges(&img, 0.1)?;

// Detect edges using Canny
let canny_result = canny_simple(&img_array, 1.0)?;

// Detect edges using Prewitt (available in public API)
let prewitt_result = prewitt_edges(&img, 0.1)?;

// Detect edges using Laplacian (available in public API)
let laplacian_result = laplacian_edges(&img, 0.05, true)?;

// Detect edges using Laplacian of Gaussian (available in public API)
let log_result = laplacian_of_gaussian(&img, 1.0, 0.05)?;

// Detect corners using Harris (available in public API)
let corners = harris_corners(&img, 3, 0.04, 0.01)?;

// Detect corners using FAST
let fast_corners = fast_corners(&img_array, 9, 0.05)?;

// Detect corners using Shi-Tomasi
let shi_tomasi = shi_tomasi_corners(&img_array, 100, 0.01, 10.0)?;

Color Transformations

use scirs2_vision::{rgb_to_hsv, rgb_to_lab, split_channels, image_to_array};

// Load an image and convert to array
let img = image::open("input.jpg")?;
let img_array = image_to_array(&img)?;

// Convert to HSV
let hsv = rgb_to_hsv(&img_array)?;

// Convert to LAB
let lab = rgb_to_lab(&img_array)?;

// Split into channels
let (r_channel, g_channel, b_channel) = split_channels(&img_array)?;

Image Segmentation

use scirs2_vision::{
    threshold_binary, otsu_threshold, adaptive_threshold, connected_components,
    image_to_array, AdaptiveMethod,
};

// Load an image and convert to array
let img = image::open("input.jpg")?;
let img_array = image_to_array(&img)?;

// Apply Otsu's thresholding
let (binary, threshold) = otsu_threshold(&img_array)?;

// Apply adaptive thresholding
let adaptive = adaptive_threshold(&img_array, 11, 0.02, AdaptiveMethod::Gaussian)?;

// Perform connected component labeling
let (labeled, num_components) = connected_components(&binary)?;

Morphological Operations

use scirs2_vision::{
    erode, dilate, opening, closing, morphological_gradient, 
    image_to_array, StructuringElement,
};

// Load an image and convert to array
let img = image::open("input.jpg")?;
let img_array = image_to_array(&img)?;

// Define a structuring element
let se = StructuringElement::Ellipse(5, 5);

// Apply opening (erosion followed by dilation)
let opened = opening(&img_array, se)?;

// Calculate morphological gradient
let gradient = morphological_gradient(&img_array, se)?;

Blob and Region Detection

use scirs2_vision::{log_blob_detect, image_to_array, LogBlobConfig};
use scirs2_vision::feature::{
    dog_detect, DogConfig,
    mser_detect, MserConfig,
    hough_circles, HoughCircleConfig
};

// Load an image and convert to array
let img = image::open("input.jpg")?;
let img_array = image_to_array(&img)?;

// Detect blobs using Difference of Gaussians
let dog_config = DogConfig::default();
let dog_blobs = dog_detect(&img_array, dog_config)?;

// Detect blobs using Laplacian of Gaussian (available in public API)
let log_config = LogBlobConfig::default();
let log_blobs = log_blob_detect(&img_array, log_config)?;

// Detect stable regions using MSER
let mser_config = MserConfig::default();
let mser_regions = mser_detect(&img_array, mser_config)?;

// Detect circles using Hough Transform
let hough_config = HoughCircleConfig::default();
let circles = hough_circles(&img_array, hough_config)?;

Installation

Add scirs2-vision to your dependencies in Cargo.toml:

[dependencies]
scirs2-vision = "0.1.0-beta.2"

To enable optimizations through the core module, add feature flags:

[dependencies]
scirs2-vision = { version = "0.1.0-beta.2", features = ["parallel"] }

Documentation

For detailed documentation, examples, and API reference, please refer to the API documentation and the examples directory.

Performance and Production Characteristics

🚀 High Performance

• Parallel Processing: Multi-threaded implementations using Rayon for CPU-intensive operations
• Memory Efficient: Optimized algorithms that minimize memory allocation and copying
• SIMD Ready: Foundation for SIMD acceleration in performance-critical paths
• Benchmarked: Algorithms tested against reference implementations for accuracy and speed

🔧 Production Features

• Robust Error Handling: Comprehensive error types with detailed diagnostic information
• Parameter Validation: Input validation for all algorithms with clear error messages
• Thread Safety: All algorithms are thread-safe and can be used in concurrent applications
• SciPy Compatibility: API design follows SciPy conventions for familiar usage patterns

📊 Quality Assurance

• 217 Unit Tests: Comprehensive test coverage for all implemented functionality
• Zero Warnings: Clean code following Rust best practices and Clippy recommendations
• Working Examples: All documentation examples are tested and verified to work
• Continuous Integration: Automated testing ensures reliability across different environments

Testing

The module includes a comprehensive test suite to ensure functionality works as expected:

# Run all tests (217 tests passing)
cargo test

# Run tests with output to see detailed results
cargo test -- --nocapture

# Run specific test module
cargo test preprocessing

# Run specific test
cargo test test_grayscale_conversion

Dependencies

• scirs2-core: Core functionality for SciRS2
• scirs2-ndimage: N-dimensional image processing
• ndarray: N-dimensional array manipulation
• image: Basic image processing in Rust
• num-traits and num-complex: Numerical type traits

License

This project is dual-licensed under:

• MIT License
• Apache License Version 2.0

You can choose to use either license. See the LICENSE file for details.

Production Readiness

This 0.1.0-beta.2 release represents a mature, production-ready computer vision library suitable for:

🏭 Production Applications

• Scientific Computing: Research applications requiring reliable computer vision algorithms
• Image Processing Pipelines: Batch processing of scientific imagery with parallel processing
• Computer Vision Research: Foundation for building advanced vision applications
• Educational Use: Teaching computer vision concepts with real, working implementations

🔬 Validated Algorithms

All implemented algorithms have been validated against reference implementations and tested with:

• Numerical Accuracy: Results compared against established libraries like OpenCV and SciPy
• Edge Cases: Comprehensive testing of boundary conditions and error scenarios
• Performance: Benchmarked for reasonable performance characteristics
• Memory Safety: Rust's guarantees ensure memory safety without runtime overhead

🎯 API Stability

The public API is considered stable for the alpha release series, meaning:

• Consistent Interface: Function signatures and behavior will remain consistent
• Backward Compatibility: New features will be added without breaking existing code
• Clear Documentation: All public functions are documented with examples
• Semantic Versioning: Version numbers follow semantic versioning principles

Future Development

Post-alpha development will focus on:

• Performance Optimization: SIMD acceleration and GPU support
• Advanced Algorithms: Deep learning integration and advanced computer vision techniques
• Domain-Specific Features: Medical imaging, remote sensing, and specialized applications
• Extended Format Support: Additional image formats and metadata handling

Contributing

Contributions are welcome! Please see the project's CONTRIBUTING.md file for guidelines.

For the post-alpha roadmap, we're particularly interested in:

• Performance optimizations and benchmarking
• Additional computer vision algorithms
• Domain-specific applications and use cases
• Integration with machine learning frameworks