cdshealpix 0.9.1

Rust implementation of the HEALPix tesselation.
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

use std::{convert::Infallible, error::Error};

use crate::nested::{get, iter::checksorted::NotSortedItError, Layer};

/// The internal Iterator must be an iterator on `(lon, lat)` tuples in radians.
/// This Iterator fails (i.e. returns an Error) if the computed value are not ordered
/// by increasing `hash` values.
pub struct SortedHashIt<I>
where
  I: Iterator<Item = (f64, f64)>,
{
  layer: &'static Layer,
  prev: u64,
  coo_it: I,
}

impl<I> SortedHashIt<I>
where
  I: Iterator<Item = (f64, f64)>,
{
  pub fn new(depth: u8, coo_it: I) -> Self {
    Self {
      layer: get(depth),
      prev: 0,
      coo_it,
    }
  }
  pub fn depth(&self) -> u8 {
    self.layer.depth
  }
}

impl<I> Iterator for SortedHashIt<I>
where
  I: Iterator<Item = (f64, f64)>,
{
  type Item = Result<u64, NotSortedItError<u64, Infallible>>;

  fn next(&mut self) -> Option<Self::Item> {
    match self.coo_it.next() {
      Some((lon, lat)) => {
        let curr = self.layer.hash(lon, lat);
        if self.prev <= curr {
          self.prev = curr;
          Some(Ok(curr))
        } else {
          Some(Err(NotSortedItError::NotSorted {
            prev: self.prev,
            curr,
          }))
        }
      }
      None => None,
    }
  }
}

/// The internal Iterator must be an iterator on `(lon, lat)` tuples in radians.
pub struct SortedHashItFromFallibleIt<E, I>
where
  E: Error,
  I: Iterator<Item = Result<(f64, f64), E>>,
{
  layer: &'static Layer,
  prev: u64,
  res_coo_it: I,
}

impl<E, I> SortedHashItFromFallibleIt<E, I>
where
  E: Error,
  I: Iterator<Item = Result<(f64, f64), E>>,
{
  pub fn new(depth: u8, res_coo_it: I) -> Self {
    Self {
      layer: get(depth),
      prev: 0,
      res_coo_it,
    }
  }
  pub fn depth(&self) -> u8 {
    self.layer.depth
  }
}

impl<E, I> Iterator for SortedHashItFromFallibleIt<E, I>
where
  E: Error,
  I: Iterator<Item = Result<(f64, f64), E>>,
{
  type Item = Result<u64, NotSortedItError<u64, E>>;

  fn next(&mut self) -> Option<Self::Item> {
    match self.res_coo_it.next() {
      Some(Ok((lon, lat))) => {
        let curr = self.layer.hash(lon, lat);
        if self.prev <= curr {
          self.prev = curr;
          Some(Ok(curr))
        } else {
          Some(Err(NotSortedItError::NotSorted {
            prev: self.prev,
            curr,
          }))
        }
      }
      Some(Err(e)) => Some(Err(NotSortedItError::Other(e))),
      None => None,
    }
  }
}