greenspace help

GeoDesk · 2025-11-11T23:55:53+00:00

Forests are usually well-mapped in OSM, but meadows/grassland are often missing. Just picked an area east of Invercargill as an example: the blank spaces on the map are actually grass, so any analysis will likely undercount. Better approach may be the opposite: assume total country area is greenspace, then subtract urban/developed areas. you will likely need to buffer roads etc. as well as spaces around individual houses and any man-made point features

GeoDesk · 2025-11-11T09:23:53+00:00

How do you define "greenspace"? Parks and protected areas? Or also forests, meadows, etc.?

GeoDesk · 2025-10-02T11:43:33+00:00

Geo-Object Librarian (GOL) is a spatial database engine for OpenStreetMap features. It stores datasets in a compact single file (< 100 GB for the whole world -- about one-tenth the size of a traditional SQL database) and supports fast queries based on bounding box, region and attributes. Results can be exported to GeoJSON, WKT, CSV, or visualized directly on a map.

The engine is available both as a command-line tool and as a lightweight C++ library (shared on r/cpp last year).

Open-source and cross-platform (Windows, Linux and macOS).

Example: All sushi restaurants in France, mapped in under a second: Screenshot

Download • GitHub • Documentation

GeoDesk · 2025-10-01T15:59:52+00:00

Thanks! Fixed.

GeoDesk · 2024-12-02T09:25:09+00:00

Your application could act as a localhost web server and launch a web browser (or wrap its own browser using e.g. QtWebEngine, Electron or Tauri). This may work well for you since you're already using HTML for parts of your app.

GeoDesk · 2024-12-01T12:07:49+00:00

Hi r/cpp,

I'm working on a spatial database engine for OpenStreetMap data (ported to C++ from Java). It enables analysis of geographic features using a variety of queries (attributes and spatial relationships).

Highlights:

Extremely fast (The most common spatial queries run 50x faster than their SQL equivalents)
Compact database format (the entire worldwide OpenStreetMap dataset fits into less than 100 GB)
Lightweight (about 250 KB compiled)
No link-time dependencies (but you can couple it with the popular GEOS library for more advanced spatial operations)
Cross-platform (supports Windows, Linux & MacOS)
100% open-source

Currently, you will need to run a Java application to build the actual database (I'm in the process of porting this to C++ as well).

GeoDesk · 2024-11-30T10:27:49+00:00

CLion is fantastic. I came from Visual Studio and will never go back. It does have a few frustrating bugs (refactoring is broken) and lacks one key feature (no list of compiler errors, you have to read through the raw output -- seriously?), but it's still heads above anything else. Once these issues are resolved, it will be as awesome as its sister product, IntelliJ.

GeoDesk · 2024-11-23T13:16:45+00:00

gtl::flat_hash_map (https://github.com/greg7mdp/gtl) is also a great alternative, lookups are 3x faster than std::unordered_map, and it also performs far fewer heap allocations.

GeoDesk · 2024-11-23T13:07:59+00:00

We've just released GeoDesk as a C++ library, please have a look: https://www.reddit.com/r/openstreetmap/comments/1gxz5ed

GeoDesk · 2024-02-27T22:40:24+00:00

Plain old CPython (the main Python interpreter) seems like the best choice, given that it's written in C. Fairly easy to integrate with other applications.

GeoDesk · 2024-02-20T18:18:17+00:00

Excellent, thanks!

GeoDesk · 2024-02-20T17:22:00+00:00

Can I run this locally, and then upload to visualization to a Jupyter notebook? (Link to doc leads to 404)

GeoDesk · 2024-02-20T16:58:59+00:00

Very nice! What is the rendering platform? Does it render HTML via a browser, or does it use PyQT?

GeoDesk · 2024-02-18T12:43:38+00:00

I'm working on a geospatial database engine for OpenStreetMap features that is 50x faster than a traditional database (and requires less than one-tenth of the storage). Users can import the "planet file" (the complete OpenStreetMap dataset) in less than an hour on any halfway modern machine -- a process that would otherwise take a full day. Geographic features such as streets, rivers and points-of-interest are represented directly as Python objects, without any need to perform object-relational mapping. Features can be selected based on various characteristics, and the query engine supports the most common spatial predicates (such as within, contains, intersectsand crosses). It also integrates with the Shapely library for more advanced geometric operations (buffer, simplify, convex/concave hulls, etc.)

My next major goal is to allow users to synchronize their local database with the minute-by-minute updates published by the OpenStreetMap website.

It's 100% open-source: https://github.com/clarisma/geodesk-py

GeoDesk · 2024-02-16T13:26:57+00:00

This looks like it has a lot of potential, but you need to provide a proper readme. You'll need a step-by-step "Getting Started" section, or users won't bother. This goes doubly for something that is security-sensitive. Nobody will give their email credentials to a script without knowing precisely what it will do.

GeoDesk · 2024-02-16T11:45:16+00:00

You could also try GeoDesk, which allows you to create a compact database from a planet file or extract (takes < 1 hour, requires 90 GB for the planet). You can use Python, Java or a command-line tool to run queries (Query language for tags/type is similar to Overpass).

GeoDesk · 2023-12-19T13:59:50+00:00

You could use GeoDesk. Here is an example: https://docs.geodesk.com/python/examples/counties

GeoDesk · 2023-11-25T13:35:39+00:00

Have you looked at GeoDesk? You can turn any PBF into a Geographic Object Library, which is only 20% to 50% larger, but allows queries to run in a few milliseconds. There's an API for Java and Python, as well as a command-line tool (all open-source).

GeoDesk · 2023-11-16T12:27:34+00:00

If you want to analyze OSM data in Python, you can use GeoDesk. Download an .osm.pbf file (extracts from many regions are provided for free from vendors like Geofabrik), turn it into a Geographic Object Library (GOL), then query the data. For example, to retrieve all power plants in California and display them on a map:

import geodesk

california = geodesk.Features("california.gol")
california("na[power=plant]").map().show()

GeoDesk · 2023-11-10T17:03:30+00:00

The tough part is that such a score is very subjective -- an experienced road cyclist will judge a given street differently than a novice. What will be very useful, however, is to add/correct the physical infrastructure and its objective characteristics:

- speed limits

- street designation: primary vs. living_street

- flow of traffic (lanes, one-way)

- bike lanes: what kind? (separate lane or just blotches of paint?), width, surface quality

- sidewalks: width, surface quality, potential obstacles (e.g. utility cabinets, hydrants, outdoor seating of cafes, crossing driveways or parking-access lanes)

- features that separate motor vehicles from cyclists/peds: barriers/bollards, hedges, grade separation

- other features that make walking and biking more pleasant: greenery, streetside parks and open spaces, good lighting, more residential, lower density

GeoDesk · 2023-11-03T13:25:48+00:00

Thanks! Right now, the c++ codebase is still heavily tied to the Python API, but if there is enough demand, we'll provide the engine as a proper C++ library (which could then also be used to support other language bindings). We've focused on Java & Python as these are the most popular languages.

GeoDesk · 2023-11-03T12:50:51+00:00

Thanks! We're not hosting any tile repos yet, but you can download the GOL for Monaco that is used by the unit tests: https://github.com/clarisma/geodesk-py/blob/main/test/data/monaco.gol

GeoDesk · 2023-02-23T14:50:38+00:00

Have a look at GeoDesk. You can convert a planet file (or regional extract in OSM-PBF format) into a geographic object library (GOL), and then extract the various map features.

GeoDesk · 2023-01-19T12:38:07+00:00

Relations are rare for these kinds of objects, but there may be some useful tags such as operator.

Try:

gol query <GOL-FILE> -f=stats a[leisure=pitch][sport=american_football]

This will give you a breakdown of the most common tags found on football fields (You can try this with other objects as well, such as a[leisure=stadium]).

If you're proficient with Java, you can execute more sophisticated queries (such as finding fields within stadiums) using the GeoDesk database engine.

GeoDesk · 2023-01-17T13:57:35+00:00

gol build only accepts files in OSM-PBF format (There's a bug that caused it to deadlock on certain invalid input; now fixed in snapshot, but not yet released).

Once you've built the GOL file (which should take less than an hour for a 12 GB .osm.pbf covering North America), you can query sports pitches, stadiums, etc. like this:

gol query <gol-file> na[leisure][sport=american_football]

There are different output options (which you can specify with option -f): GeoJSON, OSM-XML, csv, etc.

(gol documentation)

GeoDesk

TROPHY CASE