@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,109 @@
+// 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)
+
+#include "s2/s2projections.h"
+
+#include <cmath>
+#include "s2/s2latlng.h"
+
+using std::fabs;
+
+namespace S2 {
+
+R2Point Projection::WrapDestination(const R2Point& a, const R2Point& b) const {
+  R2Point wrap = wrap_distance();
+  double x = b.x(), y = b.y();
+  // The code below ensures that "b" is unmodified unless wrapping is required.
+  if (wrap.x() > 0 && fabs(x - a.x()) > 0.5 * wrap.x()) {
+    x = a.x() + remainder(x - a.x(), wrap.x());
+  }
+  if (wrap.y() > 0 && fabs(y - a.y()) > 0.5 * wrap.y()) {
+    y = a.y() + remainder(y - a.y(), wrap.y());
+  }
+  return R2Point(x, y);
+}
+
+// Default implementation, suitable for any projection where edges are defined
+// as straight lines in the 2D projected space.
+R2Point Projection::Interpolate(double f,
+                                const R2Point& a, const R2Point& b) const {
+  return (1 - f) * a + f * b;
+}
+
+PlateCarreeProjection::PlateCarreeProjection(double x_scale)
+    : x_wrap_(2 * x_scale),
+      to_radians_(M_PI / x_scale),
+      from_radians_(x_scale / M_PI) {
+}
+
+R2Point PlateCarreeProjection::Project(const S2Point& p) const {
+  return FromLatLng(S2LatLng(p));
+}
+
+R2Point PlateCarreeProjection::FromLatLng(const S2LatLng& ll) const {
+  return R2Point(from_radians_ * ll.lng().radians(),
+                 from_radians_ * ll.lat().radians());
+}
+
+S2Point PlateCarreeProjection::Unproject(const R2Point& p) const {
+  return ToLatLng(p).ToPoint();
+}
+
+S2LatLng PlateCarreeProjection::ToLatLng(const R2Point& p) const {
+  return S2LatLng::FromRadians(to_radians_ * p.y(),
+                               to_radians_ * remainder(p.x(), x_wrap_));
+}
+
+R2Point PlateCarreeProjection::wrap_distance() const {
+  return R2Point(x_wrap_, 0);
+}
+
+MercatorProjection::MercatorProjection(double max_x)
+    : x_wrap_(2 * max_x),
+      to_radians_(M_PI / max_x),
+      from_radians_(max_x / M_PI) {
+}
+
+R2Point MercatorProjection::Project(const S2Point& p) const {
+  return FromLatLng(S2LatLng(p));
+}
+
+R2Point MercatorProjection::FromLatLng(const S2LatLng& ll) const {
+  // This formula is more accurate near zero than the log(tan()) version.
+  // Note that latitudes of +/- 90 degrees yield "y" values of +/- infinity.
+  double sin_phi = sin(ll.lat());
+  double y = 0.5 * log((1 + sin_phi) / (1 - sin_phi));
+  return R2Point(from_radians_ * ll.lng().radians(), from_radians_ * y);
+}
+
+S2Point MercatorProjection::Unproject(const R2Point& p) const {
+  return ToLatLng(p).ToPoint();
+}
+
+S2LatLng MercatorProjection::ToLatLng(const R2Point& p) const {
+  // This formula is more accurate near zero than the atan(exp()) version.
+  double x = to_radians_ * remainder(p.x(), x_wrap_);
+  double k = exp(2 * to_radians_ * p.y());
+  double y = std::isinf(k) ? M_PI_2 : asin((k - 1) / (k + 1));
+  return S2LatLng::FromRadians(y, x);
+}
+
+R2Point MercatorProjection::wrap_distance() const {
+  return R2Point(x_wrap_, 0);
+}
+
+}  // namespace S2

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

@@ -0,0 +1,161 @@
+// 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)
+//
+// Defines a few simple map projections.  (Clients that need more complex
+// projections should use a third-party library such as GeographicLib to
+// implement their own projection subtypes.)
+
+#ifndef S2_S2PROJECTIONS_H_
+#define S2_S2PROJECTIONS_H_
+
+#include "s2/r2.h"
+#include "s2/s2latlng.h"
+#include "s2/s2point.h"
+
+namespace S2 {
+
+// For the purposes of the S2 library, a projection is a function that maps
+// between S2Points and R2Points.  It can also define the coordinate wrapping
+// behavior along each axis.
+class Projection {
+ public:
+  virtual ~Projection() {}
+
+  // Converts a point on the sphere to a projected 2D point.
+  virtual R2Point Project(const S2Point& p) const = 0;
+
+  // Converts a projected 2D point to a point on the sphere.
+  //
+  // If wrapping is defined for a given axis (see below), then this method
+  // should accept any real number for the corresponding coordinate.
+  virtual S2Point Unproject(const R2Point& p) const = 0;
+
+  // Convenience function equivalent to Project(ll.ToPoint()), but the
+  // implementation may be more efficient.
+  virtual R2Point FromLatLng(const S2LatLng& ll) const = 0;
+
+  // Convenience function equivalent to S2LatLng(Unproject(p)), but the
+  // implementation may be more efficient.
+  virtual S2LatLng ToLatLng(const R2Point& p) const = 0;
+
+  // Returns the point obtained by interpolating the given fraction of the
+  // distance along the line from A to B.  Almost all projections should
+  // use the default implementation of this method, which simply interpolates
+  // linearly in R2 space.  Fractions < 0 or > 1 result in extrapolation
+  // instead.
+  //
+  // The only reason to override this method is if you want edges to be
+  // defined as something other than straight lines in the 2D projected
+  // coordinate system.  For example, using a third-party library such as
+  // GeographicLib you could define edges as geodesics over an ellipsoid model
+  // of the Earth.  (Note that very few data sets define edges this way.)
+  //
+  // Also note that there is no reason to define a projection where edges are
+  // geodesics over the sphere, because this is the native S2 interpretation.
+  virtual R2Point Interpolate(double f, const R2Point& a, const R2Point& b)
+      const;
+
+  // Defines the coordinate wrapping distance along each axis.  If this value
+  // is non-zero for a given axis, the coordinates are assumed to "wrap" with
+  // the given period.  For example, if wrap_distance.y() == 360 then (x, y)
+  // and (x, y + 360) should map to the same S2Point.
+  //
+  // This information is used to ensure that edges takes the shortest path
+  // between two given points.  For example, if coordinates represent
+  // (latitude, longitude) pairs in degrees and wrap_distance().y() == 360,
+  // then the edge (5:179, 5:-179) would be interpreted as spanning 2 degrees
+  // of longitude rather than 358 degrees.
+  //
+  // If a given axis does not wrap, its wrap_distance should be set to zero.
+  virtual R2Point wrap_distance() const = 0;
+
+  // Helper function that wraps the coordinates of B if necessary in order to
+  // obtain the shortest edge AB.  For example, suppose that A = [170, 20],
+  // B = [-170, 20], and the projection wraps so that [x, y] == [x + 360, y].
+  // Then this function would return [190, 20] for point B (reducing the edge
+  // length in the "x" direction from 340 to 20).
+  R2Point WrapDestination(const R2Point& a, const R2Point& b) const;
+};
+
+// PlateCarreeProjection defines the "plate carree" (square plate) projection,
+// which converts points on the sphere to (longitude, latitude) pairs.
+// Coordinates can be scaled so that they represent radians, degrees, etc, but
+// the projection is always centered around (latitude=0, longitude=0).
+//
+// Note that (x, y) coordinates are backwards compared to the usual (latitude,
+// longitude) ordering, in order to match the usual convention for graphs in
+// which "x" is horizontal and "y" is vertical.
+class PlateCarreeProjection final : public Projection {
+ public:
+  // Constructs the plate carree projection where the x coordinates
+  // (longitude) span [-x_scale, x_scale] and the y coordinates (latitude)
+  // span [-x_scale/2, x_scale/2].  For example if x_scale==180 then the x
+  // range is [-180, 180] and the y range is [-90, 90].
+  //
+  // By default coordinates are expressed in radians, i.e. the x range is
+  // [-Pi, Pi] and the y range is [-Pi/2, Pi/2].
+  explicit PlateCarreeProjection(double x_scale = M_PI);
+
+  R2Point Project(const S2Point& p) const override;
+  S2Point Unproject(const R2Point& p) const override;
+  R2Point FromLatLng(const S2LatLng& ll) const override;
+  S2LatLng ToLatLng(const R2Point& p) const override;
+  R2Point wrap_distance() const override;
+
+ private:
+  double x_wrap_;
+  double to_radians_;    // Multiplier to convert coordinates to radians.
+  double from_radians_;  // Multiplier to convert coordinates from radians.
+};
+
+// MercatorProjection defines the spherical Mercator projection.  Google Maps
+// uses this projection together with WGS84 coordinates, in which case it is
+// known as the "Web Mercator" projection (see Wikipedia).  This class makes
+// no assumptions regarding the coordinate system of its input points, but
+// simply applies the spherical Mercator projection to them.
+//
+// The Mercator projection is finite in width (x) but infinite in height (y).
+// "x" corresponds to longitude, and spans a finite range such as [-180, 180]
+// (with coordinate wrapping), while "y" is a function of latitude and spans
+// an infinite range.  (As "y" coordinates get larger, points get closer to
+// the north pole but never quite reach it.)  The north and south poles have
+// infinite "y" values.  (Note that this will cause problems if you tessellate
+// a Mercator edge where one endpoint is a pole.  If you need to do this, clip
+// the edge first so that the "y" coordinate is no more than about 5 * max_x.)
+class MercatorProjection final : public Projection {
+ public:
+  // Constructs a Mercator projection where "x" corresponds to longitude in
+  // the range [-max_x, max_x] , and "y" corresponds to latitude and can be
+  // any real number.  The horizontal and vertical scales are equal locally.
+  explicit MercatorProjection(double max_x);
+
+  R2Point Project(const S2Point& p) const override;
+  S2Point Unproject(const R2Point& p) const override;
+  R2Point FromLatLng(const S2LatLng& ll) const override;
+  S2LatLng ToLatLng(const R2Point& p) const override;
+  R2Point wrap_distance() const override;
+
+ private:
+  double x_wrap_;
+  double to_radians_;    // Multiplier to convert coordinates to radians.
+  double from_radians_;  // Multiplier to convert coordinates from radians.
+};
+
+}  // namespace S2
+
+
+#endif  // S2_S2PROJECTIONS_H_

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

@@ -0,0 +1,78 @@
+// 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)
+
+#include "s2/s2projections.h"
+
+#include <limits>
+#include <gtest/gtest.h>
+#include "s2/s2latlng.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2testing.h"
+
+namespace S2 {
+
+TEST(PlateCarreeProjection, Interpolate) {
+  PlateCarreeProjection proj(180);
+
+  // Test that coordinates and/or arguments are not accidentally reversed.
+  EXPECT_EQ(R2Point(1.5, 6),
+            proj.Interpolate(0.25, R2Point(1, 5), R2Point(3, 9)));
+
+  // Test extrapolation.
+  EXPECT_EQ(R2Point(-3, 0), proj.Interpolate(-2, R2Point(1, 0), R2Point(3, 0)));
+
+  // Check that interpolation is exact at both endpoints.
+  R2Point a(1.234, -5.456e-20), b(2.1234e-20, 7.456);
+  EXPECT_EQ(a, proj.Interpolate(0, a, b));
+  EXPECT_EQ(b, proj.Interpolate(1, a, b));
+}
+
+void TestProjectUnproject(const Projection& projection,
+                          const R2Point& px, const S2Point& x) {
+  // The arguments are chosen such that projection is exact, but
+  // unprojection may not be.
+  EXPECT_EQ(px, projection.Project(x)) << projection.Project(x);
+  EXPECT_TRUE(S2::ApproxEquals(x, projection.Unproject(px)))
+      << x << " vs. " << projection.Unproject(px);
+}
+
+TEST(PlateCarreeProjection, ProjectUnproject) {
+  PlateCarreeProjection proj(180);
+  TestProjectUnproject(proj, R2Point(0, 0), S2Point(1, 0, 0));
+  TestProjectUnproject(proj, R2Point(180, 0), S2Point(-1, 0, 0));
+  TestProjectUnproject(proj, R2Point(90, 0), S2Point(0, 1, 0));
+  TestProjectUnproject(proj, R2Point(-90, 0), S2Point(0, -1, 0));
+  TestProjectUnproject(proj, R2Point(0, 90), S2Point(0, 0, 1));
+  TestProjectUnproject(proj, R2Point(0, -90), S2Point(0, 0, -1));
+}
+
+TEST(MercatorProjection, ProjectUnproject) {
+  MercatorProjection proj(180);
+  double inf = std::numeric_limits<double>::infinity();
+  TestProjectUnproject(proj, R2Point(0, 0), S2Point(1, 0, 0));
+  TestProjectUnproject(proj, R2Point(180, 0), S2Point(-1, 0, 0));
+  TestProjectUnproject(proj, R2Point(90, 0), S2Point(0, 1, 0));
+  TestProjectUnproject(proj, R2Point(-90, 0), S2Point(0, -1, 0));
+  TestProjectUnproject(proj, R2Point(0, inf), S2Point(0, 0, 1));
+  TestProjectUnproject(proj, R2Point(0, -inf), S2Point(0, 0, -1));
+
+  // Test one arbitrary point as a sanity check.
+  TestProjectUnproject(proj, R2Point(0, 70.255578967830246),
+                       S2LatLng::FromRadians(1, 0).ToPoint());
+}
+
+}  //  namespace S2

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

@@ -0,0 +1,88 @@
+// 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)
+
+#include "s2/s2r2rect.h"
+
+#include <iosfwd>
+
+#include "s2/base/logging.h"
+#include "s2/r1interval.h"
+#include "s2/s2cap.h"
+#include "s2/s2cell.h"
+#include "s2/s2cell_id.h"
+#include "s2/s2coords.h"
+#include "s2/s2latlng_rect.h"
+
+S2R2Rect S2R2Rect::FromCell(const S2Cell& cell) {
+  // S2Cells have a more efficient GetSizeST() method than S2CellIds.
+  double size = cell.GetSizeST();
+  return FromCenterSize(cell.id().GetCenterST(), R2Point(size, size));
+}
+
+S2R2Rect S2R2Rect::FromCellId(S2CellId id) {
+  double size = id.GetSizeST();
+  return FromCenterSize(id.GetCenterST(), R2Point(size, size));
+}
+
+S2R2Rect* S2R2Rect::Clone() const {
+  return new S2R2Rect(*this);
+}
+
+S2Point S2R2Rect::ToS2Point(const R2Point& p) {
+  return S2::FaceUVtoXYZ(0, S2::STtoUV(p.x()), S2::STtoUV(p.y())).Normalize();
+}
+
+S2Cap S2R2Rect::GetCapBound() const {
+  if (is_empty()) return S2Cap::Empty();
+
+  // The rectangle is a convex polygon on the sphere, since it is a subset of
+  // one cube face.  Its bounding cap is also a convex region on the sphere,
+  // and therefore we can bound the rectangle by just bounding its vertices.
+  // We use the rectangle's center in (s,t)-space as the cap axis.  This
+  // doesn't yield the minimal cap but it's pretty close.
+  S2Cap cap = S2Cap::FromPoint(ToS2Point(GetCenter()));
+  for (int k = 0; k < 4; ++k) {
+    cap.AddPoint(ToS2Point(GetVertex(k)));
+  }
+  return cap;
+}
+
+S2LatLngRect S2R2Rect::GetRectBound() const {
+  // This is not very tight but hopefully good enough.
+  return GetCapBound().GetRectBound();
+}
+
+bool S2R2Rect::Contains(const S2Point& p) const {
+  if (S2::GetFace(p) != 0) return false;
+  double u, v;
+  S2::ValidFaceXYZtoUV(0, p, &u, &v);
+  return Contains(R2Point(S2::UVtoST(u), S2::UVtoST(v)));
+}
+
+bool S2R2Rect::Contains(const S2Cell& cell) const {
+  if (cell.face() != 0) return false;
+  return Contains(S2R2Rect::FromCell(cell));
+}
+
+bool S2R2Rect::MayIntersect(const S2Cell& cell) const {
+  if (cell.face() != 0) return false;
+  return Intersects(S2R2Rect::FromCell(cell));
+}
+
+std::ostream& operator<<(std::ostream& os, const S2R2Rect& r) {
+  return os << "[Lo" << r.lo() << ", Hi" << r.hi() << "]";
+}