CartoType can be used to display maps created from Mapbox vector tiles, allowing you to display a map of the whole world down to street level with routing and geocoding.
How to open a map using Mapbox data
First you'll need a Mapbox account. Then you need to create an access token. Using your access token, you can open a Mapbox map of the world in almost the same way as opening a CartoType map file (a .CTM1 file). Instead of the filename, you supply the Mapbox vector tile URL:
https://api.mapbox.com/v4/mapbox.mapbox-streets-v8
and set the Key parameter in the CartoType framework parameter object to your access key.
You will need internet access for this system to work, because it downloads map data from the Mapbox server.
Mapbox data works on the following CartoType platforms: Windows, .NET, Android, Linux, iOS and macOS.
Details
Styling: Mapbox data is converted automatically into layers that work properly with the standard CartoType style sheet. You do not need to create a different style sheet to use Mapbox data.
Route calculation: The Mapbox routing system supplies four built-in profiles: Driving-Traffic, Driving, Walking and Cycling. The difference between the first two is that Driving-Traffic takes account of current traffic conditions. These profiles are supplied in the normal way by the BuiltInProfile and BuiltinProfileCount functions of the CartoType Framework class.
Address searching: If you supply at least a street name, address searching uses the Mapbox forward geocoding system.
Converting a point to an address (reverse geocoding): CartoType's GetAddress function, taking a geographical point, uses the Mapbox reverse geocoding system to convert it to an address.
Temporary and permanent geocoding: compliance with Mapbox terms of service
If you use address searching or conversion of a point to an address you must comply with the Mapbox terms of service. In particular, if you intend to cache the results or store them permanently you must call CartoType's Framework::SetProviderParam function (or Framework.setProviderParam, etc., according to the SDK) in this way:
SetProviderParam("mapbox/geocoding/permanent","true")
ensuring that the "permanent=true" parameter is set in the URL passed to the Mapbox server.
See the Mapbox geoding documentation, which includes the following statement: "Using Permanent storage with the Geocoding API requires that you have a valid credit card on file or an active enterprise contract."
This applies to calling the following CartoType functions:
C++:
Framework::FindAddress
Framework::FindAddressAsync
Framework::GetGeoCodeSummary (taking a geographic point)
Framework::GetAddress (taking a geographic point)
.NET
Framework.FindAddress
Framework.FindAddressAsync
Framework.GeoCodeSummary (taking a geographic point)
Framework.GetAddress (taking a geographic point)
Android
Framework.findAddress
Framework.findAddressAsync
Framework.geoCodeSummary (taking a geographic point)
Framework.getAddress
iOS
CartoTypeFramework.find: maxItems: address: fuzzy:
CartoTypeFramework.findAddressAsync
CartoTypeFramework.geoCodeSummary
CartoTypeFramework.getAddress: point: coordType:
CartoType GL is the graphics-accelerated version of CartoType. It gives you a smooth, fast, fluid user experience, with no delays when panning or zooming the map.
At present, in CartoType 8.4, online data is supported by using CartoType to serve bitmap tiles, which can then be drawn by any standard slippy-map system.
The next release, scheduled for summer 2023, includes more flexible support for online data on any platform. The new system is called CartoType Online
How CartoType Online works
A CartoType app opens a map, supplying a URL instead of a file name, for example, https://www.example.com/maps/germany.ctm1, and everything works as usual. The server supplies vector tiles and handles searches and routing requests. Mobile applications benefit by not needing to store large maps locally.
There are some advantages over serving bitmap tiles:
- The map can be in any projection. Bitmap tiles usually require a Web Mercator projection.
- You can use any style sheet, or change the style at run-time. Bitmap tiles are always in a fixed style.
- When you rotate the map, labels remain horizontal.
- The server uses much less disk space than a typical tile server. No tile cache is required.
- You can add data to the map at run-time, or combine the map with local data such as pushpins or annotations.
The client is an ordinary CartoType app on any platform. The server application is an executable that is run by the main server program, such as Apache, NGINX, or Windows IIS, via the FastCGI protocol. Stand-alone server systems can also be provided.
Please contact us for more information.
Nvidia's Jetson embedded computing boards can run CartoType, with full support for hardware-accelerated graphics. We do not build the CartoType SDK for Jetson as part of our regular release process, so if you need an evaluation CartoType SDK for Jetson please contact us and we'll send it to you. It's a standard Linux SDK built for the Jetson architecture.
You'll need to install the Mesa libraries to support the OpenGL ES 2.0 graphics system:
sudo apt-get install mesa-dev
sudo apt-get install mesa-utils-extra
sudo apt-get install libgles2-mesa-dev
If you want to run the demonstration program you'll also need to install the Code::Blocks IDE and the GLFW library:
sudo apt-get install codeblocks
sudo apt-get install libglfw3-dev
... then load the project file unix_gl_demo.cbp into Code::Blocks, and change the libraries in the Linker Settings section of the CodeBlocks build options to
../../../../../../../usr/lib/aarch64-linux-gnu/libglfw.so ../../../../../../../usr/lib/aarch64-linux-gnu/libGLESv2.so
The mapinfo tool allows you to analyse the structure and content of CartoType maps (CTM1 files), search them for specified map objects, and get the total area or length of a group of map objects. For example, you can get the total length of all roads, list the layers in the map, or find out what type of routing data is stored.
Download mapinfo:
mapinfo for Windows
mapinfo for 64-bit Linux
mapinfo for mac OS
To uninstall mapinfo just delete the executable.
By using the CartoType mapinfo tool (mapinfo.exe, mapinfo_mac, mapinfo_linux, ctm1_info.exe, etc., or any other variant, not necessarily having one of the names listed here), however acquired, you accept the terms of the CartoType Evaluation License and you also accept that neither CartoType Ltd, nor any owners, shareholders or officers of CartoType Ltd, or any other contributors to, authors of or maintainers of the CartoType system, are liable for any damage, direct or consequential, caused by downloading, installing or using the mapinfo tool, and that the mapinfo tool is not warranted fit for any particular use and may not be used for any commercial purpose without the purchase of a CartoType license.
Find out how to create CartoType maps here.
This release was made on 15th September 2020 and is based on mainline revision 9241.
The previous release, 6.0, was made on 6th July 2020 and was based on mainline revision 9085.
Summary
Note: these changes were made between release 6.0 and release 6.2. Some of them were merged into release 6.2.
Improvements to the TECH router. The TECH (turn-expanded contraction hierarchy) router, which you can use via the makemap command line option '/route=tech', now incurs much lower peak RAM use in makemap when the data is being created.
General router improvements. Turn costs and instructions and junction information are now consistent over all router types apart from the CH router, which does not support turn costs. A-star routing is now faster, and is as fast for vehicle types containing maximum weights or other dimensions as for those without. However, as explained below, A-star routing is now deprecated: use /route=t instead of /route=a or /route=yes, which is the same thing.
Deprecation of non-turn-expanded routers. The two recommended router types are now /route=t: turn-expanded A-star, supporting flexible routing profiles at runtime; and /route=tech: turn-expanded contraction hierarchy, for lower RAM use and very fast routing at the cost of larger CTM1 files and a fixed set of routing profiles decided at map creation time. The other types of router data (/route=a and /route=ch) are still however supported and can be created by makemap and used by the CartoType library. The reasons for their deprecation are that neither of them can create correct routes in certain circumstances involving complex junctions, and that the CH router does not support turn costs. This deprecation policy means that there will be no further development effort for the deprecated routing systems.
New containment and intersection functions for map objects. There are now functions to determine the way a path, represented by a Geometry object, intersects with a map object or list of map objects. Intersection and containment are distinguished, and in the case of non-intersection the distance and closest points are found.
Maps can now straddle the antimeridian. Countries like Russia, the USA and Fiji have territories on both sides of the antimeridian at 180 degrees West or East. To create maps straddling the antimeridian use longitude values greater than 180 for the eastern edge, and use an appropriate projection (e.g., Lambert Azimuthal Equidistant for Fiji: /project=laea, or Albers Equal Area for Russia; see https://spatialreference.org/ref/sr-org/8568/).
Most out-of-memory exceptions are now trapped. The operations of routing, loading a map, and finding large numbers of map objects are now performed inside try...catch constructs so that out-of-memory conditions are reported as error codes rather than causing program termination. This is principally relevant to mobile platforms (iOS and Android) but happens on all platforms.
Selected other changes and fixes
fixed case 2694: TECH router doesn't handle changes to the traffic light time correctly; logic for deciding whether a turn was cross-traffic was wrong
implemented case 2664: makemap should write the CartoType version used to build the CTM1 file
fixed case 2704: One way restriction not being followed
implemented case 2688: makemap should use information in GeoTIFF files in preference to world files
fixed case 3717: TileBitmap doesn't support night mode
fixed case 3718: wrong route time on tech map
fixed case 3719: wrong route calculated with tech maps; only the first positive turn restriction was handled by FixRestrictions, so second and subsequent positive restrictions were ignored
fixed case 3715: high RAM use when zoomed out in a very large map
fixed case 3722: extra turns in cycling route
fixed flickering when drawing labels using latest Qt 5.15; supplement to case 2626: display flickers in web assembly
fixed case 3725: route geometry is incomplete
fixed case 3735: a-star router adds five minute delay at end of route
prevented a long sequence of deprecated roads (speed plus bonus = 0) from being used
fixed case 3738: memory map database ignores condition when deleting entire range of object IDs
made admin areas relevant when searching for localities and sub-localities in FindAddress: fixed case 3733: Diemelstadt not found; Diemelstadt is a municipality, which becomes TGeoCodeType::AdminArea8
fixed case 3729: FindAddress doesn't merge streets properly
fixed case 3740: FindAddress sets a very large margin around cities
the windows demo and the maps app now create a non-overlapping envelope for found linear objects
the maps app didn't enable 'find next' for address finding
fixed case 3741: FindAddress doesn't find roads by reference
fixed case 3732: CreateRoute crashes with coordinate outside the map
fixed case 3730: FindAddress can't find Frankfurt (Oder); space is now used as a separator when matching tokens in a name
fixed case 1963: make nearby object warnings work even when not navigating
implemented case 3708: add option to maps app to use shift-left-click to simulate a location fix
maps app now shows the current navigation state when simulating a route
fixed case 2667: loading a custom route profile in maps app when custom routing is selected doesn't change the route
fixed case 3742: some graticule lines are not displayed when graphics acceleration is on
fixed case 3744: LoadIcon doesn't work when TileBitmap is used
This release was made on 6th July 2020 and is based on mainline revision 9085. It includes support for Web Assembly, faster and lower-memory map creation, and faster routing.
The previous release, 5.12, was made on 25th March 2020 and is based on mainline revision 8838.
CartoType is now available as a web assembly library in the desktop version of the Chrome browser. There's a simple demonstration here. It enables you to provide CartoType mapping and routing capabilities to your users in a browser window without asking them to install anything.
The web assembly version of CartoType is full-featured and contains everything that the other versions have on Windows, iOS, Android, and Linux.
This release was made on 25th March 2020 and is based on mainline revision 8838.
The previous release, 5.10, was made on 15th October 2019 and was based on mainline revision 8479.
Sometimes you need the power of a full programming language when importing data. For example, you might need to load an ESRI shapefile, read records with a matching key in an associated DBF file, and loop through the records. The ChaiScript language, which can be used anywhere suitable in a CartoType makemap file inside the element <script> ... </script>, allows you to do that. It's very similar to C++, with some differences (e.g., 'int x = 0' in C++ becomes 'auto x = int(0)' in ChaiScript; there are no postincrement or postdecrement operators; etc.). This article explains the functions added to ChaiScript to make data import possible. General notes on the ChaiScript language are found on another page.
This document describes ChaiScript, an open-source (BSD license) scripting language invented by Jason Turner. It was written by examining the ChaiScript source code and searching the internet for examples and explanations. Any inaccuracies are the fault of the author.
This release was made on 15th October 2019 and is based on mainline revision 8479.
The previous release, 5.8, was made on 26th April 2019, based on mainline revision 8175.
This release on 26th April 2019 is based on mainline revision 8175.
Previous release 5.6 on 11th February 2019 was based on mainline revision 7972.
Release date: 12th February 2019
Previous release: 5.4, 23rd October 2018
General
Isochrones (travel ranges) now work for the turn-expanded router
Turn-expanded router data can now be stored in serialized form, for fast loading, in CTM1 (map) files
Address data can be added to map objects at data preparation time for use by a new function, GetAddressFast, which uses data only from the map object for which an address is required
Release date: 23rd October 2018
Previous release: 5.2, 12th July 2018
Summary of changes
SetScaleBar, SetLegend, SetCopyright and other new functions allow scale bars, legends (map keys) and copyright notices to be added to the map easily, and to be displayed properly when using hardware graphics acceleration.
Boxed labels for point objects can now optionally have small triangular pointers which indicate the exact position of the point object.
It's possible to use the makemap tool to create very large CartoType maps (CTM1 files), up to and including a map of the whole world using the full OpenStreetMap data file planet.osm. The easiest and fastest way is to use lots of RAM.
CartoType's graphics acceleration system gives you a smooth, fast, fluid user experience, with no delays when panning or zooming the map. Drawing speeds of up to 30 frames per second are supported.
This document explains the CartoTypeRouteProfile XML format, used in .ctprofile files. These files are used to store route profiles, which are used to customize the behavior of the route calculation system. For example, it's possible to make some types of roads more or less preferable than others, or to forbid them entirely, and to set the type of vehicle, for instance to a car, heavy goods vehicle or bicycle.
Here are answers to some questions frequently asked about CartoType.
CartoType uses a standard set of map layers and attributes. These are used by the import rules built into makemap, and by the standard style sheet. You can override them completely by using your own import rules and style sheets, but it is better to use the standard set, adding new layers and attributes where needed, or omitting unnecessary ones. The reason for using the standard set is that they used by the address searching system. In general, attributes and layers are described according to how they are imported from OpenStreetMap data.
