mirror of
https://github.com/OrcaSlicer/OrcaSlicer.git
synced 2026-05-19 11:23:42 +00:00
Update eigen to v5.0.1 and libigl to v2.6.0. (#11311)
* Update eigen from v3.3.7 to v5.0.1. This updates eigen from v3.3.7 released on December 11, 2018-12-11 to v5.0.1 released on 2025-11-11. There have be a large number of bug-fixes, optimizations, and improvements between these releases. See the details at; https://gitlab.com/libeigen/eigen/-/releases It retains the previous custom minimal `CMakeLists.txt`, and adds a README-OrcaSlicer.md that explains what version and parts of the upstream eigen release have been included, and where the full release can be found. * Update libigl from v2.0.0 (or older) to v2.6.0. This updates libigl from what was probably v2.0.0 released on 2018-10-16 to v2.6.0 released on 2025-05-15. It's possible the old version was even older than that but there is no version indicators in the code and I ran out of patience identifying missing changes and only went back as far as v2.0.0. There have been a large number of bug-fixes, optimizations, and improvements between these versions. See the following for details; https://github.com/libigl/libigl/releases I retained the minimal custom `CMakeLists.txt`, added `README.md` from the libigl distribution which identifies the version, and added a README-OrcaSlicer.md that details the version and parts that have been included. * Update libslic3r for libigl v2.6.0 changes. This updates libslic3r for all changes moving to eigen v5.0.1 and libigl v2.6.0. Despite the large number of updates to both dependencies, no changes were required for the eigen update, and only one change was required for the libigl update. For libigl, `igl::Hit` was changed to a template taking the Scalar type to use. Previously it was hard-coded to `float`, so to minimize possible impact I've updated all places it is used from `igl::Hit` to `igl::Hit<float>`. * Add compiler option `-DNOMINMAX` for libigl with MSVC. MSVC by default defines `min(()` and `max()` macros that break `std::numeric_limits<>::max()`. The upstream cmake that we don't include adds `-DNOMINMAX` for the libigl module when compiling with MSVC, so we need to add the same thing here. * Fix src/libslic3r/TriangleMeshDeal.cpp for the unmodified upstream libigl. This fixes `TriangleMeshDeal.cpp` to work with the unmodified upstream libigl v2.6.0. loop.{h,cpp} implementation. This file and feature was added in PR "BBS Port: Mesh Subdivision" (#12150) which included changes to `loop.{h,cpp}` in the old version of libigl. This PR avoids modifying the included dependencies, and uses the updated upstream versions of those files without any modifications, which requires fixing TriangleMeshDeal.cpp to work with them. In particular, the modifications made to `loop.{h,cpp}` included changing the return type from void to bool, adding additional validation checking of the input meshes, and returning false if they failed validation. These added checks looked unnecessary and would only have caught problems if the input mesh was very corrupt. To make `TriangleMeshDeal.cpp` work without this built-in checking functionality, I removed checking/handling of any `false` return value. There was also a hell of a lot of redundant copying and casting back and forth between float and double, so I cleaned that up. The input and output meshs use floats for the vertexes, and there would be no accuracy benefits from casting to and from doubles for the simple weighted average operations done by igl::loop(). So this just uses `Eigen:Map` to use the original input mesh vertex data directly without requiring any copy or casting. * Move eigen from included `deps_src` to externaly fetched `deps`. This copys what PrusaSlicer did and moved it from an included dependency under `deps_src` to an externaly fetched dependency under `deps`. This requires updating some `CMakeList.txt` configs and removing the old and obsolete `cmake/modules/FindEigen3.cmake`. The details of when this was done in PrusaSlicer and the followup fixes are at; *21116995d7* https://github.com/prusa3d/PrusaSlicer/issues/13608 * https://github.com/prusa3d/PrusaSlicer/pull/13609 *e3c277b9eeFor some reason I don't fully understand this also required fixing `src/slic3r/GUI/GUI_App.cpp` by adding `#include <boost/nowide/cstdio.hpp>` to fix an `error: ‘remove’ is not a member of ‘boost::nowide'`. The main thing I don't understand is how it worked before. Note that this include is in the PrusaSlicer version of this file, but it also significantly deviates from what is currently in OrcaSlicer in many other ways. * Whups... I missed adding the deps/Eigen/Eigen.cmake file... * Tidy some whitespace indenting in CMakeLists.txt. * Ugh... tabs indenting needing fixes. * Change the include order of deps/Eigen. It turns out that although Boost includes some references to Eigen, Eigen also includes some references to Boost for supporting some of it's additional numeric types. I don't think it matters much since we are not using these features, but I think technically its more correct to say Eigen depends on Boost than the other way around, so I've re-ordered them. * Add source for Eigen 5.0.1 download to flatpak yml config. * Add explicit `DEPENDS dep_Boost to deps/Eigen. I missed this before. This ensures we don't rely on include orders to make sure Boost is installed before we configure Eigen. * Add `DEPENDS dep_Boost dep_GMP dep_MPFR` to deps/Eigen. It turns out Eigen can also use GMP and MPFR for multi-precision and multi-precision-rounded numeric types if they are available. Again, I don't think we are using these so it doesn't really matter, but it is technically correct and ensures they are there if we ever do need them. * Fix deps DEPENDENCY ordering for GMP, MPFR, Eigen, and CGAL. I think this is finally correct. Apparently CGAL also optionally depends on Eigen, so the correct dependency order from lowest to highest is GMP, MPFR, Eigen, and CGAL. --------- Co-authored-by: Donovan Baarda <dbaarda@google.com> Co-authored-by: Noisyfox <timemanager.rick@gmail.com>
This commit is contained in:
Donovan Baarda
committed by
SoftFever
SoftFever
parent
797ee70b0b
commit
807520ca1d
@@ -1,330 +1,161 @@
|
||||
// This file is part of libigl, a simple c++ geometry processing library.
|
||||
//
|
||||
// Copyright (C) 2016 Alec Jacobson <alecjacobson@gmail.com>
|
||||
//
|
||||
// This Source Code Form is subject to the terms of the Mozilla Public License
|
||||
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
|
||||
//
|
||||
// Copyright (C) 2019 Hanxiao Shen <hanxiao@cims.nyu.edu>
|
||||
//
|
||||
// This Source Code Form is subject to the terms of the Mozilla Public License
|
||||
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
|
||||
// obtain one at http://mozilla.org/MPL/2.0/.
|
||||
#include <igl/cut_mesh.h>
|
||||
#include <igl/vertex_triangle_adjacency.h>
|
||||
#include <igl/triangle_triangle_adjacency.h>
|
||||
#include <igl/is_border_vertex.h>
|
||||
#include <igl/HalfEdgeIterator.h>
|
||||
#include <set>
|
||||
#include "cut_mesh.h"
|
||||
#include "triangle_triangle_adjacency.h"
|
||||
#include "HalfEdgeIterator.h"
|
||||
#include "is_border_vertex.h"
|
||||
|
||||
// This file violates many of the libigl style guidelines.
|
||||
|
||||
namespace igl {
|
||||
|
||||
|
||||
template <typename DerivedV, typename DerivedF, typename VFType, typename DerivedTT, typename DerivedC>
|
||||
class MeshCutterMini
|
||||
{
|
||||
public:
|
||||
// Input
|
||||
//mesh
|
||||
const Eigen::PlainObjectBase<DerivedV> &V;
|
||||
const Eigen::PlainObjectBase<DerivedF> &F;
|
||||
// TT is the same type as TTi? This is likely to break at some point
|
||||
const Eigen::PlainObjectBase<DerivedTT> &TT;
|
||||
const Eigen::PlainObjectBase<DerivedTT> &TTi;
|
||||
const std::vector<std::vector<VFType> >& VF;
|
||||
const std::vector<std::vector<VFType> >& VFi;
|
||||
const std::vector<bool> &V_border; // bool
|
||||
//edges to cut
|
||||
const Eigen::PlainObjectBase<DerivedC> &Handle_Seams; // 3 bool
|
||||
|
||||
// total number of scalar variables
|
||||
int num_scalar_variables;
|
||||
|
||||
// per face indexes of vertex in the solver
|
||||
DerivedF HandleS_Index;
|
||||
|
||||
// per vertex variable indexes
|
||||
std::vector<std::vector<int> > HandleV_Integer;
|
||||
|
||||
IGL_INLINE MeshCutterMini(
|
||||
const Eigen::PlainObjectBase<DerivedV> &_V,
|
||||
const Eigen::PlainObjectBase<DerivedF> &_F,
|
||||
const Eigen::PlainObjectBase<DerivedTT> &_TT,
|
||||
const Eigen::PlainObjectBase<DerivedTT> &_TTi,
|
||||
const std::vector<std::vector<VFType> > &_VF,
|
||||
const std::vector<std::vector<VFType> > &_VFi,
|
||||
const std::vector<bool> &_V_border,
|
||||
const Eigen::PlainObjectBase<DerivedC> &_Handle_Seams);
|
||||
|
||||
// vertex to variable mapping
|
||||
// initialize the mapping for a given sampled mesh
|
||||
IGL_INLINE void InitMappingSeam();
|
||||
|
||||
private:
|
||||
|
||||
IGL_INLINE void FirstPos(const int v, int &f, int &edge);
|
||||
|
||||
IGL_INLINE int AddNewIndex(const int v0);
|
||||
|
||||
IGL_INLINE bool IsSeam(const int f0, const int f1);
|
||||
|
||||
// find initial position of the pos to
|
||||
// assing face to vert inxex correctly
|
||||
IGL_INLINE void FindInitialPos(const int vert, int &edge, int &face);
|
||||
|
||||
|
||||
// initialize the mapping given an initial pos
|
||||
// whih must be initialized with FindInitialPos
|
||||
IGL_INLINE void MapIndexes(const int vert, const int edge_init, const int f_init);
|
||||
|
||||
// initialize the mapping for a given vertex
|
||||
IGL_INLINE void InitMappingSeam(const int vert);
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
template <typename DerivedV, typename DerivedF, typename VFType, typename DerivedTT, typename DerivedC>
|
||||
IGL_INLINE igl::MeshCutterMini<DerivedV, DerivedF, VFType, DerivedTT, DerivedC>::
|
||||
MeshCutterMini(
|
||||
const Eigen::PlainObjectBase<DerivedV> &_V,
|
||||
const Eigen::PlainObjectBase<DerivedF> &_F,
|
||||
const Eigen::PlainObjectBase<DerivedTT> &_TT,
|
||||
const Eigen::PlainObjectBase<DerivedTT> &_TTi,
|
||||
const std::vector<std::vector<VFType> > &_VF,
|
||||
const std::vector<std::vector<VFType> > &_VFi,
|
||||
const std::vector<bool> &_V_border,
|
||||
const Eigen::PlainObjectBase<DerivedC> &_Handle_Seams):
|
||||
V(_V),
|
||||
F(_F),
|
||||
TT(_TT),
|
||||
TTi(_TTi),
|
||||
VF(_VF),
|
||||
VFi(_VFi),
|
||||
V_border(_V_border),
|
||||
Handle_Seams(_Handle_Seams)
|
||||
{
|
||||
num_scalar_variables=0;
|
||||
HandleS_Index.setConstant(F.rows(),3,-1);
|
||||
HandleV_Integer.resize(V.rows());
|
||||
}
|
||||
|
||||
|
||||
template <typename DerivedV, typename DerivedF, typename VFType, typename DerivedTT, typename DerivedC>
|
||||
IGL_INLINE void igl::MeshCutterMini<DerivedV, DerivedF, VFType, DerivedTT, DerivedC>::
|
||||
FirstPos(const int v, int &f, int &edge)
|
||||
{
|
||||
f = VF[v][0]; // f=v->cVFp();
|
||||
edge = VFi[v][0]; // edge=v->cVFi();
|
||||
}
|
||||
|
||||
template <typename DerivedV, typename DerivedF, typename VFType, typename DerivedTT, typename DerivedC>
|
||||
IGL_INLINE int igl::MeshCutterMini<DerivedV, DerivedF, VFType, DerivedTT, DerivedC>::
|
||||
AddNewIndex(const int v0)
|
||||
{
|
||||
num_scalar_variables++;
|
||||
HandleV_Integer[v0].push_back(num_scalar_variables);
|
||||
return num_scalar_variables;
|
||||
}
|
||||
|
||||
template <typename DerivedV, typename DerivedF, typename VFType, typename DerivedTT, typename DerivedC>
|
||||
IGL_INLINE bool igl::MeshCutterMini<DerivedV, DerivedF, VFType, DerivedTT, DerivedC>::
|
||||
IsSeam(const int f0, const int f1)
|
||||
{
|
||||
for (int i=0;i<3;i++)
|
||||
{
|
||||
int f_clos = TT(f0,i);
|
||||
|
||||
if (f_clos == -1)
|
||||
continue; ///border
|
||||
|
||||
if (f_clos == f1)
|
||||
return(Handle_Seams(f0,i));
|
||||
}
|
||||
assert(0);
|
||||
return false;
|
||||
}
|
||||
|
||||
///find initial position of the pos to
|
||||
// assing face to vert inxex correctly
|
||||
template <typename DerivedV, typename DerivedF, typename VFType, typename DerivedTT, typename DerivedC>
|
||||
IGL_INLINE void igl::MeshCutterMini<DerivedV, DerivedF, VFType, DerivedTT, DerivedC>::
|
||||
FindInitialPos(const int vert,
|
||||
int &edge,
|
||||
int &face)
|
||||
{
|
||||
int f_init;
|
||||
int edge_init;
|
||||
FirstPos(vert,f_init,edge_init); // todo manually the function
|
||||
igl::HalfEdgeIterator<DerivedF,DerivedTT,DerivedTT> VFI(F,TT,TTi,f_init,edge_init);
|
||||
|
||||
bool vertexB = V_border[vert];
|
||||
bool possible_split=false;
|
||||
bool complete_turn=false;
|
||||
do
|
||||
{
|
||||
int curr_f = VFI.Fi();
|
||||
int curr_edge=VFI.Ei();
|
||||
VFI.NextFE();
|
||||
int next_f=VFI.Fi();
|
||||
///test if I've just crossed a border
|
||||
bool on_border=(TT(curr_f,curr_edge)==-1);
|
||||
//bool mismatch=false;
|
||||
bool seam=false;
|
||||
|
||||
///or if I've just crossed a seam
|
||||
///if I'm on a border I MUST start from the one next t othe border
|
||||
if (!vertexB)
|
||||
//seam=curr_f->IsSeam(next_f);
|
||||
seam=IsSeam(curr_f,next_f);
|
||||
// if (vertexB)
|
||||
// assert(!Handle_Singular(vert));
|
||||
// ;
|
||||
//assert(!vert->IsSingular());
|
||||
possible_split=((on_border)||(seam));
|
||||
complete_turn = next_f == f_init;
|
||||
} while ((!possible_split)&&(!complete_turn));
|
||||
face=VFI.Fi();
|
||||
edge=VFI.Ei();
|
||||
}
|
||||
|
||||
|
||||
|
||||
///initialize the mapping given an initial pos
|
||||
///whih must be initialized with FindInitialPos
|
||||
template <typename DerivedV, typename DerivedF, typename VFType, typename DerivedTT, typename DerivedC>
|
||||
IGL_INLINE void igl::MeshCutterMini<DerivedV, DerivedF, VFType, DerivedTT, DerivedC>::
|
||||
MapIndexes(const int vert,
|
||||
const int edge_init,
|
||||
const int f_init)
|
||||
{
|
||||
///check that is not on border..
|
||||
///in such case maybe it's non manyfold
|
||||
///insert an initial index
|
||||
int curr_index=AddNewIndex(vert);
|
||||
///and initialize the jumping pos
|
||||
igl::HalfEdgeIterator<DerivedF,DerivedTT,DerivedTT> VFI(F,TT,TTi,f_init,edge_init);
|
||||
bool complete_turn=false;
|
||||
do
|
||||
{
|
||||
int curr_f = VFI.Fi();
|
||||
int curr_edge = VFI.Ei();
|
||||
///assing the current index
|
||||
HandleS_Index(curr_f,curr_edge) = curr_index;
|
||||
VFI.NextFE();
|
||||
int next_f = VFI.Fi();
|
||||
///test if I've finiseh with the face exploration
|
||||
complete_turn = (next_f==f_init);
|
||||
///or if I've just crossed a mismatch
|
||||
if (!complete_turn)
|
||||
{
|
||||
bool seam=false;
|
||||
//seam=curr_f->IsSeam(next_f);
|
||||
seam=IsSeam(curr_f,next_f);
|
||||
if (seam)
|
||||
{
|
||||
///then add a new index
|
||||
curr_index=AddNewIndex(vert);
|
||||
}
|
||||
}
|
||||
} while (!complete_turn);
|
||||
}
|
||||
|
||||
///initialize the mapping for a given vertex
|
||||
template <typename DerivedV, typename DerivedF, typename VFType, typename DerivedTT, typename DerivedC>
|
||||
IGL_INLINE void igl::MeshCutterMini<DerivedV, DerivedF, VFType, DerivedTT, DerivedC>::
|
||||
InitMappingSeam(const int vert)
|
||||
{
|
||||
///first rotate until find the first pos after a mismatch
|
||||
///or a border or return to the first position...
|
||||
int f_init = VF[vert][0];
|
||||
int indexE = VFi[vert][0];
|
||||
|
||||
igl::HalfEdgeIterator<DerivedF,DerivedTT,DerivedTT> VFI(F,TT,TTi,f_init,indexE);
|
||||
|
||||
int edge_init;
|
||||
int face_init;
|
||||
FindInitialPos(vert,edge_init,face_init);
|
||||
MapIndexes(vert,edge_init,face_init);
|
||||
}
|
||||
|
||||
///vertex to variable mapping
|
||||
///initialize the mapping for a given sampled mesh
|
||||
template <typename DerivedV, typename DerivedF, typename VFType, typename DerivedTT, typename DerivedC>
|
||||
IGL_INLINE void igl::MeshCutterMini<DerivedV, DerivedF, VFType, DerivedTT, DerivedC>::
|
||||
InitMappingSeam()
|
||||
{
|
||||
num_scalar_variables=-1;
|
||||
for (unsigned int i=0;i<V.rows();i++)
|
||||
InitMappingSeam(i);
|
||||
|
||||
for (unsigned int j=0;j<V.rows();j++)
|
||||
assert(HandleV_Integer[j].size()>0);
|
||||
}
|
||||
|
||||
|
||||
template <typename DerivedV, typename DerivedF, typename VFType, typename DerivedTT, typename DerivedC>
|
||||
IGL_INLINE void igl::cut_mesh(
|
||||
const Eigen::PlainObjectBase<DerivedV> &V,
|
||||
const Eigen::PlainObjectBase<DerivedF> &F,
|
||||
const std::vector<std::vector<VFType> >& VF,
|
||||
const std::vector<std::vector<VFType> >& VFi,
|
||||
const Eigen::PlainObjectBase<DerivedTT>& TT,
|
||||
const Eigen::PlainObjectBase<DerivedTT>& TTi,
|
||||
const std::vector<bool> &V_border,
|
||||
const Eigen::PlainObjectBase<DerivedC> &cuts,
|
||||
Eigen::PlainObjectBase<DerivedV> &Vcut,
|
||||
Eigen::PlainObjectBase<DerivedF> &Fcut)
|
||||
{
|
||||
//finding the cuts is done, now we need to actually generate a cut mesh
|
||||
igl::MeshCutterMini<DerivedV, DerivedF, VFType, DerivedTT, DerivedC> mc(V, F, TT, TTi, VF, VFi, V_border, cuts);
|
||||
mc.InitMappingSeam();
|
||||
|
||||
Fcut = mc.HandleS_Index;
|
||||
//we have the faces, we need the vertices;
|
||||
int newNumV = Fcut.maxCoeff()+1;
|
||||
Vcut.setZero(newNumV,3);
|
||||
for (int vi=0; vi<V.rows(); ++vi)
|
||||
for (int i=0; i<mc.HandleV_Integer[vi].size();++i)
|
||||
Vcut.row(mc.HandleV_Integer[vi][i]) = V.row(vi);
|
||||
|
||||
//ugly hack to fix some problematic cases (border vertex that is also on the boundary of the hole
|
||||
for (int fi =0; fi<Fcut.rows(); ++fi)
|
||||
for (int k=0; k<3; ++k)
|
||||
if (Fcut(fi,k)==-1)
|
||||
{
|
||||
//we need to add a vertex
|
||||
Fcut(fi,k) = newNumV;
|
||||
newNumV ++;
|
||||
Vcut.conservativeResize(newNumV, Eigen::NoChange);
|
||||
Vcut.row(newNumV-1) = V.row(F(fi,k));
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
//Wrapper of the above with only vertices and faces as mesh input
|
||||
// wrapper for input/output style
|
||||
template <typename DerivedV, typename DerivedF, typename DerivedC>
|
||||
IGL_INLINE void igl::cut_mesh(
|
||||
const Eigen::PlainObjectBase<DerivedV> &V,
|
||||
const Eigen::PlainObjectBase<DerivedF> &F,
|
||||
const Eigen::PlainObjectBase<DerivedC> &cuts,
|
||||
Eigen::PlainObjectBase<DerivedV> &Vcut,
|
||||
Eigen::PlainObjectBase<DerivedF> &Fcut)
|
||||
{
|
||||
std::vector<std::vector<int> > VF, VFi;
|
||||
igl::vertex_triangle_adjacency(V,F,VF,VFi);
|
||||
// Alec: Cast? Why? This is likely to break.
|
||||
Eigen::MatrixXd Vt = V;
|
||||
Eigen::MatrixXi Ft = F;
|
||||
Eigen::MatrixXi TT, TTi;
|
||||
igl::triangle_triangle_adjacency(Ft,TT,TTi);
|
||||
std::vector<bool> V_border = igl::is_border_vertex(V,F);
|
||||
igl::cut_mesh(V, F, VF, VFi, TT, TTi, V_border, cuts, Vcut, Fcut);
|
||||
const Eigen::MatrixBase<DerivedV>& V,
|
||||
const Eigen::MatrixBase<DerivedF>& F,
|
||||
const Eigen::MatrixBase<DerivedC>& C,
|
||||
Eigen::PlainObjectBase<DerivedV>& Vn,
|
||||
Eigen::PlainObjectBase<DerivedF>& Fn
|
||||
){
|
||||
Vn = V;
|
||||
Fn = F;
|
||||
typedef typename DerivedF::Scalar Index;
|
||||
Eigen::Matrix<Index,Eigen::Dynamic,1> _I;
|
||||
cut_mesh(Vn,Fn,C,_I);
|
||||
}
|
||||
|
||||
template <
|
||||
typename DerivedV,
|
||||
typename DerivedF,
|
||||
typename DerivedC,
|
||||
typename DerivedVn,
|
||||
typename DerivedFn,
|
||||
typename DerivedI>
|
||||
IGL_INLINE void igl::cut_mesh(
|
||||
const Eigen::MatrixBase<DerivedV>& V,
|
||||
const Eigen::MatrixBase<DerivedF>& F,
|
||||
const Eigen::MatrixBase<DerivedC>& C,
|
||||
Eigen::PlainObjectBase<DerivedVn>& Vn,
|
||||
Eigen::PlainObjectBase<DerivedFn>& Fn,
|
||||
Eigen::PlainObjectBase<DerivedI>& I
|
||||
){
|
||||
static_assert(std::is_same<typename DerivedV::Scalar, typename DerivedVn::Scalar>::value, "Scalar types of V and Vn must match");
|
||||
static_assert(std::is_same<typename DerivedF::Scalar, typename DerivedFn::Scalar>::value, "Scalar types of F and Fn must match");
|
||||
Vn = V;
|
||||
Fn = F;
|
||||
cut_mesh(Vn,Fn,C,I);
|
||||
}
|
||||
|
||||
template <typename DerivedV, typename DerivedF, typename DerivedC, typename DerivedI>
|
||||
IGL_INLINE void igl::cut_mesh(
|
||||
Eigen::PlainObjectBase<DerivedV>& V,
|
||||
Eigen::PlainObjectBase<DerivedF>& F,
|
||||
const Eigen::MatrixBase<DerivedC>& C,
|
||||
Eigen::PlainObjectBase<DerivedI>& I
|
||||
){
|
||||
DerivedF FF, FFi;
|
||||
igl::triangle_triangle_adjacency(F,FF,FFi);
|
||||
igl::cut_mesh(V,F,FF,FFi,C,I);
|
||||
}
|
||||
|
||||
template <typename DerivedV, typename DerivedF, typename DerivedFF, typename DerivedFFi, typename DerivedC, typename DerivedI>
|
||||
IGL_INLINE void igl::cut_mesh(
|
||||
Eigen::PlainObjectBase<DerivedV>& V,
|
||||
Eigen::PlainObjectBase<DerivedF>& F,
|
||||
Eigen::MatrixBase<DerivedFF>& FF,
|
||||
Eigen::MatrixBase<DerivedFFi>& FFi,
|
||||
const Eigen::MatrixBase<DerivedC>& C,
|
||||
Eigen::PlainObjectBase<DerivedI>& I
|
||||
){
|
||||
|
||||
typedef typename DerivedF::Scalar Index;
|
||||
|
||||
// store current number of occurance of each vertex as the alg proceed
|
||||
Eigen::Matrix<Index,Eigen::Dynamic,1> occurence(V.rows());
|
||||
occurence.setConstant(1);
|
||||
|
||||
// set eventual number of occurance of each vertex expected
|
||||
Eigen::Matrix<Index,Eigen::Dynamic,1> eventual(V.rows());
|
||||
eventual.setZero();
|
||||
for(Index i=0;i<F.rows();i++){
|
||||
for(Index k=0;k<3;k++){
|
||||
Index u = F(i,k);
|
||||
Index v = F(i,(k+1)%3);
|
||||
if(FF(i,k) == -1){
|
||||
// add one extra occurance for boundary vertices
|
||||
eventual(u) += 1;
|
||||
}else if(
|
||||
(u < v) &&
|
||||
(C(i,k) || C(FF(i,k),FFi(i,k))) )
|
||||
{
|
||||
// only compute every (undirected) edge ones
|
||||
eventual(u) += 1;
|
||||
eventual(v) += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// original number of vertices
|
||||
Index n_v = V.rows();
|
||||
|
||||
// estimate number of new vertices and resize V
|
||||
Index n_new = 0;
|
||||
for(Index i=0;i<eventual.rows();i++)
|
||||
n_new += ((eventual(i) > 0) ? eventual(i)-1 : 0);
|
||||
V.conservativeResize(n_v+n_new,Eigen::NoChange);
|
||||
I = DerivedI::LinSpaced(V.rows(),0,V.rows());
|
||||
|
||||
// pointing to the current bottom of V
|
||||
Index pos = n_v;
|
||||
for(Index f=0;f<C.rows();f++){
|
||||
for(Index k=0;k<3;k++){
|
||||
Index v0 = F(f,k);
|
||||
if(F(f,k) >= n_v) continue; // ignore new vertices
|
||||
if(C(f,k) == 1 && occurence(v0) != eventual(v0)){
|
||||
igl::HalfEdgeIterator<DerivedF,DerivedF,DerivedF> he(F,FF,FFi,f,k);
|
||||
|
||||
// rotate clock-wise around v0 until hit another cut
|
||||
std::vector<Index> fan;
|
||||
Index fi = he.Fi();
|
||||
Index ei = he.Ei();
|
||||
do{
|
||||
fan.push_back(fi);
|
||||
he.flipE();
|
||||
he.flipF();
|
||||
fi = he.Fi();
|
||||
ei = he.Ei();
|
||||
}while(C(fi,ei) == 0 && !he.isBorder());
|
||||
|
||||
// make a copy
|
||||
V.row(pos) << V.row(v0);
|
||||
I(pos) = v0;
|
||||
// add one occurance to v0
|
||||
occurence(v0) += 1;
|
||||
|
||||
// replace old v0
|
||||
for(Index f0: fan)
|
||||
for(Index j=0;j<3;j++)
|
||||
if(F(f0,j) == v0)
|
||||
F(f0,j) = pos;
|
||||
|
||||
// mark cuts as boundary
|
||||
FF(f,k) = -1;
|
||||
FF(fi,ei) = -1;
|
||||
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
#ifdef IGL_STATIC_LIBRARY
|
||||
// Explicit template instantiation
|
||||
template void igl::cut_mesh<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, int, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, std::vector<bool, std::allocator<bool> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
||||
template void igl::cut_mesh<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
||||
template void igl::cut_mesh<Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> >&);
|
||||
template void igl::cut_mesh<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 3, 0, -1, 3> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
||||
template void igl::cut_mesh<Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> >&);
|
||||
template void igl::cut_mesh<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 3, 0, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
||||
template void igl::cut_mesh<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
||||
template void igl::cut_mesh<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&);
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user