corrmatch 0.1.0

CPU-first template matching with ZNCC/SSD and coarse-to-fine pyramid search
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

//! Correlation kernel implementations.

use crate::candidate::topk::Peak;
use crate::util::CorrMatchResult;
use crate::ImageView;

/// Scan configuration for kernel evaluations.
#[derive(Clone, Copy, Debug)]
pub struct ScanParams {
    /// Maximum number of peaks to retain.
    pub topk: usize,
    /// Minimum variance threshold for the image window (ZNCC only).
    pub min_var_i: f32,
    /// Minimum score threshold (discard below this value).
    pub min_score: f32,
}

/// Inclusive ROI bounds for scan operations (placement coordinates).
#[derive(Clone, Copy, Debug)]
pub(crate) struct ScanRoi {
    pub(crate) x0: usize,
    pub(crate) y0: usize,
    pub(crate) x1: usize,
    pub(crate) y1: usize,
}

impl ScanRoi {
    pub(crate) fn new(x0: usize, y0: usize, x1: usize, y1: usize) -> Self {
        Self { x0, y0, x1, y1 }
    }

    pub(crate) fn clamp_inclusive(self, max_x: usize, max_y: usize) -> Option<Self> {
        if self.x0 > max_x || self.y0 > max_y {
            return None;
        }
        let x1 = self.x1.min(max_x);
        let y1 = self.y1.min(max_y);
        if self.x0 > x1 || self.y0 > y1 {
            return None;
        }
        Some(Self {
            x0: self.x0,
            y0: self.y0,
            x1,
            y1,
        })
    }
}

/// Kernel trait for scoring and scan operations.
pub trait Kernel {
    type Plan;

    /// Computes the score at a single placement (top-left coordinates).
    fn score_at(
        image: ImageView<'_, u8>,
        plan: &Self::Plan,
        x: usize,
        y: usize,
        min_var_i: f32,
    ) -> f32;

    /// Scans the full valid placement range and returns top-K peaks.
    fn scan_full(
        image: ImageView<'_, u8>,
        plan: &Self::Plan,
        angle_idx: usize,
        params: ScanParams,
    ) -> CorrMatchResult<Vec<Peak>>;

    /// Scans an ROI of placement coordinates and returns top-K peaks.
    #[allow(clippy::too_many_arguments)]
    fn scan_roi(
        image: ImageView<'_, u8>,
        plan: &Self::Plan,
        angle_idx: usize,
        x0: usize,
        y0: usize,
        x1: usize,
        y1: usize,
        params: ScanParams,
    ) -> CorrMatchResult<Vec<Peak>>;
}

pub mod scalar;

#[cfg(feature = "simd")]
pub mod simd;

#[cfg(feature = "rayon")]
pub mod rayon;