dotmax 0.1.7

High-performance terminal braille rendering for images, animations, and graphics
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Demonstrates line drawing primitives using Bresenham's algorithm.
//!
//! This example showcases various line drawing capabilities:
//! - Horizontal and vertical lines
//! - Diagonal lines (45° angles)
//! - Arbitrary angle lines
//! - Thick lines (varying thickness)
//! - Lines clipped at grid boundaries
//!
//! Run with: `cargo run --example lines_demo`

use dotmax::{
    primitives::{draw_line, draw_line_thick},
    BrailleGrid, TerminalRenderer,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize tracing for debug output (optional)
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .init();

    println!("=== Line Drawing Demo ===\n");

    // Create a braille grid (80×24 cells = 160×96 dots)
    let mut grid = BrailleGrid::new(80, 24)?;
    let mut renderer = TerminalRenderer::new()?;

    // Demo 1: Horizontal line across middle
    println!("Demo 1: Horizontal line across middle");
    draw_line(&mut grid, 10, 48, 150, 48)?;
    renderer.render(&grid)?;
    std::thread::sleep(std::time::Duration::from_secs(2));

    // Clear for next demo
    grid.clear();

    // Demo 2: Vertical line down center
    println!("\nDemo 2: Vertical line down center");
    draw_line(&mut grid, 80, 10, 80, 86)?;
    renderer.render(&grid)?;
    std::thread::sleep(std::time::Duration::from_secs(2));

    // Clear for next demo
    grid.clear();

    // Demo 3: X pattern (two diagonals)
    println!("\nDemo 3: X pattern with diagonal lines");
    draw_line(&mut grid, 20, 10, 140, 86)?; // Top-left to bottom-right
    draw_line(&mut grid, 140, 10, 20, 86)?; // Top-right to bottom-left
    renderer.render(&grid)?;
    std::thread::sleep(std::time::Duration::from_secs(2));

    // Clear for next demo
    grid.clear();

    // Demo 4: Star pattern (arbitrary angles)
    println!("\nDemo 4: Star pattern with arbitrary angles");
    let center_x = 80;
    let center_y = 48;
    let radius = 40;

    // Draw 8-pointed star
    for i in 0..8 {
        let angle = i as f64 * std::f64::consts::PI / 4.0;
        let end_x = center_x + (angle.cos() * radius as f64) as i32;
        let end_y = center_y + (angle.sin() * radius as f64) as i32;
        draw_line(&mut grid, center_x, center_y, end_x, end_y)?;
    }
    renderer.render(&grid)?;
    std::thread::sleep(std::time::Duration::from_secs(2));

    // Clear for next demo
    grid.clear();

    // Demo 5: Thick lines (varying thickness)
    println!("\nDemo 5: Thick lines (thickness 1, 3, 5)");
    draw_line_thick(&mut grid, 20, 20, 140, 20, 1)?; // Thin
    draw_line_thick(&mut grid, 20, 40, 140, 40, 3)?; // Medium
    draw_line_thick(&mut grid, 20, 60, 140, 60, 5)?; // Thick
    renderer.render(&grid)?;
    std::thread::sleep(std::time::Duration::from_secs(2));

    // Clear for next demo
    grid.clear();

    // Demo 6: Border with thick lines
    println!("\nDemo 6: Border frame with thick lines");
    let thickness = 2;
    // Top border
    draw_line_thick(&mut grid, 0, 0, 159, 0, thickness)?;
    // Bottom border
    draw_line_thick(&mut grid, 0, 95, 159, 95, thickness)?;
    // Left border
    draw_line_thick(&mut grid, 0, 0, 0, 95, thickness)?;
    // Right border
    draw_line_thick(&mut grid, 159, 0, 159, 95, thickness)?;

    // Add diagonal accent
    draw_line(&mut grid, 30, 30, 130, 66)?;
    renderer.render(&grid)?;
    std::thread::sleep(std::time::Duration::from_secs(2));

    // Clear for next demo
    grid.clear();

    // Demo 7: Lines clipped at boundaries (extending beyond grid)
    println!("\nDemo 7: Lines clipped at grid boundaries");
    // Lines that start outside and end inside
    draw_line(&mut grid, -50, 48, 80, 48)?; // From left
    draw_line(&mut grid, 210, 48, 80, 48)?; // From right
    draw_line(&mut grid, 80, -30, 80, 48)?; // From top
    draw_line(&mut grid, 80, 120, 80, 48)?; // From bottom
    renderer.render(&grid)?;
    std::thread::sleep(std::time::Duration::from_secs(2));

    // Clear for next demo
    grid.clear();

    // Demo 8: Complex pattern - grid lines
    println!("\nDemo 8: Grid pattern");
    // Vertical lines every 20 dots
    for x in (0..=160).step_by(20) {
        draw_line(&mut grid, x as i32, 0, x as i32, 95)?;
    }
    // Horizontal lines every 12 dots
    for y in (0..=96).step_by(12) {
        draw_line(&mut grid, 0, y as i32, 159, y as i32)?;
    }
    renderer.render(&grid)?;
    std::thread::sleep(std::time::Duration::from_secs(2));

    println!("\n=== Demo Complete ===");
    println!("All line drawing demos executed successfully!");
    println!("\nKey features demonstrated:");
    println!("✓ Horizontal, vertical, diagonal lines (all octants)");
    println!("✓ Arbitrary angle lines (star pattern)");
    println!("✓ Line thickness variations (1, 3, 5 dots)");
    println!("✓ Boundary clipping (lines extending beyond grid)");
    println!("✓ Complex patterns (border frame, grid)");
    println!("\nPerformance: All lines drawn in <1ms each (Bresenham algorithm)");

    Ok(())
}