added some new parameter and stl files

Author: guglielmopadula

pygem/__init__.py

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

pygem/bffd.py

@@ -11,7 +11,7 @@
 
 from pygem.ffd import FFD
 import numpy as np
-
+from scipy.optimize import LinearConstraint, differential_evolution
 
 class CFFD(FFD):
     """
@@ -42,10 +42,6 @@ class CFFD(FFD):
     :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.
-    :cvar numpy.ndarray weight_matrix: a symmetric positive definite weigth matrix. 
-        It must be of row and column size the number of trues in the mask.
-        It weights the movemement of the control points which have a true flag in the ffd_mask.
-        Default is identity.
 
     :Example:
 
@@ -67,7 +63,7 @@ def __init__(self,
                 fun,
                 n_control_points=None,
                 ffd_mask=None,
-                fun_mask=None, weight_matrix=None):
+                fun_mask=None):
         super().__init__(n_control_points)
 
         if ffd_mask is None:
@@ -82,18 +78,18 @@ def __init__(self,
             self.fun_mask = np.full((self.num_cons, 3), True, dtype=bool)
         else:
             self.fun_mask = fun_mask
-
-        if weight_matrix is None:
-            self.weight_matrix = np.eye(np.sum(self.ffd_mask))
-    def _adjust_control_points_inner(self,src_pts,hyper_param):
+    def adjust_control_points(self,src_pts):
         '''
-        Adjust the FFD control points such that fun(ffd(src_pts))=fixval given a hyperparameter.
+        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)
         mask_bak = self.ffd_mask.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)
@@ -118,19 +114,8 @@ def _adjust_control_points_inner(self,src_pts,hyper_param):
             saved_parameters[indices] = saved_parameters[indices] + deltax
             self._load_parameters(saved_parameters)
         self.ffd_mask = mask_bak.copy()
+        self.fixval=fixval_bak.copy()
 
-
-    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)
-        self._adjust_control_points_inner(src_pts,hyper_param)
     def ffd(self, src_pts):
         '''
         Performs Classic Free Form Deformation.
@@ -199,3 +184,126 @@ def _compute_linear_map(self, src_pts, saved_parameters, indices):
         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
+        >>> 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.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.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')
+        >>> 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))])
+