Struct MatteHandle 

pub struct MatteHandle { /* private fields */ }

Builder for chaining mask processing operations on the raw matte.

The raw matte is the soft, grayscale alpha prediction from the model.

Example

use outline::Outline;

let outline = Outline::new("model.onnx");
let session = outline.for_image("input.jpg")?;

// Chain operations and execute them
let mask = session.matte()
    .blur_with(6.0)          // Smooth edges
    .threshold_with(120)     // Convert to binary
    .dilate_with(5.0)        // Expand slightly
    .processed()?;           // Execute operations

mask.save("mask.png")?;

Implementations

impl MatteHandle

pub fn to_raw_matte(&self) -> GrayImage

Clone and return the raw grayscale matte.

pub fn as_raw_matte(&self) -> &GrayImage

Get a reference to the raw grayscale matte.

pub fn dimensions(&self) -> (u32, u32)

Return the current matte canvas dimensions.

pub fn raw(&self) -> GrayImage

👎Deprecated:

use to_raw_matte()

Get the raw grayscale matte.

pub fn into_image(self) -> GrayImage

Consume the handle and return the current matte as a grayscale image.

pub fn save(&self, path: impl AsRef<Path>) -> OutlineResult<()>

Save the current matte to the specified path.

pub fn bounding_box(&self) -> Option<BoundingBox>

Compute the bounding box of the current matte using a non-zero threshold.

pub fn bounding_box_with(&self, threshold: u8) -> Option<BoundingBox>

Compute the bounding box of the current matte at or above threshold.

pub fn blur(self) -> Self

Add a blur operation using the default sigma.

pub fn blur_with(self, sigma: f32) -> Self

Add a blur operation with a custom sigma.

pub fn threshold(self) -> Self

Add a threshold operation using the default mask threshold.

pub fn threshold_with(self, value: u8) -> Self

Add a threshold operation with a custom value.

pub fn dilate(self) -> Self

Add a dilation operation using the default radius.

Note: Dilation typically works best on binary masks. Consider calling threshold before dilate if working with a soft matte.

pub fn dilate_with(self, radius: f32) -> Self

Add a dilation operation with a custom radius.

Note: Dilation typically works best on binary masks. Consider calling threshold before dilate if working with a soft matte.

pub fn erode(self) -> Self

Add an erosion operation using the default radius.

Note: Erosion typically works best on binary masks. Consider calling threshold before erode if working with a soft matte.

pub fn erode_with(self, radius: f32) -> Self

Add an erosion operation with a custom radius.

Note: Erosion typically works best on binary masks. Consider calling threshold before erode if working with a soft matte.

pub fn erode_with_border_mode( self, radius: f32, border_mode: ErosionBorderMode, ) -> Self

Add an erosion operation with a custom radius and boundary behavior.

Note: Erosion typically works best on binary masks. Consider calling threshold before erode if working with a soft matte.

pub fn fill_holes(self) -> Self

Add a hole-filling operation to the processing pipeline.

Note: Hole-filling typically works best on binary masks. Consider calling threshold before fill_holes if working with a soft matte.

pub fn fill_holes_with(self, threshold: u8) -> Self

Add a hole-filling operation with a custom threshold.

Note: Hole-filling typically works best on binary masks. Consider calling threshold before fill_holes if working with a soft matte.

pub fn keep_largest_component(self) -> Self

Keep only the largest connected foreground component.

Note: Component filtering typically works best on binary masks. Consider calling threshold before keep_largest_component if working with a soft matte.

pub fn keep_n_largest_components(self, count: usize) -> Self

Keep the largest count connected foreground components.

Note: Component filtering typically works best on binary masks. Consider calling threshold before keep_n_largest_components if working with a soft matte.

pub fn drop_components_below_area(self, min_area: f32) -> Self

Drop connected foreground components below min_area pixels.

Note: Component filtering typically works best on binary masks. Consider calling threshold before drop_components_below_area if working with a soft matte.

Panics

Panics if min_area is negative or NaN.

pub fn processed(self) -> OutlineResult<MaskHandle>

Process the raw matte with the accumulated operations.

pub fn processed_with( self, pipeline: &MaskPipeline, ) -> OutlineResult<MaskHandle>

Process the raw matte with the accumulated operations and a custom pipeline.

pub fn foreground(&self) -> OutlineResult<ForegroundHandle>

Compose the RGBA foreground image from the RGB image and the current matte.

pub fn colorize(&self, color: impl Into<MaskColor>) -> RgbaImage

Colorize the current matte into a flat-color RGBA image.

pub fn trace<V>( &self, vectorizer: &V, options: &V::Options, ) -> OutlineResult<V::Output>

where V: MaskVectorizer,

Trace the current matte using the specified vectorizer and options.

pub fn pad(self, padding: impl Into<Padding>) -> Self

Expand the matte canvas by the given padding while keeping content at the same offset.

Any pending matte operations are applied before padding so method call order is preserved. The underlying RGB canvas is padded with black to keep foreground aligned with the matte.

pub fn crop(self, bounds: BoundingBox) -> Option<Self>

Crop the matte and source RGB image to bounds.

Returns None when bounds is empty or outside the current matte canvas.

pub fn crop_to_content(self) -> Option<Self>

Crop the matte and source RGB image to the smallest non-zero content box.

Returns None when the current matte has no non-zero pixels.

pub fn crop_to_content_with(self, threshold: u8) -> Option<Self>

Crop the matte and source RGB image to the smallest content box at or above threshold.

Returns None when the current matte has no pixels at or above threshold.

Trait Implementations

impl Clone for MatteHandle

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MatteHandle

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

Formats the value using the given formatter.