separate things again, fixed docs and tutorialx

Author: guglielmopadula

docs/source/_tutorials/tutorial-7-cffd.html

@@ -1,15 +1,15 @@
 Barycenter Free-form Deformation
 =====================
 
-.. currentmodule:: pygem.cffd
+.. currentmodule:: pygem.bffd
 
-.. automodule:: pygem.cffd
+.. automodule:: pygem.bffd
 
 .. autosummary::
 	:toctree: _summaries
 	:nosignatures:
 
-.. autoclass:: pygem.cffd.BFFD
+.. autoclass:: pygem.bffd.BFFD
 	:members:
 	:special-members: __call__
 	:private-members:

docs/source/bffd.rst

@@ -1,15 +1,15 @@
 Volume Free-form Deformation
 =====================
 
-.. currentmodule:: pygem.cffd
+.. currentmodule:: pygem.vffd
 
-.. automodule:: pygem.cffd
+.. automodule:: pygem.vffd
 
 .. autosummary::
 	:toctree: _summaries
 	:nosignatures:
 
-.. autoclass:: pygem.cffd.VFFD
+.. autoclass:: pygem.vffd.VFFD
 	:members:
 	:special-members: __call__
 	:private-members:

docs/source/vffd.rst

@@ -15,9 +15,11 @@
 
 from .deformation import Deformation
 from .ffd import FFD
-from .cffd import CFFD,BFFD,VFFD
+from .cffd import CFFD
 from .rbf import RBF
 from .idw import IDW
 from .rbf_factory import RBFFactory
 from .custom_deformation import CustomDeformation
 from .meta import *
+from .bffd import BFFD
+from .vffd import VFFD

pygem/__init__.py

@@ -0,0 +1,52 @@
+from pygem.cffd import CFFD
+import numpy as np
+class BFFD(CFFD):
+    '''
+    Class that handles the Barycenter Free Form Deformation on the mesh points.
+ 
+    :param list n_control_points: number of control points in the x, y, and z
+        direction. Default is [2, 2, 2].
+        
+    :cvar numpy.ndarray box_length: dimension of the FFD bounding box, in the
+        x, y and z direction (local coordinate system).
+    :cvar numpy.ndarray box_origin: the x, y and z coordinates of the origin 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 length x.
+    :cvar numpy.ndarray array_mu_y: collects the displacements (weights) along
+        y, normalized with the box length y.
+    :cvar numpy.ndarray array_mu_z: collects the displacements (weights) along
+        z, normalized with the box length z.
+    :cvar callable fun: it defines the F of the constraint F(x)=c. Default is the constant 1 function.
+    :cvar numpy.ndarray fixval: it defines the c of the constraint F(x)=c. Default is 1.
+    :cvar numpy.ndarray mask: a boolean tensor that tells to the class 
+        which control points can be moved, and in what direction, to enforce the constraint. 
+        The tensor has shape (n_x,n_y,n_z,3), where the last dimension indicates movement
+        on x,y,z respectively. Default is all true.
+
+    :Example:
+
+        >>> from pygem import BFFD
+        >>> b = np.random.rand(3)
+        >>> bffd = BFFD(b, [2, 2, 2])
+        >>> bffd.read_parameters('tests/test_datasets/parameters_test_cffd')
+        >>> original_mesh_points = np.load("tests/test_datasets/test_sphere_cffd.npy")
+        >>> bffd.adjust_control_points(original_mesh_points[:-4])
+        >>> assert np.isclose(np.linalg.norm(bffd.fun(bffd.ffd(original_mesh_points[:-4])) - b), np.array([0.]))
+        >>> new_mesh_points = bffd.ffd(original_mesh_points)
+    '''
+
+    def __init__(self, fixval=None, n_control_points=None, ffd_mask=None):
+        super().__init__(fixval, None, n_control_points, ffd_mask, None)
+
+        def linfun(x):
+            return np.mean(x.reshape(-1, 3), axis=0)
+
+        self.fun = linfun
+        self.fixval = fixval
+        self.fun_mask = np.array([[True, False, False], [False, True, False],
+                                  [False, False, True]])
+
+

pygem/bffd.py

@@ -47,7 +47,7 @@ class CFFD(FFD):
     :Example:
         >>> from pygem import CFFD
         >>> import numpy as np
-        >>> original_mesh_points = np.random.rand(100, 3)
+        >>> original_mesh_points = np.load("tests/test_datasets/test_sphere_cffd.npy")
         >>> A = np.random.rand(3, original_mesh_points[:-4].reshape(-1).shape[0])
         >>> fun = lambda x: A @ x.reshape(-1)
         >>> b = np.random.rand(3)
@@ -184,121 +184,4 @@ def _compute_linear_map(self, src_pts, saved_parameters, indices):
                               rcond=None)  #computation of the linear map
         A = sol[0].T[:, :-1]  #coefficient
         b = sol[0].T[:, -1]  #intercept
-        return A, b
-
-
-class BFFD(CFFD):
-    '''
-    Class that handles the Barycenter Free Form Deformation on the mesh points.
- 
-    :param list n_control_points: number of control points in the x, y, and z
-        direction. Default is [2, 2, 2].
-        
-    :cvar numpy.ndarray box_length: dimension of the FFD bounding box, in the
-        x, y and z direction (local coordinate system).
-    :cvar numpy.ndarray box_origin: the x, y and z coordinates of the origin 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 length x.
-    :cvar numpy.ndarray array_mu_y: collects the displacements (weights) along
-        y, normalized with the box length y.
-    :cvar numpy.ndarray array_mu_z: collects the displacements (weights) along
-        z, normalized with the box length z.
-    :cvar callable fun: it defines the F of the constraint F(x)=c. Default is the constant 1 function.
-    :cvar numpy.ndarray fixval: it defines the c of the constraint F(x)=c. Default is 1.
-    :cvar numpy.ndarray mask: a boolean tensor that tells to the class 
-        which control points can be moved, and in what direction, to enforce the constraint. 
-        The tensor has shape (n_x,n_y,n_z,3), where the last dimension indicates movement
-        on x,y,z respectively. Default is all true.
-
-    :Example:
-
-        >>> from pygem import BFFD
-        >>> b = np.random.rand(3)
-        >>> bffd = BFFD(b, [2, 2, 2])
-        >>> bffd.read_parameters('tests/test_datasets/parameters_test_cffd')
-        >>> original_mesh_points = np.random.rand(100, 3)
-        >>> bffd.adjust_control_points(original_mesh_points[:-4])
-        >>> assert np.isclose(np.linalg.norm(bffd.fun(bffd.ffd(original_mesh_points[:-4])) - b), np.array([0.]))
-        new_mesh_points = bffd.ffd(original_mesh_points)
-    '''
-
-    def __init__(self, fixval=None, n_control_points=None, ffd_mask=None):
-        super().__init__(fixval, None, n_control_points, ffd_mask, None)
-
-        def linfun(x):
-            return np.mean(x.reshape(-1, 3), axis=0)
-
-        self.fun = linfun
-        self.fixval = fixval
-        self.fun_mask = np.array([[True, False, False], [False, True, False],
-                                  [False, False, True]])
-
-
-class VFFD(CFFD):
-    '''
-    Class that handles the Volumetric Free Form Deformation on the mesh points.
- 
-    :param list n_control_points: number of control points in the x, y, and z
-        direction. Default is [2, 2, 2].
-    :param string mode: it can be ``affine`` or ``triaffine``. The first option is for the F that are affine in all the coordinates of the points. 
-        The second one is for functions that are F in the coordinates of the points. The first option implies the second, but is optimal for that class of functions.
-    :cvar numpy.ndarray box_length: dimension of the FFD bounding box, in the
-        x, y and z direction (local coordinate system).
-    :cvar numpy.ndarray box_origin: the x, y and z coordinates of the origin 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 length x.
-    :cvar numpy.ndarray array_mu_y: collects the displacements (weights) along
-        y, normalized with the box length y.
-    :cvar numpy.ndarray array_mu_z: collects the displacements (weights) along
-        z, normalized with the box length z.
-    :cvar callable fun: it defines the F of the constraint F(x)=c. Default is the constant 1 function.
-    :cvar numpy.ndarray fixval: it defines the c of the constraint F(x)=c. Default is 1.
-    :cvar numpy.ndarray ffd_mask: a boolean tensor that tells to the class 
-        which control points can be moved, and in what direction, to enforce the constraint. 
-        The tensor has shape (n_x,n_y,n_z,3), where the last dimension indicates movement
-        on x,y,z respectively. Default is all true.
-    :cvar numpy.ndarray fun_mask: a boolean tensor that tells to the class 
-        on which axis which constraint depends on. The tensor has shape (n_cons,3), where the last dimension indicates dependency on
-        on x,y,z respectively. Default is all true. It used only in the triaffine mode.
-
-    :Example:
-
-        >>> from pygem import VFFD
-        >>> import numpy as np
-        >>> import meshio
-        >>> mesh = meshio.read('tests/test_datasets/test_sphere_cffd.stl')
-        >>> original_mesh_points = mesh.points
-        >>> triangles = mesh.cells_dict["triangle"]
-        >>> b = np.random.rand(1)
-        >>> vffd = VFFD(triangles, b, [2, 2, 2])
-        >>> vffd.read_parameters('tests/test_datasets/parameters_test_cffd.prm')
-        >>> vffd.adjust_control_points(original_mesh_points)
-        >>> new_mesh_points = vffd(original_mesh_points)
-        >>> assert np.isclose(np.linalg.norm(vffd.fun(new_mesh_points) - b), np.array([0.]), atol=1e-07)
-
-    '''
-    def __init__(self, triangles, fixval, n_control_points=None, ffd_mask=None):
-        super().__init__(fixval, None, n_control_points, ffd_mask, None)
-
-        self.triangles = triangles
-
-        def volume_inn(x):
-            return _volume(x, self.triangles)
-
-        self.fun = volume_inn
-        self.fixval = fixval
-        self.fun_mask = np.array([[True, True, True]])
-
-
-def _volume(x, triangles):
-    x = x.reshape(-1, 3)
-    mesh = x[triangles]
-    return np.array([np.sum(np.linalg.det(mesh))])
-
-
+        return A, b

pygem/cffd.py

@@ -0,0 +1,67 @@
+from pygem.cffd import CFFD
+import numpy as np
+class VFFD(CFFD):
+    '''
+    Class that handles the Volumetric Free Form Deformation on the mesh points.
+ 
+    :param list n_control_points: number of control points in the x, y, and z
+        direction. Default is [2, 2, 2].
+    :param string mode: it can be ``affine`` or ``triaffine``. The first option is for the F that are affine in all the coordinates of the points. 
+        The second one is for functions that are F in the coordinates of the points. The first option implies the second, but is optimal for that class of functions.
+    :cvar numpy.ndarray box_length: dimension of the FFD bounding box, in the
+        x, y and z direction (local coordinate system).
+    :cvar numpy.ndarray box_origin: the x, y and z coordinates of the origin 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 length x.
+    :cvar numpy.ndarray array_mu_y: collects the displacements (weights) along
+        y, normalized with the box length y.
+    :cvar numpy.ndarray array_mu_z: collects the displacements (weights) along
+        z, normalized with the box length z.
+    :cvar callable fun: it defines the F of the constraint F(x)=c. Default is the constant 1 function.
+    :cvar numpy.ndarray fixval: it defines the c of the constraint F(x)=c. Default is 1.
+    :cvar numpy.ndarray ffd_mask: a boolean tensor that tells to the class 
+        which control points can be moved, and in what direction, to enforce the constraint. 
+        The tensor has shape (n_x,n_y,n_z,3), where the last dimension indicates movement
+        on x,y,z respectively. Default is all true.
+    :cvar numpy.ndarray fun_mask: a boolean tensor that tells to the class 
+        on which axis which constraint depends on. The tensor has shape (n_cons,3), where the last dimension indicates dependency on
+        on x,y,z respectively. Default is all true. It used only in the triaffine mode.
+
+    :Example:
+
+        >>> from pygem import VFFD
+        >>> import numpy as np
+        >>> import meshio
+        >>> mesh = meshio.read('tests/test_datasets/test_sphere_cffd.stl')
+        >>> original_mesh_points = mesh.points
+        >>> triangles = mesh.cells_dict["triangle"]
+        >>> b = np.random.rand(1)
+        >>> vffd = VFFD(triangles, b, [2, 2, 2])
+        >>> vffd.read_parameters('tests/test_datasets/parameters_test_cffd.prm')
+        >>> vffd.adjust_control_points(original_mesh_points)
+        >>> new_mesh_points = vffd(original_mesh_points)
+        >>> assert np.isclose(np.linalg.norm(vffd.fun(new_mesh_points) - b), np.array([0.]), atol=1e-07)
+
+    '''
+    def __init__(self, triangles, fixval, n_control_points=None, ffd_mask=None):
+        super().__init__(fixval, None, n_control_points, ffd_mask, None)
+
+        self.triangles = triangles
+
+        def volume_inn(x):
+            return _volume(x, self.triangles)
+
+        self.fun = volume_inn
+        self.fixval = fixval
+        self.fun_mask = np.array([[True, True, True]])
+
+
+def _volume(x, triangles):
+    x = x.reshape(-1, 3)
+    mesh = x[triangles]
+    return np.array([np.sum(np.linalg.det(mesh))])
+
+

pygem/vffd.py

@@ -0,0 +1,32 @@
+import filecmp
+import os
+from unittest import TestCase
+import numpy as np
+from pygem import BFFD
+
+
+class TestBFFD(TestCase):
+
+    def test_nothing_happens_bffd(self):
+        np.random.seed(0)
+        original_mesh_points = np.random.rand(100, 3)
+        A = np.random.rand(3, original_mesh_points.reshape(-1).shape[0])
+
+        b = np.mean(original_mesh_points, axis=0)
+        cffd = BFFD(b)
+        cffd.adjust_control_points(original_mesh_points)
+        new_mesh_points = cffd.ffd(original_mesh_points)
+        assert np.linalg.norm(original_mesh_points - new_mesh_points
+                              ) / np.linalg.norm(original_mesh_points) < 1e-02
+
+    def test_constraint_bffd(self):
+        np.random.seed(0)
+        original_mesh_points = np.random.rand(100, 3)
+        A = np.random.rand(3, original_mesh_points.reshape(-1).shape[0])
+        b = np.mean(original_mesh_points, axis=0) + 0.02 * np.random.rand(3)
+        cffd = BFFD(b)
+        cffd.read_parameters('tests/test_datasets/parameters_test_cffd.prm')
+        cffd.adjust_control_points(original_mesh_points)
+        new_mesh_points = cffd.ffd(original_mesh_points)
+        assert np.linalg.norm(
+            b - np.mean(new_mesh_points, axis=0)) / np.linalg.norm(b) < 1e-02