solvr 0.2.0

Advanced computing library for real-world problem solving - optimization, differential equations, interpolation, statistics, and more
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

//! Edge detection algorithm traits.
//!
//! Provides algorithms for detecting edges in N-dimensional arrays using
//! derivative-based filters (Sobel, Prewitt, Laplace).
use crate::DType;

use numr::error::Result;
use numr::runtime::Runtime;
use numr::tensor::Tensor;

/// Algorithmic contract for edge detection operations.
///
/// All backends implementing edge detection MUST implement this trait using
/// the EXACT SAME ALGORITHMS to ensure numerical parity.
pub trait EdgeDetectionAlgorithms<R: Runtime<DType = DType>> {
    /// Apply Sobel filter along the given axis.
    ///
    /// Computes an approximation of the gradient along one axis using a Sobel
    /// operator. For 2D arrays, this is a 3x3 convolution kernel.
    /// For N-D, applies separable Sobel along the specified axis.
    ///
    /// # Arguments
    ///
    /// * `input` - Input tensor (at least 2D)
    /// * `axis` - Axis along which to compute the gradient
    ///
    /// # Returns
    ///
    /// Gradient tensor with same shape as input.
    fn sobel(&self, input: &Tensor<R>, axis: usize) -> Result<Tensor<R>>;

    /// Apply Prewitt filter along the given axis.
    ///
    /// Similar to Sobel but uses equal weighting instead of Gaussian-weighted
    /// smoothing in the orthogonal direction.
    ///
    /// # Arguments
    ///
    /// * `input` - Input tensor (at least 2D)
    /// * `axis` - Axis along which to compute the gradient
    fn prewitt(&self, input: &Tensor<R>, axis: usize) -> Result<Tensor<R>>;

    /// Apply Laplacian filter.
    ///
    /// Computes the Laplacian (sum of second derivatives) of the input using
    /// second-difference operators along each axis.
    ///
    /// # Arguments
    ///
    /// * `input` - Input tensor (any dimensionality >= 1)
    fn laplace(&self, input: &Tensor<R>) -> Result<Tensor<R>>;

    /// Apply Gaussian then Laplacian (Laplacian of Gaussian / LoG).
    ///
    /// First smooths with a Gaussian filter, then applies the Laplacian.
    /// Useful for blob detection.
    ///
    /// # Arguments
    ///
    /// * `input` - Input tensor
    /// * `sigma` - Standard deviation for Gaussian smoothing (applied to all axes)
    fn gaussian_laplace(&self, input: &Tensor<R>, sigma: f64) -> Result<Tensor<R>>;

    /// Compute the gradient magnitude after Gaussian smoothing.
    ///
    /// Smooths input with Gaussian, computes gradient along each axis,
    /// returns sqrt(sum of squared gradients).
    ///
    /// # Arguments
    ///
    /// * `input` - Input tensor
    /// * `sigma` - Standard deviation for Gaussian smoothing (applied to all axes)
    fn gaussian_gradient_magnitude(&self, input: &Tensor<R>, sigma: f64) -> Result<Tensor<R>>;
}