Get initial e2e test working

.gitignore

 /local
 /InterCal.egg-info
 *.pyc
-.*.swp
+.*.sw?

intercal/modis.py

+
+import pyhdf.SD
+from intercal.util import great_circle_dist
+
+def circle_stats(mod03_file, circle_lat, circle_lon, circle_radius):
+
+    sd = pyhdf.SD.SD(str(mod03_file))
+    sds = sd.select('Latitude')
+    lat = sds.get()
+    sds.endaccess()
+    sds = sd.select('Longitude')
+    lon = sds.get()
+    sds.endaccess()
+    d = great_circle_dist(lat, lon, circle_lat, circle_lon)
+    return (d <= circle_radius).sum()
+

intercal/test/cases/__init__.py

+
+def load_case(name):
+
+    pass
+

intercal/test/cases/modis.json

+{
+    "distance_threshold": 50.0,
+    "elements": 1354,
+    "lines": 2030,
+    "mid_lat": 40.995255,
+    "mid_lon": -21.367945,
+    "mod021km_file": "/mnt/flofs/ingest/modis/aqua/2014/001/MYD021KM.006/MYD021KM.A2014001.1430.006.2014009211719.hdf",
+    "mod03_file": "/mnt/flofs/ingest/modis/aqua/2014/001/MYD03.006/MYD03.A2014001.1430.006.2014009190828.hdf",
+    "n": 7761
+}

intercal/test/cases/modis.py

+
+import os
+import pyhdf.SD
+from intercal.util import great_circle_dist
+
+mod03_file = ('/mnt/flofs/ingest/modis/aqua/2014/001/MYD03.006/'
+                  'MYD03.A2014001.1430.006.2014009190828.hdf')
+mod021km_file = ('/mnt/flofs/ingest/modis/aqua/2014/001/MYD021KM.006/'
+                     'MYD021KM.A2014001.1430.006.2014009211719.hdf')
+
+sd = pyhdf.SD.SD(mod03_file)
+lat = sd.select('Latitude').get()
+lon = sd.select('Longitude').get()
+lines, elements = lat.shape
+mid_lat = lat[lines/2,elements/2]
+mid_lon = lon[lines/2,elements/2]
+distance_threshold = 50.0
+n = (great_circle_dist(lat, lon, mid_lat, mid_lon) <= distance_threshold).sum()
+

intercal/test/cases/util.py

+
+import json
+import os
+import sys
+
+def main():
+
+    case_name = sys.argv[1]
+    case_vars = execute_case(case_name)
+    generate_case_output(case_vars, case_name)
+
+def execute_case(case_name):
+
+    case_vars = {}
+    execfile(case_file(case_name, '.py'), case_vars)
+    case_vars = filter_unserializable_case_vars(case_vars)
+    return case_vars
+
+def filter_unserializable_case_vars(case_vars):
+
+    new_vars = {}
+    for key, value in case_vars.items():
+        try:
+            value = eval(repr(value))
+            json.dumps(value)
+            new_vars[key] = value
+        except (SyntaxError, TypeError):
+            pass
+    return new_vars
+
+def generate_case_output(case_vars, case_name):
+
+    output = json.dumps(case_vars, sort_keys=True, indent=4, separators=(',', ': ')) + '\n'
+    with open(case_file(case_name, '.json'), 'w') as output_file:
+        output_file.write(output)
+    sys.stdout.write(output)
+
+def case_file(case_name, suffix):
+
+    return os.path.join(os.path.dirname(__file__), case_name + suffix)
+
+def load_case(name):
+
+    with open(case_file(name, '.json')) as f:
+        return Bunch(**json.load(f))
+
+class Bunch(object):
+
+    """Provide attribute access to values in a dict with string keys
+
+    Swiped from Alex Martelli off Stack Overflow.
+    """
+
+    def __init__(self, **d):
+
+        self.__dict__.update(d)
+
+if __name__ == '__main__':
+    main()
+     

intercal/test/e2e/test.py

 
 from unittest import TestCase
+from intercal.modis import circle_stats
+from intercal.test.cases.util import load_case
 
-class NewProjectE2eTest(TestCase):
+class IntercalTest(TestCase):
 
-    def test_works(self):
+    def test_counts_number_of_modis_pixels_near_a_ground_point(self):
 
-        pass
+        c = load_case('modis')
+        n = circle_stats(c.mod03_file, c.mid_lat, c.mid_lon, c.distance_threshold)
 

intercal/test/unit/test_util.py

+
+from unittest import TestCase
+import numpy as np
+from intercal.util import great_circle_dist, earth_radius
+
+class GreatCircleDistTest(TestCase):
+
+    def test_handles_zero_distance(self):
+
+        madison_lat, madison_lon = 43.07, -89.40
+        d = great_circle_dist(madison_lat, madison_lon, madison_lat, madison_lon)
+        self.assertAlmostEqual(d, 0.0)
+
+    def test_handles_maximum_distance(self):
+
+        self.assertAlmostEqual(great_circle_dist(90.0, 0.0, -90.0, 0.0), np.pi * earth_radius)
+        self.assertAlmostEqual(great_circle_dist(0.0, 0.0, 0.0, 180.0), np.pi * earth_radius)
+
+    def test_handles_new_york_to_los_angeles(self):
+
+        # test case created using gcmap.com (JFK->LAX); the result didn't agree exactly
+        # and i'm guessing that's because gcmap.com computes a minimal geodesic path
+        # while great_circle_dist assumes a spherical earth
+        ny_lat, ny_lon = 40.64, -73.78
+        la_lat, la_lon = 33.94, -118.41
+        expected_distance = 3983.0
+        self.assertAlmostEqual(great_circle_dist(ny_lat, ny_lon, la_lat, la_lon),
+                               expected_distance, delta=10.0)
+
+    def test_works_with_numpy_arrays(self):
+
+        lat_1, lon_1 = np.zeros([2, 2, 1])
+        lat_2, lon_2 = np.zeros([2, 1, 2])
+        d = great_circle_dist(lat_1, lon_1, lat_2, lon_2)
+        self.assertEqual(d.shape, (2, 2))
+        self.assertAlmostEqual(d[0,0], 0.0)
+

intercal/util.py

+
+import numpy as np
+
+def great_circle_dist(lat_1, lon_1, lat_2, lon_2):
+
+    """Great circle distance in kilometers between 2 ground points"""
+
+    lat_1, lon_1, lat_2, lon_2 = [np.radians(x) for x in [lat_1, lon_1, lat_2, lon_2]]
+    tmp = (np.sin(lat_1) * np.sin(lat_2) + np.cos(lat_1) * np.cos(lat_2) * np.cos(lon_1 - lon_2))
+    return np.arccos(tmp) * earth_radius
+
+earth_radius = 6371.0
+

setup.py

@@ -6,7 +6,7 @@ def run_setup():
     setup(name='InterCal',
           version='DEV',
           packages=find_packages(),
-          install_requires=['nose', 'numpy', 'pyhdf'],
+          install_requires=['matplotlib', 'nose', 'numpy', 'pyhdf'],
           zip_safe=False)
 
 if __name__ == '__main__':