@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,348 @@
+// Copyright 2013 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)
+
+#include "s2/s2lax_polygon_shape.h"
+
+#include "s2/s2shapeutil_get_reference_point.h"
+
+using absl::make_unique;
+using absl::MakeSpan;
+using absl::Span;
+using std::vector;
+using ChainPosition = S2Shape::ChainPosition;
+
+// When adding a new encoding, be aware that old binaries will not be able
+// to decode it.
+static const unsigned char kCurrentEncodingVersionNumber = 1;
+
+S2LaxPolygonShape::S2LaxPolygonShape(
+    const vector<S2LaxPolygonShape::Loop>& loops) {
+  Init(loops);
+}
+
+S2LaxPolygonShape::S2LaxPolygonShape(const S2Polygon& polygon) {
+  Init(polygon);
+}
+
+void S2LaxPolygonShape::Init(const vector<S2LaxPolygonShape::Loop>& loops) {
+  vector<Span<const S2Point>> spans;
+  spans.reserve(loops.size());
+  for (const S2LaxPolygonShape::Loop& loop : loops) {
+    spans.emplace_back(loop);
+  }
+  Init(spans);
+}
+
+void S2LaxPolygonShape::Init(const S2Polygon& polygon) {
+  vector<Span<const S2Point>> spans;
+  for (int i = 0; i < polygon.num_loops(); ++i) {
+    const S2Loop* loop = polygon.loop(i);
+    if (loop->is_full()) {
+      spans.emplace_back();  // Empty span.
+    } else {
+      spans.emplace_back(&loop->vertex(0), loop->num_vertices());
+    }
+  }
+  Init(spans);
+
+  // S2Polygon and S2LaxPolygonShape holes are oriented oppositely, so we need
+  // to reverse the orientation of any loops representing holes.
+  for (int i = 0; i < polygon.num_loops(); ++i) {
+    if (polygon.loop(i)->is_hole()) {
+      S2Point* v0 = &vertices_[cumulative_vertices_[i]];
+      std::reverse(v0, v0 + num_loop_vertices(i));
+    }
+  }
+}
+
+void S2LaxPolygonShape::Init(const vector<Span<const S2Point>>& loops) {
+  num_loops_ = loops.size();
+  if (num_loops_ == 0) {
+    num_vertices_ = 0;
+    vertices_ = nullptr;
+  } else if (num_loops_ == 1) {
+    num_vertices_ = loops[0].size();
+    vertices_.reset(new S2Point[num_vertices_]);
+    std::copy(loops[0].begin(), loops[0].end(), vertices_.get());
+  } else {
+    cumulative_vertices_ = new uint32[num_loops_ + 1];
+    int32 num_vertices = 0;
+    for (int i = 0; i < num_loops_; ++i) {
+      cumulative_vertices_[i] = num_vertices;
+      num_vertices += loops[i].size();
+    }
+    cumulative_vertices_[num_loops_] = num_vertices;
+    vertices_.reset(new S2Point[num_vertices]);
+    for (int i = 0; i < num_loops_; ++i) {
+      std::copy(loops[i].begin(), loops[i].end(),
+                vertices_.get() + cumulative_vertices_[i]);
+    }
+  }
+}
+
+S2LaxPolygonShape::~S2LaxPolygonShape() {
+  if (num_loops() > 1) {
+    delete[] cumulative_vertices_;
+  }
+}
+
+int S2LaxPolygonShape::num_vertices() const {
+  if (num_loops() <= 1) {
+    return num_vertices_;
+  } else {
+    return cumulative_vertices_[num_loops()];
+  }
+}
+
+int S2LaxPolygonShape::num_loop_vertices(int i) const {
+  S2_DCHECK_LT(i, num_loops());
+  if (num_loops() == 1) {
+    return num_vertices_;
+  } else {
+    return cumulative_vertices_[i + 1] - cumulative_vertices_[i];
+  }
+}
+
+const S2Point& S2LaxPolygonShape::loop_vertex(int i, int j) const {
+  S2_DCHECK_LT(i, num_loops());
+  S2_DCHECK_LT(j, num_loop_vertices(i));
+  if (num_loops() == 1) {
+    return vertices_[j];
+  } else {
+    return vertices_[cumulative_vertices_[i] + j];
+  }
+}
+
+void S2LaxPolygonShape::Encode(Encoder* encoder,
+                               s2coding::CodingHint hint) const {
+  encoder->Ensure(1 + Varint::kMax32);
+  encoder->put8(kCurrentEncodingVersionNumber);
+  encoder->put_varint32(num_loops_);
+  s2coding::EncodeS2PointVector(MakeSpan(vertices_.get(), num_vertices()),
+                                hint, encoder);
+  if (num_loops() > 1) {
+    s2coding::EncodeUintVector<uint32>(MakeSpan(cumulative_vertices_,
+                                                num_loops() + 1), encoder);
+  }
+}
+
+bool S2LaxPolygonShape::Init(Decoder* decoder) {
+  if (decoder->avail() < 1) return false;
+  uint8 version = decoder->get8();
+  if (version != kCurrentEncodingVersionNumber) return false;
+
+  uint32 num_loops;
+  if (!decoder->get_varint32(&num_loops)) return false;
+  num_loops_ = num_loops;
+  s2coding::EncodedS2PointVector vertices;
+  if (!vertices.Init(decoder)) return false;
+
+  if (num_loops_ == 0) {
+    num_vertices_ = 0;
+    vertices_ = nullptr;
+  } else {
+    vertices_ = make_unique<S2Point[]>(vertices.size());
+    for (int i = 0; i < vertices.size(); ++i) {
+      vertices_[i] = vertices[i];
+    }
+    if (num_loops_ == 1) {
+      num_vertices_ = vertices.size();
+    } else {
+      s2coding::EncodedUintVector<uint32> cumulative_vertices;
+      if (!cumulative_vertices.Init(decoder)) return false;
+      cumulative_vertices_ = new uint32[cumulative_vertices.size()];
+      for (int i = 0; i < cumulative_vertices.size(); ++i) {
+        cumulative_vertices_[i] = cumulative_vertices[i];
+      }
+    }
+  }
+  return true;
+}
+
+S2Shape::Edge S2LaxPolygonShape::edge(int e0) const {
+  S2_DCHECK_LT(e0, num_edges());
+  int e1 = e0 + 1;
+  if (num_loops() == 1) {
+    if (e1 == num_vertices_) { e1 = 0; }
+  } else {
+    // Find the index of the first vertex of the loop following this one.
+    const int kMaxLinearSearchLoops = 12;  // From benchmarks.
+    uint32* next = cumulative_vertices_ + 1;
+    if (num_loops() <= kMaxLinearSearchLoops) {
+      while (*next <= e0) ++next;
+    } else {
+      next = std::lower_bound(next, next + num_loops(), e1);
+    }
+    // Wrap around to the first vertex of the loop if necessary.
+    if (e1 == *next) { e1 = next[-1]; }
+  }
+  return Edge(vertices_[e0], vertices_[e1]);
+}
+
+S2Shape::ReferencePoint S2LaxPolygonShape::GetReferencePoint() const {
+  return s2shapeutil::GetReferencePoint(*this);
+}
+
+S2Shape::Chain S2LaxPolygonShape::chain(int i) const {
+  S2_DCHECK_LT(i, num_loops());
+  if (num_loops() == 1) {
+    return Chain(0, num_vertices_);
+  } else {
+    int start = cumulative_vertices_[i];
+    return Chain(start, cumulative_vertices_[i + 1] - start);
+  }
+}
+
+S2Shape::Edge S2LaxPolygonShape::chain_edge(int i, int j) const {
+  S2_DCHECK_LT(i, num_loops());
+  S2_DCHECK_LT(j, num_loop_vertices(i));
+  int n = num_loop_vertices(i);
+  int k = (j + 1 == n) ? 0 : j + 1;
+  if (num_loops() == 1) {
+    return Edge(vertices_[j], vertices_[k]);
+  } else {
+    int base = cumulative_vertices_[i];
+    return Edge(vertices_[base + j], vertices_[base + k]);
+  }
+}
+
+S2Shape::ChainPosition S2LaxPolygonShape::chain_position(int e) const {
+  S2_DCHECK_LT(e, num_edges());
+  const int kMaxLinearSearchLoops = 12;  // From benchmarks.
+  if (num_loops() == 1) {
+    return ChainPosition(0, e);
+  } else {
+    // Find the index of the first vertex of the loop following this one.
+    uint32* next = cumulative_vertices_ + 1;
+    if (num_loops() <= kMaxLinearSearchLoops) {
+      while (*next <= e) ++next;
+    } else {
+      next = std::lower_bound(next, next + num_loops(), e + 1);
+    }
+    return ChainPosition(next - (cumulative_vertices_ + 1), e - next[-1]);
+  }
+}
+
+bool EncodedS2LaxPolygonShape::Init(Decoder* decoder) {
+  if (decoder->avail() < 1) return false;
+  uint8 version = decoder->get8();
+  if (version != kCurrentEncodingVersionNumber) return false;
+
+  uint32 num_loops;
+  if (!decoder->get_varint32(&num_loops)) return false;
+  num_loops_ = num_loops;
+
+  if (!vertices_.Init(decoder)) return false;
+
+  if (num_loops_ > 1) {
+    if (!cumulative_vertices_.Init(decoder)) return false;
+  }
+  return true;
+}
+
+int EncodedS2LaxPolygonShape::num_vertices() const {
+  if (num_loops() <= 1) {
+    return vertices_.size();
+  } else {
+    return cumulative_vertices_[num_loops()];
+  }
+}
+
+int EncodedS2LaxPolygonShape::num_loop_vertices(int i) const {
+  S2_DCHECK_LT(i, num_loops());
+  if (num_loops() == 1) {
+    return vertices_.size();
+  } else {
+    return cumulative_vertices_[i + 1] - cumulative_vertices_[i];
+  }
+}
+
+S2Point EncodedS2LaxPolygonShape::loop_vertex(int i, int j) const {
+  S2_DCHECK_LT(i, num_loops());
+  S2_DCHECK_LT(j, num_loop_vertices(i));
+  if (num_loops() == 1) {
+    return vertices_[j];
+  } else {
+    return vertices_[cumulative_vertices_[i] + j];
+  }
+}
+
+S2Shape::Edge EncodedS2LaxPolygonShape::edge(int e) const {
+  S2_DCHECK_LT(e, num_edges());
+  int e1 = e + 1;
+  if (num_loops() == 1) {
+    if (e1 == vertices_.size()) { e1 = 0; }
+  } else {
+    // Find the index of the first vertex of the loop following this one.
+    const int kMaxLinearSearchLoops = 12;  // From benchmarks.
+    int next = 1;
+    if (num_loops() <= kMaxLinearSearchLoops) {
+      while (cumulative_vertices_[next] <= e) ++next;
+    } else {
+      next = cumulative_vertices_.lower_bound(e1);
+    }
+    // Wrap around to the first vertex of the loop if necessary.
+    if (e1 == cumulative_vertices_[next]) {
+      e1 = cumulative_vertices_[next - 1];
+    }
+  }
+  return Edge(vertices_[e], vertices_[e1]);
+}
+
+S2Shape::ReferencePoint EncodedS2LaxPolygonShape::GetReferencePoint() const {
+  return s2shapeutil::GetReferencePoint(*this);
+}
+
+S2Shape::Chain EncodedS2LaxPolygonShape::chain(int i) const {
+  S2_DCHECK_LT(i, num_loops());
+  if (num_loops() == 1) {
+    return Chain(0, vertices_.size());
+  } else {
+    int start = cumulative_vertices_[i];
+    return Chain(start, cumulative_vertices_[i + 1] - start);
+  }
+}
+
+S2Shape::Edge EncodedS2LaxPolygonShape::chain_edge(int i, int j) const {
+  S2_DCHECK_LT(i, num_loops());
+  S2_DCHECK_LT(j, num_loop_vertices(i));
+  int n = num_loop_vertices(i);
+  int k = (j + 1 == n) ? 0 : j + 1;
+  if (num_loops() == 1) {
+    return Edge(vertices_[j], vertices_[k]);
+  } else {
+    int base = cumulative_vertices_[i];
+    return Edge(vertices_[base + j], vertices_[base + k]);
+  }
+}
+
+S2Shape::ChainPosition EncodedS2LaxPolygonShape::chain_position(int e) const {
+  S2_DCHECK_LT(e, num_edges());
+  const int kMaxLinearSearchLoops = 12;  // From benchmarks.
+  if (num_loops() == 1) {
+    return ChainPosition(0, e);
+  } else {
+    // Find the index of the first vertex of the loop following this one.
+    int next = 1;
+    if (num_loops() <= kMaxLinearSearchLoops) {
+      while (cumulative_vertices_[next] <= e) ++next;
+    } else {
+      next = cumulative_vertices_.lower_bound(e + 1);
+    }
+    return ChainPosition(next - 1, e - cumulative_vertices_[next - 1]);
+  }
+}

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

@@ -0,0 +1,183 @@
+// Copyright 2013 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_S2LAX_POLYGON_SHAPE_H_
+#define S2_S2LAX_POLYGON_SHAPE_H_
+
+#include <memory>
+#include <vector>
+
+#include "s2/third_party/absl/types/span.h"
+#include "s2/encoded_s2point_vector.h"
+#include "s2/encoded_uint_vector.h"
+#include "s2/s2polygon.h"
+#include "s2/s2shape.h"
+
+// S2LaxPolygonShape represents a region defined by a collection of zero or
+// more closed loops.  The interior is the region to the left of all loops.
+// This is similar to S2Polygon::Shape except that this class supports
+// polygons with degeneracies.  Degeneracies are of two types: degenerate
+// edges (from a vertex to itself) and sibling edge pairs (consisting of two
+// oppositely oriented edges).  Degeneracies can represent either "shells" or
+// "holes" depending on the loop they are contained by.  For example, a
+// degenerate edge or sibling pair contained by a "shell" would be interpreted
+// as a degenerate hole.  Such edges form part of the boundary of the polygon.
+//
+// Loops with fewer than three vertices are interpreted as follows:
+//  - A loop with two vertices defines two edges (in opposite directions).
+//  - A loop with one vertex defines a single degenerate edge.
+//  - A loop with no vertices is interpreted as the "full loop" containing
+//    all points on the sphere.  If this loop is present, then all other loops
+//    must form degeneracies (i.e., degenerate edges or sibling pairs).  For
+//    example, two loops {} and {X} would be interpreted as the full polygon
+//    with a degenerate single-point hole at X.
+//
+// S2LaxPolygonShape does not have any error checking, and it is perfectly
+// fine to create S2LaxPolygonShape objects that do not meet the requirements
+// below (e.g., in order to analyze or fix those problems).  However,
+// S2LaxPolygonShapes must satisfy some additional conditions in order to
+// perform certain operations:
+//
+//  - In order to be valid for point containment tests, the polygon must
+//    satisfy the "interior is on the left" rule.  This means that there must
+//    not be any crossing edges, and if there are duplicate edges then all but
+//    at most one of thm must belong to a sibling pair (i.e., the number of
+//    edges in opposite directions must differ by at most one).
+//
+//  - To be valid for boolean operations (S2BooleanOperation), degenerate
+//    edges and sibling pairs cannot coincide with any other edges.  For
+//    example, the following situations are not allowed:
+//
+//      {AA, AA}      // degenerate edge coincides with another edge
+//      {AA, AB}      // degenerate edge coincides with another edge
+//      {AB, BA, AB}  // sibling pair coincides with another edge
+//
+// Note that S2LaxPolygonShape is must faster to initialize and is more
+// compact than S2Polygon, but unlike S2Polygon it does not have any built-in
+// operations.  Instead you should use S2ShapeIndex operations
+// (S2BooleanOperation, S2ClosestEdgeQuery, etc).
+class S2LaxPolygonShape : public S2Shape {
+ public:
+  static constexpr TypeTag kTypeTag = 5;
+
+  // Constructs an empty polygon.
+  S2LaxPolygonShape() : num_loops_(0), num_vertices_(0) {}
+
+  // Constructs an S2LaxPolygonShape from the given vertex loops.
+  using Loop = std::vector<S2Point>;
+  explicit S2LaxPolygonShape(const std::vector<Loop>& loops);
+
+  // Constructs an S2LaxPolygonShape from an S2Polygon, by copying its data.
+  // Full and empty S2Polygons are supported.
+  explicit S2LaxPolygonShape(const S2Polygon& polygon);
+
+  ~S2LaxPolygonShape() override;
+
+  // Initializes an S2LaxPolygonShape from the given vertex loops.
+  void Init(const std::vector<Loop>& loops);
+
+  // Initializes an S2LaxPolygonShape from an S2Polygon, by copying its data.
+  // Full and empty S2Polygons are supported.
+  void Init(const S2Polygon& polygon);
+
+  // Returns the number of loops.
+  int num_loops() const { return num_loops_; }
+
+  // Returns the total number of vertices in all loops.
+  int num_vertices() const;
+
+  // Returns the number of vertices in the given loop.
+  int num_loop_vertices(int i) const;
+
+  // Returns the vertex from loop "i" at index "j".
+  // REQUIRES: 0 <= i < num_loops()
+  // REQUIRES: 0 <= j < num_loop_vertices(i)
+  const S2Point& loop_vertex(int i, int j) const;
+
+  // Appends an encoded representation of the S2LaxPolygonShape to "encoder".
+  //
+  // REQUIRES: "encoder" uses the default constructor, so that its buffer
+  //           can be enlarged as necessary by calling Ensure(int).
+  void Encode(Encoder* encoder,
+              s2coding::CodingHint hint = s2coding::CodingHint::COMPACT) const;
+
+  // Decodes an S2LaxPolygonShape, returning true on success.  (The method
+  // name is chosen for compatibility with EncodedS2LaxPolygonShape below.)
+  bool Init(Decoder* decoder);
+
+  // S2Shape interface:
+  int num_edges() const final { return num_vertices(); }
+  Edge edge(int e) const final;
+  int dimension() const final { return 2; }
+  ReferencePoint GetReferencePoint() const final;
+  int num_chains() const final { return num_loops(); }
+  Chain chain(int i) const final;
+  Edge chain_edge(int i, int j) const final;
+  ChainPosition chain_position(int e) const final;
+  TypeTag type_tag() const override { return kTypeTag; }
+
+ private:
+  void Init(const std::vector<absl::Span<const S2Point>>& loops);
+
+  int32 num_loops_;
+  std::unique_ptr<S2Point[]> vertices_;
+  // If num_loops_ <= 1, this union stores the number of vertices.
+  // Otherwise it points to an array of size (num_loops + 1) where element "i"
+  // is the total number of vertices in loops 0..i-1.
+  union {
+    int32 num_vertices_;
+    uint32* cumulative_vertices_;  // Don't use unique_ptr in unions.
+  };
+};
+
+// Exactly like S2LaxPolygonShape, except that the vertices are kept in an
+// encoded form and are decoded only as they are accessed.  This allows for
+// very fast initialization and no additional memory use beyond the encoded
+// data.  The encoded data is not owned by this class; typically it points
+// into a large contiguous buffer that contains other encoded data as well.
+class EncodedS2LaxPolygonShape : public S2Shape {
+ public:
+  // Constructs an uninitialized object; requires Init() to be called.
+  EncodedS2LaxPolygonShape() {}
+
+  // Initializes an EncodedS2LaxPolygonShape.
+  //
+  // REQUIRES: The Decoder data buffer must outlive this object.
+  bool Init(Decoder* decoder);
+
+  int num_loops() const { return num_loops_; }
+  int num_vertices() const;
+  int num_loop_vertices(int i) const;
+  S2Point loop_vertex(int i, int j) const;
+
+  // S2Shape interface:
+  int num_edges() const final { return num_vertices(); }
+  Edge edge(int e) const final;
+  int dimension() const final { return 2; }
+  ReferencePoint GetReferencePoint() const final;
+  int num_chains() const final { return num_loops(); }
+  Chain chain(int i) const final;
+  Edge chain_edge(int i, int j) const final;
+  ChainPosition chain_position(int e) const final;
+
+ private:
+  int32 num_loops_;
+  s2coding::EncodedS2PointVector vertices_;
+  s2coding::EncodedUintVector<uint32> cumulative_vertices_;
+};
+
+#endif  // S2_S2LAX_POLYGON_SHAPE_H_