mm2 0.26.0

minimap2 frontend
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
145
146
147
148
149
150
151
152
153
154
155
156

use crate::align_processor::AlignInfo;

/*

0 => Cigar::Match(cnt),
                1 => Cigar::Ins(cnt),
                2 => Cigar::Del(cnt),
                3 => Cigar::RefSkip(cnt),
                4 => Cigar::SoftClip(cnt),
                5 => Cigar::HardClip(cnt),
                6 => Cigar::Pad(cnt),
                7 => Cigar::Equal(cnt),
                8 => Cigar::Diff(cnt),

*/

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum AlignOp {
    Match(u32),
    Ins(u32),
    Del(u32),
    RefSkip(u32),
    SoftClip(u32),
    HardClip(u32),
    Pad(u32),
    Equal(u32),
    Diff(u32),
}

impl From<u8> for AlignOp {
    fn from(value: u8) -> Self {
        match value {
            0 => AlignOp::Match(1),
            1 => AlignOp::Ins(1),
            2 => AlignOp::Del(1),
            3 => AlignOp::RefSkip(1),
            4 => AlignOp::SoftClip(1),
            5 => AlignOp::HardClip(1),
            6 => AlignOp::Pad(1),
            7 => AlignOp::Equal(1),
            8 => AlignOp::Diff(1),
            _ => panic!("invalid code. {}", value),
        }
    }
}

pub trait TAlignedPairs {
    fn target_start(&self) -> usize;
    fn target_end(&self) -> usize;
    fn query_start(&self) -> usize; // 原始序列的开始
    fn query_end(&self) -> usize; // 原始序列的结束
    fn is_reverse(&self) -> bool;
    fn cigars(&self) -> &[(u32, u8)]; // 如果是 reverse，那么是 reverse 后的 cigar。

    fn aligned_pairs(
        &self,
        query_len: usize,
    ) -> impl Iterator<Item = (Option<usize>, Option<usize>, AlignOp)> {
        let mut query_cursor = if self.is_reverse() {
            query_len - self.query_end()
        } else {
            self.query_start()
        };

        let mut target_cursor = self.target_start();

        self.cigars().iter().copied().flat_map(move |(cnt, op)| {
            let cnt = cnt as usize;
            match op {
                0 => panic!("eqx required"),
                1 => {
                    // ins
                    let old_query_cursor = query_cursor;
                    query_cursor += cnt;
                    Box::new(
                        (0..cnt)
                            .into_iter()
                            .map(move |shift| (Some(old_query_cursor + shift), None, op.into())),
                    )
                        as Box<dyn Iterator<Item = (Option<usize>, Option<usize>, AlignOp)>>
                }
                2 => {
                    // del
                    let old_target_cursor = target_cursor;
                    target_cursor += cnt;
                    Box::new(
                        (0..cnt)
                            .into_iter()
                            .map(move |shift| (None, Some(old_target_cursor + shift), op.into())),
                    )
                        as Box<dyn Iterator<Item = (Option<usize>, Option<usize>, AlignOp)>>
                }
                7 | 8 => {
                    let old_query_cursor = query_cursor;
                    query_cursor += cnt;
                    let old_target_cursor = target_cursor;
                    target_cursor += cnt;

                    Box::new((0..cnt).into_iter().map(move |shift| {
                        (
                            Some(old_query_cursor + shift),
                            Some(old_target_cursor + shift),
                            op.into(),
                        )
                    }))
                        as Box<dyn Iterator<Item = (Option<usize>, Option<usize>, AlignOp)>>
                }
                op => panic!("not a valid op:{}", op),
            }
        })
    }
}

impl TAlignedPairs for AlignInfo {
    fn cigars(&self) -> &[(u32, u8)] {
        &self.cigar
    }

    fn is_reverse(&self) -> bool {
        !self.fwd
    }

    fn query_end(&self) -> usize {
        self.qend
    }
    fn query_start(&self) -> usize {
        self.qstart
    }
    fn target_end(&self) -> usize {
        self.rend
    }
    fn target_start(&self) -> usize {
        self.rstart
    }
}

#[cfg(test)]
mod test {
    use crate::{align_processor::AlignInfo, aligned_pairs::TAlignedPairs};

    #[test]
    fn test_align_info() {
        let align_info = AlignInfo {
            rstart: 0,
            rend: 10,
            qstart: 1,
            qend: 12,
            fwd: true,
            primary: true,
            cigar: vec![(4, 7), (2, 1), (4, 7), (1, 2), (1, 7)],
        };
        for align_info in align_info.aligned_pairs(12) {
            println!("align_info:{:?}", align_info);
        }
    }
}