Write quadtree/get_points

modules/demo/api-server/routes/quadtree/index.js

@@ -27,6 +27,7 @@ module.exports = async function(fastify, opts) {
   fastify.register(arrowPlugin);
   fastify.decorate('cacheObject', gpu_cache.cacheObject);
   fastify.decorate('getData', gpu_cache.getData);
+  fastify.decorate('listDataframes', gpu_cache.listDataframes);
   fastify.decorate('readCSV', gpu_cache.readCSV);
 
   const get_schema = {
@@ -70,7 +71,7 @@ module.exports = async function(fastify, opts) {
           parseFloat(table.get(request.body.yAxisName).max()),
         ];
         try {
-          const quadtree    = cuspatial.Quadtree.new({
+          const quadtree          = cuspatial.Quadtree.new({
             x: table.get(request.body.xAxisName),
             y: table.get(request.body.yAxisName),
             xMin,
@@ -81,10 +82,12 @@ module.exports = async function(fastify, opts) {
             maxDepth: 15,
             minSize: 1e5
           });
-          const saved       = await fastify.cacheObject(request.params.table);
-          result.message    = 'Quadtree created';
-          result.success    = true;
-          result.statusCode = 200;
+          const quadtree_name     = request.params.table + '_quadtree';
+          request.params.quadtree = quadtree_name
+          const saved             = await fastify.cacheObject(quadtree_name, quadtree);
+          result.message          = 'Quadtree created';
+          result.success          = true;
+          result.statusCode       = 200;
           await reply.code(result.statusCode).send(result);
         } catch (e) {
           result.message    = e;
@@ -100,17 +103,22 @@ module.exports = async function(fastify, opts) {
     method: 'POST',
     url: '/set_polygons_quadtree',
     schema: {
-      querystring:
-        {polygon_offset: {type: 'array'}, ring_offset: {type: 'array'}, points: {type: 'array'}}
+      querystring: {
+        name: {type: 'string'},
+        polygon_offset: {type: 'array'},
+        ring_offset: {type: 'array'},
+        points: {type: 'array'}
+      }
     },
     handler: async (request, reply) => {
       let message = 'Error';
       let result  = {'params': request.params, success: false, message: message};
       try {
         const polygon_offset = Series.new(new Int32Array(request.body.polygon_offset));
         const ring_offset    = Series.new(new Int32Array(request.body.ring_offset));
-        const points         = Series.new(new Float32Array(request.body.points));
-        fastify.cacheObject(request.body.name, {polygon_offset, ring_offset, points});
+        const points         = Series.new(new Float64Array(request.body.points));
+        const cached =
+          await fastify.cacheObject(request.body.name, {polygon_offset, ring_offset, points});
         result.message    = 'Set polygon ' + request.body.name;
         result.success    = true;
         result.statusCode = 200;
@@ -124,4 +132,41 @@ module.exports = async function(fastify, opts) {
       }
     }
   });
+
+  fastify.route({
+    method: 'GET',
+    url: '/get_points/:quadtree/:polygon',
+    schema: {querystring: {quadtree: {type: 'string'}, polygon: {type: 'string'}}},
+    handler: async (request, reply) => {
+      let message = 'Error';
+      let result  = {'params': request.params, success: false, message: message};
+      try {
+        const quadtree = await fastify.getData(request.params.quadtree);
+        const {polygon_offset, ring_offset, points} = await fastify.getData(request.params.polygon);
+        const data                                  = await fastify.listDataframes();
+        const pts                                   = cuspatial.makePoints(
+          points.gather(Series.sequence({size: points.length, step: 2, init: 0})),
+          points.gather(Series.sequence({size: points.length, step: 2, init: 1})));
+        const polylines      = cuspatial.makePolylines(pts, ring_offset);
+        const polygons       = cuspatial.makePolygons(polylines, polygon_offset);
+        const polyPointPairs = quadtree.pointInPolygon(polygons);
+        const resultPoints   = quadtree.points.gather(polyPointPairs.get('point_index'));
+        const numPoints      = resultPoints.get('x').length
+        let result_col       = Series.sequence({size: numPoints * 2, step: 0, init: 0});
+        result_col           = result_col.scatter(resultPoints.get('x'),
+                                        Series.sequence({size: numPoints, step: 2, init: 0}));
+        result_col           = result_col.scatter(resultPoints.get('y'),
+                                        Series.sequence({size: numPoints, step: 2, init: 1}));
+        result               = new DataFrame({'points_in_polygon': result_col})
+        const writer         = RecordBatchStreamWriter.writeAll(result.toArrow());
+        writer.close();
+        await reply.code(200).send(writer.toNodeStream());
+      } catch (e) {
+        result.message    = e;
+        result.success    = false;
+        result.statusCode = 500;
+        await reply.code(result.statusCode).send(result);
+      }
+    }
+  });
 }

modules/demo/api-server/test/routes/quadtree.test.js

@@ -38,12 +38,12 @@ test('quadtree/create/:table', async (t) => {
   t.same(result, {
     statusCode: 200,
     message: 'Quadtree created',
-    params: {table: 'csv_quadtree.csv'},
+    params: {table: 'csv_quadtree.csv', quadtree: 'csv_quadtree.csv_quadtree'},
     success: true
   })
 });
 
-test('quadtree/set_polygons', {only: true}, async (t) => {
+test('quadtree/set_polygons', async (t) => {
   const dir   = t.testdir(csv_quadtree);
   const rpath = 'test/routes/' + dir.substring(dir.lastIndexOf('/'));
   const app   = await build(t);
@@ -66,3 +66,38 @@ test('quadtree/set_polygons', {only: true}, async (t) => {
     success: true
   })
 });
+
+test('quadtree/get_points', {only: true}, async (t) => {
+  const dir   = t.testdir(csv_quadtree);
+  const rpath = 'test/routes/' + dir.substring(dir.lastIndexOf('/'));
+  const app   = await build(t);
+  gpu_cache._setPathForTesting(rpath);
+  const load = await app.inject(
+    {method: 'POST', url: '/gpu/DataFrame/readCSV', body: {filename: 'csv_quadtree.csv'}});
+  const create        = await app.inject({
+    method: 'POST',
+    url: '/quadtree/create/csv_quadtree.csv',
+    body: {xAxisName: 'x', yAxisName: 'y'}
+  });
+  const quadtree_name = JSON.parse(create.payload).params.quadtree;
+  const set_poly      = await app.inject({
+    method: 'POST',
+    url: '/quadtree/set_polygons_quadtree',
+    body: {
+      name: 'test',
+      polygon_offset: [0, 1],
+      ring_offset: [0, 4],
+      points: [-2, -2, -2, 2, 2, 2, 2, -2]
+    }
+  });
+  const polygons_name = JSON.parse(set_poly.payload).params.name;
+  const res           = await app.inject({
+    method: 'GET',
+    url: 'quadtree/get_points/' + quadtree_name + '/' + polygons_name,
+  })
+  const release       = await app.inject({method: 'POST', url: '/graphology/release'});
+  const table         = tableFromIPC(res.rawPayload);
+  const got           = table.getChild('points_in_polygon').toArray();
+  const expected      = [1, -1, -1, 1, 0, 0];
+  t.same(expected, got);
+});

modules/demo/api-server/util/gpu_cache.js

@@ -82,6 +82,7 @@ module.exports = {
   async cacheObject(name, data) { cacheObject(name, data); },
 
   async getData(name) { return datasets != null ? datasets[name] : undefined; },
+  getDataSync(name) { return datasets != null ? datasets[name] : undefined; },
 
   async listDataframes() { return datasets != null ? Object.keys(datasets) : []; },