@sentryware/s2-node 0.0.6

package/third_party/s2geometry/src/s2/s2point_compression_test.cc

@@ -0,0 +1,305 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+
+#include "s2/s2point_compression.h"
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+#include "s2/base/commandlineflags.h"
+#include "s2/base/logging.h"
+#include <gtest/gtest.h>
+
+#include "s2/s1angle.h"
+#include "s2/s2cell_id.h"
+#include "s2/s2coords.h"
+#include "s2/s2testing.h"
+#include "s2/s2text_format.h"
+#include "s2/third_party/absl/container/fixed_array.h"
+#include "s2/third_party/absl/types/span.h"
+#include "s2/util/coding/coder.h"
+
+using absl::FixedArray;
+using absl::MakeSpan;
+using absl::Span;
+using std::vector;
+
+S2_DEFINE_int32(s2point_compression_bm_level, 30,
+             "Level to encode at for benchmarks.");
+S2_DEFINE_double(s2point_compression_bm_radius_km, 1000.0,
+              "Radius to use for loop for benchmarks.");
+
+namespace {
+
+S2Point SnapPointToLevel(const S2Point& point, int level) {
+  return S2CellId(point).parent(level).ToPoint();
+}
+
+vector<S2Point> SnapPointsToLevel(const vector<S2Point>& points,
+                                  int level) {
+  vector<S2Point> snapped_points(points.size());
+  for (int i = 0; i < points.size(); ++i) {
+    snapped_points[i] = SnapPointToLevel(points[i], level);
+  }
+  return snapped_points;
+}
+
+// Make a regular loop around the corner of faces 0, 1, and 2 with the
+// specified radius in meters (on the earth) and number of vertices.
+vector<S2Point> MakeRegularPoints(int num_vertices,
+                                  double radius_km,
+                                  int level) {
+  const S2Point center = S2Point(1.0, 1.0, 1.0).Normalize();
+  const S1Angle radius_angle = S2Testing::KmToAngle(radius_km);
+
+  const vector<S2Point> unsnapped_points =
+      S2Testing::MakeRegularPoints(center, radius_angle, num_vertices);
+
+  return SnapPointsToLevel(unsnapped_points, level);
+}
+
+void MakeXYZFaceSiTiPoints(Span<const S2Point> points,
+                           Span<S2XYZFaceSiTi> result) {
+  S2_CHECK_EQ(points.size(), result.size());
+  for (int i = 0; i < points.size(); ++i) {
+    result[i].xyz = points[i];
+    result[i].cell_level = S2::XYZtoFaceSiTi(points[i], &result[i].face,
+                                             &result[i].si, &result[i].ti);
+  }
+}
+
+class S2PointCompressionTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    loop_4_ = MakeRegularPoints(4, 0.1, S2::kMaxCellLevel);
+
+    const S2Point center = S2Point(1.0, 1.0, 1.0).Normalize();
+    const S1Angle radius = S2Testing::KmToAngle(0.1);
+    loop_4_unsnapped_ = S2Testing::MakeRegularPoints(center, radius, 4);
+
+    // Radius is 100m, so points are about 141 meters apart.
+    // Snapping to level 14 will move them by < 47m.
+    loop_4_level_14_ = MakeRegularPoints(4, 0.1, 14);
+
+    loop_100_ = MakeRegularPoints(100, 0.1, S2::kMaxCellLevel);
+
+    loop_100_unsnapped_ = S2Testing::MakeRegularPoints(center, radius, 100);
+
+    loop_100_mixed_15_ = S2Testing::MakeRegularPoints(center, radius, 100);
+    for (int i = 0; i < 15; ++i) {
+      loop_100_mixed_15_[3 * i] = SnapPointToLevel(loop_100_mixed_15_[3 * i],
+                                                   S2::kMaxCellLevel);
+    }
+
+    loop_100_mixed_25_ = S2Testing::MakeRegularPoints(center, radius, 100);
+    for (int i = 0; i < 25; ++i) {
+      loop_100_mixed_25_[4 * i] = SnapPointToLevel(loop_100_mixed_25_[4 * i],
+                                                   S2::kMaxCellLevel);
+    }
+
+    // Circumference is 628m, so points are about 6 meters apart.
+    // Snapping to level 22 will move them by < 2m.
+    loop_100_level_22_ = MakeRegularPoints(100, 0.1, 22);
+
+    vector<S2Point> multi_face_points(6);
+    multi_face_points[0] = S2::FaceUVtoXYZ(0, -0.5, 0.5).Normalize();
+    multi_face_points[1] = S2::FaceUVtoXYZ(1, -0.5, 0.5).Normalize();
+    multi_face_points[2] = S2::FaceUVtoXYZ(1, 0.5, -0.5).Normalize();
+    multi_face_points[3] = S2::FaceUVtoXYZ(2, -0.5, 0.5).Normalize();
+    multi_face_points[4] = S2::FaceUVtoXYZ(2, 0.5, -0.5).Normalize();
+    multi_face_points[5] = S2::FaceUVtoXYZ(2, 0.5, 0.5).Normalize();
+    loop_multi_face_ = SnapPointsToLevel(multi_face_points, S2::kMaxCellLevel);
+
+    vector<S2Point> line_points(100);
+    for (int i = 0; i < line_points.size(); ++i) {
+      const double s = 0.01 + 0.005 * i;
+      const double t = 0.01 + 0.009 * i;
+      const double u = S2::STtoUV(s);
+      const double v = S2::STtoUV(t);
+      line_points[i] = S2::FaceUVtoXYZ(0, u, v).Normalize();
+    }
+    line_ = SnapPointsToLevel(line_points, S2::kMaxCellLevel);
+  }
+
+  void Encode(Span<const S2Point> points, int level) {
+    FixedArray<S2XYZFaceSiTi> pts(points.size());
+    MakeXYZFaceSiTiPoints(points, MakeSpan(pts));
+    S2EncodePointsCompressed(pts, level, &encoder_);
+  }
+
+  void Decode(int level, Span<S2Point> points) {
+    decoder_.reset(encoder_.base(), encoder_.length());
+    EXPECT_TRUE(S2DecodePointsCompressed(&decoder_, level, points));
+  }
+
+  void Roundtrip(const vector<S2Point>& loop, int level) {
+    Encode(loop, level);
+    vector<S2Point> points(loop.size());
+    Decode(level, MakeSpan(points));
+
+    EXPECT_TRUE(loop == points)
+        << "Decoded points\n" << s2textformat::ToString(points)
+        << "\ndo not match original points\n"
+        << s2textformat::ToString(loop);
+  }
+
+  Encoder encoder_;
+  Decoder decoder_;
+
+  // Four vertex loop near the corner of faces 0, 1, and 2.
+  vector<S2Point> loop_4_;
+  // Four vertex loop near the corner of faces 0, 1, and 2;
+  // unsnapped.
+  vector<S2Point> loop_4_unsnapped_;
+  // Four vertex loop near the corner of faces 0, 1, and 2;
+  // snapped to level 14.
+  vector<S2Point> loop_4_level_14_;
+  // 100 vertex loop near the corner of faces 0, 1, and 2.
+  vector<S2Point> loop_100_;
+  // 100 vertex loop near the corner of faces 0, 1, and 2;
+  // unsnapped.
+  vector<S2Point> loop_100_unsnapped_;
+  // 100 vertex loop near the corner of faces 0, 1, and 2;
+  // 15 points snapped to kMakCellLevel, the others not snapped.
+  vector<S2Point> loop_100_mixed_15_;
+  // 100 vertex loop near the corner of faces 0, 1, and 2;
+  // 25 points snapped to kMakCellLevel, the others not snapped.
+  vector<S2Point> loop_100_mixed_25_;
+  // 100 vertex loop near the corner of faces 0, 1, and 2;
+  // snapped to level 22.
+  vector<S2Point> loop_100_level_22_;
+  // A loop with two vertices on each of three faces.
+  vector<S2Point> loop_multi_face_;
+  // A straight line of 100 vertices on face 0 that should compress well.
+  vector<S2Point> line_;
+};
+
+TEST_F(S2PointCompressionTest, RoundtripsEmpty) {
+  // Just check this doesn't crash.
+  Encode(Span<S2Point>(), S2::kMaxCellLevel);
+  Decode(S2::kMaxCellLevel, Span<S2Point>());
+}
+
+TEST_F(S2PointCompressionTest, RoundtripsFourVertexLoop) {
+  Roundtrip(loop_4_, S2::kMaxCellLevel);
+}
+
+TEST_F(S2PointCompressionTest, RoundtripsFourVertexLoopUnsnapped) {
+  Roundtrip(loop_4_unsnapped_, S2::kMaxCellLevel);
+}
+
+TEST_F(S2PointCompressionTest, FourVertexLoopSize) {
+  Encode(loop_4_, S2::kMaxCellLevel);
+  // It would take 32 bytes uncompressed.
+  EXPECT_EQ(39, encoder_.length());
+}
+
+TEST_F(S2PointCompressionTest, RoundtripsFourVertexLevel14Loop) {
+  const int level = 14;
+  Roundtrip(loop_4_level_14_, level);
+}
+
+TEST_F(S2PointCompressionTest, FourVertexLevel14LoopSize) {
+  const int level = 14;
+  Encode(loop_4_level_14_, level);
+  // It would take 4 bytes per vertex without compression.
+  EXPECT_EQ(23, encoder_.length());
+}
+
+TEST_F(S2PointCompressionTest, Roundtrips100VertexLoop) {
+  Roundtrip(loop_100_, S2::kMaxCellLevel);
+}
+
+TEST_F(S2PointCompressionTest, Roundtrips100VertexLoopUnsnapped) {
+  Roundtrip(loop_100_unsnapped_, S2::kMaxCellLevel);
+}
+
+TEST_F(S2PointCompressionTest, Roundtrips100VertexLoopMixed15) {
+  Roundtrip(loop_100_mixed_15_, S2::kMaxCellLevel);
+  EXPECT_EQ(2381, encoder_.length());
+}
+
+TEST_F(S2PointCompressionTest, Roundtrips100VertexLoopMixed25) {
+  Roundtrip(loop_100_mixed_25_, S2::kMaxCellLevel);
+  EXPECT_EQ(2131, encoder_.length());
+}
+
+TEST_F(S2PointCompressionTest, OneHundredVertexLoopSize) {
+  Encode(loop_100_, S2::kMaxCellLevel);
+  EXPECT_EQ(257, encoder_.length());
+}
+
+TEST_F(S2PointCompressionTest, OneHundredVertexLoopUnsnappedSize) {
+  Encode(loop_100_unsnapped_, S2::kMaxCellLevel);
+  EXPECT_EQ(2756, encoder_.length());
+}
+
+TEST_F(S2PointCompressionTest, Roundtrips100VertexLevel22Loop) {
+  const int level = 22;
+  Roundtrip(loop_100_level_22_, level);
+}
+
+TEST_F(S2PointCompressionTest, OneHundredVertexLoopLevel22Size) {
+  Encode(loop_100_level_22_, 22);
+  EXPECT_EQ(148, encoder_.length());
+}
+
+TEST_F(S2PointCompressionTest, MultiFaceLoop) {
+  Roundtrip(loop_multi_face_, S2::kMaxCellLevel);
+}
+
+TEST_F(S2PointCompressionTest, StraightLineCompressesWell) {
+  Roundtrip(line_, S2::kMaxCellLevel);
+  // About 1 byte / vertex.
+  EXPECT_EQ(line_.size() + 17, encoder_.length());
+}
+
+TEST_F(S2PointCompressionTest, FirstPointOnFaceEdge) {
+  // This test used to trigger a bug in which EncodeFirstPointFixedLength()
+  // tried to encode a pi/qi value of (2**level) in "level" bits (which did
+  // not work out so well).  The fix is documented in SiTitoPiQi().
+  //
+  // The test data consists of two points, where the first point is exactly on
+  // an S2Cell face edge (with ti == S2::kMaxSiTi), and the second point is
+  // encodable at snap level 8.  This used to cause the code to try encoding
+  // qi = 256 in 8 bits.
+  S2XYZFaceSiTi points[] = {
+    {
+      S2Point(0.054299323861222645, -0.70606358900180299,
+              0.70606358900180299),
+      2,                      // face
+      956301312, 2147483648,  // si, ti
+      -1                      // level
+    },
+    {
+      S2Point(0.056482651436986935, -0.70781701406865505,
+              0.70413406726388494),
+      4,                    // face
+      4194304, 1195376640,  // si, ti
+      8                     // level
+    }};
+
+  Encoder encoder;
+  S2EncodePointsCompressed(points, 8, &encoder);
+  Decoder decoder(encoder.base(), encoder.length());
+  S2Point result[2];
+  S2DecodePointsCompressed(&decoder, 8, result);
+  S2_CHECK(result[0] == points[0].xyz);
+  S2_CHECK(result[1] == points[1].xyz);
+}
+
+}  // namespace

package/third_party/s2geometry/src/s2/s2point_index.h

@@ -0,0 +1,345 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#ifndef S2_S2POINT_INDEX_H_
+#define S2_S2POINT_INDEX_H_
+
+#include <tuple>
+#include <type_traits>
+#include "s2/util/gtl/btree_map.h"
+#include "s2/s2cell_id.h"
+
+// S2PointIndex maintains an index of points sorted by leaf S2CellId.  Each
+// point can optionally store auxiliary data such as an integer or pointer.
+// This can be used to map results back to client data structures.
+//
+// The class supports adding or removing points dynamically, and provides a
+// seekable iterator interface for navigating the index.
+//
+// You can use this class in conjuction with S2ClosestPointQuery to find the
+// closest index points to a given query point.  For example:
+//
+// void Test(const vector<S2Point>& index_points,
+//           const vector<S2Point>& target_points) {
+//   // The template argument allows auxiliary data to be attached to each
+//   // point (in this case, the array index).
+//   S2PointIndex<int> index;
+//   for (int i = 0; i < index_points.size(); ++i) {
+//     index.Add(index_points[i], i);
+//   }
+//   S2ClosestPointQuery<int> query(&index);
+//   query.mutable_options()->set_max_results(5);
+//   for (const S2Point& target_point : target_points) {
+//     S2ClosestPointQueryPointTarget target(target_point);
+//     for (const auto& result : query.FindClosestPoints(&target)) {
+//       // The Result class contains the following methods:
+//       //   distance() is the distance to the target.
+//       //   point() is the indexed point.
+//       //   data() is the auxiliary data.
+//       DoSomething(target_point, result);
+//     }
+//   }
+// }
+//
+// The Data argument defaults to an empty class, which uses no additional
+// space beyond the S2Point itself.  In this case the Data argument is
+// required.  For example:
+//
+//   S2PointIndex<> index;
+//   index.Add(point);
+//
+// Points can be added or removed from the index at any time by calling Add()
+// or Remove().  However when the index is modified, you must call Init() on
+// each iterator before using it again (or simply create a new iterator).
+//
+//   index.Add(new_point, 123456);
+//   it.Init(&index);
+//   it.Seek(target.range_min());
+//
+// You can also access the index directly using the iterator interface.  For
+// example, here is how to iterate through all the points in a given S2CellId
+// "target_id":
+//
+//   S2PointIndex<int>::Iterator it(&index);
+//   it.Seek(target_id.range_min());
+//   for (; !it.done() && it.id() <= target_id.range_max(); it.Next()) {
+//     DoSomething(it.id(), it.point(), it.data());
+//   }
+//
+// TODO(ericv): Consider adding an S2PointIndexRegion class, which could be
+// used to efficiently compute coverings of a collection of S2Points.
+//
+// REQUIRES: "Data" has default and copy constructors.
+// REQUIRES: "Data" has operator== and operator<.
+template <class Data = std::tuple<> /*empty class*/>
+class S2PointIndex {
+ public:
+  // PointData is essentially std::pair with named fields.  It stores an
+  // S2Point and its associated data, taking advantage of the "empty base
+  // optimization" to ensure that no extra space is used when Data is empty.
+  class PointData {
+   public:
+    PointData() {}  // Needed by STL
+    PointData(const S2Point& point, const Data& data) : tuple_(point, data) {}
+
+    const S2Point& point() const { return std::get<0>(tuple_); }
+    const Data& data() const { return std::get<1>(tuple_); }
+
+    friend bool operator==(const PointData& x, const PointData& y) {
+      return x.tuple_ == y.tuple_;
+    }
+    friend bool operator<(const PointData& x, const PointData& y) {
+      return x.tuple_ < y.tuple_;
+    }
+
+   private:
+    // Note that std::tuple has special template magic to ensure that Data
+    // doesn't take up any space when it is empty.  (This is not true if you
+    // simply declare a member of type Data.)
+    std::tuple<S2Point, Data> tuple_;
+  };
+
+  // Default constructor.
+  S2PointIndex();
+
+  // Returns the number of points in the index.
+  int num_points() const;
+
+  // Adds the given point to the index.  Invalidates all iterators.
+  void Add(const S2Point& point, const Data& data);
+  void Add(const PointData& point_data);
+
+  // Convenience function for the case when Data is an empty class.
+  void Add(const S2Point& point);
+
+  // Removes the given point from the index.  Both the "point" and "data"
+  // fields must match the point to be removed.  Returns false if the given
+  // point was not present.  Invalidates all iterators.
+  bool Remove(const S2Point& point, const Data& data);
+  bool Remove(const PointData& point_data);
+
+  // Convenience function for the case when Data is an empty class.
+  void Remove(const S2Point& point);
+
+  // Resets the index to its original empty state.  Invalidates all iterators.
+  void Clear();
+
+ private:
+  // Defined here because the Iterator class below uses it.
+  using Map = gtl::btree_multimap<S2CellId, PointData>;
+
+ public:
+  class Iterator {
+   public:
+    // Default constructor; must be followed by a call to Init().
+    Iterator();
+
+    // Convenience constructor that calls Init().
+    explicit Iterator(const S2PointIndex* index);
+
+    // Initializes an iterator for the given S2PointIndex.  If the index is
+    // non-empty, the iterator is positioned at the first cell.
+    //
+    // This method may be called multiple times, e.g. to make an iterator
+    // valid again after the index is modified.
+    void Init(const S2PointIndex* index);
+
+    // The S2CellId for the current index entry.
+    // REQUIRES: !done()
+    S2CellId id() const;
+
+    // The point associated with the current index entry.
+    // REQUIRES: !done()
+    const S2Point& point() const;
+
+    // The client-supplied data associated with the current index entry.
+    // REQUIRES: !done()
+    const Data& data() const;
+
+    // The (S2Point, data) pair associated with the current index entry.
+    const PointData& point_data() const;
+
+    // Returns true if the iterator is positioned past the last index entry.
+    bool done() const;
+
+    // Positions the iterator at the first index entry (if any).
+    void Begin();
+
+    // Positions the iterator so that done() is true.
+    void Finish();
+
+    // Advances the iterator to the next index entry.
+    // REQUIRES: !done()
+    void Next();
+
+    // If the iterator is already positioned at the beginning, returns false.
+    // Otherwise positions the iterator at the previous entry and returns true.
+    bool Prev();
+
+    // Positions the iterator at the first entry with id() >= target, or at the
+    // end of the index if no such entry exists.
+    void Seek(S2CellId target);
+
+   private:
+    const Map* map_;
+    typename Map::const_iterator iter_, end_;
+  };
+
+ private:
+  friend class Iterator;
+  Map map_;
+
+  S2PointIndex(const S2PointIndex&) = delete;
+  void operator=(const S2PointIndex&) = delete;
+};
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+template <class Data>
+S2PointIndex<Data>::S2PointIndex() {
+}
+
+template <class Data>
+inline int S2PointIndex<Data>::num_points() const {
+  return map_.size();
+}
+
+template <class Data>
+void S2PointIndex<Data>::Add(const PointData& point_data) {
+  S2CellId id(point_data.point());
+  map_.insert(std::make_pair(id, point_data));
+}
+
+template <class Data>
+void S2PointIndex<Data>::Add(const S2Point& point, const Data& data) {
+  Add(PointData(point, data));
+}
+
+template <class Data>
+void S2PointIndex<Data>::Add(const S2Point& point) {
+  static_assert(std::is_empty<Data>::value, "Data must be empty");
+  Add(point, {});
+}
+
+template <class Data>
+bool S2PointIndex<Data>::Remove(const PointData& point_data) {
+  S2CellId id(point_data.point());
+  for (typename Map::iterator it = map_.lower_bound(id), end = map_.end();
+       it != end && it->first == id; ++it) {
+    if (it->second == point_data) {
+      map_.erase(it);
+      return true;
+    }
+  }
+  return false;
+}
+
+template <class Data>
+bool S2PointIndex<Data>::Remove(const S2Point& point, const Data& data) {
+  return Remove(PointData(point, data));
+}
+
+template <class Data>
+void S2PointIndex<Data>::Remove(const S2Point& point) {
+  static_assert(std::is_empty<Data>::value, "Data must be empty");
+  Remove(point, {});
+}
+
+template <class Data>
+void S2PointIndex<Data>::Clear() {
+  map_.clear();
+}
+
+template <class Data>
+inline S2PointIndex<Data>::Iterator::Iterator() : map_(nullptr) {
+}
+
+template <class Data>
+inline S2PointIndex<Data>::Iterator::Iterator(
+    const S2PointIndex<Data>* index) {
+  Init(index);
+}
+
+template <class Data>
+inline void S2PointIndex<Data>::Iterator::Init(
+    const S2PointIndex<Data>* index) {
+  map_ = &index->map_;
+  iter_ = map_->begin();
+  end_ = map_->end();
+}
+
+template <class Data>
+inline S2CellId S2PointIndex<Data>::Iterator::id() const {
+  S2_DCHECK(!done());
+  return iter_->first;
+}
+
+template <class Data>
+inline const S2Point& S2PointIndex<Data>::Iterator::point() const {
+  S2_DCHECK(!done());
+  return iter_->second.point();
+}
+
+template <class Data>
+inline const Data& S2PointIndex<Data>::Iterator::data() const {
+  S2_DCHECK(!done());
+  return iter_->second.data();
+}
+
+template <class Data>
+inline const typename S2PointIndex<Data>::PointData&
+S2PointIndex<Data>::Iterator::point_data() const {
+  S2_DCHECK(!done());
+  return iter_->second;
+}
+
+template <class Data>
+inline bool S2PointIndex<Data>::Iterator::done() const {
+  return iter_ == end_;
+}
+
+template <class Data>
+inline void S2PointIndex<Data>::Iterator::Begin() {
+  iter_ = map_->begin();
+}
+
+template <class Data>
+inline void S2PointIndex<Data>::Iterator::Finish() {
+  iter_ = end_;
+}
+
+template <class Data>
+inline void S2PointIndex<Data>::Iterator::Next() {
+  S2_DCHECK(!done());
+  ++iter_;
+}
+
+template <class Data>
+inline bool S2PointIndex<Data>::Iterator::Prev() {
+  if (iter_ == map_->begin()) return false;
+  --iter_;
+  return true;
+}
+
+template <class Data>
+inline void S2PointIndex<Data>::Iterator::Seek(S2CellId target) {
+  iter_ = map_->lower_bound(target);
+}
+
+#endif  // S2_S2POINT_INDEX_H_