Struct DocTrPostProcess 

pub struct DocTrPostProcess {
    pub scale: f32,
}

Post-processor for document transformation results.

The DocTrPostProcess struct handles the post-processing of document transformation model outputs, converting normalized coordinates back to pixel coordinates and applying various transformations.

Fields

scale: f32

Scale factor to convert normalized values back to pixel values.

Implementations

impl DocTrPostProcess

pub fn new(scale: f32) -> Self

Creates a new DocTrPostProcess instance.

Arguments

• scale - Scale factor for converting normalized coordinates to pixels.

Examples

use oar_ocr::processors::DocTrPostProcess;

let postprocessor = DocTrPostProcess::new(1.0);

pub fn scale(&self) -> f32

Gets the current scale factor.

Returns

The scale factor used for coordinate conversion.

pub fn set_scale(&mut self, scale: f32)

Sets a new scale factor.

Arguments

• scale - New scale factor.

pub fn denormalize_coordinates(&self, normalized_coords: &[f32]) -> Vec<f32>

Converts normalized coordinates to pixel coordinates.

Arguments

• normalized_coords - Vector of normalized coordinates (0.0 to 1.0).

Returns

• Vec<f32> - Vector of pixel coordinates.

Examples

use oar_ocr::processors::DocTrPostProcess;

let postprocessor = DocTrPostProcess::new(100.0);
let normalized = vec![0.1, 0.2, 0.8, 0.9];
let pixels = postprocessor.denormalize_coordinates(&normalized);
assert_eq!(pixels, vec![10.0, 20.0, 80.0, 90.0]);

pub fn normalize_coordinates(&self, pixel_coords: &[f32]) -> Vec<f32>

Converts pixel coordinates to normalized coordinates.

Arguments

• pixel_coords - Vector of pixel coordinates.

Returns

• Vec<f32> - Vector of normalized coordinates (0.0 to 1.0).

Examples

use oar_ocr::processors::DocTrPostProcess;

let postprocessor = DocTrPostProcess::new(100.0);
let pixels = vec![10.0, 20.0, 80.0, 90.0];
let normalized = postprocessor.normalize_coordinates(&pixels);
assert_eq!(normalized, vec![0.1, 0.2, 0.8, 0.9]);

pub fn process_bbox(&self, bbox: &[f32; 4]) -> [f32; 4]

Processes a bounding box from normalized to pixel coordinates.

Arguments

• bbox - Bounding box as [x1, y1, x2, y2] in normalized coordinates.

Returns

• [f32; 4] - Bounding box in pixel coordinates.

Examples

use oar_ocr::processors::DocTrPostProcess;

let postprocessor = DocTrPostProcess::new(100.0);
let normalized_bbox = [0.1, 0.2, 0.8, 0.9];
let pixel_bbox = postprocessor.process_bbox(&normalized_bbox);
assert_eq!(pixel_bbox, [10.0, 20.0, 80.0, 90.0]);

pub fn process_bboxes(&self, bboxes: &[[f32; 4]]) -> Vec<[f32; 4]>

Processes multiple bounding boxes.

Arguments

• bboxes - Vector of bounding boxes in normalized coordinates.

Returns

• Vec<[f32; 4]> - Vector of bounding boxes in pixel coordinates.

pub fn process_polygon(&self, polygon: &[[f32; 2]]) -> Vec<[f32; 2]>

Processes a polygon from normalized to pixel coordinates.

Arguments

• polygon - Vector of points as [x, y] pairs in normalized coordinates.

Returns

• Vec<[f32; 2]> - Vector of points in pixel coordinates.

Examples

use oar_ocr::processors::DocTrPostProcess;

let postprocessor = DocTrPostProcess::new(100.0);
let normalized_polygon = vec![[0.1, 0.2], [0.8, 0.2], [0.8, 0.9], [0.1, 0.9]];
let pixel_polygon = postprocessor.process_polygon(&normalized_polygon);
assert_eq!(pixel_polygon[0], [10.0, 20.0]);

pub fn clamp_coordinates( &self, coords: &[f32], min_val: f32, max_val: f32, ) -> Vec<f32>

Clamps coordinates to valid ranges.

Arguments

• coords - Vector of coordinates to clamp.
• min_val - Minimum allowed value.
• max_val - Maximum allowed value.

Returns

• Vec<f32> - Vector of clamped coordinates.

pub fn validate_coordinates( &self, coords: &[f32], min_val: f32, max_val: f32, ) -> bool

Validates that coordinates are within expected ranges.

Arguments

• coords - Vector of coordinates to validate.
• min_val - Minimum expected value.
• max_val - Maximum expected value.

Returns

• true - If all coordinates are within range.
• false - If any coordinate is out of range.

pub fn round_coordinates(&self, coords: &[f32]) -> Vec<i32>

Rounds coordinates to integer values.

Arguments

• coords - Vector of coordinates to round.

Returns

• Vec<i32> - Vector of rounded integer coordinates.

pub fn process_transformation_matrix(&self, matrix: &[f32; 9]) -> [f32; 9]

Processes transformation matrix values.

Arguments

• matrix - 3x3 transformation matrix as a flat vector.

Returns

• Vec<f32> - Processed transformation matrix.

pub fn apply_inverse_transform( &self, coords: &[[f32; 2]], matrix: &[f32; 9], ) -> Result<Vec<[f32; 2]>, String>

Applies inverse transformation to coordinates.

Arguments

• coords - Vector of coordinates to transform.
• matrix - 3x3 transformation matrix.

Returns

• Result<Vec<[f32; 2]>, String> - Transformed coordinates or error.

pub fn apply_batch(&self, output: &Tensor4D) -> Result<Vec<RgbImage>, String>

Applies batch processing to tensor output to produce rectified images.

Arguments

• output - 4D tensor output from the model [batch, channels, height, width].

Returns

• Result<Vec<image::RgbImage>, String> - Vector of rectified images or error.

Trait Implementations

impl Debug for DocTrPostProcess

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

Formats the value using the given formatter.

impl Default for DocTrPostProcess

fn default() -> Self

Creates a default DocTrPostProcess with scale factor 1.0.

impl FromStr for DocTrPostProcess

fn from_str(s: &str) -> Result<Self, Self::Err>

Creates a DocTrPostProcess from a string representation of the scale factor.

Arguments

• s - String representation of the scale factor.

Returns

• Ok(DocTrPostProcess) - If the string can be parsed as a float.
• Err(ParseFloatError) - If the string cannot be parsed.

type Err = ParseFloatError

The associated error which can be returned from parsing.