The Success Of Google Maps
Google Maps a free web mapping service application and technology provided by Google. It offers street maps, a route planner, and an urban business locator for numerous countries around the world. Google Maps can generate driving directions between any pair of locations and can also show turn-by-turn instructions, an estimate of the trip time, and the distance between the two locations.
To be able to embed Google Maps into web pages for either more elaborated customization, we need Google Maps API. Google API stands for ‘Application Programmable Interface’. As it’s name implies, it is an interface that queries the Google database to help programmers in the development of their applications.
[By definition, Google API’s consist basically of specialized Web services and programs and specialized scripts that makes it possible for Internet application developers to better find and process information on the Web. In essence, Google APIs can be used as an added resource in their applications.
In the real world, application programmers, developers and integrators write software programs that can connect remotely to the Google API’s. All data communications are executed via the ‘Simple Object Access Protocol’ (SOAP), which is a Web services standards as defined by the industry. The SOAP protocol is an XML-based technology meant to easily exchange information entered into a Web application.
Google’s API can better help developers in easily accessing Google’s web search database. This empowers them in developing software that can query billions of Web documents, constantly refreshed by Google’s automated crawlers. Programmers can happily initiate search queries to Google’s colossal index of more than three billion pages and have results delivered to them as structured data that is simple to analyse and work with. Additionally, Google API’s can perfectly access data in the Google cache, while at the same time provide checking in the spelling of words. Google APIs will more precisely implement the standardized search syntax used on many of Google’s search properties.]
The map data in Google Maps is compiled by a private company with whom Google have a partnership. This company is Tele Atlas and they are a world leaders in navigation and location-based services. The maps are highly accurate and have been praised for recording extremely rural areas and mapping the terrain correctly.
Google Maps also coordinates with several other in-house application currently run by Google. The most obvious of these is Google Earth. The two services use each other’s data for coordinating satellite imagery and in updating newly-developed areas which have yet to be updated on both databases.
Business and premises which are place-marked on maps have been supplied by directory listings. In the US, Google say that they use Yellow Pages directories but also mentions, “We aren’t currently able to share our full list of U.S. Yellow Pages sources.” All other premises and place-marks are shared by users – which we will take a look at next.
The technology behind Google Maps could generically be described as a map server. The map server generates a map for the requested location from a large set of pre-generated map tile images covering the entire planet. The map server may overlay data from other databases on top of this. The combination of a map viewer client and geographical database is traditionally called a Geographical Information System (GIS).
Overlays are objects on the map that are tied to latitude/longitude coordinates, so they move when you drag or zoom the map. Overlays reflect objects that you “add” to the map to designate points, lines, or areas.
The Maps API has several types of overlays:
* Points on the map are displayed using markers, and often display a custom icon. Markers are objects of type GMarker and may make use of the GIcon type.
* Lines on the map are displayed using polylines (representing a collection of points). Lines are objects of type GPolyline.
* Areas on the map are displayed either as polygons if they are areas of an arbitrary shape or as ground overlays if they are rectangular. Polygons are similar to polylines in that they consist of a collection of points with a closed loop and may take any shape. Ground overlays are often used for areas that map either directly or indirectly to tiles on the map.
* The map itself is displayed using a tile overlay. You can modify this with your own set of tiles by using a GTileLayerOverlay or even by creating your map type using a GMapType.
* The info window is also a special kind of overlay. Note, however, that the info window is added to the map automatically, and that there can only be one object of type GInfoWindow attached to a map.
Each overlay implements the GOverlay interface. Overlays can be added to a map using the GMap2.addOverlay() method and removed using the GMap2.removeOverlay() method. (Note that the info window is added by default to the map.)
GPolyline objects use the vector drawing capabilities of the browser, if available. In Internet Explorer, Google Maps uses VML (see XHTML and VML) to draw polylines; in other browsers SVG is used if available. In all other circumstances, we request an image of the line from Google servers and overlay that image on the map, refreshing the image as necessary as the map is zoomed and dragged around.
These scripts interact with Google applications such as Google Spreadsheets, Google Finance, and Google Sites, and enable varying degrees of interactivity among the applications. Google Apps Scripts is powerful and flexible enough to be used to accomplish a wide range of different tasks, but it’s also easy enough to use that you don’t have to be a programmer to create scripts.
Scripts are saved and run from an associated Google Spreadsheet. You can save as many scripts as you want to a particular Spreadsheet, then run them at will. The data your script works with is typically stored in a Google Spreadsheet, but you can retrieve information from many external sources, including web pages and XML sources. You can use Google Apps Script to create email, spreadsheets, pages on Google Sites, and files in the Google Docs Document List.
The instructions in a script are grouped into functions. Each function performs a section of the larger task your script accomplishes. For example, if you write a script to manage your budget, the first function might display custom menus in the Spreadsheet and the second might pop up a dialog box that you use to insert additional information into the Spreadsheet.
Google Apps Script provides a robust API (Applications Programming Interface) of objects and methods that you use in your scripts for such tasks such as displaying a dialog box, creating a calendar event, creating a page on a Google Site, and many other activities. The Google Apps Script API document is here.
This code defines a variable (named map) and assigns that variable to a new Map object, also passing in options defined within the myOptions object literal. These options will be used to initialize the map’s properties. The function Map() is known as a constructor and its definition is shown below:
While an HTML page renders, the document object model (DOM) is built out, and any external images and scripts are received and incorporated into the document object. To ensure that the map is placed on the page after the page has fully loaded, the function, which constructs the Map object once the <body> element of the HTML page receives an onload event, is executed. Doing so avoids unpredictable behavior and gives the user more control on how and when the map draws.
The maps on Google Maps contain UI(User Interaction) elements for allowing user interaction through the map. These elements are known as controls and variations of these controls can be included in a Google Maps API application.
The Maps API provides built-in controls which may be useful when creating a map:
The Navigation control displays a large pan/zoom control as used on Google Maps. This control appears by default in the top left corner of the map.
The Scale control displays a map scale element. This control is not enabled by default.
The MapType control lets the user toggle between map types (such as ROADMAP and SATELLITE). This control appears by default in the top right corner of the map.
controls cannot be accessed or modified directly. Instead, the map’s MapOptions fields, which affect the visibility and presentation of controls, is changed.
can be calculated by using the DirectionsService object. This object communicates with the Google Maps API Directions Service which receives direction requests and returns computed results. The user may either handle these directions results himself or use the DirectionsRenderer object to render these results.
Directions may specify origins and destinations either as text strings (e.g. “Chicago, IL” or “Darwin, NSW, Australia”) or as LatLng values. The Directions service can return multi-part directions using a series of waypoints. Directions are displayed as a polyline drawing the route on a map, or additionally as a series of textual description within a <div> element (e.g. “Turn right onto the Williamsburg Bridge ramp”).
The Elevation service provides elevation data for locations on the surface of the earth, including depth locations on the ocean floor (which return negative values). If Google does not know the exact elevation value, it uses four nearest locations and returns the avareged value.
The ElevationService object provides you with a simple interface to query locations on the earth for elevation data. Additionally, you may request sampled elevation data along paths, allowing you to calculate the equidistant elevation changes along routes. The ElevationService object communicates with the Google Maps API Elevation Service which receives elevation requests and returns elevation data.
The SDK includes two SWC files, a Flex version for use within FlexBuilder (or with the free Flex SDK), and a non-Flex version for use within Flash CS3. The Flex *.swc is denoted with a _flex suffix in the filename.
These SWC files contain interfaces for all public classes in the Google Maps API for Flash development environment. Compiling your application with this library ensures that it can utilize and communicate with all public functionality of the runtime Google Maps API for Flash library, which is retrieved from Google’s servers whenever a client loads your application.