manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

small updates

This commit is contained in:
T.Alderighi 2018-05-08 13:16:07 +02:00
parent 239dfce517
commit 25339718d9
4 changed files with 322 additions and 387 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vcg/complex/algorithms/update/flag.h
View File

@ -192,7 +192,7 @@ public:
if(!(*ti).IsD()) if(!(*ti).IsD())
for(int j = 0; j < 4; ++j) for(int j = 0; j < 4; ++j)
{ {
if (tetrahedron::IsBorder(*fi,j)) (*ti).SetB(j); if (tetrahedron::IsBorder(*ti,j)) (*ti).SetB(j);
else (*ti).ClearB(j); else (*ti).ClearB(j);
} }
} }

120
vcg/simplex/tetrahedron/base.h
View File

@ -44,30 +44,6 @@ added
namespace vcg { namespace vcg {
/*------------------------------------------------------------------*/ /*------------------------------------------------------------------*/
/*
The base class of all the recusive definition chain. It is just a container of the typenames of the various simplexes.
These typenames must be known form all the derived classes.
*/
// template <class BVT, class BET, class BFT, class BTT>
// class TetraTypeHolder{
// public:
// typedef BVT VertexType;
// typedef typename VertexType::CoordType CoordType;
// typedef typename VertexType::ScalarType ScalarType;
// typedef BET EdgeType;
// typedef BFT FaceType;
// typedef BTT TetraType;
// typedef BVT *VertPointer;
// typedef BET *EdgePointer;
// typedef BFT *FacePointer;
// typedef BTT *TetraPointer;
// static void Name(std::vector<std::string> & name){}
// // prot
// };
// /* The base class form which we start to add our components. // /* The base class form which we start to add our components.
// it has the empty definition for all the standard members (coords, color flags) // it has the empty definition for all the standard members (coords, color flags)
@ -80,87 +56,14 @@ These typenames must be known form all the derived classes.
// we have to build the type a step a time (deriving from a single ancestor at a time). // we have to build the type a step a time (deriving from a single ancestor at a time).
// */
// template <class BVT, class BET=DumET, class BFT=DumFT, class BTT=DumTT>
// class TetraBase: public tetra::EmptyCore<
// TetraTypeHolder <BVT, BET, BFT, BTT> > {
// };
// // Metaprogramming Core
// template <class BVT, class BET, class BFT,class BTT,
// template <typename> class A>
// class TetraArity1: public A<TetraBase<BVT,BET,BFT,BTT> > {};
// template <class BVT, class BET, typename BFT, class BTT,
// template <typename> class A, template <typename> class B>
// class TetraArity2: public B<TetraArity1<BVT,BET,BFT,BTT, A> > {};
// template <class BVT, class BET, typename BFT,class BTT,
// template <typename> class A, template <typename> class B,
// template <typename> class C >
// class TetraArity3: public C<TetraArity2<BVT,BET,BFT,BTT, A, B> > {};
// template <class BVT, class BET, typename BFT,class BTT,
// template <typename> class A, template <typename> class B,
// template <typename> class C, template <typename> class D>
// class TetraArity4: public D<TetraArity3<BVT,BET,BFT,BTT, A, B, C> > {};
// template <class BVT, class BET, typename BFT,class BTT,
// template <typename> class A, template <typename> class B,
// template <typename> class C, template <typename> class D,
// template <typename> class E >
// class TetraArity5: public E<TetraArity4<BVT,BET,BFT,BTT, A, B, C, D> > {};
// template <class BVT, class BET, typename BFT,class BTT,
// template <typename> class A, template <typename> class B,
// template <typename> class C, template <typename> class D,
// template <typename> class E, template <typename> class F >
// class TetraArity6: public F<TetraArity5<BVT,BET,BFT,BTT, A, B, C, D, E> > {};
// template <class BVT, class BET, typename BFT,class BTT,
// template <typename> class A, template <typename> class B,
// template <typename> class C, template <typename> class D,
// template <typename> class E, template <typename> class F,
// template <typename> class G >
// class TetraArity7: public G<TetraArity6<BVT,BET,BFT,BTT, A, B, C, D, E, F> > {};
// template <class BVT, class BET, typename BFT,class BTT,
// template <typename> class A, template <typename> class B,
// template <typename> class C, template <typename> class D,
// template <typename> class E, template <typename> class F,
// template <typename> class G, template <typename> class H >
// class TetraArity8: public H<TetraArity7<BVT,BET,BFT,BTT, A, B, C, D, E, F, G> > {};
// /* The Real Big Face class;
// The class __FaceArityMax__ is the one that is the Last to be derived,
// and therefore is the only one to know the real members
// (after the many overrides) so all the functions with common behaviour
// using the members defined in the various Empty/nonEmpty component classes
// MUST be defined here.
// I.e. IsD() that uses the overridden Flags() member must be defined here.
// */
// template <class BVT, class BET, typename BFT,class BTT,
// template <typename> class A, template <typename> class B,
// template <typename> class C, template <typename> class D,
// template <typename> class E, template <typename> class F,
// template <typename> class G, template <typename> class H,
// template <typename> class I >
// class TetraArityMax: public I<TetraArity8<BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H> > {
template <class UserTypes> template <class UserTypes>
class TetraTypeHolder: public UserTypes { class TetraTypeHolder: public UserTypes {
public: public:
template <class LeftT> template <class RightT>
void ImportData(const LeftT & ){} void ImportData(const RightT & ){}
static void Name(std::vector<std::string> & /* name */){} static void Name(std::vector<std::string> & /* name */){}
@ -209,6 +112,7 @@ public:
BORDER1 = 0x00000080, BORDER1 = 0x00000080,
BORDER2 = 0x00000100, BORDER2 = 0x00000100,
BORDER3 = 0x00000200, BORDER3 = 0x00000200,
BORDER0123 = BORDER0 | BORDER1 | BORDER2 | BORDER3,
// Crease _flags, it is assumed that FEATUREi = FEATURE0<<i // Crease _flags, it is assumed that FEATUREi = FEATURE0<<i
// First user bit // First user bit
USER0 = 0x00004000 USER0 = 0x00004000
@ -260,7 +164,7 @@ public:
void ClearV() {this->Flags() &= ~VISITED;} void ClearV() {this->Flags() &= ~VISITED;}
/// This function checks if the face is selected /// This function checks if the face is selected
bool IsB(int i) const {return (this->Flags() & (BORDER0<<i)) != 0;} bool IsB(int i) const {return (this->cFlags() & (BORDER0<<i)) != 0;}
/// This function select the face /// This function select the face
void SetB(int i) {this->Flags() |=(BORDER0<<i);} void SetB(int i) {this->Flags() |=(BORDER0<<i);}
/// This funcion execute the inverse operation of SetS() /// This funcion execute the inverse operation of SetS()
@ -345,22 +249,6 @@ TTAdj //topology: face face adj
*/ */
// template <class BVT, class BET, class BFT, class BTT,
// template <typename> class A = TetraDefaultDeriver, template <typename> class B = TetraDefaultDeriver,
// template <typename> class C = TetraDefaultDeriver, template <typename> class D = TetraDefaultDeriver,
// template <typename> class E = TetraDefaultDeriver, template <typename> class F = TetraDefaultDeriver,
// template <typename> class G = TetraDefaultDeriver, template <typename> class H = TetraDefaultDeriver,
// template <typename> class I = TetraDefaultDeriver >
// class TetraSimp3: public TetraArityMax<BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I> {};
// class DumTT;
// template <class BVT, class BET, class BFT,
// template <typename> class A = TetraDefaultDeriver, template <typename> class B = TetraDefaultDeriver,
// template <typename> class C = TetraDefaultDeriver, template <typename> class D = TetraDefaultDeriver,
// template <typename> class E = TetraDefaultDeriver, template <typename> class F = TetraDefaultDeriver,
// template <typename> class G = TetraDefaultDeriver, template <typename> class H = TetraDefaultDeriver,
// template <typename> class I = TetraDefaultDeriver >
// class TetraSimp2: public TetraArityMax<BVT,BET,BFT,DumTT, A, B, C, D, E, F, G, H, I> {};
template <class UserTypes, template <class UserTypes,
template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver, template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
template <typename> class C = DefaultDeriver, template <typename> class D = DefaultDeriver, template <typename> class C = DefaultDeriver, template <typename> class D = DefaultDeriver,

5
vcg/simplex/tetrahedron/component.h
View File

@ -287,8 +287,9 @@ template <class T> class BitFlags: public T {
public: public:
typedef int FlagType; typedef int FlagType;
BitFlags(){_flags=0;} BitFlags(){_flags=0;}
int &Flags() {return _flags; }
int cFlags() const {return _flags; } inline int &Flags() {return _flags; }
inline int cFlags() const {return _flags; }
template <class RightValueType> template <class RightValueType>
void ImportData(const RightValueType & rightT){ void ImportData(const RightValueType & rightT){

46
vcg/simplex/tetrahedron/topology.h
View File

@ -42,6 +42,52 @@ inline bool IsBorder(TetraType const & t, const int j )
return true; return true;
} }
template <class TetraMesh, class TriMesh>
inline void TriMeshFromBorder(TetraMesh & tetramesh, TriMesh & trimesh)
{
RequireTTAdjacency(tetramesh);
tri::UpdateTopology<TetraMesh>::TetraTetra(tetramesh);
trimesh.Clear();
std::vector<TriMesh::VertexPointer> verts;
std::vector<TriMesh::FacePointer> faces;
ForEachTetra(tetramesh, [&] (TetraMesh::TetraType & t) {
for (int i = 0; i < 4; ++i)
if (IsBorder(t, i))
{
verts.push_back(t.V(Tetra::VofF(i, 0)));
verts.push_back(t.V(Tetra::VofF(i, 1)));
verts.push_back(t.V(Tetra::VofF(i, 2)));
}
});
TriMesh::VertexIterator vi = tri::Allocator<TriMesh>::AddVertices(trimesh, verts.size());
TriMesh::FaceIterator fi = tri::Allocator<TriMesh>::AddFaces(trimesh, verts.size() / 3);
for (int i = 0; i < verts.size(); i += 3)
{
fi->Alloc(3);
vi->P() = verts[i + 0]->P();
fi->V(0) = &*vi;
++vi;
vi->P() = verts[i + 1]->P();
fi->V(1) = &*vi;
++vi;
vi->P() = verts[i + 2]->P();
fi->V(2) = &*vi;
++vi;
++fi;
}
tri::Clean<TriMesh>::RemoveDuplicateVertex(trimesh);
}
} }
} }