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


use std::fs::File;
use std::io::BufWriter;

use byteorder::{LittleEndian, WriteBytesExt};

use {Affine, CHeader, Header, Point, Streamlines, Translation};

pub struct Writer {
    writer: BufWriter<File>,
    affine: Affine,
    translation: Translation,
    real_n_count: i32
}

impl Writer {
    pub fn new(path: &str, reference: Option<Header>) -> Writer
    {
        let f = File::create(path).expect("Can't create new trk file.");
        let mut writer = BufWriter::new(f);

        let header = match reference {
            Some(r) => r.clone(),
            None => Header::default()
        };
        header.write(&mut writer);

        Writer {
            writer,
            affine: header.affine.try_inverse().unwrap(),
            translation: header.translation,
            real_n_count: 0
        }
    }

    pub fn write_all(&mut self, streamlines: &Streamlines) {
        for streamline in streamlines {
            self.write(streamline);
        }
    }

    pub fn write(&mut self, streamline: &[Point]) {
        self.writer.write_i32::<LittleEndian>(
            streamline.len() as i32).unwrap();
        for p in streamline {
            self.write_point(*p);
        }
        self.real_n_count += 1;
    }

    pub fn write_from_iter<I>(&mut self, streamline: I, len: usize)
        where I: IntoIterator<Item = Point>
    {
        self.writer.write_i32::<LittleEndian>(len as i32).unwrap();
        for p in streamline {
            self.write_point(p);
        }
        self.real_n_count += 1;
    }

    fn write_point(&mut self, p: Point) {
        let p = (p - self.translation) * self.affine;
        self.writer.write_f32::<LittleEndian>(p.x).unwrap();
        self.writer.write_f32::<LittleEndian>(p.y).unwrap();
        self.writer.write_f32::<LittleEndian>(p.z).unwrap();
    }
}

// Finally write `n_count`
impl Drop for Writer {
    fn drop(&mut self) {
        CHeader::seek_n_count_field(&mut self.writer);
        self.writer.write_i32::<LittleEndian>(self.real_n_count).unwrap();
    }
}