Link createLonLatToCartesian in @rapidsai/cuspatial (#440)

* Create createLonLatToCartesian

* Add the missing test file and a little cleanup.

* Really need that file.

* Refactor based on Paul's comments.

* Update modules/cuspatial/src/node_cuspatial.ts

Co-authored-by: Paul Taylor <paul.e.taylor@me.com>

* Update modules/cuspatial/test/spatial-tests.ts

Co-authored-by: Paul Taylor <paul.e.taylor@me.com>

* Update modules/cuspatial/src/spatial.ts

Co-authored-by: Paul Taylor <paul.e.taylor@me.com>

* fix tsc compilation errors

* add optional memoryResource argument to convertLonLatToCartesian

* update copyright year

Co-authored-by: Paul Taylor <paul.e.taylor@me.com>

Author: thomcom

modules/cuspatial/src/addon.cpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2021, NVIDIA CORPORATION.
+// Copyright (c) 2021-2022, NVIDIA CORPORATION.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -21,19 +21,20 @@ struct rapidsai_cuspatial : public nv::EnvLocalAddon, public Napi::Addon<rapidsa
   rapidsai_cuspatial(Napi::Env const& env, Napi::Object exports) : nv::EnvLocalAddon(env, exports) {
     DefineAddon(
       exports,
-      {
-        InstanceMethod("init", &rapidsai_cuspatial::InitAddon),
-        InstanceValue("_cpp_exports", _cpp_exports.Value()),
-        InstanceMethod<&rapidsai_cuspatial::create_quadtree>("createQuadtree"),
-        InstanceMethod<&rapidsai_cuspatial::quadtree_bounding_box_intersections>(
-          "findQuadtreeAndBoundingBoxIntersections"),
-        InstanceMethod<&rapidsai_cuspatial::find_points_in_polygons>("findPointsInPolygons"),
-        InstanceMethod<&rapidsai_cuspatial::find_polyline_nearest_to_each_point>(
-          "findPolylineNearestToEachPoint"),
-        InstanceMethod<&rapidsai_cuspatial::compute_polygon_bounding_boxes>(
-          "computePolygonBoundingBoxes"),
-        InstanceMethod<&rapidsai_cuspatial::compute_polyline_bounding_boxes>(
-          "computePolylineBoundingBoxes"),
+      {InstanceMethod("init", &rapidsai_cuspatial::InitAddon),
+       InstanceValue("_cpp_exports", _cpp_exports.Value()),
+       InstanceMethod<&rapidsai_cuspatial::create_quadtree>("createQuadtree"),
+       InstanceMethod<&rapidsai_cuspatial::quadtree_bounding_box_intersections>(
+         "findQuadtreeAndBoundingBoxIntersections"),
+       InstanceMethod<&rapidsai_cuspatial::find_points_in_polygons>("findPointsInPolygons"),
+       InstanceMethod<&rapidsai_cuspatial::find_polyline_nearest_to_each_point>(
+         "findPolylineNearestToEachPoint"),
+       InstanceMethod<&rapidsai_cuspatial::compute_polygon_bounding_boxes>(
+         "computePolygonBoundingBoxes"),
+       InstanceMethod<&rapidsai_cuspatial::compute_polyline_bounding_boxes>(
+         "computePolylineBoundingBoxes"),
+       InstanceMethod<&rapidsai_cuspatial::lonlat_to_cartesian>("lonLatToCartesian")
+
       });
   }
 
@@ -54,6 +55,9 @@ struct rapidsai_cuspatial : public nv::EnvLocalAddon, public Napi::Addon<rapidsa
   Napi::Value compute_polyline_bounding_boxes(Napi::CallbackInfo const& info) {
     return nv::compute_polyline_bounding_boxes(info);
   }
+  Napi::Value lonlat_to_cartesian(Napi::CallbackInfo const& info) {
+    return nv::lonlat_to_cartesian(info);
+  }
 };
 
 NODE_API_ADDON(rapidsai_cuspatial);

modules/cuspatial/src/addon.ts

@@ -26,6 +26,7 @@ export const {
   computePolylineBoundingBoxes,
   findPointsInPolygons,
   findPolylineNearestToEachPoint,
+  lonLatToCartesian,
   _cpp_exports,
 } = require('bindings')('rapidsai_cuspatial.node').init(CORE, CUDA, RMM, CUDF) as
     typeof import('./node_cuspatial');

modules/cuspatial/src/geometry.cpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2021, NVIDIA CORPORATION.
+// Copyright (c) 2021-2022, NVIDIA CORPORATION.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@
 
 #include <node_rmm/utilities/napi_to_cpp.hpp>
 
+#include <cuspatial/coordinate_transform.hpp>
 #include <cuspatial/error.hpp>
 #include <cuspatial/polygon_bounding_box.hpp>
 #include <cuspatial/polyline_bounding_box.hpp>
@@ -73,4 +74,21 @@ Napi::Value compute_polyline_bounding_boxes(CallbackArgs const& args) {
   return output;
 }
 
+Napi::Value lonlat_to_cartesian(CallbackArgs const& args) {
+  double origin_lon                   = args[0];
+  double origin_lat                   = args[1];
+  Column::wrapper_t lons_column       = args[2];
+  Column::wrapper_t lats_column       = args[3];
+  rmm::mr::device_memory_resource* mr = args[4];
+  auto result                         = [&]() {
+    try {
+      return cuspatial::lonlat_to_cartesian(origin_lon, origin_lat, *lons_column, *lats_column, mr);
+    } catch (std::exception const& e) { throw Napi::Error::New(args.Env(), e.what()); }
+  }();
+  auto output = Napi::Object::New(args.Env());
+  output.Set("x", Column::New(args.Env(), std::move(result.first)));
+  output.Set("y", Column::New(args.Env(), std::move(result.second)));
+  return output;
+}
+
 }  // namespace nv

modules/cuspatial/src/index.ts

@@ -14,3 +14,4 @@
 
 export * from './geometry';
 export * from './quadtree';
+export * from './spatial';

modules/cuspatial/src/node_cuspatial.ts

@@ -78,3 +78,10 @@ export declare function findPolylineNearestToEachPoint<T extends FloatingPoint>(
   polylinePointsY: Column<T>,
   memoryResource
   ?: MemoryResource): {table: Table, names: ['point_index', 'polyline_index', 'distance']};
+
+export declare function lonLatToCartesian<T extends FloatingPoint>(
+  origin_lon: number,
+  origin_lat: number,
+  lats: Column<T>,
+  lons: Column<T>,
+  memoryResource?: MemoryResource): {x: Column<T>, y: Column<T>};

modules/cuspatial/src/node_cuspatial/geometry.hpp

@@ -34,4 +34,11 @@ Napi::Value compute_polygon_bounding_boxes(CallbackArgs const& args);
  */
 Napi::Value compute_polyline_bounding_boxes(CallbackArgs const& args);
 
+/**
+ * @brief Convert lon/lat coordinate columns into cartesian coordinates.
+ *
+ * @param args CallbackArgs JavaScript arguments list.
+ */
+Napi::Value lonlat_to_cartesian(CallbackArgs const& args);
+
 }  // namespace nv

modules/cuspatial/src/spatial.ts

@@ -0,0 +1,35 @@
+// Copyright (c) 2022, NVIDIA CORPORATION.
+//
+// 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.
+
+import {
+  Column,
+  FloatingPoint,
+  Series,
+} from '@rapidsai/cudf';
+import {makePoints} from '@rapidsai/cuspatial';
+import {MemoryResource} from '@rapidsai/rmm';
+
+import {
+  lonLatToCartesian,
+} from './addon';
+
+export function convertLonLatToCartesian<T extends FloatingPoint>(centerX: number,
+                                                                  centerY: number,
+                                                                  lonPoints: Series<T>,
+                                                                  latPoints: Series<T>,
+                                                                  memoryResource?: MemoryResource) {
+  const {x, y} = lonLatToCartesian(
+    centerX, centerY, lonPoints._col as Column<T>, latPoints._col as Column<T>, memoryResource);
+  return makePoints(Series.new(x), Series.new(y));
+}

modules/cuspatial/test/spatial-tests.ts

@@ -0,0 +1,35 @@
+// Copyright (c) 2022, NVIDIA CORPORATION.
+//
+// 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.
+
+import '@rapidsai/cudf/test/jest-extensions';
+
+import {setDefaultAllocator} from '@rapidsai/cuda';
+import {Series} from '@rapidsai/cudf';
+import {convertLonLatToCartesian} from '@rapidsai/cuspatial';
+import {DeviceBuffer} from '@rapidsai/rmm';
+
+setDefaultAllocator((byteLength: number) => new DeviceBuffer(byteLength));
+
+describe('Spatial', () => {
+  test(`convertLonLatToCartesian`, () => {
+    const seriesX = Series.new([-120.0, -120.0]);
+    const seriesY = Series.new([48.0, 49.0]);
+    const result  = convertLonLatToCartesian(1.0, 1.0, seriesX, seriesY);
+
+    expect(result.getChild('y').toArray())
+      .toMatchObject({'0': -5222.222222222223, '1': -5333.333333333334});
+    expect(result.getChild('x').toArray())
+      .toMatchObject({'0': 12233.92375289575, '1': 12184.804692381627});
+  });
+});