From 01a3a4953b65b8d8eba53eef574284c85f1941d6 Mon Sep 17 00:00:00 2001
From: David Troy <dave@popvox.com>
Date: Fri, 30 May 2008 10:53:13 -0400
Subject: [PATCH] added project files

---
 geohash.js       | 216 +++++++++++++++++++++++++++++++++++++++++++++++
 index.html       |  47 +++++++++++
 labeledmarker.js | 142 +++++++++++++++++++++++++++++++
 matrix.txt       |  65 ++++++++++++++
 4 files changed, 470 insertions(+)
 create mode 100644 geohash.js
 create mode 100644 index.html
 create mode 100644 labeledmarker.js
 create mode 100644 matrix.txt

diff --git a/geohash.js b/geohash.js
new file mode 100644
index 0000000..8c7c16b
--- /dev/null
+++ b/geohash.js
@@ -0,0 +1,216 @@
+var BASE32 = 											   "0123456789bcdefghjkmnpqrstuvwxyz";
+var NEIGHBORS = { right  : { even :  "bc01fg45238967deuvhjyznpkmstqrwx" },
+									left   : { even :  "238967debc01fg45kmstqrwxuvhjyznp" },
+									top    : { even :  "p0r21436x8zb9dcf5h7kjnmqesgutwvy" },
+									bottom : { even :  "14365h7k9dcfesgujnmqp0r2twvyx8zb" } };
+var BORDERS   = { right  : { even : "bcfguvyz" },
+									left   : { even : "0145hjnp" },
+									top    : { even : "prxz" },
+									bottom : { even : "028b" } };
+
+NEIGHBORS.bottom.odd = NEIGHBORS.left.even;
+NEIGHBORS.top.odd = NEIGHBORS.right.even;
+NEIGHBORS.left.odd = NEIGHBORS.bottom.even;
+NEIGHBORS.right.odd = NEIGHBORS.top.even;
+
+BORDERS.bottom.odd = BORDERS.left.even;
+BORDERS.top.odd = BORDERS.right.even;
+BORDERS.left.odd = BORDERS.bottom.even;
+BORDERS.right.odd = BORDERS.top.even;
+
+var ZOOMLEVELS = { 3: 7, 4 : 10, 5 : 12, 6 : 15, 7 : 17, 8 : 17 };
+	
+BITS = [16, 8, 4, 2, 1];
+
+function wheelZoom(a) { (a.detail || -a.wheelDelta) < 0 ? map.zoomIn() : map.zoomOut(); }
+
+function sizeMap() {
+	map = new GMap2(document.getElementById("map"));
+
+ 	map.setCenter(new GLatLng(39.024,-76.51), 9);
+	map.addControl(new GSmallMapControl());	
+}
+
+function refine_interval(interval, cd, mask) {
+	if (cd&mask)
+		interval[0] = (interval[0] + interval[1])/2;
+  else
+		interval[1] = (interval[0] + interval[1])/2;
+}
+
+function decodeGeoHash(geohash) {
+	var is_even = 1;
+	var lat = []; var lon = [];
+	lat[0] = -90.0;  lat[1] = 90.0;
+	lon[0] = -180.0; lon[1] = 180.0;
+	lat_err = 90.0;  lon_err = 180.0;
+	
+	for (i=0; i<geohash.length; i++) {
+		c = geohash[i];
+		cd = BASE32.indexOf(c);
+		for (j=0; j<5; j++) {
+			mask = BITS[j];
+			if (is_even) {
+				lon_err /= 2;
+				refine_interval(lon, cd, mask);
+			} else {
+				lat_err /= 2;
+				refine_interval(lat, cd, mask);
+			}
+			is_even = !is_even;
+		}
+	}
+	lat[2] = (lat[0] + lat[1])/2;
+	lon[2] = (lon[0] + lon[1])/2;
+
+	return { latitude: lat, longitude: lon};
+}
+
+function encodeGeoHash(latitude, longitude) {
+	var is_even=1;
+	var i=0;
+	var lat = []; var lon = [];
+	var bit=0;
+	var ch=0;
+	var precision = 12;
+	geohash = "";
+
+	lat[0] = -90.0;  lat[1] = 90.0;
+	lon[0] = -180.0; lon[1] = 180.0;
+	
+	while (geohash.length < precision) {
+	  if (is_even) {
+			mid = (lon[0] + lon[1]) / 2;
+	    if (longitude > mid) {
+				ch |= BITS[bit];
+				lon[0] = mid;
+	    } else
+				lon[1] = mid;
+	  } else {
+			mid = (lat[0] + lat[1]) / 2;
+	    if (latitude > mid) {
+				ch |= BITS[bit];
+				lat[0] = mid;
+	    } else
+				lat[1] = mid;
+	  }
+
+		is_even = !is_even;
+	  if (bit < 4)
+			bit++;
+	  else {
+			geohash += BASE32[ch];
+			bit = 0;
+			ch = 0;
+	  }
+	}
+	return geohash;
+}
+
+function calculateHash(srcHash, dir) {
+	srcHash = srcHash.toLowerCase();
+	var lastChr = srcHash.charAt(srcHash.length-1);
+	var type = (srcHash.length % 2) ? 'odd' : 'even';
+	var base = srcHash.substring(0,srcHash.length-1);
+	if (BORDERS[dir][type].indexOf(lastChr)!=-1)
+		base = calculateHash(base, dir);
+	return base + BASE32[NEIGHBORS[dir][type].indexOf(lastChr)];
+}
+
+GeoHashBox.prototype.centerMap = function () {
+	map.setCenter(new GLatLng(this.centerPoint[0], this.centerPoint[1]), ZOOMLEVELS[this.geohash.length]);
+}
+	
+GeoHashBox.prototype.showNeighbors = function () {
+	var geohashPrefix = this.geohash.substring(0,this.geohash.length-1);
+	 
+	this.neighbors.top = new GeoHashBox(calculateHash(this.geohash, 'top'));
+	this.neighbors.bottom = new GeoHashBox(calculateHash(this.geohash, 'bottom'));
+	this.neighbors.right = new GeoHashBox(calculateHash(this.geohash, 'right'));
+	this.neighbors.left = new GeoHashBox(calculateHash(this.geohash, 'left'));
+	this.neighbors.topleft = new GeoHashBox(calculateHash(this.neighbors.left.geohash, 'top'));
+	this.neighbors.topright = new GeoHashBox(calculateHash(this.neighbors.right.geohash, 'top'));
+	this.neighbors.bottomright = new GeoHashBox(calculateHash(this.neighbors.right.geohash, 'bottom'));
+	this.neighbors.bottomleft = new GeoHashBox(calculateHash(this.neighbors.left.geohash, 'bottom'));
+}
+
+GeoHashBox.prototype.plot = function () {
+	var polyline = new GPolygon([
+	  this.corners.topleft,
+		this.corners.topright,
+		this.corners.bottomright,
+		this.corners.bottomleft,
+	  this.corners.topleft
+	  ], "#007799", 3, 0.7, "#003366", 0.5, {geodesic:true});
+  map.addOverlay(polyline);
+	var marker = new LabeledMarker(new GLatLng(this.box.latitude[2],this.box.longitude[2]), this.options );
+	map.addOverlay(marker);
+}
+
+function GeoHashBox (geohash) {
+	this.geohash = geohash;
+	this.box = decodeGeoHash(geohash);
+	this.corners = {};
+	this.corners.topleft = new GLatLng(this.box.latitude[0], this.box.longitude[0]);
+	this.corners.topright = new GLatLng(this.box.latitude[1], this.box.longitude[0]);
+	this.corners.bottomright = new GLatLng(this.box.latitude[1], this.box.longitude[1]);
+	this.corners.bottomleft = new GLatLng(this.box.latitude[0], this.box.longitude[1]);
+	
+	this.centerPoint = [ (this.box.latitude[0] + this.box.latitude[1])/2, (this.box.longitude[0] + this.box.longitude[1])/2];
+	this.options = {labelText : geohash};
+	var lastChr = this.geohash.charAt(this.geohash.length-1);
+	this.selfPos = BASE32.indexOf(lastChr);
+	this.neighbors = {};
+	this.plot();
+}
+
+function geocodeAddress () {
+	var address = document.getElementById("address").value;
+	var geocoder = new GClientGeocoder();
+	geocoder.getLatLng(address, plotGeoHash);
+}
+
+function plotGeoHash (gLatLng) {
+	var geohash = encodeGeoHash(gLatLng.lat(), gLatLng.lng());
+	document.getElementById("geoHash").value = geohash;
+	var resolution = document.getElementById("hashResolution").value;
+	geohash = geohash.substr(0,resolution);
+	var geoHashBox = new GeoHashBox(geohash);
+	geoHashBox.centerMap();
+	geoHashBox.showNeighbors();
+
+	boxList = document.getElementById("boxList");
+	boxList.innerHTML = "LEFT(geohash," + resolution + ") IN (";
+	var boxes = [];
+	for (var n in geoHashBox.neighbors) {
+		boxes.push("'"+geoHashBox.neighbors[n].geohash+"'");
+	}
+	boxList.innerHTML += boxes.join(',') + ")";
+
+	searchInfo = document.getElementById("searchInfo");
+	var xdistance = geoHashBox.neighbors.topleft.corners.topleft.distanceFrom(geoHashBox.neighbors.topright.corners.topright);
+	var ydistance = geoHashBox.neighbors.topleft.corners.topleft.distanceFrom(geoHashBox.neighbors.bottomleft.corners.bottomleft);
+	var searcharea = parseInt((xdistance/1000) * (ydistance/1000)*100)/100;
+	if (xdistance>2000) {
+		xdistance = parseInt(xdistance/10)/100;
+		ydistance = parseInt(ydistance/10)/100;
+		units = "km";
+	} else {
+		xdistance = parseInt(xdistance+0.5);
+		ydistance = parseInt(ydistance+0.5);
+		units = "m";
+	}
+
+	searchInfo.innerHTML = "w:" + xdistance + units + ", h:" + ydistance + units + " (" + searcharea + "km2)";
+}
+
+window.onload = function () {
+	if (GBrowserIsCompatible()) {
+		sizeMap();
+	  GEvent.addDomListener(document.getElementById('map'), "DOMMouseScroll", wheelZoom);
+	  GEvent.addDomListener(document.getElementById('map'), "mousewheel", wheelZoom);
+  } else {
+    alert("Sorry, your browser is lame!")
+  }
+  
+}
\ No newline at end of file
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..15ccab0
--- /dev/null
+++ b/index.html
@@ -0,0 +1,47 @@
+<html>
+<head>
+  <title>geohash demonstrator</title>
+   <script src="http://maps.google.com/maps?file=api&amp;v=2&amp;key=ABQIAAAAS-9BXlmhAxzk5tMQ6009tBQ60YHOa08tQ3Rk7kk6p9CpE9bRLhRgOlUOLYUPHsGwp_XgmEwZWB1hnA&amp;hl=" type="text/javascript"/>
+   <script src="./geohash.js" type="text/javascript"/>
+   <script src="./labeledmarker.js" type="text/javascript"/>
+<style>
+body {
+  font-family: 'Helvetica';
+  font-weight: Bold;
+  color: white;
+  margin: 0px;
+}
+input {
+  font-family: 'Helvetica';  
+  font-weight: Normal;
+}
+.LabeledMarker_markerLabel {
+  color: white;
+  font-size: 13px;
+  font-family: "helvetica neue";
+  text-transform: uppercase;
+}
+</style>
+</head>
+<body>
+  <div style="width:100%; background: #000; height: 10%; padding: 15px;">
+    <input type="text" value="1600 Pennsylvania Ave, Washington, DC" id="address" name="address" size="50">
+    <input type="text" value="" id="geoHash" name="geoHash">
+<select id="hashResolution" name="hashResolution">
+  <option>3
+  <option>4
+  <option selected>5
+  <option>6
+  <option>7
+  <option>8
+</select>
+    
+    <input type="button" value="plot" onClick="geocodeAddress();">
+    <input type="button" value="clear" onClick="map.clearOverlays();">
+    <br>
+    <span id="boxList"></span><br/>
+    <span id="searchInfo"></span>
+  </div>
+  <div id="map" style="width:100%; height:90%;">
+</body>
+</html>
\ No newline at end of file
diff --git a/labeledmarker.js b/labeledmarker.js
new file mode 100644
index 0000000..9c6777a
--- /dev/null
+++ b/labeledmarker.js
@@ -0,0 +1,142 @@
+/*
+* LabeledMarker Class
+*
+* Copyright 2007 Mike Purvis (http://uwmike.com)
+* 
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+* 
+*       http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+* This class extends the Maps API's standard GMarker class with the ability
+* to support markers with textual labels. Please see articles here:
+*
+*       http://googlemapsbook.com/2007/01/22/extending-gmarker/
+*       http://googlemapsbook.com/2007/03/06/clickable-labeledmarker/
+*/
+
+/**
+ * Constructor for LabeledMarker, which picks up on strings from the GMarker
+ * options array, and then calls the GMarker constructor.
+ *
+ * @param {GLatLng} latlng
+ * @param {GMarkerOptions} Named optional arguments:
+ *   opt_opts.labelText {String} text to place in the overlay div.
+ *   opt_opts.labelClass {String} class to use for the overlay div.
+ *     (default "LabeledMarker_markerLabel")
+ *   opt_opts.labelOffset {GSize} label offset, the x- and y-distance between
+ *     the marker's latlng and the upper-left corner of the text div.
+ */
+function LabeledMarker(latlng, opt_opts){
+  this.latlng_ = latlng;
+  this.opts_ = opt_opts || {};
+
+  this.labelText_ = this.opts_.labelText || "";
+  this.labelClass_ = this.opts_.labelClass || "LabeledMarker_markerLabel";
+  this.labelOffset_ = this.opts_.labelOffset || new GSize(0, 0);
+  
+  this.clickable_ = this.opts_.clickable || true;
+  
+  if (this.opts_.draggable) {
+    // This version of LabeledMarker doesn't support dragging.
+    this.opts_.draggable = false;
+  }
+  
+  GMarker.apply(this, arguments);
+}
+
+
+// It's a limitation of JavaScript inheritance that we can't conveniently
+// inherit from GMarker without having to run its constructor. In order for 
+// the constructor to run, it requires some dummy GLatLng.
+LabeledMarker.prototype = new GMarker(new GLatLng(0, 0));
+
+/**
+ * Is called by GMap2's addOverlay method. Creates the text div and adds it
+ * to the relevant parent div.
+ *
+ * @param {GMap2} map the map that has had this labeledmarker added to it.
+ */
+LabeledMarker.prototype.initialize = function(map) {
+  // Do the GMarker constructor first.
+  GMarker.prototype.initialize.apply(this, arguments);
+  
+  this.map_ = map;
+  this.div_ = document.createElement("div");
+  this.div_.className = this.labelClass_;
+  this.div_.innerHTML = this.labelText_;
+  this.div_.style.position = "absolute";
+  this.div_.style.cursor = "pointer";
+  map.getPane(G_MAP_MARKER_PANE).appendChild(this.div_);
+
+  if (this.clickable_) {
+    /**
+     * Creates a closure for passing events through to the source marker
+     * This is located in here to avoid cluttering the global namespace.
+     * The downside is that the local variables from initialize() continue
+     * to occupy space on the stack.
+     *
+     * @param {Object} object to receive event trigger.
+     * @param {GEventListener} event to be triggered.
+     */
+    function newEventPassthru(obj, event) {
+      return function() { 
+        GEvent.trigger(obj, event);
+      };
+    }
+  
+    // Pass through events fired on the text div to the marker.
+    var eventPassthrus = ['click', 'dblclick', 'mousedown', 'mouseup', 'mouseover', 'mouseout'];
+    for(var i = 0; i < eventPassthrus.length; i++) {
+      var name = eventPassthrus[i];
+      GEvent.addDomListener(this.div_, name, newEventPassthru(this, name));
+    }
+  }
+}
+
+/**
+ * Move the text div based on current projection and zoom level, call the redraw()
+ * handler in GMarker.
+ *
+ * @param {Boolean} force will be true when pixel coordinates need to be recomputed.
+ */
+LabeledMarker.prototype.redraw = function(force) {
+  GMarker.prototype.redraw.apply(this, arguments);
+  
+  // Calculate the DIV coordinates of two opposite corners of our bounds to
+  // get the size and position of our rectangle
+  var p = this.map_.fromLatLngToDivPixel(this.latlng_);
+  var z = GOverlay.getZIndex(this.latlng_.lat());
+  
+  // Now position our div based on the div coordinates of our bounds
+  this.div_.style.left = (p.x + this.labelOffset_.width) + "px";
+  this.div_.style.top = (p.y + this.labelOffset_.height) + "px";
+  this.div_.style.zIndex = z; // in front of the marker
+}
+
+/**
+ * Remove the text div from the map pane, destroy event passthrus, and calls the
+ * default remove() handler in GMarker.
+ */
+ LabeledMarker.prototype.remove = function() {
+  GEvent.clearInstanceListeners(this.div_);
+  this.div_.parentNode.removeChild(this.div_);
+  this.div_ = null;
+  GMarker.prototype.remove.apply(this, arguments);
+}
+
+/**
+ * Return a copy of this overlay, for the parent Map to duplicate itself in full. This
+ * is part of the Overlay interface and is used, for example, to copy everything in the 
+ * main view into the mini-map.
+ */
+LabeledMarker.prototype.copy = function() {
+  return new LabeledMarker(this.latlng_, this.opt_opts_);
+}
\ No newline at end of file
diff --git a/matrix.txt b/matrix.txt
new file mode 100644
index 0000000..010e975
--- /dev/null
+++ b/matrix.txt
@@ -0,0 +1,65 @@
+
+02 03 08 09 06 07 12 13 10 11 00 01 14 15 04 05 18 19 24 25 22 23 28 29 26 27 16 17 30 31 20 21
+10 11 00 01 14 15 04 05 02 03 08 09 06 07 12 13 26 27 16 17 30 31 20 21 18 19 24 25 22 23 28 29 
+
+01 04 03 06 05 16 07 18 09 12 11 14 13 24 15 26 17 20 19 22 21 00 23 02 25 28 27 30 29 08 31 10
+00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
+
+00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
+21 00 23 02 01 04 03 06 29 08 31 10 09 12 11 14 05 16 07 18 17 20 19 22 13 24 15 26 25 28 27 30
+
+
+odd neighbors
+00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
+
+
+Even Lengths
+21 23 29 31   21 23 29 31   21 23 29 31
+20 22 28 30   20 22 28 30   20 22 28 30
+17 19 25 27   17 19 25 27   17 19 25 27
+16 18 24 26   16 18 24 26   16 18 24 26
+05 07 13 15   05 07 13 15   05 07 13 15
+04 06 12 14   04 06 12 14   04 06 12 14
+01 03 09 11   01 03 09 11   01 03 09 11
+00 02 08 10   00 02 08 10   00 02 08 10
+
+21 23 29 31   21 23 29 31   21 23 29 31
+20 22 28 30   20 22 28 30   20 22 28 30
+17 19 25 27   17 19 25 27   17 19 25 27
+16 18 24 26   16 18 24 26   16 18 24 26
+05 07 13 15   05 07 13 15   05 07 13 15
+04 06 12 14   04 06 12 14   04 06 12 14
+01 03 09 11   01 03 09 11   01 03 09 11
+00 02 08 10   00 02 08 10   00 02 08 10
+
+21 23 29 31   21 23 29 31   21 23 29 31
+20 22 28 30   20 22 28 30   20 22 28 30
+17 19 25 27   17 19 25 27   17 19 25 27
+16 18 24 26   16 18 24 26   16 18 24 26
+05 07 13 15   05 07 13 15   05 07 13 15
+04 06 12 14   04 06 12 14   04 06 12 14
+01 03 09 11   01 03 09 11   01 03 09 11
+00 02 08 10   00 02 08 10   00 02 08 10
+
+Odd Lengths
+10 11 14 15 26 27 30 31   10 11 14 15 26 27 30 31   10 11 14 15 26 27 30 31
+08 09 12 13 24 25 28 29   08 09 12 13 24 25 28 29   08 09 12 13 24 25 28 29
+02 03 06 07 18 19 22 23   02 03 06 07 18 19 22 23   02 03 06 07 18 19 22 23
+00 01 04 05 16 17 20 21   00 01 04 05 16 17 20 21   00 01 04 05 16 17 20 21
+                                                    
+10 11 14 15 26 27 30 31   10 11 14 15 26 27 30 31   10 11 14 15 26 27 30 31
+08 09 12 13 24 25 28 29   08 09 12 13 24 25 28 29   08 09 12 13 24 25 28 29
+02 03 06 07 18 19 22 23   02 03 06 07 18 19 22 23   02 03 06 07 18 19 22 23
+00 01 04 05 16 17 20 21   00 01 04 05 16 17 20 21   00 01 04 05 16 17 20 21
+                                                    
+10 11 14 15 26 27 30 31   10 11 14 15 26 27 30 31   10 11 14 15 26 27 30 31
+08 09 12 13 24 25 28 29   08 09 12 13 24 25 28 29   08 09 12 13 24 25 28 29
+02 03 06 07 18 19 22 23   02 03 06 07 18 19 22 23   02 03 06 07 18 19 22 23
+00 01 04 05 16 17 20 21   00 01 04 05 16 17 20 21   00 01 04 05 16 17 20 21
+
+DQCB -> DQF0
+c == 11
+f == 14
+
+b == 10
+0 == 0