Clean params classes

Author: ndem0

pygem/__init__.py

@@ -1,17 +1,17 @@
 """
 """
 __all__ = [
-    'affine', 'filehandler', 'freeform', 'radial', 'openfhandler', 'params',
+    'affine', 'filehandler', 'freeform', 'radial', 'openfhandler',
     'stlhandler', 'unvhandler', 'vtkhandler', 'nurbshandler', 'stephandler',
-    'igeshandler', 'utils', 'gui', 'khandler', 'idw', 'params_idw'
+    'igeshandler', 'utils', 'gui', 'khandler', 'idw', 'params_idw',
+    'params_rbf', 'params_ffd'
 ]
 
 from . import affine
 from . import filehandler
 from . import freeform
 from . import radial
 from . import openfhandler
-from . import params
 from . import stlhandler
 from . import unvhandler
 from . import vtkhandler
@@ -23,3 +23,5 @@
 from . import khandler
 from . import idw
 from . import params_idw
+from . import params_rbf
+from . import params_ffd

pygem/params.py pygem/params_ffd.pypygem/params.py renamed to pygem/params_ffd.py

@@ -25,27 +25,14 @@ class FFDParameters(object):
     :param list n_control_points: number of control points in the x, y, and z
         direction.  If not provided it is set to [2, 2, 2].
 
-    :cvar float length_box_x: length of the FFD bounding box in the x direction
-        (local coordinate system).
-    :cvar float length_box_y: length of the FFD bounding box in the y direction
-        (local coordinate system).
-    :cvar float length_box_z: length of the FFD bounding box in the z direction
-        (local coordinate system).
-
-    :cvar numpy.ndarray origin_box: a 3-by-1 vector of float numbers
-        representing the x, y and z coordinates of the origin of the FFD
-        bounding box.
-
-    :cvar float rot_angle_x: rotation angle around x axis of the FFD bounding
-        box.
-    :cvar float rot_angle_y: rotation angle around y axis of the FFD bounding
-        box.
-    :cvar float rot_angle_z: rotation angle around z axis of the FFD bounding
-        box.
-
-    :cvar list n_control_points: list of 3 int representing the number of
-        control points in the x, y, and z direction.
-
+    :cvar numpy.ndarray length_box: dimension of the FFD bounding box, in the
+        x, y and z direction (local coordinate system).
+    :cvar numpy.ndarray origin_box: the x, y and z coordinates of the origin of
+        the FFD bounding box.
+    :cvar numpy.ndarray rot_angle: rotation angle around x, y and z axis of the
+        FFD bounding box.
+    :cvar numpy.ndarray n_control_points: the number of control points in the
+        x, y, and z direction.
     :cvar numpy.ndarray array_mu_x: collects the displacements (weights) along
         x, normalized with the box lenght x.
     :cvar numpy.ndarray array_mu_y: collects the displacements (weights) along
@@ -73,16 +60,18 @@ class FFDParameters(object):
     :Example: from file
 
     >>> import pygem.params as ffdp
-
+    >>> 
     >>> # Reading an existing file
     >>> params1 = ffdp.FFDParameters()
-    >>> params1.read_parameters(filename='tests/test_datasets/parameters_test_ffd_identity.prm')
-
-    >>> # Creating a default parameters file with the right dimensions (if the file does not exists
-    >>> # it is created with that name). So it is possible to manually edit it and read it again.
+    >>> params1.read_parameters(
+    >>>     filename='tests/test_datasets/parameters_test_ffd_identity.prm')
+    >>> 
+    >>> # Creating a default parameters file with the right dimensions (if the
+    >>> # file does not exists it is created with that name). So it is possible
+    >>> # to manually edit it and read it again.
     >>> params2 = ffdp.FFDParameters(n_control_points=[2, 3, 2])
     >>> params2.read_parameters(filename='parameters_test.prm')
-
+    >>> 
     >>> # Creating bounding box of the given shape
     >>> from OCC.IGESControl import IGESControl_Reader
     >>> params3 = ffdp.FFDParameters()
@@ -115,15 +104,42 @@ def __init__(self, n_control_points=None):
         self.array_mu_y = np.zeros(self.n_control_points)
         self.array_mu_z = np.zeros(self.n_control_points)
 
-        self.psi_mapping = np.diag(1. / self.lenght_box)
-        self.inv_psi_mapping = np.diag(self.lenght_box)
-
-        self.rotation_matrix = np.eye(3)
         self.position_vertex_0 = self.origin_box
         self.position_vertex_1 = np.array([1., 0., 0.])
         self.position_vertex_2 = np.array([0., 1., 0.])
         self.position_vertex_3 = np.array([0., 0., 1.])
 
+    @property
+    def psi_mapping(self):
+        """
+        Map from the physical domain to the reference domain.
+
+        :return: map from the pysical domain to the reference domain.
+        :rtype: numpy.ndarray
+        """
+        return np.diag(np.reciprocal(self.lenght_box))
+
+    @property
+    def inv_psi_mapping(self):
+        """
+        Map from the reference domain to the physical domain.
+
+        :return: map from the reference domain to  domain.
+        :rtype: numpy.ndarray
+        """
+        return np.diag(self.lenght_box)
+
+    @property
+    def rotation_matrix(self):
+        """
+    :cvar numpy.ndarray rotation_matrix: rotation matrix (according to
+        rot_angle_x, rot_angle_y, rot_angle_z).
+        """
+        return at.angles2matrix(
+            radians(self.rot_angle[2]), radians(self.rot_angle[1]),
+            radians(self.rot_angle[0]))
+
+
     def read_parameters(self, filename='parameters.prm'):
         """
         Reads in the parameters file and fill the self structure.
@@ -181,10 +197,6 @@ def read_parameters(self, filename='parameters.prm'):
             values = line.split()
             self.array_mu_z[tuple(map(int, values[0:3]))] = float(values[3])
 
-        self.rotation_matrix = at.angles2matrix(
-            radians(self.rot_angle[2]), radians(self.rot_angle[1]),
-            radians(self.rot_angle[0]))
-
         self.position_vertex_0 = self.origin_box
         self.position_vertex_1 = self.position_vertex_0 + \
             np.dot(self.rotation_matrix, [self.lenght_box[0], 0, 0])
@@ -193,9 +205,6 @@ def read_parameters(self, filename='parameters.prm'):
         self.position_vertex_3 = self.position_vertex_0 + \
             np.dot(self.rotation_matrix, [0, 0, self.lenght_box[2]])
 
-        self.psi_mapping = np.diag(1. / self.lenght_box)
-        self.inv_psi_mapping = np.diag(self.lenght_box)
-
     def write_parameters(self, filename='parameters.prm'):
         """
         This method writes a parameters file (.prm) called `filename` and fills
@@ -343,24 +352,10 @@ def build_bounding_box(self,
         min_xyz, max_xyz = self._calculate_bb_dimension(shape, tol, triangulate,
                                                         triangulate_tol)
         self.origin_box = min_xyz
-        self._set_box_dimensions(min_xyz, max_xyz)
+        self.lenght_box = max_xyz - min_xyz
         self._set_position_of_vertices()
-        self._set_mapping()
         self._set_transformation_params_to_zero()
 
-    def _set_box_dimensions(self, min_xyz, max_xyz):
-        """
-        Dimensions of the cage are set as distance from the origin (minimum) of
-        the cage to the maximal point in each dimension.
-
-        :param iterable min_xyz: three values representing the minimal values of
-            the bounding box in XYZ respectively
-        :param iterable max_xyz: three values representing the maximal values of
-            the bounding box in XYZ respectively
-        """
-        dims = [max_xyz[i] - min_xyz[i] for i in range(3)]
-        self.lenght_box = np.asarray(dims)
-
     def _set_position_of_vertices(self):
         """
         Vertices of the control box around the object are set in this method.
@@ -376,24 +371,15 @@ def _set_position_of_vertices(self):
         self.position_vertex_3 = self.origin_box + np.array(
             [.0, .0, self.lenght_box[2]])
 
-    def _set_mapping(self):
-        """
-        This method sets mapping from physcial domain to the reference domain
-        (``psi_mapping``) as well as inverse mapping (``inv_psi_mapping``).
-        """
-        self.psi_mapping = np.diag([1. / self.lenght_box[i] for i in range(3)])
-        self.inv_psi_mapping = np.diag(self.lenght_box)
-
     def _set_transformation_params_to_zero(self):
         """
         Sets transfomration parameters (``array_mu_x, array_mu_y, array_mu_z``)
         to arrays of zeros (``numpy.zeros``). The shape of arrays corresponds to
         the number of control points in each dimension.
         """
-        ctrl_pnts = self.n_control_points
-        self.array_mu_x = np.zeros(ctrl_pnts)
-        self.array_mu_y = np.zeros(ctrl_pnts)
-        self.array_mu_z = np.zeros(ctrl_pnts)
+        self.array_mu_x.fill(0.0)
+        self.array_mu_y.fill(0.0)
+        self.array_mu_z.fill(0.0)
 
     @staticmethod
     def _calculate_bb_dimension(shape,
@@ -428,170 +414,3 @@ def _calculate_bb_dimension(shape,
         xyz_min = np.array([xmin, ymin, zmin])
         xyz_max = np.array([xmax, ymax, zmax])
         return xyz_min, xyz_max
-
-
-class RBFParameters(object):
-    """
-    Class that handles the Radial Basis Functions parameters in terms of RBF
-    control points and basis functions.
-
-    :cvar string basis: name of the basis functions to use in the
-        transformation. The functions implemented so far are: gaussian spline,
-        multi quadratic biharmonic spline, inv multi quadratic biharmonic
-        spline, thin plate spline, beckert wendland c2 basis, polyharmonic
-        splines. For a comprehensive list with details see the class
-    :class:`~pygem.radialbasis.RBF`.  The default value is None.
-    :cvar float radius: is the scaling parameter r that affects the shape of the
-        basis functions.  For details see the class
-        :class:`~pygem.radialbasis.RBF`. The default value is None.
-    :cvar int n_control_points: total number of control points.
-    :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 value
-        is None.
-    :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 value is
-        None.
-    """
-
-    def __init__(self):
-        self.basis = None
-        self.radius = None
-        self.power = 2
-        self.n_control_points = None
-        self.original_control_points = None
-        self.deformed_control_points = None
-
-    def read_parameters(self, filename='parameters_rbf.prm'):
-        """
-        Reads in the parameters file and fill the self structure.
-
-        :param string filename: parameters file to be read in. Default value is
-            parameters_rbf.prm.
-        """
-        if not isinstance(filename, str):
-            raise TypeError('filename must be a string')
-
-        # Checks if the parameters file exists. If not it writes the default
-        # class into filename.  It consists in the vetices of a cube of side one
-        # with a vertex in (0, 0, 0) and opposite one in (1, 1, 1).
-        if not os.path.isfile(filename):
-            self.basis = 'gaussian_spline'
-            self.radius = 0.5
-            self.n_control_points = 8
-            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.]).reshape((8, 3))
-            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.]).reshape((8, 3))
-            self.write_parameters(filename)
-            return
-
-        config = configparser.RawConfigParser()
-        config.read(filename)
-
-        self.basis = config.get('Radial Basis Functions', 'basis function')
-        self.radius = config.getfloat('Radial Basis Functions', 'radius')
-        self.power = config.getint('Radial Basis Functions', 'power')
-
-        ctrl_points = config.get('Control points', 'original control points')
-        lines = ctrl_points.split('\n')
-        self.n_control_points = len(lines)
-        self.original_control_points = np.zeros((self.n_control_points, 3))
-        for line, i in zip(lines, list(range(0, self.n_control_points))):
-            values = line.split()
-            self.original_control_points[i] = np.array(
-                [float(values[0]),
-                 float(values[1]),
-                 float(values[2])])
-
-        mod_points = config.get('Control points', 'deformed control points')
-        lines = mod_points.split('\n')
-
-        if len(lines) != self.n_control_points:
-            raise TypeError("The number of control points must be equal both in the 'original control points'" + \
-                " and in the 'deformed control points' section of the parameters file ({0!s})".format(filename))
-
-        self.deformed_control_points = np.zeros((self.n_control_points, 3))
-        for line, i in zip(lines, list(range(0, self.n_control_points))):
-            values = line.split()
-            self.deformed_control_points[i] = np.array(
-                [float(values[0]),
-                 float(values[1]),
-                 float(values[2])])
-
-    def write_parameters(self, filename='parameters_rbf.prm'):
-        """
-        This method writes a parameters file (.prm) called `filename` and fills
-        it with all the parameters class members. Default value is
-        parameters_rbf.prm.
-
-        :param string filename: parameters file to be written out.
-        """
-        if not isinstance(filename, str):
-            raise TypeError("filename must be a string")
-
-        with open(filename, 'w') as output_file:
-            output_file.write('\n[Radial Basis Functions]\n')
-            output_file.write(
-                '# This section describes the radial basis functions shape.\n')
-
-            output_file.write('\n# basis funtion is the name of the basis functions to use in the transformation. ' + \
-                'The functions\n')
-            output_file.write(
-                '# implemented so far are: gaussian_spline, multi_quadratic_biharmonic_spline,\n'
-            )
-            output_file.write(
-                '# inv_multi_quadratic_biharmonic_spline, thin_plate_spline, beckert_wendland_c2_basis, polyharmonic_spline.\n'
-            )
-            output_file.write(
-                '# For a comprehensive list with details see the class RBF.\n')
-            output_file.write('basis function: ' + str(self.basis) + '\n')
-
-            output_file.write('\n# radius is the scaling parameter r that affects the shape of the basis functions. ' + \
-                'See the documentation\n')
-            output_file.write('# of the class RBF for details.\n')
-            output_file.write('radius: ' + str(self.radius) + '\n')
-            output_file.write(
-                '\n# The power parameter k for polyharmonic spline')
-            output_file.write('\n# See the documentation for details\n')
-            output_file.write('power: ' + str(self.power) + '\n')
-
-            output_file.write('\n\n[Control points]\n')
-            output_file.write(
-                '# This section describes the RBF control points.\n')
-
-            output_file.write('\n# original control points collects the coordinates of the interpolation ' + \
-                'control points before the deformation.\n')
-            output_file.write('original control points:')
-            offset = 1
-            for i in range(0, self.n_control_points):
-                output_file.write(offset * ' ' + str(self.original_control_points[i][0]) + '   ' + \
-                    str(self.original_control_points[i][1]) + '   ' + \
-                    str(self.original_control_points[i][2]) + '\n')
-                offset = 25
-
-            output_file.write('\n# deformed control points collects the coordinates of the interpolation ' + \
-                'control points after the deformation.\n')
-            output_file.write('deformed control points:')
-            offset = 1
-            for i in range(0, self.n_control_points):
-                output_file.write(offset * ' ' + str(self.deformed_control_points[i][0]) + '   ' + \
-                    str(self.deformed_control_points[i][1]) + '   ' + \
-                    str(self.deformed_control_points[i][2]) + '\n')
-                offset = 25
-
-    def __str__(self):
-        """
-        This method prints all the RBF parameters on the screen. Its purpose is
-        for debugging.
-        """
-        string = ''
-        string += 'basis function = {}\n'.format(self.basis)
-        string += 'radius = {}\n'.format(self.radius)
-        string += 'power = {}\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