geospatial 0.0.1 → 1.0.0

data/lib/geospatial/hilbert/traverse.rb

@@ -0,0 +1,65 @@
+# Copyright, 2016, by Samuel G. D. Williams. <http://www.codeotaku.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative 'curve'
+
+require 'pry'
+
+module Geospatial
+	module Hilbert
+		class Curve
+			def traverse(&block)
+				return to_enum(:traverse) unless block_given?
+				
+				traverse_recurse(@order-1, 0, 0, self.origin, self.size, &block)
+			end
+			
+			def bit_width
+				@dimensions.count
+			end
+			
+			# Traversal enumerates all regions of a curve, top-down.
+			def traverse_recurse(order, mask, value, origin, size, &block)
+				half_size = size.collect{|value| value * 0.5}.freeze
+				prefix_mask = (1 << order) | mask
+				
+				(2**bit_width).times do |prefix|
+					# These both do the same thing, not sure which one is faster:
+					child_value = (value << @dimensions.count) | prefix
+					prefix = child_value << (order*bit_width)
+					
+					index = HilbertIndex.from_integral(prefix, bit_width, @order).to_ordinal
+					
+					index = index & prefix_mask
+					
+					child_origin = @dimensions.unmap(index.axes).freeze
+					
+					# puts "yield(#{child_origin}, #{half_size}, #{prefix}, #{order})"
+					# We avoid calling traverse_recurse simply to hit the callback on the leaf nodes:
+					result = yield child_origin, half_size, prefix, order
+					
+					if order > 0 and result != :skip
+						self.traverse_recurse(order - 1, prefix_mask, child_value, child_origin, half_size, &block)
+					end
+				end
+			end
+		end
+	end
+end

data/lib/geospatial/hilbert.rb

@@ -1,106 +1,127 @@
+# Copyright, 2016, by Samuel G. D. Williams. <http://www.codeotaku.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
 
 module Geospatial
-	class Hilbert
-		# Quadrants are numbered 0 to 3, and are in the following order:
-		# y
-		# 1 | 3 | 2 |
-		# 0 | 0 | 1 |
-		#     0   1  x
-		# The origin is in the lower left, and the most rapidly changing value is along the x axis for the initial rotation.
+	module Hilbert
+		# Convert between Hilbert index and N-dimensional points.
+		# 
+		# The Hilbert index is expressed as an array of transposed bits.
+		# 
+		# Example: 5 bits for each of n=3 coordinates.
+		# 15-bit Hilbert integer = A B C D E F G H I J K L M N O is stored
+		# as its Transpose                        ^
+		# X[0] = A D G J M                    X[2]|  7
+		# X[1] = B E H K N        <------->       | /X[1]
+		# X[2] = C F I L O                   axes |/
+		#        high low                         0------> X[0]
+		#
+		# This algorithm is derived from work done by John Skilling and published in "Programming the Hilbert curve".
 		
-		# Four quadrants/rotations, the direction indicates the axis of the final two coordinates (e.g. 2 -> 3) and is for informal use only.
-		A = 0 # LEFT
-		# | 3 | 2 |
-		# | 0 | 1 |
-		
-		B = 1 # DOWN
-		# | 1 | 2 |
-		# | 0 | 3 |
-		
-		C = 2 # RIGHT
-		# | 1 | 0 |
-		# | 2 | 3 |
-		
-		D = 3 # UP
-		# | 3 | 0 |
-		# | 2 | 1 |
-		
-		# This maps the identity rotation/quadrants into their prefix quadrant. The prefix quadrant is the 2 bit number (0 to 3) which identifies along the curve which quadrant the value falls into. This can be computed by looking at how the curve for a given rotation and looking at the correspondence between the identity quadrants and the curve's traversal.
-		ROTATE = [
-			[A, B, C, D], # A is the identity
-			[A, D, C, B], # Map A onto B.
-			[C, D, A, B], # Map A onto C.
-			[C, B, A, D], # Map A onto D.
-		].freeze
-		
-		# Rotate quadrant by rotation. The provided quadrant is with respect to the Up rotation.
-		# Note that this function is self-inverting in the sense that rotate(r, rotate(r, x)) == x.
-		def self.rotate(rotation, quadrant)
-			ROTATE[rotation][quadrant]
-		end
-		
-		# These prefixes are generated by the following graph:
-		# Rotation | 0 1 2 3 (Prefix)
-		#        A | B A A D
-		#        B | A B B C
-		#        C | D C C B
-		#        D | C D D A
-		# We can compute this matrix by looking how the given prefix quadrant maps onto a curve one level down the tree, given the current rotation. We identify that colums 1 and 2 are the same as the input so we take advantage of this by mapping only the columns which are different, i.e. for prefix 0 and 3.
-		
-		PREFIX0 = [B, A, D, C].freeze
-		PREFIX3 = [D, C, B, A].freeze
-		
-		# Given the current rotation and the prefix quadrant, compute the next rotation one level down the tree.
-		def self.next_rotation(rotation, prefix)
-			if prefix == 0
-				PREFIX0[rotation]
-			elsif prefix == 3
-				PREFIX3[rotation]
-			else
-				rotation
-			end
-		end
-		
-		# Compute which quadrant this bit is in.
-		def self.normalized_quadrant(x, y, bit_offset)
-			mask = 1 << bit_offset
+		# Convert the Hilbert index into an N-dimensional point expressed as a vector of uints.
+		# @param transposed_index The Hilbert index stored in transposed form.
+		# @param bits Number of bits per coordinate.
+		# @return Coordinate vector.
+		def self.unmap(transposed_index, bits)
+			x = transposed_index.dup #var X = (uint[])transposedIndex.Clone();
+			n = x.length # n: Number of dimensions
+			m = 1 << bits
 			
-			if (y & mask) == 0
-				if (x & mask) == 0
-					return 0
-				else
-					return 1
-				end
-			else
-				if (x & mask) == 0
-					return 3
-				else
-					return 2
+			# Gray decode by H ^ (H/2)
+			t = x[n-1] >> 1 # t = X[n - 1] >> 1;
+			
+			(n-1).downto(1) {|i| x[i] ^= x[i-1]}
+			x[0] ^= t
+			
+			# Undo excess work
+			q = 2
+			while q != m
+				p = q - 1
+				
+				i = n - 1
+				while i >= 0
+					if x[i] & q != 0
+						x[0] ^= p # invert
+					else
+						t = (x[0] ^ x[i]) & p;
+						x[0] ^= t;
+						x[i] ^= t;
+					end
+					
+					i -= 1
 				end
+
+				q <<= 1
 			end
+			
+			return x
 		end
 		
-		def self.hash(x, y, order)
-			result = 0
-			# The initial rotation depends on the order:
-			rotation = order.even? ? A : B
+		# Given the coordinates of a point in N-Dimensional space, find the distance to that point along the Hilbert curve.
+		# That distance will be transposed; broken into pieces and distributed into an array.
+		# 
+		# The number of dimensions is the length of the hilbert_index array.
+		# @param hilbert_index Point in N-space.
+		# @param bits Depth of the Hilbert curve. If bits is one, this is the top-level Hilbert curve.
+		# @return The Hilbert distance (or index) as a transposed Hilbert index.
+		def self.map(hilbert_axes, bits)
+			x = hilbert_axes.dup
+			n = x.length # n: Number of dimensions
+			m = 1 << (bits - 1)
 			
-			order.downto(0) do |i|
-				# This computes the normalized quadrant for the ith bit of x, y:
-				quadrant = self.normalized_quadrant(x, y, i)
+			# Inverse undo
+			q = m
+			while q > 1
+				p = q - 1
+				i = 0
 				
-				# Given the normalised quadrant, compute the prefix bits for the given quadrant for the given hilbert curve rotation:
-				prefix = rotate(rotation, quadrant)
+				while i < n
+					if (x[i] & q) != 0
+							x[0] ^= p # invert
+					else
+						t = (x[0] ^ x[i]) & p;
+						x[0] ^= t;
+						x[i] ^= t;
+					end
+					
+					i += 1
+				end
 				
-				# These both do the same thing, not sure which one is faster:
-				result = (result << 2) | prefix
-				#result |= (rotated << (i * 2))
+				q >>= 1
+			end # exchange
+			
+			# Gray encode
+			1.upto(n-1) {|i| x[i] ^= x[i-1]}
+			
+			t = 0
+			q = m
+			while q > 1
+				if x[n-1] & q != 0
+					t ^= q - 1
+				end
 				
-				# Given the current rotation and the prefix for the hilbert curve, compute the next rotation one level in:
-				rotation = next_rotation(rotation, prefix)
+				q >>= 1
 			end
 			
-			return result
+			0.upto(n-1) {|i| x[i] ^= t}
+			
+			return x
 		end
 	end
-end
+end

data/lib/geospatial/index.rb

@@ -0,0 +1,80 @@
+# Copyright, 2016, by Samuel G. D. Williams. <http://www.codeotaku.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative 'interleave'
+require_relative 'hilbert'
+
+module Geospatial
+	# This class represents a n-dimentional index.
+	# @param axes Point in n-space, e.g. [3, 7].
+	# @param bits Number of bits to use for each axis, e.g. 8.
+	class Index
+		def initialize(axes, bits)
+			@axes = axes
+			@bits = bits
+		end
+		
+		def self.from_integral(integral, width, bits)
+			self.new(Interleave.unmap(integral, width), bits)
+		end
+		
+		attr :axes
+		attr :bits
+		
+		def & mask
+			self.class.new(axes.collect{|axis| axis & mask}, @bits)
+		end
+		
+		def hash
+			@axes.hash
+		end
+		
+		def eql?(other)
+			self.class.eql?(other.class) and @axes.eql?(other.axes) and @bits.eql?(other.bits)
+		end
+		
+		def to_i
+			Interleave.map(@axes, @bits)
+		end
+		
+		def bit_length
+			@axes.size * @bits
+		end
+		
+		def inspect
+			i = self.to_i
+			"\#<#{self.class}[#{@bits}] 0b#{i.to_s(2).rjust(bit_length, '0')} (#{i}) #{@axes.inspect}>"
+		end
+	end
+	
+	# Represents an index on the hilbert curve.
+	class HilbertIndex < Index
+		def to_ordinal
+			OrdinalIndex.new(Hilbert.unmap(@axes, @bits), @bits)
+		end
+	end
+	
+	# Represents an index in ordinal space.
+	class OrdinalIndex < Index
+		def to_hilbert
+			HilbertIndex.new(Hilbert.map(@axes, @bits), @bits)
+		end
+	end
+end

data/lib/geospatial/interleave.rb

@@ -0,0 +1,69 @@
+# Copyright, 2016, by Samuel G. D. Williams. <http://www.codeotaku.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module Geospatial
+	module Interleave
+		# Convert a Tranpose Hilbert index into a Hilbert integer
+		# 15-bit Hilbert integer = A B C D E F G H I J K L M N O is stored
+		# as its Transpose:
+		# x[0] = A D G J M
+		# x[1] = B E H K N
+		# x[2] = C F I L O
+		#        |--bits-|
+		def self.map(index, bits)
+			result = 0
+			
+			index.each_with_index do |x, i|
+				offset = index.size - (i+1)
+				
+				bits.times do |j|
+					result |= (x & 1) << (j*index.size+offset)
+					
+					x >>= 1
+					
+					break if x == 0
+				end
+			end
+			
+			return result
+		end
+		
+		def self.unmap(integral, width)
+			result = [0] * width
+			mask = (1 << width) - 1
+			offset = 0
+			
+			while integral != 0
+				# N times, look at each bit and append
+				width.times do |i|
+					bit = (integral >> i) & 1
+					result[-1-i] |= bit << offset
+				end
+				
+				# Pop first n bits
+				integral >>= width
+				
+				offset += 1
+			end
+			
+			return result
+		end
+	end
+end

data/lib/geospatial/location.rb

@@ -1,3 +1,22 @@
+# Copyright, 2015, by Samuel G. D. Williams. <http://www.codeotaku.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
 
 module Geospatial
 	# This location is specifically relating to a WGS84 coordinate on Earth.
@@ -16,59 +35,61 @@ module Geospatial
 		R2D = (180.0 / Math::PI)
 		D2R = (Math::PI / 180.0)
 
-		MIN_LATITUDE = -90.0 * D2R
-		MAX_LATITUDE = 90 * D2R
-		VALID_LATITUDE = MIN_LATITUDE...MAX_LATITUDE
-		
 		MIN_LONGITUDE = -180 * D2R
 		MAX_LONGITUDE = 180 * D2R
 		VALID_LONGITUDE = MIN_LONGITUDE...MAX_LONGITUDE
-		
-		def initialize(latitude, longitude, altitude = 0)
+
+		MIN_LATITUDE = -90.0 * D2R
+		MAX_LATITUDE = 90 * D2R
+		VALID_LATITUDE = MIN_LATITUDE...MAX_LATITUDE
+
+		def initialize(longitude, latitude)
 			@latitude = latitude
 			@longitude = longitude
-			@altitude = altitude
 		end
 		
 		def valid?
-			VALID_LATITUDE.include? latitude and VALID_LONGITUDE.include? longitude
+			VALID_LONGITUDE.include?(longitude) and VALID_LATITUDE.include?(latitude)
+		end
+		
+		def to_a
+			[@longitude, @latitude]
 		end
 		
 		def to_s
-			"#<Location latitude=#{@latitude} longitude=#{@longitude.to_f} altitude=#{@altitude.to_f}>"
+			"#<Location longitude=#{@longitude.to_f} latitude=#{@latitude}>"
 		end
 		
 		alias inspect to_s
 		
-		attr :latitude
-		attr :longitude
-		attr :altitude
+		attr :longitude # -180 -> 180 (equivalent to x)
+		attr :latitude # -90 -> 90 (equivalent to y)
 		
 		# http://janmatuschek.de/LatitudeLongitudeBoundingCoordinates
 		def bounding_box(distance, radius = EARTH_RADIUS)
 			raise ArgumentError.new("Invalid distance or radius") if distance < 0 or radius < 0
 
 			# angular distance in radians on a great circle
-			angular_distance = distance / (radius + self.altitude)
+			angular_distance = distance / radius
 
 			min_latitude = (self.latitude * D2R) - angular_distance
 			max_latitude = (self.latitude * D2R) + angular_distance
 
-			if min_latitude > MIN_LAT and max_latitude < MAX_LAT
+			if min_latitude > MIN_LATITUDE and max_latitude < MAX_LATITUDE
 				longitude_delta = Math::asin(Math::sin(angular_distance) / Math::cos(self.latitude * D2R))
 				
 				min_longitude = (self.longitude * D2R) - longitude_delta
-				min_longitude += 2.0 * Math::PI if (min_longitude < MIN_LON)
+				min_longitude += 2.0 * Math::PI if (min_longitude < MIN_LONGITUDE)
 				
 				max_longitude = (self.longitude * D2R) + longitude_delta;
-				max_longitude -= 2.0 * Math::PI if (max_longitude > MAX_LON)
+				max_longitude -= 2.0 * Math::PI if (max_longitude > MAX_LONGITUDE)
 			else
 				# a pole is within the distance
-				min_latitude = [min_latitude, MIN_LAT].max
-				max_latitude = [max_latitude, MAX_LAT].min
+				min_latitude = [min_latitude, MIN_LATITUDE].max
+				max_latitude = [max_latitude, MAX_LATITUDE].min
 				
-				min_longitude = MIN_LON
-				max_longitude = MAX_LON
+				min_longitude = MIN_LONGITUDE
+				max_longitude = MAX_LONGITUDE
 			end
 			
 			return {
@@ -78,17 +99,17 @@ module Geospatial
 		end
 		
 		# Converts latitude, longitude to ECEF coordinate system
-		def to_ecef(alt)
-			clat = Math::cos(lat * D2R)
-			slat = Math::sin(lat * D2R)
+		def to_ecef
 			clon = Math::cos(lon * D2R)
 			slon = Math::sin(lon * D2R)
-		
+			clat = Math::cos(lat * D2R)
+			slat = Math::sin(lat * D2R)
+
 			n = WGS84_A / Math::sqrt(1.0 - WGS84_E * WGS84_E * slat * slat)
 		
-			x = (n + alt) * clat * clon
-			y = (n + alt) * clat * slon
-			z = (n * (1.0 - WGS84_E * WGS84_E) + alt) * slat
+			x = n * clat * clon
+			y = n * clat * slon
+			z = n * (1.0 - WGS84_E * WGS84_E) * slat
 	
 			return x, y, z
 		end
@@ -108,18 +129,18 @@ module Geospatial
 			lat = Math::atan2((z+ep*ep*b*(Math::sin(th) ** 3)), (p-e*e*a*(Math::cos(th)**3)))
 			
 			n = a / Math::sqrt(1.0-e*e*(Math::sin(lat) ** 2))
-			alt = p / Math::cos(lat)-n
-	
-			return self.new(lat*R2D, lon*R2D, alt)
+			# alt = p / Math::cos(lat)-n
+			
+			return self.new(lat*R2D, lon*R2D)
 		end
 		
 		# calculate distance in metres between us and something else
 		# ref: http://codingandweb.blogspot.co.nz/2012/04/calculating-distance-between-two-points.html
 		def distance_from(other_position)
-			rlat1 = self.latitude * D2R 
 			rlong1 = self.longitude * D2R 
-			rlat2 = other_position.latitude * D2R 
+			rlat1 = self.latitude * D2R 
 			rlong2 = other_position.longitude * D2R 
+			rlat2 = other_position.latitude * D2R 
 			
 			dlon = rlong1 - rlong2
 			dlat = rlat1 - rlat2

data/lib/geospatial/map/index.rb

@@ -0,0 +1,57 @@
+# Copyright, 2016, by Samuel G. D. Williams. <http://www.codeotaku.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative '../map'
+
+module Geospatial
+	class Map
+		# Uses dependency injection to generate a class to `load` and `dump` a serialized column.
+		class Index
+			class << self
+				attr_accessor :map
+				
+				def load(hash)
+					if hash
+						map.point_for_hash(hash)
+					end
+				end
+				
+				def dump(point)
+					if point.is_a?(Point)
+						point.hash
+					elsif point.respond_to?(:to_a)
+						map.hash_for_coordinates(point.to_a)
+					elsif !point.nil?
+						raise ArgumentError.new("Could not convert #{point} on #{map}!")
+					end
+				end
+			end
+		end
+		
+		# serialize :point, Map.for_earth.index
+		def index
+			klass = Class.new(Index)
+			
+			klass.map = self
+			
+			return klass
+		end
+	end
+end