Introduction

I set out to create a simluation to evaluate the theory that the American Airlines jetliner that scores of horrified witnesses saw plow into the Pentagon's west facade on 9/11/2001 had instead flown over the building without anyone noticing. Because people's ability to take this theory seriously seems to be inversely proportional to their familiarity with the geography and viewscapes of the Pentagon's immediate surroundings, I thought of using Google Earth to create a simulation of what such an event would look like from the highways surrounding the vast office building.

My method, described in general terms in the essay debunking the flyover theory, is described in detail here, providing a tutorial on the integration of Google Earth, Google Maps and Street View using only only simple coding not involving the APIs (application programming interfaces) of this software.

I created the simulation in Google Earth supplemented with StreetView because of the two's complimentary features. Google Earth would provide relatively realistic views of the events to be simulated because it shows the releif of terrain with a resolition of several meters, has a 3-dimensional model of the Pentagon as part of its 3-D buildings feature, and enables the overlay of models of the aircraft and the explosion. However, without the addition of image overlays, Google Earth does not accurately render details of a scene such as trees and small buildings. The StreetView feature of Google Maps does provide imagery containing such detail, along spans of roadway that have been filmed by vehicles equipped with cameras. Thus, the simulation that used Google Earth to show they hypothetical events from a variety of vantage points, would be be supplmented by StreetView views from the same vantage points.

From StreetView URLs to KML Camera and Placemark Objects

Because the simulation's vantage points would need to exist in both Google Earth and StreetView, and because StreetView vantage points exist only along recorded spans of roads, I started by selecting a set of camera positions in StreetView and recording those positions by clicking the "Link" button in the upper-right of the screen, and copying and pasting the contents of the first line providing a hypertext link.

http://maps.google.com/maps/sv?client=firefox-a&hl=en&ie=UTF8&ll=38.865158,-77.067139&spn=0,359.961376&t=h&z=16&layer=c&cbll=38.865367,-77.067314&panoid=lJAz5ICU37DOGBrfIH2Etg&cbp=12,60.56,,1,5

Which, helpfully formatted, is:

http://maps.google.com/maps/sv?client=firefox-a
	&hl=en
	&ie=UTF8
	&ll=38.865158,-77.067139
	&spn=0,359.961376
	&t=h
	&z=16
	&layer=c
	&cbll=38.865367,-77.067314
	&panoid=lJAz5ICU37DOGBrfIH2Etg
	&cbp=12,60.56,,1,5

What's needed is a way to translate that into a camera position in KML, such as:

    	<Camera id="395_1">
    		<latitude>38.865367</latitude>
    		<longitude>-77.067314</longitude>
    		<altitude>2</altitude>
    		<altitudeMode>relativeToGround</altitudeMode>
    		<heading>60.56</heading>
    		<tilt>85.0</tilt>
    	</Camera>

Not fiding such a tool, I wrote the following Ruby code to turn a list of labels and Google Maps URLs into a series of camera positions in KML. I consulted the page Google Map Parameters to deciper the URLs from SteetView.

exit unless lis = File.open("places.lis",'r')
kml = File.open("places.kml",'w');
kml.print "
  <kml xmlns=\"http://earth.google.com/kml/2.2\">
  <Folder xmlns:gx=\"http://www.google.com/kml/ext/2.2\" xmlns:kml=\"http://www.opengis.net/kml/2.2\" xmlns:atom=\"http://www.w3.org/2005/Atom\" >`\n
"
name = nil
while (!lis.eof?)
  fid = nil 
  lat = nil; lon = nil
  latc = nil; lonc = nil
  bearing = 0
  pitch = 0
  tilt = 0
  line = lis.readline.chomp!
  unless line =~ /&/
    name = line
    next
  end
  fields = line.split('&')
  fields.each do | field |
    next unless field =~ /=/
    fid,value = field.split('=')
    case fid
    when 'll'; lat,lon = value.split(',')
    when 'cbll'; latc,lonc = value.split(',')
    when 'cbp'; arrangement,bearing,tilt,zoom,pitch = value.split(',')
    end
  end
  elev = 90 - pitch.to_f
  kml.print "
    <Folder>
    \t<name>#{name}</name>
    \t<Camera id=\"#{name}\">
    \t\t<latitude>#{latc}</latitude>
    \t\t<longitude>#{lonc}</longitude>
    \t\t<altitude>2</altitude>
    \t\t<altitudeMode>relativeToGround</altitudeMode>
    \t\t<heading>#{bearing}</heading>
    \t\t<tilt>#{elev}</tilt>
    \t</Camera>
    </Folder>
  "
end
kml.print "
  </Folder>
  </kml>
"
kml.close

Note that because the StreetView URLs do not encode elevation or altitude data, I generated the KML file using the <altitudeMode> of relativeToGround with an <altitude> of 2 meters. That way, the terrain data in Google Earth is used to establish the elevation of a camera position given it's longitude and latitude coordinates, and two meters are added to account for the elevation of a driver's eyes above the street. This method results in camera positions that are about 20 feet below the actual positions on overpasses, whose elevation above the ground is generally not reflected in the terrain data.

I then opened the KML file places.kml in Google Earth and was able to fly to each of the camera positions I had recorded in StreetView. At each camera position I would take screenshots for each of a set of five different states of the model representing five different times.

To see these places, just open the following file in Google Earth:

  • places.kml ( http://911research.wtc7.net/essays/pentacon/docs/places.kml )

The Simulation Model: Using Sketchup, and Editing KML Files

I created the simulation model by adding instances of 3-d models to a local instance of Google Earth in which the model instances are managed through the "Temporary Places" and "My Places" menus. To create different model states that could be switched easily, I would generate a series of instances of each of the two objects -- the explosion and the plane -- each having distinct coordinates in space. But turning on and off the instances on the Google Earth Places menu, I would simulate different points in time.

Google describes a procedure by which models can be positioned within Sketchup against background Google Maps imagery, and then uploaded cirectly to Google Earth. This process, intended primarily for positioning fixed buildings, is cumbersome for positioning multiple copies, so I would create and position copies using KML -- the XML langage used by Google Maps and Earth.

I used models found in the form of KMZ files in the Google Sketchup 3D warehouse. Once loaded into Sketchup and moved to a reference position, I uploaded the models to Google Earth. For the explosion, the reference position is the center of the impact puncture of the Pentagon's west facade, approximately at gound level. For the plane, the reference position is directly above the explosion's reference position, where the plane's center of gravity is about 90 feet above ground level.

In Google earth the model reference instances appear in the "Temporary Places", and I renamed them to "plane_p1" and "fireball_p1". I then saved the model instances as KML files, listed here, so that they could be easily edited.

Note that each of these instances has a hierarchical structure in which a <Folder> contains six objects structured as follows, with most of the contents omitted (as ...) for clarity:

<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://earth.google.com/kml/2.2">
<Folder>
	<name>plane_p1<name>
	<description> ...
	<lookAt> ...
	<Folder>
		<Placemark>
			<name>Camera<name>
			<LookAt> ...
		</Placemark>
	</Folder>
	<Placemark>
		<name>Model</name>
		<Style> ...
		<Model>
			<altitudeMode>relativeToGround<altitudeMode>
			<Location> ...
			<Orientation> ...
			<Scale> ...
			<Link>
				<href>plane.kmz/models/SUPreview2.dae</href>
			</Link>
			<ResourceMap> ...
		</Model>
	</Placemark>
	<DocumentSource> ...
<Folder>

Initially, I made five copies of these model instance files, giving each a unique <name>, and editing the <Location> of the <Model> in each. A more elegant way of creating multiple instances of a given model places them in the single file, as in the following two files:

In creating the consolodated files, I created a single named folder to contain the instances, and for each instance, I omitted the objects containing the <lookAt> objects. When Google Earth opens the files, the hierarchy of objects it contains is displayed or updated in the places bar.