Adds check if variables_files have same properties

pymica/pymica2.py

@@ -3,11 +3,13 @@
 '''
 import json
 from multiprocessing.sharedctypes import Value
+from tabnanny import check
 
 from interpolation.idw import idw
 from interpolation.inverse_distance import inverse_distance
 from interpolation.inverse_distance_3d import inverse_distance_3d
-from numpy import concatenate, newaxis
+from numpy import asarray, concatenate, newaxis, array_equal
+import numpy as np
 from osgeo import gdal, ogr, osr
 
 from pymica.apply_regression import (apply_clustered_regression,
@@ -21,9 +23,7 @@ class PyMica:
     them with the interpolated residuals and saves files and gives
     errors.
     '''
-    def __init__(self, methodology, variables_file,
-                 clusters=None, data_format=None,
-                 z_field='altitude', config={}):
+    def __init__(self, methodology, config):
         '''
         Args:
             data_file (str): The path with the point data
@@ -68,17 +68,16 @@ def __init__(self, methodology, variables_file,
                 print('id_penalization not in the configuration dictionary. '
                       'id_penalization set to default value of 30.')
             self.smoothing = config.get('id_penalization', 30.0)
-
-
 
+        '''
         if data_format is None:
             self.data_format = {'loc_vars': ('lon', 'lat'),
                                 'id_key': 'id',
                                 'y_var': 'temp',
                                 'x_vars': ('altitude', 'dist')}
         else:
             self.data_format = data_format
-
+        '''
         if 'power' in config.keys():
             self.power = float(config['power'])
         else:
@@ -93,19 +92,22 @@ def __init__(self, methodology, variables_file,
             self.penalization = float(config['penalization'])
         else:
             self.penalization = 30.0
-
+        '''
         with open(data_file, "r") as f_p:
             data = json.load(f_p)
-
-        self.__read_variables_files__(variables_file)
+        '''
+        # self.__read_variables_files__(variables_file)
 
         in_proj = osr.SpatialReference()
         in_proj.ImportFromEPSG(4326)
+        self.config = config
 
-        transf = osr.CoordinateTransformation(in_proj, self.out_proj)
+        self.__check_variables__()
 
-        cl_reg, out_data = self.__get_regression_results(clusters, data)
+        # transf = osr.CoordinateTransformation(in_proj, self.out_proj)
 
+        # cl_reg, out_data = self.__get_regression_results(clusters, data)
+        '''
         residuals = cl_reg.get_residuals()
         residuals_data = {}
 
@@ -148,8 +150,36 @@ def __init__(self, methodology, variables_file,
                              " \"id3d\" or \"idw\"")
 
         self.result = out_data - residuals_field
-
-    def interpolate(data_file)
+        '''
+
+    def __check_variables__(self):
+        """Checks if the properties of variables are the same with each other.
+
+        Raises:
+            ValueError: If properties of variable fields are not the same with
+                        each other.
+        """
+        if len(self.config['variables_files'].keys()) < 2:
+            pass
+        for i, var in enumerate(list(self.config['variables_files'].keys())):
+            var_ds = gdal.Open(self.config['variables_files'][var])
+            if i == 0:
+                var_md = np.array([var_ds.GetGeoTransform(),
+                                   var_ds.GetProjectionRef(),
+                                   var_ds.RasterXSize,
+                                   var_ds.RasterYSize], dtype='object')
+                check_equal = True
+            else:
+                check_equal = array_equal(np.array([var_ds.GetGeoTransform(),
+                                                    var_ds.GetProjectionRef(),
+                                                    var_ds.RasterXSize,
+                                                    var_ds.RasterYSize],
+                                                   dtype='object'),
+                                          var_md)
+            if check_equal is False:
+                raise ValueError('Variables properties are not the same. '
+                                 'Variables fields must have the same '
+                                 'GeoTransform, Projection, XSize and YSize.')
 
     def save_file(self, file_name):
         '''Saves the calculate field data into a file

test/pymica2_test.py

@@ -0,0 +1,118 @@
+'''Tests for pymica.pymica.py
+'''
+from operator import methodcaller
+import unittest
+from tempfile import gettempdir
+
+import numpy as np
+from osgeo import gdal, osr
+from pymica.pymica2 import PyMica
+
+
+class TestPyMica2(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.variables_file = gettempdir() + '/variables.tiff'
+        cls.config = {'variables_files':
+                      {'altitude': gettempdir() + '/altitude.tif',
+                       'd_coast': gettempdir() + '/d_coast.tif'}}
+        cls.config_wrong = {'variables_files':
+                            {'altitude': gettempdir() + '/altitude.tif',
+                             'd_coast': gettempdir() + '/d_coast_2.tif'}}
+
+        size = [1000, 1000]
+        alt_data = np.ones(size)
+        alt_data[2][2] = 12
+
+        dist_data = np.ones(size)
+
+        proj = osr.SpatialReference()
+        proj.ImportFromEPSG(25831)
+
+        driver = gdal.GetDriverByName('GTiff')
+
+        # Create fake altitude field
+        d_s = driver.Create(cls.config['variables_files']['altitude'],
+                            size[1], size[0], 1, gdal.GDT_Float32)
+        d_s.GetRasterBand(1).WriteArray(alt_data)
+        d_s.SetGeoTransform((260000, 270, 0, 4750000, 0, -270))
+        d_s.SetProjection(proj.ExportToWkt())
+        d_s = None
+
+        # Create fake distance to coast field
+        d_s = driver.Create(cls.config['variables_files']['d_coast'],
+                            size[1], size[0], 1, gdal.GDT_Float32)
+        d_s.GetRasterBand(1).WriteArray(dist_data)
+        d_s.SetGeoTransform((260000, 270, 0, 4750000, 0, -270))
+        d_s.SetProjection(proj.ExportToWkt())
+        d_s = None
+
+        # Create wrong fake distance to coast field
+        d_s = driver.Create(cls.config_wrong['variables_files']['d_coast'],
+                            3, 3, 1, gdal.GDT_Float32)
+        d_s.GetRasterBand(1).WriteArray(dist_data[:3, :3])
+        d_s.SetGeoTransform((260000, 270, 0, 4750000, 0, -270))
+        d_s.SetProjection(proj.ExportToWkt())
+        d_s = None
+
+    def test_init(cls):
+
+        mlr_id2d = PyMica(methodology='mlr+id2d', config=cls.config)
+        cls.assertEqual(mlr_id2d.smoothing, 0.0)
+        cls.assertEqual(mlr_id2d.power, 2.5)
+
+        mlr_id3d = PyMica(methodology='mlr+id3d', config=cls.config)
+        cls.assertEqual(mlr_id3d.smoothing, 0.0)
+        cls.assertEqual(mlr_id3d.power, 2.5)
+        cls.assertEqual(mlr_id3d.penalization, 30)
+
+    def test_init_wrong_variables_files(cls):
+        with cls.assertRaises(ValueError) as cm:
+            PyMica(methodology='mlr+id2d', config=cls.config_wrong)
+        cls.assertEqual('Variables properties are not the same. '
+                        'Variables fields must have the same '
+                        'GeoTransform, Projection, XSize and YSize.',
+                        str(cm.exception))
+
+    def test_init_different_vars(self):
+        with open("./test/data/sample_data.json") as d_s:
+            data = d_s.read()
+        with open(gettempdir() + "/sample_data.json", "w") as d_s:
+            d_s.write(data.replace('id', 'other_id')
+                          .replace('temp', 'other_var')
+                          .replace('dist', 'other_x_var'))
+
+        data_format = {'loc_vars': ('lon', 'lat'),
+                       'id_key': 'other_id',
+                       'y_var': 'other_var',
+                       'x_vars': ('altitude', 'other_x_var')}
+        inst = PyMica(gettempdir() + "/sample_data.json", self.variables_file,
+                      self.clusters, data_format)
+        self.assertEqual(inst.result.shape, (1000, 1000))
+
+    @unittest.skip
+    def test_errors(self):
+
+        with self.assertRaises(FileNotFoundError) as cm:
+            PyMica("BadFile", self.variables_file,
+                   self.clusters)
+        self.assertEqual(
+            "[Errno 2] No such file or directory: 'BadFile'",
+            str(cm.exception))
+
+        with self.assertRaises(FileNotFoundError) as cm:
+            PyMica("./test/data/sample_data.json", ["BadFile"])
+        self.assertEqual(
+            "[Errno 2] No such file or directory: 'BadFile'",
+            str(cm.exception))
+
+        with self.assertRaises(ValueError) as cm:
+            PyMica("./test/data/sample_data.json", self.variables_file,
+                   residuals_int='BadMethdology')
+        self.assertEqual(
+            "[Errno 2]residuals_int must be \"id2d\"," +
+            " \"id3d\" or \"idw\"",
+            str(cm.exception)
+            )
+        # TODO : mask doesn't exist or clusters bad formatted
+        # TODO : Bad variable names passed