Refactor attribute

Author: ndem0

pygem/freeform.py

@@ -86,12 +86,8 @@ def perform(self):
         # translation and then affine transformation
         translation = self.parameters.origin_box
 
-        physical_frame = np.array([
-            self.parameters.position_vertex_1 - translation,
-            self.parameters.position_vertex_2 - translation,
-            self.parameters.position_vertex_3 - translation, [0, 0, 0]
-        ])
-        reference_frame = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 0, 0]])
+        physical_frame = self.parameters.position_vertices - translation
+        reference_frame = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]])
 
         transformation = at.affine_points_fit(physical_frame, reference_frame)
         inverse_transformation = at.affine_points_fit(reference_frame,

pygem/params/ffdparams.py

@@ -41,23 +41,6 @@ class FFDParameters(object):
     :cvar numpy.ndarray array_mu_z: collects the displacements (weights) along
         z, normalized with the box lenght z.
 
-    :cvar numpy.ndarray psi_mapping: map from the pysical domain to the
-        reference domain.
-    :cvar numpy.ndarray inv_psi_mapping: map from the reference domain to the
-        physical domain.
-
-    :cvar numpy.ndarray rotation_matrix: rotation matrix (according to
-        rot_angle_x, rot_angle_y, rot_angle_z).
-
-    :cvar numpy.ndarray position_vertex_0: position of the first vertex of the
-        FFD bounding box.  It is always equal to the member `origin_box`.
-    :cvar numpy.ndarray position_vertex_1: position of the second vertex of the
-        FFD bounding box.
-    :cvar numpy.ndarray position_vertex_2: position of the third vertex of the
-        FFD bounding box.
-    :cvar numpy.ndarray position_vertex_3: position of the fourth vertex of the
-        FFD bounding box.
-
     :Example: from file
 
     >>> import pygem.params as ffdp
@@ -105,11 +88,6 @@ 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.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):
         """
@@ -140,6 +118,17 @@ def rotation_matrix(self):
             radians(self.rot_angle[2]), radians(self.rot_angle[1]),
             radians(self.rot_angle[0]))
 
+    @property
+    def position_vertices(self):
+        """
+        The position of the second vertex of the FFD bounding box.
+
+        :rtype: numpy.ndarray
+        """
+        return self.origin_box + np.vstack([
+            np.zeros((1, 3)), 
+            self.rotation_matrix.dot(np.diag(self.lenght_box)).T
+        ])
 
     def read_parameters(self, filename='parameters.prm'):
         """
@@ -198,14 +187,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.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])
-        self.position_vertex_2 = self.position_vertex_0 + \
-            np.dot(self.rotation_matrix, [0, self.lenght_box[1], 0])
-        self.position_vertex_3 = self.position_vertex_0 + \
-            np.dot(self.rotation_matrix, [0, 0, self.lenght_box[2]])
-
     def write_parameters(self, filename='parameters.prm'):
         """
         This method writes a parameters file (.prm) called `filename` and fills
@@ -316,10 +297,7 @@ def __str__(self):
         string += '\narray_mu_z =\n{}\n'.format(self.array_mu_z)
         string += '\npsi_mapping = \n{}\n'.format(self.psi_mapping)
         string += '\nrotation_matrix = \n{}\n'.format(self.rotation_matrix)
-        string += '\nposition_vertex_0 = {}\n'.format(self.position_vertex_0)
-        string += 'position_vertex_1 = {}\n'.format(self.position_vertex_1)
-        string += 'position_vertex_2 = {}\n'.format(self.position_vertex_2)
-        string += 'position_vertex_3 = {}\n'.format(self.position_vertex_3)
+        string += '\nposition_vertices = {}\n'.format(self.position_vertices)
         return string
 
     def save(self, filename, write_deformed=True):
@@ -336,7 +314,7 @@ def save(self, filename, write_deformed=True):
 
         :Example:
 
-        >>> from pygem.params_ffd import FFDParameters
+        >>> from pygem.params import FFDParameters
         >>> 
         >>> params = FFDParameters()
         >>> params.read_parameters(
@@ -418,25 +396,9 @@ def build_bounding_box(self,
                                                         triangulate_tol)
         self.origin_box = min_xyz
         self.lenght_box = max_xyz - min_xyz
-        self._set_position_of_vertices()
-        self._set_transformation_params_to_zero()
+        self.reset_deformation()
 
-    def _set_position_of_vertices(self):
-        """
-        Vertices of the control box around the object are set in this method.
-        Four vertices (non coplanar) are sufficient to uniquely identify a
-        parallelepiped -- the second half of the box is created as a mirror
-        reflection of the first four vertices.
-        """
-        self.position_vertex_0 = self.origin_box
-        self.position_vertex_1 = self.origin_box + np.array(
-            [self.lenght_box[0], .0, .0])
-        self.position_vertex_2 = self.origin_box + np.array(
-            [.0, self.lenght_box[1], .0])
-        self.position_vertex_3 = self.origin_box + np.array(
-            [.0, .0, self.lenght_box[2]])
-
-    def _set_transformation_params_to_zero(self):
+    def reset_deformation(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

tests/test_ffdparams.py

@@ -7,7 +7,7 @@
 from OCC.BRepPrimAPI import BRepPrimAPI_MakeSphere, BRepPrimAPI_MakeBox
 from OCC.gp import gp_Pnt
 
-from pygem import FFDParameters
+from pygem.params import FFDParameters
 
 
 class TestFFDParameters(TestCase):
@@ -60,25 +60,16 @@ def test_class_members_default_rotation_matrix(self):
         params = FFDParameters()
         np.testing.assert_array_almost_equal(params.rotation_matrix, np.eye(3))
 
-    def test_class_members_default_position_vertex_0(self):
+    def test_class_members_default_position_vertices(self):
         params = FFDParameters()
-        np.testing.assert_array_almost_equal(params.position_vertex_0,
-                                             np.zeros(3))
-
-    def test_class_members_default_position_vertex_1(self):
-        params = FFDParameters()
-        np.testing.assert_array_almost_equal(params.position_vertex_1,
-                                             np.array([1., 0., 0.]))
-
-    def test_class_members_default_position_vertex_2(self):
-        params = FFDParameters()
-        np.testing.assert_array_almost_equal(params.position_vertex_2,
-                                             np.array([0., 1., 0.]))
-
-    def test_class_members_default_position_vertex_3(self):
-        params = FFDParameters()
-        np.testing.assert_array_almost_equal(params.position_vertex_3,
-                                             np.array([0., 0., 1.]))
+        expected_matrix = np.array([
+            [0., 0., 0.],
+            [1., 0., 0.],
+            [0., 1., 0.],
+            [0., 0., 1.]
+        ])
+        np.testing.assert_array_almost_equal(params.position_vertices,
+                                             expected_matrix)
 
     def test_class_members_generic_n_control_points(self):
         params = FFDParameters([2, 3, 5])
@@ -180,38 +171,21 @@ def test_read_parameters_rotation_matrix(self):
     def test_read_parameters_position_vertex_0_origin(self):
         params = FFDParameters(n_control_points=[3, 2, 2])
         params.read_parameters('tests/test_datasets/parameters_sphere.prm')
-        np.testing.assert_array_almost_equal(params.position_vertex_0,
+        np.testing.assert_array_almost_equal(params.position_vertices[0],
                                              params.origin_box)
 
     def test_read_parameters_position_vertex_0(self):
         params = FFDParameters(n_control_points=[3, 2, 2])
         params.read_parameters('tests/test_datasets/parameters_sphere.prm')
-        position_vertex_0_exact = np.array([-20.0, -55.0, -45.0])
-        np.testing.assert_array_almost_equal(params.position_vertex_0,
-                                             position_vertex_0_exact)
-
-    def test_read_parameters_position_vertex_1(self):
-        params = FFDParameters(n_control_points=[3, 2, 2])
-        params.read_parameters('tests/test_datasets/parameters_sphere.prm')
-        position_vertex_1_exact = np.array(
-            [24.17322326, -52.02107006, -53.05309404])
-        np.testing.assert_array_almost_equal(params.position_vertex_1,
-                                             position_vertex_1_exact)
+        position_vertices = np.array([
+            [-20.0, -55.0, -45.0],
+            [24.17322326, -52.02107006, -53.05309404],
+            [-20., 29.41000412, -13.77579136],
+            [-2.82719042, -85.65053198, 37.85915459]
+        ])
 
-    def test_read_parameters_position_vertex_2(self):
-        params = FFDParameters(n_control_points=[3, 2, 2])
-        params.read_parameters('tests/test_datasets/parameters_sphere.prm')
-        position_vertex_2_exact = np.array([-20., 29.41000412, -13.77579136])
-        np.testing.assert_array_almost_equal(params.position_vertex_2,
-                                             position_vertex_2_exact)
-
-    def test_read_parameters_position_vertex_3(self):
-        params = FFDParameters(n_control_points=[3, 2, 2])
-        params.read_parameters('tests/test_datasets/parameters_sphere.prm')
-        position_vertex_3_exact = np.array(
-            [-2.82719042, -85.65053198, 37.85915459])
-        np.testing.assert_array_almost_equal(params.position_vertex_3,
-                                             position_vertex_3_exact)
+        np.testing.assert_array_almost_equal(params.position_vertices,
+                                             position_vertices)
 
     def test_read_parameters_failing_filename_type(self):
         params = FFDParameters(n_control_points=[3, 2, 2])
@@ -286,33 +260,32 @@ def test_build_bounding_box_2(self):
         params = FFDParameters()
         params.build_bounding_box(cube)
 
+        expected_matrix = np.array([
+            [0., 0., 0.],
+            [1., 0., 0.],
+            [0., 1., 0.],
+            [0., 0., 1.]
+        ])
         np.testing.assert_almost_equal(
-            params.position_vertex_0, origin, decimal=5)
-        np.testing.assert_almost_equal(
-            params.position_vertex_1, [1., 0., 0.], decimal=5)
-        np.testing.assert_almost_equal(
-            params.position_vertex_2, [0., 1., 0.], decimal=5)
-        np.testing.assert_almost_equal(
-            params.position_vertex_3, [0., 0., 1.], decimal=5)
+            params.position_vertices, expected_matrix, decimal=5)
 
     def test_set_position_of_vertices(self):
-        vertex_0 = [0., 0., 0.]
-        vertex_1 = [1., 0., 0.]
-        vertex_2 = [0., 1., 0.]
-        vertex_3 = [0., 0., 1.]
+        expected_matrix = np.array([
+            [0., 0., 0.],
+            [1., 0., 0.],
+            [0., 1., 0.],
+            [0., 0., 1.]
+        ])
         tops = np.array([1., 1., 1.])
         params = FFDParameters()
-        params.origin_box = vertex_0
-        params.lenght_box = tops - vertex_0
-        params._set_position_of_vertices()
-        np.testing.assert_equal(params.position_vertex_0, vertex_0)
-        np.testing.assert_equal(params.position_vertex_1, vertex_1)
-        np.testing.assert_equal(params.position_vertex_2, vertex_2)
-        np.testing.assert_equal(params.position_vertex_3, vertex_3)
+        params.origin_box = expected_matrix[0]
+        params.lenght_box = tops - expected_matrix[0]
+        np.testing.assert_almost_equal(
+            params.position_vertices, expected_matrix, decimal=5)
 
     def test_set_modification_parameters_to_zero(self):
         params = FFDParameters([5, 5, 5])
-        params._set_transformation_params_to_zero()
+        params.reset_deformation()
         np.testing.assert_almost_equal(
             params.array_mu_x, np.zeros(shape=(5, 5, 5)))
         np.testing.assert_almost_equal(