@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,295 @@
+// 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/s2min_distance_targets.h"
+
+#include <memory>
+#include "s2/third_party/absl/memory/memory.h"
+#include "s2/s1angle.h"
+#include "s2/s2cap.h"
+#include "s2/s2cell.h"
+#include "s2/s2closest_cell_query.h"
+#include "s2/s2closest_edge_query.h"
+#include "s2/s2edge_distances.h"
+#include "s2/s2shape_index_region.h"
+
+S2Cap S2MinDistancePointTarget::GetCapBound() {
+  return S2Cap(point_, S1ChordAngle::Zero());
+}
+
+bool S2MinDistancePointTarget::UpdateMinDistance(
+    const S2Point& p, S2MinDistance* min_dist) {
+  return min_dist->UpdateMin(S2MinDistance(S1ChordAngle(p, point_)));
+}
+
+bool S2MinDistancePointTarget::UpdateMinDistance(
+    const S2Point& v0, const S2Point& v1, S2MinDistance* min_dist) {
+  return S2::UpdateMinDistance(point_, v0, v1, min_dist);
+}
+
+bool S2MinDistancePointTarget::UpdateMinDistance(
+    const S2Cell& cell, S2MinDistance* min_dist) {
+  return min_dist->UpdateMin(S2MinDistance(cell.GetDistance(point_)));
+}
+
+bool S2MinDistancePointTarget::VisitContainingShapes(
+    const S2ShapeIndex& index, const ShapeVisitor& visitor) {
+  return MakeS2ContainsPointQuery(&index).VisitContainingShapes(
+      point_, [this, &visitor](S2Shape* shape) {
+        return visitor(shape, point_);
+      });
+}
+
+S2Cap S2MinDistanceEdgeTarget::GetCapBound() {
+  // The following computes a radius equal to half the edge length in an
+  // efficient and numerically stable way.
+  double d2 = S1ChordAngle(a_, b_).length2();
+  double r2 = (0.5 * d2) / (1 + sqrt(1 - 0.25 * d2));
+  return S2Cap((a_ + b_).Normalize(), S1ChordAngle::FromLength2(r2));
+}
+
+bool S2MinDistanceEdgeTarget::UpdateMinDistance(
+    const S2Point& p, S2MinDistance* min_dist) {
+  return S2::UpdateMinDistance(p, a_, b_, min_dist);
+}
+
+bool S2MinDistanceEdgeTarget::UpdateMinDistance(
+    const S2Point& v0, const S2Point& v1, S2MinDistance* min_dist) {
+  return S2::UpdateEdgePairMinDistance(a_, b_, v0, v1, min_dist);
+}
+
+bool S2MinDistanceEdgeTarget::UpdateMinDistance(
+    const S2Cell& cell, S2MinDistance* min_dist) {
+  return min_dist->UpdateMin(S2MinDistance(cell.GetDistance(a_, b_)));
+}
+
+bool S2MinDistanceEdgeTarget::VisitContainingShapes(
+    const S2ShapeIndex& index, const ShapeVisitor& visitor) {
+  // We test the center of the edge in order to ensure that edge targets AB
+  // and BA yield identical results (which is not guaranteed by the API but
+  // users might expect).  Other options would be to test both endpoints, or
+  // return different results for AB and BA in some cases.
+  S2MinDistancePointTarget target((a_ + b_).Normalize());
+  return target.VisitContainingShapes(index, visitor);
+}
+
+S2MinDistanceCellTarget::S2MinDistanceCellTarget(const S2Cell& cell)
+    : cell_(cell) {
+}
+
+S2Cap S2MinDistanceCellTarget::GetCapBound() {
+  return cell_.GetCapBound();
+}
+
+bool S2MinDistanceCellTarget::UpdateMinDistance(const S2Point& p,
+                                                S2MinDistance* min_dist) {
+  return min_dist->UpdateMin(S2MinDistance(cell_.GetDistance(p)));
+}
+
+bool S2MinDistanceCellTarget::UpdateMinDistance(
+    const S2Point& v0, const S2Point& v1, S2MinDistance* min_dist) {
+  return min_dist->UpdateMin(S2MinDistance(cell_.GetDistance(v0, v1)));
+}
+
+bool S2MinDistanceCellTarget::UpdateMinDistance(
+    const S2Cell& cell, S2MinDistance* min_dist) {
+  return min_dist->UpdateMin(S2MinDistance(cell_.GetDistance(cell)));
+}
+
+bool S2MinDistanceCellTarget::VisitContainingShapes(
+    const S2ShapeIndex& index, const ShapeVisitor& visitor) {
+  // The simplest approach is simply to return the polygons that contain the
+  // cell center.  Alternatively, if the index cell is smaller than the target
+  // cell then we could return all polygons that are present in the
+  // S2ShapeIndexCell, but since the index is built conservatively this may
+  // include some polygons that don't quite intersect the cell.  So we would
+  // either need to recheck for intersection more accurately, or weaken the
+  // VisitContainingShapes contract so that it only guarantees approximate
+  // intersection, neither of which seems like a good tradeoff.
+  S2MinDistancePointTarget target(cell_.GetCenter());
+  return target.VisitContainingShapes(index, visitor);
+}
+
+S2MinDistanceCellUnionTarget::S2MinDistanceCellUnionTarget(
+    S2CellUnion cell_union)
+    : cell_union_(std::move(cell_union)),
+      query_(absl::make_unique<S2ClosestCellQuery>(&index_)) {
+  for (S2CellId cell_id : cell_union_) {
+    index_.Add(cell_id, 0);
+  }
+  index_.Build();
+}
+
+S2MinDistanceCellUnionTarget::~S2MinDistanceCellUnionTarget() {
+}
+
+bool S2MinDistanceCellUnionTarget::use_brute_force() const {
+  return query_->options().use_brute_force();
+}
+
+void S2MinDistanceCellUnionTarget::set_use_brute_force(
+    bool use_brute_force) {
+  query_->mutable_options()->set_use_brute_force(use_brute_force);
+}
+
+bool S2MinDistanceCellUnionTarget::set_max_error(
+    const S1ChordAngle& max_error) {
+  query_->mutable_options()->set_max_error(max_error);
+  return true;  // Indicates that we may return suboptimal results.
+}
+
+S2Cap S2MinDistanceCellUnionTarget::GetCapBound() {
+  return cell_union_.GetCapBound();
+}
+
+inline bool S2MinDistanceCellUnionTarget::UpdateMinDistance(
+    S2MinDistanceTarget* target, S2MinDistance* min_dist) {
+  query_->mutable_options()->set_max_distance(*min_dist);
+  S2ClosestCellQuery::Result r = query_->FindClosestCell(target);
+  if (r.is_empty()) return false;
+  *min_dist = r.distance();
+  return true;
+}
+
+bool S2MinDistanceCellUnionTarget::UpdateMinDistance(
+    const S2Point& p, S2MinDistance* min_dist) {
+  S2ClosestCellQuery::PointTarget target(p);
+  return UpdateMinDistance(&target, min_dist);
+}
+
+bool S2MinDistanceCellUnionTarget::UpdateMinDistance(
+    const S2Point& v0, const S2Point& v1, S2MinDistance* min_dist) {
+  S2ClosestCellQuery::EdgeTarget target(v0, v1);
+  return UpdateMinDistance(&target, min_dist);
+}
+
+bool S2MinDistanceCellUnionTarget::UpdateMinDistance(
+    const S2Cell& cell, S2MinDistance* min_dist) {
+  S2ClosestCellQuery::CellTarget target(cell);
+  return UpdateMinDistance(&target, min_dist);
+}
+
+bool S2MinDistanceCellUnionTarget::VisitContainingShapes(
+    const S2ShapeIndex& query_index, const ShapeVisitor& visitor) {
+  for (S2CellId cell_id : cell_union_) {
+    S2MinDistancePointTarget target(cell_id.ToPoint());
+    if (!target.VisitContainingShapes(query_index, visitor)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+S2MinDistanceShapeIndexTarget::S2MinDistanceShapeIndexTarget(
+    const S2ShapeIndex* index)
+    : index_(index), query_(absl::make_unique<S2ClosestEdgeQuery>(index)) {
+}
+
+S2MinDistanceShapeIndexTarget::~S2MinDistanceShapeIndexTarget() {
+}
+
+bool S2MinDistanceShapeIndexTarget::include_interiors() const {
+  return query_->options().include_interiors();
+}
+
+void S2MinDistanceShapeIndexTarget::set_include_interiors(
+    bool include_interiors) {
+  query_->mutable_options()->set_include_interiors(include_interiors);
+}
+
+bool S2MinDistanceShapeIndexTarget::use_brute_force() const {
+  return query_->options().use_brute_force();
+}
+
+void S2MinDistanceShapeIndexTarget::set_use_brute_force(
+    bool use_brute_force) {
+  query_->mutable_options()->set_use_brute_force(use_brute_force);
+}
+
+bool S2MinDistanceShapeIndexTarget::set_max_error(
+    const S1ChordAngle& max_error) {
+  query_->mutable_options()->set_max_error(max_error);
+  return true;  // Indicates that we may return suboptimal results.
+}
+
+S2Cap S2MinDistanceShapeIndexTarget::GetCapBound() {
+  return MakeS2ShapeIndexRegion(index_).GetCapBound();
+}
+
+inline bool S2MinDistanceShapeIndexTarget::UpdateMinDistance(
+    S2MinDistanceTarget* target, S2MinDistance* min_dist) {
+  query_->mutable_options()->set_max_distance(*min_dist);
+  S2ClosestEdgeQuery::Result r = query_->FindClosestEdge(target);
+  if (r.is_empty()) return false;
+  *min_dist = r.distance();
+  return true;
+}
+
+bool S2MinDistanceShapeIndexTarget::UpdateMinDistance(
+    const S2Point& p, S2MinDistance* min_dist) {
+  S2ClosestEdgeQuery::PointTarget target(p);
+  return UpdateMinDistance(&target, min_dist);
+}
+
+bool S2MinDistanceShapeIndexTarget::UpdateMinDistance(
+    const S2Point& v0, const S2Point& v1, S2MinDistance* min_dist) {
+  S2ClosestEdgeQuery::EdgeTarget target(v0, v1);
+  return UpdateMinDistance(&target, min_dist);
+}
+
+bool S2MinDistanceShapeIndexTarget::UpdateMinDistance(
+    const S2Cell& cell, S2MinDistance* min_dist) {
+  S2ClosestEdgeQuery::CellTarget target(cell);
+  return UpdateMinDistance(&target, min_dist);
+}
+
+bool S2MinDistanceShapeIndexTarget::VisitContainingShapes(
+    const S2ShapeIndex& query_index, const ShapeVisitor& visitor) {
+  // It is sufficient to find the set of chain starts in the target index
+  // (i.e., one vertex per connected component of edges) that are contained by
+  // the query index, except for one special case to handle full polygons.
+  //
+  // TODO(ericv): Do this by merge-joining the two S2ShapeIndexes, and share
+  // the code with S2BooleanOperation.
+
+  for (S2Shape* shape : *index_) {
+    if (shape == nullptr) continue;
+    int num_chains = shape->num_chains();
+    // Shapes that don't have any edges require a special case (below).
+    bool tested_point = false;
+    for (int c = 0; c < num_chains; ++c) {
+      S2Shape::Chain chain = shape->chain(c);
+      if (chain.length == 0) continue;
+      tested_point = true;
+      S2Point v0 = shape->chain_edge(c, 0).v0;
+      S2MinDistancePointTarget target(v0);
+      if (!target.VisitContainingShapes(query_index, visitor)) {
+        return false;
+      }
+    }
+    if (!tested_point) {
+      // Special case to handle full polygons.
+      S2Shape::ReferencePoint ref = shape->GetReferencePoint();
+      if (!ref.contained) continue;
+      S2MinDistancePointTarget target(ref.point);
+      if (!target.VisitContainingShapes(query_index, visitor)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}

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

@@ -0,0 +1,273 @@
+// Copyright 2017 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)
+//
+// This file defines a collection of classes that are useful for computing
+// minimum distances on the sphere.  Their purpose is to allow code to be
+// shared among the various query classes that find nearby geometry, such as
+// S2ClosestEdgeQuery, S2ClosestPointQuery, and S2ClosestCellQuery.
+
+#ifndef S2_S2MIN_DISTANCE_TARGETS_H_
+#define S2_S2MIN_DISTANCE_TARGETS_H_
+
+#include <memory>
+
+#include "s2/_fp_contract_off.h"
+#include "s2/s1angle.h"
+#include "s2/s1chord_angle.h"
+#include "s2/s2cell.h"
+#include "s2/s2cell_index.h"
+#include "s2/s2distance_target.h"
+#include "s2/s2edge_distances.h"
+#include "s2/s2shape_index.h"
+
+// Forward references because these classes depend on the types defined here.
+class S2ClosestCellQuery;
+class S2ClosestEdgeQuery;
+
+// S2MinDistance is a thin wrapper around S1ChordAngle that is used by classes
+// such as S2ClosestEdgeQuery to compute minimum distances on the sphere (as
+// opposed to maximum distances, ellipsoidal distances, etc).
+//
+// It implements the Distance concept defined by S2DistanceTarget (see
+// s2distance_target.h for details).
+class S2MinDistance : public S1ChordAngle {
+ public:
+  using Delta = S1ChordAngle;
+
+  S2MinDistance() : S1ChordAngle() {}
+  explicit S2MinDistance(S1Angle x) : S1ChordAngle(x) {}
+  explicit S2MinDistance(S1ChordAngle x) : S1ChordAngle(x) {}
+  static S2MinDistance Zero();
+  static S2MinDistance Infinity();
+  static S2MinDistance Negative();
+  friend S2MinDistance operator-(S2MinDistance x, S1ChordAngle delta);
+  S1ChordAngle GetChordAngleBound() const;
+
+  // If (dist < *this), updates *this and returns true (used internally).
+  bool UpdateMin(const S2MinDistance& dist);
+};
+
+// S2MinDistanceTarget represents a geometric object to which distances are
+// measured.  Specifically, it is used to compute minimum distances on the
+// sphere (as opposed to maximum distances, ellipsoidal distances, etc).
+//
+// Subtypes are defined below for measuring the distance to a point, an edge,
+// an S2Cell, or an S2ShapeIndex (an arbitrary collection of geometry).
+using S2MinDistanceTarget = S2DistanceTarget<S2MinDistance>;
+
+// An S2DistanceTarget subtype for computing the minimum distance to a point.
+class S2MinDistancePointTarget : public S2MinDistanceTarget {
+ public:
+  explicit S2MinDistancePointTarget(const S2Point& point);
+  S2Cap GetCapBound() final;
+  bool UpdateMinDistance(const S2Point& p, S2MinDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Point& v0, const S2Point& v1,
+                         S2MinDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Cell& cell,
+                         S2MinDistance* min_dist) final;
+  bool VisitContainingShapes(const S2ShapeIndex& index,
+                             const ShapeVisitor& visitor) final;
+
+ private:
+  S2Point point_;
+};
+
+// An S2DistanceTarget subtype for computing the minimum distance to a edge.
+class S2MinDistanceEdgeTarget : public S2MinDistanceTarget {
+ public:
+  S2MinDistanceEdgeTarget(const S2Point& a, const S2Point& b);
+  S2Cap GetCapBound() final;
+  bool UpdateMinDistance(const S2Point& p, S2MinDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Point& v0, const S2Point& v1,
+                         S2MinDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Cell& cell,
+                         S2MinDistance* min_dist) final;
+  bool VisitContainingShapes(const S2ShapeIndex& index,
+                             const ShapeVisitor& visitor) final;
+
+ private:
+  S2Point a_, b_;
+};
+
+// An S2DistanceTarget subtype for computing the minimum distance to an S2Cell
+// (including the interior of the cell).
+class S2MinDistanceCellTarget : public S2MinDistanceTarget {
+ public:
+  explicit S2MinDistanceCellTarget(const S2Cell& cell);
+  S2Cap GetCapBound() final;
+  bool UpdateMinDistance(const S2Point& p, S2MinDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Point& v0, const S2Point& v1,
+                         S2MinDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Cell& cell,
+                         S2MinDistance* min_dist) final;
+  bool VisitContainingShapes(const S2ShapeIndex& index,
+                             const ShapeVisitor& visitor) final;
+
+ private:
+  S2Cell cell_;
+};
+
+// An S2DistanceTarget subtype for computing the minimum distance to an
+// S2CellUnion (including the interior of all cells).
+class S2MinDistanceCellUnionTarget : public S2MinDistanceTarget {
+ public:
+  explicit S2MinDistanceCellUnionTarget(S2CellUnion cell_union);
+  ~S2MinDistanceCellUnionTarget() override;
+
+  // Specifies that the distances should be computed by examining every cell
+  // in the S2CellIndex (for testing and debugging purposes).
+  //
+  // DEFAULT: false
+  bool use_brute_force() const;
+  void set_use_brute_force(bool use_brute_force);
+
+  // Note that set_max_error() should not be called directly by clients; it is
+  // used internally by the S2Closest*Query implementations.
+  bool set_max_error(const S1ChordAngle& max_error) override;
+
+  S2Cap GetCapBound() final;
+  bool UpdateMinDistance(const S2Point& p, S2MinDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Point& v0, const S2Point& v1,
+                         S2MinDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Cell& cell,
+                         S2MinDistance* min_dist) final;
+  bool VisitContainingShapes(const S2ShapeIndex& query_index,
+                             const ShapeVisitor& visitor) final;
+
+ private:
+  bool UpdateMinDistance(S2MinDistanceTarget* target, S2MinDistance* min_dist);
+
+  S2CellUnion cell_union_;
+  S2CellIndex index_;
+  std::unique_ptr<S2ClosestCellQuery> query_;
+};
+
+// An S2DistanceTarget subtype for computing the minimum distance to an
+// S2ShapeIndex (a collection of points, polylines, and/or polygons).
+//
+// Note that ShapeIndexTarget has its own options:
+//
+//   include_interiors()
+//     - specifies that distances are measured to the boundary and interior
+//       of polygons in the S2ShapeIndex.  (If set to false, distance is
+//       measured to the polygon boundary only.)
+//       DEFAULT: true.
+//
+//   brute_force()
+//     - specifies that the distances should be computed by examining every
+//       edge in the S2ShapeIndex (for testing and debugging purposes).
+//       DEFAULT: false.
+//
+// These options are specified independently of the corresponding
+// S2ClosestEdgeQuery options.  For example, if include_interiors is true for
+// a ShapeIndexTarget but false for the S2ClosestEdgeQuery where the target
+// is used, then distances will be measured from the boundary of one
+// S2ShapeIndex to the boundary and interior of the other.
+//
+// Note that when the distance to a ShapeIndexTarget is zero because the
+// target intersects the interior of the query index, you can find a point
+// that achieves this zero distance by calling the VisitContainingShapes()
+// method directly.  For example:
+//
+//   S2ClosestEdgeQuery::ShapeIndexTarget target(&target_index);
+//   target.VisitContainingShapes(
+//       query_index, [](S2Shape* containing_shape,
+//                       const S2Point& target_point) {
+//         ... do something with "target_point" ...
+//         return false;  // Terminate search
+//       }));
+class S2MinDistanceShapeIndexTarget : public S2MinDistanceTarget {
+ public:
+  explicit S2MinDistanceShapeIndexTarget(const S2ShapeIndex* index);
+  ~S2MinDistanceShapeIndexTarget() override;
+
+  // Specifies that distance will be measured to the boundary and interior
+  // of polygons in the S2ShapeIndex rather than to polygon boundaries only.
+  //
+  // DEFAULT: true
+  bool include_interiors() const;
+  void set_include_interiors(bool include_interiors);
+
+  // Specifies that the distances should be computed by examining every edge
+  // in the S2ShapeIndex (for testing and debugging purposes).
+  //
+  // DEFAULT: false
+  bool use_brute_force() const;
+  void set_use_brute_force(bool use_brute_force);
+
+  // Note that set_max_error() should not be called directly by clients; it is
+  // used internally by the S2Closest*Query implementations.
+  bool set_max_error(const S1ChordAngle& max_error) override;
+
+  S2Cap GetCapBound() final;
+  bool UpdateMinDistance(const S2Point& p, S2MinDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Point& v0, const S2Point& v1,
+                         S2MinDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Cell& cell,
+                         S2MinDistance* min_dist) final;
+  bool VisitContainingShapes(const S2ShapeIndex& query_index,
+                             const ShapeVisitor& visitor) final;
+
+ private:
+  bool UpdateMinDistance(S2MinDistanceTarget* target, S2MinDistance* min_dist);
+
+  const S2ShapeIndex* index_;
+  std::unique_ptr<S2ClosestEdgeQuery> query_;
+};
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+inline S2MinDistance S2MinDistance::Zero() {
+  return S2MinDistance(S1ChordAngle::Zero());
+}
+
+inline S2MinDistance S2MinDistance::Infinity() {
+  return S2MinDistance(S1ChordAngle::Infinity());
+}
+
+inline S2MinDistance S2MinDistance::Negative() {
+  return S2MinDistance(S1ChordAngle::Negative());
+}
+
+inline S2MinDistance operator-(S2MinDistance x, S1ChordAngle delta) {
+  return S2MinDistance(S1ChordAngle(x) - delta);
+}
+
+inline S1ChordAngle S2MinDistance::GetChordAngleBound() const {
+  return PlusError(GetS1AngleConstructorMaxError());
+}
+
+inline bool S2MinDistance::UpdateMin(const S2MinDistance& dist) {
+  if (dist < *this) {
+    *this = dist;
+    return true;
+  }
+  return false;
+}
+
+inline S2MinDistancePointTarget::S2MinDistancePointTarget(const S2Point& point)
+    : point_(point) {
+}
+
+inline S2MinDistanceEdgeTarget::S2MinDistanceEdgeTarget(const S2Point& a,
+                                                        const S2Point& b)
+    : a_(a), b_(b) {
+}
+
+#endif  // S2_S2MIN_DISTANCE_TARGETS_H_