Build vector tilesets from large collections of GeoJSON features.

Overview

tippecanoe

Builds vector tilesets from large (or small) collections of GeoJSON, Geobuf, or CSV features, like these.

Mapbox Tippecanoe

Build Status Coverage Status

Mapbox has a new service for creating vector tilesets!

Mapbox Tiling Service (MTS) is a hosted, data processing service that allows you to integrate custom datasets of any scale into your maps faster, cheaper, and with more flexibility and control than previously possible.

MTS is the same service we use internally to create our global, daily updating basemap product Mapbox Streets, which serves over 650 million monthly active users and customers such as Facebook, Snap, the Weather Channel, Tableau, and Shopify.

MTS creates and updates data using distributed and parallelized processing, meaning data is processed much more quickly than is possible with a standard, single server setup with comparable tools. For example, a global basemap at 30cm precision (max zoom of 16) can be processed in under 2 hours with MTS, whereas a comparable workload would take multiple days to process on a single server.

Customers like AllTrails, Plume Labs, and Ookla have noted that MTS helps them:

  • build applications faster by focusing more on app development, not infrastructure
  • build more compelling user experiences that drive better user engagement
  • get updated data to their users faster—in some cases up to 90% faster than previous tools

Learn more about MTS.

Intent

The goal of Tippecanoe is to enable making a scale-independent view of your data, so that at any level from the entire world to a single building, you can see the density and texture of the data rather than a simplification from dropping supposedly unimportant features or clustering or aggregating them.

If you give it all of OpenStreetMap and zoom out, it should give you back something that looks like "All Streets" rather than something that looks like an Interstate road atlas.

If you give it all the building footprints in Los Angeles and zoom out far enough that most individual buildings are no longer discernable, you should still be able to see the extent and variety of development in every neighborhood, not just the largest downtown buildings.

If you give it a collection of years of tweet locations, you should be able to see the shape and relative popularity of every point of interest and every significant travel corridor.

Installation

The easiest way to install tippecanoe on OSX is with Homebrew:

$ brew install tippecanoe

On Ubuntu it will usually be easiest to build from the source repository:

$ git clone https://github.com/mapbox/tippecanoe.git
$ cd tippecanoe
$ make -j
$ make install

See Development below for how to upgrade your C++ compiler or install prerequisite packages if you get compiler errors.

Usage

$ tippecanoe -o file.mbtiles [options] [file.json file.json.gz file.geobuf ...]

If no files are specified, it reads GeoJSON from the standard input. If multiple files are specified, each is placed in its own layer.

The GeoJSON features need not be wrapped in a FeatureCollection. You can concatenate multiple GeoJSON features or files together, and it will parse out the features and ignore whatever other objects it encounters.

Try this first

If you aren't sure what options to use, try this:

$ tippecanoe -zg -o out.mbtiles --drop-densest-as-needed in.geojson

The -zg option will make Tippecanoe choose a maximum zoom level that should be high enough to reflect the precision of the original data. (If it turns out still not to be as detailed as you want, use -z manually with a higher number.)

If the tiles come out too big, the --drop-densest-as-needed option will make Tippecanoe try dropping what should be the least visible features at each zoom level. (If it drops too many features, use -x to leave out some feature attributes that you didn't really need.)

Examples

Create a tileset of TIGER roads for Alameda County, to zoom level 13, with a custom layer name and description:

$ tippecanoe -o alameda.mbtiles -l alameda -n "Alameda County from TIGER" -z13 tl_2014_06001_roads.json

Create a tileset of all TIGER roads, at only zoom level 12, but with higher detail than normal, with a custom layer name and description, and leaving out the LINEARID and RTTYP attributes:

$ cat tiger/tl_2014_*_roads.json | tippecanoe -o tiger.mbtiles -l roads -n "All TIGER roads, one zoom" -z12 -Z12 -d14 -x LINEARID -x RTTYP

Cookbook

Linear features (world railroads), visible at all zoom levels

curl -L -O https://www.naturalearthdata.com/http//www.naturalearthdata.com/download/10m/cultural/ne_10m_railroads.zip
unzip ne_10m_railroads.zip
ogr2ogr -f GeoJSON ne_10m_railroads.geojson ne_10m_railroads.shp

tippecanoe -zg -o ne_10m_railroads.mbtiles --drop-densest-as-needed --extend-zooms-if-still-dropping ne_10m_railroads.geojson
  • -zg: Automatically choose a maxzoom that should be sufficient to clearly distinguish the features and the detail within each feature
  • --drop-densest-as-needed: If the tiles are too big at low zoom levels, drop the least-visible features to allow tiles to be created with those features that remain
  • --extend-zooms-if-still-dropping: If even the tiles at high zoom levels are too big, keep adding zoom levels until one is reached that can represent all the features

Discontinuous polygon features (buildings of Rhode Island), visible at all zoom levels

curl -L -O https://usbuildingdata.blob.core.windows.net/usbuildings-v1-1/RhodeIsland.zip
unzip RhodeIsland.zip

tippecanoe -zg -o RhodeIsland.mbtiles --drop-densest-as-needed --extend-zooms-if-still-dropping RhodeIsland.geojson
  • -zg: Automatically choose a maxzoom that should be sufficient to clearly distinguish the features and the detail within each feature
  • --drop-densest-as-needed: If the tiles are too big at low or medium zoom levels, drop the least-visible features to allow tiles to be created with those features that remain
  • --extend-zooms-if-still-dropping: If even the tiles at high zoom levels are too big, keep adding zoom levels until one is reached that can represent all the features

Continuous polygon features (states and provinces), visible at all zoom levels

curl -L -O https://www.naturalearthdata.com/http//www.naturalearthdata.com/download/10m/cultural/ne_10m_admin_1_states_provinces.zip
unzip -o ne_10m_admin_1_states_provinces.zip
ogr2ogr -f GeoJSON ne_10m_admin_1_states_provinces.geojson ne_10m_admin_1_states_provinces.shp

tippecanoe -zg -o ne_10m_admin_1_states_provinces.mbtiles --coalesce-densest-as-needed --extend-zooms-if-still-dropping ne_10m_admin_1_states_provinces.geojson
  • -zg: Automatically choose a maxzoom that should be sufficient to clearly distinguish the features and the detail within each feature
  • --coalesce-densest-as-needed: If the tiles are too big at low or medium zoom levels, merge as many features together as are necessary to allow tiles to be created with those features that are still distinguished
  • --extend-zooms-if-still-dropping: If even the tiles at high zoom levels are too big, keep adding zoom levels until one is reached that can represent all the features

Large point dataset (GPS bus locations), for visualization at all zoom levels

curl -L -O ftp://avl-data.sfmta.com/avl_data/avl_raw/sfmtaAVLRawData01012013.csv
sed 's/PREDICTABLE.*/PREDICTABLE/' sfmtaAVLRawData01012013.csv > sfmta.csv
tippecanoe -zg -o sfmta.mbtiles --drop-densest-as-needed --extend-zooms-if-still-dropping sfmta.csv

(The sed line is to clean the corrupt CSV header, which contains the wrong number of fields.)

  • -zg: Automatically choose a maxzoom that should be sufficient to clearly distinguish the features and the detail within each feature
  • --drop-densest-as-needed: If the tiles are too big at low or medium zoom levels, drop the least-visible features to allow tiles to be created with those features that remain
  • --extend-zooms-if-still-dropping: If even the tiles at high zoom levels are too big, keep adding zoom levels until one is reached that can represent all the features

Clustered points (world cities), summing the clustered population, visible at all zoom levels

curl -L -O https://www.naturalearthdata.com/http//www.naturalearthdata.com/download/10m/cultural/ne_10m_populated_places.zip
unzip -o ne_10m_populated_places.zip
ogr2ogr -f GeoJSON ne_10m_populated_places.geojson ne_10m_populated_places.shp

tippecanoe -zg -o ne_10m_populated_places.mbtiles -r1 --cluster-distance=10 --accumulate-attribute=POP_MAX:sum ne_10m_populated_places.geojson
  • -zg: Automatically choose a maxzoom that should be sufficient to clearly distinguish the features and the detail within each feature
  • -r1: Do not automatically drop a fraction of points at low zoom levels, since clustering will be used instead
  • --cluster-distance=10: Cluster together features that are closer than about 10 pixels from each other
  • --accumulate-attribute=POP_MAX:sum: Sum the POP_MAX (population) attribute in features that are clustered together. Other attributes will be arbitrarily taken from the first feature in the cluster.

Show countries at low zoom levels but states at higher zoom levels

curl -L -O https://www.naturalearthdata.com/http//www.naturalearthdata.com/download/10m/cultural/ne_10m_admin_0_countries.zip
unzip ne_10m_admin_0_countries.zip
ogr2ogr -f GeoJSON ne_10m_admin_0_countries.geojson ne_10m_admin_0_countries.shp

curl -L -O https://www.naturalearthdata.com/http//www.naturalearthdata.com/download/10m/cultural/ne_10m_admin_1_states_provinces.zip
unzip -o ne_10m_admin_1_states_provinces.zip
ogr2ogr -f GeoJSON ne_10m_admin_1_states_provinces.geojson ne_10m_admin_1_states_provinces.shp

tippecanoe -z3 -o countries-z3.mbtiles --coalesce-densest-as-needed ne_10m_admin_0_countries.geojson
tippecanoe -zg -Z4 -o states-Z4.mbtiles --coalesce-densest-as-needed --extend-zooms-if-still-dropping ne_10m_admin_1_states_provinces.geojson
tile-join -o states-countries.mbtiles countries-z3.mbtiles states-Z4.mbtiles

Countries:

  • -z3: Only generate zoom levels 0 through 3
  • --coalesce-densest-as-needed: If the tiles are too big at low or medium zoom levels, merge as many features together as are necessary to allow tiles to be created with those features that are still distinguished

States and Provinces:

  • -Z4: Only generate zoom levels 4 and beyond
  • -zg: Automatically choose a maxzoom that should be sufficient to clearly distinguish the features and the detail within each feature
  • --coalesce-densest-as-needed: If the tiles are too big at low or medium zoom levels, merge as many features together as are necessary to allow tiles to be created with those features that are still distinguished
  • --extend-zooms-if-still-dropping: If even the tiles at high zoom levels are too big, keep adding zoom levels until one is reached that can represent all the features

Represent multiple sources (Illinois and Indiana counties) as separate layers

curl -L -O https://www2.census.gov/geo/tiger/TIGER2010/COUNTY/2010/tl_2010_17_county10.zip
unzip tl_2010_17_county10.zip
ogr2ogr -f GeoJSON tl_2010_17_county10.geojson tl_2010_17_county10.shp

curl -L -O https://www2.census.gov/geo/tiger/TIGER2010/COUNTY/2010/tl_2010_18_county10.zip
unzip tl_2010_18_county10.zip
ogr2ogr -f GeoJSON tl_2010_18_county10.geojson tl_2010_18_county10.shp

tippecanoe -zg -o counties-separate.mbtiles --coalesce-densest-as-needed --extend-zooms-if-still-dropping tl_2010_17_county10.geojson tl_2010_18_county10.geojson
  • -zg: Automatically choose a maxzoom that should be sufficient to clearly distinguish the features and the detail within each feature
  • --coalesce-densest-as-needed: If the tiles are too big at low or medium zoom levels, merge as many features together as are necessary to allow tiles to be created with those features that are still distinguished
  • --extend-zooms-if-still-dropping: If even the tiles at high zoom levels are too big, keep adding zoom levels until one is reached that can represent all the features

Merge multiple sources (Illinois and Indiana counties) into the same layer

curl -L -O https://www2.census.gov/geo/tiger/TIGER2010/COUNTY/2010/tl_2010_17_county10.zip
unzip tl_2010_17_county10.zip
ogr2ogr -f GeoJSON tl_2010_17_county10.geojson tl_2010_17_county10.shp

curl -L -O https://www2.census.gov/geo/tiger/TIGER2010/COUNTY/2010/tl_2010_18_county10.zip
unzip tl_2010_18_county10.zip
ogr2ogr -f GeoJSON tl_2010_18_county10.geojson tl_2010_18_county10.shp

tippecanoe -zg -o counties-merged.mbtiles -l counties --coalesce-densest-as-needed --extend-zooms-if-still-dropping tl_2010_17_county10.geojson tl_2010_18_county10.geojson

As above, but

  • -l counties: Specify the layer name instead of letting it be derived from the source file names

Selectively remove and replace features (Census tracts) to update a tileset

# Retrieve and tile California 2000 Census tracts
curl -L -O https://www2.census.gov/geo/tiger/TIGER2010/TRACT/2000/tl_2010_06_tract00.zip
unzip tl_2010_06_tract00.zip
ogr2ogr -f GeoJSON tl_2010_06_tract00.shp.json tl_2010_06_tract00.shp
tippecanoe -z11 -o tracts.mbtiles -l tracts tl_2010_06_tract00.shp.json

# Create a copy of the tileset, minus Alameda County (FIPS code 001)
tile-join -j '{"*":["none",["==","COUNTYFP00","001"]]}' -f -o tracts-filtered.mbtiles tracts.mbtiles

# Retrieve and tile Alameda County Census tracts for 2010
curl -L -O https://www2.census.gov/geo/tiger/TIGER2010/TRACT/2010/tl_2010_06001_tract10.zip
unzip tl_2010_06001_tract10.zip
ogr2ogr -f GeoJSON tl_2010_06001_tract10.shp.json tl_2010_06001_tract10.shp
tippecanoe -z11 -o tracts-added.mbtiles -l tracts tl_2010_06001_tract10.shp.json

# Merge the filtered tileset and the tileset of new tracts into a final tileset
tile-join -o tracts-final.mbtiles tracts-filtered.mbtiles tracts-added.mbtiles

The -z11 option explicitly specifies the maxzoom, to make sure both the old and new tilesets have the same zoom range.

The -j option to tile-join specifies a filter, so that only the desired features will be copied to the new tileset. This filter excludes (using none) any features whose FIPS code (COUNTYFP00) is the code for Alameda County (001).

Options

There are a lot of options. A lot of the time you won't want to use any of them other than -o output.mbtiles to name the output file, and probably -f to delete the file that already exists with that name.

If you aren't sure what the right maxzoom is for your data, -zg will guess one for you based on the density of features.

Tippecanoe will normally drop a fraction of point features at zooms below the maxzoom, to keep the low-zoom tiles from getting too big. If you have a smaller data set where all the points would fit without dropping any of them, use -r1 to keep them all. If you do want point dropping, but you still want the tiles to be denser than -zg thinks they should be, use -B to set a basezoom lower than the maxzoom.

If some of your tiles are coming out too big in spite of the settings above, you will often want to use --drop-densest-as-needed to drop whatever fraction of the features is necessary at each zoom level to make that zoom level's tiles work.

If your features have a lot of attributes, use -y to keep only the ones you really need.

If your input is formatted as newline-delimited GeoJSON, use -P to make input parsing a lot faster.

Output tileset

  • -o file.mbtiles or --output=file.mbtiles: Name the output file.
  • -e directory or --output-to-directory=directory: Write tiles to the specified directory instead of to an mbtiles file.
  • -f or --force: Delete the mbtiles file if it already exists instead of giving an error
  • -F or --allow-existing: Proceed (without deleting existing data) if the metadata or tiles table already exists or if metadata fields can't be set. You probably don't want to use this.

Tileset description and attribution

  • -n name or --name=name: Human-readable name for the tileset (default file.json)
  • -A text or --attribution=text: Attribution (HTML) to be shown with maps that use data from this tileset.
  • -N description or --description=description: Description for the tileset (default file.mbtiles)

Input files and layer names

  • name.json or name.geojson: Read the named GeoJSON input file into a layer called name.
  • name.json.gz or name.geojson.gz: Read the named gzipped GeoJSON input file into a layer called name.
  • name.geobuf: Read the named Geobuf input file into a layer called name.
  • name.csv: Read the named CSV input file into a layer called name.
  • -l name or --layer=name: Use the specified layer name instead of deriving a name from the input filename or output tileset. If there are multiple input files specified, the files are all merged into the single named layer, even if they try to specify individual names with -L.
  • -L name:file.json or --named-layer=name:file.json: Specify layer names for individual files. If your shell supports it, you can use a subshell redirect like -L name:<(cat dir/*.json) to specify a layer name for the output of streamed input.
  • -L{layer-json} or --named-layer={layer-json}: Specify an input file and layer options by a JSON object. The JSON object must contain a "file" key to specify the filename to read from. (If the "file" key is an empty string, it means to read from the standard input stream.) It may also contain a "layer" field to specify the name of the layer, and/or a "description" field to specify the layer's description in the tileset metadata, and/or a "format" field to specify csv or geobuf file format if it is not obvious from the name. Example:
tippecanoe -z5 -o world.mbtiles -L'{"file":"ne_10m_admin_0_countries.json", "layer":"countries", "description":"Natural Earth countries"}'

CSV input files currently support only Point geometries, from columns named latitude, longitude, lat, lon, long, lng, x, or y.

Parallel processing of input

  • -P or --read-parallel: Use multiple threads to read different parts of each GeoJSON input file at once. This will only work if the input is line-delimited JSON with each Feature on its own line, because it knows nothing of the top-level structure around the Features. Spurious "EOF" error messages may result otherwise. Performance will be better if the input is a named file that can be mapped into memory rather than a stream that can only be read sequentially.

If the input file begins with the RFC 8142 record separator, parallel processing of input will be invoked automatically, splitting at record separators rather than at all newlines.

Parallel processing will also be automatic if the input file is in Geobuf format.

Projection of input

  • -s projection or --projection=projection: Specify the projection of the input data. Currently supported are EPSG:4326 (WGS84, the default) and EPSG:3857 (Web Mercator). In general you should use WGS84 for your input files if at all possible.

Zoom levels

  • -z zoom or --maximum-zoom=zoom: Maxzoom: the highest zoom level for which tiles are generated (default 14)
  • -zg or --maximum-zoom=g: Guess what is probably a reasonable maxzoom based on the spacing of features.
  • -Z zoom or --minimum-zoom=zoom: Minzoom: the lowest zoom level for which tiles are generated (default 0)
  • -ae or --extend-zooms-if-still-dropping: Increase the maxzoom if features are still being dropped at that zoom level. The detail and simplification options that ordinarily apply only to the maximum zoom level will apply both to the originally specified maximum zoom and to any levels added beyond that.
  • -R zoom/x/y or --one-tile=zoom/x/y: Set the minzoom and maxzoom to zoom and produce only the single specified tile at that zoom level.

If you know the precision to which you want your data to be represented, or the map scale of a corresponding printed map, this table shows the approximate precision and scale corresponding to various -z options if you use the default -d detail of 12:

zoom level precision (ft) precision (m) map scale
-z0 32000 ft 10000 m 1:320,000,000
-z1 16000 ft 5000 m 1:160,000,000
-z2 8000 ft 2500 m 1:80,000,000
-z3 4000 ft 1250 m 1:40,000,000
-z4 2000 ft 600 m 1:20,000,000
-z5 1000 ft 300 m 1:10,000,000
-z6 500 ft 150 m 1:5,000,000
-z7 250 ft 80 m 1:2,500,000
-z8 125 ft 40 m 1:1,250,000
-z9 64 ft 20 m 1:640,000
-z10 32 ft 10 m 1:320,000
-z11 16 ft 5 m 1:160,000
-z12 8 ft 2 m 1:80,000
-z13 4 ft 1 m 1:40,000
-z14 2 ft 0.5 m 1:20,000
-z15 1 ft 0.25 m 1:10,000
-z16 6 in 15 cm 1:5000
-z17 3 in 8 cm 1:2500
-z18 1.5 in 4 cm 1:1250
-z19 0.8 in 2 cm 1:600
-z20 0.4 in 1 cm 1:300
-z21 0.2 in 0.5 cm 1:150
-z22 0.1 in 0.25 cm 1:75

Tile resolution

  • -d detail or --full-detail=detail: Detail at max zoom level (default 12, for tile resolution of 2^12=4096)
  • -D detail or --low-detail=detail: Detail at lower zoom levels (default 12, for tile resolution of 2^12=4096)
  • -m detail or --minimum-detail=detail: Minimum detail that it will try if tiles are too big at regular detail (default 7)

All internal math is done in terms of a 32-bit tile coordinate system, so 1/(2^32) of the size of Earth, or about 1cm, is the smallest distinguishable distance. If maxzoom + detail > 32, no additional resolution is obtained than by using a smaller maxzoom or detail.

Filtering feature attributes

  • -x name or --exclude=name: Exclude the named attributes from all features. You can specify multiple -x options to exclude several attributes. (Don't comma-separate names within a single -x.)
  • -y name or --include=name: Include the named attributes in all features, excluding all those not explicitly named. You can specify multiple -y options to explicitly include several attributes. (Don't comma-separate names within a single -y.)
  • -X or --exclude-all: Exclude all attributes and encode only geometries

Modifying feature attributes

  • -Tattribute:type or --attribute-type=attribute:type: Coerce the named feature attribute to be of the specified type. The type may be string, float, int, or bool. If the type is bool, then original attributes of 0 (or, if numeric, 0.0, etc.), false, null, or the empty string become false, and otherwise become true. If the type is float or int and the original attribute was non-numeric, it becomes 0. If the type is int and the original attribute was floating-point, it is rounded to the nearest integer.
  • -Yattribute:description or --attribute-description=attribute:description: Set the description for the specified attribute in the tileset metadata to description instead of the usual String, Number, or Boolean.
  • -Eattribute:operation or --accumulate-attribute=attribute:operation: Preserve the named attribute from features that are dropped, coalesced-as-needed, or clustered. The operation may be sum, product, mean, max, min, concat, or comma to specify how the named attribute is accumulated onto the attribute of the same name in a feature that does survive.
  • -pe or --empty-csv-columns-are-null: Treat empty CSV columns as nulls rather than as empty strings.
  • -aI or --convert-stringified-ids-to-numbers: If a feature ID is the string representation of a number, convert it to a plain number to use as the feature ID.
  • --use-attribute-for-id=name: Use the attribute with the specified name as if it were specified as the feature ID. (If this attribute is a stringified number, you must also use -aI to convert it to a number.)

Filtering features by attributes

  • -j filter or --feature-filter=filter: Check features against a per-layer filter (as defined in the Mapbox GL Style Specification) and only include those that match. Any features in layers that have no filter specified will be passed through. Filters for the layer "*" apply to all layers. The special variable $zoom refers to the current zoom level.
  • -J filter-file or --feature-filter-file=filter-file: Like -j, but read the filter from a file.

Example: to find the Natural Earth countries with low scalerank but high LABELRANK:

tippecanoe -z5 -o filtered.mbtiles -j '{ "ne_10m_admin_0_countries": [ "all", [ "<", "scalerank", 3 ], [ ">", "LABELRANK", 5 ] ] }' ne_10m_admin_0_countries.geojson

Example: to retain only major TIGER roads at low zoom levels:

tippecanoe -o roads.mbtiles -j '{ "*": [ "any", [ ">=", "$zoom", 11 ], [ "in", "MTFCC", "S1100", "S1200" ] ] }' tl_2015_06001_roads.json

Tippecanoe also accepts expressions of the form [ "attribute-filter", name, expression ], to filter individual feature attributes instead of entire features. For example, you can exclude the road names at low zoom levels by doing

tippecanoe -o roads.mbtiles -j '{ "*": [ "attribute-filter", "FULLNAME", [ ">=", "$zoom", 9 ] ] }' tl_2015_06001_roads.json

An attribute-filter expression itself is always considered to evaluate to true (in other words, to retain the feature instead of dropping it). If you want to use multiple attribute-filter expressions, or to use other expressions to remove features from the same layer, enclose them in an all expression so they will all be evaluated.

Dropping a fixed fraction of features by zoom level

  • -r rate or --drop-rate=rate: Rate at which dots are dropped at zoom levels below basezoom (default 2.5). If you use -rg, it will guess a drop rate that will keep at most 50,000 features in the densest tile. You can also specify a marker-width with -rgwidth to allow fewer features in the densest tile to compensate for the larger marker, or -rfnumber to allow at most number features in the densest tile.
  • -B zoom or --base-zoom=zoom: Base zoom, the level at and above which all points are included in the tiles (default maxzoom). If you use -Bg, it will guess a zoom level that will keep at most 50,000 features in the densest tile. You can also specify a marker-width with -Bgwidth to allow fewer features in the densest tile to compensate for the larger marker, or -Bfnumber to allow at most number features in the densest tile.
  • -al or --drop-lines: Let "dot" dropping at lower zooms apply to lines too
  • -ap or --drop-polygons: Let "dot" dropping at lower zooms apply to polygons too
  • -K distance or --cluster-distance=distance: Cluster points (as with --cluster-densest-as-needed, but without the experimental discovery process) that are approximately within distance of each other. The units are tile coordinates within a nominally 256-pixel tile, so the maximum value of 255 allows only one feature per tile. Values around 10 are probably appropriate for typical marker sizes. See --cluster-densest-as-needed below for behavior.

Dropping a fraction of features to keep under tile size limits

  • -as or --drop-densest-as-needed: If a tile is too large, try to reduce it to under 500K by increasing the minimum spacing between features. The discovered spacing applies to the entire zoom level.
  • -ad or --drop-fraction-as-needed: Dynamically drop some fraction of features from each zoom level to keep large tiles under the 500K size limit. (This is like -pd but applies to the entire zoom level, not to each tile.)
  • -an or --drop-smallest-as-needed: Dynamically drop the smallest features (physically smallest: the shortest lines or the smallest polygons) from each zoom level to keep large tiles under the 500K size limit. This option will not work for point features.
  • -aN or --coalesce-smallest-as-needed: Dynamically combine the smallest features (physically smallest: the shortest lines or the smallest polygons) from each zoom level into other nearby features to keep large tiles under the 500K size limit. This option will not work for point features, and will probably not help very much with LineStrings. It is mostly intended for polygons, to maintain the full original area covered by polygons while still reducing the feature count somehow. The attributes of the small polygons are not preserved into the combined features (except through --accumulate-attribute), only their geometry. Furthermore, the polygons to which nested polygons are coalesced may not necessarily be the immediately enclosing features.
  • -aD or --coalesce-densest-as-needed: Dynamically combine the densest features from each zoom level into other nearby features to keep large tiles under the 500K size limit. (Again, mostly useful for polygons.)
  • -aS or --coalesce-fraction-as-needed: Dynamically combine a fraction of features from each zoom level into other nearby features to keep large tiles under the 500K size limit. (Again, mostly useful for polygons.)
  • -pd or --force-feature-limit: Dynamically drop some fraction of features from large tiles to keep them under the 500K size limit. It will probably look ugly at the tile boundaries. (This is like -ad but applies to each tile individually, not to the entire zoom level.) You probably don't want to use this.
  • -aC or --cluster-densest-as-needed: If a tile is too large, try to reduce its size by increasing the minimum spacing between features, and leaving one placeholder feature from each group. The remaining feature will be given a "clustered": true attribute to indicate that it represents a cluster, a "point_count" attribute to indicate the number of features that were clustered into it, and a "sqrt_point_count" attribute to indicate the relative width of a feature to represent the cluster. If the features being clustered are points, the representative feature will be located at the average of the original points' locations; otherwise, one of the original features will be left as the representative.

Dropping tightly overlapping features

  • -g gamma or --gamma=_gamma_: Rate at which especially dense dots are dropped (default 0, for no effect). A gamma of 2 reduces the number of dots less than a pixel apart to the square root of their original number.
  • -aG or --increase-gamma-as-needed: If a tile is too large, try to reduce it to under 500K by increasing the -g gamma. The discovered gamma applies to the entire zoom level. You probably want to use --drop-densest-as-needed instead.

Line and polygon simplification

  • -S scale or --simplification=scale: Multiply the tolerance for line and polygon simplification by scale. The standard tolerance tries to keep the line or polygon within one tile unit of its proper location. You can probably go up to about 10 without too much visible difference.
  • -ps or --no-line-simplification: Don't simplify lines and polygons
  • -pS or --simplify-only-low-zooms: Don't simplify lines and polygons at maxzoom (but do simplify at lower zooms)
  • -pn or --no-simplification-of-shared-nodes: Don't simplify away nodes that appear in more than one feature or are used multiple times within the same feature, so that the intersection node will not be lost from intersecting roads. (This will not be effective if you also use --coalesce or --detect-shared-borders.)
  • -pt or --no-tiny-polygon-reduction: Don't combine the area of very small polygons into small squares that represent their combined area.

Attempts to improve shared polygon boundaries

  • -ab or --detect-shared-borders: In the manner of TopoJSON, detect borders that are shared between multiple polygons and simplify them identically in each polygon. This takes more time and memory than considering each polygon individually.
  • -aL or --grid-low-zooms: At all zoom levels below maxzoom, snap all lines and polygons to a stairstep grid instead of allowing diagonals. You will also want to specify a tile resolution, probably -D8. This option provides a way to display continuous parcel, gridded, or binned data at low zooms without overwhelming the tiles with tiny polygons, since features will either get stretched out to the grid unit or lost entirely, depending on how they happened to be aligned in the original data. You probably don't want to use this.

Controlling clipping to tile boundaries

  • -b pixels or --buffer=pixels: Buffer size where features are duplicated from adjacent tiles. Units are "screen pixels"—1/256th of the tile width or height. (default 5)
  • -pc or --no-clipping: Don't clip features to the size of the tile. If a feature overlaps the tile's bounds or buffer at all, it is included completely. Be careful: this can produce very large tilesets, especially with large polygons.
  • -pD or --no-duplication: As with --no-clipping, each feature is included intact instead of cut to tile boundaries. In addition, it is included only in a single tile per zoom level rather than potentially in multiple copies. Clients of the tileset must check adjacent tiles (possibly some distance away) to ensure they have all features.

Reordering features within each tile

  • -pi or --preserve-input-order: Preserve the original input order of features as the drawing order instead of ordering geographically. (This is implemented as a restoration of the original order at the end, so that dot-dropping is still geographic, which means it also undoes -ao).
  • -ac or --coalesce: Coalesce consecutive features that have the same attributes. This can be useful if you have lots of small polygons with identical attributes and you would like to merge them together.
  • -ao or --reorder: Reorder features to put ones with the same attributes in sequence (instead of ones that are approximately spatially adjacent), to try to get them to coalesce. You probably want to use this if you use --coalesce.
  • -ar or --reverse: Try reversing the directions of lines to make them coalesce and compress better. You probably don't want to use this.
  • -ah or --hilbert: Put features in Hilbert Curve order instead of the usual Z-Order. This improves the odds that spatially adjacent features will be sequentially adjacent, and should improve density calculations and spatial coalescing. It should be the default eventually.

Adding calculated attributes

  • -ag or --calculate-feature-density: Add a new attribute, tippecanoe_feature_density, to each feature, to record how densely features are spaced in that area of the tile. You can use this attribute in the style to produce a glowing effect where points are densely packed. It can range from 0 in the sparsest areas to 255 in the densest.
  • -ai or --generate-ids: Add an id (a feature ID, not an attribute named id) to each feature that does not already have one. There is currently no guarantee that the id added will be stable between runs or that it will not conflict with manually-assigned feature IDs. Future versions of Tippecanoe may change the mechanism for allocating IDs.

Trying to correct bad source geometry

  • -aw or --detect-longitude-wraparound: Detect when consecutive points within a feature jump to the other side of the world, and try to fix the geometry.
  • -pw or --use-source-polygon-winding: Instead of respecting GeoJSON polygon ring order, use the original polygon winding in the source data to distinguish inner (clockwise) and outer (counterclockwise) polygon rings.
  • -pW or --reverse-source-polygon-winding: Instead of respecting GeoJSON polygon ring order, use the opposite of the original polygon winding in the source data to distinguish inner (counterclockwise) and outer (clockwise) polygon rings.
  • --clip-bounding-box=minlon,minlat,maxlon,maxlat: Clip all features to the specified bounding box.

Setting or disabling tile size limits

  • -M bytes or --maximum-tile-bytes=bytes: Use the specified number of bytes as the maximum compressed tile size instead of 500K.
  • -O features or --maximum-tile-features=features: Use the specified number of features as the maximum in a tile instead of 200,000.
  • -pf or --no-feature-limit: Don't limit tiles to 200,000 features
  • -pk or --no-tile-size-limit: Don't limit tiles to 500K bytes
  • -pC or --no-tile-compression: Don't compress the PBF vector tile data. If you are getting "Unimplemented type 3" error messages from a renderer, it is probably because it expects uncompressed tiles using this option rather than the normal gzip-compressed tiles.
  • -pg or --no-tile-stats: Don't generate the tilestats row in the tileset metadata. Uploads without tilestats will take longer to process.
  • --tile-stats-attributes-limit=count: Include tilestats information about at most count attributes instead of the default 1000.
  • --tile-stats-sample-values-limit=count: Calculate tilestats attribute statistics based on count values instead of the default 1000.
  • --tile-stats-values-limit=count: Report count unique attribute values in tilestats instead of the default 100.

Temporary storage

  • -t directory or --temporary-directory=directory: Put the temporary files in directory. If you don't specify, it will use /tmp.

Progress indicator

  • -q or --quiet: Work quietly instead of reporting progress or warning messages
  • -Q or --no-progress-indicator: Don't report progress, but still give warnings
  • -U seconds or --progress-interval=seconds: Don't report progress more often than the specified number of seconds.
  • -v or --version: Report Tippecanoe's version number

Filters

  • -C command or --prefilter=command: Specify a shell filter command to be run at the start of assembling each tile
  • -c command or --postfilter=command: Specify a shell filter command to be run at the end of assembling each tile

The pre- and post-filter commands allow you to do optional filtering or transformation on the features of each tile as it is created. They are shell commands, run with the zoom level, X, and Y as the $1, $2, and $3 arguments. Future versions of Tippecanoe may add additional arguments for more context.

The features are provided to the filter as a series of newline-delimited GeoJSON objects on the standard input, and tippecanoe expects to read another set of GeoJSON features from the filter's standard output.

The prefilter receives the features at the highest available resolution, before line simplification, polygon topology repair, gamma calculation, dynamic feature dropping, or other internal processing. The postfilter receives the features at tile resolution, after simplification, cleaning, and dropping.

The layer name is provided as part of the tippecanoe element of the feature and must be passed through to keep the feature in its correct layer. In the case of the prefilter, the tippecanoe element may also contain index, sequence, extent, and dropped, elements, which must be passed through for internal operations like --drop-densest-as-needed, --drop-smallest-as-needed, and --preserve-input-order to work.

Examples:

  • Make a tileset of the Natural Earth countries to zoom level 5, and also copy the GeoJSON features to files in a tiles/z/x/y.geojson directory hierarchy.
tippecanoe -o countries.mbtiles -z5 -C 'mkdir -p tiles/$1/$2; tee tiles/$1/$2/$3.geojson' ne_10m_admin_0_countries.json
tippecanoe -o countries.mbtiles -z5 -C './filters/limit-tiles-to-bbox 5.8662 47.2702 15.0421 55.0581 $*' ne_10m_admin_0_countries.json
  • Make a tileset of TIGER roads in Tippecanoe County, leaving out all but primary and secondary roads (as classified by TIGER) below zoom level 11.
tippecanoe -o roads.mbtiles -c 'if [ $1 -lt 11 ]; then grep "\"MTFCC\": \"S1[12]00\""; else cat; fi' tl_2016_18157_roads.json

Environment

Tippecanoe ordinarily uses as many parallel threads as the operating system claims that CPUs are available. You can override this number by setting the TIPPECANOE_MAX_THREADS environmental variable.

GeoJSON extension

Tippecanoe defines a GeoJSON extension that you can use to specify the minimum and/or maximum zoom level at which an individual feature will be included in the vector tileset being produced. If you have a feature like this:

{
    "type" : "Feature",
    "tippecanoe" : { "maxzoom" : 9, "minzoom" : 4 },
    "properties" : { "FULLNAME" : "N Vasco Rd" },
    "geometry" : {
        "type" : "LineString",
        "coordinates" : [ [ -121.733350, 37.767671 ], [ -121.733600, 37.767483 ], [ -121.733131, 37.766952 ] ]
    }
}

with a tippecanoe object specifiying a maxzoom of 9 and a minzoom of 4, the feature will only appear in the vector tiles for zoom levels 4 through 9. Note that the tippecanoe object belongs to the Feature, not to its properties. If you specify a minzoom for a feature, it will be preserved down to that zoom level even if dot-dropping with -r would otherwise have dropped it.

You can also specify a layer name in the tippecanoe object, which will take precedence over the filename or name specified using --layer, like this:

{
    "type" : "Feature",
    "tippecanoe" : { "layer" : "streets" },
    "properties" : { "FULLNAME" : "N Vasco Rd" },
    "geometry" : {
        "type" : "LineString",
        "coordinates" : [ [ -121.733350, 37.767671 ], [ -121.733600, 37.767483 ], [ -121.733131, 37.766952 ] ]
    }
}

If your source GeoJSON only has minzoom, maxzoom and/or layer within properties you can use ndjson-cli to move them into the required tippecanoe object by piping the GeoJSON like this:

ndjson-map 'd.tippecanoe = { minzoom: d.properties.minzoom, maxzoom: d.properties.maxzoom, layer: d.properties.layer }, delete d.properties.minzoom, delete d.properties.maxzoom, delete d.properties.layer, d'

Geometric simplifications

At every zoom level, line and polygon features are subjected to Douglas-Peucker simplification to the resolution of the tile.

For point features, it drops 1/2.5 of the dots for each zoom level above the point base zoom (which is normally the same as the -z max zoom, but can be a different zoom specified with -B if you have precise but sparse data). I don't know why 2.5 is the appropriate number, but the densities of many different data sets fall off at about this same rate. You can use -r to specify a different rate.

You can use the gamma option to thin out especially dense clusters of points. For any area where dots are closer than one pixel together (at whatever zoom level), a gamma of 3, for example, will reduce these clusters to the cube root of their original density.

For line features, it drops any features that are too small to draw at all. This still leaves the lower zooms too dark (and too dense for the 500K tile limit, in some places), so I need to figure out an equitable way to throw features away.

Unless you specify --no-tiny-polygon-reduction, any polygons that are smaller than a minimum area (currently 4 square subpixels) will have their probability diffused, so that some of them will be drawn as a square of this minimum size and others will not be drawn at all, preserving the total area that all of them should have had together.

Features in the same tile that share the same type and attributes are coalesced together into a single geometry if you use --coalesce. You are strongly encouraged to use -x to exclude any unnecessary attributes to reduce wasted file size.

If a tile is larger than 500K, it will try encoding that tile at progressively lower resolutions before failing if it still doesn't fit.

Development

Requires sqlite3 and zlib (should already be installed on MacOS). Rebuilding the manpage uses md2man (gem install md2man).

Linux:

sudo apt-get install build-essential libsqlite3-dev zlib1g-dev

Then build:

make

and perhaps

make install

Tippecanoe now requires features from the 2011 C++ standard. If your compiler is older than that, you will need to install a newer one. On MacOS, updating to the lastest XCode should get you a new enough version of clang++. On Linux, you should be able to upgrade g++ with

sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
sudo apt-get update -y
sudo apt-get install -y g++-5
export CXX=g++-5

Docker Image

A tippecanoe Docker image can be built from source and executed as a task to automatically install dependencies and allow tippecanoe to run on any system supported by Docker.

$ docker build -t tippecanoe:latest .
$ docker run -it --rm \
  -v /tiledata:/data \
  tippecanoe:latest \
  tippecanoe --output=/data/output.mbtiles /data/example.geojson

The commands above will build a Docker image from the source and compile the latest version. The image supports all tippecanoe flags and options.

Examples

Check out some examples of maps made with tippecanoe

Name

The name is a joking reference to a "tiler" for making map tiles.

tile-join

Tile-join is a tool for copying and merging vector mbtiles files and for joining new attributes from a CSV file to existing features in them.

It reads the tiles from an existing .mbtiles file or a directory of tiles, matches them against the records of the CSV (if one is specified), and writes out a new tileset.

If you specify multiple source mbtiles files or source directories of tiles, all the sources are read and their combined contents are written to the new mbtiles output. If they define the same layers or the same tiles, the layers or tiles are merged.

The options are:

Output tileset

  • -o out.mbtiles or --output=out.mbtiles: Write the new tiles to the specified .mbtiles file.
  • -e directory or --output-to-directory=directory: Write the new tiles to the specified directory instead of to an mbtiles file.
  • -f or --force: Remove out.mbtiles if it already exists.

Tileset description and attribution

  • -A attribution or --attribution=attribution: Set the attribution string.
  • -n name or --name=name: Set the tileset name.
  • -N description or --description=description: Set the tileset description.

Layer filtering and naming

  • -l layer or --layer=layer: Include the named layer in the output. You can specify multiple -l options to keep multiple layers. If you don't specify, they will all be retained.
  • -L layer or --exclude-layer=layer: Remove the named layer from the output. You can specify multiple -L options to remove multiple layers.
  • -Rold:new or --rename-layer=old:new: Rename the layer named old to be named new instead. You can specify multiple -R options to rename multiple layers. Renaming happens before filtering.

Zoom levels

  • -z zoom or --maximum-zoom=zoom: Don't copy tiles from higher zoom levels than the specified zoom
  • -Z zoom or --minimum-zoom=zoom: Don't copy tiles from lower zoom levels than the specified zoom

Merging attributes from a CSV file

  • -c match.csv or --csv=match.csv: Use match.csv as the source for new attributes to join to the features. The first line of the file should be the key names; the other lines are values. The first column is the one to match against the existing features; the other columns are the new data to add.

Filtering features and feature attributes

  • -x key or --exclude=key: Remove attributes of type key from the output. You can use this to remove the field you are matching against if you no longer need it after joining, or to remove any other attributes you don't want.
  • -X or --exclude-all: Remove all attributes from the output.
  • -i or --if-matched: Only include features that matched the CSV.
  • -j filter or --feature-filter=filter: Check features against a per-layer filter (as defined in the Mapbox GL Style Specification) and only include those that match. Any features in layers that have no filter specified will be passed through. Filters for the layer "*" apply to all layers.
  • -J filter-file or --feature-filter-file=filter-file: Like -j, but read the filter from a file.
  • -pe or --empty-csv-columns-are-null: Treat empty CSV columns as nulls rather than as empty strings.

Setting or disabling tile size limits

  • -pk or --no-tile-size-limit: Don't skip tiles larger than 500K.
  • -pC or --no-tile-compression: Don't compress the PBF vector tile data.
  • -pg or --no-tile-stats: Don't generate the tilestats row in the tileset metadata. Uploads without tilestats will take longer to process.

Because tile-join just copies the geometries to the new .mbtiles without processing them (except to rescale the extents if necessary), it doesn't have any of tippecanoe's recourses if the new tiles are bigger than the 500K tile limit. If a tile is too big and you haven't specified -pk, it is just left out of the new tileset.

Example

Imagine you have a tileset of census blocks:

curl -L -O http://www2.census.gov/geo/tiger/TIGER2010/TABBLOCK/2010/tl_2010_06001_tabblock10.zip
unzip tl_2010_06001_tabblock10.zip
ogr2ogr -f GeoJSON tl_2010_06001_tabblock10.json tl_2010_06001_tabblock10.shp
./tippecanoe -o tl_2010_06001_tabblock10.mbtiles tl_2010_06001_tabblock10.json

and a CSV of their populations:

curl -L -O http://www2.census.gov/census_2010/01-Redistricting_File--PL_94-171/California/ca2010.pl.zip
unzip -p ca2010.pl.zip cageo2010.pl |
awk 'BEGIN {
    print "GEOID10,population"
}
(substr($0, 9, 3) == "750") {
    print "\"" substr($0, 28, 2) substr($0, 30, 3) substr($0, 55, 6) substr($0, 62, 4) "\"," (0 + substr($0, 328, 9))
}' > population.csv

which looks like this:

GEOID10,population
"060014277003018",0
"060014283014046",0
"060014284001020",0
...
"060014507501001",202
"060014507501002",119
"060014507501003",193
"060014507501004",85
...

Then you can join those populations to the geometries and discard the no-longer-needed ID field:

./tile-join -o population.mbtiles -x GEOID10 -c population.csv tl_2010_06001_tabblock10.mbtiles

tippecanoe-enumerate

The tippecanoe-enumerate utility lists the tiles that an mbtiles file defines. Each line of the output lists the name of the mbtiles file and the zoom, x, and y coordinates of one of the tiles. It does basically the same thing as

select zoom_level, tile_column, (1 << zoom_level) - 1 - tile_row from tiles;

on the file in sqlite3.

tippecanoe-decode

The tippecanoe-decode utility turns vector mbtiles back to GeoJSON. You can use it either on an entire file:

tippecanoe-decode file.mbtiles

or on an individual tile:

tippecanoe-decode file.mbtiles zoom x y
tippecanoe-decode file.vector.pbf zoom x y

Unless you use -c, the output is a set of nested FeatureCollections identifying each tile and layer separately. Note that the same features generally appear at all zooms, so the output for the file will have many copies of the same features at different resolutions.

Options

  • -s projection or --projection=projection: Specify the projection of the output data. Currently supported are EPSG:4326 (WGS84, the default) and EPSG:3857 (Web Mercator).
  • -z maxzoom or --maximum-zoom=maxzoom: Specify the highest zoom level to decode from the tileset
  • -Z minzoom or --minimum-zoom=minzoom: Specify the lowest zoom level to decode from the tileset
  • -l layer or --layer=layer: Decode only layers with the specified names. (Multiple -l options can be specified.)
  • -c or --tag-layer-and-zoom: Include each feature's layer and zoom level as part of its tippecanoe object rather than as a FeatureCollection wrapper
  • -S or --stats: Just report statistics about each tile's size and the number of features in it, as a JSON structure.
  • -f or --force: Decode tiles even if polygon ring order or closure problems are detected

tippecanoe-json-tool

Extracts GeoJSON features or standalone geometries as line-delimited JSON objects from a larger JSON file, following the same extraction rules that Tippecanoe uses when parsing JSON.

tippecanoe-json-tool file.json [... file.json]

Optionally also wraps them in a FeatureCollection or GeometryCollection as appropriate.

Optionally extracts an attribute from the GeoJSON properties for sorting.

Optionally joins a sorted CSV of new attributes to a sorted GeoJSON file.

The reason for requiring sorting is so that it is possible to work on CSV and GeoJSON files that are larger than can comfortably fit in memory by streaming through them in parallel, in the same way that the Unix join command does. The Unix sort command can be used to sort large files to prepare them for joining.

The sorting interface is weird, and future version of tippecanoe-json-tool will replace it with something better.

Options

  • -w or --wrap: Add the FeatureCollection or GeometryCollection wrapper.
  • -e attribute or --extract=attribute: Extract the named attribute as a prefix to each feature. The formatting makes excessive use of \u quoting so that it follows JSON string rules but will still be sorted correctly by tools that just do ASCII comparisons.
  • -c file.csv or --csv=file.csv: Join attributes from the named sorted CSV file, using its first column as the join key. Geometries will be passed through even if they do not match the CSV; CSV lines that do not match a geometry will be discarded.
  • -pe or --empty-csv-columns-are-null: Treat empty CSV columns as nulls rather than as empty strings.

Example

Join Census LEHD (Longitudinal Employer-Household Dynamics) employment data to a file of Census block geography for Tippecanoe County, Indiana.

Download Census block geometry, and convert to GeoJSON:

$ curl -L -O https://www2.census.gov/geo/tiger/TIGER2010/TABBLOCK/2010/tl_2010_18157_tabblock10.zip
$ unzip tl_2010_18157_tabblock10.zip
$ ogr2ogr -f GeoJSON tl_2010_18157_tabblock10.json tl_2010_18157_tabblock10.shp

Download Indiana employment data, and fix name of join key in header

$ curl -L -O https://lehd.ces.census.gov/data/lodes/LODES7/in/wac/in_wac_S000_JT00_2015.csv.gz
$ gzip -dc in_wac_S000_JT00_2015.csv.gz | sed '1s/w_geocode/GEOID10/' > in_wac_S000_JT00_2015.csv

Sort GeoJSON block geometry so it is ordered by block ID. If you don't do this, you will get a "GeoJSON file is out of sort" error.

$ tippecanoe-json-tool -e GEOID10 tl_2010_18157_tabblock10.json | LC_ALL=C sort > tl_2010_18157_tabblock10.sort.json

Join block geometries to employment attributes:

$ tippecanoe-json-tool -c in_wac_S000_JT00_2015.csv tl_2010_18157_tabblock10.sort.json > blocks-wac.json
Issues
  • Can't generate tile with very dense polygon layer

    Can't generate tile with very dense polygon layer

    I have a dense polygon layer of parcel boundaries containing 2.5 million records and over 75 million points. I've tried all sorts of options to generate tiles for the data, but it keeps failing on zoom level 8. Here's the data:

    https://dl.dropboxusercontent.com/u/30623980/nz_primary_parcels.json.zip

    screen shot 2016-10-21 at 9 00 00 pm

    The last set of options I tried was:

    tippecanoe -X -r4.0 -d 8 -B 18 -S 10 -pd -ar -o primary_parcels.mbtiles nz_primary_parcels.json
    

    output https://gist.github.com/palmerj/d99ce2d3a3de2d083767ff14d8703520

    I also tried the -pk option but that also failed (And also ended up with large vtiles).

    I'm running on MacOSX using latest master build.

    tippecanoe --version
    tippecanoe v1.14.4
    

    Any suggestions?

    opened by palmerj 54
  • Windows build

    Windows build

    Any thoughts on creating package for Windows? Or perhaps adding instructions for creating a windows build to the documentation?

    opened by chrislukic 34
  • [Feature Request] Prefilter and Postfilter Functionality as Long-running Process

    [Feature Request] Prefilter and Postfilter Functionality as Long-running Process

    Tippecanoe supports prefilter and postfilter arguments to perform per-tile transformations. It looks like Tippecanoe starts a new process for each tile, though. Is that correct?

    Would it be possible to have the ability to instead keep the prefilter and postfilter functionality running alongside Tippecanoe in their own processes, instead of per tile? Instead of starting up the filter processes with the z, x, and y arguments, I suppose it can just pass those variables on stdin whenever the tile changes. Maybe something like:

    0 0 0
    { "type": "Feature" .... }
    { "type": "Feature" .... }
    { "type": "Feature" .... }
    .
    .
    .
    1 0 0
    { "type": "Feature" .... }
    { "type": "Feature" .... }
    { "type": "Feature" .... }
    .
    .
    .
    

    And Tippecanoe can continue to handle the output as it usually does.

    opened by caneroj1 31
  • Upgrade Clipper to 07b828b1 to fix self-intersecting polygons

    Upgrade Clipper to 07b828b1 to fix self-intersecting polygons

    cc @mourner @flippmoke

    opened by e-n-f 28
  • Tippecanoe consistently freezes up with complex geometry

    Tippecanoe consistently freezes up with complex geometry

    We have a large national parks GeoJSON dataset with large, complex geometry (the Appalachian trail for example). Tippecanoe consistently freezes up around ~23% whenever that dataset is included. I've tried to dive into the code to figure out where this is happening, but I'm not sure how to debug that.

    Any ideas?

    opened by outlandnish 24
  • running tippecanoe on larger geo json files

    running tippecanoe on larger geo json files

    i have 2 layers that need to be proccessed into tippecanoe, one is 57gb (water) and the other is 230gb(roads)

    i had planned on running tippecaoe with my options on just 1 zoom layer at a time and using tile-join to join the mbtiles files together but it is killing the process immediately

    is there any suggestions ? or would you know how much processing power would be needed to run this conversion?

    screen shot 2017-04-12 at 11 14 58 am
    opened by kenchambers 22
  • What's the difference between z20 with Z15 z20?

    What's the difference between z20 with Z15 z20?

    Hi all: I have make a test ,the steps like these: case 1: tippecanoe -z 20 -L admin:admin.geojson -o admin.mbtiles case 2: step 1: tippecanoe -z 14 -L admin:admin.geojson -o admin0.mbtiles step 2: tippecanoe -Z15 -z20 -L admin:admin.geojson -o admin1.mbtiles step 3: tile-join admin0.mbtiles admin1.mbtiles -o admin.mbtiles

    The question are:

    1. In case 2, the step 2 process is very very slow, why?
    2. In case 2, the file size of admin1.mbtiles is much more bigger than admin.mbtiles(case 1), why?

    Is there any idea?Thanks!

    opened by dythbj 19
  • input geobuf with multiple Data{} messages

    input geobuf with multiple Data{} messages

    Can one input stream (one giant geobuf) containing multiple proto Data{} message be supported? Currently only 1 Data{} message for each geobuf is supported if i am not mistaken? Protobuf has message size limitations that can be solved by splitting it up in several Data{} messages

    opened by gertcuykens 18
  • Question on performance

    Question on performance

    Hi there, I had a qq on performance. I have four geojson files, which are all really quite small (1.5MB, 7.4MB, 3.4MB, 1.5MB). But I am trying to use tippecanoe on them, and it's been going for almost two hours now (granted it's running on my macbook, but still)?

    The output tells me the four layers contain: 3295 features, 4149968 bytes of geometry, 945005 bytes of metadata

    Note: I did run tippecanoe with -z17 but it's only at 82.8% at the moment, and according to the output it's still on zoom level 14. ie even if I hadn't changed the zoom level, I dont think it would be done by now.

    The mbtiles it's producing so far is already 2GB. Which is rather impressive since the input in total is just under 15mb :-)

    Is this expected??

    question 
    opened by liebrand 18
  • Inner rings not inside outer rings

    Inner rings not inside outer rings

    Further testing on Natural Earth ne_10m_admin_0_countries turns up lots of cases where a polygon's inner ring has points that are not inside the polygon's outer ring according to pnpoly.

    I'm not sure yet whether they are (harmlessly?) on the line or genuinely sticking out.

    opened by e-n-f 18
  • Uncluster features at a particular zoom level

    Uncluster features at a particular zoom level

    I have a geojson having a large number of features. I am using tippecanoe to convert the geojson into vector. It works but one thing i want to have is that if map reaches a particular zoom level the the features should uncluster irrespective of distance between them. How can i achieve this?

    opened by Samaid2025 0
  • Make error

    Make error

    From Github Actions:

    Cloning into 'tippecanoe'...
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o geojson.o geojson.cpp
    cc -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -c -o jsonpull/jsonpull.o jsonpull/jsonpull.c
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o tile.o tile.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o pool.o pool.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o mbtiles.o mbtiles.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o geometry.o geometry.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o projection.o projection.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o memfile.o memfile.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o mvt.o mvt.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o serial.o serial.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o main.o main.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o text.o text.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o dirtiles.o dirtiles.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o plugin.o plugin.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o read_json.o read_json.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o write_json.o write_json.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o geobuf.o geobuf.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o evaluator.o evaluator.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o geocsv.o geocsv.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o csv.o csv.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o geojson-loop.o geojson-loop.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o enumerate.o enumerate.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o decode.o decode.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o tile-join.o tile-join.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o unit.o unit.cpp
    g++ -MMD  -I/usr/local/include -I. -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -c -o jsontool.o jsontool.cpp
    g++  -L/usr/local/lib -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -o tippecanoe-enumerate enumerate.o  -lsqlite3
    g++  -L/usr/local/lib -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -o tippecanoe-json-tool jsontool.o jsonpull/jsonpull.o csv.o text.o geojson-loop.o  -lm -lz -lsqlite3 -lpthread
    g++  -L/usr/local/lib -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -o tippecanoe-decode decode.o projection.o mvt.o write_json.o text.o jsonpull/jsonpull.o dirtiles.o  -lm -lz -lsqlite3
    g++  -L/usr/local/lib -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -o tile-join tile-join.o projection.o pool.o mbtiles.o mvt.o memfile.o dirtiles.o jsonpull/jsonpull.o text.o evaluator.o csv.o write_json.o  -lm -lz -lsqlite3 -lpthread
    g++  -L/usr/local/lib -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -o tippecanoe geojson.o jsonpull/jsonpull.o tile.o pool.o mbtiles.o geometry.o projection.o memfile.o mvt.o serial.o main.o text.o dirtiles.o plugin.o read_json.o write_json.o geobuf.o evaluator.o geocsv.o csv.o geojson-loop.o  -lm -lz -lsqlite3 -lpthread
    g++  -L/usr/local/lib -g -Wall -Wshadow -Wsign-compare -Wextra -Wunreachable-code -Wuninitialized -Wshadow -O3 -DNDEBUG  -std=c++11 -o unit unit.o text.o  -lm -lz -lsqlite3 -lpthread
    mkdir -p /usr/local/bin
    mkdir -p /usr/local/share/man/man1/
    cp tippecanoe /usr/local/bin/tippecanoe
    cp tippecanoe-enumerate /usr/local/bin/tippecanoe-enumerate
    cp tippecanoe-decode /usr/local/bin/tippecanoe-decode
    cp tippecanoe-json-tool /usr/local/bin/tippecanoe-json-tool
    cp tile-join /usr/local/bin/tile-join
    cp man/tippecanoe.1 /usr/local/share/man/man1//tippecanoe.1
    cp: cannot create regular file '/usr/local/share/man/man1//tippecanoe.1': Permission denied
    make: *** [Makefile:34: install] Error 1
    Error: Process completed with exit code 2.
    

    Is the double slash wrong/causing this?

    Expected cp man/tippecanoe.1 /usr/local/share/man/man1/tippecanoe.1

    Looks like makefile Ln2 has a closing / where it should not.

    opened by golfecholima 4
  • Modifying feature attribute by expressions?

    Modifying feature attribute by expressions?

    Hi everyone: Is there any way to modifying feature attribute by expressions? eg: feature attribute "A" has different values in different zoom level --expression A=10-$zoom Hope for you help!

    opened by dythbj 0
  • LineString feature splits/breaks at tile edge

    LineString feature splits/breaks at tile edge

    Originally posted in mapbox-gl-js: [https://github.com/mapbox/mapbox-gl-js/issues/11073#issuecomment-936331366](GL-JS Issue)

    My sample dataset is generated from zoom level 14-16. On level 16, several lines deviate from the correct path somehow. Vladimir suggested I check with tippecanoe to see can be done. His comment was that the coordinates go past the maximum possible buffer and result in the line being shifted.

    Is the line not "dense" enough with points?

    Link to viewable failure: https://jsfiddle.net/alexthomaseog/u2q3ev5k

    tippecanoe command:

    tippecanoe -f -Q -P -l outputlayer -e /tmp/outputsource -b0 -r1 --drop-densest-as-needed -pc -ps -z16 -Z14 //tmp/output.geojson
    

    //tmp/output.geojson :

    {"geometry":{"type":"LineString","coordinates":[[-103.84333237,32.06315212],[-103.8424836,32.06298158],[-103.84409085,32.05280362],[-103.84304467,32.0526831]]},"type":"Feature","properties":{"shape_length":0.012222915323124061}}
    {"geometry":{"type":"LineString","coordinates":[[-103.84386138,32.05356729],[-103.84232055,32.063333]]},"type":"Feature","properties":{"shape_length":0.009886512980288725}}
    {"geometry":{"type":"LineString","coordinates":[[-103.84221115,32.0634072],[-103.84375238,32.05363809]]},"type":"Feature","properties":{"shape_length":0.009889933775552704}}
    {"geometry":{"type":"LineString","coordinates":[[-103.84318992,32.0528697],[-103.84376815,32.0529419],[-103.84387915,32.0529591],[-103.84387495,32.0529911],[-103.84348885,32.05546468],[-103.84292098,32.05901744],[-103.84239231,32.06240941],[-103.84219655,32.0634386],[-103.84223295,32.0634426]]},"type":"Feature","properties":{"shape_length":0.011345890692680561}}
    {"geometry":{"type":"LineString","coordinates":[[-103.84309571,32.0527825],[-103.84398175,32.0528997],[-103.84400035,32.0529261],[-103.84397935,32.0529421],[-103.84397376,32.0529631],[-103.84371242,32.05462848],[-103.84295301,32.05950124],[-103.84246472,32.06244421],[-103.84233655,32.0633358]]},"type":"Feature","properties":{"shape_length":0.011475483112780932}}
    {"geometry":{"type":"LineString","coordinates":[[-103.84216241,32.063362],[-103.84382501,32.0528987],[-103.84305398,32.0528099]]},"type":"Feature","properties":{"shape_length":0.011370695476310786}}
    {"geometry":{"type":"LineString","coordinates":[[-103.84309131,32.0527349],[-103.84395315,32.0528331],[-103.84362883,32.05490348],[-103.8429118,32.05941704],[-103.8424909,32.06204961],[-103.8424853,32.06206721],[-103.84219516,32.06371999]]},"type":"Feature","properties":{"shape_length":0.011895731314378741}}
    
    
    opened by AlexThomasEOG 0
  • catch exception when parsing invalid pbf - fixes #817

    catch exception when parsing invalid pbf - fixes #817

    adding a try/catch block to catch exceptions when decoding so that an error message is printed detailing which tile caused the exception

    opened by mmc1718 0
  • Feature Request: --one-tile option for tile-join

    Feature Request: --one-tile option for tile-join

    I have a similar situation to https://github.com/mapbox/tippecanoe/issues/109 where I am constantly amending an mbtiles with new geojson using tile-join. I have a serverless backend that serves vector tiles. Sometimes the mbtiles requires many updates in quick succession so re-generating, deleting and uploading all the files for the standard output wasn't feasible. Currently I fetch the mbtiles, generate the tiles and return the requested x/y/z. This works but it still requires me to generate hundreds of files on each request (they are cached but still), it would be great if tile-join had a --one-tile property similar to tippecanoe.

    To summarize, for updating tiles I do essentially:

    • fetch existing.mbtiles
    • tile-join -f -o /tmp/existing.mbtiles /tmp/new.mbtiles /tmp/old.mbtiles
    • upload new.mbtiles as existing.mbtiles

    Then on each vector tile request to /endpoint/z/x/y

    • fetch existing.mbtiles
    • tile-join -f -e /tmp/tiles -z18 --layer=run /tmp/existing.mbtiles <- this generates the entire structure unnecessarily
    • return /tmp/tiles/z/x/y.pbf

    Admittedly I'm not sure how much of a performance gain I'd get by only generating one tile since I don't know the implementation details but this would be helpful. If you know of a better way of doing what I'm doing that I'm open to that as well, thank you.

    opened by RyPope 0
  • Timestamp, can't represent too-large feature.

    Timestamp, can't represent too-large feature.

    Hi, I have a csv with a column named timestamp. When I execute tippecanoe with this csv file I get the following warning: Warning: Can't represent too-large feature ID 0. I have converted the timestamp column values to string values assuming it could not represent the attribute because of the size of the integer values (1e09) and it could represent a nine character string, but the same warning is appearing possibly because even though I converted the values to string, it may be inferring is an integer, I do not know. In anycase is there any solution to be able to use tippecanoe and represent the feature attribute timestamp?

    opened by JavierBrRuiz 0
  • "Show countries at low zoom levels but states at higher zoom levels" manual example does not work

    The "Show countries at low zoom levels but states at higher zoom levels" entry in the manual does not work since you can't join tiles with mismatched zoom layers. The example will give the following warning:

    "Warning: mismatched maxzooms: 5 in states-Z4.mbtiles vs previous 3" 
    
    opened by Marwwin 0
  • Clustering gives wrong point_count value

    Clustering gives wrong point_count value

    Hello, I encounter some difficulties with clustering of features.

    I gave about 1 millions features to Tippecanoe with the following call: tippecanoe --force --no-tile-compression -zg --cluster-distance=60 -r1

    Then with Openlayers I display the value of point_count for each feature and when I am zooming in a lot, a lot of features have a wrong point_count.

    The following image shows a feature wich is alone, so it should not be clustered (so we would not have 3 as point_count value) :

    image

    If I use the same geojson to generate vector tiles without clustering, there is indeed only one feature on this position and not 3. This is also not 3 features at the exactly same position.

    I have really no ideas and how to fix this but I really need to have the right value on point_count.

    I saw that you worked on this feature @ericfischer maybe you could help me on this please?

    Thank you very much!

    opened by AntoJvlt 0
  • About ArcGIS api for js‘s vector tile

    About ArcGIS api for js‘s vector tile

    Hello

    I'm glad to discuss Tippecanoe with you. I use Tippecanoe to output PBF folder and load it with ArcGIS API for JS. I define the coordinate system as EPSG: 4326, but after the map is displayed, it is loaded into wkid: 3857. Can you help me to solve the problem?

    opened by Antlers777 0
Releases(1.36.0)
  • 1.36.0(Aug 26, 2020)

  • 1.35.0(Feb 7, 2020)

    1.35.0

    • Fix calculation of mean when accumulating attributes in clusters

    1.34.6

    • Fix crash when there are null entries in the metadata table

    1.34.5

    • Fix line numbers in GeoJSON feature parsing error messages

    1.34.4

    • Be careful to avoid undefined behavior from shifting negative numbers
    Source code(tar.gz)
    Source code(zip)
  • 1.34.3(May 16, 2019)

    1.34.3

    • Add an option to keep intersection nodes from being simplified away

    1.34.2

    • Be more consistent about when longitudes beyond 180 are allowed. Now if the entire feature is beyond 180, it will still appear.

    1.34.1

    • Don't run shell filters if the current zoom is below the minzoom
    • Fix -Z and -z for tile directories in tile-join and tippecanoe-decode
    • Return a successful error status for --help and --version
    Source code(tar.gz)
    Source code(zip)
  • 1.34.0(Apr 5, 2019)

  • 1.33.0(Mar 2, 2019)

    1.33.0

    • MultiLineStrings were previously ignored in Geobuf input

    1.32.12

    • Accept .mvt as well as .pbf in directories of tiles
    • Allow tippecanoe-decode and tile-join of directories with no metadata

    1.32.11

    • Don't let attribute exclusion apply to the attribute that has been specified to become the feature ID
    Source code(tar.gz)
    Source code(zip)
  • 1.32.10(Jan 16, 2019)

  • 1.32.9(Dec 19, 2018)

    1.32.9

    • Limit tile detail to 30 and buffer size to 127 to prevent coordinate delta overflow in vector tiles.

    1.32.8

    • Better error message if the output tileset already exists

    1.32.7

    • Point features may now be coalesced into MultiPoint features with --coalesce.
    • Add --hilbert option to put features in Hilbert Curve sequence

    1.32.6

    • Make it an error, not a warning, to have missing coordinates for a point
    Source code(tar.gz)
    Source code(zip)
  • 1.32.5(Nov 26, 2018)

    1.32.5

    • Use less memory on lines and polygons that are too small for the tile
    • Fix coordinate rounding problem that was causing --grid-low-zooms grids to be lost at low zooms if the original polygons were not aligned to tile boundaries

    1.32.4

    • Ignore leading zeroes when converting string attributes to feature IDs
    Source code(tar.gz)
    Source code(zip)
  • 1.32.3(Nov 7, 2018)

    1.32.3

    • Add an option to convert stringified number feature IDs to numbers
    • Add an option to use a specified feature attribute as the feature ID

    1.32.2

    • Warn in tile-join if tilesets being joined have inconsistent maxzooms
    Source code(tar.gz)
    Source code(zip)
  • 1.32.1(Oct 23, 2018)

    1.32.1

    • Fix null pointer crash when reading filter output that does not tag features with their extent
    • Add --clip-bounding-box option to clip input geometry
    Source code(tar.gz)
    Source code(zip)
  • 1.32.0(Oct 10, 2018)

    1.32.0

    • Fix a bug that allowed coalescing of features with mismatched attributes if they had been passed through a shell prefilter

    1.31.7

    • Create the output tile directory even if there are no valid features

    1.31.6

    • Issue an error message in tile-join if minzoom is greater than maxzoom
    Source code(tar.gz)
    Source code(zip)
  • 1.31.5(Sep 11, 2018)

    1.31.5

    • Add options to change the tilestats limits

    1.31.4

    • Keep tile-join from generating a tileset name longer than 255 characters

    1.31.3

    • Fix the missing filename in JSON parsing warning messages

    1.31.2

    • Don't accept anything inside another JSON object's properties as a feature or geometry of its own.

    1.31.1

    • Add --exclude-all to tile-join
    Source code(tar.gz)
    Source code(zip)
  • 1.31.0(Aug 6, 2018)

    1.31.0

    • Upgrade Wagyu to version 0.4.3

    1.30.6

    • Take cluster distance into account when guessing a maxzoom

    1.30.4

    • Features within the z0 tile buffer of the antimeridian (not only those that cross it) are duplicated on both sides.
    Source code(tar.gz)
    Source code(zip)
  • 1.30.3(Jul 30, 2018)

  • 1.30.1(Jul 20, 2018)

    1.30.1

    • Ensure that per-feature minzoom and maxzoom are integers
    • Report compression errors in tippecanoe-decode
    • Add the ability to specify the file format with -L{"format":"…"}
    • Add an option to treat empty CSV columns as nulls, not empty strings
    Source code(tar.gz)
    Source code(zip)
  • 1.30.0(Jun 19, 2018)

    1.30.0

    • Add a filter extension to allow filtering individual attributes

    1.29.3

    • Include a generator field in tileset metadata with the Tippecanoe version

    1.29.2

    • Be careful to remove null attributes from prefilter/postfilter output

    1.29.1

    • Add --use-source-polygon-winding and --reverse-source-polygon-winding
    Source code(tar.gz)
    Source code(zip)
  • 1.29.0(May 24, 2018)

    1.29.0

    • Add the option to specify layer file, name, and description as JSON
    • Add the option to specify the description for attributes in the tileset metadata
    • In CSV input, a trailing comma now counts as a trailing empty field
    • In tippecanoe-json-tool, an empty CSV field is now an empty string, not null (for consistency with tile-join)

    1.28.1

    • Explicitly check for infinite and not-a-number input coordinates
    Source code(tar.gz)
    Source code(zip)
  • 1.28.0(May 14, 2018)

    1.28.0

    • Directly support gzipped GeoJSON as input files

    1.27.16

    • Fix thread safety issues related to the out-of-disk-space checker

    1.27.15

    • --extend-zooms-if-still-dropping now also extends zooms if features are dropped by --force-feature-limit
    Source code(tar.gz)
    Source code(zip)
  • 1.27.14(Apr 20, 2018)

  • 1.27.13(Apr 16, 2018)

    1.27.13

    • Allow filtering features by zoom level in conditional expressions
    • Lines in CSV input with empty geometry columns will be ignored

    1.27.12

    • Check integrity of sqlite3 file before decoding or tile-joining

    1.27.11

    • Always include tile and layer in tippecanoe-decode, fixing corrupt JSON.
    • Clean up writing of JSON in general.

    1.27.10

    • Add --progress-interval setting to reduce progress indicator frequency
    Source code(tar.gz)
    Source code(zip)
  • 1.27.9(Mar 2, 2018)

  • 1.27.8(Mar 1, 2018)

    1.27.8

    • Add --accumulate-attribute to keep attributes of dropped, coalesced, or clustered features
    • Make sure numeric command line arguments are actually numbers
    • Don't coalesce features whose non-string-pool attributes don't match
    Source code(tar.gz)
    Source code(zip)
  • 1.27.7(Feb 12, 2018)

    1.27.7

    • Add an option to produce only a single tile
    • Retain non-ASCII characters in layernames generated from filenames
    • Remember to close input files after reading them
    • Add --coalesce-fraction-as-needed and --coalesce-densest-as-needed
    • Report distances in both feet and meters
    Source code(tar.gz)
    Source code(zip)
  • 1.27.6(Jan 19, 2018)

    1.27.6

    • Fix opportunities for integer overflow and out-of-bounds references

    1.27.5

    • Add --cluster-densest-as-needed to cluster features
    • Add --maximum-tile-features to set the maximum number of features in a tile

    1.27.4

    • Support CSV point input
    • Don't coalesce features that have different IDs but are otherwise identical
    • Remove the 700-point limit on coalesced features, since polygon merging is no longer a performance problem

    1.27.3

    • Clean up duplicated code for reading tiles from a directory

    1.27.2

    • Tippecanoe-decode can decode directories of tiles, not just mbtiles
    • The --allow-existing option works on directories of tiles
    • Trim .geojson, not just .json, when making layer names from filenames
    Source code(tar.gz)
    Source code(zip)
  • 1.27.1(Nov 23, 2017)

    1.27.1

    • Fix a potential null pointer when parsing GeoJSON with bare geometries
    • Fix a bug that could cause the wrong features to be coalesced when input was parsed in parallel
    Source code(tar.gz)
    Source code(zip)
  • 1.27.0(Nov 21, 2017)

    1.27.0

    • Add tippecanoe-json-tool for sorting and joining GeoJSON files
    • Fix problem where --detect-shared-borders could simplify polygons away
    • Attach --coalesce-smallest-as-needed leftovers to the last feature, not the first
    • Fix overflow when iterating through 0-length lists backwards

    1.26.7

    • Add an option to quiet the progress indicator but not warnings
    • Enable more compiler warnings and fix related problems

    1.26.6

    • Be more careful about checking for overflow when parsing numbers

    1.26.5

    • Support UTF-16 surrogate pairs in JSON strings
    • Support arbitrarily long lines in CSV files.
    • Treat CSV fields as numbers only if they follow JSON number syntax

    1.26.4

    • Array bounds bug fix in binary to decimal conversion library
    Source code(tar.gz)
    Source code(zip)
  • 1.26.3(Oct 31, 2017)

    1.26.3

    • Guard against impossible coordinates when decoding tilesets

    1.26.2

    • Make sure to encode tile-joined integers as ints, not doubles

    1.26.1

    • Add tile-join option to rename layers
    Source code(tar.gz)
    Source code(zip)
  • 1.26.0(Oct 13, 2017)

    1.26.0

    Fix error when parsing attributes with empty-string keys

    1.25.0

    • Add --coalesce-smallest-as-needed strategy for reducing tile sizes
    • Add --stats option to tipppecanoe-decode
    Source code(tar.gz)
    Source code(zip)
  • 1.24.1(Sep 8, 2017)

  • 1.24.0(Sep 6, 2017)

Owner
Mapbox
Mapbox is the location data platform for mobile and web applications. We're changing the way people move around cities and explore our world.
Mapbox
Interactive, thoroughly customizable maps in native Android, iOS, macOS, Node.js, and Qt applications, powered by vector tiles and OpenGL

Mapbox GL Native A C++ library that powers customizable vector maps in native applications on multiple platforms by taking stylesheets that conform to

Mapbox 4.1k Nov 27, 2021
Mapnik implemention of Mapbox Vector Tile specification

mapnik-vector-tile A Mapnik implemention of Mapbox Vector Tile specification. Provides C++ headers that support rendering geodata into vector tiles an

Mapbox 524 Nov 24, 2021
experimental project to create PBF vector tiles

Vector tiles producer This is an experimental project to create vector tiles. What does this do? This creates vector tiles based on the mapnik proto f

vross 31 Nov 2, 2021
The PULP Ara is a 64-bit Vector Unit, compatible with the RISC-V Vector Extension Version 0.9, working as a coprocessor to CORE-V's CVA6 core

Ara Ara is a vector unit working as a coprocessor for the CVA6 core. It supports the RISC-V Vector Extension, version 0.9. Dependencies Check DEPENDEN

null 78 Nov 14, 2021
Earth observation data cubes from GDAL image collections

gdalcubes - Earth observation data cubes from GDAL image collections gdalcubes is a library to represent collections of Earth Observation (EO) images

Marius Appel 67 Nov 23, 2021
Collections of AndLua modding related projects

AndLua Modding Projects Just my collections of AndLua modding related projects. Sorry, if I become file hoarder now, I collect everything but never us

null 6 Sep 12, 2021
A library of type safe sets over fixed size collections of types or values, including methods for accessing, modifying, visiting and iterating over those.

cpp_enum_set A library of type safe sets over fixed size collections of types or values, including methods for accessing, modifying, visiting and iter

Carl Dehlin 22 Nov 26, 2021
Free osu tool used to download beatmap collections from osucollector.com

osu collector free edition. created in c++. Background Osu collector is a paid service used to download packages of organized osu beatmaps called "col

EternalRift 2 Nov 27, 2021
VexCL is a C++ vector expression template library for OpenCL/CUDA/OpenMP

VexCL VexCL is a vector expression template library for OpenCL/CUDA. It has been created for ease of GPGPU development with C++. VexCL strives to redu

Denis Demidov 648 Nov 21, 2021
2D Vector Graphics Engine Powered by a JIT Compiler

Blend2D 2D Vector Graphics Powered by a JIT Compiler. Official Home Page (blend2d.com) Official Repository (blend2d/blend2d) Public Chat Channel Zlib

Blend2D 959 Nov 24, 2021
Antialiased 2D vector drawing library on top of OpenGL for UI and visualizations.

This project is not actively maintained. NanoVG NanoVG is small antialiased vector graphics rendering library for OpenGL. It has lean API modeled afte

Mikko Mononen 4.2k Dec 4, 2021
libsvm websitelibsvm - A simple, easy-to-use, efficient library for Support Vector Machines. [BSD-3-Clause] website

Libsvm is a simple, easy-to-use, and efficient software for SVM classification and regression. It solves C-SVM classification, nu-SVM classification,

Chih-Jen Lin 4.1k Dec 7, 2021
linalg.h is a single header, public domain, short vector math library for C++

linalg.h linalg.h is a single header, public domain, short vector math library for C++. It is inspired by the syntax of popular shading and compute la

Sterling Orsten 686 Nov 26, 2021
SIMD Vector Classes for C++

You may be interested in switching to std-simd. Features present in Vc 1.4 and not present in std-simd will eventually turn into Vc 2.0, which then de

null 1.1k Dec 6, 2021
An implementation of a weak handle interface to a packed vector in C++

Experimental handle container in C++ Overview Following on from c-handle-container, this library builds on the same ideas but supports a dynamic numbe

Tom Hulton-Harrop 12 Apr 25, 2021
Interactive, thoroughly customizable maps in native Android, iOS, macOS, Node.js, and Qt applications, powered by vector tiles and OpenGL

Mapbox GL Native A C++ library that powers customizable vector maps in native applications on multiple platforms by taking stylesheets that conform to

Mapbox 4.1k Nov 27, 2021
Mapnik implemention of Mapbox Vector Tile specification

mapnik-vector-tile A Mapnik implemention of Mapbox Vector Tile specification. Provides C++ headers that support rendering geodata into vector tiles an

Mapbox 524 Nov 24, 2021
experimental project to create PBF vector tiles

Vector tiles producer This is an experimental project to create vector tiles. What does this do? This creates vector tiles based on the mapnik proto f

vross 31 Nov 2, 2021
Open-source vector similarity search for Postgres

Open-source vector similarity search for Postgres

Andrew Kane 428 Nov 28, 2021
Benchmarking a trivial replacement for std::vector

std::vector replacement benchmark Dependencies You'll need gnuplot and bash to run ./bench.sh. In addition to that, you'll need to have gcc and clang

Dale Weiler 6 Aug 6, 2021
Support Vector Machines Implementation from scratch in C++

SVM C++ Samples These are sample programs of Support Vector Machines from scratch in C++. 1. Implementation Model Class Problem Decision Boundary Code

null 4 Nov 17, 2021
Public repository for rolling release of main Vector robot code repository.

vector Public repository for rolling release of main Vector robot code repository. This rolling release will be worked to completion until all non-thi

Digital Dream Labs 40 Nov 24, 2021
static_vector implementation in terms of std::vector. No need to implement each function again and again ;)

static_vector static_vector implementation in terms of std::vector. No need to implement each function again and again ;) The usage is basically the s

Alex 3 Oct 26, 2021
A wrapper for intel SSE/AVX vector instructions

VMath A wrapper for intel SSE/AVX vector instructions This is just a toy thing to figure out what working with intrinsics is like. I tried to keep it

Dennis 6 Nov 25, 2021
A wrapper of C++ std::vector for functional programming

Say hello to functional C++ vectors A wrapper for C++ std::vector geared towards functional programming and fluent APIs. The primary focus is readabil

null 16 Nov 10, 2021
A non-backtracking NFA/DFA-based Perl-compatible regex engine matching on large data streams

Name libsregex - A non-backtracking NFA/DFA-based Perl-compatible regex engine library for matching on large data streams Table of Contents Name Statu

OpenResty 575 Nov 23, 2021
C++ library for solving large sparse linear systems with algebraic multigrid method

AMGCL AMGCL is a header-only C++ library for solving large sparse linear systems with algebraic multigrid (AMG) method. AMG is one of the most effecti

Denis Demidov 453 Dec 1, 2021
Simple constant key/value storage library, for read-heavy systems with infrequent large bulk inserts.

Sparkey is a simple constant key/value storage library. It is mostly suited for read heavy systems with infrequent large bulk inserts. It includes bot

Spotify 952 Nov 29, 2021
A C++11 large integer library with effective high performance, simplistic in nature and also clean in the eyes.

BigIntegerCPP BigIntegerCPP is a C++11 port of large integer library used in CryptoLib4Pascal. It allows mostly parsing of numbers as strings in diffe

Telepati 21 Nov 26, 2021