Struct ChessDetector 

pub struct ChessDetector;

Zero-sized DenseDetector implementor for the ChESS kernel.

Wraps the canonical 16-sample ring response (crate::detect::chess::response::chess_response_u8) and the threshold + NMS + cluster-filter peak detector (crate::detect::detect_peaks_from_response). Subpixel refinement (center-of-mass, Förstner, saddle-point) is a separate detector-agnostic stage; see crate::detect::refine_corners_on_image.

Trait Implementations

impl Clone for ChessDetector

fn clone(&self) -> ChessDetector

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ChessDetector

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ChessDetector

fn default() -> ChessDetector

Returns the “default value” for a type.

impl DenseDetector for ChessDetector

type Params = ChessParams

Detector-specific tuning parameters.

type Buffers = ChessBuffers

Reusable scratch buffers. Allocated once via Default::default and reused across compute_response calls to avoid per-frame allocation.

type Response<'a> = &'a ResponseMap

Native response representation. May be owned (a borrow of an owned ResponseMap in Self::Buffers) or a transient view (RadonResponseView) over the same scratch. The borrow lifetime ties the response back to the buffers that produced it.

fn compute_response<'a>( &self, view: ImageView<'_>, params: &Self::Params, buffers: &'a mut Self::Buffers, ) -> Self::Response<'a>

Compute the dense response over view, writing into buffers and returning a borrowed handle.

fn detect_corners( &self, response: &Self::Response<'_>, params: &Self::Params, refine_border: i32, ) -> Vec<Corner>

Extract corner peaks from response. Positions are in the input-image frame (the same frame view was passed in at Self::compute_response).

fn compute_response_patch<'a>( &self, base: ImageView<'_>, roi: (i32, i32, i32, i32), params: &Self::Params, buffers: &'a mut Self::Buffers, ) -> Self::Response<'a>

Compute the dense response over the sub-rectangle [x0..x1) × [y0..y1) of base, where the ROI is given as the tuple (x0, y0, x1, y1). The returned response is sized to the ROI; any Corner positions produced from it by Self::detect_corners are patch-local (origin = ROI’s top-left), and the caller is responsible for shifting them back into base-image coordinates by adding (x0, y0).

fn roi_border(&self, params: &Self::Params) -> i32

Detector-specific safety border (in base-image pixels) the orchestrator must keep around each seed when carving an ROI. Typically the sum of the detector’s response-support radius (e.g. ChESS ring radius, Radon ray radius) and its NMS half-window — i.e. the minimum margin needed for Self::compute_response_patch + Self::detect_corners to return a non-trivial peak inside the ROI.

fn refine_peaks_on_image( &self, corners: Vec<Corner>, image: ImageView<'_>, response: &Self::Response<'_>, refiner: &mut dyn CornerRefiner, ) -> Vec<Corner>

Apply a detector-appropriate image-domain refinement step to the peaks produced by Self::detect_corners.

fn refines_on_image(&self) -> bool

Whether Self::refine_peaks_on_image actually consumes the orchestrator-supplied refiner. When false, the orchestrator must not include the refiner’s patch radius in the per-seed ROI margin — otherwise a no-op refiner choice would still shrink the valid seed area near the image border (a tunable silently coupling to an unused setting).

impl Copy for ChessDetector