// define a location hash:
var location = {
    'name':'Tokyo',
    'latitude':35.65444,
    'longitude':139.74472
    // Other data: 
    //'heading' : 0 ,
    //'tilt' : 0 ,
    //'range':  1000000 
}
// choose a name for your .kml file:
var myFileName = 'my_geo.kml';

// now use them to force opening a .kml file:
$google.openKMLFile(location,myFileName);

<?xml version="1.0" encoding="UTF-8" ?> 
<kml xmlns="http://earth.google.com/kml/2.0">
<Document>
<Placemark>
<name>Tokyo</name> 
<Point>
<altitudeMode>relativeToGround</altitudeMode> 
<coordinates>139.74472,35.65444,0</coordinates> 
</Point>
<LookAt>
<heading>0</heading> 
<tilt>0</tilt> 
<range>1000000</range> 
<latitude>35.65444</latitude> 
<longitude>139.74472</longitude> 
</LookAt>
</Placemark>
</Document>
</kml>

var $google = { 
	
	_exampleLocation : { 
		'name':'Tokyo',
		'latitude':35.65444,
		'longitude':139.74472
		// Other data: 
		//'heading' : 0 ,
		//'tilt' : 0 ,
		//'range':  1000000 
	},
	
	_CC : Components.classes,
	
	_CI : Components.interfaces,
	
	_getDOMImpl : function(){
		if (this._domImpl == null){
			this._domImpl = this._CC["@mozilla.org/xmlextras/domparser;1"].createInstance(this._CI.nsIDOMParser).parseFromString("<foo/>", "text/xml").implementation;
		}
		return this._domImpl;
	},
	
	_stringToTmpFile: function(dataString, charset, tmpFileName) {
		var unicodeConverter = this._CC["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(this._CI.nsIScriptableUnicodeConverter);
		unicodeConverter.charset = charset;
		var convertedString = unicodeConverter.ConvertFromUnicode(dataString);
				
		var tmpFile = this._CC["@mozilla.org/file/directory_service;1"].getService(this._CI.nsIProperties).get("TmpD", this._CI.nsILocalFile);
									 
		tmpFile.append(tmpFileName);
		tmpFile.createUnique(this._CI.nsIFile.NORMAL_FILE_TYPE, 0664);
	
		var outStream = this._CC["@mozilla.org/network/file-output-stream;1"].createInstance(this._CI.nsIFileOutputStream);

		outStream.init(tmpFile, 0x02 | 0x08 | 0x20, 0664, 0);
		outStream.write(convertedString, convertedString.length);
				
		var finalData = unicodeConverter.Finish();
		if (finalData.length > 0) {
			outStream.write(finalData, finalData.length);
		}
		outStream.close(); 
		
		return tmpFile ; 
	},
	
	openKMLFile : function(location,fileName) {
		
		if (!location || location == '') {  location = this._exampleLocation ; }
			
		var doc = this._getDOMImpl().createDocument("http://earth.google.com/kml/2.0", "kml", null);
				
		var kmlDocument = doc.createElement("Document");
		doc.documentElement.appendChild(kmlDocument);
		
		var kmlPlacemark = doc.createElement("Placemark")
		kmlDocument.appendChild(kmlPlacemark);
		
		var kmlName = doc.createElement("name");
		kmlPlacemark.appendChild(kmlName);	
		
		var kmlPoint = doc.createElement("Point");
		kmlPlacemark.appendChild(kmlPoint);

		var kmlAltitudeMode = doc.createElement("altitudeMode");
		kmlPoint.appendChild(kmlAltitudeMode);
		
		var kmlCoordinates = doc.createElement("coordinates");
		kmlPoint.appendChild(kmlCoordinates);
		
		var kmlLookAt = doc.createElement("LookAt");
		kmlPlacemark.appendChild(kmlLookAt);

		var kmlHeading = doc.createElement("heading");
		kmlLookAt.appendChild(kmlHeading);

		var kmlTilt = doc.createElement("tilt");
		kmlLookAt.appendChild(kmlTilt);
		
		var kmlRange = doc.createElement("range");
		kmlLookAt.appendChild(kmlRange);
		
		var kmlLatitude = doc.createElement("latitude");
		kmlLookAt.appendChild(kmlLatitude);
		
		var kmlLongitude = doc.createElement("longitude");
		kmlLookAt.appendChild(kmlLongitude);
	
		kmlName.appendChild(doc.createTextNode(location.name));
		kmlAltitudeMode.appendChild(doc.createTextNode("relativeToGround"));
		kmlCoordinates.appendChild(doc.createTextNode(location.longitude + "," + location.latitude + ",0"));	
		kmlHeading.appendChild(doc.createTextNode(location.heading ? location.heading : '0'));
		kmlTilt.appendChild(doc.createTextNode(location.tilt ? location.tilt : '0'));
		kmlRange.appendChild(doc.createTextNode(location.range ? location.range : '1000000'));
		kmlLatitude.appendChild(doc.createTextNode(location.latitude));
		kmlLongitude.appendChild(doc.createTextNode(location.longitude));		
		
		var serializer = this._CC["@mozilla.org/xmlextras/xmlserializer;1"].createInstance(this._CI.nsIDOMSerializer);
		var kmlString = '<?xml version="1.0" encoding="UTF-8"?>' + serializer.serializeToString(doc);

		var kmlFile = this._stringToTmpFile(kmlString, "UTF-8", fileName);
		kmlFile.launch();
		
	}
	
}

#! /usr/bin/env python

# A tile stitching program.
from glob import glob
from cgi import parse_qs
import os.path
from pprint import pprint

# load all the files in this directory to be processed
filenames = glob('*.png')
try:
    filenames.remove('output.png')
except ValueError:
    pass

canvas = {}

for name in filenames:
    qs = os.path.splitext(name)[0]
    params = parse_qs(name)
    x = params['x'][0]
    y = params['y'][0]
    if canvas.has_key(x):
        canvas[x][y] = name
    else:
        canvas[x] = { y : name }

#pprint(canvas)

# calculate the dimensions of the output
tile_size = 256
temp = canvas.popitem()
canvas[temp[0]] = temp[1]
x1 = len(canvas)
y1 = len(temp[1])

xdim = x1 * tile_size
ydim = y1 * tile_size

# create the full size blank image
from PIL import Image
mode = 'RGB'
im = Image.new(mode, (xdim,ydim))

# walk the array
position = (0,0)
for row in sorted(canvas):
    for column in sorted(canvas[row]):
        current_tile = canvas[row][column]
        temp = Image.open(current_tile)
        im.paste(temp, position)
        position = (position[0], position[1] + 256)
    position = (position[0] + 256, 0)

im.save('output.png')

  m = document.getElementById("map_canvas");
      gold = m.childNodes[0].childNodes[0].childNodes[1];
      list = gold.getElementsByTagName('img');
      a = new Array(list.length);
      for (var i = 0; i < list.length; i++)
      {
        a[i] = list[i].getAttribute('src');
      }
      alert(data);