fixed tutorials and documentation, applied code formatter

Author: guglielmopadula

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

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

docs/source/bffd.rst

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

docs/source/vffd.rst

@@ -13,6 +13,7 @@
 import numpy as np
 from scipy.optimize import LinearConstraint, differential_evolution
 
+
 class CFFD(FFD):
     """
     Class that handles the Constrained Free Form Deformation on the mesh points.
@@ -44,77 +45,79 @@ class CFFD(FFD):
         on x,y,z respectively. Default is all true. It used only in the triaffine mode.
 
     :Example:
-
         >>> from pygem import CFFD
         >>> import numpy as np
-        >>> original_mesh_points = np.load('tests/test_datasets/meshpoints_sphere_orig.npy')
+        >>> original_mesh_points = np.random.rand(100, 3)
         >>> 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)
         >>> cffd = CFFD(b, fun, [2, 2, 2])
-        >>> cffd.read_parameters('tests/test_datasets/parameters_test_ffd_sphere.prm')
+        >>> cffd.read_parameters('tests/test_datasets/parameters_test_cffd.prm')
         >>> cffd.adjust_control_points(original_mesh_points[:-4])
-        >>> assert np.isclose(np.linalg.norm(fun(cffd.ffd(original_mesh_points[:-4])) - b), np.array([0.]),atol = 1e-06)
+        >>> assert np.isclose(np.linalg.norm(fun(cffd.ffd(original_mesh_points[:-4])) - b), np.array([0.]), atol = 1e-06)
         >>> new_mesh_points = cffd.ffd(original_mesh_points)
-    """
 
+    """
     def __init__(self,
-                fixval,
-                fun,
-                n_control_points=None,
-                ffd_mask=None,
-                fun_mask=None):
+                 fixval,
+                 fun,
+                 n_control_points=None,
+                 ffd_mask=None,
+                 fun_mask=None):
         super().__init__(n_control_points)
 
         if ffd_mask is None:
-            self.ffd_mask = np.full((*self.n_control_points, 3), True, dtype=bool)
+            self.ffd_mask = np.full((*self.n_control_points, 3),
+                                    True,
+                                    dtype=bool)
         else:
             self.ffd_mask = ffd_mask
 
-        self.num_cons=len(fixval)
-        self.fun=fun
-        self.fixval=fixval
+        self.num_cons = len(fixval)
+        self.fun = fun
+        self.fixval = fixval
         if fun_mask is None:
             self.fun_mask = np.full((self.num_cons, 3), True, dtype=bool)
         else:
             self.fun_mask = fun_mask
-    def adjust_control_points(self,src_pts):
+
+    def adjust_control_points(self, src_pts):
         '''
         Adjust the FFD control points such that fun(ffd(src_pts))=fixval
             
         :param np.ndarray src_pts: the points whose deformation we want to be 
             constrained.
         :rtype: None.
         '''
-        hyper_param=self.fun_mask.copy().astype(float)
-        hyper_param=hyper_param/np.sum(hyper_param,axis=1)
+        hyper_param = self.fun_mask.copy().astype(float)
+        hyper_param = hyper_param / np.sum(hyper_param, axis=1)
         mask_bak = self.ffd_mask.copy()
-        fixval_bak=self.fixval.copy()
+        fixval_bak = self.fixval.copy()
         diffvolume = self.fixval - self.fun(self.ffd(src_pts))
         for i in range(3):
-            self.ffd_mask = np.full((*self.n_control_points, 3), False, dtype=bool)
+            self.ffd_mask = np.full((*self.n_control_points, 3),
+                                    False,
+                                    dtype=bool)
             self.ffd_mask[:, :, :, i] = mask_bak[:, :, :, i].copy()
-            self.fixval = self.fun(self.ffd(src_pts)) + hyper_param[:,i] * (
-                diffvolume
-            )
+            self.fixval = self.fun(
+                self.ffd(src_pts)) + hyper_param[:, i] * (diffvolume)
             saved_parameters = self._save_parameters()
             indices = np.arange(np.prod(self.n_control_points) *
                                 3)[self.ffd_mask.reshape(-1)]
             A, b = self._compute_linear_map(src_pts, saved_parameters.copy(),
-                                        indices)
-            A=A[self.fun_mask[:,i].reshape(-1),:]
-            b=b[self.fun_mask[:,i].reshape(-1)]
+                                            indices)
+            A = A[self.fun_mask[:, i].reshape(-1), :]
+            b = b[self.fun_mask[:, i].reshape(-1)]
             d = A @ saved_parameters[indices] + b
-            fixval=self.fixval[self.fun_mask[:,i].reshape(-1)]
+            fixval = self.fixval[self.fun_mask[:, i].reshape(-1)]
             deltax = np.linalg.multi_dot([
                 A.T,
-                np.linalg.inv(np.linalg.multi_dot([A, A.T])),
-                (fixval - d)
+                np.linalg.inv(np.linalg.multi_dot([A, A.T])), (fixval - d)
             ])
             saved_parameters[indices] = saved_parameters[indices] + deltax
             self._load_parameters(saved_parameters)
         self.ffd_mask = mask_bak.copy()
-        self.fixval=fixval_bak.copy()
+        self.fixval = fixval_bak.copy()
 
     def ffd(self, src_pts):
         '''
@@ -182,7 +185,7 @@ def _compute_linear_map(self, src_pts, saved_parameters, indices):
         A = sol[0].T[:, :-1]  #coefficient
         b = sol[0].T[:, -1]  #intercept
         return A, b
-    
+
 
 class BFFD(CFFD):
     '''
@@ -213,33 +216,27 @@ class BFFD(CFFD):
     :Example:
 
         >>> from pygem import BFFD
-        >>> import numpy as np
         >>> b = np.random.rand(3)
         >>> bffd = BFFD(b, [2, 2, 2])
-        >>> bffd.read_parameters('tests/test_datasets/parameters_test_ffd_sphere.prm')
-        >>> original_mesh_points = np.load('tests/test_datasets/meshpoints_sphere_orig.npy')
+        >>> 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)
+        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 __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],
+        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.
@@ -275,35 +272,33 @@ class VFFD(CFFD):
         >>> from pygem import VFFD
         >>> import numpy as np
         >>> import meshio
-        >>> mesh = meshio.read('tests/test_datasets/test_sphere.stl')  
+        >>> mesh = meshio.read('tests/test_datasets/test_sphere_cffd.stl')
         >>> original_mesh_points = mesh.points
         >>> triangles = mesh.cells_dict["triangle"]
-        >>> b = np.random.rand()
-        >>> vffd = VFFD(triangles, b,[2, 2, 2])
-        >>> vffd.read_parameters('tests/test_datasets/parameters_test_ffd_sphere.prm')
+        >>> 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)
+        >>> 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)
 
-    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
 
-        self.triangles=triangles
         def volume_inn(x):
-            return _volume(x,self.triangles)
+            return _volume(x, self.triangles)
 
         self.fun = volume_inn
-        self.fixval=fixval
-        self.fun_mask=np.array([[True, True, True]])
-        
-def _volume(x,triangles):
+        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/cffd.py

@@ -2,44 +2,48 @@
 import os
 from unittest import TestCase
 import numpy as np
-from pygem import CFFD,BFFD,VFFD
+from pygem import CFFD, BFFD, VFFD
 from pygem.cffd import _volume
 
+
 class TestCFFD(TestCase):
 
     def test_nothing_happens_cffd(self):
         np.random.seed(0)
-        original_mesh_points = np.random.rand(100,3)
+        original_mesh_points = np.random.rand(100, 3)
         A = np.random.rand(3, original_mesh_points.reshape(-1).shape[0])
 
         def fun(x):
             x = x.reshape(-1)
             return A @ x
 
         b = fun(original_mesh_points)
-        cffd = CFFD(b,fun)
+        cffd = CFFD(b, fun)
         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
+        assert np.linalg.norm(original_mesh_points - new_mesh_points
+                              ) / np.linalg.norm(original_mesh_points) < 1e-02
 
     def test_constraint_cffd(self):
         np.random.seed(0)
-        original_mesh_points = np.random.rand(100,3)
+        original_mesh_points = np.random.rand(100, 3)
         A = np.random.rand(3, original_mesh_points.reshape(-1).shape[0])
+
         def fun(x):
             x = x.reshape(-1)
             return A @ x
 
-        b = fun(original_mesh_points)+0.02*np.random.rand(3)
-        cffd = CFFD(b,fun)
+        b = fun(original_mesh_points) + 0.02 * np.random.rand(3)
+        cffd = CFFD(b, fun)
         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-fun(new_mesh_points))/np.linalg.norm(b)<1e-02
+        assert np.linalg.norm(b -
+                              fun(new_mesh_points)) / np.linalg.norm(b) < 1e-02
 
     def test_nothing_happens_vffd(self):
         np.random.seed(0)
-        points = 0.5*np.array([
+        points = 0.5 * np.array([
             [0.0, 1.0, 0.0],
             [0.0, 0.0, 1.0],
             [0.0, 1.0, 1.0],
@@ -64,16 +68,16 @@ def test_nothing_happens_vffd(self):
             [6, 2, 1],
             [6, 1, 4],
         ])
-        b = _volume(points,triangles)
-        cffd = VFFD(triangles,b)
+        b = _volume(points, triangles)
+        cffd = VFFD(triangles, b)
         cffd.adjust_control_points(points)
         new_mesh_points = cffd.ffd(points)
-        new_fix=cffd.fun(new_mesh_points)
+        new_fix = cffd.fun(new_mesh_points)
         assert np.allclose(np.linalg.norm(points - new_mesh_points), 0.0)
 
     def test_constraint_vffd(self):
         np.random.seed(0)
-        points = 0.5*np.array([
+        points = 0.5 * np.array([
             [0.0, 1.0, 0.0],
             [0.0, 0.0, 1.0],
             [0.0, 1.0, 1.0],
@@ -98,32 +102,34 @@ def test_constraint_vffd(self):
             [6, 2, 1],
             [6, 1, 4],
         ])
-        b = _volume(points,triangles)+0.02*np.random.rand()
-        cffd = VFFD(triangles,b)
+        b = _volume(points, triangles) + 0.02 * np.random.rand()
+        cffd = VFFD(triangles, b)
         cffd.read_parameters('tests/test_datasets/parameters_test_cffd.prm')
         cffd.adjust_control_points(points)
         new_mesh_points = cffd.ffd(points)
-        new_fix=cffd.fun(new_mesh_points)
-        assert np.linalg.norm(new_fix - b)/np.linalg.norm(b)<1e-02
-    
+        new_fix = cffd.fun(new_mesh_points)
+        assert np.linalg.norm(new_fix - b) / np.linalg.norm(b) < 1e-02
+
     def test_nothing_happens_bffd(self):
         np.random.seed(0)
-        original_mesh_points = np.random.rand(100,3)
+        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)
+        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
+        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)
+        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)
+        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
+        assert np.linalg.norm(
+            b - np.mean(new_mesh_points, axis=0)) / np.linalg.norm(b) < 1e-02