Collaboration diagram for igl::PlanarizerShapeUp< DerivedV, DerivedF >:

Public Member Functions
	PlanarizerShapeUp (const Eigen::PlainObjectBase< DerivedV > &V_, const Eigen::PlainObjectBase< DerivedF > &F_, const int maxIter_, const double &threshold_)

void	planarize (Eigen::PlainObjectBase< DerivedV > &Vout)

Protected Member Functions
void	assembleQ ()

void	assembleP ()

void	assembleNi ()

void	assembleSelector (int fi, Eigen::SparseMatrix< typename DerivedV::Scalar > &S)

Protected Attributes
long	numV

long	numF

const Eigen::PlainObjectBase< DerivedV > &	Vin

const Eigen::PlainObjectBase< DerivedF > &	Fin

Eigen::Matrix< typename DerivedV::Scalar, Eigen::Dynamic, 1 >	Vv

Eigen::Matrix< typename DerivedV::Scalar, Eigen::Dynamic, 1 >	weightsSqrt

Eigen::Matrix< typename DerivedV::Scalar, Eigen::Dynamic, 1 >	P

Eigen::SparseMatrix< typename DerivedV::Scalar >	Q

Eigen::SparseMatrix< typename DerivedV::Scalar >	Ni

Eigen::SimplicialLDLT< Eigen::SparseMatrix< typename DerivedV::Scalar > >	solver

int	maxIter

double	threshold

const int	ni = 4

Detailed Description

template<typename DerivedV, typename DerivedF>
class igl::PlanarizerShapeUp< DerivedV, DerivedF >

Constructor & Destructor Documentation

◆ PlanarizerShapeUp()

template<typename DerivedV , typename DerivedF >

igl::PlanarizerShapeUp< DerivedV, DerivedF >::PlanarizerShapeUp	(	const Eigen::PlainObjectBase< DerivedV > &	V_,
		const Eigen::PlainObjectBase< DerivedF > &	F_,
		const int	maxIter_,
		const double &	threshold_
	)

inline

                                                                                              :
numV(V_.rows()),
numF(F_.rows()),
Vin(V_),
Fin(F_),
weightsSqrt(Eigen::Matrix<typename DerivedV::Scalar, Eigen::Dynamic, 1>::Ones(numF,1)),
maxIter(maxIter_),
threshold(threshold_)
{
  // assemble stacked vertex position vector
  Vv.setZero(3*numV,1);
  for (int i =0;i<numV;++i)
    Vv.segment(3*i,3) = Vin.row(i);
  // assemble and factorize lhs matrix
  assembleQ();
};

References igl::PlanarizerShapeUp< DerivedV, DerivedF >::assembleQ(), igl::PlanarizerShapeUp< DerivedV, DerivedF >::numV, Eigen::PlainObjectBase< Derived >::setZero(), igl::PlanarizerShapeUp< DerivedV, DerivedF >::Vin, and igl::PlanarizerShapeUp< DerivedV, DerivedF >::Vv.

Here is the call graph for this function:

Member Function Documentation

◆ assembleNi()

template<typename DerivedV , typename DerivedF >

void igl::PlanarizerShapeUp< DerivedV, DerivedF >::assembleNi

inlineprotected

{
  std::vector<Eigen::Triplet<typename DerivedV::Scalar>> tripletList;
  for (int ii = 0; ii< ni; ii++)
  {
    for (int jj = 0; jj< ni; jj++)
    {
      tripletList.push_back(Eigen::Triplet<typename DerivedV::Scalar>(3*ii+0,3*jj+0,-1./ni));
      tripletList.push_back(Eigen::Triplet<typename DerivedV::Scalar>(3*ii+1,3*jj+1,-1./ni));
      tripletList.push_back(Eigen::Triplet<typename DerivedV::Scalar>(3*ii+2,3*jj+2,-1./ni));
    }
    tripletList.push_back(Eigen::Triplet<typename DerivedV::Scalar>(3*ii+0,3*ii+0,1.));
    tripletList.push_back(Eigen::Triplet<typename DerivedV::Scalar>(3*ii+1,3*ii+1,1.));
    tripletList.push_back(Eigen::Triplet<typename DerivedV::Scalar>(3*ii+2,3*ii+2,1.));
  }
  Ni.resize(3*ni,3*ni);
  Ni.setFromTriplets(tripletList.begin(), tripletList.end());
}

◆ assembleP()

template<typename DerivedV , typename DerivedF >

void igl::PlanarizerShapeUp< DerivedV, DerivedF >::assembleP

inlineprotected

{
  P.setZero(3*ni*numF);
  for (int fi = 0; fi< numF; fi++)
  {
    // todo: this can be made faster by omitting the selector matrix
    Eigen::SparseMatrix<typename DerivedV::Scalar > Sfi;
    assembleSelector(fi, Sfi);
    Eigen::SparseMatrix<typename DerivedV::Scalar > NSi = Ni*Sfi;
    
    Eigen::Matrix<typename DerivedV::Scalar, Eigen::Dynamic, 1> Vi = NSi*Vv;
    Eigen::Matrix<typename DerivedV::Scalar, Eigen::Dynamic, Eigen::Dynamic> CC(3,ni);
    for (int i = 0; i <ni; ++i)
      CC.col(i) = Vi.segment(3*i, 3);
    Eigen::Matrix<typename DerivedV::Scalar, 3, 3> C = CC*CC.transpose();
    
    // Alec: Doesn't compile
    Eigen::EigenSolver<Eigen::Matrix<typename DerivedV::Scalar, 3, 3>> es(C);
    // the real() is for compilation purposes
    Eigen::Matrix<typename DerivedV::Scalar, 3, 1> lambda = es.eigenvalues().real();
    Eigen::Matrix<typename DerivedV::Scalar, 3, 3> U = es.eigenvectors().real();
    int min_i;
    lambda.cwiseAbs().minCoeff(&min_i);
    U.col(min_i).setZero();
    Eigen::Matrix<typename DerivedV::Scalar, Eigen::Dynamic, Eigen::Dynamic> PP = U*U.transpose()*CC;
    for (int i = 0; i <ni; ++i)
     P.segment(3*ni*fi+3*i, 3) =  weightsSqrt[fi]*PP.col(i);
    
  }
}

References Eigen::EigenSolver< _MatrixType >::eigenvalues(), Eigen::EigenSolver< _MatrixType >::eigenvectors(), and Eigen::PlainObjectBase< Derived >::setZero().

Here is the call graph for this function:

◆ assembleQ()

template<typename DerivedV , typename DerivedF >

void igl::PlanarizerShapeUp< DerivedV, DerivedF >::assembleQ

inlineprotected

{
  std::vector<Eigen::Triplet<typename DerivedV::Scalar> > tripletList;
  
  // assemble the Ni matrix
  assembleNi();
  
  for (int fi = 0; fi< numF; fi++)
  {
    Eigen::SparseMatrix<typename DerivedV::Scalar > Sfi;
    assembleSelector(fi, Sfi);
    
    // the final matrix per face
    Eigen::SparseMatrix<typename DerivedV::Scalar > Qi = weightsSqrt(fi)*Ni*Sfi;
    // put it in the correct block of Q
    // todo: this can be made faster by omitting the selector matrix
    for (int k=0; k<Qi.outerSize(); ++k)
      for (typename Eigen::SparseMatrix<typename DerivedV::Scalar >::InnerIterator it(Qi,k); it; ++it)
      {
        typename DerivedV::Scalar val = it.value();
        int row = it.row();
        int col = it.col();
        tripletList.push_back(Eigen::Triplet<typename DerivedV::Scalar>(row+3*ni*fi,col,val));
      }
  }
  
  Q.resize(3*ni*numF,3*numV);
  Q.setFromTriplets(tripletList.begin(), tripletList.end());
  // the actual lhs matrix is Q'*Q
  // prefactor that matrix
  solver.compute(Q.transpose()*Q);
  if(solver.info()!=Eigen::Success)
  {
    std::cerr << "Cholesky failed - PlanarizerShapeUp.cpp" << std::endl;
    assert(0);
  }
}

References col(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::outerSize(), row(), and Eigen::Success.

Referenced by igl::PlanarizerShapeUp< DerivedV, DerivedF >::PlanarizerShapeUp().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assembleSelector()

template<typename DerivedV , typename DerivedF >

void igl::PlanarizerShapeUp< DerivedV, DerivedF >::assembleSelector	(	int	fi,
		Eigen::SparseMatrix< typename DerivedV::Scalar > &	S
	)

inlineprotected

{
  
  std::vector<Eigen::Triplet<typename DerivedV::Scalar>> tripletList;
  for (int fvi = 0; fvi< ni; fvi++)
  {
    int vi = Fin(fi,fvi);
    tripletList.push_back(Eigen::Triplet<typename DerivedV::Scalar>(3*fvi+0,3*vi+0,1.));
    tripletList.push_back(Eigen::Triplet<typename DerivedV::Scalar>(3*fvi+1,3*vi+1,1.));
    tripletList.push_back(Eigen::Triplet<typename DerivedV::Scalar>(3*fvi+2,3*vi+2,1.));
  }
  
  S.resize(3*ni,3*numV);
  S.setFromTriplets(tripletList.begin(), tripletList.end());
  
}

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

Here is the call graph for this function:

◆ planarize()

template<typename DerivedV , typename DerivedF >

void igl::PlanarizerShapeUp< DerivedV, DerivedF >::planarize ( Eigen::PlainObjectBase< DerivedV > & Vout )

inline

{
  Eigen::Matrix<typename DerivedV::Scalar, Eigen::Dynamic, 1> planarity;
  Vout = Vin;
  
  for (int iter =0; iter<maxIter; ++iter)
  {
    igl::quad_planarity(Vout, Fin, planarity);
    typename DerivedV::Scalar nonPlanarity = planarity.cwiseAbs().maxCoeff();
    //std::cerr<<"iter #"<<iter<<": max non-planarity: "<<nonPlanarity<<std::endl;
    if (nonPlanarity<threshold)
      break;
    assembleP();
    Vv = solver.solve(Q.transpose()*P);
    if(solver.info()!=Eigen::Success)
    {
      std::cerr << "Linear solve failed - PlanarizerShapeUp.cpp" << std::endl;
      assert(0);
    }
    for (int i =0;i<numV;++i)
      Vout.row(i) << Vv.segment(3*i,3).transpose();
  }
  // set the mean of Vout to the mean of Vin
  Eigen::Matrix<typename DerivedV::Scalar, 1, 3> oldMean, newMean;
  oldMean = Vin.colwise().mean();
  newMean = Vout.colwise().mean();
  Vout.rowwise() += (oldMean - newMean);
  
};