adding more test cases to raster class

fauxgeo/raster.py

@@ -11,14 +11,15 @@
 import ogr
 import osr
 import numpy as np
-from affine import Affine
+# from affine import Affine
 from shapely.geometry import Polygon
 import shapely
 import pyproj
 import PIL
-
 import pygeoprocessing as pygeo
 
+from fauxgeo.affine import Affine
+
 LOGGER = logging.getLogger('Raster Class')
 logging.basicConfig(format='%(asctime)s %(name)-15s %(levelname)-8s \
     %(message)s', level=logging.DEBUG, datefmt='%m/%d/%Y %H/%M/%S')

fauxgeo/raster_factory.py

@@ -4,8 +4,9 @@
 import random
 
 import numpy as np
-from affine import Affine
+# from affine import Affine
 
+from fauxgeo.affine import Affine
 from fauxgeo.raster import Raster
 
 

tests/test_raster.py

@@ -25,45 +25,47 @@ class TestRasterGetAndAlign(unittest.TestCase):
     def setUp(self):
         self.shape = (3, 4)
         self.array = np.ones(self.shape)
-        self.affine = Affine(1, 0, 0, 0, 1, 0)
-        self.misaligned_affine = Affine(1, 0, 0, 0, 1, 1)
+        self.affine = Affine(1, 0, 0, 0, -1, 3)
+        self.misaligned_affine = Affine(1, 0, 0, 0, -1, 4)
         self.proj = 4326
         self.datatype = gdal.GDT_Float64
         self.nodata_val = -9999
-
-        self.raster = Raster.from_array(
-            self.array, self.affine, self.proj, self.datatype, self.nodata_val)
-        self.aligned_raster = Raster.from_array(
-            np.zeros(self.shape), self.affine, self.proj, self.datatype, self.nodata_val)
-        self.misaligned_raster = Raster.from_array(
-            self.array, self.misaligned_affine, self.proj, self.datatype, self.nodata_val)
+        self.factory = RasterFactory(
+            self.proj, self.datatype, self.nodata_val, *self.shape, affine=self.affine)
+        self.misaligned_factory = RasterFactory(
+            self.proj, self.datatype, self.nodata_val, *self.shape, affine=self.misaligned_affine)
 
     def test_get_functions(self):
-        assert(self.raster.get_rows() == self.shape[0])
-        assert(self.raster.get_cols() == self.shape[1])
-        assert(self.raster.get_shape() == self.shape)
-        np.testing.assert_array_equal(self.raster.get_band(1), self.array)
-        np.testing.assert_array_equal(
-            self.raster.get_bands(), np.array([self.array]))
-        assert(self.raster.get_nodata(1) == self.nodata_val)
-        assert(self.raster.get_datatype(1) == self.datatype)
-        assert(self.raster.get_geotransform() == self.affine.to_gdal())
-        assert(self.raster.get_affine() == self.affine)
-        assert(self.raster.get_projection() == 4326)
+        a = self.factory.uniform(1.0)
+        assert(a.get_rows() == self.shape[0])
+        assert(a.get_cols() == self.shape[1])
+        assert(a.get_shape() == self.shape)
+        assert(a.get_nodata(1) == self.nodata_val)
+        assert(a.get_datatype(1) == self.datatype)
+        assert(a.get_geotransform() == self.affine.to_gdal())
+        assert(a.get_affine() == self.affine)
+        assert(a.get_projection() == 4326)
 
     def test_is_aligned(self):
-        assert(self.raster.is_aligned(self.aligned_raster) == True)
-        assert(self.raster.is_aligned(self.misaligned_raster) == False)
+        a = self.factory.uniform(1.0)
+        b = self.factory.uniform(1.0)
+        c = self.misaligned_factory.uniform(1.0)
+        assert(a.is_aligned(b) == True)
+        assert(a.is_aligned(c) == False)
 
     def test_align(self):
-        assert(self.raster.is_aligned(self.misaligned_raster) == False)
-        new_raster = self.raster.align(self.misaligned_raster, "nearest")
-        assert(self.raster.is_aligned(new_raster) == True)
+        a = self.factory.uniform(1.0)
+        b = self.misaligned_factory.uniform(1.0)
+        assert(a.is_aligned(b) == False)
+        c = a.align(b, "nearest")
+        assert(a.is_aligned(c) == True)
 
     def test_align_to(self):
-        assert(self.raster.is_aligned(self.misaligned_raster) == False)
-        new_raster = self.misaligned_raster.align_to(self.raster, "nearest")
-        assert(self.raster.is_aligned(new_raster) == True)
+        a = self.misaligned_factory.uniform(1.0)
+        b = self.factory.uniform(1.0)
+        assert(a.is_aligned(b) == False)
+        c = a.align_to(b, "nearest")
+        assert(b.is_aligned(c) == True)
 
 
 class TestRasterCopy(unittest.TestCase):
@@ -143,7 +145,7 @@ def test_rdiv(self):
     def test_rpow(self):
         a = self.factory.alternating(2.0, 3.0)
         b = 4 ** a
-        assert(b.get_band(1)[0, 0] == 8)
+        assert(b.get_band(1)[0, 0] == 16)
 
 
 class TestRasterReclass(unittest.TestCase):
@@ -158,15 +160,105 @@ def setUp(self):
             self.proj, self.datatype, self.nodata_val, *self.shape, affine=self.affine)
 
     def test_reclass(self):
-        pass
+        a = self.factory.alternating(1.0, 2.0)
+        reclass_dict = {1: 3, 2: 4}
+        b = a.reclass(reclass_dict)
+        assert(b.get_band(1)[0, 0] == 3)
+        assert(b.get_band(1)[0, 1] == 4)
 
 
 class TestRasterClip(unittest.TestCase):
-    pass
+    def setUp(self):
+        self.shape = (3, 4)
+        self.array = np.ones(self.shape)
+        self.affine = Affine(1, 0, 0, 0, -1, 3)
+        self.proj = 4326
+        self.datatype = gdal.GDT_Float64
+        self.nodata_val = -9999
+        self.factory = RasterFactory(
+            self.proj, self.datatype, self.nodata_val, *self.shape, affine=self.affine)
 
 
 class TestRasterBoundingBox(unittest.TestCase):
-    pass
+    def setUp(self):
+        self.shape = (3, 4)
+        self.array = np.ones(self.shape)
+        self.affine = Affine(1, 0, 0, 0, -1, 3)
+        self.proj = 4326
+        self.datatype = gdal.GDT_Float64
+        self.nodata_val = -9999
+        self.factory = RasterFactory(
+            self.proj, self.datatype, self.nodata_val, *self.shape, affine=self.affine)
+
+    def test_bounding_box(self):
+        a = self.factory.alternating(1.0, 2.0)
+        assert(a.get_bounding_box() == [0.0, 3.0, 4.0, 0.0])
+
+
+class TestRasterSetNodataAndDatatype(unittest.TestCase):
+    def setUp(self):
+        self.shape = (3, 4)
+        self.array = np.ones(self.shape)
+        self.affine = Affine(1, 0, 0, 0, -1, 3)
+        self.proj = 4326
+        self.datatype = gdal.GDT_Float64
+        self.nodata_val = -9999
+        self.factory = RasterFactory(
+            self.proj, self.datatype, self.nodata_val, *self.shape, affine=self.affine)
+
+    def test_set_nodata(self):
+        a = self.factory.alternating(1.0, 2.0)
+        b = a.set_nodata(-1)
+        assert(b.get_nodata(1) == -1)
+        assert(a.uri != b.uri)
+
+    def test_set_datatype(self):
+        a = self.factory.alternating(1.0, 2.0)
+        b = a.set_datatype(gdal.GDT_Int16)
+        assert(b.get_datatype(1) == gdal.GDT_Int16)
+        assert(a.uri != b.uri)
+
+    def test_set_nodata_and_datatype(self):
+        a = self.factory.alternating(1.0, 2.0)
+        b = a.set_datatype_and_nodata(gdal.GDT_Int16, -1)
+        assert(b.get_nodata(1) == -1)
+        assert(b.get_datatype(1) == gdal.GDT_Int16)
+        assert(a.uri != b.uri)
+
+
+class TestRasterReproject(unittest.TestCase):
+    def setUp(self):
+        self.shape = (3, 4)
+        self.array = np.ones(self.shape)
+        self.affine = Affine(1, 0, 0, 0, -1, 3)
+        self.proj = 4326
+        self.datatype = gdal.GDT_Float64
+        self.nodata_val = -9999
+        self.factory = RasterFactory(
+            self.proj, self.datatype, self.nodata_val, *self.shape, affine=self.affine)
+
+    def test_reproject(self):
+        # This test needs to be more rigorous
+        a = self.factory.alternating(1.0, 2.0)
+        b = a.reproject(32631, 'nearest', pixel_size=1000)
+        assert(b.get_shape() == (333, 444))
+
+
+class TestRasterResizePixels(unittest.TestCase):
+    def setUp(self):
+        self.shape = (4, 4)
+        self.array = np.ones(self.shape)
+        self.affine = Affine(1, 0, 0, 0, -1, 4)
+        self.proj = 4326
+        self.datatype = gdal.GDT_Float64
+        self.nodata_val = -9999
+        self.factory = RasterFactory(
+            self.proj, self.datatype, self.nodata_val, *self.shape, affine=self.affine)
+
+    def test_resize_pixels(self):
+        a = self.factory.alternating(1.0, 2.0)
+        b = a.resize_pixels(0.5, 'nearest')
+        assert(b.get_shape() == (8, 8))
 
 if __name__ == '__main__':
     unittest.main()

tests/test_raster_factory.py

@@ -19,7 +19,7 @@
 from fauxgeo.raster_factory import RasterFactory
 
 
-class Test_RasterFactory(unittest.TestCase):
+class TestRasterFactory(unittest.TestCase):
 
     def setUp(self):
         self.shape = (3, 3)