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 raw(&self) -> GrayImage

Get the raw grayscale matte.

pub fn into_image(self) -> GrayImage

Consume the handle and return the raw grayscale matte.

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

Save the raw grayscale matte to the specified path.

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 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 processed(self) -> OutlineResult<MaskHandle>

Process the raw matte with the accumulated operations and default options.

pub fn processed_with( self, options: &MaskProcessingOptions, ) -> OutlineResult<MaskHandle>

Process the raw matte with the accumulated operations and custom options.

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

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

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

where V: MaskVectorizer,

Trace the raw matte using the specified vectorizer and options.

Trait Implementations

impl Clone for MatteHandle

fn clone(&self) -> MatteHandle

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.