@sentryware/s2-node 0.0.6

package/src/earth.h

@@ -0,0 +1,33 @@
+#ifndef RADAR_EARTH
+#define RADAR_EARTH
+
+#include <napi.h>
+#include "latlng.h"
+#include "s2/s1angle.h"
+#include "s2/s2latlng.h"
+#include "s2/s2earth.h"
+
+class Earth : public Napi::ObjectWrap<Earth> {
+  public:
+    Earth(const Napi::CallbackInfo& info);
+
+    static Napi::FunctionReference constructor;
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+    S2Earth Get();
+
+  private:
+    static Napi::Value ToMeters(const Napi::CallbackInfo &info);
+    static Napi::Value ToKm(const Napi::CallbackInfo &info);
+    static Napi::Value GetRadians(const Napi::CallbackInfo &info);
+    static Napi::Value GetDegrees(const Napi::CallbackInfo &info);
+    static Napi::Value GetDistanceKm(const Napi::CallbackInfo &info);
+    static Napi::Value GetDistanceMeters(const Napi::CallbackInfo &info);
+    static Napi::Value GetInitalBearingDegrees(const Napi::CallbackInfo &info);
+
+    static bool PreCheck(const Napi::CallbackInfo &info, S2LatLng &latlng1, S2LatLng &latlng2);
+
+    S2Earth s2earth;
+};
+
+#endif

package/src/latlng.cc

@@ -0,0 +1,132 @@
+#include "latlng.h"
+
+Napi::FunctionReference LatLng::constructor;
+
+Napi::Object LatLng::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(env, "LatLng", {
+    InstanceMethod("latitude", &LatLng::Latitude),
+    InstanceMethod("longitude", &LatLng::Longitude),
+    InstanceMethod("toString", &LatLng::ToString),
+    InstanceMethod("normalized", &LatLng::Normalized),
+    InstanceMethod("approxEquals", &LatLng::ApproxEquals)
+  });
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  exports.Set("LatLng", func);
+  return exports;
+}
+
+Napi::Object LatLng::NewInstance(Napi::Value lat, Napi::Value lng) {
+  return constructor.New({ lat, lng });
+}
+
+LatLng::LatLng(const Napi::CallbackInfo& info) : Napi::ObjectWrap<LatLng>(info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  int length = info.Length();
+
+  if (length <= 0 || length > 2) {
+    Napi::TypeError::New(env, "(lat: number, lng: number) | Point expected.").ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (length == 1) { // Point
+    if (!info[0].IsObject()) {
+      Napi::TypeError::New(env, "Point expected.").ThrowAsJavaScriptException();
+      return;
+    }
+    Napi::Object object = info[0].As<Napi::Object>();
+    bool isPoint = object.InstanceOf(Point::constructor.Value());
+    if (!isPoint) {
+      Napi::TypeError::New(env, "Point expected.").ThrowAsJavaScriptException();
+      return;
+    }
+
+    Point* point = Point::Unwrap(object);
+    this->s2latlng = S2LatLng(point->Get());
+  } else { // lat, lng
+    if (!info[0].IsNumber() || !info[1].IsNumber()) {
+      Napi::TypeError::New(env, "(lat: number, lng: number) expected.").ThrowAsJavaScriptException();
+      return;
+    }
+
+    Napi::Number lat = info[0].As<Napi::Number>();
+    Napi::Number lng = info[1].As<Napi::Number>();
+
+    this->s2latlng = S2LatLng::FromDegrees(
+      lat.DoubleValue(),
+      lng.DoubleValue()
+    );
+  }
+}
+
+
+S2LatLng LatLng::Get() {
+  return s2latlng;
+}
+
+Napi::Value LatLng::ToString(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(), this->s2latlng.ToStringInDegrees());
+}
+
+Napi::Value LatLng::Normalized(const Napi::CallbackInfo& info) {
+  S2LatLng normalized = this->s2latlng.Normalized();
+
+  return LatLng::NewInstance(
+    Napi::Number::New(info.Env(), normalized.lat().degrees()),
+    Napi::Number::New(info.Env(), normalized.lng().degrees())
+  );
+}
+
+Napi::Value LatLng::Latitude(const Napi::CallbackInfo& info) {
+  return Napi::Number::New(
+    info.Env(),
+    this->s2latlng.lat().degrees()
+  );
+}
+
+Napi::Value LatLng::Longitude(const Napi::CallbackInfo& info) {
+  return Napi::Number::New(
+    info.Env(),
+    this->s2latlng.lng().degrees()
+  );
+}
+
+Napi::Value LatLng::ApproxEquals(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int length = info.Length();
+  S1Angle maxError = S1Angle::Radians(1e-15);
+
+  if (length < 1 || length > 2) {
+    Napi::TypeError::New(env, "(ll: LatLng, maxErrorRadians?: number) expected.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object object = info[0].As<Napi::Object>();
+  bool isLatlng = object.InstanceOf(LatLng::constructor.Value());
+  if (!isLatlng) {
+    Napi::TypeError::New(env, "(ll: LatLng, maxErrorRadians?: number) expected.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  LatLng* ll = LatLng::Unwrap(object);
+  S2LatLng s2LatLng = ll->Get();
+
+  if (length == 2) {
+    if (!info[1].IsNumber()) {
+      Napi::TypeError::New(env, "(ll: LatLng, maxErrorRadians?: number) expected.").ThrowAsJavaScriptException();
+      return env.Null();
+    }
+
+    double radians = info[1].As<Napi::Number>().DoubleValue();
+    maxError = S1Angle::Radians(radians);
+  }
+
+  bool isEqual = this->s2latlng.ApproxEquals(s2LatLng, maxError);
+  return Napi::Boolean::New(info.Env(), isEqual);
+}

package/src/latlng.h

@@ -0,0 +1,28 @@
+#ifndef RADAR_LATLNG
+#define RADAR_LATLNG
+
+#include <napi.h>
+#include "point.h"
+#include "s2/s2latlng.h"
+
+class LatLng : public Napi::ObjectWrap<LatLng> {
+
+  public:
+    LatLng(const Napi::CallbackInfo& info);
+
+    static Napi::FunctionReference constructor;
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    static Napi::Object NewInstance(Napi::Value lat, Napi::Value lng);
+
+    S2LatLng Get();
+
+  private:
+    Napi::Value ToString(const Napi::CallbackInfo &info);
+    Napi::Value Normalized(const Napi::CallbackInfo &info);
+    Napi::Value Latitude(const Napi::CallbackInfo &info);
+    Napi::Value Longitude(const Napi::CallbackInfo &info);
+    Napi::Value ApproxEquals(const Napi::CallbackInfo &info);
+    S2LatLng s2latlng;
+};
+
+#endif

package/src/loop.cc

@@ -0,0 +1,51 @@
+#include "loop.h"
+#include "s2/s2pointutil.h"
+
+Napi::FunctionReference Loop::constructor;
+
+Napi::Object Loop::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(env, "Loop", {});
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  exports.Set("Loop", func);
+  return exports;
+}
+
+Loop::Loop(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Loop>(info)  {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  int length = info.Length();
+
+  if (length <= 0 || !info[0].IsArray()) {
+    Napi::TypeError::New(env, "(latlngs: s2.LatLng[]) expected.").ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Array llArray = info[0].As<Napi::Array>();
+  uint32_t arrayLength = llArray.Length();
+  if (arrayLength <= 0) {
+    Napi::RangeError::New(env, "(latlngs: s2.LatLng[]) was empty.").ThrowAsJavaScriptException();
+    return;
+  }
+
+  std::vector<S2Point> pointVector;
+  for (uint32_t i = 0; i < arrayLength; i++) {
+    Napi::Value obj = llArray[i];
+    LatLng* ll = LatLng::Unwrap(obj.As<Napi::Object>());
+    S2Point point = ll->Get().Normalized().ToPoint().Normalize();
+    pointVector.push_back(point);
+  }
+
+  this->s2loop = std::make_shared<S2Loop>(pointVector, S2Debug::ALLOW);
+
+  S2Error error;
+  if (this->s2loop->FindValidationError(&error)) {
+    Napi::Error::New(env, StringPrintf("Loop is invalid: %s", error.text().c_str())).ThrowAsJavaScriptException();
+    return;
+  }
+}

package/src/loop.h

@@ -0,0 +1,21 @@
+#ifndef RADAR_LOOP
+#define RADAR_LOOP
+
+#include <napi.h>
+#include "latlng.h"
+#include "s2/s2loop.h"
+#include "s2/s2error.h"
+#include "s2/base/stringprintf.h"
+
+class Loop : public Napi::ObjectWrap<Loop> {
+
+  public:
+    static Napi::FunctionReference constructor;
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+    Loop(const Napi::CallbackInfo& info);
+
+    std::shared_ptr<S2Loop> s2loop;
+};
+
+#endif

package/src/point.cc

@@ -0,0 +1,69 @@
+#include "point.h"
+
+Napi::FunctionReference Point::constructor;
+
+Napi::Object Point::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(env, "Point", {
+    InstanceMethod("x", &Point::X),
+    InstanceMethod("y", &Point::Y),
+    InstanceMethod("z", &Point::Z),
+  });
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  exports.Set("Point", func);
+  return exports;
+}
+
+Point::Point(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Point>(info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  int length = info.Length();
+  string badArgs = "(number, number, number) expected.";
+
+  if (length != 1 && length != 3) {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (length == 1) { // S2 Point
+    if (!info[0].IsExternal()) {
+      Napi::TypeError::New(env, "S2Point expected.").ThrowAsJavaScriptException();
+      return;
+    }
+    Napi::External<S2Point> external = info[0].As<Napi::External<S2Point>>();
+    this->s2Point = *external.Data();
+
+  } else { // (x, y, z)
+    if (!info[0].IsNumber() || !info[1].IsNumber() || !info[2].IsNumber()) {
+      Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+      return;
+    }
+
+    this->s2Point = S2Point(
+      info[0].As<Napi::Number>().DoubleValue(),
+      info[1].As<Napi::Number>().DoubleValue(),
+      info[2].As<Napi::Number>().DoubleValue()
+    );
+  }
+}
+
+Napi::Value Point::X(const Napi::CallbackInfo &info) {
+  return Napi::Number::New(info.Env(), s2Point.x());
+}
+
+Napi::Value Point::Y(const Napi::CallbackInfo &info) {
+  return Napi::Number::New(info.Env(), s2Point.y());
+}
+
+Napi::Value Point::Z(const Napi::CallbackInfo &info) {
+  return Napi::Number::New(info.Env(), s2Point.z());
+}
+
+S2Point Point::Get() {
+  return s2Point;
+}

package/src/point.h

@@ -0,0 +1,23 @@
+#ifndef RADAR_POINT
+#define RADAR_POINT
+
+#include <napi.h>
+#include <sstream>
+#include "s2/s2point.h"
+
+class Point : public Napi::ObjectWrap<Point> {
+  public:
+    Point(const Napi::CallbackInfo& info);
+    S2Point Get();
+
+    static Napi::FunctionReference constructor;
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  private:
+    Napi::Value X(const Napi::CallbackInfo &info);
+    Napi::Value Y(const Napi::CallbackInfo &info);
+    Napi::Value Z(const Napi::CallbackInfo &info);
+    S2Point s2Point;
+};
+
+#endif

package/src/polygon.cc

@@ -0,0 +1,36 @@
+#include "polygon.h"
+
+Napi::FunctionReference Polygon::constructor;
+
+Napi::Object Polygon::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(env, "Polygon", {});
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  exports.Set("Polygon", func);
+  return exports;
+}
+
+Polygon::Polygon(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Polygon>(info)  {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsArrayBuffer()) {
+    Napi::TypeError::New(env, "(encoded: ArrayBuffer) expected.").ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::ArrayBuffer encoded = info[0].As<Napi::ArrayBuffer>();
+
+  this->s2polygon = std::make_shared<S2Polygon>();
+  Decoder decoder(encoded.Data(), encoded.ByteLength());
+  if (!this->s2polygon->Decode(&decoder)) {
+    Napi::TypeError::New(env, "malformed ArrayBuffer for S2Polygon.").ThrowAsJavaScriptException();
+    return;
+  }
+}

package/src/polygon.h

@@ -0,0 +1,20 @@
+#ifndef RADAR_POLYGON
+#define RADAR_POLYGON
+
+#include <napi.h>
+#include "s2/s2polygon.h"
+#include "s2/s2error.h"
+#include "s2/base/stringprintf.h"
+
+class Polygon : public Napi::ObjectWrap<Polygon> {
+
+  public:
+    static Napi::FunctionReference constructor;
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+    Polygon(const Napi::CallbackInfo& info);
+
+    std::shared_ptr<S2Polygon> s2polygon;
+};
+
+#endif

package/src/polyline.cc

@@ -0,0 +1,186 @@
+#include "polyline.h"
+
+Napi::FunctionReference Polyline::constructor;
+
+Napi::Object Polyline::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(env, "Polyline", {
+    InstanceMethod("contains", &Polyline::Contains),
+    InstanceMethod("nearlyCovers", &Polyline::NearlyCovers),
+    InstanceMethod("getLength", &Polyline::GetLength),
+    InstanceMethod("getCentroid", &Polyline::GetCentroid),
+    InstanceMethod("interpolate", &Polyline::Interpolate),
+    InstanceMethod("project", &Polyline::Project),
+  });
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  exports.Set("Polyline", func);
+  return exports;
+}
+
+Polyline::Polyline(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Polyline>(info)  {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  int length = info.Length();
+
+  if (length <= 0 || !info[0].IsArray()) {
+    Napi::TypeError::New(env, "(latlngs: s2.LatLng[]) expected.").ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Array llArray = info[0].As<Napi::Array>();
+  uint32_t arrayLength = llArray.Length();
+  if (arrayLength <= 0) {
+    Napi::RangeError::New(env, "(latlngs: s2.LatLng[]) was empty.").ThrowAsJavaScriptException();
+    return;
+  }
+
+  std::vector<S2Point> pointVector;
+  for (uint32_t i = 0; i < arrayLength; i++) {
+    Napi::Value obj = llArray[i];
+    LatLng* ll = LatLng::Unwrap(obj.As<Napi::Object>());
+    S2Point point = ll->Get().Normalized().ToPoint().Normalize();
+    pointVector.push_back(point);
+  }
+
+  this->s2polyline = S2Polyline(pointVector, S2Debug::ALLOW);
+
+  S2Error error;
+  if (this->s2polyline.FindValidationError(&error)) {
+    Napi::Error::New(env, StringPrintf("Polyline is invalid: %s", error.text().c_str())).ThrowAsJavaScriptException();
+    return;
+  }
+}
+
+Napi::Value Polyline::Contains(const Napi::CallbackInfo& info){
+  bool contains = false;
+
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsObject()){
+    Napi::TypeError::New(env, "expected cell").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object object = info[0].As<Napi::Object>();
+  bool isCell = object.InstanceOf(Cell::constructor.Value());
+  if (!isCell) {
+    Napi::TypeError::New(env, "Cell expected.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Cell* cell = Cell::Unwrap(object);
+  S2Cell s2cell = cell->Get();
+
+  contains = this->s2polyline.Contains(s2cell);
+
+  return Napi::Boolean::New(info.Env(), contains);
+}
+
+Napi::Value Polyline::NearlyCovers(const Napi::CallbackInfo& info){
+  bool isCover = false;
+
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length != 2 || !info[0].IsObject() || !info[1].IsNumber()){
+    Napi::TypeError::New(env, "(polyline: Polyline, margin: number) expected.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object object = info[0].As<Napi::Object>();
+  bool isPolyline = object.InstanceOf(Polyline::constructor.Value());
+  if (!isPolyline) {
+    Napi::TypeError::New(env, "(polyline: Polyline, margin: number) expected.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  double max_error_degree = info[1].As<Napi::Number>().DoubleValue();
+  S1Angle max_error = S1Angle::Degrees(max_error_degree);
+
+  Polyline* polyline = Polyline::Unwrap(object);
+  S2Polyline* s2polyline = polyline->Get();
+
+  isCover = this->s2polyline.NearlyCovers(*s2polyline, max_error);
+
+  return Napi::Boolean::New(info.Env(), isCover);
+}
+
+S2Polyline* Polyline::Get() {
+  return this->s2polyline.Clone();
+}
+
+Napi::Value Polyline::GetLength(const Napi::CallbackInfo& info){
+  double length = 1;
+  Napi::Env env = info.Env();
+  S1Angle s1Angle = this->s2polyline.GetLength();
+  length = S2Earth::ToMeters(s1Angle);
+
+  return Napi::Number::New(env, length);
+}
+
+Napi::Value Polyline::GetCentroid(const Napi::CallbackInfo& info){
+  S2Point s2point = this->s2polyline.GetCentroid();
+  S2LatLng s2latlng = S2LatLng(s2point);
+  return LatLng::NewInstance(
+    Napi::Number::New(info.Env(), s2latlng.lat().degrees()),
+    Napi::Number::New(info.Env(), s2latlng.lng().degrees())
+  );
+}
+
+Napi::Value Polyline::Interpolate(const Napi::CallbackInfo& info){
+   Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length != 1 || !info[0].IsNumber()){
+    Napi::TypeError::New(env, "expected fraction").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  double fraction = info[0].As<Napi::Number>().DoubleValue();
+  S2Point s2point = this->s2polyline.Interpolate(fraction);
+  S2LatLng s2latlng = S2LatLng(s2point);
+  return LatLng::NewInstance(
+    Napi::Number::New(info.Env(), s2latlng.lat().degrees()),
+    Napi::Number::New(info.Env(), s2latlng.lng().degrees())
+  );
+}
+
+Napi::Value Polyline::Project(const Napi::CallbackInfo& info){
+   Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length != 1 || !info[0].IsObject()) {
+    Napi::TypeError::New(env, "(ll: LatLng) expected.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object object = info[0].As<Napi::Object>();
+  bool isLatlng = object.InstanceOf(LatLng::constructor.Value());
+  if (!isLatlng) {
+    Napi::TypeError::New(env, "(ll: LatLng) expected.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  LatLng* ll = LatLng::Unwrap(object);
+  S2LatLng sourceLatLng = ll->Get();
+
+  int index;
+  S2Point s2point = this->s2polyline.Project(sourceLatLng.ToPoint(), &index);
+  S2LatLng s2latlng = S2LatLng(s2point);
+
+  Napi::Object newPoint = LatLng::NewInstance(
+    Napi::Number::New(info.Env(), s2latlng.lat().degrees()),
+    Napi::Number::New(info.Env(), s2latlng.lng().degrees())
+  );
+
+  Napi::Object returnObj = Napi::Object::New(env);
+  returnObj.Set("point", newPoint);
+  returnObj.Set("index", index);
+  return returnObj;
+}

package/src/polyline.h

@@ -0,0 +1,34 @@
+#ifndef RADAR_POLYLINE
+#define RADAR_POLYLINE
+
+#include <napi.h>
+
+#include "latlng.h"
+#include "cell.h"
+#include "s2/s1angle.h"
+#include "s2/s2earth.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2polyline.h"
+#include "s2/base/stringprintf.h"
+
+class Polyline : public Napi::ObjectWrap<Polyline> {
+  public:
+    Polyline(const Napi::CallbackInfo& info);
+
+    static Napi::FunctionReference constructor;
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+    S2Polyline* Get();
+
+  private:
+    Napi::Value Contains(const Napi::CallbackInfo &info);
+    Napi::Value NearlyCovers(const Napi::CallbackInfo &info);
+    Napi::Value GetLength(const Napi::CallbackInfo &info);
+    Napi::Value GetCentroid(const Napi::CallbackInfo &info);
+    Napi::Value Interpolate(const Napi::CallbackInfo &info);
+    Napi::Value Project(const Napi::CallbackInfo &info);
+
+    S2Polyline s2polyline;
+};
+
+#endif