Struct ConversionOptions 

pub struct ConversionOptions {
    pub columns: Option<u32>,
    pub font_ratio: f32,
    pub luminance: u8,
    pub ascii_chars: String,
    pub output_mode: OutputMode,
}

Options for ASCII conversion

Fields

columns: Option<u32>

Target width in characters (columns)

font_ratio: f32

Font aspect ratio (width/height of character)

luminance: u8

Luminance threshold (0-255) for transparency

ascii_chars: String

ASCII character set to use (from darkest to lightest)

output_mode: OutputMode

What output files to generate

Implementations

impl ConversionOptions

pub fn with_columns(self, columns: u32) -> Self

Create options with a specific width

Examples found in repository

examples/simple_image.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a converter with default configuration
    let converter = AsciiConverter::new();

    // Configure conversion options
    let options = ConversionOptions::default()
        .with_columns(100)
        .with_font_ratio(0.5)
        .with_luminance(20);

    // Example 1: Convert image to ASCII file
    let input = Path::new("resources/source.png");
    let output = Path::new("example_output.txt");

    if input.exists() {
        println!("Converting {} to ASCII art...", input.display());
        converter.convert_image(input, output, &options)?;
        println!("✓ ASCII art saved to {}", output.display());
    } else {
        println!(
            "Note: {} not found, skipping file conversion example",
            input.display()
        );
    }

    // Example 2: Convert image to string (no file)
    if input.exists() {
        println!("\nConverting image to string...");
        let ascii_string = converter.image_to_string(input, &options)?;
        println!(
            "✓ Generated ASCII string ({} characters)",
            ascii_string.len()
        );
        println!("\nFirst 500 characters:");
        println!("{}", &ascii_string[..500.min(ascii_string.len())]);
    }

    // Example 3: Using presets
    if input.exists() {
        println!("\n\nUsing 'small' preset...");
        let small_options = converter.options_from_preset("small")?;
        let output_small = Path::new("example_output_small.txt");
        converter.convert_image(input, output_small, &small_options)?;
        println!("✓ Small ASCII art saved to {}", output_small.display());
    }

    Ok(())
}

pub fn with_font_ratio(self, font_ratio: f32) -> Self

Create options with a specific font ratio

Examples found in repository

examples/simple_video.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a converter
    let converter = AsciiConverter::new();

    // Configure video options
    let video_opts = VideoOptions {
        fps: 10,
        start: Some("0".to_string()),
        end: Some("2".to_string()), // Extract first 2 seconds
        columns: 200,
        extract_audio: false,
        preprocess_filter: None,
    };

    // Configure conversion options
    let conv_opts = ConversionOptions::default()
        .with_font_ratio(0.5)
        .with_luminance(20);

    // Convert video
    let input = Path::new("tests/video/input/test.mkv");
    let output_dir = Path::new("example_video_output");

    if input.exists() {
        println!("Converting video to ASCII frames...");
        println!("Input: {}", input.display());
        println!("Output: {}", output_dir.display());
        println!("Settings: {}fps, {}s duration", video_opts.fps, 2);

        converter.convert_video(
            input,
            output_dir,
            &video_opts,
            &conv_opts,
            false, // Don't keep intermediate PNG files
        )?;

        println!("✓ Video conversion complete!");
        println!("ASCII frames saved to {}", output_dir.display());
    } else {
        println!("Note: {} not found.", input.display());
        println!("To use this example, provide a video file at that path.");
    }

    Ok(())
}

examples/simple_image.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a converter with default configuration
    let converter = AsciiConverter::new();

    // Configure conversion options
    let options = ConversionOptions::default()
        .with_columns(100)
        .with_font_ratio(0.5)
        .with_luminance(20);

    // Example 1: Convert image to ASCII file
    let input = Path::new("resources/source.png");
    let output = Path::new("example_output.txt");

    if input.exists() {
        println!("Converting {} to ASCII art...", input.display());
        converter.convert_image(input, output, &options)?;
        println!("✓ ASCII art saved to {}", output.display());
    } else {
        println!(
            "Note: {} not found, skipping file conversion example",
            input.display()
        );
    }

    // Example 2: Convert image to string (no file)
    if input.exists() {
        println!("\nConverting image to string...");
        let ascii_string = converter.image_to_string(input, &options)?;
        println!(
            "✓ Generated ASCII string ({} characters)",
            ascii_string.len()
        );
        println!("\nFirst 500 characters:");
        println!("{}", &ascii_string[..500.min(ascii_string.len())]);
    }

    // Example 3: Using presets
    if input.exists() {
        println!("\n\nUsing 'small' preset...");
        let small_options = converter.options_from_preset("small")?;
        let output_small = Path::new("example_output_small.txt");
        converter.convert_image(input, output_small, &small_options)?;
        println!("✓ Small ASCII art saved to {}", output_small.display());
    }

    Ok(())
}

pub fn with_luminance(self, luminance: u8) -> Self

Create options with a specific luminance threshold

Examples found in repository

examples/simple_video.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a converter
    let converter = AsciiConverter::new();

    // Configure video options
    let video_opts = VideoOptions {
        fps: 10,
        start: Some("0".to_string()),
        end: Some("2".to_string()), // Extract first 2 seconds
        columns: 200,
        extract_audio: false,
        preprocess_filter: None,
    };

    // Configure conversion options
    let conv_opts = ConversionOptions::default()
        .with_font_ratio(0.5)
        .with_luminance(20);

    // Convert video
    let input = Path::new("tests/video/input/test.mkv");
    let output_dir = Path::new("example_video_output");

    if input.exists() {
        println!("Converting video to ASCII frames...");
        println!("Input: {}", input.display());
        println!("Output: {}", output_dir.display());
        println!("Settings: {}fps, {}s duration", video_opts.fps, 2);

        converter.convert_video(
            input,
            output_dir,
            &video_opts,
            &conv_opts,
            false, // Don't keep intermediate PNG files
        )?;

        println!("✓ Video conversion complete!");
        println!("ASCII frames saved to {}", output_dir.display());
    } else {
        println!("Note: {} not found.", input.display());
        println!("To use this example, provide a video file at that path.");
    }

    Ok(())
}

examples/simple_image.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a converter with default configuration
    let converter = AsciiConverter::new();

    // Configure conversion options
    let options = ConversionOptions::default()
        .with_columns(100)
        .with_font_ratio(0.5)
        .with_luminance(20);

    // Example 1: Convert image to ASCII file
    let input = Path::new("resources/source.png");
    let output = Path::new("example_output.txt");

    if input.exists() {
        println!("Converting {} to ASCII art...", input.display());
        converter.convert_image(input, output, &options)?;
        println!("✓ ASCII art saved to {}", output.display());
    } else {
        println!(
            "Note: {} not found, skipping file conversion example",
            input.display()
        );
    }

    // Example 2: Convert image to string (no file)
    if input.exists() {
        println!("\nConverting image to string...");
        let ascii_string = converter.image_to_string(input, &options)?;
        println!(
            "✓ Generated ASCII string ({} characters)",
            ascii_string.len()
        );
        println!("\nFirst 500 characters:");
        println!("{}", &ascii_string[..500.min(ascii_string.len())]);
    }

    // Example 3: Using presets
    if input.exists() {
        println!("\n\nUsing 'small' preset...");
        let small_options = converter.options_from_preset("small")?;
        let output_small = Path::new("example_output_small.txt");
        converter.convert_image(input, output_small, &small_options)?;
        println!("✓ Small ASCII art saved to {}", output_small.display());
    }

    Ok(())
}

pub fn with_ascii_chars(self, ascii_chars: String) -> Self

Create options with custom ASCII character set

pub fn with_output_mode(self, mode: OutputMode) -> Self

Set the output mode

pub fn from_preset(preset: &Preset, ascii_chars: String) -> Self

Create options from a preset

Trait Implementations

impl Clone for ConversionOptions

fn clone(&self) -> ConversionOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConversionOptions

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

Formats the value using the given formatter.

impl Default for ConversionOptions

fn default() -> Self

Returns the “default value” for a type.