Struct RadonDetector 

pub struct RadonDetector;

Zero-sized DenseDetector implementor for the whole-image Duda-Frese Radon kernel.

Wraps crate::radon_response_u8 (SAT-based dense response) and crate::detect_peaks_from_radon (threshold, NMS, 3-point Gaussian peak-fit on the working-resolution map). Output Corner positions are in the input-image frame: the Radon peak detector divides by image_upsample internally.

Trait Implementations

impl Clone for RadonDetector

fn clone(&self) -> RadonDetector

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RadonDetector

impl Debug for RadonDetector

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

Formats the value using the given formatter.

impl Default for RadonDetector

fn default() -> RadonDetector

Returns the “default value” for a type.

impl DenseDetector for RadonDetector

type Params = RadonDetectorParams

Detector-specific tuning parameters.

type Buffers = RadonBuffers

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

type Response<'a> = RadonResponseView<'a>

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).