Google Geo Developers Blog

Geolocation, Mobile Web Apps, Geo-Autocomplete, Geohashing, and more from GeoMeme

2009-11-23T06:47:00.000-08:00

Guest post by Bob Hitching, Director of Technology for Xumii, recently acquired by Myriad (Myriad Group AG), Europe's largest mobile technology company with software in over 2 billion phones.Bob also writes about mobile + geo + social on his blog and tweets as @hitching.

GeoMeme is a pet project of mine. It's a web app, and also a mobile web app for iPhone and Android, that measures real-time local twitter trends to work out what's happening where.

Visitors to GeoMeme choose a location on the map, and two search terms to compare. GeoMeme then measures and compares the number of matching tweets within the bounds of the map. Tweets are located using Twitter's brand new geotagging feature, and public data from a number of mobile twitter apps.

As an example, GeoMeme can work out that 'love' beats 'hate' in New York:

GeoMeme is packed full of geo goodness, and I am excited to share some details on how it all works in the following articles. I hope these are useful to those of you building your own geo apps.

Location-aware mobile web apps using Google Maps v3 + geolocation

This article explains how location-aware mobile web apps such as GeoMeme Mobile are now becoming a viable alternative to native mobile apps for iPhone &/or Android.

Also covered is how to combine various geolocation techniques to work out where on earth a mobile phone is located, and how to dynamically retrieve content local to the user for display on a mobile map.

Sample code is provided in the form of a 'Here I Am' location-aware mobile web app that combines geolocation techniques, and retrieves local photos from Panoramio for sharing on Twitter or Facebook.

Fast map re-location using Google Static Maps v2 + geocoder

As well as offering users the normal pan and zoom controls to move the map around, GeoMeme also adds an innovative geo-autocomplete control which provides a refreshingly quick way for users to re-position the map anywhere on the planet.

This article explains how the geo-autocomplete control uses the geocoder service from Google Maps v3 API to match location names as they are being typed, and then the new Static Maps v2 API to present the results as a menu of map thumbnails to choose from.

Sample code is provided in the form of a jQuery plugin for you to build your own geo-autocomplete controls.

Scalable, fast, accurate geo apps using Google App Engine + geohash + faultline correction

GeoMeme generates a large amount of geo-data, and so arises a need shared by many geo apps: scalable, fast, and accurate spatial queries, to select a subset of geo-data for display as markers on a map.

This article is all about using Google App Engine to host scalable and fast geo apps, and using an optimised version of the geohash algorithm to perform your spatial queries.

There's a fun demo showing the effect of geohash faultlines, and the relative accuracy of spatial queries with or without faultline correction

Sample code is provided as a python module to handle faultline-friendly geo search, if you want to use this technique on your own geo apps.

Finding mashups: Needle in a haystack?

2009-11-19T13:11:00.000-08:00

Over the last four years, developers have created hundreds of thousands of mashups that use the various Maps APIs. These range from practical and useful to fun and bizarre. With so many API sites out there, how do you find one about a specific topic and place, say "wine shops in New York City"? Or how would the developer of this mashup get his site in front of users looking for something to do in New York?

You may have noticed that user-created "My Maps" are shown on Google Maps when searching or looking at a specific place. Similarly, we think that there are many Google Maps API sites that would be very interesting to users searching on Google Maps. So we've been working on a way to expose relevant Maps API sites on Google Maps. In order to do this well, we need to know the location and content of the markers and/or infowindows that are displayed on these mashups. In a few weeks, we will turn on new functionality that helps Google to log this information from mashups that are using the JavaScript Maps API v2. We'll announce the exact date as we get closer but we wanted to provide an early look into our plans.

We realize that some of your markers or infowindows may contain information that you don't want us to display in search results or on Google Maps. Your content may be personal in nature or perhaps you don't have the necessary rights to allow indexing of the content you are displaying. Maps API Premier customers in particular may not want their content indexed and displayed in Google Maps. To ensure that this new feature doesn't cause any issues, we have put a few controls in place:

We only index data from maps that have been viewed by many unique users. For example, maps only viewed by you and a few friends won't be indexed.
If your page is protected by robots.txt, we will not index your content.
You can opt-out of the logging by specifying "indexing=false" when loading the API For example:
```
http://maps.google.com/maps?file=api&v=2&key=abcdefg&sensor=true&indexing=false
```
If you are a Maps API Premier customer, we will not index data from your maps, unless you opt into indexing by passing in "indexing=true".

We're excited about letting users easily find the wonderful mashups developers have created. As always, if you have any feedback for us, please use the Maps API Google Group.

Mickey Kataria, Product Manager

Mapsicle 1.0: Annotating Street View Panoramas

2009-11-16T22:44:00.000-08:00

Hi, I'm John Clegg of ProjectX. We build a range of map applications such as journeyplanners and addressing tools in Wellington, New Zealand. We have been working on a library to add more functionality to Street View called Mapsicle.

Ever since the release of Google Street View in 2007, we have been thinking about how we could enhance it. It wasn't until Street View arrived in New Zealand in December 2008 that we finally decided to build a prototype called Mapsicle (Maps meets Popsicle).

The prototype showed how you could easily overlay content such as markers and InfoWindows onto Street View. We showed Mapsicle to a few people including the Google Maps API team who were excited about what it could do. We asked Google if we could submit Mapsicle into the Maps Util library to ensure that we accelerate the development of Street View as a maps application platform. After a couple of months of testing and bug fixing, we are happy to announce that Mapsicle v1.0 is now live.

What can Mapsicle do ?

Using Mapsicle library, you can do a lot of interesting things:

Create and show markers at various locations on Street View such as Disneyland Paris

Show markers that are outside of the field of view such as the NZ flag marker above.

Create InfoWindows at locations.

Getting Started

To try it out yourself, read through the developer's guide and reference, and check out the examples that show how to implement custom infowindows, markers, and map integration.

The world of possibilities

Now that Street View is being extended via the Street View partner program, Mapsicle could be used to create a whole range of maps applications…

Advanced Store locators: Create store locators that show exactly how to get to your store from the user's current location.
Interactive tours: Combine Street View with content to give tours of the streets of the world.
Digital signage: Create interactive advertising on Street View using video and images.
Interactive kiosk: Build a touch screen information kiosk for visitors.
Games: Build a treasure hunt application or a racing game to drive around Thunderhill raceway.

As one example of the possibilities, we created a fun little mashup called StreetTag.

Thanks to the team

Kudos to the entire team at ProjectX, in particular:

Stephen Davis, who created and named the Mapsicle prototype.
Cameron Prebble, who has been working on building lots of demos and the front end experience.
Thong Kuah, for managing the project and pushing us to open source.
Raja Bhadhury, who has been helping us test and refine Mapsicle over the last few months.

We've had a lot of fun building Mapsicle and we're really excited to see what cool things geo developers are going to do with it. We'd love your help to build out Mapsicle and add more features. You can contribute to the project by joining the Google Maps API Utility Library, and you can let us know how you're using the library by posting in the forum. Enjoy!

Hackathons in NYC and Mountain View

2009-11-03T23:00:00.000-08:00

We're really excited to announce two upcoming hackathons for our Google Geo APIs. The first will be held in New York City on November 20th followed by a second one in Mountain View on December 15th. This will be a great learning opportunity for any developer interested or currently involved in building Geo-enabled applications using our APIs. Come join us for a great session where you'll be able to hack away on your own projects alongside our engineers who'll be readily available to provide support. Below is a list of the various Google Geo APIs you'll learn about:

Registration for these events are completely free, and space is limited. Reserve your spot now using the following links below!

Bring your laptops, your brains, and we'll see you soon!

Directions in the Maps API v3: Where will you go from here?

2009-10-29T17:02:00.001-07:00

One of the primary uses of a map has always been to figure out how to get from point A to point B. Until now the only way users of our Maps API v3 could put directions on their map was to draw a straight polyline and tell people to fly. Well, fret no more: we've just released Directions in v3, and rather than just porting it over from v2, we've given it a complete makeover and hope you'll like the new look.

So, what does the new Directions interface look like? We've split the GDirections object from v2 into two separate classes that work together to give you routing goodness. DirectionsService passes directions queries to our server and returns the results in JSON format, while DirectionsRenderer displays the results on your map. The 'load' event from v2 has been removed; instead, a callback function containing your rendering code is passed to the DirectionsService when making a new query.

We've also introduced a couple of options for specifing the kind of results that you want returned from our server. If there's more than one way to get from A to B, you can opt to retrieve all of them with provideTripAlternatives, and if the imperial system offends you, just tell the DirectionsService that you always want metric units returned by using unitSystem. Here's a code snippet that adds directions to a map and step-by-step instructions to an accompanying panel, as well as specifying both of the new options:

 
var map = new google.maps.Map(document.getElementById("map_canvas"), {
  zoom: 7,
  mapTypeId: google.maps.MapTypeId.ROADMAP,
  center: new google.maps.LatLng(-33.868011, 151207566)
});
 
var directionsRenderer = new google.maps.DirectionsRenderer();
directionsRenderer.setMap(map);    
directionsRenderer.setPanel(document.getElementById('directionsPanel'));
 
var directionsService = new google.maps.DirectionsService();
var request = {
  origin: "Sydney, NSW", 
  destination: "Chatswood, NSW",
  travelMode: google.maps.DirectionsTravelMode.DRIVING,
  unitSystem: google.maps.DirectionsUnitSystem.METRIC,
  provideTripAlternatives: true
};
directionsService.route(request, function(response, status) {
  if (status == google.maps.DirectionsStatus.OK) {
    directionsRenderer.setDirections(response);
  } else {
    alert('Error: ' + status);
  }
});

You'll get something that looks like this:

To get started, take a look at the reference and an explanation of the concepts involved, as well as the examples. As always, tell us if you have any questions or comments. We may not choose the most interesting route for you to travel on, but you can rest assured that if you ever want to drive from Seattle to Honolulu, we'll...draw a straight polyline and tell you to kayak*.

Bon voyage!

* because we don't know if your car is watertight.

Posted by Jennifer Chye, Maps API team

Our Favorites: Driving, Sailing, Running, and Landing on the Moon!

2009-10-19T17:30:00.000-07:00

Just like Ricky Bobby, I like going fast. Most of the time, though, going too fast in real life can be dangerous. That's why I also enjoy playing driving games and simulators—all from the comfort and safety of my own home!

The great thing is, thanks to the Earth API and Maps API for Flash, developers have built a flurry of simulator applications that are visually stunning, geographically realistic, and highly addictive. Below are some of my favorite simulators for driving, sailing, running, and even landing on the moon!

WARNING: I will not be held liable for any lost productivity resulting from these awesome apps!

	Ships Considered by most to be in the list of top Earth API apps, Ships is a highly polished simulator by New Zealand-based Dinther Product Design for a variety of sea vessels (and a blimp!). The visual effects (i.e. the ship's wake using animated ground overlays), camera angles, and detailed screen overlay-based dials make Ships an exceptionally fun and immersive simulator. Primary API: Earth API
	Race My Race Although I don't have the endurance to run a marathon, I can still check out various marathon routes with the help of Race My Race! This app is a really fun way to explore the terrain along these difficult routes. And, if you're planning on running a marathon in the near future, this site can even help you prepare! Primary API: Earth API
	Sea-Seek Virtual Dive Ever want to explore the world's great bodies of water? Sea-Seek's Virtual Dive is perfect for just that! This app lets you commandeer a variety of air, ocean surface, and underwater vessels along coastlines and even in the deep blue sea! My favorite vessel is the 'Shark Sub,' equipped with a headlamp model. Primary API: Earth API
	Geoquake - Driving Simulator on Google Maps (Perspective) The original, 2D version of this simulator was very impressive—it allowed you to drive a car or truck in a city of your choosing in a Grand Theft Auto-like perspective. This version, however, one-ups the original by utilizing the new 3D perspective in the Maps API for Flash with a 3D car model for a more realistic feel. A great game from a great developer in Japan! Primary API: Maps API for Flash
	Apollo 11 Moon Lander Another gem from Dinther Product Design, this challenging, but very fun, minigame lets you attempt to land the Apollo 11 Moon Lander. I personally have never been able to land without crashing, but a few of my coworkers had no problem finishing with a successful 'Eagle Touchdown.' To them, I say: apply to NASA! Primary API: Earth API
	Gaiagi Driver This is a super-mashup of a number of Google and non-Google APIs, allowing you to visualize—in every way imaginable—the driving route between two addresses. The demo really shows off what's possible with today's geo platforms. Very exciting stuff! Primary API: Various

I hope you enjoyed trying out these simulators; maybe a few of you were inspired to write your own simulation apps! I bet we'll be seeing more and more of these types of apps in the future. 'Til next time, thanks for reading and drive safely!

Posted by Roman Nurik, Geo APIs Team

Maps API v3 Now Speaks Your Language

2009-10-13T17:07:00.000-07:00

Good morning! G'day! Bom dia! Bonjour! доброе утро! 早安! നമസ്കാരമ്! доброго ранку!

This is how we, members of the Maps API team, would salute each other if we decided to use our native languages in the mornings. And those are just a minuscule sample of the multitude of the native languages for Googlers all over the world.

But this is only one of the reasons we are so passionate about translating our products to as many languages as possible. Our mission is to organize the world's information and make it universally accessible and useful. Providing our services in the native tongue of our users goes a long way towards achieving the universal accessibility and usefulness aspects of our mission.

Today, we are proud to announce that the Maps API v3 is now available in 40 languages, in addition to US English. You can find the list of languages here. (Right to left languages are notably missing from this list, as we still have some work to do before we can support them.)

Most developers won't need to do anything to take advantage of the new translations, our servers will decide what language to provide based on the browser's preferred languages settings.

Developers can override that behavior (and force all of their users to see one language) by specifying a parameter in the script tag. For instance, to force UI controls to always be displayed in Brazilian Portuguese, use:

  <script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=false&language=pt-BR">

Map tiles may also vary slightly according to where in the world you or the bulk of your audience is. You may also want to bias geocoding results towards a specific region. "Newcastle", for instance, will geocode to different locations depending on whether you are more interested in American, British or Australian places.

Again, you can override the region biasing by specifying a parameter in the script tag. For instance, to bias your application towards British results, use:

  <script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=false®ion=GB">

For more in-depth information about localization of Google Maps API v3 maps, please refer to the documentation. As always, you can send feedback and questions via the forum.

Posted by Marcelo Camelo, Maps API team

Our Favorites: History!

2009-10-12T11:56:00.000-07:00

Most people here know me for being a geo geek, working on Maps and Earth. But many of you don't know that my first love was history. I got my first Master's in history before pursuing a career in tech. And since much of my early studies of history had to do with maps, whenever I find a historical map I get really excited. Pamela's post on Time-Based Maps shows some of the power of Maps mashups. But history, despite what you may have learned in high school, isn't just about dates. So I selected a few of my favorite historical data visualizations to show you here.
	AfricaMap This is an amazing map, which allows you to view a ton of different data. It includes layers for ethnographic surveys from different years, language differences, economic data points, historic maps of Africa layered on using GTileOverlay, and much more. And best of all, you can add more than one layer at once.
	The Diary of Samuel Pepys Samuel Pepys was a 17th Century British Member of Parliament and naval administrator, in London. He left a rich diary about an important time in British history and his participation in it. The diary is being gradually released as daily blog, and there's an accompanying map of important places in the diary. There's a nice implementation of custom infowindows. And in the Encyclopedia many of the entries have maps.
	LookBack Maps LookBack Maps puts historic photos onto a map. It allows users to add photos and geolocate them. When you click on a marker, you get the photo and some data about it. If you click on details, it takes you to a page that has a StreetView of the photo's location. It's a nice mashup of how things are now and how they were.
	Google Lit Trips This site has KML files that give insights into cultural history. The trips aim to show that "...literature can act as a kind of map and has a profound effect on the ways in which a culture imagines its place in the known world." From a map of the locations in James Joyce's Portrait of the Artist as a Young Man, to a map of Virgil's Aeneid, these trips provide interesting perspectives to a reader often less familiar with the part of the world referenced in the work.
	Global Paleogeographic Views Valery Hronusov created this great view of the movement of continents in Google Earth by putting TimeSpan elements in KML GroundOverlays. This one has been around for awhile, but shows both Valery's creativity and the power of using time in KML.

Geography is such an important part of history. There has been a lot of great work done with Google's Geo APIs, and I think there's room for much more. If you're interested in more historical sites, check out the history maps label on Google Maps Mania.

Posted by Mano Marks, Geo APIs Team

Map data updates for the United States

2009-10-07T09:10:00.000-07:00

As you may have seen on the Lat Long blog today, we've made some significant changes to the map data for the United States. We're excited to bring new features and functionality to Google Maps, including comprehensive parcel data, more detailed natural features like parks and water bodies, and new base map data types like bike paths and university campus maps. These updates have improved our geocoding accuracy as well as our imagery/data alignment, and we'll be making even more improvements going forward.

How does this update impact developers? First, you can use the new "Report a Problem" link on maps to communicate directly with Google about any updates or corrections that you think need to be made to our maps. Second, the data that powers API features like geocoding and driving directions has also been updated. If you're using client-side geocoding in the browser, your applications will automatically start using the new data. If you've been using the HTTP geocoder and caching any retrieved data, you should re-geocode with the new data as soon as possible. With the "Report a Problem" feature, we'll be updating the map data regularly, so we recommend that you continue to refresh any cached data in order to take advantage of corrections from our users.

As always, if you have any questions or feedback about how this change affects your use of the API, you should post to the relevant forum:

We're excited about the changes we're making today! For those of you overlaying data and creating Google Maps applications for the United States, we hope that the underlying base map will continue to evolve, just like the amazing mapping tools that you are maintaining.

Posted by Michael Weiss-Malik, Software Engineer

Increase your AdSense revenue with Maps Ad Unit and GoogleBar

2009-10-05T22:44:00.000-07:00

Since we launched AdSense for Maps many developers have shared their experiences with monetizing their Google Maps API implementations. Here is a detailed, first hand account from one developer..

Hi, I'm Martin Fröhlich from Maplandia, a world gazetteer based on Google Maps. I'm delighted to share our experience with recently launched monetization tools available through the Google Maps API. We have been successfully using traditional AdSense to monetize our traffic for some time, so we were happy when the Geo Developers Blog announced two new ways how to generate revenue designed purely for Maps.

Maps Ad Unit

There are some significant advantages of Maps Ad Unit in comparison to classic ad units: the relevance of ads is determined not only by the content of the page but also from what is currently shown on the map itself. The other advantage is that the ads are updated (re-targeted) each time a user moves or zooms the map, so they are always tailored to what is viewed on the map.

These two reasons lead to more relevant ads. From the entrepreneurial point of view, this leads to more revenue which is very important to us. We have experienced a 35% increase in our daily revenue from AdSense For Content (This number stands for the portion of total revenue generated by our Maps Ad Unit channel, calculated for the last two months since we implemented the Maps Ad Unit). We didn't notice any decline in the revenue from other AdSense ads placed on the page, so this is really pure increase of profit. The only drawback was that we had to remove GOverviewMapControl (which I always liked) due to the ads. However, this is not necessary if you decide to place ads in other than bottom right corner.

Finally, the implementation is really simple, consisting of adding these few lines to your code:

var publisher_id = yourPublisherID;

var adsManagerOptions = {
 maxAdsOnMap : 2,
 style: 'adunit',
 // The channel field is optional - replace this field with a channel number
 // for Google AdSense tracking
 channel: 'your_channel_id' 
};

adsManager = new GAdsManager(map, publisher_id, adsManagerOptions);
adsManager.enable();

GoogleBar

GoogleBar was introduced back in 2007, but only the latest update made it possible to monetize this search experience. We have a lot of visitors looking for many different places all over the world. Unfortunately, there are (and always will be) some places we can't provide any information on, so this is why I find GoogleBar with its local search functionality to be a very useful tool for our users. Advertising revenue from GoogleBar is a nice bonus: adding GoogleBar to our maps more than doubled our daily revenue from AdSense for Search (which we used with Google Custom Search Engine already).

On Maplandia we have been using both these features together for more than two months now. So far, the results are impressive. There are plenty of mashups with much less non-map content than we tend to have. I sincerely believe that those of you with these types of sites can easily beat our AdSense revenue increase numbers. I highly recommend trying Adsense For Maps, if you haven't done so yet. Good luck and happy coding!

Posted by Mike Pegg, Marketing Manager - Google Geo APIs

Polys in the Maps API v3: Now with Level of Detail & Holes!

2009-09-29T18:53:00.000-07:00

We've just added Polylines and Polygons to Maps API v3. These allow you to draw lines or filled regions on the map, specify stroke and fill styles, and handle events. They work in all supported browsers.

We've also made a few improvements from Polylines and Polygons in Maps API v2.

You can send in multiple paths for one Polygon, and use that to render holes inside your poly, like in this Pentagon example.
When you give us a set of vertices, we assign a level of detail to each vertex, showing only the necessary amount of vertices per zoom level. This is how we show complex routes in driving directions on Google Maps, and now you can benefit from that optimization with no extra work. Zoom in on the fractal snowflake poly example to see how it looks.

Adding a polyline or polygon to a map is easy, as shown in this snippet from the documentation:

 
  var flightPlanCoordinates = [
    new google.maps.LatLng(37.772323, -122.214897),
    new google.maps.LatLng(21.291982, -157.821856),
    new google.maps.LatLng(-18.142599, 178.431),
    new google.maps.LatLng(-27.46758, 153.027892)
  ];
  var flightPath = new google.maps.Polyline({
    path: flightPlanCoordinates,
    strokeColor: "#FF0000",
    strokeOpacity: 1.0,
    strokeWeight: 2
  });
  flightPath.setMap(map);

We wanted to launch early and get feedback, so there are still some features to come:

Support for the 'mouseover' event
Further rendering optimizations
Built-in editing like in Google My Maps

That said, here's a simple demo of polygon editing to show what you can do.

As always, please provide feedback in the Google Maps JS API v3 Group.

Posted by Ben Appleton, Maps API team

Displaying the World's Information: New Articles for KML

2009-09-21T13:30:00.000-07:00

KML is the most common data format for displaying geographic information, with over half a billion KML files on the web. However, much of the world's geographic information is also in other file types, particularly shapefiles, and image data. Fortunately, there's an open source utility library that helps developers work with all sort of Geographic file types, the Geospatial Data Abstraction Library. We've taken just two of the utilities in GDAL, and wrote articles about them.

Converting GIS Vector Data to KML: This tutorial walks you through the basics of converting GIS vector data to KML using the OGR open source library.

Creating super-overlays with gdal2tiles: This tutorial walks you through the basics of creating a super-overlay, a set of ground overlays that use region-based NetworkLinks, using the open source gdal2tiles utility.

And of course, if you want to learn more about these utilites or other Google Geo APIs, come to our San Francisco hackathon!

Posted by Mano Marks, Geo APIs team

SnapshotControl 1.0: Using the Static Maps API to Snapshot Your Maps

2009-09-20T00:30:00.000-07:00

Hi everyone, my name is Masashi Katsumata. I'm a Maps API expert in Japan. I love playing around with the Maps APIs, and I share everything I learn on my website for Japanese speaking developers. But don't worry, English speakers - I also like to create open-source extensions for the utility library, and share them with you here.

Today, I'm annoucing my newest contribution: SnapshotControl. This control makes it easy to generate an image "snapshot" of your interactive map, using the recently released Google Static Maps API v2.

The default behavior of the control is to add a button on the map, and that button pops up a snapshot when clicked. However, the control can be hidden and the generated snapshot URLs can be programmatically retrieved, so that the library may be used in a more flexible manner. Check out this demo to play with different options and see the generated URL.

This control also knows how to encode polylines, using the Douglas-Peucker algorithm, which means that it can be used on maps with very long paths. For example, the control can create static maps for driving direction routes, as shown in the this demo.

To learn more about this control, check out the reference and more examples. Enjoy!

Posted by Masashi Katsumata, Community Developer

Our Favorites: Get Outdoors!

2009-09-16T20:26:00.001-07:00

As a Googler, I spend most of my weekdays behind the keyboard and mouse, so I like to recharge on the weekends by getting outdoors to enjoy the best that Northern California has to offer. Let me introduce myself: I'm Billy Rutledge, a manager, tech-lead and advocate for Google Developer Relations. As part of the "Our Favorites" blog series, I want to highlight a few web sites that have done a great job implementing the Google Maps APIs to help people like you and me spend more time under the sun.
	WikiLoc This site uses the JavaScript Maps API to let users upload and share GPS tracks. It embeds the Panoramio GLayer to let users see photos near their waypoints, and also displays an altitude chart for your track. It also supports input/export of common GPS file formats. They offer a native mobile phone app that captures GPS points and uploads the data to the site for you. Additionally, they let you create your own tracks by placing points on the map and rendering them as polylines.
	GPSies - Tracks for Vagabonds GPSies - Tracks for Vagabonds Another site for managing GPS tracks, which works great with free, native mobile applications for Android and iPhone devices. The mobile apps are simple and easy to use, helping you monitor and save your tracks, and then upload them over the air to GPSies where they are visible in your tracks list. The visualization is a robust JavaScript Maps API implementation that overlays a polyline across the GPS points. Nice additions include mile marker points (also in metric), integrated altitude charts that follow the polyline with mouse-move events, and integration of the DragZoomControl for easier zooming into an area of interest.
	Trailspotting.com This outdoor site boasts an outstanding collection of hiking trails in Northern California and Hawaii. In-depth reviews, photos and comments are coupled with Google My Maps for visualization. Stuart and Jenna, the outdoor enthusiasts who run this terrific site, go the extra mile to include enhanced content like area facts, photography, nearby POI, and location web sites.
	Topo! Explorer I bought the 10 CD set of Topo! from NatGeo years ago and really enjoyed browsing/zooming into locations, then printing my own weatherproof map before embarking on an expedition. Today, they've made this much easier. A free registration gets you access to browse the latest Topo! maps which uses our JavaScript Maps API as a framework to explore their custom map tiles.
These are just a few of the many great sites devoted to finding that perfect place to get some fresh air. I look forward to uncovering new sites in the future, as developers are always finding innovative ways to integrate the Maps APIs and outdoor exploration! Billy Rutledge - Google Developer Relations

Introducing ContextMenuControl 1.0: Give Your Users the Power of Right-Click

2009-09-14T20:00:00.000-07:00

My name is Wolfgang Pichler. I have been developing with the Google Maps JS API for a few years now, posting in the forums and publishing my various experiments for others to learn from.

When a user right-clicks on Google Maps, a context menu appears with options like getting directions, zooming in, or finding the address of the center point (reverse geocoding). Since I wanted this helpful feature in my own maps, and the core API does not provide it, I decided to implement a fully open-source version and release it in the utility library: ContextMenuControl.

This control includes all the same items as the native Google Maps control, but I've implemented the directions functionality in a different way. Instead of requiring the developer to provide a panel and inserting the directions steps there, I create infowindows that the user can step through. Now, any developer can use this control and not worry about having to allocate space on their page for the directions steps. The directions functionality also includes the ability to add, remove, and drag points, so that the user can easily customize their query.

The result is a control that's easy for users and easy for developers, and is probably the fastest way to add reverse geocoding and directions functionality to your map (especially if it's a small map). Just include the script tag for the source code, insert this line in your map init function, and you'll get a right-click menu like the screenshot shows below:

  map.addControl(new ContextMenuControl());

For more information, read through the reference and developer's guide. For other open-source extensions that can enhance your mashup, check out the utility library. Enjoy giving your users the power of right-click!

Posted by Wolfgang Pichler, Community Developer

San Francisco Geo APIs Hackathon on September 24th

2009-09-09T13:45:00.000-07:00

Calling all Bay Area coders! We've just finalized another hackathon for late September! On September 24th, 2009, from 1:30 to 8, Google will host a hackathon for our Geo APIs in our San Francisco office. At the hackathon, Google engineers will give one or two API overview presentations and then will be on hand to answer all your geo related questions. You can work on suggested codelabs, or just bring your own project and we'll lend you a hand.

The hackathon will cover the following APIs:

The Google Maps API for JavaScript V2 and V3
The Google Maps API for Flash
The Google Earth API
KML
The Google Maps Data API

Space is limited, so register now! And remember, this will be a code-heavy event, so bring your laptop and come ready to code!

Posted by Roman Nurik, Geo APIs team

Our Favorites: Time-Based Maps

2009-09-03T07:30:00.000-07:00

Obviously, we love when we see developers using the Maps API to create sophisticated and innovative applications. It makes us feel good that we put time into creating our APIs, and it excites us that there are so many creative developers in the world. But, we don't always wear our heart on our sleeve, and share our love for great uses of the APIs with everyone. So, we're initiating a series of blog posts about our favorite maps, and this is the first in the lot. We'll also use this series as a way to introduce you to other members of our ever expanding team here. You likely already know me, as I'm something of a regular on this blog - getting started 3 years ago with a post showing how to use the then-just-introduced GPolygon (man, that makes me feel old). So, I'll go straight into my favorites.

I was once asked what I thought the next frontier in maps mashups was, and I responded: "time". Why? It's tricky figuring out how to display layers of data on top of a map, but it's even trickier to squeeze in one more dimension and display time-based data, and I admire those developers that take on the challenge. Here are some examples:

	NYC Homicides Map Displays 10 years of homicide data in New York City, including as recent as the last 2 weeks (eerie!). They give users a slider to quickly slide through the years and see how the density changes, and also give them different options for coloring the data. It's a great, simple combination of two different ways of visualizing data.
	RozTracker Shows the voyage of a woman that's in the middle of rowing across the Pacific. The user can see how many oar strokes she's done, and zoom in to see her tweets, blog posts, and videos from the voyage so far.
	WW2 TimeMap Displays WW2 events using TimeMap, the open-source project combining the SIMILE Timeline with the Google Maps API. It's a rich timeline that's able to show long-running events as well as single-time events, and deals with overlapping events. It means that the developer can open the map up to user contributions, and not worry about the usability of the interface being compromised.
	Manhattan Map Shows what Manhattan looked like hundreds of years ago (a whole lot greener), and gives the user a slider to change the transparency of the 1609 imagery, giving the illusion of the modern-day landscape fading in. The user can also hover over individual city blocks for information on what that block was like back then.
	TimeSpace Clusters the top news stories on the map, and gives the user a time slider to pan through the day's events. The graph underlaid beneath the slider shows how the news density varies during the day, and a search box lets the user filter the news displayed. It's a much more fun way to browse the news, and a good way to encourage readers to be interested in news all over the world.

As you can see, there are a lot of ways to show time-based data on maps, and each of them suit different needs. The important thing is that developers are pushing the envelope and experimenting with different interfaces, and putting it out there for all of us to enjoy. For more examples like these, check out the "Timeline" label in the Google Maps Mania directory. Tune in next week to hear about more of our favorites! :)

Posted by Pamela Fox, Developer Relations

New Articles: Powering Maps API v3 Apps with MySQL

2009-09-01T20:00:00.000-07:00

The Google Maps API v3, our new lightweight version of the JavaScript API, has been out for a few months now, and we want to help developers use this API with server-side scripting and databases. So, we've added an articles section to the documentation with three new articles:

"Creating a Mobile Store Locator" shows how to query a database for stores near a user's location, and how to present that in a nice mobile-friendly webpage.
"Using PHP/MySQL with Google Maps" shows how to pull data from a SQL database as XML and display that on the map.
"From InfoWindows to a Database: Saving User-Added Form Data" shows you how to enable users to add geo-tagged information to a database via your map application.

We've also added links to articles from developer Gabriel Svennerberg, who has started a series on Maps API v3 and is in the process of writing a book.

If you have written an article about using any of our APIs, please let us know using this form. We love to see developers adding knowledge to the community.

Posted by Pamela Fox, Maps API Team

New Earth API Developer's Guide and DOM Articles

2009-08-31T20:00:00.000-07:00

Hey Earth API developers, have you visited the Developer's Guide recently? If not, you're missing out on some great new content and sample code! We've recently revamped the Developer's Guide in some very big ways:

Sections are now organized by topic, as opposed to level of difficulty
Older topics such as balloons and events have been revisited and rewritten; important concepts are covered in more depth and some subtleties have been formally addressed. Some older, but very important, topics such as object containers now get their own full sections of the documentation.
New topics such as tour playback, Sky/Mars/Moon, and general JavaScript debugging tips are now discussed in detail in the new Developer's Guide. Previously, the only available resources for some of these topics were sample code and the API reference.

A special thanks goes out to Michael Jeffrey on the Earth API team for writing the new Developer's Guide. Thanks Mike!

Once you're done checking out the new Developer's Guide, click over to the Articles section of the documentation to read two new Earth API articles that shed some more light on the KML Document Object Model in the Earth API:

DOM Part I: An Introduction to the Earth API Document Object Model This article provides an introduction to the W3C Document Object Model (DOM) specification and discusses the parallels between the Earth API's KML DOM access methods and web browsers' HTML DOM methods.
DOM Part II: Using the GEarthExtensions Utility Library for Easy DOM Manipulation In this article, we'll learn about the GEarthExtensions utility library's method of simplifying DOM traversals and how we can easily perform common DOM search and manipulation operations on entire KML document trees using this method.

The first article briefly discusses DOM concepts and motivations, while the second article jumps into code that uses the GEarthExtensions Earth API utility library to simplify common tasks in the Earth API.

I hope you all enjoy reading through the new articles and Developer's Guide! If you find any bugs, feel free to file them in the Earth API issue tracker or post to the discussion group.

Posted by Roman Nurik, Google Geo APIs Team

New Library Creates JavaScript Bridge to Google Maps API for Flash

2009-08-31T07:20:00.000-07:00

Hi,I am Nianwei Liu, a web developer located in Charlotte, North Carolina that enjoy workings with various flavors of theGoogle Maps APIs.

A few weeks ago, Google announced 3D/perspective capability in the Flash API. If you would like to try out this functionality, but you're not ready to fully commit to AS3 yet, you may find this open source library helpful: Map Bridge.

The concept is very simple: programing a flash component with JavaScript, similar to what you do with GStreetViewPanorama. This library exposes all core classes in the Flash API and packages them in an easy to use way. You can write a simple Map3D application like this:

 
var map;
function init() {
  MapBridge.createMap(document.getElementById('map_canvas'), function(mp, brg) {
    map = mp;
    map.addEventListener('mapevent_mappreinitialize', onMapPreinitialize);
    map.addEventListener('mapevent_mapready', onMapReady);
  });
}
            
function onMapPreinitialize(e) {
  var myMapOptions = new MapOptions({
    zoom: 12,
    center: new LatLng(40.756054, -73.986951),
    mapType: MapType.NORMAL_MAP_TYPE(),
    viewMode: View.VIEWMODE_PERSPECTIVE(),
    attitude: new Attitude(20, 30, 0)
  });
  map.setInitOptions(myMapOptions);
}
            
function onMapReady(e) {
  map.enableContinuousZoom();
  map.enableScrollWheelZoom();
  map.addControl(new NavigationControl());
  map.addControl(new MapTypeControl());
}

Here is an example that uses Map3D and driving directions for a fly-over.

For more information, check out more examples, how-to, and reference.

Posted by Nianwei Liu, Community Developer

One week left to submit abstracts to AGU!

2009-08-27T11:21:00.000-07:00

Guest post by Richard Treves, AGU Virtual Globes session co-convener

Every December, an astonishing 15,000 geoscientists gather in San Francisco for the American Geophysical Union's Fall Meeting. One of the best-attended sessions at the conference is the Virtual Globes session, returning for its fourth year (previous sessions 2006, 2007, 2008). It provides a forum for scientists, educators, developers, and GIS specialists to meet and discuss developments in the use of geobrowsers. Presenters in previous years included the authors of some of the most popular geoscience KML files on the web, as well as many well-known geo bloggers and industry developers. The session includes both talks and interactive demonstrations, with the latter involving large plasma screens, poster board displays and high-speed internet for each presenter.

This year's AGU Fall Meeting is December 14-18, and the deadline for submitting abstracts is September 3, which is coming up fast! We encourage all scientists, educators, developers, and GIS specialists to submit abstracts relating to uses of GeoWeb technologies for better scientific understanding, public outreach and education about our "real" world. The Virtual Globes session is even going to be webcast this year, which means that talks will reach more than just the live audience at the conference!

The Virtual Globes website has details of how to submit your abstract and links to more info on the rest of the AGU conference. Those interested in attending can register online. We'll post a full schedule of the Virtual Globes talks and demonstrations in mid-October.

Static Maps API v2: Encoded Paths, Polygons & Geocoding

2009-08-25T19:15:00.000-07:00

Two years ago, we announced the Static Maps API. This API allowed developers to generate images that represented maps with markers and paths, and to embed those images in webpages. Developers embraced this API as a way to put lightweight thumbnails on their site (like Glotter) and as a way to create non-Javascript versions of their websites (like LonelyPlanet and Orbitz), and they clamored for more features to extend the functionality of their sites.

Now, in order to support the top requested features and to make it easy to fulfill future requests, we've rewritten the API and are launching the new interface as Static Maps API v2. The main new features are:

Paths can be specified as encoded polylines. (Issue 205)
Paths can be filled and rendered as polygons. (Issue 792)
Locations (in center, markers, or path parameters) can now be specified as addresses instead of latitude/longitude coordinates.
Colors can now be specified as any 24-bit or 32-bit color.

To show off the new stuff (and my recent vacation in Japan), I've developed a Secret Treasures of Kyoto" mobile-friendly website. You can use it to visit a park where monkeys roam free in Arashiyama (using a filled path), to walk from our hotel to a restaurant with the most delicious deep fried roast beef sandwiches (using a path), or to stalk a creepy looking soft-shelled turtle (using a turtle-colored marker). Check out the iframed website below, or in your mobile browser:

All of the old features are supported in the new API but some of the URL parameters have changed, so if you're a developer that's already using the old API, please refer to the upgrade guide. (That also means that Static Maps v1 is being deprecated - but don't worry, there's plenty of time to upgrade).

If you're a developer that wants to take advantage of the new features, read through our developer guide. To play around with everything right now, try the new Static Maps v2 Wizard.

Posted by Pamela Fox, Maps API Team

Java Support and Docs for the Maps Data API

2009-08-21T00:01:00.000-07:00

Posted by Tom Manshreck and Bart Locanthi, Maps API Team

Back in May, we launched the Maps Data API, a programmatic way to interact with map data using Google's GData infrastructure. At the time, we offered a basic HTTP protocol and a Java library. The Java client library for the Maps Data API allows you to create robust Maps data applications without the need to manage raw HTTP requests. Instead, you can create an inherently more scalable application in Java, which handles all of the HTTP requests and responses for you. We're happy to announce that we've updated the Java client library to add better Maps Data support, and have published an accompanying Java Developer Guide to get you started. The sample code within the developer guide is also included within the sample code available within the gdata-java-client library. What did we add? In specific we added several helper methods which should make creating features easier:

The getFeatureFeed() method can now be used on a MapEntry object to return the URI of the map's feature feed directly, rather than requiring inspection of the map's associated feeds.
Creation of KML features has been augmented to not only work for features within KML files but provided as text strings. Simply call the FeatureEntry's setKml() method passing it the string.
The setKml() method also automatically sets the supplied KML to the appropriate mime-type and XML namespace.

The Javadoc reference contains full reference materials on all public methods in the API. We're actively adding more support to the Java client library and support for additional programming languages, so check back with us in the future. As always, check out the Maps Data API group to discuss the API and let us know what features you'd like to see added to it.

Upcoming Seattle Geo APIs Hackathon

2009-08-12T13:56:00.000-07:00

September 3rd, 2009, from 11 to 6, Google is hosting a hackathon for our Google Geo APIs in our Seattle offices. At the hackathon, you can code on our Google Geo APIs, with the guidance of Google Engineers. We'll provide you with suggested codelabs, or you can just work on your own projects. You can work on the following APIs: The Google Maps API for JavaScript V2and V3, the Google Maps API for Flash, the Google Earth API, KML, and the Google Maps Data API.

So bring your laptops, and your brains, and be prepared to code.

Space is limited, so register now!

GradientControl: Making Thematic Mapping Easier, One Gradient at a Time

2009-08-06T06:38:00.000-07:00

I'm Simon, and I work as a Site Reliability Engineer at Google. One of the benefits of working here is that I get to choose interesting 20% projects to work on. Recently, I worked with Project Vulcan at Purdue University to create a map that visualized greenhouse gas emissions. I chose to visualize that data by coloring countries depending on the values associated with them. This technique is called chloropleths, or thematic maps.

Google APIs made most of the map creation tasks quite easy, but fine-tuning thematic maps still required a lot of work. I wanted to load a dataset and make a single library call to calculate the color gradients, but at the same time I wanted to be able to express complex rules, like "draw all negative values with a red-yellow gradient, then draw the bottom 50% of the positive values with a yellow-orange gradient, and the rest with a orange-red gradient".

Developer Bjørn Sandvik created the great Thematic Mapping library using the Google Earth API and Google Visualization APIs in JavaScript, but while it supports a large number of thematic map types, it can only draw a gradient between two colors. So, to satisfy my needs for multi-colored gradients and more control, I wrote a library for the Maps API for Flash called GradientControl.

Here's a simple example of using GradientControl, with just a three-color gradient, from green to yellow to red:

You can drag the slider under the map to change the position of the middle color and immediately see the results. Click on a country to see the value associated with it. You can also try out a larger version of this example, with two middle colors and three sliders.

The color gradient configuration can be either constructed with Actionscript function calls, or moved into an external XML file. The complex example that I wanted to write would look like this:

<gradientRuleList> 
  <gradientRule> 
    <gradient> 
      <minColor>0x0000ff</maxColor> 
      <maxValue>0</minValue> 
    </gradient> 
   </gradientRule> 
   <gradientRule> 
     <gradientRuleList> 
       <gradientRule> 
         <gradient> 
           <minColor>0xff0000</minColor>     
           <maxColor>0xff8000</maxColor> 
           <maxPercent>50</maxPercent> 
         </gradient> 
       </gradientRule> 
       <gradientRule> 
         <gradient> 
           <minColor>0xffff00</minColor>
           <maxColor>0x00ff00</maxColor> 
         </gradient> 
      </gradientRule> 
    </gradientRuleList> 
  </gradientRule> 
 </gradientRuleList>

This is verbose, of course, but still much easier than writing custom code.

To get started using the library, check out the source, read the documentation, and post in the forum if you're having issues (or simply to show off what you've made). If you're interested in improving this control or making it work better with existing standards or APIs, please join the utility library forum. Enjoy!

Posted by Simon Ilyushchenko, Google Engineer