igl::Frame_field_deformer Class Reference

Collaboration diagram for igl::Frame_field_deformer:

Public Member Functions
IGL_INLINE	Frame_field_deformer ()
IGL_INLINE	~Frame_field_deformer ()
IGL_INLINE void	init (const Eigen::MatrixXd &_V, const Eigen::MatrixXi &_F, const Eigen::MatrixXd &_D1, const Eigen::MatrixXd &_D2, double _Lambda, double _perturb_rotations, int _fixed=1)
IGL_INLINE void	optimize (int N, bool reset=false)
IGL_INLINE void	reset_opt ()
IGL_INLINE void	precompute_opt ()
IGL_INLINE void	precompute_ARAP (Eigen::SparseMatrix< double > &Lff, Eigen::MatrixXd &LfcVc)
IGL_INLINE void	precompute_SMOOTH (Eigen::SparseMatrix< double > &MS, Eigen::MatrixXd &bS)
IGL_INLINE void	extractBlock (Eigen::SparseMatrix< double > &mat, int r0, int c0, int r, int c, Eigen::SparseMatrix< double > &m1)
IGL_INLINE void	compute_optimal_rotations ()
IGL_INLINE void	compute_optimal_positions ()
IGL_INLINE void	computeXField (std::vector< Eigen::Matrix< double, 3, 2 > > &XF)
IGL_INLINE void	compute_idealWarp (std::vector< Eigen::Matrix< double, 3, 3 > > &WW)

Public Attributes
Eigen::MatrixXd	V
Eigen::MatrixXi	F
std::vector< std::vector< int > >	VT
std::vector< std::vector< int > >	VTi
Eigen::MatrixXd	V_w
std::vector< Eigen::Matrix< double, 3, 2 > >	FF
std::vector< Eigen::Matrix< double, 3, 3 > >	WW
std::vector< Eigen::Matrix< double, 3, 2 > >	XF
int	fixed
double	perturb_rotations
int	nfree
int	nconst
Eigen::MatrixXd	C
Eigen::SparseMatrix< double >	L
Eigen::SparseMatrix< double >	M
Eigen::MatrixXd	RHS
std::vector< Eigen::Matrix< double, 3, 3 > >	RW
Eigen::SimplicialCholesky< Eigen::SparseMatrix< double > >	solver

Private Attributes
double	Lambda = 0.1

Detailed Description

Constructor & Destructor Documentation

Frame_field_deformer()

IGL_INLINE igl::Frame_field_deformer::Frame_field_deformer

(

)

{}

~Frame_field_deformer()

IGL_INLINE igl::Frame_field_deformer::~Frame_field_deformer

(

)

{}

Member Function Documentation

compute_idealWarp()

IGL_INLINE void igl::Frame_field_deformer::compute_idealWarp

(

std::vector< Eigen::Matrix< double, 3, 3 > > &

WW

)

{
  using namespace Eigen;
 
  WW.resize(F.rows());
  for (int i=0;i<(int)FF.size();i++)
  {
    Vector3d v0,v1,v2;
    v0 = FF[i].col(0);
    v1 = FF[i].col(1);
    v2=v0.cross(v1); v2.normalize();      // normal
 
    Matrix3d A,AI;                // compute affine map A that brings:
    A <<    v0[0], v1[0], v2[0],        //  first vector of FF to x unary vector
    v0[1], v1[1], v2[1],        //  second vector of FF to xy plane
    v0[2], v1[2], v2[2];        //  triangle normal to z unary vector
    AI = A.inverse();
 
    // polar decomposition to discard rotational component (unnecessary but makes it easier)
    Eigen::JacobiSVD<Matrix<double,3,3> > svd(AI, Eigen::ComputeFullU | Eigen::ComputeFullV );
    //Matrix<double,3,3>  au = svd.matrixU();
    Matrix<double,3,3>  av = svd.matrixV();
    DiagonalMatrix<double,3>  as(svd.singularValues());
    WW[i] = av*as*av.transpose();
  }
}

References Eigen::ComputeFullU, Eigen::ComputeFullV, F, FF, Eigen::SVDBase< Derived >::matrixV(), Eigen::SVDBase< Derived >::singularValues(), and WW.

Referenced by precompute_opt().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_optimal_positions()

IGL_INLINE void igl::Frame_field_deformer::compute_optimal_positions

(

)

{
  using namespace Eigen;
  // compute variable RHS of ARAP-warp part of the system
  MatrixXd b(nfree,3);          // fx3 known term of the system
  MatrixXd X;                   // result
  int t;                        // triangles incident to edge (i,j)
  int vi,i1,i2;                 // index of vertex i wrt tri t0
 
  for (int i=0;i<nfree;i++)
  {
    b.row(i) << 0.0, 0.0, 0.0;
    for (int k=0;k<(int)VT[i].size();k++)         // for all incident triangles
    {
      t = VT[i][k];                       // incident tri
      vi = (i==F(t,0))?0:(i==F(t,1))?1:(i==F(t,2))?2:3; // index of i in t
      assert(vi!=3);
      i1 = F(t,(vi+1)%3);
      i2 = F(t,(vi+2)%3);
      b.row(i)+=(C(t,(vi+2)%3)*RW[t]*(V.row(i1)-V.row(i)).transpose()).transpose();
      b.row(i)+=(C(t,(vi+1)%3)*RW[t]*(V.row(i2)-V.row(i)).transpose()).transpose();
    }
  }
  b/=2.0;
  b=-4*b;
 
  b*=(1-Lambda);    // blend
 
  b+=RHS;       // complete known term
 
  X = solver.solve(b);
  if (solver.info()!=Eigen::Success) {printf("Solving linear system failed!\n"); return;}
 
  // copy result to mw.V
  for (int i=0;i<nfree;i++)
    V_w.row(i)=X.row(i);
 
}

References C, F, Eigen::SimplicialCholeskyBase< Derived >::info(), Lambda, nfree, RHS, RW, Eigen::SparseSolverBase< Derived >::solve(), solver, Eigen::Success, V, V_w, and VT.

Referenced by optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_optimal_rotations()

IGL_INLINE void igl::Frame_field_deformer::compute_optimal_rotations

(

)

{
  using namespace Eigen;
  Matrix<double,3,3> r,S,P,PP,D;
 
  for (int i=0;i<F.rows();i++)
  {
    // input tri --- could be done once and saved in a matrix
    P.col(0) = (V.row(F(i,1))-V.row(F(i,0))).transpose();
    P.col(1) = (V.row(F(i,2))-V.row(F(i,1))).transpose();
    P.col(2) = (V.row(F(i,0))-V.row(F(i,2))).transpose();
 
    P = WW[i] * P;    // apply ideal warp
 
    // current tri
    PP.col(0) = (V_w.row(F(i,1))-V_w.row(F(i,0))).transpose();
    PP.col(1) = (V_w.row(F(i,2))-V_w.row(F(i,1))).transpose();
    PP.col(2) = (V_w.row(F(i,0))-V_w.row(F(i,2))).transpose();
 
    // cotangents
    D <<    C(i,2), 0,      0,
    0,      C(i,0), 0,
    0,      0,      C(i,1);
 
    S = PP*D*P.transpose();
    Eigen::JacobiSVD<Matrix<double,3,3> > svd(S, Eigen::ComputeFullU | Eigen::ComputeFullV );
    Matrix<double,3,3>  su = svd.matrixU();
    Matrix<double,3,3>  sv = svd.matrixV();
    r = su*sv.transpose();
 
    if (r.determinant()<0)  // correct reflections
    {
      su(0,2)=-su(0,2); su(1,2)=-su(1,2); su(2,2)=-su(2,2);
      r = su*sv.transpose();
    }
    RW[i] = r*WW[i];    // RW INCORPORATES IDEAL WARP WW!!!
  }
}

References C, Eigen::ComputeFullU, Eigen::ComputeFullV, F, Eigen::SVDBase< Derived >::matrixU(), Eigen::SVDBase< Derived >::matrixV(), RW, V, V_w, and WW.

Referenced by optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

computeXField()

IGL_INLINE void igl::Frame_field_deformer::computeXField

(

std::vector< Eigen::Matrix< double, 3, 2 > > &

XF

)

{
  using namespace Eigen;
  Matrix<double,3,3> P,PP,DG;
  XF.resize(F.rows());
 
  for (int i=0;i<F.rows();i++)
  {
    int i0,i1,i2;
    // indexes of vertices of face i
    i0 = F(i,0); i1 = F(i,1); i2 = F(i,2);
 
    // input frame
    P.col(0) = (V.row(i1)-V.row(i0)).transpose();
    P.col(1) = (V.row(i2)-V.row(i0)).transpose();
    P.col(2) = P.col(0).cross(P.col(1));
 
    // output triangle brought to origin
    PP.col(0) = (V_w.row(i1)-V_w.row(i0)).transpose();
    PP.col(1) = (V_w.row(i2)-V_w.row(i0)).transpose();
    PP.col(2) = PP.col(0).cross(PP.col(1));
 
    // deformation gradient
    DG = PP * P.inverse();
    XF[i] = DG * FF[i];
  }
}

References F, FF, V, V_w, and XF.

Referenced by optimize().

Here is the caller graph for this function:

extractBlock()

IGL_INLINE void igl::Frame_field_deformer::extractBlock	(	Eigen::SparseMatrix< double > &	mat,
		int	r0,
		int	c0,
		int	r,
		int	c,
		Eigen::SparseMatrix< double > &	m1
	)

{
  std::vector<Eigen::Triplet<double> > tripletList;
  for (int k=c0; k<c0+c; ++k)
    for (Eigen::SparseMatrix<double>::InnerIterator it(mat,k); it; ++it)
    {
      if (it.row()>=r0 && it.row()<r0+r)
        tripletList.push_back(Eigen::Triplet<double>(it.row()-r0,it.col()-c0,it.value()));
    }
  m1.setFromTriplets(tripletList.begin(), tripletList.end());
}

References Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::setFromTriplets().

Referenced by precompute_ARAP(), and precompute_SMOOTH().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

IGL_INLINE void igl::Frame_field_deformer::init	(	const Eigen::MatrixXd &	_V,
		const Eigen::MatrixXi &	_F,
		const Eigen::MatrixXd &	_D1,
		const Eigen::MatrixXd &	_D2,
		double	_Lambda,
		double	_perturb_rotations,
		int	_fixed = 1
	)

{
  V = _V;
  F = _F;
 
  assert(_D1.rows() == _D2.rows());
 
  FF.clear();
  for (unsigned i=0; i < _D1.rows(); ++i)
  {
    Eigen::Matrix<double,3,2> ff;
    ff.col(0) = _D1.row(i);
    ff.col(1) = _D2.row(i);
    FF.push_back(ff);
  }
 
  fixed = _fixed;
  Lambda = _Lambda;
  perturb_rotations = _perturb_rotations;
 
  reset_opt();
  precompute_opt();
}

References F, FF, fixed, Lambda, perturb_rotations, precompute_opt(), reset_opt(), and V.

Referenced by igl::frame_field_deformer().

Here is the call graph for this function:

Here is the caller graph for this function:

optimize()

IGL_INLINE void igl::Frame_field_deformer::optimize	(	int	N,
		bool	reset = false
	)

{
  //Reset optimization
  if (reset)
    reset_opt();
 
  // Iterative Local/Global optimization
  for (int i=0; i<N;i++)
  {
    compute_optimal_rotations();
    compute_optimal_positions();
    computeXField(XF);
  }
}

References compute_optimal_positions(), compute_optimal_rotations(), computeXField(), reset_opt(), and XF.

Referenced by igl::frame_field_deformer().

Here is the call graph for this function:

Here is the caller graph for this function:

precompute_ARAP()

IGL_INLINE void igl::Frame_field_deformer::precompute_ARAP	(	Eigen::SparseMatrix< double > &	Lff,
		Eigen::MatrixXd &	LfcVc
	)

{
  using namespace Eigen;
  fprintf(stdout,"Precomputing ARAP terms\n");
  SparseMatrix<double> LL = -4*L;
  Lff = SparseMatrix<double>(nfree,nfree);
  extractBlock(LL,0,0,nfree,nfree,Lff);
  SparseMatrix<double> Lfc = SparseMatrix<double>(nfree,nconst);
  extractBlock(LL,0,nfree,nfree,nconst,Lfc);
  LfcVc = - Lfc * V_w.block(nfree,0,nconst,3);
}

References extractBlock(), L, nconst, nfree, and V_w.

Referenced by precompute_opt().

Here is the call graph for this function:

Here is the caller graph for this function:

precompute_opt()

IGL_INLINE void igl::Frame_field_deformer::precompute_opt

(

)

{
  using namespace Eigen;
  nfree = V.rows() - fixed;               // free vertices (at the beginning ov m.V) - global
  nconst = V.rows()-nfree;            // #constrained vertices
  igl::vertex_triangle_adjacency(V,F,VT,VTi);                // compute vertex to face relationship
 
  igl::cotmatrix_entries(V,F,C);                   // cotangent matrix for opt. rotations - global
 
  igl::cotmatrix(V,F,L);
 
  SparseMatrix<double> MA;            // internal matrix for ARAP-warping energy
  MatrixXd LfcVc;                     // RHS (partial) for ARAP-warping energy
  SparseMatrix<double> MS;            // internal matrix for smoothing energy
  MatrixXd bS;                        // RHS (full) for smoothing energy
 
  precompute_ARAP(MA,LfcVc);          // precompute terms for the ARAP-warp part
  precompute_SMOOTH(MS,bS);           // precompute terms for the smoothing part
  compute_idealWarp(WW);              // computes the ideal warps
  RW.resize(F.rows());                // init rotation matrices - global
 
  M =   (1-Lambda)*MA + Lambda*MS;    // matrix for linear system - global
 
  RHS = (1-Lambda)*LfcVc + Lambda*bS; // RHS (partial) for linear system - global
  solver.compute(M);                  // system pre-conditioning
  if (solver.info()!=Eigen::Success) {fprintf(stderr,"Decomposition failed in pre-conditioning!\n"); exit(-1);}
 
  fprintf(stdout,"Preconditioning done.\n");
 
}

References C, Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::compute(), compute_idealWarp(), igl::cotmatrix(), igl::cotmatrix_entries(), F, fixed, Eigen::SimplicialCholeskyBase< Derived >::info(), L, Lambda, M, nconst, nfree, precompute_ARAP(), precompute_SMOOTH(), RHS, RW, solver, Eigen::Success, V, igl::vertex_triangle_adjacency(), VT, VTi, and WW.

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

precompute_SMOOTH()

IGL_INLINE void igl::Frame_field_deformer::precompute_SMOOTH	(	Eigen::SparseMatrix< double > &	MS,
		Eigen::MatrixXd &	bS
	)

{
  using namespace Eigen;
  fprintf(stdout,"Precomputing SMOOTH terms\n");
 
  SparseMatrix<double> LL = 4*L*L;
 
  // top-left
  MS = SparseMatrix<double>(nfree,nfree);
  extractBlock(LL,0,0,nfree,nfree,MS);
 
  // top-right
  SparseMatrix<double> Mfc = SparseMatrix<double>(nfree,nconst);
  extractBlock(LL,0,nfree,nfree,nconst,Mfc);
 
  MatrixXd MfcVc = Mfc * V_w.block(nfree,0,nconst,3);
  bS = (LL*V).block(0,0,nfree,3)-MfcVc;
 
}

References block(), extractBlock(), L, nconst, nfree, V, and V_w.

Referenced by precompute_opt().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_opt()

IGL_INLINE void igl::Frame_field_deformer::reset_opt

(

)

{
  V_w = V;
 
  for (unsigned i=0; i<V_w.rows(); ++i)
    for (unsigned j=0; j<V_w.cols(); ++j)
      V_w(i,j) += (double(rand())/double(RAND_MAX))*10e-4*perturb_rotations;
 
}

References perturb_rotations, V, and V_w.

Referenced by init(), and optimize().

Here is the caller graph for this function:

Member Data Documentation

C

Eigen::MatrixXd igl::Frame_field_deformer::C

Referenced by compute_optimal_positions(), compute_optimal_rotations(), and precompute_opt().

F

Eigen::MatrixXi igl::Frame_field_deformer::F

Referenced by compute_idealWarp(), compute_optimal_positions(), compute_optimal_rotations(), computeXField(), init(), and precompute_opt().

FF

std::vector< Eigen::Matrix<double,3,2> > igl::Frame_field_deformer::FF

Referenced by compute_idealWarp(), computeXField(), and init().

fixed

int igl::Frame_field_deformer::fixed

Referenced by init(), and precompute_opt().

L

Eigen::SparseMatrix<double> igl::Frame_field_deformer::L

Referenced by precompute_ARAP(), precompute_opt(), and precompute_SMOOTH().

Lambda

double igl::Frame_field_deformer::Lambda = 0.1

private

Referenced by compute_optimal_positions(), init(), and precompute_opt().

M

Eigen::SparseMatrix<double> igl::Frame_field_deformer::M

Referenced by precompute_opt().

nconst

int igl::Frame_field_deformer::nconst

Referenced by precompute_ARAP(), precompute_opt(), and precompute_SMOOTH().

nfree

int igl::Frame_field_deformer::nfree

Referenced by compute_optimal_positions(), precompute_ARAP(), precompute_opt(), and precompute_SMOOTH().

perturb_rotations

double igl::Frame_field_deformer::perturb_rotations

Referenced by init(), and reset_opt().

RHS

Eigen::MatrixXd igl::Frame_field_deformer::RHS

Referenced by compute_optimal_positions(), and precompute_opt().

RW

std::vector< Eigen::Matrix<double,3,3> > igl::Frame_field_deformer::RW

Referenced by compute_optimal_positions(), compute_optimal_rotations(), and precompute_opt().

solver

Eigen::SimplicialCholesky<Eigen::SparseMatrix<double> > igl::Frame_field_deformer::solver

Referenced by compute_optimal_positions(), and precompute_opt().

V

Eigen::MatrixXd igl::Frame_field_deformer::V

Referenced by compute_optimal_positions(), compute_optimal_rotations(), computeXField(), init(), precompute_opt(), precompute_SMOOTH(), and reset_opt().

V_w

Eigen::MatrixXd igl::Frame_field_deformer::V_w

Referenced by compute_optimal_positions(), compute_optimal_rotations(), computeXField(), igl::frame_field_deformer(), precompute_ARAP(), precompute_SMOOTH(), and reset_opt().

VT

std::vector<std::vector<int> > igl::Frame_field_deformer::VT

Referenced by compute_optimal_positions(), and precompute_opt().

VTi

std::vector<std::vector<int> > igl::Frame_field_deformer::VTi

Referenced by precompute_opt().

WW

std::vector< Eigen::Matrix<double,3,3> > igl::Frame_field_deformer::WW

Referenced by compute_idealWarp(), compute_optimal_rotations(), and precompute_opt().

XF

std::vector< Eigen::Matrix<double,3,2> > igl::Frame_field_deformer::XF

Referenced by computeXField(), igl::frame_field_deformer(), and optimize().

---

The documentation for this class was generated from the following file:

• src/libigl/igl/frame_field_deformer.cpp