IDW refactoring

Author: ndem0

pygem/__init__.py

@@ -24,6 +24,7 @@ def get_current_year():
 from .deformation import Deformation
 from .ffd import FFD
 from .rbf import RBF
+from .idw import IDW
 from .rbf_factory import RBFFactory
 #from .radial import RBF
 #from .idw import IDW

pygem/idw.py

@@ -36,70 +36,83 @@
     :math:`\\mathrm{x}_i` and :math:`p` is a power parameter, typically equal to
     2.
 """
+import os
 import numpy as np
+try:
+    import configparser as configparser
+except ImportError:
+    import ConfigParser as configparser
+
 from scipy.spatial.distance import cdist
+from .deformation import Deformation
 
 
-class IDW(object):
+class IDW(Deformation):
     """
-    Class that handles the IDW technique.
-
-    :param idw_parameters: the parameters of the IDW
-    :type idw_parameters: :class:`IDWParameters`
-    :param numpy.ndarray original_mesh_points: coordinates of the original
-        points of the mesh.
-
-    :cvar parameters: the parameters of the IDW.
-    :vartype parameters: :class:`~pygem.params_idw.IDWParameters`
-    :cvar numpy.ndarray original_mesh_points: coordinates of the original
-        points of the mesh.
-    :cvar numpy.ndarray modified_mesh_points: coordinates of the deformed
-        points of the mesh.
+    Class that perform the Inverse Distance Weighting (IDW).
+
+    :cvar int power: the power parameter. The default value is 2.
+    :cvar numpy.ndarray original_control_points: it is an
+        `n_control_points`-by-3 array with the coordinates of the original
+        interpolation control points before the deformation. The default is the
+        vertices of the unit cube.
+    :cvar numpy.ndarray deformed_control_points: it is an
+        `n_control_points`-by-3 array with the coordinates of the interpolation
+        control points after the deformation. The default is the vertices of
+        the unit cube.
 
     :Example:
 
-    >>> from pygem.idw import IDW
-    >>> from pygem.params_idw import IDWParameters
+    >>> from pygem import IDW
     >>> import numpy as np
-    >>> params = IDWParameters()
-    >>> params.read_parameters('tests/test_datasets/parameters_idw_cube.prm')
     >>> nx, ny, nz = (20, 20, 20)
     >>> mesh = np.zeros((nx * ny * nz, 3))
     >>> xv = np.linspace(0, 1, nx)
     >>> yv = np.linspace(0, 1, ny)
     >>> zv = np.linspace(0, 1, nz)
     >>> z, y, x = np.meshgrid(zv, yv, xv)
-    >>> mesh = np.array([x.ravel(), y.ravel(), z.ravel()])
-    >>> original_mesh_points = mesh.T
-    >>> idw = IDW(rbf_parameters, original_mesh_points)
-    >>> idw.perform()
-    >>> new_mesh_points = idw.modified_mesh_points
+    >>> mesh_points = np.array([x.ravel(), y.ravel(), z.ravel()])
+    >>> idw = IDW()
+    >>> idw.read_parameters('tests/test_datasets/parameters_idw_cube.prm')
+    >>> new_mesh_points = idw(mesh_points.T)
     """
 
-    def __init__(self, idw_parameters, original_mesh_points):
-        self.parameters = idw_parameters
-        self.original_mesh_points = original_mesh_points
-        self.modified_mesh_points = None
+    def __init__(self,
+            original_control_points=None,
+            deformed_control_points=None,
+            power=2):
+
+        if original_control_points is None:
+            self.original_control_points = np.array(
+                [[0., 0., 0.], [0., 0., 1.], [0., 1., 0.], [1., 0., 0.],
+                 [0., 1., 1.], [1., 0., 1.], [1., 1., 0.], [1., 1., 1.]])
+        else:
+            self.original_control_points = original_control_points
+
+        if deformed_control_points is None:
+            self.deformed_control_points = np.array(
+                [[0., 0., 0.], [0., 0., 1.], [0., 1., 0.], [1., 0., 0.],
+                 [0., 1., 1.], [1., 0., 1.], [1., 1., 0.], [1., 1., 1.]])
+        else:
+            self.deformed_control_points = deformed_control_points
+
+        self.power = power
 
-    def perform(self):
+    def __call__(self, src_pts):
         """
         This method performs the deformation of the mesh points. After the
         execution it sets `self.modified_mesh_points`.
         """
 
         def distance(u, v):
-            """
-            Norm of u - v
-            """
-            return np.linalg.norm(u - v, ord=self.parameters.power)
+            """ Norm of u - v """
+            return np.linalg.norm(u - v, ord=self.power)
 
         # Compute displacement of the control points
-        displ = (self.parameters.deformed_control_points -
-                 self.parameters.original_control_points)
+        displ = self.deformed_control_points - self.original_control_points
 
         # Compute the distance between the mesh points and the control points
-        dist = cdist(self.original_mesh_points,
-                     self.parameters.original_control_points, distance)
+        dist = cdist(src_pts, self.original_control_points, distance)
 
         # Weights are set as the reciprocal of the distance if the distance is
         # not zero, otherwise 1.0 where distance is zero.
@@ -112,4 +125,82 @@ def distance(u, v):
             for wi in weights
         ])
 
-        self.modified_mesh_points = self.original_mesh_points + offset
+        return src_pts + offset
+
+    def read_parameters(self, filename):
+        """
+        Reads in the parameters file and fill the self structure.
+
+        :param string filename: parameters file to be read in.
+        """
+        if not isinstance(filename, str):
+            raise TypeError('filename must be a string')
+
+        if not os.path.isfile(filename):
+            raise IOError('filename does not exist')
+
+        config = configparser.RawConfigParser()
+        config.read(filename)
+
+        self.power = config.getint('Inverse Distance Weighting', 'power')
+
+        ctrl_points = config.get('Control points', 'original control points')
+        self.original_control_points = np.array(
+            [line.split() for line in ctrl_points.split('\n')], dtype=float)
+
+        defo_points = config.get('Control points', 'deformed control points')
+        self.deformed_control_points = np.array(
+            [line.split() for line in defo_points.split('\n')], dtype=float)
+
+    def write_parameters(self, filename):
+        """
+        This method writes a parameters file (.prm) called `filename` and fills
+        it with all the parameters class members.
+
+        :param string filename: parameters file to be written out.
+        """
+        if not isinstance(filename, str):
+            raise TypeError("filename must be a string")
+
+        output_string = ""
+        output_string += "\n[Inverse Distance Weighting]\n"
+        output_string += "# This section describes the settings of idw.\n\n"
+        output_string += "# the power parameter\n"
+        output_string += "power = {}\n".format(self.power)
+
+        output_string += "\n\n[Control points]\n"
+        output_string += "# This section describes the IDW control points.\n\n"
+        output_string += "# original control points collects the coordinates\n"
+        output_string += "# of the interpolation control points before the\n"
+        output_string += "# deformation.\n"
+
+        output_string += "original control points: "
+        output_string += (
+            '   '.join(map(str, self.original_control_points[0])) + "\n")
+        for points in self.original_control_points[1:]:
+            output_string += 25 * ' ' + '   '.join(map(str, points)) + "\n"
+        output_string += "\n"
+        output_string += "# deformed control points collects the coordinates\n"
+        output_string += "# of the interpolation control points after the\n"
+        output_string += "# deformation.\n"
+        output_string += "deformed control points: "
+        output_string += (
+            '   '.join(map(str, self.original_control_points[0])) + "\n")
+        for points in self.deformed_control_points[1:]:
+            output_string += 25 * ' ' + '   '.join(map(str, points)) + "\n"
+
+        with open(filename, 'w') as f:
+            f.write(output_string)
+
+    def __str__(self):
+        """
+        This method prints all the IDW parameters on the screen. Its purpose is
+        for debugging.
+        """
+        string = ''
+        string += 'p = {}\n'.format(self.power)
+        string += '\noriginal_control_points =\n'
+        string += '{}\n'.format(self.original_control_points)
+        string += '\ndeformed_control_points =\n'
+        string += '{}\n'.format(self.deformed_control_points)
+        return string

pygem/rbf.py

@@ -60,10 +60,11 @@
 
 from scipy.spatial.distance import cdist
 
+from .deformation import Deformation
 from .rbf_factory import RBFFactory
 
 
-class RBF(object):
+class RBF(Deformation):
     """
     Class that handles the Radial Basis Functions interpolation on the mesh
     points.

tests/test_idw.py

@@ -1,9 +1,8 @@
+import os
+import filecmp
+import numpy as np
 from unittest import TestCase
-import unittest
 from pygem import IDW
-from pygem import IDWParameters
-import numpy as np
-
 
 class TestIDW(TestCase):
     def get_cube_mesh_points(self):
@@ -19,20 +18,76 @@ def get_cube_mesh_points(self):
         return original_mesh_points
 
     def test_idw(self):
-        params = IDWParameters()
-        params.read_parameters('tests/test_datasets/parameters_idw_default.prm')
-        idw = IDW(params, self.get_cube_mesh_points())
+        idw = IDW()
 
-    def test_idw_perform(self):
-        params = IDWParameters()
-        params.read_parameters('tests/test_datasets/parameters_idw_default.prm')
-        IDW(params, self.get_cube_mesh_points()).perform()
+    def test_idw_call(self):
+        idw = IDW()
+        idw.read_parameters('tests/test_datasets/parameters_idw_default.prm')
+        idw(self.get_cube_mesh_points())
 
     def test_idw_perform_deform(self):
-        params = IDWParameters()
+        idw = IDW()
         expected_stretch = [1.19541593, 1.36081491, 1.42095073]
-        params.read_parameters('tests/test_datasets/parameters_idw_deform.prm')
-        idw = IDW(params, self.get_cube_mesh_points())
-        idw.perform()
-        np.testing.assert_array_almost_equal(idw.modified_mesh_points[-3],
-                                             expected_stretch)
+        idw.read_parameters('tests/test_datasets/parameters_idw_deform.prm')
+        new_pts = idw(self.get_cube_mesh_points())
+        np.testing.assert_array_almost_equal(new_pts[-3], expected_stretch)
+
+    def test_class_members_default_p(self):
+        idw = IDW()
+        assert idw.power == 2
+
+    def test_class_members_default_original_points(self):
+        idw = IDW()
+        cube_vertices = np.array([[0., 0., 0.], [0., 0., 1.], [0., 1., 0.],
+                                  [1., 0., 0.], [0., 1., 1.], [1., 0., 1.],
+                                  [1., 1., 0.], [1., 1., 1.]])
+        np.testing.assert_equal(idw.original_control_points, cube_vertices)
+
+    def test_class_members_default_deformed_points(self):
+        idw = IDW()
+        cube_vertices = np.array([[0., 0., 0.], [0., 0., 1.], [0., 1., 0.],
+                                  [1., 0., 0.], [0., 1., 1.], [1., 0., 1.],
+                                  [1., 1., 0.], [1., 1., 1.]])
+        np.testing.assert_equal(idw.deformed_control_points, cube_vertices)
+
+    def test_write_parameters_filename_default(self):
+        params = IDW()
+        outfilename = 'parameters_rbf.prm'
+        outfilename_expected = 'tests/test_datasets/parameters_idw_default.prm'
+        params.write_parameters(outfilename)
+        self.assertTrue(filecmp.cmp(outfilename, outfilename_expected))
+        os.remove(outfilename)
+
+    def test_write_not_string(self):
+        params = IDW()
+        with self.assertRaises(TypeError):
+            params.write_parameters(5)
+
+    def test_read_deformed(self):
+        params = IDW()
+        filename = 'tests/test_datasets/parameters_idw_deform.prm'
+        def_vertices = np.array([[0., 0., 0.], [0., 0., 1.], [0., 1., 0.],
+                                 [1., 0., 0.], [0., 1., 1.], [1., 0., 1.],
+                                 [1., 1., 0.], [1.5, 1.6, 1.7]])
+        params.read_parameters(filename)
+        np.testing.assert_equal(params.deformed_control_points, def_vertices)
+
+    def test_read_p(self):
+        idw = IDW()
+        filename = 'tests/test_datasets/parameters_idw_deform.prm'
+        idw.read_parameters(filename)
+        assert idw.power == 3
+
+    def test_read_not_string(self):
+        idw = IDW()
+        with self.assertRaises(TypeError):
+            idw.read_parameters(5)
+
+    def test_read_not_real_file(self):
+        idw = IDW()
+        with self.assertRaises(IOError):
+            idw.read_parameters('not_real_file')
+
+    def test_print(self):
+        idw = IDW()
+        print(idw)