Paul’s Perspective on FOSS4G 2014

FOSS4G 2014

The world of open source geospatial gathered itself together again last week, as Boundless joined almost 900 developers, users and managers at FOSS4G 2014 in Portland, Oregon. This is the ninth such gathering I’ve attended, and they all have a special local flavour: in this case the flavour of locally-sourced ingredients and micro-brewed beer.

Exciting Technology

Each year also has it’s own favored technology, the topic that packs rooms and spills attendees into the halls: in the early days, MapServer and then PostGIS; Java technology like GeoServer and GeoTools; the first open source slippy maps like OpenLayers; new server technologies like Node.js. This year the topics that I observed drawing in the big crowds were vector tiles and drones.

Vector tiles are close to home, a technology I understand and have experimented with, and if PostGIS, GeoServer and OpenLayers are not producing and consuming vector tiles within a year I will be surprised. There’s lots of demand for the technology, a solid use case in mobile clients, and a clear implementation path forwards.

Drones, on the other hand, represent a whole new opportunity for open source since, like open source software, cheap drones and sensors democratize information about location. Cheap tools and open software are a great match. Aaron Racicot shared his experience building a quadrocopter for image acquisition for under $700, and Stephen Mather described how he processes drone photos from imagery into a 3D point cloud and textured terrain mesh using open source tools. From here it’s not hard to imagine a future where a digital model of a city could be automatically and continuously updated from the cameras of hundreds of personal drones swooping around.

New Ideas

In talks there were some great examples of Spatial IT: building tools that integrate spatial thinking with existing IT architectures and data flows. For example, the improved MapFish Printing module, which may find its way into OpenGeo Suite over the next year, is centered around producing reports (which might contain maps) rather than producing maps (that may have some reporting).

Similarly, practical and incremental transformation stories from proprietary to open source were common. Sara Safavi presented basic case studies and patterns for integrating open source into proprietary shops: web first, database first, or desktop first, but never all at once. Karl-Magnus Jonsson shared the story of his city’s move from 100% proprietary to 100% open source over several years of gradual transformation: first the web, then the database, and finally then the desktop.

Growing Community

On the show floor was the usual collection of companies like ourselves supporting particular open source projects for enterprises, but a few companies in different but important categories: Amazon and OpenShift, promoting the deployment of open source geospatial systems on their platforms; and PlanetLabs, talking about their new sources of earth imaging. As the open source economy grows, the number of companies that generate value indirectly from and for open source is growing along with it.

Next year FOSS4G will be in Seoul, South Korea, which will give international attendees a great opportunity to learn what is happening in Asia in general and the Korean technosphere in particular. I’m anticipating seeing some truly outstanding work that would otherwise be very hard to discover, it’s going to be a must-attend event.

Thanks to the organizers in Portland for a seamless and enjoyable event! And thanks for putting a bird on it!

The Spatial IT Job Board

CareersThose of you who’ve seen Paul Ramsey’s Spatial IT and the Spatial Web presentation or read Michael Terner’s blog piece know that we see a great future for software developers and IT professionals with an interest in spatial technology. Below are several job openings we’ve seen in the past month.

Job Listings

There are plenty of opportunities for Spatial IT professionals but if we missed any relevant positions please contact us and we’ll be sure to include them in future job board posts.

Announcing QGIS support offerings!


Over the past two years, our involvement with QGIS has steadily grown. We hired Victor Olaya, participated in community events such as the Inaugural US QGIS  Users Group meeting and the C Tribe Sprint, and developed easy-to-install QGIS packages and OpenGeo Suite integration. Today, we’re excited to announce new QGIS support offerings just in time for FOSS4G!

When we introduced our plugin for managing data and publishing layers from QGIS, we knew it would be a powerful interface for desktop GIS analysts wanting to configure OpenGeo Suite from the desktop. The plugin provides greater integration between QGIS and components such as PostGIS and GeoServer, facilitating the management and analysis of spatial data, deployment of web services, and development of web applications using OpenGeo Suite. This meets the needs of experienced GIS analysts and the growing number of developers for whom GIS is one part of a larger Spatial IT challenge.

Now offering QGIS support!

Our new QGIS support options start at $150 per seat and are available to OpenGeo Suite Enterprise customers seeking support for desktop GIS users. Download our hassle-free QGIS packages for Windows and OSX and contact us to get started.

Stay tuned for several QGIS training offerings from Boundless in the future.

QGIS and OpenGeo Explorer plugin

Learn more

Read these previous posts for more about QGIS and our efforts around the project:

Attending FOSS4G? Try our QGIS for Analysts workshop on Tuesday afternoon!

Boundless is heading to Portland for FOSS4G 2014!

FOSS4G 2014Next week, several members of the Boundless team are heading to Portland for the annual FOSS4G conference. We look forward to this conference every year as it’s the best place to exchange ideas about open source spatial software with our customers, partners, and friends. We’re proud to be sponsors and be participating in at least nine presentations and nine workshops — even more than last year!

Come by booth #16 to meet our experts and learn about the newest version of OpenGeo Suite and other tools we’re working on. Don’t forget to register for field trips and check out the social calendar as well!

Here’s a list of many of the events we’re involved with:

DateEventStart TimeSpeaker/Attending
9/8/2014OpenLayers 3: First Contact8:00Andreas Hocevar with Marc Jansen, Éric Lemoine, and Tim Schaub
Building Apps with OpenLayers13:00Andreas Hocevar
Introduction to PostGIS13:00Paul Ramsey
9/9/2014GeoTools DataStore Workshop8:00Jody Garnett and Eva Shon with Tom Kunicki
Introduction to GeoServer8:00Mike Pumphrey
Versioning Spatial Data with GeoGig (formerly GeoGit)8:00Benjamin Trigona-Harany
GeoServer Cartography and Styling13:00Jody Garnett, Eva Shon
GeoWebCache in Production13:00Mike Pumphrey
QGIS for Analysts13:00Benjamin Trigona-Harany
9/10/2014GeoServer Feature Frenzy10:00Jody Garnett and Justin Deoliveira with Andrea Aime and others
The Manager’s Guide to PostGIS11:00Paul Ramsey
GeoScript: A Geospatial Swiss Army Knife13:00Justin Deoliveira
OSGeo Incubation13:30Jody Garnett
Getting Started with OpenLayers 315:00Andreas Hocevar with Tim Schaub
9/11/2014LocationTech Projects13:30Jody Garnett and Justin Deoliveira with Andrew Ross, Rob Emanuele, and others
MapStory: The next plateau16:00Ian Schneider
9/12/2014State of GeoServer and GeoTools10:00Justin Deoliveira and Jody Garnett with Andrea Aime, Martin Davis, and others
PostGIS Feature Frenzy13:00Paul Ramsey

OpenGeo Suite 4.1.1 Released!

We’ve been hard at work fixing bugs, and polishing OpenGeo Suite, so we’re proud to announce the release of OpenGeo Suite 4.1.1!  This release focuses exclusively on performance and stability updates.

For those who don’t regularly follow our blog, the OpenGeo Suite 4.1 release included many new features and improvements:

Try it!

Download 4.1.1 and try our census map tutorial or heat map tutorial to learn more. Details about this release are included in the release notes and, as always, we strongly advise you to read the upgrade instructions and backup your data before installing.

OpenLayers 3.0 Released!

OpenLayers 3 has been a long time in the making but we’re proud to announce that the project is ready for release! This release includes a ton of new features such as an easier to use API as well as improved vector rendering and image manipulation.

While we’ve confidently supported OpenLayers 3 in production since the OpenGeo Suite 4.0 release and have long offered professional services for developers looking to build web applications, we hope this announcement marks a significant step forward in adoption of the library.

Check out some of our previous blog posts to learn more about using OpenLayers 3:

And don’t forget to check out the project website for some great documentation and examples.

OL3 vector rendering

Announcing the OpenGeo Suite App Contest!

OpenGeo Suite

Boundless wants to know how you’ve been using OpenGeo Suite! We already know what customers such as NYC DoITT, FCCSan Jose Water Company, and Howard County are building with our software but we are launching an app contest where developers, like you, can show off applications that use components of OpenGeo Suite.

Winners will be promoted on our website and will receive free access to our online training offerings. We know you are making some awesome real-world applications, and we want everyone to know because, in the end, OpenGeo Suite is only as great as the apps it helps power.

FCC National Broadband Map

The process is simple. All you have to do is provide the following information through our submission form:

  1. Describe what you’ve built. What’s its purpose?

  2. What technology does it use, including specific OpenGeo Suite components?

  3. Why did you choose OpenGeo Suite?

  4. What are your future plans for this app?

  5. How did you architect and build the app?

  6. Is this available to the public, if so, what is the URL?

  7. Is this your first time using OpenGeo Suite or any of its components?

You can enter the contest starting today and we will be taking submissions through September 13th, the last day of FOSS4G. Throughout the contest, we will promote the best submissions on our blog and through our Twitter account. We’ll announce semi-finalists the week after FOSS4G and then welcome the community to cast a vote for the finalists, which we will announce at the GeoNYC Meetup in October.

We can’t wait to see, share, and celebrate what you’ve been creating with OpenGeo Suite so submit your app!

Ice Cubed (Part 2): Building an Application

Matt Richards

OpenGeo Suite is a complete geospatial platform for managing data and building maps and applications. In the newest versionBoundless makes it even easier to create complete, enterprise-grade web applications. While we’ve previously show how to build applications using OpenGeo Suite, this post follows our previous post in describing how to create an application to visualize changes in Arctic sea ice.


Our first demo application, Ice3, is a mapping application that visualizes changes in Arctic sea ice over a 33 year period (1980-2013). The maximum August sea ice extent is shown in the timeline slider beneath the map. Additionally, an outline of the 30-year (1981-2010) median August sea ice extent is included for comparison. All data is from the National Snow & Ice Data Center, a source for consistently processed ice extent and concentration images and data values since 1979. A third dataset showing the average snow extent in August (1967-2004) is also included for reference.

Defining the User Experience

To begin, we’ll think about the desired user experience. We’d like an interface that displays the ice extent while also allowing the user to toggle between sea ice extent for different years. As shown above, we’ll present a map and provide radio buttons to allow the user to select between the various years.

Creating the HTML & CSS

To make it easier to follow along, all of the source code for the Ice3 application is available on GitHub.

Let’s start off with the implementation of the HTML. This is a very standard implementation, and can easily be included in a web app, content management system, or a simple static HTML page. In this case, we’ll just generate a static, flat HTML file for this demonstration. To follow along, a great starting point is the HTML5 Boilerplate.

The CSS implementation is also straightforward. OpenLayers 3 plays very nicely with CSS by making it easy to provide a style that fits the look and feel you are going for. We also wanted to create a fluid, responsive CSS layout that supports mobile, tablets, and desktops. OL3 completely supported this with no additional changes needed out-of-the-box. As the viewport and layout change using CSS media queries, the map supported this by simply changing the containing elements and using a width and height of 100% of the map itself.

Working with JavaScript

Next, we’ll walk through the JavaScript for the application itself, which will be used to set up the map, wire up the behavior, and manage the interactions.

Determining layer extents and projections

First, we set up the extents for the layers that we’ll be using. We found these extents by looking at GeoServer’s layer preview, and noting down the numbers that were used there for each relevant layer:

var extent3408 = [
  -4938036.174191093, -2573213.9925217666,
  5084539.232734008, 3938318.148811234

var extent3413 = [
  -2700000, -3600000,
  2350000, 2100000

While the previous post described how to reproject the data in QGIS, in this example we’ll instead setup the projection objects to cover pulling in the data in different projections and have GeoServer reproject them in real time:

var projection3408 = ol.proj.get('EPSG:3408').setExtent(extent3408);
var projection3413 = ol.proj.get('EPSG:3413').setExtent(extent3413);

Defining the base map

Next, we’ll set up the base layer. We’ll be using the Natural Earth base map, which we reprojected to 3408:

var wmsUrl = '';
var workspace = 'icecubed';

var baseLayer = new ol.layer.Tile({
  source: new ol.source.TileWMS({
    url: wmsUrl,
    params: {
      LAYERS: workspace + ':NaturalEarth1_3408_basemap',
      TILED: true
    extent: extent3408,
    serverType: 'geoserver',
    projection: projection3408

Working with layers

Now we’ll make the preparations for the remaining layers: sea ice extents for each year, median sea ice line, and an external average snow extent layer.  On page load, we want to show the first snow ice extent layer. The median and average snow extent layers will be visible as well, with separate controls to toggle their visibility.

We’ll use a couple of helper functions, and populate a lookup of layer name to layer object. This will be used later on to lookup the layer to display when the user clicks on a radio button.

var extentLayerNames = [

function makeExtentLayer(layerName, isVisible) {
  isVisible = !! isVisible;
  return new ol.layer.Tile({
    source: new ol.source.TileWMS({
      url: wmsUrl,
      params: {
        LAYERS: workspace + ':' + layerName,
        TILED: true
      serverType: 'geoserver',
      projection: projection3413
    visible: isVisible

var iceLayers = [];
var layerLookup = {};
extentLayerNames.forEach(function(layerName) {
  var layer = makeExtentLayer(layerName);
  layerLookup[layerName] = layer;
var medianLayer = makeExtentLayer('median_N_08_1981_2010_polyline', true);
var cryoLayer = new ol.layer.Tile({
  source: new ol.source.TileWMS({
    url: '',
    params: {
      LAYERS: 'snow_extent_08',
      TILED: true,
    projection: projection3408
  visible: true

var allLayers = [baseLayer]

Now that the layers are set up, we can create the OpenLayers map object.

var map = new ol.Map({
  target: 'map',
  renderer: 'canvas',
  layers: allLayers,
  view: new ol.View({
    center: [-5049.84109515, 825838.67673878],
    zoom: 2,
    projection: projection3408

All that’s left is now is to add the appropriate behavior to the controls, including radio buttons that display each layer as well as a toggle for the external WMS layer.

First, let’s wire up the radio buttons. This is fairly typical JavaScript code looks up the layer that was clicked on, marks everything as invisible first, and then sets the layer chosen visible:

// turn on the single layer that is clicked on
$('#radios').click(function(e) {
  var target =;
  var layerName = target.getAttribute('data-radio');
  if (!layerName) {
    // user clicked in area but not on radio
  var layer = layerLookup[layerName];
  if (!layer) {
    throw new Error('Could not find layer name: ' + layerName);
  iceLayers.forEach(function(iceLayer) {

Next, we need to wire up the external average snow extent layer. This is just a matter of toggle that particular layer’s visibility:

$('#cryo').click(function(e) {

And finally, we’ll want to display the first layer on page load:


Learn more!

Interested in building your own apps using OpenGeo Suite? Find out how with our training and professional services.

Ice Cubed (Part 1): Data Preparation with QGIS

Victor Olaya

OpenGeo Suite is a complete geospatial platform for managing data and building maps and applications. In the newest version, Boundless makes it even easier to build and deploy applications by adding better data management tools to QGIS and improving the SDK with support for OpenLayers 3.

This post is the first of a series of posts describing how to create complete, enterprise-grade web applications using these and other features. While we’ve previously shown how to configure OpenGeo Suite from QGIS, this post will describe a typical workflow to show how easy it is to analyze and style on the desktop using QGIS and then publish to the web using GeoServer. Our next post will describe how to use this data to create an application to visualize this data.


Our first demo application, Ice3, is a mapping application that visualizes changes in Arctic sea ice over a 33 year period (1980-2013). The maximum August sea ice extent is shown in the timeline slider beneath the map. Additionally, an outline of the 30-year (1981-2010) median August sea ice extent is included for comparison. All data is from the National Snow & Ice Data Center, a source for consistently processed ice extent and concentration images and data values since 1979. A third dataset showing the average snow extent in August (1967-2004) is also included for reference.

Preparing the Data

The workflow that we have to execute involves loading and reprojecting several layers into the same coordinate reference system (CRS), styling them, and then publishing them to GeoServer. It is not strictly necessary to reproject layers, as GeoServer can do that on the fly, but if we expect most requests to use a given CRS then reprojecting them in advance will avoid having to reproject them at request time and thus make our service more performant.  In order to show the capabilities of GeoServer, other posts in this series will use layers in their original CRS, but in this one we will be reprojecting them to a common one using QGIS. We will be using the following datasets:

Setting up GeoServer

Before preparing our layers, we need configure the GeoServer catalog. From the QGIS plugin, we can connect to our GeoServer instance and create a new workspace that will contain our layers.


Base map layer

To reproject the Natural Earth base map layer into a polar projection, we will use the Reproject vector layer algorithm in the Processing toolbox. Doing so will generate a new layer in the EPSG:3408 CRS, which will be our target for all layers.


We can then define a style for the layer on the layer properties dialog. Once the layer is ready to be published,  we can drag and drop the layer into the desired catalog and workspace using the QGIS plugin.

Average snow extent layer

The average snow extent layer is based on an an existing WMS service. Currently, cascading a WMS service can only be configured from the GeoServer administration interface, but an upcoming release of OpenGeo Suite will make it possible to define a new connection in QGIS…


…and then add a corresponding layer from the list provided by that service.


Sea ice layers

Preparing and publishing the sea ice layers is the most complex part, since there is a large number of them. We will show how to automate the process to simplify it.

All layers will have the same styling, since we do not plan to show them together, but as different snapshots. That means we can reuse the style definition. We style one of the layers and then save the style as a QGIS QML file.


The operation that we need to perform for all the layers in the sea ice set is reprojecting them and then applying the style that we have just saved. To make it easier to run repeatedly, we can define this small workflow as a model in the QGIS processing framework. This is what the model should look like:


The reprojection algorithm uses EPSG:3408 as the destination CRS, and the Style vector layer algorithm uses our QML style file.

To run this model in all of our layers, we can run it as a batch process. Selecting the sea ice layers as inputs for the batch process will generate a new set of reprojected and styled layers, ready to be published to GeoServer.


Another way of using our model is by setting it as a pre-publish hook. Our QGIS plugin makes it possible to define an operation to be performed to any layer as it is published. If we set our model to run when publishing then there is no need to run the batch process. Simply publish the set of sea ice layer from our QGIS plugin by dragging and dropping them on the destination workspace item they will be reprojected and styled as they’re published.

Preparing the cache

Once all layers are published, we can also create the corresponding cache layers and seed the cache from the QGIS plugin. To create a cache layer, just right-click on the GeoWebCache item and select the GWC layer and then specify the layer to cache.


Or, even easier, just drag a Geoserver layer into the GeoWebCache item. You can then cache the layer to its full extent, or, if you just want to cache a given region, define its bounding box by clicking on Define in canvas button and then dragging and dropping the QGIS map to select the bounding box.



Now we have configured all the layers for our Ice3 demo application by reprojecting and publishing from QGIS to GeoServer.  In the next post we will see how to create an interface for the application using OpenLayers 3.

Boundless Growth

Eddie Pickle

Boundless is growing but our focus remains helping customers build the best web mapping applications. We’ve recruited a stronger leadership team and are enhancing our current products while also developing new products and services to help customers in new ways.

We recently added Ann Johnson as our new CEO to strengthen our team and leadership. Ann’s experience with enterprise software, particularly her deep knowledge of security, greatly expand our expertise in critical areas of Spatial IT.

At the same time, we have been steadily adding capabilities to OpenGeo Suite to enable easier, more scalable web services deployments. To help our customers successfully build enterprise mapping applications, we’re advancing open source software like OpenLayers 3 and providing new SDK templates that leverage this new technology. We continue to “lower the cost of free software” by making secure, fault tolerant, and scalable deployments of our open source stack simpler, faster, and easier.

Additionally, some of our key initiatives include:

With Ann joining Boundless, I’m focusing my efforts on developing these and other capabilities to grow our business, with a particular emphasis on developing new partnerships to create a new geospatial ecosystem based on open source software. We believe the future is bright for open source–based solutions to address a variety of challenges, from publishing data to asset management to customer services. I look forward to working with our customers and partners to reshape this industry!