STB: space time boxes
Abstract
With the advent of the mobile era in the last decade and the evolution of the app economy in smartphones and other smart devices, there is an abundance of location data available. Traditional spatial analysis techniques are locked away in databases (such as DB2 Spatial, ESRI ArcGIS server, Oracle Spatial and Graph) that only enable basic analytics and do not scale very well to societal scale data. Moreover, these approaches tend to deal with only static objects, where time is not treated as a first class citizen. This paper introduces the idea of discretizing spacetime as a first order primitive to significantly alter downstream algorithms ranging from simple spatial indexing to complex deep learning that operate on such spacetime data. We coin the term space time box (STB) and propose this as a fundamental primitive of thinking about trajectories of moving objects. We substantiate and validate the concept of STB through various pieces of our past work. Finally, we show that 3D STBs can be used for efficiently tracking very fast moving objects (asteroids), which was never before been done.
Keywords
Space time box Geospatial Geohash Asteroid1 Introduction
Mobile devices such as smartphones and incar navigation systems have become quite popular in the last decade. As these devices collect location data over time, there is an abundance of space and time data that has become available. Examples of applications that collect such spacetime data are mapping apps (Google Maps, Bing Maps), car apps (Progressive insurance), weather applications (AccuWeather, Weather), and many more. This spacetime data has been used for urban planning, forecasting traffic conditions, and predicting spread of viruses (Kitamura et al. 2000; Eubank et al. 2004; Gonzalez et al. 2008). In addition to mobile devices owned by regular consumers, other moving objects such as airplanes, ships, and even astronomical objects are monitored and location data collected from these objects. Enterprise focused applications such as safety and security and optimization of airtraffic flows are enabled through the collection and analysis of the spacetime data (in such environments). A key challenge that arises in such location data analysis is that of being able to store, query, and build machine learning models on societal and enterprise scale volumes of spacetime data (Ganti et al. 2016; Srivatsa et al. 2017).
In order to address the problem of being able to store, query, and learn patterns from these spacetime data, we introduce the notion of encoding location at a given time as a discrete entity, convert a continuous trajectory into a discrete trajectory. We coin the term space time box (STB), a snapshot of the moving object. STB can be thought of as a region in spacetime where the object dwells during a time period and within the limits of a spatial region. The concept of STB is fairly generic and is analgous to the digitization of a continuous signal, such as an AD converter. This digitization of space and time fundamentally changes the way one thinks about trajectories; paving the way for new algorithms that enable fast querying of spacetime data on distributed platforms. Further, the choice of the right encoding/digitization allows for hardware acceleration and many of the spacetime operations to be implemented using digital logic, which provide several orders of magnitude speedup (on all the queries).
We used the concept of STBs in tackling various problems that range from encoding of spatial operations in hardware using FPGAs, indexing and querying spacetime data on distributed noSQL stores, and using deep convolutional neural networks for predicting housing prices (Lee et al. 2014, 2016; Li et al. 2015, 2017; Moussalli et al. 2015; Ganti et al. 2016; Srivatsa et al. 2017; Bency et al. 2017). In this paper, we introduce in a more formal manner the concept of STB (space time box) and show that all of our work derives from this fundamental and novel concept. Thus far, our work had focused on only motion in twodimensional space. In this paper, we show that STBs in three dimensions are extremely useful in solving astronomical problems. We use 3D STBs to solve the problem of predicting asteroidasteroid flybys, which is a fundamentally challenging problem in the astronomy community. We also note that 3D STBs are useful in ncoding and analyzing objects that are in 3D space, such as planes and drones.
The fundamental contribution of this paper is to show how the fundamental concept of STB is applicable to a wide array of algorithms on various moving objects (whether on the Earth, flying in the air, or moving in the cosmic space). We expand on STBs and their key algorithmic properties in the next Section. We will then summarize the body of work that used STBs in various forms in Sects. 3 and 4. We will go into depth about the asteroidasteroid flyby detections/prediction in Sect. 5. The goal of this paper is to show the broad applicability of STBs, in application domains with different types of moving objects or in algorithms for querying and machine learning as well as hardware based acceleration of the various algorithms. As such, we note that the goal of this paper is not to cover any single algorithm, which is done in a piecemeal fashion in our previous work, but to apprise the research community of the benefits of the concept of STB (and different ways of implementing/realizing it). STBs provide a fundamentally new way of thinking about spacetime related problems, the discretization fo space/time while preserving key properties of the underlying trajectory is a powerful construct and has the potential to dramatically change the way the research community has been working with such spacetime data.
2 STB: space time box
STB is a generic technique that discretizes space and time, thus allowing trajectories that are continuous in space and time to be digitized and far more amenable to algorithms for computer systems (we will show later how a specific realization of STB has resulted in significant speedup in spatial indexing and advances in deep learning algorithms). A key question that remains is how to discretize time and space that best achieves performance. We examined several approaches to discretize space and time in our past work (Li et al. 2015, 2017) and we believe that geohashes (Niemeyer 2008) are computationally most efficient in terms of discretizing space and time. We note that geohashes as described in existing literature are applicable to space only, we can extend this to include time as well with simple mechanisms of interleaving a time range as well. For ease of explanation, we will only focus on the encoding of space; with the extensions to multiple dimensions being trivial.

Deterministic hashing, i.e., an object’s coordinates should be deterministically map always to a set of keys. In general, each hash value h covers a region, such that all points within that region are mapped to the same value h. Deterministic hashing allows for the generation of keys that can be directly used in a distributed scalable keyvalue stores, and thus enable fast queries on spatiotemporal data. Further, deterministic hashing allows for the mapping of each hash value to a state, which can be used to model trajectory movements easily.
 Extensible/telescopic hashing, i.e., an object’s coordinates should be mapped to an extensible key such that mapping at different spatial resolutions result in consistent key assignment. An example of extensible hashing over two dimensional coordinates with gradual precision loss (based on key length) is shown below. Given two hashes h and \(h'\) that covers regions r and \(r'\) respectively; in extensible hashing, if h is a prefix of \(h'\) then region \(r'\) is fully contained in region r. Extensible hashing enables variable sampling rates, for example if one were to use a key of length 64, it would result in no sampling at all, whereas a key of length 25 might result in a sampling ratio of 20. An important point to note here is that the sampling ratio when using such a spatial encoding mechanism is data dependent. Further, extensibility yields keys that can not only be used in keyvalue stores, but also directly support multiresolution spatial analysis of the data (e.g., zoom into the vicinity of a particular location). We show below the base32 encoding of the geohashes for different latitude/longitude values and illustrate the telescopy property in Fig. 2.$$\begin{aligned} hash(40.00105, 78.30105) & = {} dr07d1yzj21 \\ hash(40.001, 78.301) & = dr07d1yy \\ hash(40.01, 78.2) & = dr07se \\ hash(40, 78) &= dr0e \\ \end{aligned}$$

Uniform density hashing, i.e., the technique must support a choice of keys such that given any set of points, the number of points mapped to a given key is nearly equal for all the keys. This allows for a bound on the number of keys that are used at a given granularity and thus enabling variable resolution encoding.

Bit arithmetic for manipulating the keys and performing various operations on the keys such as truncate, distance between the keys, and identifying neighboring keys in the 2D space, this enables extremely fast operations on modern processors, GPUs and FPGAs. This enables significant speedups on various spatial operations, which we will show in the later sections.
Summary of differences in properties across various spatial sampling techniques (\(^*\)  d is the dimension of the KDtree)
Index name  Deterministic  Extensible  Uniform  Bitwise 

Grid  \(\checkmark\)  ×  Unbounded  × 
Quadtree  ×  \(\checkmark\)  4×  × 
KDtree  ×  \(\checkmark\)  d×\(^*\)  × 
Rtree  ×  \(\checkmark\)  1×  × 
Geohash  \(\checkmark\)  \(\checkmark\)  1–2×  \(\checkmark\) 
3 Algorithms on STB
In the previous section, we described the concept of a SpaceTime Box (STB) and realized an instance of this using geohashes as the technique to implement them. We will now describe various algorithms that utilize this particular version of the STB. The first is a technique to sample the data while preserving the spatial locality and certain key properties of the trajectory data (spacetime). Such data sampling techniques can ameliorate the volumes of data collected as well as improve the compute times needed for building models. The second is a suite of techniques to index and query spatiotemporal data using STBs. These techniques are targeted toward distributed keyvalue stores that provide high throughput querying capabilities, but lack spatiotemporal support (in the last few years, support has been added, but even now, there is no native spatiotemporal support available for many of the noSQL stores). Finally, the STB concept can be applied to deep learning on satellite imagery, specifically to predict housing prices. These algorithms are described in detail in the authors’ past work and will be summarized in the rest of this section briefly. Another interesting application of the STBs in 3dimensional space and time is that of tracking asteroids, which will be covered in detail in the next Section. Such a wide applicability of the concept of STB (and its realization using geohashes) indicates that the choice of using this particular realization is quite fruitful.
3.1 Sampling of data
As location data is being collected at societal scale (e.g., cars with GPS sensors, various apps on phone), a key question is if all of this data is needed for modeling and machine learning purposes. A key question that we address in our previous work (Srivatsa et al. 2017) is that of subsampling these location traces while preserving the amount of information present in such datasets. We developed a novel subsampling technique that uses the STB geohash to enable efficient spatial cluster sampling. The technique itself is detailed in our previous work (Srivatsa et al. 2017), the key highlight is to select only a small sample of the data from a given spacetime box at a given granularity. The granularity is defined by the size of the spacetime box. Spatiotemporal information loss is measured by modeling the trajectory as a Markovian chain and different theoretical measures are obtained on these Markov chains, specifically (1) statespace error metric, (2) KLdivergence, (3) mixing time, and (4) perplexity measure. Subsampling can be performed to reduce the data by 75% while not significantly reducing the amount of information as characterized by the above four metrics. The spatial locality based hashing and the fast computation of these hashes enables efficient subsampling, thus making any of the pattern larning and downstream machine learning quite efficient.
3.2 Indexing of spatiotemporal data
3.3 Deep learning
The key idea of our work in Bency et al. (2017) was to let the DCNN learn these various features using different granularity STBs, each DCNN at a given zoom level learns a set of features (e.g., zoom level 17 may learn the presence of trees in the neighborhood, zoom level 18 may learn the presence of a swimming pool). These extracted features are then combined with the description of the house (e.g., number of rooms, square footage) and a model is trained. We showed that such a model outperforms traditional approaches such as SAR (Spatial Auto Regression) and Random Forest significantly (up to 34.5% reduction in RMSE). This is a novel application of the multilevel/telescopy feature of the STB.
4 Hardware acceleration
A key feature of the STB encoding that we alluded to earlier in Sect. 2 is that of bit arithmetic making it amenable to hardware acceleration. Hardware acceleration allows for extremely fast computations on spatiotemporal data. Speedups of up to 1000× over traditional software approaches can be achieved using hardware implementations. We proposed and implemented two different hardware acceleration approaches, one using FPGAs (Moussalli et al. 2015; Lee et al. 2016) and the second using Ternary Content Addressable Memories (TCAMs) (Ganti et al. 2016).
4.1 FPGAs
The STB encoding is a bitlevel encoding with simple bit operations mapping to spatial predicates, for example a prefix match indicates a containment relationship (within a certain degree of granularity). One way to exploit this property is through the use of FPGAs that allow for encoding the various spatial predicates (e.g., topological containment, touch). From an FPGA implementation standpoint, we can break the spatial predicate evaluation pipeline into four stages, (1) preprocessing, involves encoding the STBs and sorting them based on their lengths, (2) breakpoint identification, the first bitlevel difference between two geohashes (which is identified through a simple XOR operation), (3) mask generation, different types of masks for blocking unnecessary bits of the encoding, and (4) contains operation, this is equivalent to a prefix matching operation on the encodings. The details of these steps and their implications on various spatial predicates can be found in Moussalli et al. (2015) and Lee et al. (2016). We show that all the spatial operations can be achieved using the above four steps. These steps are realized using FPGAs, which provides a 2090x speedup over the software implementations of these various operations.
4.2 TCAMs
TCAMs—Ternary Content Addressable Memory is a hardware device that is routinely used in network routers for IP address matching and routing of the queries. TCAMs operate at billions of matching operations per second including prefix based matching. In order for indexing to work with a TCAM based approach, we need to realize a softwareonly approach that implements spatial queries as simple bit level arithmetic (e.g., boolean AND, OR). Once the spaiotemporal data is encoded through the use of STBs (realization through geohashes), we show that all the spatial (and temporal) queries can be achieved using simple bit level operations (details can be found in our previous work Ganti et al. (2016)). These queries are realized through a hierarchical representation of the encoding using a PATRICIAtrie (Morrison 1968). These bitlevel query operations are primarily prefix matching at a bit level, which is very common in TCAMs. We implemented these operations in an offtheshelf TCAM (Cisco ASR 1000 ESP), which provided a 1000x speedup in all the spatial operations.
5 Asteroid collision detection
In this section, we show how a three dimensional extension of the STB implementation can be used to solve an astronomical problem. The problem is that of being able to compute if two asteroids will intersect each other in a given time frame (the time could be in to the future as well). Before we describe the problem in further detail, we will provide a brief background and also note that this portion of the work has not been previously published.
5.1 Background
5.2 Detecting asteroid flybys
The challenge we face from a computational standpoint is to be able to compute the asteroids that are near each other in space at a given time and use this information to account for the changes in the trajectories of the asteroids that flyby each other.
From a computational standpoint, the problem of pruning objects beyond a certain distance is analogous to indexing moving objects in the 3D space. As new asteroids are discovered routinely and Nbody simulations are compute intensive, we seek a solution that can be deployed and scaled on emerging distributed platforms such as Hadoop, Spark, and Streams. Our approach is to rely on fast and efficient distributed keyvalue stores such as HBase, REDIS, which are capable of performing range queries (get all records whose key is within a range (a, b)) very efficiently.
A basic challenge for this approach to work is to be able to index the 3D location of an asteroid and update the location of the asteroid as well as perform fast queries. Current keyvalue stores support efficient queries only when the key is single dimensional and do not provide support for multidimensional keys.
However, a problem arises when two asteroids are in adjacent space boxes, but still close to each other (within the specified distance). In this situation, one needs to do an additional check, i.e. if two asteroids’ STB mappings are neighbors. This process is illustrated in Fig. 7. Note that neighborhood checks on two keys can be accomplished using simple bit arithmetic on the key values. In the worst case the number of neighbors of one space box in 3D is \(3^31 = 26\). However, in practice, one needs to explore neighboring space boxes only if the object is close to the boundary of its space box; and if the object is close to the boundary only a small subset of these 26 neighbors are relevant for spatial analysis. Given a point (x, y, z) depending on whether on one, two or all three dimensions the point is close to the space box boundary, we have one, three and seven neighbors respectively.
We remark for a randomly chosen point, the likelihood one, two or three dimensions of the point being close to the space box boundary exponentially decreases; thus the likelihood of the number of neighbors being 0, 1, 3 and 7 also exponentially decreases. Indeed the expected number of neighbors for a randomly chosen point with distance threshold set to half the space box size (in each dimension) is 3.125. We will utilize this space box approach for pruning the search space and significantly reducing the number of objects being considered when we perform the Nbody simulations to determine the new orbital elements for a given asteroid.
We will combine the above concepts to develop an endtoend algorithm for identifying pairwise asteroids that flyby within a certain distance (for a given time). As these objects are constantly moving, our approach is to consider all the possible locations of an asteroid during a given time interval. We introduce the notion of a 3D STB, which is comprised of a 3D space box and a time range. Hence, an asteroid’s current location at a given time is mapped to a 3D space box (with interleaved coordinates as specified above) and a time range (e.g., given time range parameter as one day, an asteroid which is say at Earth time 19:30 July 30, 2015 will be mapped to the time range of July 30, 2015, 19:00 to 20:00 ). Once the asteroids are mapped to their STBs at a chosen granularity, neighbors that are farther than a certain distance during a certain time range can be pruned. The asteroids that are within a certain distance during a specific time range (and the major objects such as the 8 planets and sun) are provided as input to the timestep Nbody simulator. The simulator then determines the exact locations of the asteroids at the end of the time window. We then use interpolation techniques for the specified time window to check if a pair of asteroids’ paths intersect or are within a certain distance parameter.
We observe that the choice of the granularity of the space box and time range is going to impact the performance of the algorithm. If a large spacetime box is chosen, then a larger number of asteroids need to be considered for the exact simulations, which affects the performance. If a really small spacetime box is chosen, then the accuracy of the simulations will be affected. The first step in our algorithm is to choose a time range – [t1, t2] (in this case, we chose one day based on empirical observations) and then forecast the location of each of the 600k asteroids at time t2 (given the location at time t1). This first step uses only the effects of the 8 planets and sun in the simulator. Once the locations of asteroids at time t2 are determined, we choose a space box size (in our case, 0.01 AU) and identify those asteroids that are within a distance of 0.01 AU from each other. Again, the distance is chosen based on empirical observations. Once the asteroids that are within a certain distance are identified, we rerun the simulations for a smaller time range (we chose one hour) for only those asteroids that are within the specified distance. We note that the reason to rerun the simulations is because it is highly space inefficient to keep all the locations of every asteroid during the oneday time range for the time steps (of the simulator). To give the reader a rough idea of the extent of disk space required, one year’s worth of data requires 250GB of free disk space for each asteroid when only time steps of one day intervals are stored. Further, we note that the number of asteroids involved in the smaller time range simulation is significantly lesser (in the order of a few tens). Finally, we use the smaller space box (of size 0.001 AU) to identify which asteroids are near each other and then interpolate if their paths intersect. The interpolation method that we use is a simple linear interpolation. This hierarchical descent approach can be applied further to improve the accuracy of reports by choosing a smaller time range and a space box. We also plan on exploring different interpolation techniques such as elliptic arc interpolation.
Top three encounters by proximity
Encounter  Distance  A1  S1  A2  S2 

May 1, 2032 63353.9318 (MJD)  299 km  00A9170  2–4 km  0008758  4–9 km 
0.000002 (AU)  15.8 (H)  13.9 (H)  
Nov 24, 2016 57716.07911 (MJD)  449 km  00P5634  1–2 km  0055711  2–5 km 
0.000003 (AU)  17.4 (H)  15.5 (H)  
Jan 11, 2018 58129.29692 (MJD)  449 km  K08E88J  530–1200 m  00N0062  2–4 km 
0.000003 (AU)  18.3 (H)  15.8 (H) 
Top three encounters by size and within 0.01 AU of each other
Encounter  Distance  A1  S1  A2  S2 

Feb 18, 2028 61819.1561 (MJD)  70 K km  0000346  110–240 km  00A4356  2–5 km 
0.000469 (AU)  7.13 (H)  15.5 (H)  
Feb 28, 2031 62925.12725 (MJD)  54K km  0000348  35–75 km  00G7226  2–4 km 
0.000359 (AU)  9.4 (H)  16.1 (H)  
Oct 25, 2036 64991.01073 (MJD)  43K km  0000690  65–150 km  0083174  3–7 km 
0.000289 (AU)  8.02 (H)  14.3 (H) 
In the Tables 2 and 3, A1 refers to asteroid 1 and A2 refers to asteroid 2, S1 refers to size of asteroid 1 and S2 refers to size of asteroid 2. The encounter dates are provided in calendar time as well as astronomical time (expressed as MJD, Modified Julian Day, which is an unambiguous calendar system used in astronomy), the encounter distance is provided in kilometers and typically distances under a few thousand kilometers are considered as very close flybys, asteroids are identified using their universal codes assigned to them when they are discovered, the size of the asteroid is defined in kilometers as well as the term H, which is called the absolute magnitude and is the visual magnitude an observer would record if the asteroid were placed 1 Astronomical Unit (au) away, and 1 au from the Sun and at a zero phase angle. In fact, one of our predictions was observed by our partners, Institute of Astronomy, Hawaii using the largest land telescope (Lilly et al. 2015).
6 Related work
We will provide a brief overview of the related work relevant to this paper, the detailed related work on each of the algorithms can be found in the corresponding papers. Typical approaches to analyze trajectories model the trajectory as continuous movement pattern and develop techniques on these continuous movement lines (Han et al. 2001). On the other hand, our approach to analyzing trajectories is through the use of space time box (STB) and discretization of these trajectories. The discretization step fundamentally changes the way we analyze movement patterns, allowing us to use distributed computing as well as hardware acceleration.
We will provide a brief recap of the various pieces of related work to the algorithms summarized in this paper, the data sampling focuses on preserving spatial locality while allowing for characterizing the mobility patterns. Previous work (Gonzalez et al. 2008) has shown that human mobility is highly periodic, thus providing insights into why this spatial sampling approach might work.
Spatial and spatiotemporal indexing has received a lot of attention in the past, with basic approaches such as Rtrees (Guttman 1984) and grid indexing. The various approaches can be classified as either treebased or gridbased, a comprehensive summary of these indexing schemes is provided in (Šidlauskas et al. 2009), which also shows that grid indexes and treebased approaches can be tuned to achieve comparable performance. Some extensions to these approaches were performed to work with distributed platforms such as Hadoop and HBase (Nishimura et al. 2011). Our work on indexing shows that we can use the STB concept to use existing big data systems without any modifications and perform spatial/spatiotemporal indexing. Our approach is also shown to be scalable and more performant when compared to the other systems. Other approaches to improving indexing performance include leveraging moving object patterns to maximize the bandwidth and minimize unnecessary load on the index structure, lazy batch queries, which can be used to improve any indexing technique’s performance, including the one of STBs. In fact, we believe that the STB approach will be superior as once the encoding is performed, any further operations are on bitlevel representations with simple bit operations, which is faster than traditional geometry based approaches.
Finally, the deep learning application is a completely novel approach when compared to approaches that use Spatial Autoregression (SAR) (DUBIN et al. 1999) as they are capable of capturing multilevel complex features using STBs on satellite imagery.
Overall, we have shown that STB as a concept is a powerful construct when compared to the existing techniques in various domains from sampling to deep learning. We envision that many of the future algorithms should be implemented using this fundamental construct.
7 Conclusions and future work
This paper introduced a fundamental and powerful construct called the space time box (STB), a term that we coin in this paper. This construct allows the reader to think of movement data in a discretized manner. We use geohashes as a mechanism to implement the STB construct in 2 dimensions on the Earth’s surface and extend this to 3D space through application to heliocentric coordinate system. We summarize the body of work that we conducted (through publications at various venues) on the use of realization of the STB concept toward various algorithms. These algorithms cover sampling of data for reduction in data volumes while preserving data quality, indexing of spatiotemporal data in large scale distributed systems, and deep learning on satellite images to predict house pricing. We also show that the STB encodings and operations on STBs are realizable through the use of hardware – TCAMs and FPGAs, which provide orders of improvement in performance. Finally, this paper introduced for the first time the problem of asteroidasteroid flyby detection and the application of a 3D STB to develop an efficient mechanism for solving it. We also predict the flybys for the next 25 years and with the help of our partner institute, validate one of our predictions. To conclude, we firmly believe that the concept of an STB and its realizations through geohashes and applications to various spacetime problems is only the tip of the iceberg and that the future of machine learning and more complex trajectory algorithms is in the use of these STBs. We plan to pursue efforts in using STBs for trajectory mining as well as further spacetime based machine learning in the future.
Notes
Acknowledgements
The authors would like to acknowledge all the coauthors of the previous body of work that utilized STBs and the derivative concepts, Sameh Asaad, Archit Bency, Manjunanth B. S., Larry Denneau, Dajung Lee, Kisung Lee, Eva LillySchunova, Shen Li, Ling Liu, Roger Moussalli, Jorge Ortiz, Swati Rallapalli, and Petros Zerfos.
References
 Bency, A.J., Rallapalli, S., Ganti, R.K, Srivatsa, M., Manjunath, B.S.: Beyond spatial autoregressive models: predicting housing prices with satellite imagery. In: IEEE Winter Conference on Applications of Computer Vision (WACV), Santa Rosa, 24–31 March 2017. IEEE (2017). https://doi.org/10.1109/WACV.2017.42
 Dubin, R., Pace, K., Thibodeau, T.: Spatial autoregression techniques for real estate data. J. Real Estate Lit. 7(1), 79–95 (1999)CrossRefGoogle Scholar
 Eubank, S., Guclu, H., Kumar, V., Marathe, M., Srinivasan, A., Toroczkai, Z., Wang, N.: Modelling disease outbreaks in realistic urban social networks. Nature 429(6988), 180–184 (2004)CrossRefGoogle Scholar
 Ganti, R., Srivatsa, M., Agrawal, D., Zerfos, P., Ortiz, J.: Mptrie: fast spatial queries on moving objects. In: Proceedings of the Industrial Track of the 17th International Middleware Conference, Trento, 12–16 Dec 2016. https://doi.org/10.1145/3007646.3007653
 Gonzalez, M., Hidalgo, C., Barbasi, A.L.: Understanding individual human mobility patterns. Nature 453, 779–782 (2008)CrossRefGoogle Scholar
 Granvik, M., Virtanen, J., Oszkiewicz, D., Muinonen, K.: Openorb: Opensource asteroid orbit computation software including statistical ranging. Meteorit. Planet. Sci. 44(12), 1853–1861 (2009)CrossRefGoogle Scholar
 Guttman, A.: Rtrees: a dynamic index structure for spatial searching. In: Proceedings of ACM management of data (SIGMOD), Boston, 18–21 June 1984Google Scholar
 Han, J., Kamber, M., Tung, A.K.H.: Spatial clustering methods in data mining: a survey. In: Miller, H.J., Han, J. (eds.) Geographic Data Mining and Knowledge Discovery, Research Monographs in GIS. Taylor and Francis (2001)Google Scholar
 Kitamura, R., Chen, C., Pendyala, R., Narayanan, R.: Microsimulation of daily activitytravel patterns for travel demand forecasting. Transportation 27(1), 25–51 (2000)CrossRefGoogle Scholar
 Lee, K., Ganti, R.K., Srivatsa, M., Liu, L.: Efficient spatial query processing for big data. In: Proceedings of the 22nd ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems, Dallas, 4–7 Nov 2014. https://doi.org/10.1145/2666310.2666481
 Lee, D., Moussalli, R., Asaad, S., Srivatsa, M.: Spatial predicates evaluation in the geohash domain using reconfigurable hardware. In: IEEE 24th Annual International Symposium on FieldProgrammable Custom Computing Machines (FCCM), Washington, 1–3 May 2016. IEEE (2016). https://doi.org/10.1109/FCCM.2016.51
 Li, S., Hu, S., Ganti, R., Srivatsa, M., Abdelzaher, T.: Pyro: a spatialtemporal bigdata storage system. In: USENIX Annual Technical Conference, Santa Clara, 8–10 July 2015Google Scholar
 Li, S., Amin, M.T., Ganti, R., Srivatsa, M., Hu, S., Zhao, Y., Abdelzaher, T.: Stark: Optimizing inmemory computing for dynamic dataset collections. In: IEEE 37th International Conference on Distributed Computing Systems (ICDCS), Atlanta, 5–8 June 2017. IEEE (2017). https://doi.org/10.1109/ICDCS.2017.143
 Lilly, E., Jonas, J., Srivatsa, M., Ganti, R., Agrawal, D., Denneau, L., Kratky, M., Wainscoat, R.J.: Predicting close encounters between asteroids with the STB software. In: AAS/Division for Planetary Sciences Meeting Abstracts #47, vol. 47. American Astronomical Society (2015)Google Scholar
 Morrison, D.: Patricia—practical algorithm to retrieve information coded in alphanumeric. J. ACM 15(4), 514–534 (1968)CrossRefGoogle Scholar
 Moussalli, R., Srivatsa, M., Assad, S.: Fast and flexible conversion of geohash codes to and from latitude/longitude coordinates. In: IEEE 23rd Annual International Symposium on FieldProgrammable Custom Computing Machines, Vancouver, 2–6 May 2015. IEEE (2015). https://doi.org/10.1109/FCCM.2015.18
 Niemeyer, G.: Geohash. http://en.wikipedia.org/wiki/Geohash (2008)
 Nishimura, S., Das, S., Agrawal, D., Abbadi, A.E.: Mdhbase: A scalable multidimensional data infrastructure for location aware services. In: IEEE 12th International Conference on Mobile Data Management, Lulea, 6–9 June 2011. IEEE (2011). https://doi.org/10.1109/MDM.2011.41
 Šidlauskas, D., Šaltenis, D., Christiansen, C.W., Johansen, J.M., Šaulys, D.: Trees or grids?: indexing moving objects in main memory. In: Proceedings of the 17th ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems, Seattle, 4–6 Nov 2009, pp. 236–245. https://doi.org/10.1145/1653771.1653805
 Srivatsa, M., Ganti, R., Mohapatra, P.: On the limits of subsampling of location traces. In: IEEE 37th International Conference on Distributed Computing Systems (ICDCS), Atlanta, 5–8 June 2017. IEEE (2017). https://doi.org/10.1109/ICDCS.2017.82