@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,69 @@
+// Copyright 2005 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)
+//
+// The S2 library defines extra validity checks throughout the code that can
+// optionally be enabled or disabled.  By default, these validity checks are
+// enabled in debug-mode builds (including fastbuild) and disabled in
+// optimized builds.
+//
+// There are two ways to change the default behavior:
+//
+//  - The command line --s2debug flag, which changes the global default.
+//
+//  - The S2Debug enum, which allows validity checks to be enabled or disabled
+//    for specific objects (e.g., an S2Polygon).
+//
+// If you want to intentionally create invalid geometry (e.g., in a test), the
+// S2Debug enum is preferable.  For example, to create an invalid S2Polygon,
+// you can do this:
+//
+//   S2Polygon invalid;
+//   invalid.set_s2debug_override(S2Debug::DISABLE);
+//
+// There is also a convenience constructor:
+//
+//   vector<unique_ptr<S2Loop>> loops = ...;
+//   S2Polygon invalid(loops, S2Debug::DISABLE);
+//
+// There are a few checks that cannot be disabled this way (e.g., internal
+// functions that require S2Points to be unit length).  If you absolutely need
+// to disable these checks, you can set FLAGS_s2debug for the duration of a
+// specific test like this:
+//
+// TEST(MyClass, InvalidGeometry) {
+//   FLAGS_s2debug = false;  // Automatically restored between tests
+//   ...
+// }
+
+#ifndef S2_S2DEBUG_H_
+#define S2_S2DEBUG_H_
+
+#include "s2/base/commandlineflags.h"
+#include "s2/base/integral_types.h"
+
+// Command line flag that enables extra validity checking throughout the S2
+// code.  It is turned on by default in debug-mode builds.
+S2_DECLARE_bool(s2debug);
+
+// Class that allows the --s2debug validity checks to be enabled or disabled
+// for specific objects (e.g., see S2Polygon).
+enum class S2Debug : uint8 {
+  ALLOW,    // Validity checks are controlled by --s2debug
+  DISABLE   // No validity checks even when --s2debug is true
+};
+
+#endif  // S2_S2DEBUG_H_

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

@@ -0,0 +1,165 @@
+// 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)
+
+#ifndef S2_S2DISTANCE_TARGET_H_
+#define S2_S2DISTANCE_TARGET_H_
+
+#include "s2/s2cap.h"
+#include "s2/s2cell.h"
+#include "s2/s2shape_index.h"
+
+// S2DistanceTarget represents a geometric object to which distances are
+// measured.  For example, there are subtypes for measuring distances to a
+// point, an edge, or to an S2ShapeIndex (an arbitrary collection of
+// geometry).  S2DistanceTarget objects are provided for the benefit of
+// classes that measure distances and/or find nearby geometry, such as
+// S2ClosestEdgeQuery, S2ClosestPointQuery, and S2ClosestCellQuery.
+//
+// Implementations do *not* need to be thread-safe.  They may cache data or
+// allocate temporary data structures in order to improve performance.  For
+// this reason, S2DistanceTarget objects are typically passed as pointers
+// rather than as const references.
+//
+// The Distance template argument is used to represent distances.  Usually
+// this type is a thin wrapper around S1ChordAngle, but another distance type
+// may be substituted as long as it implements the API below.  This can be
+// used to change the comparison function (e.g., to find the furthest edges
+// from the target), to get more accuracy, or to measure non-spheroidal
+// distances (e.g., using the WGS84 ellipsoid).
+//
+// The Distance concept is as follows:
+//
+// class Distance {
+//  public:
+//   // Default and copy constructors, assignment operator:
+//   Distance();
+//   Distance(const Distance&);
+//   Distance& operator=(const Distance&);
+//
+//   // Factory methods:
+//   static Distance Zero();      // Returns a zero distance.
+//   static Distance Infinity();  // Larger than any valid distance.
+//   static Distance Negative();  // Smaller than any valid distance.
+//
+//   // Comparison operators:
+//   friend bool operator==(Distance x, Distance y);
+//   friend bool operator<(Distance x, Distance y);
+//
+//   // Delta represents the positive difference between two distances.
+//   // It is used together with operator-() to implement Options::max_error().
+//   // Typically Distance::Delta is simply S1ChordAngle.
+//   class Delta {
+//    public:
+//     Delta();
+//     Delta(const Delta&);
+//     Delta& operator=(const Delta&);
+//     friend bool operator==(Delta x, Delta y);
+//     static Delta Zero();
+//   };
+//
+//   // Subtraction operator.  Note that the second argument represents a
+//   // delta between two distances.  This distinction is important for
+//   // classes that compute maximum distances (e.g., S2FurthestEdgeQuery).
+//   friend Distance operator-(Distance x, Delta delta);
+//
+//   // Method that returns an upper bound on the S1ChordAngle corresponding
+//   // to this Distance (needed to implement Options::max_distance
+//   // efficiently).  For example, if Distance measures WGS84 ellipsoid
+//   // distance then the corresponding angle needs to be 0.56% larger.
+//   S1ChordAngle GetChordAngleBound() const;
+// };
+template <class Distance>
+class S2DistanceTarget {
+ public:
+  using Delta = typename Distance::Delta;
+
+  virtual ~S2DistanceTarget() {}
+
+  // Returns an S2Cap that bounds the set of points whose distance to the
+  // target is Distance::Zero().
+  virtual S2Cap GetCapBound() = 0;
+
+  // If the distance to the point "p" "min_dist", then updates "min_dist" and
+  // returns true.  Otherwise returns false.
+  virtual bool UpdateMinDistance(const S2Point& p, Distance* min_dist) = 0;
+
+  // If the distance to the edge (v0, v1) is less than "min_dist", then
+  // updates "min_dist" and returns true.  Otherwise returns false.
+  virtual bool UpdateMinDistance(const S2Point& v0, const S2Point& v1,
+                                 Distance* min_dist) = 0;
+
+  // If the distance to the given S2Cell (including its interior) is less
+  // than "min_dist", then updates "min_dist" and returns true.  Otherwise
+  // returns false.
+  virtual bool UpdateMinDistance(const S2Cell& cell, Distance* min_dist) = 0;
+
+  // Finds all polygons in the given "query_index" that completely contain a
+  // connected component of the target geometry.  (For example, if the
+  // target consists of 10 points, this method finds polygons that contain
+  // any of those 10 points.)  For each such polygon, "visitor" is called
+  // with the S2Shape of the polygon along with a point of the target
+  // geometry that is contained by that polygon.
+  //
+  // Optionally, any polygon that intersects the target geometry may also be
+  // returned.  In other words, this method returns all polygons that
+  // contain any connected component of the target, along with an arbitrary
+  // subset of the polygons that intersect the target.
+  //
+  // For example, suppose that "query_index" contains two abutting polygons
+  // A and B.  If the target consists of two points "a" contained by A and
+  // "b" contained by B, then both A and B are returned.  But if the target
+  // consists of the edge "ab", then any subset of {A, B} could be returned
+  // (because both polygons intersect the target but neither one contains
+  // the edge "ab").
+  //
+  // If "visitor" returns false, this method terminates early and returns
+  // false as well.  Otherwise returns true.
+  //
+  // NOTE(ericv): This method exists only for the purpose of implementing
+  // S2ClosestEdgeQuery::Options::include_interiors() efficiently.  Its API is
+  // unlikely to be useful for other purposes.
+  using ShapeVisitor = std::function<bool (S2Shape* containing_shape,
+                                           const S2Point& target_point)>;
+  virtual bool VisitContainingShapes(const S2ShapeIndex& query_index,
+                                     const ShapeVisitor& visitor) = 0;
+
+  // Specifies that whenever one of the UpdateMinDistance() methods above
+  // returns "true", the returned distance is allowed to be up to "max_error"
+  // larger than the true minimum distance.  In other words, it gives this
+  // target object permission to terminate its distance calculation as soon as
+  // it has determined that (1) the minimum distance is less than "min_dist"
+  // and (2) the best possible further improvement is less than "max_error".
+  //
+  // If the target takes advantage of "max_error" to optimize its distance
+  // calculation, this method must return "true".  (Most target types can use
+  // the default implementation which simply returns false.)
+  virtual bool set_max_error(const Delta& max_error) { return false; }
+
+  // The following method is provided as a convenience for classes that
+  // compute distances to a collection of indexed geometry, such as
+  // S2ClosestPointQuery, S2ClosestEdgeQuery, and S2ClosestCellQuery.  It
+  // returns the maximum number of indexed objects for which it is faster to
+  // compute the distance by brute force (e.g., by testing every edge) rather
+  // than by using an index.  (The appropriate value is different for each
+  // index type and can be estimated for a given (distance target, index type)
+  // pair by running benchmarks.)
+  //
+  // By default this method returns -1, indicating that it is not implemented.
+  virtual int max_brute_force_index_size() const { return -1; }
+};
+
+#endif  // S2_S2DISTANCE_TARGET_H_

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

@@ -0,0 +1,52 @@
+// 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/s2earth.h"
+
+#include <cmath>
+#include <algorithm>
+
+namespace {
+
+// http://en.wikipedia.org/wiki/Haversine_formula
+// Haversine(x) has very good numerical stability around zero.
+// Haversine(x) == (1-cos(x))/2 == sin(x/2)^2; must be implemented with the
+// second form to reap the numerical benefits.
+double Haversine(const double radians) {
+  const double sinHalf = sin(radians / 2);
+  return sinHalf * sinHalf;
+}
+
+}  // namespace
+
+double S2Earth::ToLongitudeRadians(const util::units::Meters& distance,
+                                   double latitude_radians) {
+  double scalar = cos(latitude_radians);
+  if (scalar == 0) return M_PI * 2;
+  return std::min(ToRadians(distance) / scalar, M_PI * 2);
+}
+
+// Sourced from http://www.movable-type.co.uk/scripts/latlong.html.
+S1Angle S2Earth::GetInitialBearing(const S2LatLng& a, const S2LatLng& b) {
+  const double lat1 = a.lat().radians();
+  const double cosLat2 = cos(b.lat().radians());
+  const double lat_diff = b.lat().radians() - a.lat().radians();
+  const double lng_diff = b.lng().radians() - a.lng().radians();
+
+  const double x =
+      sin(lat_diff) + sin(lat1) * cosLat2 * 2 * Haversine(lng_diff);
+  const double y = sin(lng_diff) * cosLat2;
+  return S1Angle::Radians(atan2(y, x));
+}

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

@@ -0,0 +1,268 @@
+// Copyright 2005 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)
+//
+// The earth modeled as a sphere.  There are lots of convenience
+// functions so that it doesn't take 2 lines of code just to do
+// a single conversion.
+
+#ifndef S2_S2EARTH_H_
+#define S2_S2EARTH_H_
+
+#include "s2/s1angle.h"
+#include "s2/s1chord_angle.h"
+#include "s2/s2latlng.h"
+#include "s2/s2point.h"
+#include "s2/util/units/length-units.h"
+
+class S2Earth {
+ public:
+  // These functions convert between distances on the unit sphere
+  // (expressed as angles subtended from the sphere's center) and
+  // distances on the Earth's surface.  This is possible only because
+  // the Earth is modeled as a sphere; otherwise a given angle would
+  // correspond to a range of distances depending on where the
+  // corresponding line segment was located.
+  //
+  // Note that you will lose precision if you use the ToDistance() method,
+  // since Meters is a single-precision type.  If you need more precision,
+  // use one of the direct conversion methods below.
+  inline static S1Angle ToAngle(const util::units::Meters& distance);
+  inline static S1ChordAngle ToChordAngle(const util::units::Meters& distance);
+  inline static util::units::Meters ToDistance(const S1Angle& angle);
+  inline static util::units::Meters ToDistance(const S1ChordAngle& cangle);
+
+  // Convenience functions.  These methods also return a double-precision
+  // result, unlike the generic ToDistance() method.
+  inline static double ToRadians(const util::units::Meters& distance);
+  inline static double ToMeters(const S1Angle& angle);
+  inline static double ToMeters(const S1ChordAngle& cangle);
+  inline static double ToKm(const S1Angle& angle);
+  inline static double ToKm(const S1ChordAngle& cangle);
+  inline static double KmToRadians(double km);
+  inline static double RadiansToKm(double radians);
+  inline static double MetersToRadians(double meters);
+  inline static double RadiansToMeters(double radians);
+
+  // These functions convert between areas on the unit sphere
+  // (as returned by the S2 library) and areas on the Earth's surface.
+  // Note that the area of a region on the unit sphere is equal to the
+  // solid angle it subtends from the sphere's center (measured in steradians).
+  inline static double SquareKmToSteradians(double km2);
+  inline static double SquareMetersToSteradians(double m2);
+  inline static double SteradiansToSquareKm(double steradians);
+  inline static double SteradiansToSquareMeters(double steradians);
+
+  // Convenience function for the frequent case where you need to call
+  // ToRadians in order to convert an east-west distance on the globe to
+  // radians. The output is a function of how close to the poles you are
+  // (i.e. at the bulge at the equator, one unit of longitude represents a
+  // much farther distance). The function will never return more than 2*PI
+  // radians, even if you're trying to go 100 million miles west at the north
+  // pole.
+  static double ToLongitudeRadians(const util::units::Meters& distance,
+                                   double latitude_radians);
+
+  // Computes the initial bearing from a to b. This is the bearing an observer
+  // at point a has when facing point b. A bearing of 0 degrees is north, and it
+  // increases clockwise (90 degrees is east, etc).
+  // If a == b, a == -b, or a is one of the Earths' poles, the return value is
+  // undefined.
+  static S1Angle GetInitialBearing(const S2LatLng& a, const S2LatLng& b);
+
+  // Returns the distance between two points.  Example:
+  // double miles = Miles(geostore::S2Earth::GetDistance(a, b)).value();
+  //
+  // Note that these methods only have single-precision accuracy, since
+  // Meters is a single-precision type.  If you ned more precision, use one
+  // of the methods below.
+  inline static util::units::Meters GetDistance(const S2Point& a,
+                                                const S2Point& b);
+  inline static util::units::Meters GetDistance(const S2LatLng& a,
+                                                const S2LatLng& b);
+
+  // Convenience functions.  These methods also return a double-precision
+  // result, unlike the generic GetDistance() method.
+  inline static double GetDistanceKm(const S2Point& a, const S2Point& b);
+  inline static double GetDistanceKm(const S2LatLng& a, const S2LatLng& b);
+  inline static double GetDistanceMeters(const S2Point& a, const S2Point& b);
+  inline static double GetDistanceMeters(const S2LatLng& a, const S2LatLng& b);
+
+  // Returns the Earth's mean radius, which is the radius of the equivalent
+  // sphere with the same surface area.  According to NASA, this value is
+  // 6371.01 +/- 0.02 km.  The equatorial radius is 6378.136 km, and the polar
+  // radius is 6356.752 km.  They differ by one part in 298.257.
+  //
+  // Reference: http://ssd.jpl.nasa.gov/phys_props_earth.html, which quotes
+  // Yoder, C.F. 1995. "Astrometric and Geodetic Properties of Earth and the
+  // Solar System" in Global Earth Physics, A Handbook of Physical Constants,
+  // AGU Reference Shelf 1, American Geophysical Union, Table 2.
+  inline static util::units::Meters Radius();
+
+  // Convenience functions.
+  inline static double RadiusKm();
+  inline static double RadiusMeters();
+
+  // Returns the altitude of the lowest known point on Earth. The lowest known
+  // point on Earth is the Challenger Deep with an altitude of -10898 meters
+  // above the surface of the spherical earth.
+  inline static util::units::Meters LowestAltitude();
+
+  // Convenience functions.
+  inline static double LowestAltitudeKm();
+  inline static double LowestAltitudeMeters();
+
+  // Returns the altitude of the highest known point on Earth. The highest
+  // known point on Earth is Mount Everest with an altitude of 8846 meters
+  // above the surface of the spherical earth.
+  inline static util::units::Meters HighestAltitude();
+
+  // Convenience functions.
+  inline static double HighestAltitudeKm();
+  inline static double HighestAltitudeMeters();
+};
+
+inline S1Angle S2Earth::ToAngle(const util::units::Meters& distance) {
+  return S1Angle::Radians(ToRadians(distance));
+}
+
+inline S1ChordAngle S2Earth::ToChordAngle(const util::units::Meters& distance) {
+  return S1ChordAngle(ToAngle(distance));
+}
+
+inline util::units::Meters S2Earth::ToDistance(const S1Angle& angle) {
+  return util::units::Meters(ToMeters(angle));
+}
+
+inline util::units::Meters S2Earth::ToDistance(const S1ChordAngle& cangle) {
+  return util::units::Meters(ToMeters(cangle));
+}
+
+inline double S2Earth::ToRadians(const util::units::Meters& distance) {
+  return distance.value() / RadiusMeters();
+}
+
+inline double S2Earth::ToMeters(const S1Angle& angle) {
+  return angle.radians() * RadiusMeters();
+}
+
+inline double S2Earth::ToKm(const S1Angle& angle) {
+  return angle.radians() * RadiusKm();
+}
+
+inline double S2Earth::ToMeters(const S1ChordAngle& cangle) {
+  return ToMeters(cangle.ToAngle());
+}
+
+inline double S2Earth::ToKm(const S1ChordAngle& cangle) {
+  return ToKm(cangle.ToAngle());
+}
+
+inline double S2Earth::KmToRadians(double km) {
+  return km / RadiusKm();
+}
+
+inline double S2Earth::RadiansToKm(double radians) {
+  return radians * RadiusKm();
+}
+
+inline double S2Earth::MetersToRadians(double meters) {
+  return meters / RadiusMeters();
+}
+
+inline double S2Earth::RadiansToMeters(double radians) {
+  return radians * RadiusMeters();
+}
+
+inline double S2Earth::SquareKmToSteradians(double km2) {
+  return km2 / (RadiusKm() * RadiusKm());
+}
+
+inline double S2Earth::SquareMetersToSteradians(double m2) {
+  return m2 / (RadiusMeters() * RadiusMeters());
+}
+
+inline double S2Earth::SteradiansToSquareKm(double steradians) {
+  return steradians * RadiusKm() * RadiusKm();
+}
+
+inline double S2Earth::SteradiansToSquareMeters(double steradians) {
+  return steradians * RadiusMeters() * RadiusMeters();
+}
+
+inline util::units::Meters S2Earth::GetDistance(const S2Point& a,
+                                                const S2Point& b) {
+  return ToDistance(S1Angle(a, b));
+}
+
+inline util::units::Meters S2Earth::GetDistance(const S2LatLng& a,
+                                                const S2LatLng& b) {
+  return ToDistance(a.GetDistance(b));
+}
+
+inline double S2Earth::GetDistanceKm(const S2Point& a, const S2Point& b) {
+  return RadiansToKm(a.Angle(b));
+}
+
+inline double S2Earth::GetDistanceKm(const S2LatLng& a, const S2LatLng& b) {
+  return ToKm(a.GetDistance(b));
+}
+
+inline double S2Earth::GetDistanceMeters(const S2Point& a, const S2Point& b) {
+  return RadiansToMeters(a.Angle(b));
+}
+
+inline double S2Earth::GetDistanceMeters(const S2LatLng& a, const S2LatLng& b) {
+  return ToMeters(a.GetDistance(b));
+}
+
+inline util::units::Meters S2Earth::Radius() {
+  return util::units::Meters(RadiusMeters());
+}
+
+inline double S2Earth::RadiusKm() {
+  return 0.001 * RadiusMeters();
+}
+
+inline double S2Earth::RadiusMeters() {
+  return 6371010.0;
+}
+
+inline util::units::Meters S2Earth::LowestAltitude() {
+  return util::units::Meters(LowestAltitudeMeters());
+}
+
+inline double S2Earth::LowestAltitudeKm() {
+  return 0.001 * LowestAltitudeMeters();
+}
+
+inline double S2Earth::LowestAltitudeMeters() {
+  return -10898;
+}
+
+inline util::units::Meters S2Earth::HighestAltitude() {
+  return util::units::Meters(HighestAltitudeMeters());
+}
+
+inline double S2Earth::HighestAltitudeKm() {
+  return 0.001 * HighestAltitudeMeters();
+}
+
+inline double S2Earth::HighestAltitudeMeters() {
+  return 8846;
+}
+
+#endif  // S2_S2EARTH_H_