This is a static dump of all contents for this site, made for search engines that does not support javascript/ajax (which is pretty much all of them).

This page should not be visible to normal users, but if you who read this is not a crawler-bot, please go to Xtreme Route instead.


Complicated?
Don't worry!

A high performance .NET library for route planning, optimized to handle the most complicated problems with exceptional performance!

The Xtreme Route library fits in most development scenarios, including web, desktop, Silverlight, service based and more.

Professional
presentations!

Create accurate visualizations of drive range isochrones for professional presentations, or for well informed decision making!

Speed is of the essence!

100000 random routes on different networks
Benchmarks England Glasgow Napoli Stockholm
Network size 2670709 nodes 209835 nodes 355963 nodes 53112 nodes
Average travel time 03:16:45 01:14:19 00:59:05 00:23:01
Millisecond/route 22.1 ms 2.05 ms 4.63 ms 0.51 ms
The C# code for this benchmark can be viewed here. For more beanchmarks, go here!

Stay away from
roadblocks!

Avoid routing software that sends you into roadblocks. By keeping all data live the Xtreme Route library provides up-to-date results, as well as removing the need for any preprocessing.

create road

Introduction

The Xtreme Route library is a software library that contains functionality for route planning, isochrones and fleet routing. It also contains support functionality for routing (networks, nodes, links, paths, subnets, etc.) as well as extensive support for calculations in parallel.

The library is developed in Microsoft. NET using C#, and targets .NET developers in need of powerful routing functionality. It's a high-level object oriented library, very easy to use and understand, yet powerful enough to solve very advanced routing problems.

The focus during development of the Xtreme Route library has been performance and precision, which has resulted in very fast and accurate methods for many different routing scenarios. Floating-point numbers are represented with double precision and all methods and classes that perform route calculations are multithreaded.

The Xtreme Route library can be used in desktop applications, on web servers, as a service or in Silverlight applications (both in the client and on a server), and the support for multithreading makes it ideal for many server solutions. Its able to use many networks simultaneously, and can execute route calculations in parallel, both within the calculation and between different calculations. This is all handled within the library, so no extra development is needed.

Blue checkmark

Route planning

Route planning (also called point-to-point routing) is the process to calculate an optional route between 2 points, sometimes including VIA points that should be passed by the route. Once the route is calculated, a route description is typically presented that tells the user exactly how to drive to follow the route.

The Xtreme Route library contains very high performance methods for route planning, including advanced features like distance matrixes, one-to-many routes, routes with unknown endpoints etc. A more technical description of route planning in the Xtreme Route library can be read here.

Green checkmark

Isochrones

An isochrone is computed around one or more center points, and shows at each point it covers the cost from that position to the center point that gives the lowest cost. For example, when distance is used as cost each point in the isochrone will have the same value as a route over distance to the closest center node.

The Xtreme Route library contains functionality for generating isochrones, as well as for performing interpolation on them and generating a raw bitmap that can be displayed on screen or included in reports. A technical description of isochrones in the Xtreme Route library can be read here.

Peech checkmark

Fleet routing

A fleet route (also called Vehicle Routing Problem) is similar to a point-to-point route with VIA points, but with one important difference: every point visited had a load, and each vehicle has a maximum capacity, so one vehicle might not be enough to visit all VIA points. This means that several vehicles are usually needed, which adds a lot of complexity to the route calculations.

The Xtreme Route library contains functionality for solving fleet routes, with several configurable parameters. Since these problems are so complex there are several known problems that do not have a known optimal solution, only a "best found so far". On those, the Xtreme Route library holds the best known solution for all such problems that it has run on (see benchmarks for a couple of examples).

A technical description of fleet routing in the Xtreme Route library can be read here.

Orange checkmark

Extra functionality

In order for functionality like route planning and fleet routing to work, a representation of a network with nodes and links has to be available, as well as additional extra functionality for various tasks. Xtreme Route contains a very comprehensive suite of classes and methods for networks, links, nodes and more. A technical description of some of them can be read here

Red checkmark

Demo application

The demo application is a simple routing application that demonstrates some of the functionality in the Xtreme Route library. It is free to download and test for everyone, just download, install and run.

Route planning

The Xtreme Route library contains a lot of functionality for route planning. Below is a technical description of some of that functionality.

Point to point routing

VIA route

Point-to-point routing (also called PtoP) is the most common type of routing. Some of the use cases for PtoP routing are: package delivery, taxi, mail delivery, emergency vehicle routing, school busses, tourist trip planner, etc. The Xtreme Route library can also be used for non-road networks like TCP/IP network routing.

The picture to the right shows a round-trip route with 200 VIA points in south England. As with most calculations in Xtreme Route library, its fully multithreaded.

Summary:

  • High performance point to point routing, based on distance, time or a third generic cost (can be used when distance and time is not sufficient).
  • Comprehensive result that includes everything needed, including optional user supplied data if available.
  • Turn restrictions can be used to stop a left or right turn (or even going straight ahead) at an intersection. This is typically specified when importing a network.
  • VIA point optimization (also called TSP). 3 different variations is handled:
    • Round-trip: the route starts and stops at the same point.
    • Start to Stop: the route starts at one point and stops at another.
    • Start to unknown: the library calculates the optimal stop point from the available VIA points.
  • Efficient calculation of distance matrices and multi routes.

Dynamic routing

Dynamic routing adds a lot of power to route planning, and enables the calling application to make changes that affect the route calculations without changing the underlying network data. Typical scenarios where dynamic routing is usable are changes in real world conditions like traffic stocking, roadblocks, weather conditions, flooding, etc., but also routing with different types of vehicle on different types of roads falls into this category:

  • Up to 32 Boolean flags can be assigned to nodes and links, and each flag can be assigned an additional cost (either multiplicative or additive) before route calculations, without any changes to the underlying network. For example, reduce speed on smaller roads during bad weather.
  • Dynamic routing can also be used to disable links and nodes based on assigned class without actually altering the network. This provides a way to force the route to stay away from certain areas or different types of roads. For example, smaller roads can be disabled for heavy vehicles, and roads that only allow certain types of vehicles like busses and taxis can easily be made unavailable for other vehicles. This also makes it possible to have only one network for all types of roads, including roads only available for pedestrians and bicycles.
  • The calling application can provide its own cost method to modify or replace the result from the included cost method. For example, if the calling application has information about traffic stockings, it can modify the computed cost for those roads to make the route calculations stay away from roads with traffic stockings, or increase the cost to including them in the route.
  • The brute force approach is also possible but usually not needed, and it's quite simple due to the storages undo functionality: change road data in storage, calculate route(s) and rollback changes. See section about Storage for more information.

Fleet routing

The Xtreme Route library contains functionality for solving fleet routes in a few seconds, and can handle up to a few hundred VIA points with unlimited number of vehicles.

See performance for benchmarking and accuracy where a number of problems is solved, all with known solutions so accuracy can be measured.

Fleet route

The picture to the right shows a fleet route in the Glasgow/Edinburgh area, involving 3 vehicles and 28 VIA points. Each vehicle has a capacity of 100 and each VIA point has a load of 10, which means that one vehicle can at most pass 10 VIA points.

This picture, as well as many more, can be seen in full resolution on the gallery page. The pictures in the gallery also contains information about the result and execution, for example how long time the calculation took and how much memory was used.

Real world scenarios

As with point-to-point routing there are a lot of use cases for fleet routes, some of them are:

  • Package delivery involving many or a fixed number of vehicles (if only 1 vehicle, the problem becomes a point-to-point route with VIA points).
  • Transport of students to and from school.
  • Mail delivery.
  • Timber transportation.
  • Waste management.

Configurations

Settings

When calculating a fleet route, several configurable parameters can be used to modify the result:

  • Vehicle capacity: this is the maximum capacity for each vehicle.
  • VIA point load: this is the load (or size) that each VIA point requires from the vehicle. This value can be set individually for each VIA point.
  • Depot: this is the start and/or stop, depending on route type, for each vehicle.
  • Route type: the type of route for each vehicle, can be round-trip, inbound and outbound.
    • Round-trip: each route for a vehicle starts and stops and the depot.
    • Inbound: each vehicle starts at an unknown VIA point, and stops at the depot.
    • Outbound: each vehicle starts at the depot and stops at an unknown VIA point.
  • Optional: fixed number of vehicles, if this is set, the number of vehicles will never be lower than the assigned value (it can be higher though, in case no fleet route exists that can satisfy the requirement).
  • Optional: max single route cost, if set, no route for a vehicle is allowed to exceed the cost value set. Note that this cost is the route-cost, usually time or distance, and not the vehicle capacity.

These configurations are available to test and experiment with in the demo application.

Extra functionality

To make route planning, isochrones and fleet routing possible, several support classes are needed. Some of these are described below.

Note: these are technical descriptions, suited for software developers. Some GIS knowledge is also needed.

Storage

Discdrive

The storage is the container for all network related data like nodes, links, speeds, costs, etc. Its a very high performance class that contains everything needed to store and manipulate a network, including methods to load and save a network to disk or some other media (the load and save methods takes either a filename or a stream as argument).

The storage contains many optional types of data, and if no node/link contains any data of that type no memory is allocated (not even null references).

The storage can also work with undo capabilities (off by default). When undo is turned on, every change except load, save and packing can be undone up to the point where undo was turned on. This makes the storage very well suited for application with network editing, and also enables changes to be done for just one or a few routes.

Summary:

  • Contains a comprehensive suit of methods for manipulation of network data like nodes, links, costs, names, speed, states, generic data, etc.
  • All data can be saved to one or more files or to a streams.
  • Most of the data handled is optional, like link and road names, speeds, link and road classes and more.
  • Space efficient, nothing is allocated (not even null pointers) for unused optional data. Strings are only stored once for each unique string.
  • Very high performance (see performance for benchmarking.)
  • Allows unlimited undo up to the point the undo functionality was turned on.
  • Generic data can be attached to nodes and/or links. When saving, generic data will either be saved with .NET serializer or by method provided by calling application.
  • Automatic validation makes it impossible to create inconsistence in the network.
  • Some classes in Xtreme Route library uses the Storage internally, but provide higher level methods that are more object oriented. The most important ones are the Node and Link class. These classes are optional to use, and sacrifices a little performance for usability.

Coordinates & Projections

Two types of coordinates are supported: X/Y on a flat projection, and latitude & longitude typically used for world projections like WGS 84. The actual projection (if any) for the network does not matter, as long as the coordinates are either based on some metric like meter, yard, etc., or the coordinates are latitude & longitude.

Coordinates, as well as distance calculations, angles, drive and map directions and more is handled by the Metric class, and when latitude and longitude is used, distance calculations can be done in 4 accuracy modes:

  • Quick: extremely quick calculation, but only accurate on maps with a few degrees size or less.
  • Good: uses the haversine function to calculate distances with an error of up to around 0.5%.
  • Accurate: uses an advanced iterative length calculation that, based on WGS 84 sphere, gives accuracy's of around 0.1 meter.
  • Optimized: uses one of the above depending on map size, coordinate distances, etc. This is the default, and typically gives small errors with a very high performance.

The type of coordinate, as well as any relations between X and Y, is specified when importing a network from a file (see section Importing a network below).

Summary:

  • Supports flat projections (including ones with different X and Y scale).
  • Supports Latitude & Longitude coordinates and projections, for example WGS 84. Distances between 2 coordinates in Latitude & Longitude can be calculated with very high precision.
  • The popular visualization projection is also supported, used by Google, Bing, OpenStreetMap and more, see EPSG:3857.

Spatial Index

Quadtree

To speed up searches for nodes and links from a coordinate or area, the Xtreme Route library contains a spatial index. Its an highly effective implementation of a quadtree (see picture to the right) that provides extremely fast searching for nodes and links. Expect well over 100k node searches/second on a modern computer (see performance for benchmarking).

The spatial index is handled by the storage, so no extra code is needed to take advantage of it. All that's required is that every node has an assigned coordinate. The type of operations available in the spatial index is to search closest node or link from a coordinate, or search nodes within an extent or a circle.

Summary:

  • Very space and time efficient.
  • Efficiency of operations in spatial index depends very little on network size (O(logN)).
  • Automatically maintained by Storage class.
  • Contains methods for finding closest node or link to a coordinate, finding nodes within an extent or distance, finding closest point on a link, etc.

Subnets

If two points exist, A and B, and there is no path from A to B or from B to A, they are on different subnets (see strongly connected component). The Xtreme Route library contains methods for identifying and removing subnets, as well as determine if 2 points are on the same subnet. All subnet methods are at worst O(|N|+|L|) where N is the number of nodes and L is the number of links, which makes them very fast to use even on large network (see Big O notation for more information about algorithm complexity).

One common use case for this is to clean up faulty road data. If the network represent a land area with no islands, a simple way to clean up the network is to generate all subnets, and remove all but the largest subnet. By coloring all nodes in all subnets with colors depending on subnet, its also easy to visualize the network with its subnets.

It should be noted that there can be a route between 2 points on different subnets, but only in one direction.

Summary:

  • Identify & remove subnets.
  • Generate the subnet that a node belongs to.
  • Determine if 2 nodes are on same subnet.
  • Can be used to easily clean up a network by generating all subnets and removing the smaller ones (the networks in the demo was cleaned up this way).

Importing a network

Import data

The Import class is used to import data from an external format to the format used by the Xtreme Route library. Importing from ESRI shapefiles are supported, and the Import class is easy to extend for other formats (a DataReader interface with methods Open, Read and Close needs to be implemented). The DataReader only reads the raw data and returns it, while the Import class does all the network building.

Importing can be done on a whole network, parts of a network, or several imports can be appended and together form a complete network. Importing is fairly fast, less than 30 seconds for 1 million nodes, and once a network has been imported it can be saved to disk and loaded whenever needed (loading a network takes less than 1 second/million nodes).

No preprocessing or precomputing is needed before a network is imported, and the following can be configured when importing:

  • Types of coordinates (LatLong, meter, yard, etc.).
  • Preferred unit to report distances in.
  • If link geometry should be read, if not every link will be a straight line between its 2 end nodes.
  • Optional: attribute field to read link names from.
  • Optional: speed mapping, can either be a field with actual speed values, or a range of keys/values that maps a value to a speed. If speeds are not imported, routing over time will not be possible.
  • Optional: one-way mapping. This can either be a mapping between 2 values that represent digitized direction and against digitized direction, or a direction mapping where a road can only be travelled in one direction (for example north-east).
  • Optional: cost field, if supplied the cost of each link will be taken from this field, else the cost will be computed as the length of the link. The computed link length is calculated with the highest accuracy, and will use the link geometry even if its not imported.
  • Optional: cost modification that can rescale the cost, for example if coordinates are in kilometer but meter is wanted as cost value, the cost modification would be 1000.
  • Optional: reversed X and Y. This indicates the direction of X and Y (default is X increase to east and Y increase to north). This is needed for computing angles when using extra cost on turns, or for turn restrictions.
  • Optional: distance units per X/Y coordinate, this can be used for projections other than LatLong that does not have a metric as coordinate, or has a very inaccurate value (like popular visualization projection).
  • Optional: import extent, can be used to only import part of a network.

Isochrones

A somewhat formal definition of isochrones is that an isochrone is an isoline for travel time, that is a curve of equal travel time. For isochrones with color gradients, the isoline is the abstract line following a specific color.

ISO route

By representing an isochrone with colors, isochrones can also function as a basis for various decision making processes.

In the picture to the right, a stepwise coloring scheme has been used, which means a range of values gives the same colors, and the ranges are typically equal and not overlapping, for example 0 - 10 minutes, 10 minutes - 20 minutes, and so on.

Several more example pictures of isochrones can be seen in the screenshot section.

Like in route planning, there are a lot of use cases, some examples:

  • Find all customers within 10km from our service stations.
  • Find all school children that needs transportation to a school.
  • Determine the hotspots for emergency vehicles. Hot-spots in this case is the areas furthest away from any station with emergency vehicles.
  • Find all hotels within 1 hour drive.
  • Produce colorful visualizations for presentations and reports.
  • Compute isochrones as a preprocessing stage. After the calculation, routes can be fetched from any point in the network to the closest center point without any calculations. This can be very useful for driving directions to the closest office, service station, health care, etc.

The Xtreme Route library has functionality for computing various types of isochrones, even isochrones around a route or isochrones around a mix of routes and centers. There is also functionality for generating a bitmap (32bit ARGB) for an isochrone, which can easily be used in different graphical user interfaces (the demo shows how isochrones can be used in an application).

Summary of isochrone functionality in the Xtreme Route library:

  • Time, distance and generic cost can be used.
  • Uses the same base functionality as route planning, so any setting for dynamic routing, external costs, etc. will also apply to isochrones.
  • Comprehensive result which enables spatial searches, instant-routing to closest center, advanced coloring, etc.
  • Contains classes to transform a isochrone into a 2 dimensional cost-grid with different types of interpolation applied.
  • Can easily be colored with color ramps (see demo application).
  • Can generates results with soft gradients even on sparse data.

Demo application

The demo application works as a typical (but limited) desktop routing application, and uses the Xtreme Route library to show some of the functionality the library has to offer. Some functionality, like route descriptions, has not been included in the demo to ensure that the demo itself don't become a fully functional route application.

create road

The demo application is developed in Microsoft. NET 4.0 and uses WPF, so the .NET 4.0 client profile (or .NET 4 full install) is required to run the demo. The Xtreme Route library only requires .NET 2.0 though.

Included in the demo is 6 small to medium sized networks, and the demo is free to download for everyone: Download Xtreme Route Demo

Installing the demo

Download the demo application from the link above. Once downloaded, execute the downloaded file and follow the installation guide.

If you don't want to execute a file from internet (which is generally a good ide), you can download the .msi packages instead. Just make sure you have .NET 4 installed first.

Download the .msi packages: Xtreme Route Demo .msi

Using the demo

  • In the upper-left part is a toolbar that controls what action should be taken when user clicks with left mouse button on the map.
  • The upper-right part contains global settings like what type of route to use, network, using time or distance as cost and how many threads to use (default number of threads is same as the number of cores on the computer).
  • The middle-right part contains settings for the type of routing that is selected.
  • The lower-right part contains information about the loaded network.
  • The status bar at the bottom contains various information about the network and execution.
  • The 2 buttons in the lower-right corner is used to compute a route, and clear old results.

Please get in contact to info@xtremeroute.com for any questions about the demo.

Resized screenshot of the demo application:

demo application screenshot
PayPal

Online store

The Xtreme Route library can be ordered on this page, or by contacting sales@xtremeroute.com.

All online transactions are handled by PayPal for secure and reliable money transfer and credit card processing.

When using the Xtreme Route library for desktop applications, one full* license for each developer using the library is required, but the license is royalty free (no additional charge for customers using the product).

For server solutions, one full* license for each server is required, as well as one base license for each developer. Note that internal servers for testing and development does not require extra licenses.

* One full license is one base license (€790) + extra cores/cpus (€490 each) if applicable.

One year of free support is included in all products!

Order the Xtreme Route library

Xtreme Route library
1 base license for Xtreme Route library: €790

Support for one CPU/core is included in this license. For additional CPUs/cores, see below.

For site licensing, please contact sales@xtremeroute.com.

Support for additional CPUs/cores

CPU

Increase the number of CPUs/cores that the Xtreme Route library will use during calculations.

Support for 1 additional CPU/core: €490

For site licensing, please contact sales@xtremeroute.com.

Support contracts

1 year of free email support is provided for all orders (phone support can also be arranged if needed). After the first year, support is 15% of the total order value for each year.

Free patches and updates to the Xtreme Route library is also included in the support.

Shopping cart

The selected products, as well as options to check out and pay, can be seen in the shopping cart.

Stopwatch

Performance

In this section, some benchmarks for typical routing tasks are presented for route planning and fleet routing.

Some screenshots, taken from the xtreme route demo is also available.

A modern CPU was used for all benchmarks, Intel Core i7, running on Windows 7 64 bit OS. The benchmark computer has 8 Gb of memory, but the test themselves never take up more than 50 - 300 Mbyte (+ memory for network if applicable), and could easily be run on a computer with less memory.

As always with routing in the Xtreme Route library, preprocessing or other preparations for the network is not needed.

Route planning benchmarks

Point-to-point routing

This table shows average execution time for random point-to-point routes with time as cost on 4 different networks.

100000 random routes, optimized for shortest time
Benchmarks England Glasgow Napoli Stockholm
Network size 2670709 nodes 209835 nodes 355963 nodes 53112 nodes
Average travel time 03:15:13 01:14:39 00:58:40 00:23:11
Millisecond/route 14.9 ms 1.37 ms 3.28 ms 0.48 ms
Routes/second 67 routes/s 730 routes/s 305 routes/s 2083 routes/s
The C# code for this benchmark can be viewed here. No preprocessing was done on the networks.

This table shows average execution time for random point-to-point routes with distance as cost on 4 different networks.

100000 random routes, optimized for shortest distance
Benchmarks England Glasgow Napoli Stockholm
Network size 2670709 nodes 209835 nodes 355963 nodes 53112 nodes
Average travel time 04:06:42 01:26:27 01:10:39 00:25:41
Millisecond/route 16.4 ms 1.47 ms 2.76 ms 0.53 ms
Routes/second 61 routes/s 680 routes/s 362 routes/s 1887 routes/s
The C# code for this benchmark can be viewed here. No preprocessing was done on the networks.

This table shows average execution time for random point-to-point routes with time as cost and an additional time for left turns and right turns.

100000 random routes, optimized for shortest time and using turn costs
Benchmarks England Glasgow Napoli Stockholm
Network size 2670709 nodes 209835 nodes 355963 nodes 53112 nodes
Average travel time 03:39:16 01:20:26 01:05:23 00:27:07
Millisecond/route 37.8 ms 3.75 ms 8.60 ms 1.33 ms
Routes/second 26 routes/s 267 routes/s 116 routes/s 751 routes/s
The C# code for this benchmark can be viewed here. No preprocessing was done on the networks.

Fleet routing benchmarks

A new world record for G-n262-k25

G-n262-k25 is a famous and very complicated problem for fleet routing, and has often been used for benchmarking. According to the test case, the best value is 6119 but that result is probably several years old. A little googling discovered results in the 5650-5750 range from different software.

When running this problem on the fleet router in the Xtreme Route library, using 4 threads (source code here), the following results where achieved:

  • 10 seconds: result 5604
  • 60 seconds: result 5575
  • 30 minutes: result 5553
  • 60 minutes: result 5543

The detailed result, with all the routes and nodes, can be found here. A picture of the solution is availale to the right.

Yet another world record, this time for M-n200-k16

Another famously hard fleet route problem has seen a new world record with the help of the Xtreme Route library. This time its the problem named M-n200-k16 that had a previous record of 1320. In just 5 minutes the Xtreme Route library finds a better solution, and the new world record of 1284 was achieved by running the fleet router for 1 hour.

Test cases

Fleet routing in the Xtreme Route library was tested on these test cases with known solutions. The result of these tests are shown below, using 1 and 4 threads and different execution times. Some of the simpler test cases where left out, since the fleet router tends to find the optimal solution very fast on those (a few ms).

Summary

The detailed tests are shown further down (expand the table with the expand button to the right), here is the summary of the 6 tests done

4 threads and 30 second execution time
Test casesOptimal resultXtreme RouteError
1 thread, 3 seconds67376675580,24%
1 thread, 10 seconds67376674900,14%
1 thread, 30 seconds67376674050,04%
4 thread, 3 seconds67376674620,13%
4 thread, 10 seconds67376674190,06%
4 thread, 30 seconds67376673980,03%
The C# code for this benchmark can be viewed here.

Detailed benchmark for 3 seconds execution time on 1 thread.

1 thread and 3 second execution time
Test casesOptimal resultXtreme RouteVehiclesError
A-n32-k578478450%
A-n33-k566166150%
A-n33-k674274260%
A-n34-k577877850%
A-n36-k579979950%
A-n37-k566966950%
A-n37-k694994960%
A-n38-k573073050%
A-n39-k582282250%
A-n39-k683183160%
A-n44-k693793760%
A-n45-k694494460%
A-n45-k71146114670%
A-n46-k791491470%
A-n48-k71073107370%
A-n53-k71010101070%
A-n54-k71167116770%
A-n55-k91073107390%
A-n60-k91354135490%
A-n61-k91034103590.1%
A-n62-k81288129480.47%
A-n63-k1013141318100.3%
A-n63-k91616162790.68%
A-n64-k91401140890.5%
A-n65-k91174117490%
A-n69-k91159116490.43%
A-n80-k1017631771100.45%
B-n31-k567267250%
B-n34-k578878850%
B-n35-k595595550%
B-n38-k680580560%
B-n39-k554954950%
B-n41-k682983060.12%
B-n43-k674274260%
B-n44-k790990970%
B-n45-k575175150%
B-n45-k667867860%
B-n50-k774174170%
B-n50-k81312131580.23%
B-n52-k774774770%
B-n56-k770770770%
B-n57-k91598159990.06%
B-n63-k1014961517101.4%
B-n64-k986186490.35%
B-n66-k91316131990.23%
B-n67-k1010321035100.29%
B-n68-k91272128390.86%
B-n78-k1012211233100.98%
E-n22-k437537540%
E-n23-k356956930%
E-n33-k483583540%
E-n51-k552152150%
E-n76-k10830838100.96%
E-n76-k1410211032141.08%
E-n76-k768268670.59%
F-n135-k71162118471.89%
F-n72-k423724242.11%
M-n101-k10820820100%
M-n121-k71034103670.19%
P-n101-k468168440.44%
P-n16-k845045080%
P-n19-k221221220%
P-n20-k221621620%
P-n21-k221121120%
P-n22-k221621620%
P-n23-k852952980%
P-n40-k545845850%
P-n45-k551051050%
P-n50-k10696697100.14%
P-n50-k755455470%
P-n50-k863162990%
P-n55-k10694697100.43%
P-n55-k756856870%
P-n60-k10744749100.67%
P-n60-k15968972150.41%
P-n65-k10792800101.01%
P-n70-k10827827100%
P-n76-k459359740.67%
P-n76-k562763150.64%
Summary:6737667558N/A0,24%
The C# code for this benchmark can be viewed here.

Detailed benchmark for 10 seconds execution time on 1 thread.

1 thread and 10 second execution time
Test casesOptimal resultXtreme RouteVehiclesError
A-n32-k578478450%
A-n33-k566166150%
A-n33-k674274260%
A-n34-k577877850%
A-n36-k579979950%
A-n37-k566966950%
A-n37-k694994960%
A-n38-k573073050%
A-n39-k582282250%
A-n39-k683183160%
A-n44-k693793760%
A-n45-k694494460%
A-n45-k71146114670%
A-n46-k791491470%
A-n48-k71073107370%
A-n53-k71010101070%
A-n54-k71167117270.43%
A-n55-k91073107390%
A-n60-k91354135490%
A-n61-k91034103590.1%
A-n62-k81288129180.23%
A-n63-k1013141317100.23%
A-n63-k91616161690%
A-n64-k91401140890.5%
A-n65-k91174117490%
A-n69-k91159116490.43%
A-n80-k1017631763100%
B-n31-k567267250%
B-n34-k578878850%
B-n35-k595595550%
B-n38-k680580560%
B-n39-k554954950%
B-n41-k682982960%
B-n43-k674274260%
B-n44-k790990970%
B-n45-k575175150%
B-n45-k667867860%
B-n50-k774174170%
B-n50-k81312131280%
B-n52-k774774770%
B-n56-k770770770%
B-n57-k91598159890%
B-n63-k1014961517101.4%
B-n64-k986186390.23%
B-n66-k91316131990.23%
B-n67-k1010321034100.19%
B-n68-k91272127590.24%
B-n78-k1012211233100.98%
E-n22-k437537540%
E-n23-k356956930%
E-n33-k483583540%
E-n51-k552152150%
E-n76-k10830838100.96%
E-n76-k1410211027150.59%
E-n76-k768268370.15%
F-n135-k71162117871.38%
F-n72-k423723840.42%
M-n101-k10820820100%
M-n121-k71034103570.1%
P-n101-k468168240.15%
P-n16-k845045080%
P-n19-k221221220%
P-n20-k221621620%
P-n21-k221121120%
P-n22-k221621620%
P-n23-k852952980%
P-n40-k545845850%
P-n45-k551051050%
P-n50-k10696697100.14%
P-n50-k755455470%
P-n50-k863162990%
P-n55-k10694696100.29%
P-n55-k756857070.35%
P-n60-k10744744100%
P-n60-k15968968150%
P-n65-k10792792100%
P-n70-k10827827100%
P-n76-k459359540.34%
P-n76-k562763551.28%
Summary:6737667490N/A0,14%
The C# code for this benchmark can be viewed here.

Detailed benchmark for 30 seconds execution time on 1 thread.

1 thread and 30 second execution time
Test casesOptimal resultXtreme RouteVehiclesError
A-n32-k578478450%
A-n33-k566166150%
A-n33-k674274260%
A-n34-k577877850%
A-n36-k579979950%
A-n37-k566966950%
A-n37-k694994960%
A-n38-k573073050%
A-n39-k582282250%
A-n39-k683183160%
A-n44-k693793760%
A-n45-k694494460%
A-n45-k71146114670%
A-n46-k791491470%
A-n48-k71073107370%
A-n53-k71010101070%
A-n54-k71167116770%
A-n55-k91073107390%
A-n60-k91354135490%
A-n61-k91034103590.1%
A-n62-k81288129080.16%
A-n63-k1013141317100.23%
A-n63-k91616161690%
A-n64-k91401140890.5%
A-n65-k91174117490%
A-n69-k91159115990%
A-n80-k1017631763100%
B-n31-k567267250%
B-n34-k578878850%
B-n35-k595595550%
B-n38-k680580560%
B-n39-k554954950%
B-n41-k682982960%
B-n43-k674274260%
B-n44-k790990970%
B-n45-k575175150%
B-n45-k667867860%
B-n50-k774174170%
B-n50-k81312131280%
B-n52-k774774770%
B-n56-k770770770%
B-n57-k91598159890%
B-n63-k1014961497100.07%
B-n64-k986186190%
B-n66-k91316131690%
B-n67-k1010321032100%
B-n68-k91272127490.16%
B-n78-k1012211221100%
E-n22-k437537540%
E-n23-k356956930%
E-n33-k483583540%
E-n51-k552152150%
E-n76-k10830836100.72%
E-n76-k1410211021140%
E-n76-k768268270%
F-n135-k71162116470.17%
F-n72-k423723740%
M-n101-k10820820100%
M-n121-k71034103570.1%
P-n101-k468168140%
P-n16-k845045080%
P-n19-k221221220%
P-n20-k221621620%
P-n21-k221121120%
P-n22-k221621620%
P-n23-k852952980%
P-n40-k545845850%
P-n45-k551051050%
P-n50-k10696697100.14%
P-n50-k755455470%
P-n50-k863162990%
P-n55-k10694697100.43%
P-n55-k756856870%
P-n60-k10744744100%
P-n60-k15968968150%
P-n65-k10792792100%
P-n70-k10827827100%
P-n76-k459359540.34%
P-n76-k562762750%
Summary:6737667405N/A0,04%
The C# code for this benchmark can be viewed here.

Detailed benchmark for 3 seconds execution time on 4 threads.

4 threads and 3 second execution time
Test casesOptimal resultXtreme RouteVehiclesError
A-n32-k578478450%
A-n33-k566166150%
A-n33-k674274260%
A-n34-k577877850%
A-n36-k579979950%
A-n37-k566966950%
A-n37-k694994960%
A-n38-k573073050%
A-n39-k582282250%
A-n39-k683183160%
A-n44-k693793760%
A-n45-k694494460%
A-n45-k71146114670%
A-n46-k791491470%
A-n48-k71073107370%
A-n53-k71010101070%
A-n54-k71167116770%
A-n55-k91073107390%
A-n60-k91354135490%
A-n61-k91034103590.1%
A-n62-k81288129380.39%
A-n63-k1013141317100.23%
A-n63-k91616162790.68%
A-n64-k91401140890.5%
A-n65-k91174117490%
A-n69-k91159115990%
A-n80-k1017631763100%
B-n31-k567267250%
B-n34-k578878850%
B-n35-k595595550%
B-n38-k680580560%
B-n39-k554954950%
B-n41-k682982960%
B-n43-k674274260%
B-n44-k790990970%
B-n45-k575175150%
B-n45-k667867860%
B-n50-k774174170%
B-n50-k81312131380.08%
B-n52-k774774770%
B-n56-k770770770%
B-n57-k91598159890%
B-n63-k1014961497100.07%
B-n64-k986186390.23%
B-n66-k91316131690%
B-n67-k1010321033100.1%
B-n68-k91272127390.08%
B-n78-k1012211223100.16%
E-n22-k437537540%
E-n23-k356956930%
E-n33-k483583540%
E-n51-k552152150%
E-n76-k10830836100.72%
E-n76-k1410211027150.59%
E-n76-k768268570.44%
F-n135-k71162116970.6%
F-n72-k423724041.27%
M-n101-k10820820100%
M-n121-k71034103570.1%
P-n101-k468168540.59%
P-n16-k845045080%
P-n19-k221221220%
P-n20-k221621620%
P-n21-k221121120%
P-n22-k221621620%
P-n23-k852952980%
P-n40-k545845850%
P-n45-k551051050%
P-n50-k10696697100.14%
P-n50-k755455470%
P-n50-k863162990%
P-n55-k10694697100.43%
P-n55-k756856870%
P-n60-k10744744100%
P-n60-k15968968150%
P-n65-k10792798100.76%
P-n70-k10827827100%
P-n76-k459360341.69%
P-n76-k562763050.48%
Summary:6737667462N/A0,13%
The C# code for this benchmark can be viewed here.

Detailed benchmark for 10 seconds execution time on 4 threads.

4 threads and 10 second execution time
Test casesOptimal resultXtreme RouteVehiclesError
A-n32-k578478450%
A-n33-k566166150%
A-n33-k674274260%
A-n34-k577877850%
A-n36-k579979950%
A-n37-k566966950%
A-n37-k694994960%
A-n38-k573073050%
A-n39-k582282250%
A-n39-k683183160%
A-n44-k693793760%
A-n45-k694494460%
A-n45-k71146114670%
A-n46-k791491470%
A-n48-k71073107370%
A-n53-k71010101070%
A-n54-k71167116770%
A-n55-k91073107390%
A-n60-k91354135490%
A-n61-k91034103590.1%
A-n62-k81288129080.16%
A-n63-k1013141314100%
A-n63-k91616161690%
A-n64-k91401140890.5%
A-n65-k91174117490%
A-n69-k91159116390.35%
A-n80-k1017631763100%
B-n31-k567267250%
B-n34-k578878850%
B-n35-k595595550%
B-n38-k680580560%
B-n39-k554954950%
B-n41-k682982960%
B-n43-k674274260%
B-n44-k790990970%
B-n45-k575175150%
B-n45-k667867860%
B-n50-k774174170%
B-n50-k81312131380.08%
B-n52-k774774770%
B-n56-k770770770%
B-n57-k91598159890%
B-n63-k1014961497100.07%
B-n64-k986186190%
B-n66-k91316131790.08%
B-n67-k1010321032100%
B-n68-k91272127490.16%
B-n78-k1012211226100.41%
E-n22-k437537540%
E-n23-k356956930%
E-n33-k483583540%
E-n51-k552152150%
E-n76-k10830835100.6%
E-n76-k1410211021140%
E-n76-k768268370.15%
F-n135-k71162116370.09%
F-n72-k423723740%
M-n101-k10820820100%
M-n121-k71034103570.1%
P-n101-k468168140%
P-n16-k845045080%
P-n19-k221221220%
P-n20-k221621620%
P-n21-k221121120%
P-n22-k221621620%
P-n23-k852952980%
P-n40-k545845850%
P-n45-k551051050%
P-n50-k10696697100.14%
P-n50-k755455470%
P-n50-k863162990%
P-n55-k10694696100.29%
P-n55-k756856870%
P-n60-k10744744100%
P-n60-k15968968150%
P-n65-k10792798100.76%
P-n70-k10827827100%
P-n76-k459359640.51%
P-n76-k562762850.16%
Summary:6737667419N/A0,06%
The C# code for this benchmark can be viewed here.

Detailed benchmark for 30 seconds execution time on 4 threads.

4 threads and 30 second execution time
Test casesOptimal resultXtreme RouteVehiclesError
A-n32-k578478450%
A-n33-k566166150%
A-n33-k674274260%
A-n34-k577877850%
A-n36-k579979950%
A-n37-k566966950%
A-n37-k694994960%
A-n38-k573073050%
A-n39-k582282250%
A-n39-k683183160%
A-n44-k693793760%
A-n45-k694494460%
A-n45-k71146114670%
A-n46-k791491470%
A-n48-k71073107370%
A-n53-k71010101070%
A-n54-k71167116770%
A-n55-k91073107390%
A-n60-k91354135490%
A-n61-k91034103590.1%
A-n62-k81288128880%
A-n63-k1013141314100%
A-n63-k91616161690%
A-n64-k91401140890.5%
A-n65-k91174117490%
A-n69-k91159115990%
A-n80-k1017631763100%
B-n31-k567267250%
B-n34-k578878850%
B-n35-k595595550%
B-n38-k680580560%
B-n39-k554954950%
B-n41-k682982960%
B-n43-k674274260%
B-n44-k790990970%
B-n45-k575175150%
B-n45-k667867860%
B-n50-k774174170%
B-n50-k81312131280%
B-n52-k774774770%
B-n56-k770770770%
B-n57-k91598159890%
B-n63-k1014961497100.07%
B-n64-k986186190%
B-n66-k91316131690%
B-n67-k1010321032100%
B-n68-k91272127290%
B-n78-k1012211223100.16%
E-n22-k437537540%
E-n23-k356956930%
E-n33-k483583540%
E-n51-k552152150%
E-n76-k10830835100.6%
E-n76-k1410211021140%
E-n76-k768268270%
F-n135-k71162116370.09%
F-n72-k423723740%
M-n101-k10820820100%
M-n121-k71034103470%
P-n101-k468168140%
P-n16-k845045080%
P-n19-k221221220%
P-n20-k221621620%
P-n21-k221121120%
P-n22-k221621620%
P-n23-k852952980%
P-n40-k545845850%
P-n45-k551051050%
P-n50-k10696697100.14%
P-n50-k755455470%
P-n50-k863162990%
P-n55-k10694696100.29%
P-n55-k756856870%
P-n60-k10744744100%
P-n60-k15968968150%
P-n65-k10792792100%
P-n70-k10827827100%
P-n76-k459359540.34%
P-n76-k562762950.32%
Summary:6737667398N/A0,03%
The C# code for this benchmark can be viewed here.

Screenthots

Here are some screenshots taken from the xtreme route demo which is built on the Xtreme Route library. A description of the picture, as well as some data from the execution, is shown below each screenshot.

These pictures where created on an 2.4Ghz Intel P4 Quad core computer. The time below each pictures is the elapsed time, while the time in parenthesis is the total CPU time for all CPU-cores.

Note that all screenshots are compressed to JPEG and have lost some quality.

Routing pictures

Support

Support

Customers with a valid support contract has unlimited and free support using email support@xtremeroute.com.

For questions about this web page, or other type of questions, feel free to get in contact on email info@xtremeroute.com

Support over phone

Support over phone can be arranged for customers with support contract.

C# samples

Code Samples

The samples here shows how to use some of the features in the Xtreme Route libraries, and can be used as they are or with smaller changes.

For customer specific samples and help, contact info@xtremeroute.com

Point to Point routing with VIA points.

This sample shows how to calculate a point to point route passing through a number of VIA points. Start point, stop point and VIA points are all represented by coordinates, so a spatial search is also performed.

View the sample

Fleet routing sample

This sample shows how to calculate a fleet route from a number of map coordinates. The demand of each node is randomized, and the total cost for the fleet route is returned.

View the sample

Isoschrone sample

In this sample a number of isochrones are calculated from X and Y coordinates. The average cost of each node in the result is then calulcated and returned.

View the sample

Import sample

This sample shows how to import a network from a shape file. For simplicity, the following is assumed about the attribut data:

  • The name of the field containing the road names is ROADNAME
  • Speed is based on a road type with a speed mapping for each type. The field name for the road type is ROADTYPE
  • Oneway roads have 1 or 2 in the field ONEWAY to indicate direction, 0 means open both ways.

This is just one example configuration, for example if speeds are available as a field those can be used instead of the speed mapping.

View the sample

Man with computer

About Xtreme Route

Software

Xtreme Route library is a one-man project that's been in development for several years. The developer (that is, me) has a masters degree in computer science and over 20 years of experience in advanced software development, including development of AI software, math libraries, etc.

Web page

This web page is also made by me, but please don't hold that against me. I am not a designer nor a very experienced web developer :-)

Company

The company is a one-man company so far, but is expecting to grow as more customers buy our product. The company is located in Sweden.

To get in contact, email to info@xtremeroute.com

News & Announcements

  • June 26, 2012Version 2.0 of the Xtreme Route library is now available. The new version contains major performance improvements, as well as new functionality for advanced routing. Download and try the Xtreme Route Demo to try some of the new functionality.
  • June 18, 2012New breathtaking performance for trip planning in the Xtreme Route library, check for yourself at the benchmarks.
  • February 16, 2012Here is a screenshot of a routing application developed in Silverlight. The language for the application is Swedish, but you should get the basic idea anyway.
  • January 21, 2012A big Swedish company has selected Xtreme Route as the routing component in a server product that will be used by sales and support. More information about this later, when its "official".
  • December 31, 2011Happy new year!
  • December 6, 2011This web page got a little face lift, hope you like it.
  • December 3, 2011New licensing for the Xtreme Route library, now its sold and licensed as one product.
  • October 27, 2011Updated demo is available, built on version 1.2 of the Xtreme Route libraries. Includes advanced dynamic route settings, as well as real-time animated ISO surfaces. Read more on the demo page.
  • October 24, 2011Version 1.2 of the Xtreme Route library is now available, now ISO surfaces can be centered on a route. See this picture for an example.
  • October 21, 2011Xtreme Route on YouTube: Animated ISOchrones.
  • October 10, 2011Screenshots of the new "ISO on a route" functionality is available, check out the screenshot page.
  • September 30, 2011Yet another world record by Xtreme Route library, this time its the problem M-n200-k16 with a previous best of 1320 that was lowered to 1289.
  • August 21, 2011A number of code samples are now available, check em out!
  • August 06, 2011An online store is now available, using PayPal for secure and reliable money transfer and credit card processing. Go shopping!
  • July 31, 2011New World Record for famous fleet route test case, read more.
  • July 29, 2011Xtreme Route is now on Facebook, check it out!
  • July 27, 2011This site got a big facelift with the new design. Hope you like it!
  • June 29, 2011Version 1.1 of the Xtreme Route library is now available.
  • June 16, 2011A demo application for the Xtreme Route library is now available. Read more about it here or download it directly from this link: Xtreme Route Demo.
  • May 28, 2011Yet another new design for this web page, I have to stop this or I will turn into a designer (and that can't be good)!
  • January 5, 2011Well, a new year, but nothing really changed, did it? Oh yes, a new logo, this one looks happier than the last one.
  • Merry Christmas & Happy New Year!
  • December 24, 2010Here it is, the new design for this website (I am no designer, so be nice). Now its all metal and frosted red glass. Looks nice, doesn't it?
  • December 14, 2010The very first version of the xtremeroute.com was published. Happy days are here!
"Amazing results, this makes everyone else look bad!"
Route planning
-Xtreme performance.
-Optional VIA points.
-Dynamic routing.
-Turn restrictions.
-Parallel execution.
Isochrones
-Smooth gradients
or stepwise colors.
-Different types
of interpolation.
-Parallel execution.
Fleet routing
-Most accurate fleet
router in the world.
-Can handle hundreds
of pickup nodes.
-Parallel execution.
Demo application
-Demonstrates the basic
functionality of the
Xtreme Route library.
-Free download.
-No registration needed.

Copyright © 2012 Xtreme Route - All Rights Reserved. Contact us: