Tip:
Highlight text to annotate it
X
MANO MARKS: OK.
Hi.
I am Mano Marks.
I am a developer advocate on the Google Maps team.
This is Sean Maday.
SEAN MADAY: I'm Sean Maday.
I'm a geoengineer on the Enterprise team.
MANO MARKS: So it is our pleasure to
do the session today.
We're really happy to see you and everybody on live stream.
Hi.
So I want to talk a little bit of history here.
And some of you may have gone to the session yesterday--
What's New in Google Maps.
And Brian McClendon talked a little bit
about where we started.
And this is the first Google Maps.
This is Google Maps Beta in 2006.
And we started out with points and driving directions.
And it was a really revolutionary
interface at the time.
At the time, if you wanted a map, you had to go to a map
image, and if you wanted to zoom or pan, you had to click
and load a whole other image.
There probably would be a little
iframe that would refresh.
It would be like 10 seconds, because this was the
internet back then.
And what Google did was it looked at that and thought,
wouldn't it be fantastic if we could do a better experience--
a nicer, smoother experience that would not require this
sort of disengagement from the user.
And so we released what has now become a very standard way
to do maps online.
Google started this tile serving infrastructure using a
JavaScript interface, which allows you to dynamically move
and pan your maps and add things to it without having
these huge lag times--
an exploration of the map, of the world.
And we incorporated map tiles and satellite imagery all
around the world.
And it became this it sensation.
So much so that people, within days of seeing this, had
reverse-engineered it and told us, hey look, we can do really
amazing, cool things.
And so in 2006, we actually released the Google Maps API,
version 1, and asked developers to come with us on
this journey--
this journey of exploration of the world, of geospatially
organizing the world's information.
And they did.
You did.
If you're in this room, you probably have written a Maps
API application.
If you are a web developer, you have probably written a
Google Maps API application.
There are 800,000 active websites--
that's active websites--
using the Google Maps API right now.
800,000, and it continues to grow at a really huge rate.
So in 2006, we asked you to do this journey with us.
And now you have.
And we are now asking you to do it again.
Because, as Brian talked about yesterday, there are still
dragons at the edges of the map--
referencing old European maps, which used to say, here be
dragons at the outskirts of your map where
they didn't have data.
So we want you to join us on this journey
to get rid of dragons--
this adventure to get rid of dragons.
He actually called it dragon slaying.
We're going to slay some dragons.
So we want you to join us.
And we want you to do it the way we do it.
We want to make our infrastructure available to
you to serve out maps in the way that we did it--
learning the lessons that we have of creating a really
incredibly developed infrastructure for
serving out maps data.
And we want you to be able to do the same for your
organization.
So please, this is--
they always tell you to do a call to action in these.
I'm gonna do the call to action early.
The call to action is join us in this adventure.
OK, so let's talk about what that means.
That means we want you to build your maps in our cloud.
We want you to reach users on every platform
that you can reach.
And we want you to integrate our data with your data in
your applications.
Three basic key takeaways.
If you don't remember anything else, you'll remember.
If you're watching on the live stream, you should still watch
the rest of it, but those are the key takeaways.
OK.
Let's talk about what that actually means.
This right here is a Maps API application.
You may say it looks like a fairly standard Maps API
application.
I didn't gussy it up, because I'm not really a designer.
But think about it this way.
Even if you were the state of Louisiana, or not literally
the state of Louisiana--
but you are a representative of the state of Louisiana.
You're concerned about the impact of oil natural gas
infrastructure on disaster preparedness.
So you want to visualize where things are.
So we actually went out and did this.
Sean found a great site provided by the state--
right, the state of Louisiana--
that had data about where things were.
And we put that on this Maps API application.
So here are the Haynesville shale wells.
Here are some oil and gas fields.
Here our some permit points for new permits for drilling,
I'm guessing, and polygons that impact the
areas where these are.
Here are some levees.
You get you get the idea, right?
We have lots of interesting data about where things are.
Well, here's the trick.
So you've probably seen Maps API
applications like this before.
But all this data is actually being served off of Google's
infrastructure.
This is all data that's living in Google Maps Engine and is
being served directly to a Maps API application.
The only thing that is not on Google's
infrastructure is the sample.
This is an HTML5 slide deck.
I have an HTML page and some JavaScript just sitting on my
laptop-- but it could be on a server somewhere--
and that's it.
All the data is served directly from our servers in a
highly optimized fashion.
And I can share that data with whoever I want.
I've made this public, because I'm making a demonstration,
but I could limit access to who can do
what with this data.
So think about this as an example.
Sean's going to walk you through a little bit more, but
first I want to talk to you about what
the cloud looks like.
Why should you think about our geospatial cloud?
Google Maps is used a million hours every day.
For a million hours, people are using our infrastructure.
The billion monthly active users of Google
Maps services and--
I don't know, how many of you know about Santa Tracker, seen
Santa Tracker?
All right.
You guys are part of the 1.6 million queries per second
that our infrastructure handled on Christmas Day when
some very brave data center engineers stayed during
Christmas Day, probably fairly alone in the data centers,
making sure that Santa Tracker stayed up and running--
1.6 million queries per second.
So we have a solid infrastructure that we've
developed that will help you serve your data when you need
it-- and during the lean times, when you don't have
very many users, and during the high peak periods.
That's what you should be thinking about.
But there's more.
We have available for your use the world's
largest imagery database--
20 petabytes of imagery.
That's just the data that we make available through maps.
We have constantly updating base data.
So the maps are being updated moment to moment.
We have people in Map Maker.
We have a project called Ground Truth, where we're
actually sourcing our own data and inputting it.
And we also have additional data providers.
So we have a massive amount of base data
constantly being updated.
We provide you with access control, rock
solid access control.
So if you're familiar with--
how many of you use Google Docs?
And Gmail?
All right.
It's Google I/O, that's not a fair question, right?
But you know then, about access control.
You can make a document public.
You can make it private.
You can make it unlisted.
And we give you additional access control, but it's based
on the same solid infrastructure--
so security and stability.
And we have API integration.
We have the world's most popular web API--
the Google Maps API.
I'm not kidding when I say probably everybody in this
room and everybody watching has done a Google Maps API
application.
I'm sure somebody's going to tweet me later or plus me
later, and be like, I haven't.
But statistically speaking, almost all web developers,
anybody who's done JavaScript-- lots of people
learn JavaScript by actually developing Maps API
applications.
It's simple and powerful--
huge amount of features, huge amount of services.
So that's why you should be trusting our cloud.
Now Sean is going to talk to you about the
details of Maps Engine.
SEAN MADAY: All right.
Thank you, Mano.
As Mano described to you, we at Google have gotten really
good at this geospatial stuff.
Consumers around the world trust our two-dimensional maps
and our three-dimensional Google Earth environment to
make fast informed decisions.
It's that familiarity that we look to leverage with Google
Maps Engine
I should ask how many of you have used Google Maps Engine
or put your hands on this product to this point.
Good, OK.
So for those joining us via live stream, the thousands of
people in the audience all raised their hands, and their
applause and laughter and cheer was actually a bit
disruptive.
But we're back now.
Google Maps Engine is how we have basically productized the
processes and the pipelines that we used to make the
platform behind Google Earth and Google Maps.
So we have really awesome engineers, outstanding
infrastructure that does lots of really cool things with
geospatial data.
Specifically, our core competency has become
simplifying the delivery of complex geospatial data.
And that's what we're offering with Google Maps Engine.
Google Maps Engine allows you to take your imagery, terrain,
and vector data, upload it into Google's cloud.
It's replicated in our data centers.
We handle the redundancy.
We handle the failover.
You then are given tens of thousands of processing nodes
to do interesting things to process your data and to style
your data, and then all sorts of interesting end points to
deliver your data out to your intended audience, whether
that audience is public or whether you just want to share
your data with certain individuals or groups.
And we'll talk through more of this as we go.
But these end points include Google Earth, Google Maps, the
Google Maps API, OGC Standards like WMS, as well as some
mobile end points we'll display for you on a zoom
tablet here in a little while.
So in the last six months, we've really opened up the
Google Maps Engine platform and brought in some trusted
testers and some early
customers to use this platform.
And as Dylan Lorimer mentioned to you yesterday, we're now
going to increase the velocity by which we bring
stakeholders in.
And we're hoping to bring lots more individuals and
organizations into this ecosystem.
But today, it's interesting to note that this platform is
already hosting 165 terabytes of imagery.
Our vector data store is composed of over 2.5 billion
features at this point.
And that's growing exponentially.
And today, Google Maps Engine is being used to serve over
1,000 published maps.
So small numbers by Google standards, but really some
impressive usage and some impressive adoption in just
these first few months.
So as I present to you today, what I want to do is show you
the Google Maps Engine interface.
I want to get you familiar with some of the workflows.
Specifically, I want to show you how to upload data, how
that data is aggregated into individual layers, how you can
style those layers, and then how you can publish a map to
many of those different end points that I discussed
previously.
So as I operate and show you the interface, we're going to
be referencing back to the Louisiana Oil & Gas demo that
Mano showed you earlier in the presentation.
And my goal today is to show you the workflow around two
different types of data--
that is imagery data, or raster data, and vector data.
In regards to vector, I'm going to show you three
different subsets, points, lines, and polygons; how these
are handled inside of Google Maps Engine; and what tools we
give you to style and deliver this data out to your users.
So Mano showed you what we have as far as our base data
around Louisiana.
As we zoom in here, I'll then activate some of the layers
that he presented to you a bit earlier.
Specifically we can look at some point data, like the
permit locations.
We can look at polygon data, i.e. the polygons that
encompass those permitted areas.
We can also look at line data, like the levees.
And then, if our map weren't cluttered enough, we would go
ahead and add some raster data.
So here's a topographical chart--
really interesting way to visualize topographical data,
in this case, that was housed by the USGS.
And also imagery-- so I grabbed this quad of ortho
imagery here from USGS.
We can throw that on top.
This is a scene that Google doesn't have in our imagery
database, but this is available to the public
through USGS.
And what I really want to highlight here is that the
Google Maps Engine platform is a really unique way to deliver
all this data to the end user in a simplified way.
Any user who's familiar with Google Maps zooming, panning,
interrogating icons by clicking on them, will be
familiar with this workflow.
And the engineering we've done in the background makes this
delivery fast and efficient.
So the user's not sitting around waiting for
this data to render.
MANO MARKS: Sean, one key point--
where does this iframe come from?
SEAN MADAY: Yeah, great point there, Mano.
So this iframe is actually being populated right now by a
Maps widget, which is another end point that we have within
Google Maps Engine I'll show you a bit later.
But this is a little bit of embed code
that we provide you.
So at the very simplest implementation, you can put
one line of HTML code into your organization's website or
into the public facing website that you want to use to
support a disaster response or humanitarian relief-type
situation, and have all of this Maps interaction inside
of inside of your web environment.
So one other thing I want to touch on before I jump into
the live interface demo is this concept of zoom levels.
Zoom levels are the way that we handle the delivery of
tiles inside of the Google Maps environment.
So if you're delivering a map, you have a couple options.
One is to produce a really large map, high resolution,
and that can be difficult to interact with, right?
The other option is to give you a small image that has
very low resolution.
What Google Maps API and Google Maps has done is they
use a tiling schema, so that when your zoomed way out
looking at the whole world, we're just delivering you a
couple tiles that represent the world in low resolution.
And as you zoom in, you're seeing more tiles, each tile
smaller, and those tiles represent
higher resolution areas.
The reason this is important is because on the Google Maps
environment that we provide on consumer devices and to the
average public, we have a vector team that's done a
phenomenal job of making sure that the right attributes are
visible at the right zoom levels.
So for instance, when I'm zoomed out and looking at the
United States here, I'm not seeing every secondary and
tertiary street that's available.
In this case, at this zoom level, it may be appropriate
for me not to see any streets at all--
maybe just the labels associated with states.
As I zoom in further here, I start to
see interstate highways.
As I zoom in further yet, I'll start to see smaller
municipalities and smaller infrastructure pieces.
This is all important, because in Google Maps Engine we give
you the tools to style your own data and to decide how
that data should be presented to your audience.
And this chart is handy only in that, as we style some of
this data in the demo next, I just want you to keep in mind
that when you see these zoom levels, this is what we're
talking about.
Zoom level 5, we're talking about being zoomed way out at
a global view.
Zoom level 17, 18 to 24, we're talking about being zoomed way
in where you could see a building or a street.
And without further ado then, we will step off and show you
Google Maps Engine.
So this is the landing page of the dashboard that currently
exists for Google Maps Engine.
The first thing you'll notice is that inside this dashboard,
I have some analytics--
so some basic metrics on how many of my layers are being
consumed, and when my peak usage is happening.
I can also do some querying based on time to really
identify when my map data is being consumed.
The basic building blocks inside of Google Maps Engine
are data, layers, and maps.
Data is the raw source information and the raw source
files that you might currently have in your geospatial
repository.
Those are aggregated up into layers and styled in layers
inside of Google Maps Engine.
And then layers are brought together as maps.
An example of a map would be the Louisiana Oil & Gas demo
we just showed.
So the first piece here is data ingest.
So what I'll show you here is how we would upload a piece of
source data.
The upload interface is fairly simple.
It's just going to ask me right off the bat if I'm going
to upload imagery or vector data.
For this demo, I'm just going to show you what it would be
like to upload some imagery.
This is always the dangerous part of the presentation
though, because I'm going to browse to a piece of imagery,
and if I do this wrong, I'm going to end up in a folder
that has all of my Justin Bieber images and you will
forever taunt me.
So we have to make sure we land in the right place here.
Here, for example, is one of those USGS quads.
It's a .tif file.
Google Maps Engine will consume geoTIFFs, JPEG 2000s,
MrSID, most of the industry standard raster formats.
In addition to that core source piece of data, we will
also take side car files, like world files and projection
files that might provide amplifying metadata associated
with that image or that vector data.
So in this case, I don't want to just include the TIFF, I'm
going to include the world file and maybe even one of the
attribute files that's associated with it.
From here, I have the ability to name that layer.
It's going to default to whatever the file was named,
but I could put in anything here that made sense to my
individual project.
I can then decide who I initially want to share these
layers with.
The relevance and the importance of this sharing is
really the inside of the Google Maps ecosystem.
You can have many map makers.
Map makers are those who can style data and compose maps
based on layers.
So in this case, I can decide which group or which
individuals inside of my organization I want to share
this layer with.
And then I can assign attribution.
Attribution is a catalog of source information--
source provider information--
that you cultivate and you populate inside of your Google
Maps Engine environment.
It allows you to very quickly add attribution to your Google
Earth or Google Maps end point.
You can put in the date acquired.
This is very handy if you're going to do some
temporal-based positioning or if you're going to show
historic imagery or historic raster.
This is very important, because you can leverage this
in a few different ways.
You can throw in a description--
and then, tags are very significant, because tags are
what allow us to actually make this data discoverable and
searchable inside of our Google Maps Engine
implementation.
So I'm actually going to cancel that and show you what
this looks like once it's already uploaded--
save you the excitement of watching that
upload dialogue progress.
But what I can do now is I can search for some of this data.
So up in the search bar here, I'm going
to search for Louisiana.
Here's all of the layers that I have branded with that
Louisiana keyword tag.
Here is the raster layer I was just showing you.
This has been uploaded and processed.
Google Maps Engine is extremely fast at processing
and has gotten faster even in the last six months.
So it can do really wild things with
large chunks of data.
The raw size for this particular
image was 110 megabytes.
But now we can deliver those out as small consumable map
tiles for the end user.
We get some information on the resolution.
In this case, we see this piece was 2.4 meters per
pixel, which equates to a zoom level 16.
So back to our pyramid--
this would be good to about zoom level 16.
And from here, I can then aggregate
this data into a layer.
So if I do another search of my layers now to show you what
my Louisiana data looks like, I can show you all the layers
that I have built using this Louisiana data.
Specifically, I want to show you some of the point data we
talked about earlier.
In this case, it's the oil and gas locations.
It's the oil and gas wells.
One thing you'll notice is I get this thumbnail preview in
the upper right hand corner, which shows me the geographic
parameters of this particular file.
Interesting to note here that this layer of Louisiana Oil &
Gas actually shows me that I have coverage all the way up
the center of the United States through
the Mississippi corridor.
What we can look and QC, quality check,
here with the preview--
and we'll let this render here a second--
but what we can see is that the quality of this input data
wasn't great.
And in fact, this Louisiana Oil & Gas data will show me a
couple wells that are located in northern Minnesota.
So the point I want to make there is that this is not a
tool right now for editing and for curating your core
geospatial data.
And you want to make sure that the data you upload has been
quality checked before you bring it into this ecosystem.
Let's see if I can actually-- there's the actual-- there's
our delinquent well there way up in Minnesota
that throwing us off.
So the point being there that, again, we're not here to
replace your existing desktop GIS-based systems.
The systems you use to generate and cultivate this
data are important.
We're just going to become the visualization layer that
allows you to easily share this
information with your users.
From here, I can edit this layer.
And this is where I wanted to show you zoom levels.
So I have basic options here to assign either some point
icons, some place marker icons, or do some different
stylization on these individual points.
Interesting to note there that, right now, we don't
support custom icons, but that's coming very soon.
And what I really want to hit home with that is that there's
some really rapid development cycles
inside of this ecosystem.
And the benefit of a cloud-based environment like
this is that we are on a very fast release cycle where we're
pushing these things out every few weeks.
And your users and your map makers will be able to take
advantage of this functionality without
installing the latest software, without going
through an IT change management process.
One of the benefits of the cloud is, as fast as we can
roll out these new features, they're going to be available
to you and your map makers.
From here then, I can decide when these individual well
attributes should be available at which zoom level.
I can also set up some dynamic filters based on the
attributes inside of that source data.
So maybe if you're zoomed way out, I want to show you large
wells-- wells that have a certain production value that
is quantified inside of the attribute table.
In that case, I can set up some pretty simple greater
than-, less than-, equal to-type equations here to
really specify what portions of the data I want to be
available at each layer.
I can dynamically cascade those filters down and really
create a customized view for my end users.
The same basic workflow exists for line and polygon data.
I'll show you that just with levees, again to hit home that
this is all very customizable.
In this case, we could decide what colors we want the levy
to be, full color palette to choose from.
We could decide how we want to style those lines.
We can also decide how we want to present labels.
And again, using the cascading filtering, we could decide
that maybe we want labels on at a certain viewpoint, but we
want the labels to drop off and become invisible once the
user is drilled into a certain zoom level.
All of that's customizable inside the Google Maps Engine
vector-based styling UI.
Finally, these layers are all aggregated inside of maps.
We'll let this load here.
And what I want to specifically show you and what
I can search-- there we go--
is what these maps look like.
So here's my Louisiana Oil & Gas map.
It's going to show me all the layers that I have aggregated
inside of this map.
It's going to give me some metadata about when it was
processed, when it was published.
And this is where I can really set some granular sharing
parameters.
So very much like the sharing parameters inside of Google
Docs, if you've used those, I can decide which other groups
inside my organization I want to be able to edit
and modify this map.
And then I can decide how I want to handle the viewing--
the Map user side--
of this particular data.
I can decide to share this layer publicly.
I can decide to share this layer with just a specific set
of groups or individuals.
And then finally, here is my gateway and all those
endpoints we talked about earlier.
So this is the URL I could click on to interact with this
map in a Google Maps API environment.
The Maps widget that Mano asked about earlier, the
iframe code, this is all I would need to paste into my
web server in order to bring this Google Maps environment
inside of my website.
And then also we have a WMS link here.
The benefit with WMS is that now we can consume this raster
and vector data inside of our
traditional desktop GIS systems.
So for instance, if I have a cadre of QGIS users or ArcMap
users, this one environment can serve the geospatial needs
of my entire organization and any partner organizations I
might bring into my ecosystem on an ad hoc basis.
Specifically there, I'm thinking about disaster
response or humanitarian relief, where you have private
organizations partnering with public organizations in very
dynamic relief efforts that are then over a month or two
months later.
And that's the power inside of Google Maps Engine.
It's that you can very quickly share access to your data
without giving up that source data, without having to move
around gigabytes or megabytes of source data.
You can share visibility and just as quickly revoke that
visibility.
Mano's going to talk to you a little bit more about some of
the data behind our Maps API or some of usage
behind our Maps API.
But this is actually how I would reference these
individual layers from Maps API.
That's all detailed for me here as well.
So the two things I want to show you before I step off
then, is first the integration with Google Earth, both in the
client and in the web-based plug-in.
So I'll switch this over to Google Earth here.
We'll give it a second.
Maybe.
Possibly.
It wouldn't be a true demo if something
didn't go wrong, right?
The demo gods are unhappy.
We didn't sacrifice to them before we started.
MANO MARKS: Oh, sorry.
SEAN MADAY: So that's probably what happened.
MANO MARKS: Forgot that.
SEAN MADAY: Do you have Google Earth on here?
Do you mind if I launch it?
MANO MARKS: Do you want to just open up Google Earth
instead of the plug-in?
SEAN MADAY: Yeah.
MANO MARKS: And show that?
Yeah, I do.
So yeah, just go down to there.
SEAN MADAY: OK.
So obviously, I lied to you.
This is Mano's computer, so those Justin Bieber
pictures were his.
I tried to defend him.
MANO MARKS: Train.
I don't know what you're talking about.
It's Train.
SEAN MADAY: All right.
While Mano tries to fix that, let me show you what this
looks like from a mobile end point, which is kind of cool.
Let's see if we can bring this up here.
All right, so what you're seeing here, or what you
should see here is a zoom tablet.
Come on.
Maybe.
Who did we make angry?
All right, I'll give this one more try.
I swear this worked before the
presentation without any trouble.
MANO MARKS: It did.
SEAN MADAY: All right.
Perfect, thank you.
So here from inside of Google Earth, I can quickly zoom out.
You'll notice now in the Android application we have
for Google Earth, you can authenticate
to Google Maps Engine.
It will then build me a list of layers that I have access
to based on the username and password that I use to
authenticate to that Google Maps Engine.
From there, I can activate the layer and then decide which of
those layers I might want to see inside of my mobile
environment on my Android device, whether
that's a phone or tablet.
If you have the Google Maps downloaded on your Android
device, I would highly encourage you to check this
feature out.
It's quite neat.
Here you're seeing all the layers that I have access to.
I can dynamically turn those layers on or off and view them
as I see fit from this mobile device.
Mano's logging into our Google Earth implementation over here
on the desktop, so let me switch
back over to his machine.
MANO MARKS: There you see I just went up to File and Log
In, logged into Maps Engine.
By the way, you may have heard the old name for Maps Engine,
which was Earth Builder.
We rebranded about a month or so ago.
And then, you see here I have all the private maps that I
have access to.
I can also enter in a globe by address if it's a public map.
So then--
SEAN MADAY: So, similar to unlisted layers that you may
have seen with implementations like Fusion Tables.
MANO MARKS: Right.
Exactly.
So then, here I have the Louisiana Oil & Gas, and I'm
going to click on that and go back to Google Earth.
And you'll see down here in the layers section, I actually
have Louisiana Oil & Gas.
And so it's actually integrated directly with my
experience in Google Earth.
So as I zoom in, you'll see that I start to see some of
this data showing up--
different zoom levels that it's set for.
And there you go.
SEAN MADAY: The user can also control the opacity on this.
So they can very quickly go from your enterprise
geospatial layers back to Google's authoritative base
globe information, all within the Google Earth environment
that they know and love.
One other end point we'll just discuss before I pass it back
over is Google Earth Portable.
Google Earth Portable is some really interesting software
that our engineers have been working on.
It allows you to draw a polygon around that Google
Maps Engine implementation that you've created, extract
all the imagery, terrain, and vector data inside of that
polygon and create a local cache of either
two-dimensional map data or three-dimensional Google Earth
data that your users, your field workers can take with
them out into an austere environment where they may not
have connectivity back to Google's cloud.
So that's one of the ways we're bridging that gap
between ground and cloud.
I appreciate your time, and I'll pass it over to Mano to
run you through some of the developer options.
MANO MARKS: And actually, here is that Earth plug-in that you
were looking at before.
It hadn't loaded up quickly, but that's because I had
loaded in a new browser.
And it's the first time, I think, it
was using that cache.
So this is directly loading off of Google Maps Engine, but
it is using the Google Earth plug-in.
So it's a 3D environment within the browser.
And you can actually do this with your own Earth API
applications as well, which would allow you to combine
with other sources of data that aren't
hosted on Maps Engine.
So I'm going to switch back to the slides.
I turned off my clicker so I wouldn't bother Sean.
There we go.
So now we're going to talk about Google Maps Engine for
developers.
There are four different pieces that you need to
remember about Maps Engine for developers at this point.
We're in a fairly early stage.
We have MapsDataLayer, which allows you to take maps and
layers from Google Maps Engine and apply them directly to
your Maps API applications.
There's a JSON Feed that you can get, which gives you
access to information about what is stored
in individual layers.
You can also load a side database using the Earth API,
which is similar to what I just showed you.
And then if you need to do authentication it it's a
private map, you use OAuth.
So we don't have time to get into the
details of OAuth here.
And frankly, authentication is a pain, but I'm sure there are
other people here who can walk you through that.
But just keep that in mind.
So what we're going to be showing here is public maps,
but this will be--
if you can implement OAuth in your application, you can
actually get access to private maps as well.
So let's go back to this demo that we showed here.
Now this is, just as a reminder, same data.
It's the same demo we showed at the beginning.
And there's this USGS chart.
Well, I click on it, and it's actually really tiny.
It's right down in here.
There's not a whole lot that's there.
And then there's some ortho vector data.
We just basically couldn't find any--
there's some great raster data at the site where we were
downloading data.
So keep that in mind as we get back to it.
But this is basically Maps' data layer loading in that map
that we've been working with.
So here's some basic code here.
You load in the Google Maps API loader.
You use the visualization library.
So if you're not familiar with libraries in the Google Maps
API, we have a number of libraries--
one of which is visualization--
that are loaded as extra parameters to the loader.
That is, if you don't load them, then the API knows
nothing about them, so it reduces the size of your code.
And then you create a new maps data layer object and pass it
map ID, layer ID, and the map that it's
supposed to create on.
And so these are the basic pieces.
Remember-- visualization, maps data layer.
And then what you get back as a piece of that-- this is what
the JSON object contains, the information
here about your layer.
And it gives you a lot of information in there,
including the bounding box for a particular layer, a list of
all the different layers that are associated with a
particular map.
And that allows you to do some processing to figure out how
you want to display and interact with the data.
And so some of the key stuff on here is asset IDs and the
keys for the layers.
So what I did in that demo before is I just used some
jQuery to go through, parse out each of the layers, and
add a check box with an event handler that
triggers them on and off.
We're not done yet, but I want to give you just a little
thing to keep in your mind.
We announce later this year that we're going to be
releasing a full read-write API for Maps Engine, which
will allow you to upload your data programmatically to
Google Maps Engine.
Currently, that's not an option, but that is something
that we are working on and believe that we can release
within the year.
And we think that will allow developers to do a much more
dynamic approach to uploading, styling, and
implementing data.
OK, but let's talk about a couple of other features of
our Geospatial Cloud that aren't specifically tied to
Maps Engine.
And this will all come together in a minute.
One thing that we released at Where 2.0 this year is the US
Demographics Layer.
So it's a layer that's available to Enterprise Maps
customers--
if you have a Google Maps API for business.
And if you have Maps Engine you get a business license
along with that.
So it's available for internal applications.
And you see here that I get data from the US Census about
things like income, population density, property values, and
a lot more.
So we're going to take a look at income in San Francisco.
In 2010, you can see the different census tracts in
there have different income levels.
And you can look back.
We actually have the most recent census information.
We can actually even show you the boundaries for the census
block, so you get a nice sense of it.
And then we also recently released--
actually the first public
announcement of it was yesterday.
Dylan talked in the What's New in Google Maps API talk about
the Google Maps Gallery, also called the
Google Earth Gallery.
And in here, you have lots of maps
that people have created--
KML files, and also Maps Engine files that people have
uploaded and made public for anybody to have access to.
So this is real time sharing of public data.
And you can do this-- if you have Maps Engine, you can
submit your maps to the Earth Gallery.
So let's bring those together, though.
Remember, I mentioned that I was a little disappointed with
the raster support in the state of Louisiana site.
That the raster imagery-- we just didn't have very good
coverage, we felt.
So what we did here is, I pulled into this Maps API
application a separate Maps data layer.
And I brought in topographic maps from the US Geological
Society, USGS.
And you see here, I can see the actual topographic maps.
I can even see metadata about these if I'm at a zoom level.
Well, that doesn't show up right there.
But if I zoom in, you'll see I get a little metadata about
each individual map.
And I can actually see a bounding box of the different
portions of that raster.
So these are three layers provided in a different map, a
public map made public in the Google Maps Gallery.
And I just loaded it directly into the Maps API application,
the same one-- or actually, a slightly
different file, obviously.
And then I added in, also, demographics.
So I can look in and I can see at a glance-- this is income
by census tract.
What I can see here is the impact that, for instance,
permit polygons--
where they are in relation to the
demographics of that community.
And I can tell, for instance, the impact that new drilling
might have on low income or high income, whatever groups
that I'm interested in, those different communities.
So you can see by bringing these powerful visualization
technologies together, I can do some really interesting
visual analysis of my data and layer in different features
from different maps--
bringing it all together and then serving it all off of the
Google geospatial infrastructure.
So this is your next call to action.
Tomorrow, Sean Wohltman-- the other Sean, as I like to call
him; actually, when I'm talking to Sean Wohltman, I
refer to Sean Maday as the other Sean--
and Mike Evanoff are running a codelab here where you can
actually play--
Mike's in the back there.
All right, Mike, other Sean.
OK.
This is the other Sean.
Don't worry.
They're going to run a codelab with a number of tutors-- a
number of people will be there to help out-- where you can
actually get your hands on Maps Engine and play with it.
And they're going to walk you through a lot of these steps,
including, for instance, the OAuth stuff that I kind of
glossed over because it doesn't really fit well in my
nice presentation.
But they will cover that in detail, And you'll actually be
able to get hands on, using this in a development
environment.
So I'm really excited that they're here.
And I actually sat through a couple of their different
practice sessions for it.
It's really going to be great.
So that concludes the presentation.
We're really happy to have you here, and happy to see that
there's an interest in it.
After this, we'll be out in the Sandbox--
at the Google Maps Sandbox-- if you want to ask us
additional questions.
And we can take questions now.
And of course, both of us are on Google+ and Twitter, so you
can find us there if you want to ask us
questions out in the--
well, that's not really the real world, is it?
SEAN MADAY: The real virtual world.
MANO MARKS: Yes, so thank you very much.
[APPLAUSE]
MANO MARKS: So we can take questions right now.
If you would, if you want to have a question, please come
up to one of the two mics that are provided.
Yes, go ahead.
AUDIENCE: Hi, thank you for telling us about this new,
exciting product.
I was wondering about how Google Fusion Tables--
the spatial aspect of that-- fits in with this.
Is this a replacement?
Or do they work together?
Or is Fusion Tables being deprecated?
MANO MARKS: Fusion Tables is still an active product.
It's part of Google Docs.
And it does run on Google's infrastructure.
It's a different kind of product.
We saw the interest that was generated by that,
particularly among Maps developers, and we got excited
about that.
And we learned a lot of lessons from that.
Because it uses a different infrastructure for Maps
Engine, we can actually serve a much greater amount of data.
Do you want to give the stats on how big a map can be, how
big your files can be?
SEAN MADAY: Yeah, what we saw was that Fusion Tables really
showed that there was a demand for doing lots of complex
geospatial analysis in the cloud.
So what we've tried to do with Maps Engine is provide vector
tools that will handle tens of millions of vertices or
hundreds of millions of vertices.
So that's where we're really focused with Google Maps
Engine, is getting beyond those small use cases into
those niche geospatial use cases where there's really fun
things you can do with big data sets.
MANO MARKS: I spent a lot of time last year talking about
Fusion Tables.
And when I talk to people who worked in the geospatial
industry, I would say, well, you can upload
large amounts of data.
They'd say, really?
How much?
I'd say, well, you can have files up to 100 megabytes that
you can upload.
And in the geospatial world, that's not a
large amount of data.
But for a lot of use cases, that is.
So we think they fit into some different use cases.
And also we've worked on the raster support, which isn't
something that we can really do in Fusion Tables.
So we think this is definitely the enterprise
solution in the way we--
SEAN MADAY: If you need a service-level agreement for
tens of millions of vertices, Google Maps Engine is where
we'd point you.
MANO MARKS: Right.
And how large are the files that you can upload?
SEAN MADAY: So at this point, we can support several
gigabyte files.
And we're expecting that limit to grow exponentially in the
months ahead.
So we've got some really smart engineers who are doing great
things with our vector store.
And that's going to get big quick.
MANO MARKS: Yes.
AUDIENCE: I have a simple question that introduces a
more difficult question.
SEAN MADAY: I'll take a simple one.
And then I'll pass it to Mano.
MANO MARKS: I'll take the hard one.
AUDIENCE: The simple one is about data
visualization rendering.
Do you foresee to have the possibility to classify data
based on an attribute of that data, so make dynamic
classification?
And this introduces the second one, which is how do you plan
to evolve this product?
Will it become a GIS product in the future?
Thank you.
MANO MARKS: You want the first one?
SEAN MADAY: Sure.
So, yeah, great question on classification of data.
Specifically, I assume you're referring to raster data.
We announced back at the COP 16, the climate summit last
year in Mexico, that we had been working on a platform we
call Google Earth Engine, which starts to do some really
neat raster analysis.
We look forward to tighter integration of that platform
with Google Maps Engine as these platforms both mature.
But right now the Google Maps and Google Earth Engine API is
available to trusted testers.
And if you want to start doing some raster analysis and
classification, it's a really powerful platform for doing
what you described.
MANO MARKS: Talk to David--
he's in the audience right there with the hair--
for Earth Engine.
So then the question is does this become a GIS?
And I guess it depends on definitions of what is a GIS.
And I've seen lots of conversations about that,
particularly a few years ago, it was what is a GIS?
At this point, what we're looking at is, Maps Engine is
a way to serve and share your GIS data.
And we are a platform for collaboration and a platform
for integration.
And we're also a way for you to reliably have your data in
the cloud in a way that is not going to fail.
So that's where we're at.
And we're also looking at--
we have this WMS output.
So we're looking at ways in which you can actually then
use Maps and Engine to integrate not just with your
web applications but with your other GIS applications.
We're not done.
We've been out for six months.
We feel like it's a great product, and it's going to be
really, really fantastic at some point.
So we're really--
come with us on this voyage.
I think we're going to have some really special
stuff coming up.
SEAN MADAY: And just to add to Mano's point, I would really
challenge that this is GIS revisioned and reimagined.
And our core competency, again, is simplifying the
delivery of complex geospatial data.
So my mom, my neighbor, when they want to understand
geospatially what's happening in their neighborhood, they're
not going to install a heavyweight GIS application on
their desktop.
This is the way we see ourselves as being that
visualization layer that makes this consumable to everyone.
MANO MARKS: Yes.
AUDIENCE: You were talking about the ability to push
edits using the read-write APIs.
And I was wondering, have you decided to allow concurrent
editing between multiple users that would show up in real
time to all users?
And if so, how do you handle data collisions?
MANO MARKS: You mean through the API?
AUDIENCE: Mhm.
MANO MARKS: We haven't released any details on what
the API's going to look like.
So we've got the basic infrastructure for developing
the API, but we haven't figured out all the details,
and I don't want to promise to something that we can't--
SEAN MADAY: More to come on that.
All right, any other questions?
MANO MARKS: Yes.
AUDIENCE: You haven't been mentioning routing.
Are there any plans for adding new routing
features in Maps Engine?
MANO MARKS: That's a good question.
So you mean routing over your own data?
AUDIENCE: Yeah.
MANO MARKS: That's a really good question, and it's the
kind of thing that comes up a lot.
And the only thing that we have announced right now about
future features is that we will have this read-write API.
We can't tell you what other features until Dylan Lorimer
tells us that we can.
We can't tell you what other features are going
to be part of it.
But it's a really good question.
I talk to developers around the world who are really
interested in that kind of functionality.
It's very hard to do.
And we actually have solved it on our own systems.
I'd love to be able to give that to you.
SEAN MADAY: And I would recommend, too, stop by the
Sandbox and see what some of our partners are doing with
this platform and all of our geoplatforms.
MANO MARKS: GeoEye, I think, is there today.
GeoEye provides much of our satellite imagery today.
And they use Maps Engine as a way to work with partners and
distribute their data.
It's really great and inspiring to hear
what they're doing.
Other questions?
OK.
Do you mind getting to the mic?
AUDIENCE: You presented the styling for the points.
Do you have the same for polygons, points, lines?
Is it going to be a whole theming tool?
SEAN MADAY: We do, yeah.
So your question was on, if I heard you right, styling for
points, lines, and polygons.
Just in the interest of time, I left off after I showed the
styling of lines.
But yeah, styling of polygons is in the tool today.
And we only expect that those styling features are going to
become more robust in the releases ahead.
So I'll slowly bring that up as we're talking here.
But yes, the answer to your question is yes, we
support that now.
So here's the permanent polygons.
I have the ability to edit these styles with both what
the border should look like, thickness, color, and then the
fill, with not just a color, but an opacity as well.
AUDIENCE: Once the API is out, would you be able to do that
through the API?
SEAN MADAY: Our goal is to provide a rich set of features
through the API.
So, there are no specific announcements, but absolutely.
MANO MARKS: If you see Dylan Lorimer, ask him.
Get him a couple drinks, and maybe he'll tell you.
SEAN MADAY: Tell you everything.
MANO MARKS: Any more questions?
OK, great.
Thank you so much.
Again, we'll be out in the Sandbox.
SEAN MADAY: Thanks, everyone.