routingkit-cch 0.1.4

Rust bindings for RoutingKit's Customizable Contraction Hierarchies (CCH)
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

#include <routingkit/google_polyline.h>

#include <iostream>
using namespace std;

namespace RoutingKit {

void GoogleOneDimensionalPolylineEncoder::encode(float val, std::string &str) {
  const int int_val = static_cast<int>(val * 100000);
  const int delta_val = int_val - last_val;
  last_val = int_val;

  unsigned uint_val = static_cast<unsigned>(delta_val);

  uint_val <<= 1;

  if (delta_val < 0) {
    uint_val = ~uint_val;
  }

  do {
    unsigned chunk = uint_val & ((1u << 5) - 1);

    uint_val >>= 5;
    if (uint_val != 0) {
      chunk |= 0x20;
    }
    chunk += 0x3f;

    str.push_back(chunk);
  } while (uint_val != 0);
}

void GooglePolylineEncoder::encode(float lat, float lon, std::string &str) {
  lat_encoder.encode(lat, str);
  lon_encoder.encode(lon, str);
}

GoogleOneDimensionalPolylineDecoder::Result
GoogleOneDimensionalPolylineDecoder::decode(std::string_view str) {

  unsigned uint_val = 0;
  unsigned str_pos = 0;
  bool has_next = true;
  while (has_next && str_pos < str.size()) {
    unsigned chunk = str[str_pos];
    chunk -= 0x3f;
    has_next = (chunk & 0x20);
    chunk &= ((1u << 5) - 1);

    uint_val |= chunk << (5 * str_pos);
    ++str_pos;
  }

  bool is_negative = uint_val & 1;

  uint_val >>= 1;
  if (is_negative) {
    uint_val = ~uint_val;
  }

  int int_val = static_cast<int>(uint_val);

  int_val += last_val;
  last_val = int_val;

  float val = static_cast<float>(int_val) / 100000.f;

  GoogleOneDimensionalPolylineDecoder::Result result;
  result.value = val;
  result.remaining = str.substr(str_pos);
  return result;
}

GooglePolylineDecoder::Result
GooglePolylineDecoder::decode(std::string_view str) {
  GoogleOneDimensionalPolylineDecoder::Result lat_result =
      lat_decoder.decode(str);
  GoogleOneDimensionalPolylineDecoder::Result lon_result =
      lon_decoder.decode(lat_result.remaining);
  GooglePolylineDecoder::Result result;
  result.latitude = lat_result.value;
  result.longitude = lon_result.value;
  result.remaining = lon_result.remaining;
  return result;
}

} // namespace RoutingKit