Welcome
to Carmenta

We are in the process of building a new
carmenta.com experience. In the meantime,
feel free to browse our current website.

us fr de
Carmenta_3D_LineOfSight.jpg

Creating High Performance Map Displays with Carmenta Engine

Introduction

Map engines are normally used to render static maps – either to a printer or to a digital display – and the time taken to render this type of map is not usually crucial.

But when visualising large volumes of dynamic data in a map of a constantly changing situation, such as those used in Command and Control (C2) or Battle Management (BMS) systems, the update speed is very important to the system’s overall usability.

Traditionally, this type of high performance map function is part of a custom built application, and is sometimes even installed on specially designed hardware, as few off-the-shelf map engines are able to meet the necessary performance requirements. This often results in a system with sufficient performance, but one that struggles to keep the maps updated and has difficulty adapting to new data sources. 

Carmenta Engine provides a solution to this problem, making it possible to combine advanced background maps with large volumes of frequently updated dynamic data in a single situational overview, whilst maintaining excellent performance.

Typical challenges when creating high performance map displays

There are generally two types of situational data in a C2 system: the predominantly static background maps and the dynamic objects that are superimposed on top of them.

These two elements have very different characteristics, and combining them into a single map display, while maintaining a responsive GUI and rapid update rates, puts a lot of demand on the map engine.

Examples of the differences:

 

background-maps.jpg

Background maps

  • Various different file formats

  • Varied content, e.g. raster/vector

  • Different levels of detail

  • Different coordinate reference systems

DynamicData.png

Dynamic data

  • Large number of objects

  • Frequent position updates

  • Specific requirements on symbology and labelling 

 

There are of course a lot of ways to optimise the handling of the geospatial information, for example, efficient use of multiple CPU cores through multi-threading, GPU (graphics processing unit) usage optimisation, in-memory caching and spatial indexing.


The following chapters describe a few important mechanisms that Carmenta Engine employs to tackle this problem, with a focus on three common uses for a map engine.

The Carmenta Engine approach to achieving high performance

Carmenta Engine employs a wide range of techniques to overcome the challenge of combining background maps and dynamic objects while maintaining excellent performance – and it is an approach that has proven to be reliable. Thanks to Carmenta Engine, customers in the defence, security and enterprise sectors are able to run their real-time applications 24 hours a day, 7 days a week, 365 days a year.


The following chapters outline these techniques and provide information on where you can find out more about each feature. Visit www.carmenta.com to request a 30-day trial of our SDK (Software Development Kit).

Efficient handling of dynamic objects

Carmenta Engine map layers contain a dynamic caching mechanism. When activated, this mechanism can be used to optimise the performance of layers with a large number of moving objects.

 

dynamic-overlay.jpg

Typical dynamic overlay – Thousands of moving AIS tracks superimposed on a background map

 

This caching mechanism is specifically designed to cache the presentation of application data at GPU level. It provides efficient caching for the layer objects and allows the application to modify individual objects in the layer without discarding the entire cache.


This type of caching saves a lot of rendering time, particularly when only a subset of the objects in the layer is modified during each map update. For example, when the position of an object is updated but its visualisation remains unchanged, the cache functionality will boost performance significantly, as the move is carried out entirely at GPU level.

It often helps to adjust the presentation of dynamic objects depending on the current situation or needs and makes interpretation easier, as demonstrated in the example below. Carmenta Engine offers a range of different visualisation options, to ensure that the dynamic object displays are always easy to interpret.

 

flexible-presentation.jpg

Flexible presentation of the dynamic data, e.g. according to scale or number of visible objects

 

Please refer to OrdinaryLayer.CacheMode in our SDK documentation library for more information about the caching functionality.

 

Efficient handling of radar plots and other point overlays

Carmenta Engine has a specially-designed tracking and plotting functionality that enables radar plots and other simple point objects to be drawn very efficiently. Thanks to advanced GPU acceleration, PlotLayer enables several million moving plots to be managed at once, even with low-end GPUs.

 

plot-layers.jpg

Carmenta Engine’s PlotLayer functionality enables the visualisation of numerous simple objects, in this case track history and radar plots

 

The plots are managed in batches, with all plots in each batch sharing the same symbol. Plot batch opacity can be easily updated, which enables old plots to be faded out. Thanks to an individual object level hit testing capacity, interaction with individual plots is possible.
Please refer to PlotLayer in our documentation library for more information about this functionality.

Efficient handling of background maps

The background map provides a geographical reference, onto which the dynamic data is superimposed. Carmenta Engine enables you to easily combine raster and vector maps, as well as reference grids, to create the desired background map.


With native support for more than 70 different data sources, including file-based formats, databases and web services, Carmenta Engine can handle data in its original format, thus eliminating time-consuming conversion processes.

format-maps.jpg

Types of background map: an S-57 nautical chart, an orthophoto and an OpenStreetMap vector map

 

combined-nautical.jpg

Combined here to create a single background map, with and without dynamic objects

 

When changing the visible area, background maps can be loaded asynchronously – i.e. tile by tile – which ensures that the GUI will always remain responsive, and means that dynamic objects can be updated continuously, even when large map files are being loaded at the same time.

 

static-tiles.jpg

Static data in the map tiles can also contain dynamic elements,
as demonstrated here with constant label orientation, despite a rotating
background map

 

Once a background map tile has been loaded it can be cached on the GPU, thereby speeding up all subsequent map updates, for example, map refreshes due to dynamic object movement.


Please refer to TileLayer in our SDK documentation library for more information about this functionality.

 

Profiling map performance


Detailed analysis of map performance – both of background maps and dynamic data – is made easy thanks to Carmenta Engine’s built-in Profiler functionality.


The Profiler can be used in the Carmenta Explorer map preview application (part of the Carmenta Engine SDK), but it can also be easily integrated within an application. This enables performance to be fine tuned while the system is receiving data from real external interfaces.

 

profiler.jpg

The Profiler Performance Report provides detailed information on where time was spent during a map update

 

Please refer to Profiler in our SDK documentation library for more information about this functionality.