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
//! Scanlines
//use std::collections::HashMap;
/// Contigious area of data
#[derive(Debug,Default)]
pub(crate) struct Span {
/// Starting x position
pub x: i64,
/// Length of span
pub len: i64,
/// Cover values with len values
pub covers: Vec<u64>,
}
/// Unpacked Scanline
///
/// Represents a single row of an image
#[derive(Debug,Default)]
pub(crate) struct ScanlineU8 {
/// Last x value used
///
/// Used as a state variable
last_x: i64,
/// Minimum x position
///
/// This value can probably be removed
min_x: i64,
/// Collection of spans
pub spans: Vec<Span>,
// / Collection of covers
// / Needed ?
//covers: HashMap<i64, u64>,
/// Current y value
///
/// State variable
pub y: i64,
}
const LAST_X: i64 = 0x7FFF_FFF0;
impl ScanlineU8 {
/// Create a new empty scanline
pub fn new() -> Self {
Self { last_x: LAST_X, min_x: 0, y: 0,
spans: vec![], } //covers: HashMap::new() }
}
/// Reset values and clear spans
pub fn reset_spans(&mut self) {
self.last_x = LAST_X;
self.spans.clear();
//self.covers.clear();
}
/// Reset values and clear spans, setting min value
pub fn reset(&mut self, min_x: i64, _max_x: i64) {
self.last_x = LAST_X;
self.min_x = min_x;
self.spans = vec![];
//self.covers = HashMap::new()
}
/// Set the current row (y) that is to be worked on
pub fn finalize(&mut self, y: i64) {
self.y = y;
}
/// Total number of spans
pub fn num_spans(&self) -> usize {
self.spans.len()
}
/// Add a span starting at x, with a length and cover value
///
/// If the x value is 1 greater than the last value, the length of that
/// span is increased and the cover value appended
/// Otherwise, not a new span is created
pub fn add_span(&mut self, x: i64, len: i64, cover: u64) {
let x = x - self.min_x;
//self.covers.insert( x, cover );
if x == self.last_x + 1 {
let cur = self.spans.last_mut().unwrap();
//eprintln!("ADD_SPAN: Increasing length of span: {} {} x: {} {}", cur.len, cur.covers.len(), x+self.min_x, len);
cur.len += len;
cur.covers.extend(vec![cover; len as usize]);
//eprintln!("ADD_SPAN: Increasing length of span: {} {} x: {}", cur.len, cur.covers.len(), x+self.min_x);
} else {
//eprintln!("ADD_SPAN: Adding span of length: {} at {}", len, x+self.min_x);
let span = Span { x: x + self.min_x, len,
covers: vec![cover; len as usize] };
self.spans.push(span);
}
self.last_x = x + len - 1;
}
/// Add a single length span, cell, with a cover value
///
/// If the cell is 1 beyond the last value, the length is increased and the
/// cover is append, otherwise a new span is created
pub fn add_cell(&mut self, x: i64, cover: u64) {
let x = x - self.min_x;
//self.covers.insert( x, cover );
if x == self.last_x + 1 {
let cur = self.spans.last_mut().unwrap();
cur.len += 1;
cur.covers.push(cover);
} else {
//let cover = self.covers.get(&x).unwrap().clone();
let span = Span { x: x + self.min_x, len: 1,
covers: vec![cover] };
self.spans.push(span);
}
self.last_x = x;
}
}