Collaboration diagram for igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >:

Public Member Functions
IGL_INLINE void	SolvePoisson (Eigen::VectorXd Stiffness, double vector_field_scale=0.1f, double grid_res=1.f, bool direct_round=true, int localIter=0, bool _integer_rounding=true, bool _singularity_rounding=true, std::vector< int > roundVertices=std::vector< int >(), std::vector< std::vector< int > > hardFeatures=std::vector< std::vector< int > >())

IGL_INLINE	PoissonSolver (const Eigen::PlainObjectBase< DerivedV > &_V, const Eigen::PlainObjectBase< DerivedF > &_F, const Eigen::PlainObjectBase< DerivedV > &_Vcut, const Eigen::PlainObjectBase< DerivedF > &_Fcut, const Eigen::PlainObjectBase< DerivedF > &_TT, const Eigen::PlainObjectBase< DerivedF > &_TTi, const Eigen::PlainObjectBase< DerivedV > &_PD1, const Eigen::PlainObjectBase< DerivedV > &_PD2, const Eigen::Matrix< int, Eigen::Dynamic, 1 > &_Handle_Singular, const MeshSystemInfo &_Handle_SystemInfo)

IGL_INLINE std::complex< double >	GetRotationComplex (int interval)
	START COMMON MATH FUNCTIONS return the complex encoding the rotation for a given missmatch interval.

IGL_INLINE void	AddFixedVertex (int v)
	END COMMON MATH FUNCTIONS.

IGL_INLINE void	FindFixedVertField ()
	find vertex to fix in case we're using a vector field NB: multiple components not handled

IGL_INLINE void	FindFixedVert ()
	find hard constraint depending if using or not a vector field

IGL_INLINE int	GetFirstVertexIndex (int v)

IGL_INLINE void	FixBlockedVertex ()
	fix the vertices which are flagged as fixed

IGL_INLINE void	AddSingularityRound ()
	END FIXING VERTICES.

IGL_INLINE void	AddToRoundVertices (std::vector< int > ids)

IGL_INLINE void	BuildLaplacianMatrix (double vfscale=1)
	START GENERIC SYSTEM FUNCTIONS.

IGL_INLINE void	FindSizes ()
	find different sized of the system

IGL_INLINE void	AllocateSystem ()

IGL_INLINE void	InitMatrix ()
	intitialize the whole matrix

IGL_INLINE void	MapCoords ()
	map back coordinates after that the system has been solved

IGL_INLINE void	BuildSeamConstraintsExplicitTranslation ()
	END GENERIC SYSTEM FUNCTIONS.

IGL_INLINE void	BuildUserDefinedConstraints ()
	set the constraints for the inter-range cuts

IGL_INLINE void	MixedIntegerSolve (double cone_grid_res=1, bool direct_round=true, int localIter=0)
	call of the mixed integer solver

IGL_INLINE void	clearUserConstraint ()

IGL_INLINE void	addSharpEdgeConstraint (int fid, int vid)

Public Attributes
const Eigen::PlainObjectBase< DerivedV > &	V

const Eigen::PlainObjectBase< DerivedF > &	F

const Eigen::PlainObjectBase< DerivedV > &	Vcut

const Eigen::PlainObjectBase< DerivedF > &	Fcut

const Eigen::PlainObjectBase< DerivedF > &	TT

const Eigen::PlainObjectBase< DerivedF > &	TTi

const Eigen::PlainObjectBase< DerivedV > &	PD1

const Eigen::PlainObjectBase< DerivedV > &	PD2

const Eigen::Matrix< int, Eigen::Dynamic, 1 > &	Handle_Singular

const MeshSystemInfo &	Handle_SystemInfo

Eigen::VectorXd	Handle_Stiffness

std::vector< std::vector< int > >	VF

std::vector< std::vector< int > >	VFi

Eigen::MatrixXd	UV

Eigen::MatrixXd	WUV

Eigen::MatrixXd	UV_out

Eigen::SparseMatrix< double >	Lhs

Eigen::SparseMatrix< double >	Constraints

Eigen::VectorXd	rhs

Eigen::VectorXd	constraints_rhs

std::vector< double >	X
	vector of unknowns

unsigned int	n_fixed_vars
	number of fixed vertex

unsigned int	n_vert_vars
	the number of REAL variables for vertices

unsigned int	num_total_vars
	total number of variables of the system, do not consider constraints, but consider integer vars

unsigned int	n_integer_vars
	the total number of integer variables

unsigned int	num_cut_constraint
	CONSTRAINT PART number of cuts constraints.

unsigned int	num_userdefined_constraint

unsigned int	num_constraint_equations
	total number of constraints equations

std::vector< int >	Hard_constraints
	vector of blocked vertices

std::vector< int >	ids_to_round
	vector of indexes to round

std::vector< std::vector< int > >	userdefined_constraints
	vector of indexes to round

bool	integer_rounding
	boolean that is true if rounding to integer is needed

Detailed Description

template<typename DerivedV, typename DerivedF>
class igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >

Constructor & Destructor Documentation

◆ PoissonSolver()

template<typename DerivedV , typename DerivedF >

IGL_INLINE igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::PoissonSolver	(	const Eigen::PlainObjectBase< DerivedV > &	_V,
		const Eigen::PlainObjectBase< DerivedF > &	_F,
		const Eigen::PlainObjectBase< DerivedV > &	_Vcut,
		const Eigen::PlainObjectBase< DerivedF > &	_Fcut,
		const Eigen::PlainObjectBase< DerivedF > &	_TT,
		const Eigen::PlainObjectBase< DerivedF > &	_TTi,
		const Eigen::PlainObjectBase< DerivedV > &	_PD1,
		const Eigen::PlainObjectBase< DerivedV > &	_PD2,
		const Eigen::Matrix< int, Eigen::Dynamic, 1 > &	_Handle_Singular,
		const MeshSystemInfo &	_Handle_SystemInfo
	)

 :
V(_V),
F(_F),
Vcut(_Vcut),
Fcut(_Fcut),
TT(_TT),
TTi(_TTi),
PD1(_PD1),
PD2(_PD2),
Handle_Singular(_Handle_Singular),
Handle_SystemInfo(_Handle_SystemInfo)
{
  UV        = Eigen::MatrixXd(V.rows(),2);
  WUV       = Eigen::MatrixXd(F.rows(),6);
  UV_out    = Eigen::MatrixXd(Vcut.rows(),2);
  igl::vertex_triangle_adjacency(V,F,VF,VFi);
}

Here is the call graph for this function:

Member Function Documentation

◆ AddFixedVertex()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::AddFixedVertex ( int v )

END COMMON MATH FUNCTIONS.

START FIXING VERTICES set a given vertex as fixed

{
  n_fixed_vars++;
  Hard_constraints.push_back(v);
}

◆ addSharpEdgeConstraint()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::addSharpEdgeConstraint	(	int	fid,
		int	vid
	)

{
  // prepare constraint
  std::vector<int> c(Handle_SystemInfo.num_vert_variables*2 + 1);
 
  for (size_t i = 0; i < c.size(); ++i)
  {
    c[i] = 0;
  }
 
  int v1 = Fcut(fid,vid);
  int v2 = Fcut(fid,(vid+1)%3);
 
  Eigen::Matrix<typename DerivedV::Scalar, 3, 1> e = Vcut.row(v2) - Vcut.row(v1);
  e = e.normalized();
 
  double d1 = fabs(e.dot(PD1.row(fid).normalized()));
  double d2 = fabs(e.dot(PD2.row(fid).normalized()));
 
  int offset = 0;
 
  if (d1>d2)
    offset = 1;
 
  ids_to_round.push_back((v1 * 2) + offset);
  ids_to_round.push_back((v2 * 2) + offset);
 
  // add constraint
  c[(v1 * 2) + offset] =  1;
  c[(v2 * 2) + offset] = -1;
 
  // add to the user-defined constraints
  num_userdefined_constraint++;
  userdefined_constraints.push_back(c);
 
}

◆ AddSingularityRound()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::AddSingularityRound

END FIXING VERTICES.

HANDLING SINGULARITY

{
  for (unsigned int v=0;v<V.rows();v++)
  {
    if (Handle_Singular(v))
    {
      int index0=GetFirstVertexIndex(v);
      ids_to_round.push_back( index0*2   );
      ids_to_round.push_back((index0*2)+1);
    }
  }
}

◆ AddToRoundVertices()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::AddToRoundVertices ( std::vector< int > ids )

{
  for (size_t i = 0; i < ids.size(); ++i)
  {
    if (ids[i] < 0 || ids[i] >= V.rows())
      std::cerr << "WARNING: Ignored round vertex constraint, vertex " << ids[i] << " does not exist in the mesh." << std::endl;
    int index0 = GetFirstVertexIndex(ids[i]);
    ids_to_round.push_back( index0*2   );
    ids_to_round.push_back((index0*2)+1);
  }
}

◆ AllocateSystem()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::AllocateSystem

{
  Lhs.resize(n_vert_vars * 2, n_vert_vars * 2);
  Constraints.resize(num_constraint_equations, num_total_vars);
  rhs.resize(n_vert_vars * 2);
  constraints_rhs.resize(num_constraint_equations);
 
  printf("\n INITIALIZED SPARSE MATRIX OF %d x %d \n",n_vert_vars*2, n_vert_vars*2);
  printf("\n INITIALIZED SPARSE MATRIX OF %d x %d \n",num_constraint_equations, num_total_vars);
  printf("\n INITIALIZED VECTOR OF %d x 1 \n",n_vert_vars*2);
  printf("\n INITIALIZED VECTOR OF %d x 1 \n",num_constraint_equations);
}

◆ BuildLaplacianMatrix()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::BuildLaplacianMatrix ( double vfscale = 1 )

START GENERIC SYSTEM FUNCTIONS.

Compute LHS

Compute RHS

{
  Eigen::VectorXi idx  = igl::LinSpaced<Eigen::VectorXi >(Vcut.rows(), 0, 2*Vcut.rows()-2);
  Eigen::VectorXi idx2 = igl::LinSpaced<Eigen::VectorXi >(Vcut.rows(), 1, 2*Vcut.rows()-1);
 
  // get gradient matrix
  Eigen::SparseMatrix<double> G(Fcut.rows() * 3, Vcut.rows());
  igl::grad(Vcut, Fcut, G);
 
  // get triangle weights
  Eigen::VectorXd dblA(Fcut.rows());
  igl::doublearea(Vcut, Fcut, dblA);
 
  // compute intermediate result
  Eigen::SparseMatrix<double> G2;
  G2 = G.transpose() * dblA.replicate<3,1>().asDiagonal() * Handle_Stiffness.replicate<3,1>().asDiagonal();
 
  Eigen::SparseMatrix<double> Cotmatrix;
  Cotmatrix = 0.5 * G2 * G;
  igl::slice_into(Cotmatrix, idx,  idx,  Lhs);
  igl::slice_into(Cotmatrix, idx2, idx2, Lhs);
 
  // reshape nrosy vectors
  const Eigen::MatrixXd u = Eigen::Map<const Eigen::MatrixXd>(PD1.data(),Fcut.rows()*3,1); // this mimics a reshape at the cost of a copy.
  const Eigen::MatrixXd v = Eigen::Map<const Eigen::MatrixXd>(PD2.data(),Fcut.rows()*3,1); // this mimics a reshape at the cost of a copy.
 
  // multiply with weights
  Eigen::VectorXd rhs1 =  G2 * u * 0.5 * vfscale;
  Eigen::VectorXd rhs2 = -G2 * v * 0.5 * vfscale;
  igl::slice_into(rhs1, idx,  1, rhs);
  igl::slice_into(rhs2, idx2, 1, rhs);
}

References igl::doublearea(), igl::grad(), igl::slice_into(), and Eigen::SparseMatrixBase< Derived >::transpose().

Here is the call graph for this function:

◆ BuildSeamConstraintsExplicitTranslation()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::BuildSeamConstraintsExplicitTranslation

END GENERIC SYSTEM FUNCTIONS.

set the constraints for the inter-range cuts

current constraint row

get the integer variable

{
  int constr_row = 0;
 
  for (unsigned int i=0; i<num_cut_constraint; i++)
  {
    unsigned char interval = Handle_SystemInfo.EdgeSeamInfo[i].MMatch;
    if (interval==1)
      interval=3;
    else
      if(interval==3)
        interval=1;
 
    int p0  = Handle_SystemInfo.EdgeSeamInfo[i].v0;
    int p0p = Handle_SystemInfo.EdgeSeamInfo[i].v0p;
 
    std::complex<double> rot = GetRotationComplex(interval);
 
    int integerVar = n_vert_vars + Handle_SystemInfo.EdgeSeamInfo[i].integerVar;
 
    if (integer_rounding)
    {
      ids_to_round.push_back(integerVar*2);
      ids_to_round.push_back(integerVar*2+1);
    }
 
    // cross boundary compatibility conditions
    Constraints.coeffRef(constr_row,   2*p0)   +=  rot.real();
    Constraints.coeffRef(constr_row,   2*p0+1) += -rot.imag();
    Constraints.coeffRef(constr_row+1, 2*p0)   +=  rot.imag();
    Constraints.coeffRef(constr_row+1, 2*p0+1) +=  rot.real();
 
    Constraints.coeffRef(constr_row,   2*p0p)   += -1;
    Constraints.coeffRef(constr_row+1, 2*p0p+1) += -1;
 
    Constraints.coeffRef(constr_row,   2*integerVar)   += 1;
    Constraints.coeffRef(constr_row+1, 2*integerVar+1) += 1;
 
    constraints_rhs[constr_row]   = 0;
    constraints_rhs[constr_row+1] = 0;
 
    constr_row += 2;
  }
 
}

◆ BuildUserDefinedConstraints()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::BuildUserDefinedConstraints

set the constraints for the inter-range cuts

the user defined constraints are at the end

current constraint row

{
  int offset_row = num_cut_constraint*2 + n_fixed_vars*2;
 
  int constr_row = offset_row;
 
  assert(num_userdefined_constraint == userdefined_constraints.size());
 
  for (unsigned int i=0; i<num_userdefined_constraint; i++)
  {
    for (unsigned int j=0; j<userdefined_constraints[i].size()-1; ++j)
    {
      Constraints.coeffRef(constr_row, j) = userdefined_constraints[i][j];
    }
 
    constraints_rhs[constr_row] = userdefined_constraints[i][userdefined_constraints[i].size()-1];
    constr_row +=1;
  }
}

◆ clearUserConstraint()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::clearUserConstraint

{
  num_userdefined_constraint = 0;
  userdefined_constraints.clear();
}

◆ FindFixedVert()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::FindFixedVert

find hard constraint depending if using or not a vector field

{
  Hard_constraints.clear();
  FindFixedVertField();
}

◆ FindFixedVertField()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::FindFixedVertField

find vertex to fix in case we're using a vector field NB: multiple components not handled

if anything fixed fix the first

{
  Hard_constraints.clear();
 
  n_fixed_vars=0;
  //fix the first singularity
  for (unsigned int v=0;v<V.rows();v++)
  {
    if (Handle_Singular(v))
    {
      AddFixedVertex(v);
      UV.row(v) << 0,0;
      return;
    }
  }
 
  AddFixedVertex(0);
  UV.row(0) << 0,0;
  std::cerr << "No vertices to fix, I am fixing the first vertex to the origin!" << std::endl;
}

◆ FindSizes()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::FindSizes

find different sized of the system

find the vertex that need to be fixed

REAL PART

INTEGER PART the total number of integer variables

CONSTRAINT PART

total variable of the system

initialize matrix size

{
  FindFixedVert();
 
  n_vert_vars = Handle_SystemInfo.num_vert_variables;
 
  n_integer_vars = Handle_SystemInfo.num_integer_cuts;
 
  num_cut_constraint = Handle_SystemInfo.EdgeSeamInfo.size();
 
  num_constraint_equations = num_cut_constraint * 2 + n_fixed_vars * 2 + num_userdefined_constraint;
 
  num_total_vars = (n_vert_vars+n_integer_vars) * 2;
 
 
  if (DEBUGPRINT)     printf("\n*** SYSTEM VARIABLES *** \n");
  if (DEBUGPRINT)     printf("* NUM REAL VERTEX VARIABLES %d \n",n_vert_vars);
 
  if (DEBUGPRINT)     printf("\n*** INTEGER VARIABLES *** \n");
  if (DEBUGPRINT)     printf("* NUM INTEGER VARIABLES %d \n",(int)n_integer_vars);
 
  if (DEBUGPRINT)     printf("\n*** CONSTRAINTS *** \n ");
  if (DEBUGPRINT)     printf("* NUM FIXED CONSTRAINTS %d\n",n_fixed_vars);
  if (DEBUGPRINT)     printf("* NUM CUTS CONSTRAINTS %d\n",num_cut_constraint);
  if (DEBUGPRINT)     printf("* NUM USER DEFINED CONSTRAINTS %d\n",num_userdefined_constraint);
 
  if (DEBUGPRINT)     printf("\n*** TOTAL SIZE *** \n");
  if (DEBUGPRINT)     printf("* TOTAL VARIABLE SIZE (WITH INTEGER TRASL) %d \n",num_total_vars);
  if (DEBUGPRINT)     printf("* TOTAL CONSTRAINTS %d \n",num_constraint_equations);
}

References DEBUGPRINT.

◆ FixBlockedVertex()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::FixBlockedVertex

fix the vertices which are flagged as fixed

get first index of the vertex that must blocked

multiply times 2 because of uv

find the first free row to add the constraint

add fixing constraint LHS

add fixing constraint RHS

{
  int offset_row = num_cut_constraint*2;
 
  unsigned int constr_num = 0;
  for (unsigned int i=0;i<Hard_constraints.size();i++)
  {
    int v = Hard_constraints[i];
 
    //int index=v->vertex_index[0];
    int index = GetFirstVertexIndex(v);
 
    int indexvert = index*2;
 
    int indexRow = (offset_row+constr_num*2);
    int indexCol = indexRow;
 
    Constraints.coeffRef(indexRow,  indexvert)   += 1;
    Constraints.coeffRef(indexRow+1,indexvert+1) += 1;
 
    constraints_rhs[indexCol]   = UV(v,0);
    constraints_rhs[indexCol+1] = UV(v,1);
 
    constr_num++;
  }
  assert(constr_num==n_fixed_vars);
}

◆ GetFirstVertexIndex()

template<typename DerivedV , typename DerivedF >

IGL_INLINE int igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::GetFirstVertexIndex ( int v )

{
  return Fcut(VF[v][0],VFi[v][0]);
}

◆ GetRotationComplex()

template<typename DerivedV , typename DerivedF >

IGL_INLINE std::complex< double > igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::GetRotationComplex ( int interval )

START COMMON MATH FUNCTIONS return the complex encoding the rotation for a given missmatch interval.

{
  assert((interval>=0)&&(interval<4));
 
  switch(interval)
  {
    case 0:return std::complex<double>(1,0);
    case 1:return std::complex<double>(0,1);
    case 2:return std::complex<double>(-1,0);
    default:return std::complex<double>(0,-1);
  }
}

◆ InitMatrix()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::InitMatrix

intitialize the whole matrix

{
  FindSizes();
  AllocateSystem();
}

◆ MapCoords()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::MapCoords

map back coordinates after that the system has been solved

map coords to faces

then get U and V coords

{
  for (unsigned int f=0;f<Fcut.rows();f++)
  {
 
    for (int k=0;k<3;k++)
    {
      //get the index of the variable in the system
      int indexUV = Fcut(f,k);
      double U=X[indexUV*2];
      double V=X[indexUV*2+1];
 
      WUV(f,k*2 + 0) = U;
      WUV(f,k*2 + 1) = V;
    }
 
  }
 
  for(int i = 0; i < Vcut.rows(); i++){
    UV_out(i,0) = X[i*2];
    UV_out(i,1) = X[i*2+1];
  }
}

◆ MixedIntegerSolve()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::MixedIntegerSolve	(	double	cone_grid_res = `1`,
		bool	direct_round = `true`,
		int	localIter = `0`
	)

call of the mixed integer solver

variables part

matrix A

constraints part

add penalization term for integer variables

{
  X = std::vector<double>((n_vert_vars+n_integer_vars)*2);
  if (DEBUGPRINT)
    printf("\n ALLOCATED X \n");
 
  int ScalarSize = n_vert_vars*2;
  int SizeMatrix = (n_vert_vars+n_integer_vars)*2;
 
  gmm::col_matrix< gmm::wsvector< double > > A(SizeMatrix,SizeMatrix); // lhs matrix variables
 
  int CsizeX = num_constraint_equations;
  int CsizeY = SizeMatrix+1;
  gmm::row_matrix< gmm::wsvector< double > > C(CsizeX,CsizeY); // constraints
 
  if (DEBUGPRINT)
    printf("\n ALLOCATED QMM STRUCTURES \n");
 
  std::vector<double> B(SizeMatrix,0);  // rhs
 
  if (DEBUGPRINT)
    printf("\n ALLOCATED RHS STRUCTURES \n");
 
  for (int k=0; k < Lhs.outerSize(); ++k){
    for (Eigen::SparseMatrix<double>::InnerIterator it(Lhs,k); it; ++it){
      int row = it.row();
      int col = it.col();
      A(row, col) += it.value();
    }
  }
  for (int k=0; k < Constraints.outerSize(); ++k){
    for (Eigen::SparseMatrix<double>::InnerIterator it(Constraints,k); it; ++it){
      int row = it.row();
      int col = it.col();
      C(row, col) += it.value();
    }
  }
 
  if (DEBUGPRINT)
    printf("\n SET %d INTEGER VALUES \n",n_integer_vars);
 
  double penalization = 0.000001;
  int offline_index   = ScalarSize;
  for(unsigned int i = 0; i < (n_integer_vars)*2; ++i)
  {
    int index=offline_index+i;
    A(index,index)=penalization;
  }
 
  if (DEBUGPRINT)
    printf("\n SET RHS \n");
 
  // copy RHS
  for(int i = 0; i < (int)ScalarSize; ++i)
  {
    B[i] = rhs[i] * cone_grid_res;
  }
 
  // copy constraint RHS
  if (DEBUGPRINT)
    printf("\n SET %d CONSTRAINTS \n",num_constraint_equations);
 
  for(unsigned int i = 0; i < num_constraint_equations; ++i)
  {
    C(i, SizeMatrix) = -constraints_rhs[i] * cone_grid_res;
  }
 
  COMISO::ConstrainedSolver solver;
 
  solver.misolver().set_local_iters(localIter);
 
  solver.misolver().set_direct_rounding(direct_round);
 
  std::sort(ids_to_round.begin(),ids_to_round.end());
  std::vector<int>::iterator new_end=std::unique(ids_to_round.begin(),ids_to_round.end());
  int dist=distance(ids_to_round.begin(),new_end);
  ids_to_round.resize(dist);
 
  solver.solve( C, A, X, B, ids_to_round, 0.0, false, false);
}

References col(), DEBUGPRINT, and row().

Here is the call graph for this function:

◆ SolvePoisson()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::SolvePoisson	(	Eigen::VectorXd	Stiffness,
		double	vector_field_scale = `0.1f`,
		double	grid_res = `1.f`,
		bool	direct_round = `true`,
		int	localIter = `0`,
		bool	_integer_rounding = `true`,
		bool	_singularity_rounding = `true`,
		std::vector< int >	roundVertices = `std::vector<int>()`,
		std::vector< std::vector< int > >	hardFeatures = `std::vector<std::vector<int> >()`
	)

Initializing Matrix

initialize the matrix ALLOCATING SPACE

build the laplacian system

{
  Handle_Stiffness = Stiffness;
 
  //initialization of flags and data structures
  integer_rounding=_integer_rounding;
 
  ids_to_round.clear();
 
  clearUserConstraint();
  // copy the user constraints number
  for (size_t i = 0; i < hardFeatures.size(); ++i)
  {
    addSharpEdgeConstraint(hardFeatures[i][0],hardFeatures[i][1]);
  }
 
 
  int t0=clock();
 
  InitMatrix();
  if (DEBUGPRINT)
    printf("\n ALLOCATED THE MATRIX \n");
 
  BuildLaplacianMatrix(vector_field_scale);
 
  // add seam constraints
  BuildSeamConstraintsExplicitTranslation();
 
  // add user defined constraints
  BuildUserDefinedConstraints();
 
  FixBlockedVertex();
 
  if (DEBUGPRINT)
    printf("\n BUILT THE MATRIX \n");
 
  if (integer_rounding)
    AddToRoundVertices(roundVertices);
 
  if (_singularity_rounding)
    AddSingularityRound();
 
  int t1=clock();
  if (DEBUGPRINT) printf("\n time:%d \n",t1-t0);
  if (DEBUGPRINT) printf("\n SOLVING \n");
 
  MixedIntegerSolve(grid_res,direct_round,localIter);
 
  int t2=clock();
  if (DEBUGPRINT) printf("\n time:%d \n",t2-t1);
  if (DEBUGPRINT) printf("\n ASSIGNING COORDS \n");
 
  MapCoords();
 
  int t3=clock();
  if (DEBUGPRINT) printf("\n time:%d \n",t3-t2);
  if (DEBUGPRINT) printf("\n FINISHED \n");
}

References DEBUGPRINT.

Referenced by igl::copyleft::comiso::MIQ_class< DerivedV, DerivedF, DerivedU >::MIQ_class().

Here is the caller graph for this function:

Member Data Documentation

◆ Constraints

template<typename DerivedV , typename DerivedF >

Eigen::SparseMatrix<double> igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::Constraints

◆ constraints_rhs

template<typename DerivedV , typename DerivedF >

Eigen::VectorXd igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::constraints_rhs

◆ F

template<typename DerivedV , typename DerivedF >

const Eigen::PlainObjectBase<DerivedF>& igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::F

Referenced by igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::PoissonSolver().

◆ Fcut

template<typename DerivedV , typename DerivedF >

const Eigen::PlainObjectBase<DerivedF>& igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::Fcut

Referenced by igl::copyleft::comiso::MIQ_class< DerivedV, DerivedF, DerivedU >::MIQ_class().

◆ Handle_Singular

template<typename DerivedV , typename DerivedF >

const Eigen::Matrix<int, Eigen::Dynamic, 1>& igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::Handle_Singular

◆ Handle_Stiffness

template<typename DerivedV , typename DerivedF >

Eigen::VectorXd igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::Handle_Stiffness

◆ Handle_SystemInfo

template<typename DerivedV , typename DerivedF >

const MeshSystemInfo& igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::Handle_SystemInfo

◆ Hard_constraints

template<typename DerivedV , typename DerivedF >

std::vector<int> igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::Hard_constraints

vector of blocked vertices

◆ ids_to_round

template<typename DerivedV , typename DerivedF >

std::vector<int> igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::ids_to_round

vector of indexes to round

◆ integer_rounding

template<typename DerivedV , typename DerivedF >

bool igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::integer_rounding

boolean that is true if rounding to integer is needed

◆ Lhs

template<typename DerivedV , typename DerivedF >

Eigen::SparseMatrix<double> igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::Lhs

◆ n_fixed_vars

template<typename DerivedV , typename DerivedF >

unsigned int igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::n_fixed_vars

number of fixed vertex

◆ n_integer_vars

template<typename DerivedV , typename DerivedF >

unsigned int igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::n_integer_vars

the total number of integer variables

◆ n_vert_vars

template<typename DerivedV , typename DerivedF >

unsigned int igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::n_vert_vars

the number of REAL variables for vertices

◆ num_constraint_equations

template<typename DerivedV , typename DerivedF >

unsigned int igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::num_constraint_equations

total number of constraints equations

◆ num_cut_constraint

template<typename DerivedV , typename DerivedF >

unsigned int igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::num_cut_constraint

CONSTRAINT PART number of cuts constraints.

◆ num_total_vars

template<typename DerivedV , typename DerivedF >

unsigned int igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::num_total_vars

total number of variables of the system, do not consider constraints, but consider integer vars

◆ num_userdefined_constraint

template<typename DerivedV , typename DerivedF >

unsigned int igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::num_userdefined_constraint

◆ PD1

template<typename DerivedV , typename DerivedF >

const Eigen::PlainObjectBase<DerivedV>& igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::PD1

◆ PD2

template<typename DerivedV , typename DerivedF >

const Eigen::PlainObjectBase<DerivedV>& igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::PD2

◆ rhs

template<typename DerivedV , typename DerivedF >

Eigen::VectorXd igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::rhs

◆ TT

template<typename DerivedV , typename DerivedF >

const Eigen::PlainObjectBase<DerivedF>& igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::TT

◆ TTi

template<typename DerivedV , typename DerivedF >

const Eigen::PlainObjectBase<DerivedF>& igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::TTi

◆ userdefined_constraints

template<typename DerivedV , typename DerivedF >

std::vector<std::vector<int > > igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::userdefined_constraints

vector of indexes to round

◆ UV

template<typename DerivedV , typename DerivedF >

Eigen::MatrixXd igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::UV

Referenced by igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::PoissonSolver().

◆ UV_out

template<typename DerivedV , typename DerivedF >

Eigen::MatrixXd igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::UV_out

Referenced by igl::copyleft::comiso::MIQ_class< DerivedV, DerivedF, DerivedU >::MIQ_class(), and igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::PoissonSolver().

◆ V

template<typename DerivedV , typename DerivedF >

const Eigen::PlainObjectBase<DerivedV>& igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::V

Referenced by igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::PoissonSolver().

◆ Vcut

template<typename DerivedV , typename DerivedF >

const Eigen::PlainObjectBase<DerivedV>& igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::Vcut

Referenced by igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::PoissonSolver().

◆ VF

template<typename DerivedV , typename DerivedF >

std::vector<std::vector<int> > igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::VF

Referenced by igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::PoissonSolver().

◆ VFi

template<typename DerivedV , typename DerivedF >

std::vector<std::vector<int> > igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::VFi

Referenced by igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::PoissonSolver().

◆ WUV

template<typename DerivedV , typename DerivedF >

Eigen::MatrixXd igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::WUV

Referenced by igl::copyleft::comiso::MIQ_class< DerivedV, DerivedF, DerivedU >::MIQ_class(), and igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::PoissonSolver().

◆ X

template<typename DerivedV , typename DerivedF >

std::vector< double > igl::copyleft::comiso::PoissonSolver< DerivedV, DerivedF >::X

vector of unknowns

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

src/libigl/igl/copyleft/comiso/miq.cpp

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PoissonSolver()

Member Function Documentation

◆ AddFixedVertex()

◆ addSharpEdgeConstraint()

◆ AddSingularityRound()

◆ AddToRoundVertices()

◆ AllocateSystem()

◆ BuildLaplacianMatrix()

◆ BuildSeamConstraintsExplicitTranslation()

◆ BuildUserDefinedConstraints()

◆ clearUserConstraint()

◆ FindFixedVert()

◆ FindFixedVertField()

◆ FindSizes()

◆ FixBlockedVertex()

◆ GetFirstVertexIndex()

◆ GetRotationComplex()

◆ InitMatrix()

◆ MapCoords()

◆ MixedIntegerSolve()

◆ SolvePoisson()

Member Data Documentation

◆ Constraints

◆ constraints_rhs

◆ F

◆ Fcut

◆ Handle_Singular

◆ Handle_Stiffness

◆ Handle_SystemInfo

◆ Hard_constraints

◆ ids_to_round

◆ integer_rounding

◆ Lhs

◆ n_fixed_vars

◆ n_integer_vars

◆ n_vert_vars

◆ num_constraint_equations

◆ num_cut_constraint

◆ num_total_vars

◆ num_userdefined_constraint

◆ PD1

◆ PD2

◆ rhs

◆ TT

◆ TTi

◆ userdefined_constraints

◆ UV

◆ UV_out

◆ V

◆ Vcut

◆ VF

◆ VFi

◆ WUV

◆ X