@sentryware/s2-node 0.0.6

package/third_party/s2geometry/doc/examples/term_index.cc

@@ -0,0 +1,99 @@
+// Copyright 2017 Google Inc. All Rights Reserved.
+// Author: ericv@google.com (Eric Veach)
+//
+// This example shows how to add spatial data to an information retrieval
+// system.  Such systems work by converting documents into a collection of
+// "index terms" (e.g., representing words or phrases), and then building an
+// "inverted index" that maps each term to a list of documents (and document
+// positions) where that term occurs.
+//
+// This example shows how to convert spatial data into index terms, which can
+// then be indexed along with the other document information.
+
+#include <cinttypes>
+#include <cstdint>
+#include <cstdio>
+#include <set>
+#include <unordered_map>
+#include <vector>
+
+#include "s2/base/commandlineflags.h"
+#include "s2/s2earth.h"
+#include "s2/s2cap.h"
+#include "s2/s2point_index.h"
+#include "s2/s2region_term_indexer.h"
+#include "s2/s2testing.h"
+
+S2_DEFINE_int32(num_documents, 10000, "Number of documents");
+S2_DEFINE_int32(num_queries, 10000, "Number of queries");
+S2_DEFINE_double(query_radius_km, 100, "Query radius in kilometers");
+
+// A prefix added to spatial terms to distinguish them from other index terms
+// (e.g. representing words or phrases).
+static const char kPrefix[] = "s2:";
+
+int main(int argc, char **argv) {
+  // Create a set of "documents" to be indexed.  Each document consists of a
+  // single point.  (You can easily substitute any S2Region type here, or even
+  // index a mixture of region types using std::unique_ptr<S2Region>.  Other
+  // region types include polygons, polylines, rectangles, discs, buffered
+  // geometry, etc.)
+  std::vector<S2Point> documents;
+  documents.reserve(FLAGS_num_documents);
+  for (int docid = 0; docid < FLAGS_num_documents; ++docid) {
+    documents.push_back(S2Testing::RandomPoint());
+  }
+
+  // We use a hash map as our inverted index.  The key is an index term, and
+  // the value is the set of "document ids" where this index term is present.
+  std::unordered_map<string, std::vector<int>> index;
+
+  // Create an indexer suitable for an index that contains points only.
+  // (You may also want to adjust min_level() or max_level() if you plan
+  // on querying very large or very small regions.)
+  S2RegionTermIndexer::Options options;
+  options.set_index_contains_points_only(true);
+  S2RegionTermIndexer indexer(options);
+
+  // Add the documents to the index.
+  for (int docid = 0; docid < documents.size(); ++docid) {
+    S2Point index_region = documents[docid];
+    for (const auto& term : indexer.GetIndexTerms(index_region, kPrefix)) {
+      index[term].push_back(docid);
+    }
+  }
+
+  // Convert the query radius to an angle representation.
+  S1Angle radius =
+      S1Angle::Radians(S2Earth::KmToRadians(FLAGS_query_radius_km));
+
+  // Count the number of documents (points) found in all queries.
+  int64_t num_found = 0;
+  for (int i = 0; i < FLAGS_num_queries; ++i) {
+    // Choose a random center for query.
+    S2Cap query_region(S2Testing::RandomPoint(), radius);
+
+    // Convert the query region to a set of terms, and compute the union of
+    // the document ids associated with those terms.  (An actual information
+    // retrieval system would do something more sophisticated.)
+    std::set<int> candidates;
+    for (const auto& term : indexer.GetQueryTerms(query_region, kPrefix)) {
+      candidates.insert(index[term].begin(), index[term].end());
+    }
+
+    // "candidates" now contains all documents that intersect the query
+    // region, along with some documents that nearly intersect it.  We can
+    // prune the results by retrieving the original "document" and checking
+    // the distance more precisely.
+    std::vector<int> result;
+    for (int docid : candidates) {
+      if (!query_region.Contains(documents[docid])) continue;
+      result.push_back(docid);
+    }
+    // Now do something with the results (in this example we just count them).
+    num_found += result.size();
+  }
+  std::printf("Found %" PRId64 " points in %d queries\n",
+              num_found, FLAGS_num_queries);
+  return  0;
+}

package/third_party/s2geometry/doc/examples/term_index.py

@@ -0,0 +1,101 @@
+"""
+This example shows how to add spatial data to an information retrieval
+system.  Such systems work by converting documents into a collection of
+"index terms" (e.g., representing words or phrases), and then building an
+"inverted index" that maps each term to a list of documents (and document
+positions) where that term occurs.
+
+This example shows how to convert spatial data into index terms, which can
+then be indexed along with the other document information.
+
+This is a port of the C++ term_index.cc example for the Python API.
+"""
+import argparse
+from collections import defaultdict
+
+import pywraps2 as s2
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=(
+            "This example shows how to convert spatial data into index terms, "
+            "which can then be indexed along with the other document "
+            "information."
+        )
+    )
+    parser.add_argument(
+        '--num_documents', type=int, default=10000, help="Number of documents"
+    )
+    parser.add_argument(
+        '--num_queries', type=int, default=10000, help="Number of queries"
+    )
+    parser.add_argument(
+        '--query_radius_km', type=float, default=100,
+        help="Query radius in kilometers"
+    )
+
+    args = parser.parse_args()
+
+    # A prefix added to spatial terms to distinguish them from other index terms
+    # (e.g. representing words or phrases).
+    PREFIX = "s2:"
+
+    # Create a set of "documents" to be indexed.  Each document consists of a
+    # single point.  (You can easily substitute any S2Region type here, or even
+    # index a mixture of region types using S2Region.  Other
+    # region types include polygons, polylines, rectangles, discs, buffered
+    # geometry, etc.)
+    documents = []
+    for i in range(args.num_documents):
+        documents.append(s2.S2Testing.RandomPoint())
+
+    # We use a dict as our inverted index.  The key is an index term, and
+    # the value is the set of "document ids" where this index term is present.
+    index = defaultdict(set)
+
+    # Create an indexer suitable for an index that contains points only.
+    # (You may also want to adjust min_level() or max_level() if you plan
+    # on querying very large or very small regions.)
+    indexer = s2.S2RegionTermIndexer()
+    indexer.set_index_contains_points_only(True)
+
+    # Add the documents to the index.
+    for docid, index_region in enumerate(documents):
+        for term in indexer.GetIndexTerms(index_region, PREFIX):
+            index[term].add(docid)
+
+    # Convert the query radius to an angle representation.
+    radius = s2.S1Angle.Radians(s2.S2Earth.KmToRadians(args.query_radius_km))
+
+    # Count the number of documents (points) found in all queries.
+    num_found = 0
+    for i in range(args.num_queries):
+        # Choose a random center for query.
+        query_region = s2.S2Cap(s2.S2Testing.RandomPoint(), radius)
+
+        # Convert the query region to a set of terms, and compute the union of
+        # the document ids associated with those terms.  (An actual information
+        # retrieval system would do something more sophisticated.)
+        candidates = set()
+        for term in indexer.GetQueryTerms(query_region, PREFIX):
+            candidates |= index[term]
+
+        # "candidates" now contains all documents that intersect the query
+        # region, along with some documents that nearly intersect it.  We can
+        # prune the results by retrieving the original "document" and checking
+        # the distance more precisely.
+        result = []
+        for docid in candidates:
+            if query_region.Contains(documents[docid]):
+                result.append(docid)
+
+        # Now do something with the results (in this example we just count
+        # them).
+        num_found += len(result)
+
+    print("Found %d points in %d queries" % (num_found, args.num_queries))
+
+
+if __name__ == "__main__":
+    main()

package/third_party/s2geometry/src/python/coder.i

@@ -0,0 +1,125 @@
+//
+// Exposes Encoder and Decoder a subset of functionality plus the
+// ability to set and get internal buffer. This allows passing them
+// into other SWIG'd methods, such as those in the S2 SWIG library.
+// For example:
+//
+// class S2Polygon {
+//   ...
+//   void Encode(Encoder* const encoder) const override;
+//
+//   bool Decode(Decoder* const decoder) override;
+// };
+//
+// Usage:
+//   # data is a bytes object.
+//   dec = pywrapcoder.Decoder(data)
+//   polygon = s2.S2Polygon()
+//   polygon.Decode(dec)
+//
+//   enc = pywrapcoder.Encoder()
+//   polygon.Encode(enc)
+//   data = enc.buffer()
+//
+
+%{
+#include "s2/util/coding/coder.h"
+%}
+
+// For Decoder::reset to accept a bytes or bytearray object.
+%typemap(in) (const void* buf, size_t maxn) {
+  if (PyBytes_Check($input)) {
+    $1 = (void *) PyBytes_AsString($input);
+    $2 = PyBytes_Size($input);
+  } else if (PyByteArray_Check($input)) {
+    $1 = (void *) PyByteArray_AsString($input);
+    $2 = PyByteArray_Size($input);
+  } else {
+    PyErr_Format(PyExc_TypeError,
+                 "bytes or bytearray needed, %s found",
+                 $input->ob_type->tp_name);
+    return nullptr;
+  }
+};
+// For Encoder::reset to accept a bytearray object.
+%typemap(in) (void* buf, size_t maxn) {
+  if (PyByteArray_Check($input)) {
+    $1 = (void *) PyByteArray_AsString($input);
+    $2 = PyByteArray_Size($input);
+  } else {
+    PyErr_Format(PyExc_TypeError,
+                 "bytearray needed, %s found", $input->ob_type->tp_name);
+    return nullptr;
+  }
+};
+
+// Keep a reference to the object so that outside users don't
+// have to keep one, or else it could be released.
+// The auto-generated code passes *args to each of the methods, but the use
+// cases we support is only when a single arg is passed in.
+%pythonprepend Decoder::Decoder %{
+  if len(args) == 1:
+    self._data_keepalive = args[0]
+%}
+
+%pythonprepend Decoder::reset %{
+  self._data_keepalive = args[0]
+%}
+
+%extend Decoder {
+  // Allows direct construction with a bytes or bytearray objects.
+  Decoder(PyObject *obj) {
+    if (PyBytes_Check(obj)) {
+      return new Decoder(PyBytes_AsString(obj), PyBytes_Size(obj));
+    }
+    if (PyByteArray_Check(obj)) {
+      return new Decoder(PyByteArray_AsString(obj), PyByteArray_Size(obj));
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "bytes or bytearray needed, %s found", obj->ob_type->tp_name);
+    return nullptr;
+  }
+}
+
+%extend Encoder {
+  // Returns internal buffer as a bytearray.
+  PyObject* buffer() {
+    return PyByteArray_FromStringAndSize($self->base(), $self->length());
+  }
+}
+
+%ignoreall
+
+%unignore Decoder;
+%unignore Decoder::Decoder();
+%unignore Decoder::Decoder(const void*, size_t);
+%unignore Decoder::~Decoder;
+%unignore Decoder::avail() const;
+%unignore Decoder::get8();
+%unignore Decoder::get16();
+%unignore Decoder::get32();
+%unignore Decoder::get64();
+%unignore Decoder::getfloat();
+%unignore Decoder::getdouble();
+%unignore Decoder::pos() const;
+%unignore Decoder::reset(const void*, size_t);
+%unignore Encoder;
+%unignore Encoder::Encoder();
+%unignore Encoder::Encoder(void*, size_t);
+%unignore Encoder::~Encoder;
+%unignore Encoder::Ensure(size_t);
+%unignore Encoder::avail() const;
+%unignore Encoder::buffer();
+%unignore Encoder::clear();
+%unignore Encoder::length() const;
+%unignore Encoder::put8(unsigned char);
+%unignore Encoder::put16(uint16);
+%unignore Encoder::put32(uint32);
+%unignore Encoder::put64(uint64);
+%unignore Encoder::putdouble(double);
+%unignore Encoder::putfloat(float);
+%unignore Encoder::reset(void *, size_t);
+
+%include "s2/util/coding/coder.h"
+
+%unignoreall