@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,265 @@
+// Copyright 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/s2max_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/s2edge_distances.h"
+#include "s2/s2furthest_edge_query.h"
+#include "s2/s2shape_index_region.h"
+#include "s2/s2text_format.h"
+
+//////////////////   Point Target   ////////////////////
+
+// This method returns an S2Cap that bounds the antipode of the target.  (This
+// is the set of points whose S2MaxDistance to the target is
+// S2MaxDistance::Zero().)
+S2Cap S2MaxDistancePointTarget::GetCapBound() {
+  return S2Cap(-point_, S1ChordAngle::Zero());
+}
+
+bool S2MaxDistancePointTarget::UpdateMinDistance(
+    const S2Point& p, S2MaxDistance* min_dist) {
+  return min_dist->UpdateMin(S2MaxDistance(S1ChordAngle(p, point_)));
+}
+
+bool S2MaxDistancePointTarget::UpdateMinDistance(
+    const S2Point& v0, const S2Point& v1, S2MaxDistance* min_dist) {
+  S1ChordAngle dist(*min_dist);
+  if (S2::UpdateMaxDistance(point_, v0, v1, &dist)) {
+    min_dist->UpdateMin(S2MaxDistance(dist));
+    return true;
+  }
+  return false;
+}
+
+bool S2MaxDistancePointTarget::UpdateMinDistance(
+    const S2Cell& cell, S2MaxDistance* min_dist) {
+  return min_dist->UpdateMin(S2MaxDistance(cell.GetMaxDistance(point_)));
+}
+
+bool S2MaxDistancePointTarget::VisitContainingShapes(
+    const S2ShapeIndex& index, const ShapeVisitor& visitor) {
+  // For furthest points, we visit the polygons whose interior contains the
+  // antipode of the target point.  (These are the polygons whose
+  // S2MaxDistance to the target is S2MaxDistance::Zero().)
+  return MakeS2ContainsPointQuery(&index).VisitContainingShapes(
+      -point_, [this, &visitor](S2Shape* shape) {
+        return visitor(shape, point_);
+      });
+}
+
+//////////////////   Edge Target   ////////////////////
+
+// This method returns an S2Cap that bounds the antipode of the target.  (This
+// is the set of points whose S2MaxDistance to the target is
+// S2MaxDistance::Zero().)
+S2Cap S2MaxDistanceEdgeTarget::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 S2MaxDistanceEdgeTarget::UpdateMinDistance(
+    const S2Point& p, S2MaxDistance* min_dist) {
+  S1ChordAngle dist(*min_dist);
+  if (S2::UpdateMaxDistance(p, a_, b_, &dist)) {
+    min_dist->UpdateMin(S2MaxDistance(dist));
+    return true;
+  }
+  return false;
+}
+
+bool S2MaxDistanceEdgeTarget::UpdateMinDistance(
+    const S2Point& v0, const S2Point& v1, S2MaxDistance* min_dist) {
+  S1ChordAngle dist(*min_dist);
+  if (S2::UpdateEdgePairMaxDistance(a_, b_, v0, v1, &dist)) {
+    min_dist->UpdateMin(S2MaxDistance(dist));
+    return true;
+  }
+  return false;
+}
+
+bool S2MaxDistanceEdgeTarget::UpdateMinDistance(
+    const S2Cell& cell, S2MaxDistance* min_dist) {
+  return min_dist->UpdateMin(S2MaxDistance(cell.GetMaxDistance(a_, b_)));
+}
+
+bool S2MaxDistanceEdgeTarget::VisitContainingShapes(
+    const S2ShapeIndex& index, const ShapeVisitor& visitor) {
+  // We only need to test one edge point.  That is because the method *must*
+  // visit a polygon if it fully contains the target, and *is allowed* to
+  // visit a polygon if it intersects the target.  If the tested vertex is not
+  // contained, we know the full edge is not contained; if the tested vertex is
+  // contained, then the edge either is fully contained (must be visited) or it
+  // intersects (is allowed to be visited).  We visit the center of the edge so
+  // that edge AB gives identical results to BA.
+  S2MaxDistancePointTarget target((a_ + b_).Normalize());
+  return target.VisitContainingShapes(index, visitor);
+}
+
+//////////////////   Cell Target   ////////////////////
+
+// This method returns an S2Cap that bounds the antipode of the target.  (This
+// is the set of points whose S2MaxDistance to the target is
+// S2MaxDistance::Zero().)
+S2Cap S2MaxDistanceCellTarget::GetCapBound() {
+  S2Cap cap = cell_.GetCapBound();
+  return S2Cap(-cap.center(), cap.radius());
+}
+
+bool S2MaxDistanceCellTarget::UpdateMinDistance(
+    const S2Point& p, S2MaxDistance* min_dist) {
+  return min_dist->UpdateMin(S2MaxDistance(cell_.GetMaxDistance(p)));
+}
+
+bool S2MaxDistanceCellTarget::UpdateMinDistance(
+    const S2Point& v0, const S2Point& v1, S2MaxDistance* min_dist) {
+  return min_dist->UpdateMin(S2MaxDistance(cell_.GetMaxDistance(v0, v1)));
+}
+
+bool S2MaxDistanceCellTarget::UpdateMinDistance(
+    const S2Cell& cell, S2MaxDistance* min_dist) {
+  return min_dist->UpdateMin(S2MaxDistance(cell_.GetMaxDistance(cell)));
+}
+
+bool S2MaxDistanceCellTarget::VisitContainingShapes(
+    const S2ShapeIndex& index, const ShapeVisitor& visitor) {
+  // We only need to check one point here - cell center is simplest.
+  // See comment at S2MaxDistanceEdgeTarget::VisitContainingShapes.
+  S2MaxDistancePointTarget target(cell_.GetCenter());
+  return target.VisitContainingShapes(index, visitor);
+}
+
+//////////////////   Index Target   ////////////////////
+
+S2MaxDistanceShapeIndexTarget::S2MaxDistanceShapeIndexTarget(
+    const S2ShapeIndex* index)
+    : index_(index), query_(absl::make_unique<S2FurthestEdgeQuery>(index)) {
+}
+
+S2MaxDistanceShapeIndexTarget::~S2MaxDistanceShapeIndexTarget() {
+}
+
+bool S2MaxDistanceShapeIndexTarget::include_interiors() const {
+  return query_->options().include_interiors();
+}
+
+void S2MaxDistanceShapeIndexTarget::set_include_interiors(
+    bool include_interiors) {
+  query_->mutable_options()->set_include_interiors(include_interiors);
+}
+
+bool S2MaxDistanceShapeIndexTarget::use_brute_force() const {
+  return query_->options().use_brute_force();
+}
+
+void S2MaxDistanceShapeIndexTarget::set_use_brute_force(
+    bool use_brute_force) {
+  query_->mutable_options()->set_use_brute_force(use_brute_force);
+}
+
+bool S2MaxDistanceShapeIndexTarget::set_max_error(
+    const S1ChordAngle& max_error) {
+  query_->mutable_options()->set_max_error(max_error);
+  return true;  // Indicates that we may return suboptimal results.
+}
+
+// This method returns an S2Cap that bounds the antipode of the target.  (This
+// is the set of points whose S2MaxDistance to the target is
+// S2MaxDistance::Zero().)
+S2Cap S2MaxDistanceShapeIndexTarget::GetCapBound() {
+  S2Cap cap = MakeS2ShapeIndexRegion(index_).GetCapBound();
+  return S2Cap(-cap.center(), cap.radius());
+}
+
+bool S2MaxDistanceShapeIndexTarget::UpdateMinDistance(
+    const S2Point& p, S2MaxDistance* min_dist) {
+  query_->mutable_options()->set_min_distance(S1ChordAngle(*min_dist));
+  S2FurthestEdgeQuery::PointTarget target(p);
+  S2FurthestEdgeQuery::Result r = query_->FindFurthestEdge(&target);
+  if (r.shape_id() < 0) {
+    return false;
+  }
+  *min_dist = S2MaxDistance(r.distance());
+  return true;
+}
+
+bool S2MaxDistanceShapeIndexTarget::UpdateMinDistance(
+    const S2Point& v0, const S2Point& v1, S2MaxDistance* min_dist) {
+  query_->mutable_options()->set_min_distance(S1ChordAngle(*min_dist));
+  S2FurthestEdgeQuery::EdgeTarget target(v0, v1);
+  S2FurthestEdgeQuery::Result r = query_->FindFurthestEdge(&target);
+  if (r.shape_id() < 0) return false;
+  *min_dist = S2MaxDistance(r.distance());
+  return true;
+}
+
+bool S2MaxDistanceShapeIndexTarget::UpdateMinDistance(
+    const S2Cell& cell, S2MaxDistance* min_dist) {
+  query_->mutable_options()->set_min_distance(S1ChordAngle(*min_dist));
+  S2FurthestEdgeQuery::CellTarget target(cell);
+  S2FurthestEdgeQuery::Result r = query_->FindFurthestEdge(&target);
+  if (r.shape_id() < 0) return false;
+  *min_dist = S2MaxDistance(r.distance());
+  return true;
+}
+
+// For target types consisting of multiple connected components (such as
+// S2MaxDistanceShapeIndexTarget), this method should return the
+// polygons containing the antipodal reflection of *any* connected
+// component.  (It is sufficient to test containment of one vertex per
+// connected component, since the API allows us to also return any polygon
+// whose boundary has S2MaxDistance::Zero() to the target.)
+bool S2MaxDistanceShapeIndexTarget::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;
+      S2MaxDistancePointTarget target(shape->chain_edge(c, 0).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;
+      S2MaxDistancePointTarget target(ref.point);
+      if (!target.VisitContainingShapes(query_index, visitor)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}

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

@@ -0,0 +1,241 @@
+// Copyright 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.
+//
+
+// This file defines a collection of classes that are useful for computing
+// maximum distances on the sphere.  Their purpose is to allow code to be
+// shared among the various query classes that find remote geometry, such as
+// S2FurthestPointQuery and S2FurthestEdgeQuery.
+
+#ifndef S2_S2MAX_DISTANCE_TARGETS_H_
+#define S2_S2MAX_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/s2distance_target.h"
+#include "s2/s2edge_distances.h"
+#include "s2/s2shape_index.h"
+
+class S2FurthestEdgeQuery;
+
+// S2MaxDistance is a class that allows maximum distances to be computed using
+// a minimum distance algorithm.  Specifically, S2MaxDistance(x) represents the
+// supplementary distance (Pi - x).  This has the effect of inverting the sort
+// order, i.e.
+//
+//  (S2MaxDistance(x) < S2MaxDistance(y))  <=>  (Pi - x < Pi - y)  <=>  (x > y)
+//
+// All other operations are implemented similarly (using the supplementary
+// distance Pi - x).  For example, S2MaxDistance(x) - S2MaxDistance(y) ==
+// S2MaxDistance(x + y).
+class S2MaxDistance {
+ public:
+  using Delta = S1ChordAngle;
+
+  S2MaxDistance() : distance_() {}
+  explicit S2MaxDistance(S1ChordAngle x) : distance_(x) {}
+  explicit operator S1ChordAngle() const { return distance_; }
+  static S2MaxDistance Zero();
+  static S2MaxDistance Infinity();
+  static S2MaxDistance Negative();
+
+  friend bool operator==(S2MaxDistance x, S2MaxDistance y);
+  friend bool operator<(S2MaxDistance x, S2MaxDistance y);
+
+  friend S2MaxDistance operator-(S2MaxDistance x, S1ChordAngle delta);
+  S1ChordAngle GetChordAngleBound() const;
+
+  // If (dist < *this), updates *this and returns true (used internally).
+  bool UpdateMin(const S2MaxDistance& dist);
+
+ private:
+  S1ChordAngle distance_;
+};
+
+// S2MaxDistanceTarget represents a geometric object to which maximum distances
+// on the sphere are measured.
+//
+// Subtypes are defined below for measuring the distance to a point, an edge,
+// an S2Cell, or an S2ShapeIndex (an arbitrary collection of geometry).
+using S2MaxDistanceTarget = S2DistanceTarget<S2MaxDistance>;
+
+// An S2DistanceTarget subtype for computing the maximum distance to a point.
+class S2MaxDistancePointTarget : public S2MaxDistanceTarget {
+ public:
+  explicit S2MaxDistancePointTarget(const S2Point& point);
+
+  S2Cap GetCapBound() final;
+  bool UpdateMinDistance(const S2Point& p, S2MaxDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Point& v0, const S2Point& v1,
+                         S2MaxDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Cell& cell,
+                         S2MaxDistance* min_dist) final;
+  bool VisitContainingShapes(const S2ShapeIndex& index,
+                             const ShapeVisitor& visitor) final;
+
+ private:
+  S2Point point_;
+};
+
+// An S2DistanceTarget subtype for computing the maximum distance to an edge.
+class S2MaxDistanceEdgeTarget : public S2MaxDistanceTarget {
+ public:
+  explicit S2MaxDistanceEdgeTarget(const S2Point& a, const S2Point& b);
+
+  S2Cap GetCapBound() final;
+  bool UpdateMinDistance(const S2Point& p, S2MaxDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Point& v0, const S2Point& v1,
+                         S2MaxDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Cell& cell,
+                         S2MaxDistance* min_dist) final;
+  bool VisitContainingShapes(const S2ShapeIndex& index,
+                             const ShapeVisitor& visitor) final;
+
+ private:
+  S2Point a_, b_;
+};
+
+// An S2DistanceTarget subtype for computing the maximum distance to an S2Cell
+// (including the interior of the cell).
+class S2MaxDistanceCellTarget : public S2MaxDistanceTarget {
+ public:
+  explicit S2MaxDistanceCellTarget(const S2Cell& cell);
+  S2Cap GetCapBound() final;
+  bool UpdateMinDistance(const S2Point& p, S2MaxDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Point& v0, const S2Point& v1,
+                         S2MaxDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Cell& cell,
+                         S2MaxDistance* min_dist) final;
+  bool VisitContainingShapes(const S2ShapeIndex& index,
+                             const ShapeVisitor& visitor) final;
+
+ private:
+  S2Cell cell_;
+};
+
+// An S2DistanceTarget subtype for computing the maximum 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
+// S2FurthestEdgeQuery options.  For example, if include_interiors is true for
+// a ShapeIndexTarget but false for the S2FurthestEdgeQuery where the target
+// is used, then distances will be measured from the boundary of one
+// S2ShapeIndex to the boundary and interior of the other.
+//
+class S2MaxDistanceShapeIndexTarget : public S2MaxDistanceTarget {
+ public:
+  explicit S2MaxDistanceShapeIndexTarget(const S2ShapeIndex* index);
+  ~S2MaxDistanceShapeIndexTarget() 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);
+
+  bool set_max_error(const S1ChordAngle& max_error) override;
+  S2Cap GetCapBound() final;
+  bool UpdateMinDistance(const S2Point& p, S2MaxDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Point& v0, const S2Point& v1,
+                         S2MaxDistance* min_dist) final;
+  bool UpdateMinDistance(const S2Cell& cell,
+                         S2MaxDistance* min_dist) final;
+  bool VisitContainingShapes(const S2ShapeIndex& query_index,
+                             const ShapeVisitor& visitor) final;
+
+ private:
+  const S2ShapeIndex* index_;
+  std::unique_ptr<S2FurthestEdgeQuery> query_;
+};
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+inline S2MaxDistance S2MaxDistance::Zero() {
+  return S2MaxDistance(S1ChordAngle::Straight());
+}
+
+inline S2MaxDistance S2MaxDistance::Infinity() {
+  return S2MaxDistance(S1ChordAngle::Negative());
+}
+
+inline S2MaxDistance S2MaxDistance::Negative() {
+  return S2MaxDistance(S1ChordAngle::Infinity());
+}
+
+inline bool operator==(S2MaxDistance x, S2MaxDistance y) {
+  return x.distance_ == y.distance_;
+}
+
+inline bool operator<(S2MaxDistance x, S2MaxDistance y) {
+  return x.distance_ > y.distance_;
+}
+
+inline S2MaxDistance operator-(S2MaxDistance x, S1ChordAngle delta) {
+  return S2MaxDistance(x.distance_ + delta);
+}
+
+inline S1ChordAngle S2MaxDistance::GetChordAngleBound() const {
+  return S1ChordAngle::Straight() - distance_;
+}
+
+inline bool S2MaxDistance::UpdateMin(const S2MaxDistance& dist) {
+  if (dist < *this) {
+    *this = dist;
+    return true;
+  }
+  return false;
+}
+
+inline S2MaxDistancePointTarget::S2MaxDistancePointTarget(const S2Point& point)
+    : point_(point) {
+}
+
+inline S2MaxDistanceEdgeTarget::S2MaxDistanceEdgeTarget(const S2Point& a,
+                                                        const S2Point& b)
+    : a_(a), b_(b) {
+  a_.Normalize();
+  b_.Normalize();
+}
+
+inline S2MaxDistanceCellTarget::S2MaxDistanceCellTarget(const S2Cell& cell)
+    : cell_(cell) {
+}
+
+#endif  // S2_S2MAX_DISTANCE_TARGETS_H_