Approximations

tkrajina · tkrajina · commit 720eee3e6b58 · 2013-05-31T15:20:52.000+02:00
diff --git a/README.md b/README.md
@@ -6,9 +6,14 @@ See: [http://www2.jpl.nasa.gov/srtm/](http://www2.jpl.nasa.gov/srtm/).
 
 ## Usage:
 
-    >>> import srtm
-    >>> elevation_data = srtm.get_data()
-    >>> print 'CGN Airport elevation (meters):', elevation_data.get_elevation(50.8682, 7.1377)
+    import srtm
+    elevation_data = srtm.get_data()
+    print 'CGN Airport elevation (meters):', elevation_data.get_elevation(50.8682, 7.1377)
+
+With get\_elevation() an elevation of the the nearest location found in the SRTM data will be given.
+If you need an approximation based on nearby locations, you can use:
+
+    elevation_data.get_elevation(50.8682, 7.1377, approximate=True)
 
 You can create elevation images with:
 
diff --git a/srtm/data.py b/srtm/data.py
@@ -52,7 +52,7 @@ def __init__(self, srtm1_files, srtm3_files, files_directory):
 
         self.files = {}
 
-    def get_elevation(self, latitude, longitude):
+    def get_elevation(self, latitude, longitude, approximate=None):
         geo_elevation_file = self.get_file(float(latitude), float(longitude))
 
         mod_logging.debug('File for ({0}, {1}) -> {2}'.format(
@@ -61,7 +61,10 @@ def get_elevation(self, latitude, longitude):
         if not geo_elevation_file:
             return None
 
-        return geo_elevation_file.get_elevation(float(latitude), float(longitude))
+        return geo_elevation_file.get_elevation(
+                float(latitude),
+                float(longitude),
+                approximate)
 
     def get_file(self, latitude, longitude):
         """
@@ -79,7 +82,7 @@ def get_file(self, latitude, longitude):
             if not data:
                 return None
 
-            result = GeoElevationFile(file_name, data)
+            result = GeoElevationFile(file_name, data, self)
             self.files[file_name] = result
             return result
 
@@ -195,7 +198,12 @@ def get_image(self, size, latitude_interval, longitude_interval, max_elevation,
         return image
 
 class GeoElevationFile:
-    """ Contains data from a single Shuttle elevation file. """
+    """
+    Contains data from a single Shuttle elevation file.
+
+    This class hould not be instantiated without its GeoElevationData because 
+    it may need elevations from nearby files.
+    """
 
     file_name = None
     url = None
@@ -205,9 +213,10 @@ class GeoElevationFile:
 
     data = None
 
-    def __init__(self, file_name, data):
+    def __init__(self, file_name, data, geo_elevation_data):
         """ Data is a raw file contents of the file. """
 
+        self.geo_elevation_data = geo_elevation_data
         self.file_name = file_name
 
         self.parse_file_name_starting_position()
@@ -219,19 +228,66 @@ def __init__(self, file_name, data):
 
         self.square_side = int(square_side)
 
-    def get_elevation(self, latitude, longitude):
+    def get_elevation(self, latitude, longitude, approximate=None):
+        """
+        If approximate is True then only the points from SRTM grid will be 
+        used, otherwise a basic aproximation of nearby points will be calculated.
+        """
         if not (self.latitude <= latitude < self.latitude + 1):
             raise Exception('Invalid latitude %s for file %s' % (latitude, self.file_name))
         if not (self.longitude <= longitude < self.longitude + 1):
             raise Exception('Invalid longitude %s for file %s' % (longitude, self.file_name))
 
         points = self.square_side ** 2
 
-        pdb.set_trace()
-        row = int(mod_math.floor((self.latitude + 1 - latitude) * float(self.square_side - 1)))
-        column = int(mod_math.floor((longitude - self.longitude) * float(self.square_side - 1)))
+        row = mod_math.floor((self.latitude + 1 - latitude) * float(self.square_side - 1))
+        column = mod_math.floor((longitude - self.longitude) * float(self.square_side - 1))
+
+        if approximate:
+            return self.approximation(latitude, longitude)
+        else:
+            return self.get_elevation_from_row_and_column(int(row), int(column))
+    
+    def approximation(self, latitude, longitude):
+        """
+        Dummy approximation with nearest points. The nearest the neighbour the 
+        more important will be its elevation.
+        """
+        d = 1. / self.square_side
+        d_meters = d * mod_utils.ONE_DEGREE
 
-        return self.get_elevation_from_row_and_column(row, column)
+        # Since the less the distance => the more important should be the 
+        # distance of the point, we'll use d-distance as importance coef 
+        # here:
+        importance_1 = d_meters - mod_utils.distance(latitude + d, longitude, latitude, longitude)
+        elevation_1  = self.geo_elevation_data.get_elevation(latitude + d, longitude, approximate=False)
+
+        importance_2 = d_meters - mod_utils.distance(latitude - d, longitude, latitude, longitude)
+        elevation_2  = self.geo_elevation_data.get_elevation(latitude - d, longitude, approximate=False)
+
+        importance_3 = d_meters - mod_utils.distance(latitude, longitude + d, latitude, longitude)
+        elevation_3  = self.geo_elevation_data.get_elevation(latitude, longitude + d, approximate=False)
+
+        importance_4 = d_meters - mod_utils.distance(latitude, longitude - d, latitude, longitude)
+        elevation_4  = self.geo_elevation_data.get_elevation(latitude, longitude - d, approximate=False)
+        # TODO(TK) Check if coordinates inside the same file, and only the decide if to xall 
+        # self.geo_elevation_data.get_elevation or just self.get_elevation
+
+        # Normalize importance:
+        sum_importances = float(importance_1 + importance_2 + importance_3 + importance_4)
+
+        # Check normallization:
+        assert abs(importance_1 / sum_importances + \
+                   importance_2 / sum_importances + \
+                   importance_3 / sum_importances + \
+                   importance_4 / sum_importances - 1 ) < 0.000001
+
+        result = importance_1 / sum_importances * elevation_1 + \
+               importance_2 / sum_importances * elevation_2 + \
+               importance_3 / sum_importances * elevation_3 + \
+               importance_4 / sum_importances * elevation_4
+
+        return result
 
     def get_elevation_from_row_and_column(self, row, column):
         i = row * (self.square_side) + column
diff --git a/srtm/utils.py b/srtm/utils.py
@@ -14,6 +14,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import math as mod_math
+
+ONE_DEGREE = 1000. * 10000.8 / 90.
+
+def distance(latitude_1, longitude_1, latitude_2, longitude_2):
+    """
+    Distance between two points.
+    """
+
+    coef = mod_math.cos(latitude_1 / 180. * mod_math.pi)
+    x = latitude_1 - latitude_2
+    y = (longitude_1 - longitude_2) * coef
+
+    return mod_math.sqrt(x * x + y * y) * ONE_DEGREE
+
 def get_color_between(color1, color2, i):
     """ i is a number between 0 and 1, if 0 then color1, if 1 color2, ... """
     if i <= 0:
diff --git a/test.py b/test.py
@@ -83,7 +83,7 @@ def test_invalit_coordinates_for_file(self):
             message = str(e)
             self.assertEquals('Invalid longitude 1 for file N47E013.hgt', message)
 
-    def test_invalit_file(self):
+    def test_invalid_file(self):
         geo_elevation_data = mod_srtm.get_data()
         geo_file = geo_elevation_data.get_file(-47.0, -13.99)
         self.assertEquals(None, geo_file)
@@ -97,3 +97,34 @@ def test_coordinates_in_file(self):
         self.assertEquals(geo_file.get_elevation(47, 13),
                           geo_file.get_elevation(47, 13))
 
+    def test_without_approximation(self):
+        geo_elevation_data = mod_srtm.get_data()
+
+        self.assertEquals(geo_elevation_data.get_elevation(47.1, 13.1, approximate=False),
+                          geo_elevation_data.get_elevation(47.1, 13.1))
+
+        # SRTM elevations are always integers:
+        elevation = geo_elevation_data.get_elevation(47.1, 13.1)
+        self.assertTrue(int(elevation) == elevation)
+
+    def test_with_approximation(self):
+        geo_elevation_data = mod_srtm.get_data()
+
+        self.assertNotEquals(geo_elevation_data.get_elevation(47.1, 13.1, approximate=True),
+                             geo_elevation_data.get_elevation(47.1, 13.1))
+
+        # When approximating a random point, it probably won't be a integer:
+        elevation = geo_elevation_data.get_elevation(47.1, 13.1, approximate=True)
+        self.assertTrue(int(elevation) != elevation)
+
+    def test_approximation(self):
+        # TODO(TK) Better tests for approximation here:
+        geo_elevation_data = mod_srtm.get_data()
+        elevation_without_approximation = geo_elevation_data.get_elevation(47, 13)
+        elevation_with_approximation = geo_elevation_data.get_elevation(47, 13, approximate=True)
+
+        print elevation_without_approximation
+        print elevation_with_approximation
+
+        self.assertNotEquals(elevation_with_approximation, elevation_without_approximation)
+        self.assertTrue(abs(elevation_with_approximation - elevation_without_approximation) < 30)
