MapTP Technical Whitepaper
Building Scalable and Interactive Mapping Applications with NAVTEQ MapTP Product Line
Pages: 1, 2, 3, 4, 5, 6, 7, 8, 9
MapTP provides innovative software technology for interactive mapping applications. MapTP's unique technology builds the foundation for the display of accurate and up-to-date digital map data on many different platforms and many kinds of environments including Internet, distributed enterprise applications, desktops, and mobile devices.
Today, MapTP product suite is used in various vertical markets, such as fleet tracking, asset management, telematics, logistics, geomarketing, CRM software, and Web portals. MapTP's unique technology uses map data in a vector format to achieve truly interactive and scalable mapping applications.
The following gives a brief description for each chapter in this document. Chapter 1 describes in its first part different approaches for mapping technologies. In particular, the commonly used tiles approach is compared with MapTP’s technology for transferring vector map data. The second part of the chapter describes the MapTP application environment and gives the reader an understanding of what the MapTP platform offers, how it fits into mapping applications and into existing infrastructures. This first chapter is meant to be an overview for the document and touches on all aspects that are explained in detail in later chapters.
Chapter 2 explains how the MapTP services architecture is used for functional integration. This includes access to spatial services and algorithms such as geocoding, routing, and also the integration with existing infrastructures to access any kind of legacy system. This chapter also explains how a very powerful mechanism that is based on a services architecture allows applications to push data onto a mapping client and also to remote control mapping clients. The XML Web services that are explained later in Chapter 5 use the service architecture as the foundation.
Chapter 3 goes into the details of data integration. Data integration can be divided into a client and server-side implementation. With client-side integration the data is only visible to a particular client and the data is never uploaded to a server. With server-side integration on the other hand dynamic custom maps can be created and uploaded to the server. From there the custom maps are available to mapping clients.
After the three building blocks for truly rich and interactive mapping applications have been described, Chapter 4 is for the programmer. The chapter explains the programming model and different programming interfaces. The Map24 APIs are discussed in Chapter 5. Those APIs encapsulate the MapTP API and provide functionality and interfaces for specific platforms such as Microsoft ActiveX, mobile clients, and the Internet.
Chapter 6 introduces XML Web services. These services make it possible to build distributed systems that use components that are spread across the Internet. The aim of this chapter is to show how to design and build components that can be accessed over the Internet; as well as integrate into larger applications while using standard protocols such as HTTP, SOAP, and standard data formats based on XML.
Chapter 7 shows how to bring interactive maps onto mobile devices and why MapTP is the ideal platform for mobile computing. Chapter 8 describes the methodology for persistent maps: especially useful for mobile mapping and desktop applications. These are maps stored on the local file system that can be used for cashing and to take mapping clients offline. This chapter gives an overview of the technology and describes typical use case scenarios.
Chapter 9 of this technical product description gives a summary of what the MapTP platform offers and provides contact information.
In the first part of this chapter the bitmap server approach and the vector maps server approach for mapping technologies are compared. The second part of the chapter describes the MapTP application environment and explains how MapTP can fit into mapping applications as well as into existing infrastructures. This first chapter is meant to be an overview for the document and touches on all aspects of the technology that are explained in detail in later chapters.
Digital geographical maps consist of large amounts of data that was collected and digitized, then compiled to formats that are suitable for dedicated spatial algorithms and mapping applications. Maps are accurate models of the world. Map data therefore represents real world objects such as city streets, highways, railroads, administrative boundaries, water, power cable lines, and many more types of objects. In a digital map database these objects are stored with their geometric information. Besides the geometry, which is stored for every object, a digital map database also stores a set of attributes for every object. Attributes provide additional information for a map object. The kind and number of attributes is variable and depends on the object type and on the map data source. Those attributes can be names, addresses, speed limits, one-way indicators, or turn restrictions.
The first part of this chapter gives the reader an overview of the two general graphic formats for digital map data: raster graphics and vector graphics. The chapter gives the reader the necessary information to understand the differences between technologies on the market that are based on either format. The foundation of the MapTP technology will be explained and further why this unique technology is so well suited for building truly rich and interactive mapping applications. The second part of the chapter gives the software architect an overview of the MapTP system environment and explains how MapTP helps building data- and function-rich mapping solutions.
Besides others, a mapping application's task is it to display map data on a computer screen or mobile device. First and foremost this is about displaying the shape or image of the real world objects that are represented by map data. Two different ways exist for representing images in computer graphics. One of these representations is raster graphics. A raster graphic is a representation of images as a collection of pixels. Raster graphics are commonly used for photo realistic images such as satellite photos. Synonyms for the term raster graphics are raster images, raster maps, bitmaps, or pixel graphics. In this document those terms are used interchangeably. Subtle differences that might exist are beyond the context of this document.
The second way for image representation in computer graphics is the use of geometrical primitives such as points, lines, and polygons. When images are represented this way, the graphics are called vector graphics. Vector graphics are geometric models of objects and because of the existence of geometric information vector graphics are computational. Objects can be scaled up and down, stretched or compressed, moved or rotated. Figure 1.1 shows seamless zooming of a vector graphic.
Furthermore, objects of a vector graphic have a location that sets them in relation to a space. The location is expressed in latitude and longitude coordinates. Objects can be moved within the space by changing the coordinates of the object. Distances between two or more objects can also be calculated easily with the geometric information that a vector graphic provides.
These operations are not possible when objects are represented as a collection of pixels like they are in raster graphics. For example, scaling of raster graphics is not possible without loosing quality.
Geographical information systems (GIS) and digital map data providers store and distribute the map data in vector formats. That way, the geometric information for objects is maintained. Think of the objects geometry as being stored as lines, polygons, or points. There can be millions of objects belonging to one map. When objects are stored as vectors they also have a relationship to corresponding object attributes. This makes the map rich and full of valuable information.
The next three paragraphs compare different techniques for the interaction between mapping clients with mapping servers. The paragraphs show advantages and disadvantages of the techniques and show what to look for when choosing a mapping technology.
Figure 1.1: Seamless zooming of a vector map
A common approach for displaying maps is to transfer a set of pre-rendered map segments, so-called tiles, to the client. The client composes the tiles and displays the map. This approach is quite fast when panning the map view, since the server only has to transfer the tiles that are not visible on the client yet. However, for zooming actions a complete new image has to be transferred to the client, and the transition from one zoom level to the next does not appear smoothly.
Instead of transferring pre-rendered tiles, MapTP follows a fundamentally different approach by transferring vector map data to the client which then renders the vector map for display. Similarly to the tiles approach, the client application continues to use the map data that has been delivered to the client before. Only incremental updates of vector map data are sent to the client. This approach is called vector map streaming technology. The vector map streaming technology is based on the map transfer protocol MapTP that combines vector data compression with incremental updates.
For panning actions there is not much difference in performance between this technology and the tiles approach. However, there is a remarkable difference when it comes to zooming. With MapTP’s vector map streaming technology only those map details have to be sent to the client that are not yet available on the client. This approach makes seamless zooming possible and provides a true interactive experience to the users.
There is practically no delay visible on the client's display even for fast zooms and pans. Every action on the mapping client appears smoothly. For example, it is possible to continuously zoom from a continental view down to street level. Animated jumps from one location to another on the map can give users the impression to fly to the new location. In the 3D view the map can be skipped and rotated.
Figure 1.2: Animated flight along a route
Another advantage of MapTP’s vector map streaming technology is that it is possible to change map properties. For example, the colors of map objects can be adjusted to the look and feel of the customer’s Web site or application.
Figure 1.3: Custom map colors
This section gives a high level overview of MapTP, the components MapTP consists of and the environment MapTP works in. It shows how the system can be accessed both from a developer's and from a user's perspective and how the system can be extended and integrated with existing infrastructure. Figure 1.4 shows a graphical overview of the MapTP system environment.
Figure 1.4: The MapTP System Environment
Mapping applications typically work in distributed environments. In a simple distributed environment one or more client applications are connected to a server that provides the clients with map data on request. In its most simple setup a MapTP environment looks the same. The server is called MapTP server and the client applications are referred to as MapTP clients or simply mapping clients.
By default, MapTP uses standard TCP/IP connections but HTTP access is also supported. The MapTP server accepts both MapTP and HTTP requests and also works in mixed client environments. Vector map data from the leading digital map data providers can be imported and accessed via MapTP. Map data is sent from the MapTP server to client applications per client requests and the data is rendered on the client for display. Clients can provide the user with interactivity such as zooming, panning, distance measurement, and others. A wide spectrum of client types are supported. Clients can be desktop applications and applets with rich client interfaces, Web based applications, and applications for mobile devices.
So far we looked at a client-server architecture which is the simplest setup for a mapping application. There are numerous integration and extension points for a MapTP application where business logic, application specific data, and custom maps can be integrated and be distributed over multiple tiers.
A service interface gives MapTP client applications access to services that go beyond operations performed on map data. Services build a gateway for mapping applications to spatial algorithms and to other functionality and data provided by existing infrastructure.
A service runs in its own process and communicates to a MapTP server using a protocol called MapTP Service. The goal of MapTP Services is it to allow the creation of an open, flexible, and distributed architecture. MapTP Services allow the utilization of existing application functionality and infrastructure without the need to upload or to convert any application specific, or business critical data. Uploading the data to a map server system could compromise data security. With MapTP Services the data stays secure on your servers.
MapTP provides a large number of spatial algorithms as services and provides Web service interfaces for those as well. Client applications use SOAP messages to send requests to the Web services. Web services give software architects the ultimate freedom to design real distributed systems.
Above and beyond commercially available map data, every mapping application requires to work with all kinds of application and domain specific data. On a high level one can distinguish between client-side integration and server-side integration. There are some considerations that the application's architect should keep in mind when making design decisions.
If application specific data is only relevant to a specific user then client-side integration can be a fast and effective way to go. Client-side integration means that the client application loads the data from the local file system or connects to any other remote resource like a database server. Applications do not use any MapTP specific protocol to integrate the data. But MapTP does have programming interfaces that applications can use to display the data together with the map data.
An example for client-side data integration is a CRM system with integrated map that shows sales numbers such as revenue, sold products etc. per sales region. By selecting a sales region on the map the application reads the up-to-date sales information out of a relational database and displays the information on top of the selected region.
If the data is of interest for more than one client application or user or if the client application has no direct access to the data source then server-side data integration is preferred or is even required. For small amounts of data this can be done with a service that pushes data to clients. Chapter 2, MapTP Services, discusses this aspect.
If the amount of data is large then the most efficient way for client applications to access the data is to load custom maps from the server. Before a client application can load custom maps from the server a custom map service must build the maps and send them to the MapTP server. MapTP provides the programming interface for custom map services and the protocol for uploading the map to the server. The programming interface and protocol is called MapTP MapService.
A good example for a custom map is weather information. One application that has access to the weather data creates a custom map with it and uploads the map to a MapTP Server. From there many client applications request the custom map to display it on top of highways and city streets from the standard map.
MapTP is a product made for software developers. Extensive application programming interfaces (APIs) are provided that allow the tailoring of every aspect of mapping applications.
The MapTP programming interface for building client applications is equally available for the Java and for the C++ programmer. A large part of the source code is available to the developer.
For developing mobile applications the Map24 Mobile Kit is provided which is a C++ API.
A component-oriented approach for implementing mapping applications for different platforms is offered by the Map24 Component Interface (Map24 CI). Map24 CI provides several interfaces that hide the details of the MapTP API. For example, a .NET interface for Microsoft Windows and Windows CE is provided that can be used for building mapping applications for Pocket PC 2003, Smartphone 2003, Windows Mobile 5.0, and others.
The Map24 Web Services make additional services available via XML/SOAP and HTTP GET. Besides providing access to spatial algorithms, the Map24 Web Services offer interfaces for custom data integration and for remote controlling mapping clients.
The Map24 AJAX API provides a JavaScript API that gives programmers an easy and powerful way for incorporating mapping functionality into their Web applications.
Highly frequented Internet applications such as a portal for mapping and route planning receive thousands of requests within a short time frame. For those applications the workload at peek times can be too high for just a single MapTP server. Depending on the server load, clients can experience delays in response times. To increase the capacity, any number of MapTP servers can be placed behind a commercially available load balancer. In a load balanced environment a so called virtual server selects a physical server based on the current load. Those load balancers usually support a concept that is called persistence. If persistence is configured for the load balancer then subsequent client requests are all directed to the same physical server. That way it can make sense for the physical server to maintain session state that can be used for subsequent calls from the same client.
Maintaining client state is possible with the MapTP server due to the session-oriented MapTP protocol. The server holds session information for every client and remembers which map data was sent to a particular client already. Should the same client request the same data again then the server does not send anything. The server only sends additional details or map data of additional areas if a client requests it. This session-oriented protocol reduces network traffic tremendously and is essential for effective client-server communication.
Scalability was also an important factor for the design of the MapTP Services architecture discussed above. More than one instance of the same service can be connected to a MapTP server. The server dispatches client requests to the different service instances using its built-in load balancer. The MapTP Service protocol allows service instances to take advantage of session state even if they run in a load balanced environment. More details about session-orientation and load balancing services can be read in Chapter 2.4, Session-Orientation and Load Balancing of MapTP Services.
A frequently asked question to a software vendor is how open the software is. That is an important question because one thing customers don't want is to be locked-in with a vendor and its his technology. The following sections are meant to summarize openess that is characteristic for a mapping application implemented with MapTP. The answers touch on almost all aspects that have been discussed previously and that will be discussed in more depth in the coming sections.
While MapTP is not open in the sense of open source that is available under an open source license it is nevertheless in many regards an open system.
- MapTP is open to programmers. Extensive application programming interfaces (APIs) are provided that allow the tailoring of every aspect of mapping applications. All APIs are documented. In addition, a large part of the source code is available to the developer. The developer can use it as is, alter and customize it, or use it as example source code. Essential functionality that comprises the vector map processing, rendering, persistent maps, protocols and communication are not available in source code. But all these parts can be used to build mapping applications by using the API.
- MapTP is open to the integration with custom data. Custom data can be integrated client-side and rendered together with map data. This data will never be available on the server and thus will never be visible for other clients. It is always only local to the client application that loads the data.
- MapTP is open to functional integration. Service APIs allow access to spatial algorithms and to any existing information system or legacy application. MapTP provides a number of service implementations for spatial algorithms already. But mapping applications are not locked-in with the provided service implementations and can easily integrate services from other sources.
- MapTP is open to platform independent access via Web services. Web services are provided for services that run spatial algorithms and for a number of commands that control mapping clients from a remote client process.
- MapTP is open to a wide variety of map data formats. These formats can be imported without having to touch the mapping application and functionality.
After this overview of the MapTP technology and environment the next chapters look at each of the subjects in more detail. Chapter 2, MapTP Services, shows how a services concept can be used to integrate with existing infrastructure. Chapter 3 shows different ways on how application or business specific custom data can be integrated into the mapping application.
Pages: 1, 2, 3, 4, 5, 6, 7, 8, 9
|
