manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
vcglib/vcg/complex/algorithms/clip.h

1115 lines
28 KiB
C
Raw Normal View History

2011-04-01 18:25:49 +02:00
/****************************************************************************
* VCGLib o o *
* Visual and Computer Graphics Library o o *
* _ O _ *
* Copyright(C) 2004 \/)\/ *
* Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | *
* \ *
* All rights reserved. *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
* for more details. *
* *
****************************************************************************/
/****************************************************************************
History
$Log: not supported by cvs2svn $
****************************************************************************/
#ifndef __VCGLIB_TRI_CLIP
#define __VCGLIB_TRI_CLIP
#include <vector>
#ifdef _WIN32
#ifndef __MINGW32__
#include <hash_map>
#define STDEXT stdext
#else
#include <ext/hash_map>
#define STDEXT __gnu_cxx
#endif
#else
#include <ext/hash_map>
#define STDEXT __gnu_cxx
#endif
namespace vcg
{
namespace tri
{
template <typename MESH_TYPE>
class GenericVertexInterpolator
{
public:
typedef typename MESH_TYPE::VertexType VertexType;
typedef GenericVertexInterpolator<MESH_TYPE> ClassType;
typedef typename VertexType::CoordType CoordType;
typedef typename CoordType::ScalarType ScalarType;
GenericVertexInterpolator(MESH_TYPE &_m) : m(_m) {}
private:
MESH_TYPE &m;
public:
inline void operator () (const VertexType & v0, const VertexType & v1, const VertexType & v2, const ScalarType & a, const ScalarType & b, VertexType & r) const
{
// position
r.P() = v0.P() + (v1.P() - v0.P()) * a + (v2.P() - v0.P()) * b;
// normal
if (tri::HasPerVertexNormal(m))
{
r.N() = v0.cN() + (v1.cN() - v0.cN()) * a + (v2.cN() - v0.cN()) * b;
}
// color
if (tri::HasPerVertexColor(m))
{
vcg::Point4<ScalarType> vc[3];
vc[0].Import(v0.cC());
vc[1].Import(v1.cC());
vc[2].Import(v2.cC());
const vcg::Point4<ScalarType> rc = (vc[0] + (vc[1] - vc[0]) * a + (vc[2] - vc[0]) * b);
r.C()[0] = (typename vcg::Color4b::ScalarType)(rc[0]);
r.C()[1] = (typename vcg::Color4b::ScalarType)(rc[1]);
r.C()[2] = (typename vcg::Color4b::ScalarType)(rc[2]);
r.C()[3] = (typename vcg::Color4b::ScalarType)(rc[3]);
}
// texcoord
if (tri::HasPerVertexTexCoord(m))
{
const short nt = 1; //typename VertexType::TextureType::N();
for (short i=0; i<nt; ++i)
{
r.T().t(i) = v0.cT().t(i) + (v1.cT().t(i) - v0.cT().t(i)) * a + (v2.cT().t(i) - v0.cT().t(i)) * b;
}
}
}
};
template <typename TRIMESHTYPE>
class TriMeshClipper
{
public:
typedef TriMeshClipper<TRIMESHTYPE> ClassType;
typedef TRIMESHTYPE TriMeshType;
typedef typename TriMeshType::FaceType FaceType;
typedef typename FaceType::VertexType VertexType;
typedef typename VertexType::CoordType CoordType;
typedef typename CoordType::ScalarType ScalarType;
/*
static inline void Box(const Box3<ScalarType> & b, VERTEXINTEPOLATOR & vInterp, TriMeshType & m);
Clip mesh "m" against an axis aligned box (in place version);
Notes:
1) faces marked as deleted are skipped;
2) faces completely outside box are marked as deleted;
3) faces completely inside box are left unchanged;
4) faces intersecting box's sides are marked as deleted:
they are replaced with proper tesselation; new vertices and faces
are created, so reallocation could occour; previously saved pointers
could not to be valid anymore, thus they should be updated;
5) vInterp functor must implement a n operator with signature
void operator () (const VERTEX & v0, const VERTEX & v1, const VERTEX & v2, const Scalar & a, const Scalar & b, VERTEX & r);
its semantic is to intepolate vertex attribute across triangle; a typical implementation is;
r.P() = v0.P() + a * (v1.P() - v0.P()) + b * (v2.P() - v0.P()); // interpolate position
r.N() = v0.N() + a * (v1.N() - v0.N()) + b * (v2.N() - v0.N()); // interpolate normal
... // interpolate other vertex attributes
*/
template <class ScalarType>
class VertexClipInfo
{
public:
// typedef VertexClipInfo ClassType;
ScalarType fU;
ScalarType fV;
unsigned int idx;
unsigned int tref;
};
typedef typename std::vector< VertexClipInfo<ScalarType> > VertexClipInfoVec;
class TriangleInfo
{
public:
typedef TriangleInfo ClassType;
unsigned int v[3];
unsigned int idx;
};
typedef std::vector<TriangleInfo> TriangleInfoVec;
class EdgeIsect
{
public:
CoordType p;
unsigned int idx;
};
template <typename VERTEXINTEPOLATOR>
static inline void Box(const Box3<ScalarType> & b, VERTEXINTEPOLATOR & vInterp, TriMeshType & m)
{
std::vector<unsigned int> facesToDelete;
ClassType::Box(b, vInterp, m, facesToDelete);
for (size_t i=0; i<facesToDelete.size(); ++i)
{
m.face[facesToDelete[i]].SetD();
}
}
class EdgeIntersections
{
public:
unsigned int n;
EdgeIsect isects[6];
EdgeIntersections(void)
{
this->n = 0;
}
};
typedef STDEXT::hash_map<unsigned int, EdgeIntersections> UIntHMap;
typedef typename UIntHMap::iterator UIntHMap_i;
typedef typename UIntHMap::value_type UIntHMap_v;
typedef STDEXT::hash_map<unsigned int, UIntHMap> EdgeMap;
typedef typename EdgeMap::iterator EdgeMap_i;
typedef typename EdgeMap::value_type EdgeMap_v;
typedef typename TriMeshType::FaceIterator FaceIterator;
template <typename VERTEXINTEPOLATOR, typename FACEINDEXCONTAINER>
static inline void Box(const Box3<ScalarType> & b, VERTEXINTEPOLATOR & vInterp, TriMeshType & m, FACEINDEXCONTAINER & facesToDelete)
{
if (m.fn <= 0)
{
return;
}
EdgeMap edges;
VertexClipInfoVec vInfos;
TriangleInfoVec tInfos;
CoordType vTriangle[4];
CoordType vClipped[64];
CoordType pvP0[64];
CoordType pvP1[64];
unsigned int numDeletedTris = 0;
unsigned int numTriangles = 0;
unsigned int numVertices = 0;
unsigned int vIdx = (unsigned int)(m.vn);
unsigned int tIdx = (unsigned int)(m.fn);
ScalarType boxOffsets[6];
boxOffsets[0] = b.min[0];
boxOffsets[1] = -b.max[0];
boxOffsets[2] = b.min[1];
boxOffsets[3] = -b.max[1];
boxOffsets[4] = b.min[2];
boxOffsets[5] = -b.max[2];
UIntHMap emptyMap;
EdgeIntersections emptyIsects;
const ScalarType eps = (ScalarType)(1e-6);
for (FaceIterator it=m.face.begin(); it!=m.face.end(); ++it)
{
if ((*it).IsD())
{
continue;
}
unsigned int cc[3];
cc[0] = ClassType::BoxClipCode(boxOffsets, (*it).V(0)->P());
cc[1] = ClassType::BoxClipCode(boxOffsets, (*it).V(1)->P());
cc[2] = ClassType::BoxClipCode(boxOffsets, (*it).V(2)->P());
if ((cc[0] | cc[1] | cc[2]) == 0)
{
continue;
}
const unsigned int refT = (unsigned int)(std::distance(m.face.begin(), it));
if ((cc[0] & cc[1] & cc[2]) != 0)
{
facesToDelete.push_back(refT);
(*it).SetD();
numDeletedTris++;
continue;
}
facesToDelete.push_back(refT);
vTriangle[0] = (*it).V(0)->P();
vTriangle[1] = (*it).V(1)->P();
vTriangle[2] = (*it).V(2)->P();
vTriangle[3] = (*it).V(0)->P();
unsigned int n, n0, n1;
ClipPolygonLine(0, b.min[0], vTriangle, 4, pvP1, n1);
ClipPolygonLine(1, b.max[0], pvP1, n1, pvP0, n0);
ClipPolygonLine(2, b.min[1], pvP0, n0, pvP1, n1);
ClipPolygonLine(3, b.max[1], pvP1, n1, pvP0, n0);
ClipPolygonLine(4, b.min[2], pvP0, n0, pvP1, n1);
ClipPolygonLine(5, b.max[2], pvP1, n1, vClipped, n);
assert(n < 64);
unsigned int firstV, lastV;
if (n > 2)
{
if (vClipped[0] == vClipped[n - 1])
{
n--;
}
const CoordType vU = vTriangle[1] - vTriangle[0];
const CoordType vV = vTriangle[2] - vTriangle[0];
const ScalarType tArea = (vU ^ vV).SquaredNorm();
if (tArea < eps)
{
continue;
}
unsigned int tvidx[3];
tvidx[0] = (*it).V(0) - &(*(m.vert.begin()));
tvidx[1] = (*it).V(1) - &(*(m.vert.begin()));
tvidx[2] = (*it).V(2) - &(*(m.vert.begin()));
numTriangles += n - 2;
// size_t vBegin = vInfos.size();
VertexClipInfo<ScalarType> vnfo;
TriangleInfo tnfo;
unsigned int vmin[3];
unsigned int vmax[3];
if (tvidx[0] < tvidx[1])
{
vmin[0] = tvidx[0];
vmax[0] = tvidx[1];
}
else
{
vmin[0] = tvidx[1];
vmax[0] = tvidx[0];
}
if (tvidx[0] < tvidx[2])
{
vmin[1] = tvidx[0];
vmax[1] = tvidx[2];
}
else
{
vmin[1] = tvidx[2];
vmax[1] = tvidx[0];
}
if (tvidx[1] < tvidx[2])
{
vmin[2] = tvidx[1];
vmax[2] = tvidx[2];
}
else
{
vmin[2] = tvidx[2];
vmax[2] = tvidx[1];
}
for (unsigned int i=0; i<n; ++i)
{
vnfo.tref = refT;
const CoordType vP = vClipped[i] - vTriangle[0];
ScalarType tAreaU = (vU ^ vP).SquaredNorm();
ScalarType tAreaV = (vP ^ vV).SquaredNorm();
vnfo.fU = (ScalarType)(sqrt(tAreaU / tArea));
vnfo.fV = (ScalarType)(sqrt(tAreaV / tArea));
if (vClipped[i] == vTriangle[0])
{
vnfo.idx = tvidx[0];
}
else if (vClipped[i] == vTriangle[1])
{
vnfo.idx = tvidx[1];
}
else if (vClipped[i] == vTriangle[2])
{
vnfo.idx = tvidx[2];
}
else if (vnfo.fV < eps)
{
std::pair<EdgeMap_i, bool> mi = edges.insert(std::make_pair(vmin[1], emptyMap));
std::pair<UIntHMap_i, bool> hi = (*(mi.first)).second.insert(std::make_pair(vmax[1], emptyIsects));
bool found = false;
for (unsigned int s=0; s<(*(hi.first)).second.n; ++s)
{
if (vClipped[i] == (*(hi.first)).second.isects[s].p)
{
found = true;
vnfo.idx = (*(hi.first)).second.isects[s].idx;
break;
}
}
if (!found)
{
vnfo.idx = vIdx++;
numVertices++;
vInfos.push_back(vnfo);
(*(hi.first)).second.isects[(*(hi.first)).second.n].p = vClipped[i];
(*(hi.first)).second.isects[(*(hi.first)).second.n].idx = vnfo.idx;
(*(hi.first)).second.n++;
}
}
else if (vnfo.fU < eps)
{
std::pair<EdgeMap_i, bool> mi = edges.insert(std::make_pair(vmin[0], emptyMap));
std::pair<UIntHMap_i, bool> hi = (*(mi.first)).second.insert(std::make_pair(vmax[0], emptyIsects));
bool found = false;
for (unsigned int s=0; s<(*(hi.first)).second.n; ++s)
{
if (vClipped[i] == (*(hi.first)).second.isects[s].p)
{
found = true;
vnfo.idx = (*(hi.first)).second.isects[s].idx;
break;
}
}
if (!found)
{
vnfo.idx = vIdx++;
numVertices++;
vInfos.push_back(vnfo);
(*(hi.first)).second.isects[(*(hi.first)).second.n].p = vClipped[i];
(*(hi.first)).second.isects[(*(hi.first)).second.n].idx = vnfo.idx;
(*(hi.first)).second.n++;
}
}
else if ((vnfo.fU + vnfo.fV) >= ((ScalarType)(1.0 - 1e-5)))
{
std::pair<EdgeMap_i, bool> mi = edges.insert(std::make_pair(vmin[2], emptyMap));
std::pair<UIntHMap_i, bool> hi = (*(mi.first)).second.insert(std::make_pair(vmax[2], emptyIsects));
bool found = false;
for (unsigned int s=0; s<(*(hi.first)).second.n; ++s)
{
if (vClipped[i] == (*(hi.first)).second.isects[s].p)
{
found = true;
vnfo.idx = (*(hi.first)).second.isects[s].idx;
break;
}
}
if (!found)
{
vnfo.idx = vIdx++;
numVertices++;
vInfos.push_back(vnfo);
(*(hi.first)).second.isects[(*(hi.first)).second.n].p = vClipped[i];
(*(hi.first)).second.isects[(*(hi.first)).second.n].idx = vnfo.idx;
(*(hi.first)).second.n++;
}
}
else
{
vnfo.idx = vIdx++;
numVertices++;
vInfos.push_back(vnfo);
}
if (i == 0)
{
firstV = vnfo.idx;
}
if (i > 1)
{
tnfo.idx = tIdx++;
tnfo.v[0] = firstV;
tnfo.v[1] = lastV;
tnfo.v[2] = vnfo.idx;
tInfos.push_back(tnfo);
}
lastV = vnfo.idx;
}
}
}
if (numTriangles == 0)
{
return;
}
const unsigned int vSize = (unsigned int)(m.vn);
const unsigned int tSize = (unsigned int)(m.fn);
typedef Allocator<TriMeshType> TriMeshAllocatorType;
TriMeshAllocatorType::AddVertices(m, numVertices);
TriMeshAllocatorType::AddFaces(m, numTriangles);
unsigned int j = vSize;
for (size_t i=0; i<vInfos.size(); ++i)
{
if (vInfos[i].idx >= vSize)
{
const unsigned int tref = vInfos[i].tref;
vInterp(*(m.face[tref].V(0)), *(m.face[tref].V(1)), *(m.face[tref].V(2)), vInfos[i].fV, vInfos[i].fU, m.vert[j]);
j++;
}
}
j = tSize;
for (size_t i=0; i<tInfos.size(); ++i)
{
m.face[j].V(0) = &(m.vert[tInfos[i].v[0]]);
m.face[j].V(1) = &(m.vert[tInfos[i].v[1]]);
m.face[j].V(2) = &(m.vert[tInfos[i].v[2]]);
j++;
}
}
/*
static inline void Box(const Box3<ScalarType> & b, VERTEXINTEPOLATOR & vInterp, const TriMeshType & m, TriMeshType & r);
Clip mesh "m" against an axis aligned box and put resulting data in mesh "r" (out of place version);
Notes:
1) input mesh is not modified;
2) faces marked as deleted are skipped;
3) vInterp functor must implement a n operator with signature
void operator () (const VERTEX & v0, const VERTEX & v1, const VERTEX & v2, const Scalar & a, const Scalar & b, VERTEX & r);
its semantic is to intepolate vertex attribute across triangle; a typical implementation is;
r.P() = v0.P() + a * (v1.P() - v0.P()) + b * (v2.P() - v0.P()); // interpolate position
r.N() = v0.N() + a * (v1.N() - v0.N()) + b * (v2.N() - v0.N()); // interpolate normal
... // interpolate other vertex attributes
*/
template <typename VERTEXINTEPOLATOR>
static inline void Box(const Box3<ScalarType> & b, VERTEXINTEPOLATOR & vInterp, const TriMeshType & m, TriMeshType & r)
{
r.Clear();
if (m.fn <= 0)
{
return;
}
class VertexClipInfo
{
public:
typedef VertexClipInfo ClassType;
ScalarType fU;
ScalarType fV;
unsigned int idx;
unsigned int tref;
};
typedef std::vector<VertexClipInfo> VertexClipInfoVec;
class TriangleInfo
{
public:
typedef TriangleInfo ClassType;
unsigned int v[3];
unsigned int idx;
};
typedef std::vector<TriangleInfo> TriangleInfoVec;
class EdgeIsect
{
public:
CoordType p;
unsigned int idx;
};
class EdgeIntersections
{
public:
unsigned int n;
EdgeIsect isects[6];
EdgeIntersections(void)
{
this->n = 0;
}
};
typedef STDEXT::hash_map<unsigned int, EdgeIntersections> UIntHMap;
typedef typename UIntHMap::iterator UIntHMap_i;
typedef typename UIntHMap::value_type UIntHMap_v;
typedef STDEXT::hash_map<unsigned int, UIntHMap> EdgeMap;
typedef typename EdgeMap::iterator EdgeMap_i;
typedef typename EdgeMap::value_type EdgeMap_v;
typedef STDEXT::hash_map<unsigned int, unsigned int> UIHMap;
typedef typename UIHMap::iterator UIHMap_i;
typedef typename TriMeshType::ConstFaceIterator ConstFaceIterator;
UIHMap origVertsMap;
EdgeMap edges;
VertexClipInfoVec vInfos;
TriangleInfoVec tInfos;
CoordType vTriangle[4];
CoordType vClipped[64];
CoordType pvP0[64];
CoordType pvP1[64];
unsigned int numDeletedTris = 0;
unsigned int numTriangles = 0;
unsigned int numVertices = 0;
unsigned int vIdx = 0;
unsigned int tIdx = 0;
ScalarType boxOffsets[6];
boxOffsets[0] = b.min[0];
boxOffsets[1] = -b.max[0];
boxOffsets[2] = b.min[1];
boxOffsets[3] = -b.max[1];
boxOffsets[4] = b.min[2];
boxOffsets[5] = -b.max[2];
UIntHMap emptyMap;
EdgeIntersections emptyIsects;
const ScalarType eps = (ScalarType)(1e-6);
for (ConstFaceIterator it=m.face.begin(); it!=m.face.end(); ++it)
{
if ((*it).IsD())
{
continue;
}
unsigned int cc[3];
cc[0] = ClassType::BoxClipCode(boxOffsets, (*it).V(0)->P());
cc[1] = ClassType::BoxClipCode(boxOffsets, (*it).V(1)->P());
cc[2] = ClassType::BoxClipCode(boxOffsets, (*it).V(2)->P());
if ((cc[0] | cc[1] | cc[2]) == 0)
{
TriangleInfo tnfo;
VertexClipInfo vnfo;
tnfo.idx = tIdx++;
for (int i=0; i<3; ++i)
{
const unsigned int v = (*it).V(i) - &(*(m.vert.begin()));
std::pair<UIHMap_i, bool> hi = origVertsMap.insert(std::make_pair(v, vIdx));
if (hi.second)
{
vnfo.idx = v;
vInfos.push_back(vnfo);
tnfo.v[i] = vIdx++;
}
else
{
tnfo.v[i] = (*(hi.first)).second;
}
}
tInfos.push_back(tnfo);
continue;
}
if ((cc[0] & cc[1] & cc[2]) != 0)
{
numDeletedTris++;
continue;
}
vTriangle[0] = (*it).V(0)->P();
vTriangle[1] = (*it).V(1)->P();
vTriangle[2] = (*it).V(2)->P();
vTriangle[3] = (*it).V(0)->P();
unsigned int n, n0, n1;
ClipPolygonLine(0, b.min[0], vTriangle, 4, pvP1, n1);
ClipPolygonLine(1, b.max[0], pvP1, n1, pvP0, n0);
ClipPolygonLine(2, b.min[1], pvP0, n0, pvP1, n1);
ClipPolygonLine(3, b.max[1], pvP1, n1, pvP0, n0);
ClipPolygonLine(4, b.min[2], pvP0, n0, pvP1, n1);
ClipPolygonLine(5, b.max[2], pvP1, n1, vClipped, n);
assert(n < 64);
unsigned int firstV, lastV;
if (n > 2)
{
if (vClipped[0] == vClipped[n - 1])
{
n--;
}
const CoordType vU = vTriangle[1] - vTriangle[0];
const CoordType vV = vTriangle[2] - vTriangle[0];
const ScalarType tArea = (vU ^ vV).SquaredNorm();
if (tArea < eps)
{
continue;
}
unsigned int tvidx[3];
tvidx[0] = (*it).V(0) - &(*(m.vert.begin()));
tvidx[1] = (*it).V(1) - &(*(m.vert.begin()));
tvidx[2] = (*it).V(2) - &(*(m.vert.begin()));
unsigned int refT = (unsigned int)(std::distance(m.face.begin(), it));
numTriangles += n - 2;
size_t vBegin = vInfos.size();
VertexClipInfo vnfo;
TriangleInfo tnfo;
unsigned int vmin[3];
unsigned int vmax[3];
if (tvidx[0] < tvidx[1])
{
vmin[0] = tvidx[0];
vmax[0] = tvidx[1];
}
else
{
vmin[0] = tvidx[1];
vmax[0] = tvidx[0];
}
if (tvidx[0] < tvidx[2])
{
vmin[1] = tvidx[0];
vmax[1] = tvidx[2];
}
else
{
vmin[1] = tvidx[2];
vmax[1] = tvidx[0];
}
if (tvidx[1] < tvidx[2])
{
vmin[2] = tvidx[1];
vmax[2] = tvidx[2];
}
else
{
vmin[2] = tvidx[2];
vmax[2] = tvidx[1];
}
for (unsigned int i=0; i<n; ++i)
{
vnfo.tref = refT;
const CoordType vP = vClipped[i] - vTriangle[0];
ScalarType tAreaU = (vU ^ vP).SquaredNorm();
ScalarType tAreaV = (vP ^ vV).SquaredNorm();
vnfo.fU = (ScalarType)(sqrt(tAreaU / tArea));
vnfo.fV = (ScalarType)(sqrt(tAreaV / tArea));
unsigned int currVIdx;
if (vClipped[i] == vTriangle[0])
{
std::pair<UIHMap_i, bool> hi = origVertsMap.insert(std::make_pair(tvidx[0], vIdx));
if (hi.second)
{
vnfo.idx = tvidx[0];
vInfos.push_back(vnfo);
currVIdx = vIdx++;
}
else
{
currVIdx = (*(hi.first)).second;
}
}
else if (vClipped[i] == vTriangle[1])
{
std::pair<UIHMap_i, bool> hi = origVertsMap.insert(std::make_pair(tvidx[1], vIdx));
if (hi.second)
{
vnfo.idx = tvidx[1];
vInfos.push_back(vnfo);
currVIdx = vIdx++;
}
else
{
currVIdx = (*(hi.first)).second;
}
}
else if (vClipped[i] == vTriangle[2])
{
std::pair<UIHMap_i, bool> hi = origVertsMap.insert(std::make_pair(tvidx[2], vIdx));
if (hi.second)
{
vnfo.idx = tvidx[2];
vInfos.push_back(vnfo);
currVIdx = vIdx++;
}
else
{
currVIdx = (*(hi.first)).second;
}
}
else if (vnfo.fV < eps)
{
std::pair<EdgeMap_i, bool> mi = edges.insert(std::make_pair(vmin[1], emptyMap));
std::pair<UIntHMap_i, bool> hi = (*(mi.first)).second.insert(std::make_pair(vmax[1], emptyIsects));
bool found = false;
for (unsigned int s=0; s<(*(hi.first)).second.n; ++s)
{
if (vClipped[i] == (*(hi.first)).second.isects[s].p)
{
found = true;
vnfo.idx = (unsigned int)(-1);
currVIdx = (*(hi.first)).second.isects[s].idx;
break;
}
}
if (!found)
{
(*(hi.first)).second.isects[(*(hi.first)).second.n].p = vClipped[i];
(*(hi.first)).second.isects[(*(hi.first)).second.n].idx = vIdx;
(*(hi.first)).second.n++;
vnfo.idx = (unsigned int)(-1);
numVertices++;
vInfos.push_back(vnfo);
currVIdx = vIdx++;
}
}
else if (vnfo.fU < eps)
{
std::pair<EdgeMap_i, bool> mi = edges.insert(std::make_pair(vmin[0], emptyMap));
std::pair<UIntHMap_i, bool> hi = (*(mi.first)).second.insert(std::make_pair(vmax[0], emptyIsects));
bool found = false;
for (unsigned int s=0; s<(*(hi.first)).second.n; ++s)
{
if (vClipped[i] == (*(hi.first)).second.isects[s].p)
{
found = true;
vnfo.idx = (unsigned int)(-1);
currVIdx = (*(hi.first)).second.isects[s].idx;
break;
}
}
if (!found)
{
(*(hi.first)).second.isects[(*(hi.first)).second.n].p = vClipped[i];
(*(hi.first)).second.isects[(*(hi.first)).second.n].idx = vIdx;
(*(hi.first)).second.n++;
vnfo.idx = (unsigned int)(-1);
numVertices++;
vInfos.push_back(vnfo);
currVIdx = vIdx++;
}
}
else if ((vnfo.fU + vnfo.fV) >= ((ScalarType)(1.0 - 1e-5)))
{
std::pair<EdgeMap_i, bool> mi = edges.insert(std::make_pair(vmin[2], emptyMap));
std::pair<UIntHMap_i, bool> hi = (*(mi.first)).second.insert(std::make_pair(vmax[2], emptyIsects));
bool found = false;
for (unsigned int s=0; s<(*(hi.first)).second.n; ++s)
{
if (vClipped[i] == (*(hi.first)).second.isects[s].p)
{
found = true;
vnfo.idx = (unsigned int)(-1);
currVIdx = (*(hi.first)).second.isects[s].idx;
break;
}
}
if (!found)
{
(*(hi.first)).second.isects[(*(hi.first)).second.n].p = vClipped[i];
(*(hi.first)).second.isects[(*(hi.first)).second.n].idx = vIdx;
(*(hi.first)).second.n++;
vnfo.idx = (unsigned int)(-1);
numVertices++;
vInfos.push_back(vnfo);
currVIdx = vIdx++;
}
}
else
{
vnfo.idx = (unsigned int)(-1);
numVertices++;
vInfos.push_back(vnfo);
currVIdx = vIdx++;
}
if (i == 0)
{
firstV = currVIdx;
}
if (i > 1)
{
tnfo.idx = tIdx++;
tnfo.v[0] = firstV;
tnfo.v[1] = lastV;
tnfo.v[2] = currVIdx;
tInfos.push_back(tnfo);
}
lastV = currVIdx;
}
}
}
if (tInfos.empty())
{
return;
}
const unsigned int vSize = (unsigned int)(m.vn);
const unsigned int tSize = (unsigned int)(m.fn);
typedef Allocator<TriMeshType> TriMeshAllocatorType;
TriMeshAllocatorType::AddVertices(r, (int)(vInfos.size()));
TriMeshAllocatorType::AddFaces(r, (int)(tInfos.size()));
for (size_t i=0; i<vInfos.size(); ++i)
{
if (vInfos[i].idx != ((unsigned int)(-1)))
{
r.vert[i] = m.vert[vInfos[i].idx];
}
else
{
const unsigned int tref = vInfos[i].tref;
vInterp(*(m.face[tref].V(0)), *(m.face[tref].V(1)), *(m.face[tref].V(2)), vInfos[i].fV, vInfos[i].fU, r.vert[i]);
}
}
for (size_t i=0; i<tInfos.size(); ++i)
{
r.face[i].V(0) = &(r.vert[tInfos[i].v[0]]);
r.face[i].V(1) = &(r.vert[tInfos[i].v[1]]);
r.face[i].V(2) = &(r.vert[tInfos[i].v[2]]);
}
}
protected:
static inline unsigned int BoxClipCode(const ScalarType * offsets, const CoordType & p)
{
//const ScalarType eps = (ScalarType)(-1e-5);
const ScalarType eps = (ScalarType)(0);
unsigned int code = 0;
code |= ((( p[0] - offsets[0]) < eps) ? (1 << 0) : (0));
code |= (((-p[0] - offsets[1]) < eps) ? (1 << 1) : (0));
code |= ((( p[1] - offsets[2]) < eps) ? (1 << 2) : (0));
code |= (((-p[1] - offsets[3]) < eps) ? (1 << 3) : (0));
code |= ((( p[2] - offsets[4]) < eps) ? (1 << 4) : (0));
code |= (((-p[2] - offsets[5]) < eps) ? (1 << 5) : (0));
return (code);
}
static inline unsigned int InRegion(int mode, const ScalarType & value, const CoordType & p_in)
{
//const ScalarType eps = (ScalarType)(-1e-5);
const ScalarType eps = (ScalarType)(0);
unsigned int flag = 0;
switch(mode)
{
case 0:
flag = p_in[0] + eps < value;
break;
case 1:
flag = p_in[0] > value + eps;
break;
case 2:
flag = p_in[1] + eps < value;
break;
case 3:
flag = p_in[1] > value + eps;
break;
case 4:
flag = p_in[2] + eps < value;
break;
case 5:
flag = p_in[2] > value + eps;
break;
default:
break;
}
return (flag);
}
static inline void CrossPoint(int mode, const ScalarType & value, const CoordType & SP, const CoordType & PP, CoordType & p_out)
{
switch(mode)
{
case 0:
case 1:
p_out[0] = value;
if ((PP[0] - SP[0]) == ((ScalarType)(0)))
{
p_out[1] = PP[1];
p_out[2] = PP[2];
}
else
{
p_out[1] = SP[1] + (value - SP[0]) * (PP[1] - SP[1]) / (PP[0] - SP[0]);
p_out[2] = SP[2] + (value - SP[0]) * (PP[2] - SP[2]) / (PP[0] - SP[0]);
}
break;
case 2:
case 3:
p_out[1] = value;
if ((PP[1] - SP[1]) == ((ScalarType)(0)))
{
p_out[0] = PP[0];
p_out[2] = PP[2];
}
else
{
p_out[0] = SP[0] + (value - SP[1]) * (PP[0] - SP[0]) / (PP[1] - SP[1]);
p_out[2] = SP[2] + (value - SP[1]) * (PP[2] - SP[2]) / (PP[1] - SP[1]);
}
break;
case 4:
case 5:
p_out[2] = value;
if ((PP[2] - SP[2]) == ((ScalarType)(0)))
{
p_out[0] = PP[0];
p_out[1] = PP[1];
}
else
{
p_out[0] = SP[0] + (value - SP[2]) * (PP[0] - SP[0]) / (PP[2] - SP[2]);
p_out[1] = SP[1] + (value - SP[2]) * (PP[1] - SP[1]) / (PP[2] - SP[2]);
}
break;
default:
break;
}
}
static inline void ClipPolygonLine(int mode, const ScalarType & value, CoordType * P_in, unsigned int n_in, CoordType * P_out, unsigned int & n_out)
{
unsigned int ps;
CoordType * SP;
CoordType * PP;
n_out = 0;
SP = &P_in[n_in-1];
if (ClassType::InRegion(mode, value, *SP))
{
ps = 0;
}
else
{
ps = 2;
}
for(unsigned int i=0; i<n_in; ++i)
{
PP = &(P_in[i]);
ps = (ps >> 1) | ((ClassType::InRegion(mode, value, *PP)) ? (0) : (2));
switch(ps)
{
case 0:
break;
case 1:
ClassType::CrossPoint(mode, value, *SP, *PP, P_out[n_out]);
n_out++;
break;
case 2:
ClassType::CrossPoint(mode, value, *SP, *PP, P_out[n_out]);
n_out++;
P_out[n_out] = *PP;
n_out++;
break;
case 3:
P_out[n_out] = *PP;
n_out++;
break;
default:
break;
}
SP = PP;
}
}
};
} // end namespace tri
} // end namespace vcg
#endif // __VCGLIB_TRI_CLIP