pamly 0.3.5

Command line interface for digital pathology tools.
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

use crate::{Database, Tile};
use anyhow::{bail, Ok, Result};
use sqlite::State;

impl Database {
    pub fn read(&self, pos: (u64, u64), level: u64) -> Result<Tile> {
        let tile_size = self.tile_size();
        let mut tile = Tile::new(pos, level, tile_size);
        let (x, y) = pos;
        let statement = "SELECT jpeg from tiles WHERE
            x = ? AND
            y = ? AND
            level = ?
        ";
        let mut statement = self.db.prepare(statement)?;
        statement.bind((1, x as i64))?;
        statement.bind((2, y as i64))?;
        statement.bind((3, level as i64))?;

        match statement.next()? {
            State::Row => {
                let data = statement.read::<Vec<u8>, _>(0)?;
                tile.set_data(data)?;
            }
            _ => {}
        };
        return Ok(tile);
    }

    pub fn read_many(&self, start: (u64, u64), end: (u64, u64), level: u64) -> Result<Vec<Tile>> {
        let tile_size = self.tile_size();

        let statement = "SELECT x, y, jpeg from tiles WHERE
            x >= ? AND x < ? AND
            y >= ? AND y < ? AND
            level = ?
        ";
        let mut statement = self.db.prepare(statement)?;
        statement.bind((1, start.0 as i64))?;
        statement.bind((2, end.0 as i64))?;
        statement.bind((3, start.1 as i64))?;
        statement.bind((4, end.1 as i64))?;
        statement.bind((5, level as i64))?;

        let mut tiles = Vec::new();
        while statement.next()? == State::Row {
            let x = statement.read::<i64, _>(0)?;
            let y = statement.read::<i64, _>(1)?;
            let data = statement.read::<Vec<u8>, _>(2)?;
            let mut tile = Tile::new((x as u64, y as u64), level, tile_size);
            tile.set_data(data)?;
            tiles.push(tile);
        }
        Ok(tiles)
    }

    pub fn delete(&self, pos: (u64, u64), level: u64) -> Result<()> {
        let (x, y) = pos;
        let statement = "DELETE from tiles WHERE
            x = ? AND
            y = ? AND
            level = ?
        ";
        let mut statement = self.db.prepare(statement)?;
        statement.bind((1, x as i64))?;
        statement.bind((2, y as i64))?;
        statement.bind((3, level as i64))?;

        statement.next()?;
        Ok(())
    }
    pub fn write(&self, tile: &Tile) -> Result<()> {
        if tile.is_empty() {
            return Ok(());
        }
        let (x, y) = tile.pos();
        let level = tile.level();
        let id = tile.index();
        let data = tile.data()?;
        let statement = "INSERT INTO tiles VALUES (?, ?, ?, ?, ?)";
        let mut statement = self.db.prepare(statement)?;
        statement.bind((1, id as i64))?;
        statement.bind((2, x as i64))?;
        statement.bind((3, y as i64))?;
        statement.bind((4, level as i64))?;
        statement.bind((5, &data[..]))?;

        match statement.next()? {
            sqlite::State::Done => return Ok(()),
            _ => bail!("Failed insert"),
        }
    }

    pub fn list_tiles(&self, level: u64) -> Result<Vec<(u64, u64)>> {
        let statement = "SELECT x, y from tiles WHERE
            level = ?
        ";
        let mut statement = self.db.prepare(statement)?;
        statement.bind((1, level as i64))?;

        let mut positions = Vec::new();
        while statement.next()? == State::Row {
            let x = statement.read::<i64, _>(0)?;
            let y = statement.read::<i64, _>(1)?;
            positions.push((x as u64, y as u64));
        }
        Ok(positions)
    }
}