List of project proposals

Mobile Map Tools

Mobile Map Tools (MMT) is a SDK designed for building multi-platform high-performance native mobile applications using the most appropriate technology for the target platform(s).

The framework core is built using C++ and is translated to Java and JavaScript to work in all platforms.

The main capabilities of MMT are:

  • Support for mobile maps in 2D, 2,5D and 3D
  • Works on iOS, Android, webGL
  • Works with real time data to integrate any kind of data (format,size, vector, raster, 3D, 4D)
  • Integrates with legacy systems
  • High performance mobile native development
  • Support for multi Touch screens
  • Addresses mobile performance as an integrated solution between server & client
  • Addresses the problem of software and hardware fragmentation

JTS Topology Suite

The JTS Topology Suite (JTS) is an open source Java software library that provides an object model for planar geometry together with a set of fundamental geometric functions. JTS conforms to the Simple Features Specification for SQL published by the Open GIS Consortium.  JTS is designed to be used as a core component of vector-based geomatics software such as geographical information systems. It can also be used as a general-purpose library providing algorithms in computational geometry.


GeoGit is a Distributed Version Control System (DVCS) specially designed to handle geospatial data efficiently. It takes inspiration from the source code versioning system Git, but has an approach suited to the spatial data it manages. GeoGit efficiently handles very large binary data, divided up into features with the opportunity to optimise spatial operations using a spatial index. This is in contrast to Git which handles large text data, divided up into lines.

Users are able to import raw geospatial data (currently from Shapefiles, PostGIS, MS SQLServer, or SpatiaLite) in to a repository where every change to the data is tracked. These changes can be viewed in a history, reverted to older versions, branched in to sandboxed areas, merged back in, and pushed to remote repositories.

GeoGit is available as a command line tool with the following commands:

  • add             Add features to the staging area
  • apply           Apply a patch to the current working tree
  • branch          List, create, or delete branches
  • cat             Provide content of an element in the repository
  • checkout        Checkout a branch or paths to the working tree
  • cherry-pick     Apply the changes introduced by existing commits
  • clean           Deletes untracked features from working tree
  • clone           Clone a repository into a new directory
  • commit          Record staged changes to the repository
  • config          Get and set repository or global options
  • conflicts       Shows existing conflicts
  • diff            Show changes between commits, commit and working tree, etc

GeoGit is also provided as a Java Library for direct use.



GeoJinni is a comprehensive extension to Hadoop that allows efficient processing of spatial data. It injects spatial awareness in the different layers and components of Hadoop to make it more suitable and more efficient to store and process bug spatial data. More specifically, it modifies the storage layer, MapReduce layer and adds a new operations layer.

In the lowest level, it adds new data types for spatial data that can be used as keys or values in a MapReduce program. It also adds parsers and writers for interaction with files containing spatial data. Unlike traditional Hadoop where data in files are unorganized, GeoJinni provides efficient spatial indexes which are organized in two layers, global index and local index. The global index partitions data across different machines whereas local indexes organizes data inside each machine. This design is utilized to build three different indexes in GeoJinni, namely, Grid File, R-tree and R+-tree. All these indexes can be constructed upon user request and stored in the Hadoop Distributed File System (HDFS).

To allow MapReduce programs to use the constructed indexes, we add two new components to the MapReduce layer, namely, SpatialInputFormat and SpatialRecordReader. The SpatialInputFormat utilizes the global index by early pruning file partitions that are outside query range. The developer can choose which partitions to load based on a spatial FILTER function which is defined in the MapReduce program the same way the map and reduce functions are defined. The SpatialRecordReader utilizes the local index by allows the map function to choose only a subset of records to process instead of processing all records in a block.

The new components in the MapReduce layer allows GeoJinni to run many spatial operations efficiently by utilizing the underlying indexes. The operations layer encapsulates all the spatial operations to allow end users to access them quickly and efficiently. Current, GeoJinni has a dozen of operations including range query, k nearest neighbors, spatial join, convex hull, polygon union, closest pair, farthest pair, and skyline. Developers can add more operations by utilizing the new components added to GeoJinni.

GeoJinni can be installed as an extension to an existing Hadoop cluster. This means that you can run it without the need to giveup your current configuration or distribution of Hadoop. This makes it portable to run with a wide range of Hadoop distributions including Apache Hadoop, Cloudera, and Hortonworks.


The core GeoTrellis framework provides an ability to process large and small data sets with low latency by distributing the computation across multiple threads, cores, CPUs and machines.  The software includes the ability to rapidly process and distribute processing of raster data as well as data import and conversion tools for the ARG data structure.

GeoTrellis is a general framework for low-latency geospatial data processing developed using Scala and Akka.  The goal of the project is to transform user interaction with geospatial data by bringing the power of geospatial analysis to real time, interactive web applications.  It is complementary to other open source geospatial projects such as GeoServer, OpenLayers and PostGIS.  GeoTrellis was designed to solve three core problems, with an initial focus on raster processing: 

  1. Create scalable, high performance geoprocessing web services;
  2. Create distributed geoprocessing services that can act on large data sets; and
  3. Parallelizing geoprocessing operations to take full advantage of multi-core architectures

GeoTrellis spatial data processing is organized into Operations.  Multiple operations can be composed into Models.  Operations include Local, Focal and Zonal operations for raster data, vector-raster conversion and network operations.   A geoprocessing model in GeoTrellis is composed of smaller geoprocessing operations with well-defined inputs and outputs.

GeoTrellis is designed to help a developer create simple, standard REST services that return the results of geoprocessing models.  Like an RDBS that can optimize queries, GeoTrellis will automatically parallelize and optimize geoprocessing models where possible.  In the spirit of the object-functional style of Scala, it is easy to both create new operations and compose new operations with existing operations.


Spatial4j is a general purpose spatial / geospatial ASL licensed open-source Java library. Its core capabilities are 3-fold: to provide common geospatially-aware shapes, to provide distance calculations and other math, and to read and write the shapes to strings.


  • Shape classes that are geospatially aware(*)
    • Shapes: Point, Rectangle, Circle, Polygon (via JTS)
    • shape intersection logic, yielding: disjoint, contains, within, intersects
    • bounding box
    • area calculation
  • Distance math
    • Spherical: Law of Cosines, Haversine, Vincenty
  • Input and Output of shapes to strings using WKT
  • Integration with JTS to adapt its shapes to Spatial4j’s interfaces, including adding some geospatial awareness
  • No runtime dependencies unless JTS is needed

In addition, the code is well tested and it’s monitored via Travis-CI continuous integration.

(*) Geospatial awareness, AKA "geodetic" means it is aware of the implications of the international dateline and poles. It can’t pretend the earth is flat and infinitely large.


GeoMesa is a suite of geospatial libraries and tools built on top of Geotools and Accumulo, a column-family oriented distributed database. GeoMesa contains a spatio-temporal indexing structure that enables efficient storage, querying, and transformation capabilities for large spatio-temporal data sets. The spatio-temporal index and querying capabilities are exposed as Geotools DataStores, FeatureSources, FeatureReaders and other relevant Geotools interfaces thus providing transparent access to Accumulo as a data store to users of the Geotools APIs. GeoMesa implements several spatial algorithms and transformation functions in parallel using Accumulo's custom iterator extension capability as well as Map/Reduce jobs for data ingest and processing. GeoMesa has a WFS plugin to Geoserver that allows Geoserver administrators to connect to an Accumulo data source and expose a table as an OGC service over HTTP. Additionally, GeoMesa provides support for rendering raster data stored in Accumulo through an implementation of Geoserver's WMS plugin interface.

Geoff (Geo Fast Forward)

As we know, 80% of any kind of data is said to have some geospatial relevance. There are many Eclipse RCP applications connected to data sources (RDBMS, EMF models, Files, etc.) of valuable information that need to be explored and visualized geographically. Unfortunately, many users and/or developers in their respective business domains are not familiar with the rather complex geospatial topics. But, they are the experts of those domains. The problem is how to make them get their feet wet and start exploring their data sources from a geospatial point of view. As fully-fledged Geographic Information Systems (GIS) tend to be even more complex to deal with just to show some POIs (points of interest) on a map, the entry barriers are rather very high.

This project aims at simplifying the process for integrating existing business applications connected to some kind of data sources into the geospatial domain. Its intent is to provide a simple to use framework and/or tools collection for visualizing geospatial data on a geographical map embedded into Eclipse RCP applications.


GeoScript adds spatial capabilities to dynamic scripting languages. Backed by the GeoTools library, GeoScript provides a collection of modules for geometry handling, spatial data access, and vector feature rendering. Current implementations exist in Groovy, JavaScript, Python, and Scala. In a "stand-alone" context, GeoScript can be used to automate data manipulation tasks (e.g. load a batch of data into a database, applying a transform on the way) or explore data characteristics with an interactive shell. GeoScript can also be embedded into other applications running on the JVM (e.g. extending new processing capabilities to a GeoServer instance).

User-friendly Desktop Internet GIS (uDig)

uDig is an open source desktop application framework, built with Eclipse Rich Client (RCP) technology. uDig provides a complete Java solution for desktop GIS data access, editing, and viewing.

  • User friendly: familiar graphical environment for GIS users;
  • Desktop appliation: running as a thick client, natively user interface on Windows, Mac OS/X and Linux
  • Internet: supporting standard (WMS, WFS, WCS,KML) and de facto (GeoRSS, tiles) geospatial web services
  • GIS: framework for spatial data exploration and analysis