aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-11-13 18:59:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/nel/src/misc/polygon.cpp

2269 lines
57 KiB
C++
Raw Normal View History

Fixed: #1033 WebIG now works on linux too
2010-09-24 15:07:17 +00:00
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdmisc.h"
#include "nel/misc/polygon.h"
#include "nel/misc/plane.h"
#include "nel/misc/triangle.h"
using namespace std;
using namespace NLMISC;
namespace NLMISC
{
//==================================//
// CPolygon implementation //
//==================================//
// ***************************************************************************
CPolygon::CPolygon(const CVector &a, const CVector &b, const CVector &c)
{
Vertices.reserve(3);
Vertices.push_back(a);
Vertices.push_back(b);
Vertices.push_back(c);
}
// ***************************************************************************
void CPolygon::toTriFan(std::vector<NLMISC::CTriangle> &dest) const
{
sint count = (sint) Vertices.size() - 2;
for(sint k = 0; k < count; ++k)
{
dest.push_back(CTriangle(Vertices[0], Vertices[k + 1], Vertices[k + 2]));
}
}
// ***************************************************************************
float CPolygon::computeArea() const
{
float area = 0.f;
sint numVerts = (sint) Vertices.size();
for(sint k = 0; k < numVerts - 2; ++k)
{
CVector v0 = Vertices[k + 1] - Vertices[0];
CVector v1 = Vertices[k + 2] - Vertices[0];
area += (v0 ^ v1).norm();
}
return 0.5f * fabsf(area);
}
// ***************************************************************************
void CPolygon::clip(const CPlane *planes, uint nPlanes)
{
if(nPlanes==0 || getNumVertices()==0)
return;
// The final polygon has at maximum currentVertices+number of clipping planes.
// For performance, the vectors are static, so reallocation rarely occurs.
static vector<CVector> tab0, tab1;
tab0.resize(getNumVertices()+nPlanes);
tab1.resize(getNumVertices()+nPlanes);
// Init tab0 with Vertices.
copy(Vertices.begin(), Vertices.end(), tab0.begin());
CVector *in=&(*tab0.begin()), *out= &(*tab1.begin());
sint nin= getNumVertices(), nout;
for(sint i=0;i<(sint)nPlanes;i++)
{
nout= planes[i].clipPolygonBack(in, out, nin);
swap(in, out);
nin= nout;
if(nin==0)
break;
}
// Final result in "in".
Vertices.resize(nin);
if(nin>0)
{
memcpy(&(*Vertices.begin()), in, nin*sizeof(CVector));
}
}
// ***************************************************************************
void CPolygon::clip(const std::vector<CPlane> &planes)
{
if(planes.size()==0)
return;
clip(&(*planes.begin()), (uint)planes.size());
}
// ***************************************************************************
void CPolygon::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
f.serialVersion(0);
f.serialCont(Vertices);
}
// ***************************************************************************
void CPolygon::getBestTriplet(uint &index0,uint &index1,uint &index2)
{
nlassert(Vertices.size() >= 3);
uint i, j, k;
float bestArea = 0.f;
const uint numVerts = (uint)Vertices.size();
for (i = 0; i < numVerts; ++i)
{
for (j = 0; j < numVerts; ++j)
{
if (i != j)
{
for (k = 0; k < numVerts; ++k)
{
if (k != i && k != j)
{
CVector v0 = Vertices[j] - Vertices[i];
CVector v1 = Vertices[k] - Vertices[i];
float area = (v0 ^ v1).norm();
if (area > bestArea)
{
bestArea = area;
index0 = i;
index1 = j;
index2 = k;
}
}
}
}
}
}
}
// ***************************************************************************
void CPolygon::buildBasis(CMatrix &dest)
{
nlassert(Vertices.size() > 3);
uint i1, i2, i3;
getBestTriplet(i1, i2, i3);
CVector v1 = (Vertices[i2] - Vertices[i1]).normed();
CVector v2 = (Vertices[i3] - Vertices[i1]).normed();
CVector K = v2 ^ v1;
CVector I = v1 - (v1 * K) * v1;
CVector J = K ^ I;
dest.setRot(I, J, K);
dest.setPos(Vertices[i1]);
}
// ***************************************************************************
class CConcavePolygonsVertexDesc
{
public:
CConcavePolygonsVertexDesc (float length, uint index)
{
Length = length;
Index = index;
}
// Length > 0
float Length;
// First vertex index
uint Index;
};
typedef std::map<float, CConcavePolygonsVertexDesc> TCConcavePolygonsVertexMap;
// ***************************************************************************
bool CPolygon::toConvexPolygonsEdgeIntersect (const CVector2f& a0, const CVector2f& a1, const CVector2f& b0, const CVector2f& b1)
{
// both vertical?
if( a0.x-a1.x==0 && b0.x-b1.x==0 )
return false;
// compute intersection of both lines
CVector2f intersection;
// first edge vertical?
if(a0.x - a1.x==0)
{
float Ab = (b0.y - b1.y) / (b0.x - b1.x);
// Intersection
intersection.x = a0.x;
intersection.y = b0.y + (a0.x-b0.x) * Ab;
}
// second edge vertical?
else if(b0.x - b1.x==0)
{
float Aa = (a0.y - a1.y) / (a0.x - a1.x);
// Intersection
intersection.x = b0.x;
intersection.y = a0.y + (b0.x-a0.x) * Aa;
}
// standard case
else
{
float Aa = (a0.y - a1.y) / (a0.x - a1.x);
float Ba = a0.y - a0.x * Aa;
float Ab = (b0.y - b1.y) / (b0.x - b1.x);
float Bb = b0.y - b0.x * Ab;
// colinear?
if(Aa==Ab)
return false;
// Intersection
intersection.x = (Bb - Ba) / (Aa - Ab);
intersection.y = Aa * intersection.x + Ba;
}
// In it ?
return ( ( (a0-intersection)*(a1-intersection) < 0 ) && ( (b0-intersection)*(b1-intersection) < 0 ) );
}
// ***************************************************************************
class CBSPNode2v
{
public:
CBSPNode2v ()
{
Back = NULL;
Front = NULL;
}
CBSPNode2v ( const CPlane &plane, CVector p0, CVector p1, uint v0, uint v1 ) : Plane (plane), P0 (p0), P1 (p1)
{
Back = NULL;
Front = NULL;
Parent = NULL;
V0 = v0;
V1 = v1;
}
~CBSPNode2v ()
{
if (Front)
delete Front;
if (Back)
delete Back;
}
void insert (CBSPNode2v *node)
{
// Front ?
bool p0Front = (Plane * node->P0) > 0;
bool p1Front = (Plane * node->P1) > 0;
if (p0Front && p1Front)
{
// Front child ?
if (Front)
Front->insert (node);
else
{
// Link left
Front = node;
node->Parent = this;
}
}
else if ((!p0Front) && (!p1Front))
{
// Back child ?
if (Back)
Back->insert (node);
else
{
// Link left
Back = node;
node->Parent = this;
}
}
else
{
// Split vertex
CVector newVertex = Plane.intersect (node->P0, node->P1);
// New node
CBSPNode2v *newNode = new CBSPNode2v (node->Plane, node->P0, newVertex, node->V0, node->V1);
// Old node
node->P0 = newVertex;
// Insert child
CBSPNode2v **p0Parent;
CBSPNode2v **p1Parent;
// Get insertion pointer
if (p0Front)
{
p0Parent = &Front;
p1Parent = &Back;
}
else
{
p0Parent = &Back;
p1Parent = &Front;
}
// Insert children
if (*p0Parent)
{
(*p0Parent)->insert (newNode);
}
else
{
*p0Parent = newNode;
newNode->Parent = this;
}
// Insert children
if (*p1Parent)
{
(*p1Parent)->insert (node);
}
else
{
*p1Parent = node;
node->Parent = this;
}
}
}
bool intersect (const CVector &p0, const CVector &p1, uint v0, uint v1) const
{
// Front ?
bool p0Front = (Plane * p0) > 0;
bool p1Front = (Plane * p1) > 0;
if (p0Front != p1Front)
if ( (v0 != V0) && (v0 != V1) && (v1 != V0) && (v1 != V1) )
if (CPolygon::toConvexPolygonsEdgeIntersect ((CVector2f) P0, (CVector2f) P1, (CVector2f) p0, (CVector2f) p1))
return true;
if (p0Front || p1Front)
{
if (Front)
if (Front->intersect (p0, p1, v0, v1))
return true;
}
if ((!p0Front) || (!p1Front))
{
if (Back)
if (Back->intersect (p0, p1, v0, v1))
return true;
}
return false;
}
CBSPNode2v *Back, *Front, *Parent;
CPlane Plane;
CVector P0;
CVector P1;
uint V0;
uint V1;
};
// ***************************************************************************
bool CPolygon::toConvexPolygonsLeft (const std::vector<CVector> &vertex, uint a, uint b, uint c)
{
return ( (vertex[b].x - vertex[a].x) * (vertex[c].y - vertex[a].y) - (vertex[c].x - vertex[a].x) * (vertex[b].y - vertex[a].y) ) < 0;
}
// ***************************************************************************
bool CPolygon::toConvexPolygonsLeftOn (const std::vector<CVector> &vertex, uint a, uint b, uint c)
{
return ( (vertex[b].x - vertex[a].x) * (vertex[c].y - vertex[a].y) - (vertex[c].x - vertex[a].x) * (vertex[b].y - vertex[a].y) ) <= 0;
}
// ***************************************************************************
bool CPolygon::toConvexPolygonsInCone (const std::vector<CVector> &vertex, uint a, uint b)
{
// Prev and next
uint a0 = a+1;
if (a0==vertex.size())
a0=0;
uint a1;
if (a==0)
a1= (uint)vertex.size()-1;
else
a1= a-1;
if (toConvexPolygonsLeftOn (vertex, a, a1, a0) )
{
return toConvexPolygonsLeft ( vertex, a, b, a0) && toConvexPolygonsLeft ( vertex, b, a, a1);
}
else
{
return !( toConvexPolygonsLeft ( vertex, a, b, a1) && toConvexPolygonsLeft ( vertex, b, a, a0) );
}
}
// ***************************************************************************
bool CPolygon::toConvexPolygonsDiagonal (const std::vector<CVector> &vertex, const CBSPNode2v &bsp, uint a, uint b)
{
// Check it is a border
if ( ( (b - a) == 1) || ( (a - b) == 1) || ( (a==0) && (b ==(vertex.size()-1))) || ( (b==0) && (a ==(vertex.size()-1))) )
return true;
// Check visibility
if (toConvexPolygonsInCone (vertex, a, b) && toConvexPolygonsInCone (vertex, b, a))
{
// Intersection ?
return !bsp.intersect (vertex[a], vertex[b], a, b);
}
return false;
}
// ***************************************************************************
void CPolygon::toConvexPolygonsLocalAndBSP (std::vector<CVector> &localVertices, CBSPNode2v &root, const CMatrix &basis) const
{
// Invert matrix
CMatrix invert = basis;
invert.invert ();
// Insert vertices in an ordered table
uint vertexCount = (uint)Vertices.size();
TCConcavePolygonsVertexMap vertexMap;
localVertices.resize (vertexCount);
uint i, j;
// Transform the vertex
for (i=0; i<vertexCount; i++)
{
CVector local = invert*Vertices[i];
localVertices[i] = CVector (local.x, local.y, 0);
}
// Plane direction
i=0;
j=(uint)Vertices.size()-1;
CVector normal = localVertices[i] - localVertices[j];
normal = normal ^ CVector::K;
CPlane clipPlane;
clipPlane.make(normal, localVertices[i]);
// Build the BSP root
root = CBSPNode2v (clipPlane, localVertices[i], localVertices[j], i, j);
// Insert all others edges
j=i++;
for (; i<Vertices.size(); i++)
{
// Plane direction
normal = localVertices[i] - localVertices[j];
normal = normal ^ CVector::K;
clipPlane.make(normal, localVertices[i]);
// Build the BSP root
root.insert ( new CBSPNode2v (clipPlane, localVertices[i], localVertices[j], i, j) );
j=i;
}
}
// ***************************************************************************
bool CPolygon::toConvexPolygons (std::list<CPolygon>& outputPolygons, const CMatrix& basis) const
{
// Some vertices ?
if (Vertices.size()>2)
{
// Local vertices
std::vector<CVector> localVertices;
// Build the BSP root
CBSPNode2v root;
// Build the local array and the BSP
toConvexPolygonsLocalAndBSP (localVertices, root, basis);
// Build a vertex list
std::list<uint> vertexList;
uint i;
for (i=0; i<Vertices.size(); i++)
vertexList.push_back (i);
// Clip ears while there is some polygons
std::list<uint>::iterator current=vertexList.begin();
std::list<uint>::iterator begin=vertexList.begin();
do
{
again:;
// Search for a diagonal
bool found = false;
// Get next vertex
std::list<uint>::iterator first = current;
std::list<uint>::iterator lastPreviousPrevious=current;
std::list<uint>::iterator lastPrevious=current;
lastPrevious++;
if (lastPrevious==vertexList.end())
lastPrevious = vertexList.begin();
std::list<uint>::iterator currentNext = lastPrevious;
std::list<uint>::iterator last = lastPrevious;
last++;
if (last==vertexList.end())
last = vertexList.begin();
while (last != current)
{
// Is a diagonal ?
if (
(toConvexPolygonsDiagonal (localVertices, root, *lastPreviousPrevious, *last)) &&
(toConvexPolygonsDiagonal (localVertices, root, *currentNext, *last)) &&
(toConvexPolygonsDiagonal (localVertices, root, *last, *current))
)
{
// Find one
found = true;
}
else
{
// Come back
last = lastPrevious;
lastPrevious = lastPreviousPrevious;
break;
}
// Next vertex
lastPreviousPrevious = lastPrevious;
lastPrevious = last++;
if (last==vertexList.end())
last = vertexList.begin();
}
// Last polygon ?
if (last==current)
{
// Add a polygon
outputPolygons.push_back (CPolygon());
CPolygon &back = outputPolygons.back ();
back.Vertices.reserve (vertexList.size());
// Add each vertex in the new polygon
current=vertexList.begin();
while (current!=vertexList.end())
{
back.Vertices.push_back (Vertices[*current]);
current++;
}
// Exit
return true;
}
else
{
std::list<uint>::iterator firstNext = current;
std::list<uint>::iterator firstNextNext = currentNext;
if (first != vertexList.begin())
first--;
else
{
first = vertexList.end();
first--;
}
while (current != first)
{
// Is a diagonal ?
if (
(toConvexPolygonsDiagonal (localVertices, root, *firstNextNext, *first)) &&
(toConvexPolygonsDiagonal (localVertices, root, *lastPrevious, *first)) &&
(toConvexPolygonsDiagonal (localVertices, root, *last, *first))
)
{
// Find one
found = true;
}
else
{
// Come back
first = firstNext;
break;
}
// Next vertex
firstNextNext = firstNext;
firstNext = first;
if (first==vertexList.begin())
{
first = vertexList.end();
first--;
}
else
first--;
}
}
// Found ?
if (found)
{
// Count vertex
outputPolygons.push_back (CPolygon());
CPolygon &back = outputPolygons.back ();
// Vertex count
uint vertexCount = 1;
current = first;
while (current != last)
{
vertexCount++;
current++;
if (current == vertexList.end())
current = vertexList.begin();
}
// Alloc vertices
back.Vertices.reserve (vertexCount);
// Copy and remove vertices
back.Vertices.push_back (Vertices[*first]);
first++;
if (first == vertexList.end())
first = vertexList.begin();
while (first != last)
{
back.Vertices.push_back (Vertices[*first]);
// Remove from list
first = vertexList.erase (first);
if (first == vertexList.end())
first = vertexList.begin();
nlassert (first != vertexList.end());
}
back.Vertices.push_back (Vertices[*first]);
current = begin = last;
goto again;
}
// Next current
current++;
if (current == vertexList.end())
current = vertexList.begin ();
}
while (current != begin);
}
return false;
}
// ***************************************************************************
bool CPolygon::chain (const std::vector<CPolygon> &other, const CMatrix& basis)
{
// Local vertices
std::vector<CVector> localVertices;
// Build the BSP root
CBSPNode2v root;
// Build the local array and the BSP
toConvexPolygonsLocalAndBSP (localVertices, root, basis);
// Local vertices
std::vector<std::vector<CVector> > localVerticesOther (other.size());
// Build the BSP root
std::vector<CBSPNode2v> rootOther (other.size());
// Build a copy of the polygons
std::vector<CPolygon> copy = other;
// Main copy
CPolygon mainCopy = *this;
// For each other polygons
uint o;
for (o=0; o<other.size(); o++)
{
// Build the local array and the BSP
other[o].toConvexPolygonsLocalAndBSP (localVerticesOther[o], rootOther[o], basis);
}
// Look for a couple..
uint thisCount = (uint)Vertices.size();
uint i, j;
for (o=0; o<other.size(); o++)
{
uint otherCount = (uint)other[o].Vertices.size();
// Try to link in the main polygon
for (i=0; i<thisCount; i++)
{
for (j=0; j<otherCount; j++)
{
// Test this segement
if (!root.intersect (localVertices[i], localVerticesOther[o][j], i, 0xffffffff))
{
// Test each other polygons
uint otherO;
for (otherO=0; otherO<other.size(); otherO++)
{
// Intersect ?
if (rootOther[otherO].intersect (localVertices[i], localVerticesOther[o][j], 0xffffffff, (otherO == o)?j:0xffffffff))
break;
}
// Continue ?
if (otherO==other.size())
{
// Insert new vertices
mainCopy.Vertices.insert (mainCopy.Vertices.begin()+i, 2+otherCount, CVector());
// Copy the first vertex
mainCopy.Vertices[i] = mainCopy.Vertices[i+otherCount+2];
// Copy the new vertices
uint k;
for (k=0; k<otherCount; k++)
{
uint index = j+k;
if (index>=otherCount)
index -= otherCount;
mainCopy.Vertices[i+k+1] = copy[o].Vertices[index];
}
// Copy the last one
mainCopy.Vertices[i+otherCount+1] = copy[o].Vertices[j];
break;
}
}
}
if (j!=otherCount)
break;
}
// Not found ?
if (i==thisCount)
{
// Try to link in the sub polygons
uint otherToCheck;
for (otherToCheck=o+1; otherToCheck<other.size(); otherToCheck++)
{
uint otherToCheckCount = (uint)other[otherToCheck].Vertices.size();
for (i=0; i<otherToCheckCount; i++)
{
for (j=0; j<otherCount; j++)
{
// Test this segement
if (!rootOther[otherToCheck].intersect (localVerticesOther[otherToCheck][i], localVerticesOther[o][j], i, 0xffffffff))
{
// Test each other polygons
uint otherO;
for (otherO=0; otherO<other.size(); otherO++)
{
// Intersect ?
if (rootOther[otherO].intersect (localVerticesOther[otherToCheck][i], localVerticesOther[o][j], (otherToCheck == otherO)?i:0xffffffff, (otherO == o)?j:0xffffffff))
break;
}
// Continue ?
if (otherO==other.size())
{
// Insert new vertices
copy[otherToCheck].Vertices.insert (copy[otherToCheck].Vertices.begin()+i, 2+otherCount, CVector());
// Copy the first vertex
copy[otherToCheck].Vertices[i] = copy[otherToCheck].Vertices[i+otherCount+2];
// Copy the new vertices
uint k;
for (k=0; k<otherCount; k++)
{
uint index = j+k;
if (index>=otherCount)
index -= otherCount;
copy[otherToCheck].Vertices[i+k+1] = copy[otherO].Vertices[index];
}
// Copy the last one
copy[otherToCheck].Vertices[i+otherCount+1] = copy[otherO].Vertices[j];
break;
}
}
}
if (j!=otherCount)
break;
}
if (i!=otherToCheckCount)
break;
}
if (otherToCheck==other.size())
{
// Not ok
return false;
}
}
}
// Ok
*this = mainCopy;
return true;
}
// ***************************************************************************
//====================================//
// CPolygon2d implementation //
//====================================//
// ***************************************************************************
CPolygon2D::CPolygon2D(const CPolygon &src, const CMatrix &projMat)
{
fromPolygon(src, projMat);
}
// ***************************************************************************
void CPolygon2D::fromPolygon(const CPolygon &src, const CMatrix &projMat /*=CMatrix::Identity*/)
{
uint size = (uint)src.Vertices.size();
Vertices.resize(size);
for (uint k = 0; k < size; ++k)
{
CVector proj = projMat * src.Vertices[k];
Vertices[k].set(proj.x, proj.y);
}
}
// ***************************************************************************
bool CPolygon2D::isConvex()
{
bool Front = true, Back = false;
// we apply a dummy algo for now : check whether every vertex is in the same side
// of every plane defined by a segment of this poly
uint numVerts = (uint)Vertices.size();
if (numVerts < 3) return true;
CVector segStart, segEnd;
CPlane clipPlane;
for (TVec2fVect::const_iterator it = Vertices.begin(); it != Vertices.end(); ++it)
{
segStart.set(it->x, it->y, 0); // segment start
segEnd.set((it + 1)->x, (it + 1)->y, 0); // segment end
float n = (segStart - segEnd).norm(); // segment norm
if (n != 0)
{
clipPlane.make(segStart, segEnd, (n > 10 ? n : 10) * CVector::K + segStart); // make a plane, with this segment and the poly normal
// check each other vertices against this plane
for (TVec2fVect::const_iterator it2 = Vertices.begin(); it2 != Vertices.end(); ++it2)
{
if (it2 != it && it2 != (it + 1)) // the vertices must not be part of the test plane (because of imprecision)
{
float dist = clipPlane * CVector(it2->x, it2-> y, 0);
if (dist != 0) // midlle pos
{
if (dist > 0) Front = true; else Back = true;
if (Front && Back) return false; // there are both front end back vertices -> failure
}
}
}
}
}
return true;
}
// ***************************************************************************
void CPolygon2D::buildConvexHull(CPolygon2D &dest) const
{
nlassert(&dest != this);
if (this->Vertices.size() == 3) // with 3 points it is always convex
{
dest = *this;
return;
}
uint k, l;
uint numVerts = (uint)Vertices.size();
CVector2f p, curr, prev;
uint pIndex, p1Index, p2Index, pCurr, pPrev;
// this is not optimized, but not used in realtime.. =)
nlassert(numVerts >= 3);
dest.Vertices.clear();
typedef std::set<uint> TIndexSet;
TIndexSet leftIndex;
for (k = 0; k < Vertices.size(); ++k)
{
leftIndex.insert(k);
}
// 1) find the highest point p of the set. We are sure it belongs to the hull
pIndex = 0;
p = Vertices[0];
for (k = 1; k < numVerts; ++k)
{
if (Vertices[k].y < p.y)
{
pIndex = k;
p = Vertices[k];
}
}
leftIndex.erase(pIndex);
float bestCP = 1.1f;
p1Index = p2Index = pIndex;
for (k = 0; k < numVerts; ++k)
{
if (k != pIndex)
{
for (l = 0; l < numVerts; ++l)
{
if (l != pIndex && l != k)
{
CVector2f seg1 = (Vertices[l] - p).normed();
CVector2f seg2 = (Vertices[k] - p).normed();
//CVector cp = CVector(seg1.x, seg1.y, 0) ^ CVector(seg2.x, seg2.y, 0);
//float n = fabsf(cp.z);
float n = seg1 * seg2;
if (n < bestCP)
{
p1Index = l;
p2Index = k;
bestCP = n;
}
}
}
}
}
leftIndex.erase(p2Index);
// start from the given triplet, and complete the poly until we reach the first point
pCurr = p2Index;
pPrev = pIndex;
curr = Vertices[pCurr];
prev = Vertices[pPrev];
// create the first triplet vertices
dest.Vertices.push_back(Vertices[p1Index]);
dest.Vertices.push_back(prev);
dest.Vertices.push_back(curr);
uint step = 0;
for(;;)
{
bestCP = 1.1f;
CVector2f seg2 = (prev - curr).normed();
TIndexSet::iterator bestIt = leftIndex.end();
for (TIndexSet::iterator it = leftIndex.begin(); it != leftIndex.end(); ++it)
{
if (step == 0 && *it == p1Index) continue;
CVector2f seg1 = (Vertices[*it] - curr).normed();
float n = seg1 * seg2;
if (n < bestCP)
{
bestCP = n;
bestIt = it;
}
}
nlassert(bestIt != leftIndex.end());
if (*bestIt == p1Index)
{
return; // if we reach the start point we have finished
}
prev = curr;
curr = Vertices[*bestIt];
pPrev = pCurr;
pCurr = *bestIt;
// add new point to the destination
dest.Vertices.push_back(curr);
++step;
leftIndex.erase(bestIt);
}
}
// ***************************************************************************
void CPolygon2D::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
(void)f.serialVersion(0);
f.serialCont(Vertices);
}
// ***************************************************************************
/// get the best triplet of vector. e.g the triplet that has the best surface
void CPolygon2D::getBestTriplet(uint &index0, uint &index1, uint &index2)
{
nlassert(Vertices.size() >= 3);
uint i, j, k;
float bestArea = 0.f;
const uint numVerts = (uint)Vertices.size();
for (i = 0; i < numVerts; ++i)
{
for (j = 0; j < numVerts; ++j)
{
if (i != j)
{
for (k = 0; k < numVerts; ++k)
{
if (k != i && k != j)
{
CVector2f v0 = Vertices[j] - Vertices[i];
CVector2f v1 = Vertices[k] - Vertices[i];
float area = fabsf((CVector(v0.x, v0.y, 0) ^ CVector(v1.x, v1.y, 0)).norm());
if (area > bestArea)
{
bestArea = area;
index0 = i;
index1 = j;
index2 = k;
}
}
}
}
}
}
}
/// ***************************************************************************************
// scan a an edge of a poly and write it into a table
static void ScanEdge(CPolygon2D::TRasterVect &outputVect, sint topY, const CVector2f &v1, const CVector2f &v2, bool rightEdge = true)
{
const uint rol16 = 65536;
sint ceilY1 = (sint) ceilf(v1.y);
sint height;
float deltaX, deltaY;
float fInverseSlope;
sint iInverseSlope, iPosX;
// check whether this segment gives a contribution to the final poly
height = (sint) (ceilf(v2.y) - ceilY1);
if (height <= 0) return;
// compute slope
deltaY = v2.y - v1.y;
deltaX = v2.x - v1.x;
fInverseSlope = deltaX / deltaY;
CPolygon2D::TRasterVect::iterator outputIt = outputVect.begin() + (ceilY1 - topY);
// slope with ints
iInverseSlope = (sint) (rol16 * fInverseSlope);
// sub-pixel accuracy
iPosX = (int) (rol16 * (v1.x + fInverseSlope * (ceilY1 - v1.y)));
const CPolygon2D::TRasterVect::iterator endIt = outputIt + height;
if (rightEdge)
{
do
{
outputIt->second = iPosX >> 16;
iPosX += iInverseSlope;
++outputIt;
}
while (outputIt != endIt);
}
else
{
iPosX += (rol16 - 1);
do
{
outputIt->first = iPosX >> 16;
iPosX += iInverseSlope;
++outputIt;
}
while (outputIt != endIt);
}
}
// *******************************************************************************
// This function alow to cycle forward through a vertex vector like if it was a circular list
static inline CPolygon2D::TVec2fVect::const_iterator Next(const CPolygon2D::TVec2fVect::const_iterator &it, const CPolygon2D::TVec2fVect &cont)
{
nlassert(cont.size() != 0);
if ((it + 1) == cont.end()) return cont.begin();
return (it + 1);
}
// *******************************************************************************
// This function alow to cycle backward through a (non null) vertex vector like if it was a circular list
static inline CPolygon2D::TVec2fVect::const_iterator Prev(const CPolygon2D::TVec2fVect::const_iterator &it, const CPolygon2D::TVec2fVect &cont)
{
nlassert(cont.size() != 0);
if (it == cont.begin()) return cont.end() - 1;
return (it - 1);
}
// *******************************************************************************
bool CPolygon2D::isCCWOriented() const
{
const TVec2fVect &V = Vertices;
nlassert(Vertices.size() >= 3);
// compute highest and lowest pos of the poly
float fHighest = V[0].y;
float fLowest = fHighest;
// iterators to the highest and lowest vertex
TVec2fVect::const_iterator it = V.begin() ;
const TVec2fVect::const_iterator endIt = V.end();
TVec2fVect::const_iterator pHighest = V.begin();
do
{
if (it->y < fHighest)
{
fHighest = it->y;
pHighest = it;
}
fLowest = std::max(fLowest, it->y);
++it;
}
while (it != endIt);
// we seek this vertex
TVec2fVect::const_iterator pHighestRight = pHighest;
if (fLowest == fHighest)
{
// special case : degenerate poly
while (pHighestRight->x == pHighest->x)
{
pHighestRight = Next(pHighestRight, V);
if (pHighestRight == pHighest) return false; // the poly is reduced to a point, returns an abritrary value
}
return pHighest->x <= pHighestRight->x;
}
// iterator to the first vertex that has an y different from the top vertex
while (Next(pHighestRight, V)->y == fHighest)
{
pHighestRight = Next(pHighestRight, V);
}
// iterator to the first vertex after pHighestRight, that has the same y than the highest vertex
TVec2fVect::const_iterator pHighestLeft = Next(pHighestRight, V);
// seek the vertex
while (pHighestLeft->y != fHighest)
{
pHighestLeft = Next(pHighestLeft, V);
}
TVec2fVect::const_iterator pPrevHighestLeft = Prev(pHighestLeft, V);
// we need to get the orientation of the polygon
// There are 2 case : flat, and non-flat top
// check for flat top
if (pHighestLeft->x != pHighestRight->x)
{
// compare right and left side
return pHighestLeft->x <= pHighestRight->x;
}
// The top of the poly is sharp
// We perform a cross product of the 2 highest vect to get its orientation
float deltaXN = Next(pHighestRight, V)->x - pHighestRight->x;
float deltaYN = Next(pHighestRight, V)->y - pHighestRight->y;
float deltaXP = pPrevHighestLeft->x - pHighestLeft->x;
float deltaYP = pPrevHighestLeft->y - pHighestLeft->y;
return (deltaXN * deltaYP - deltaYN * deltaXP) >= 0;
}
// *******************************************************************************
void CPolygon2D::computeBorders(TRasterVect &borders, sint &highestY) const
{
#ifdef NL_DEBUG
checkValidBorders();
#endif
// an 'alias' to the vertices
const TVec2fVect &V = Vertices;
if (Vertices.size() < 3)
{
borders.clear();
return;
}
bool ccw; // set to true when it has a counter clock wise orientation
// compute highest and lowest pos of the poly
float fHighest = V[0].y;
float fLowest = fHighest;
// iterators to the thighest and lowest vertex
TVec2fVect::const_iterator pLowest = V.begin(), pHighest = V.begin();
TVec2fVect::const_iterator it = V.begin() ;
const TVec2fVect::const_iterator endIt = V.end();
do
{
if (it->y > fLowest)
{
fLowest = it->y;
pLowest = it;
}
else
if (it->y < fHighest)
{
fHighest = it->y;
pHighest = it;
}
++it;
}
while (it != endIt);
sint iHighest = (sint) ceilf(fHighest) ;
sint iLowest = (sint) ceilf(fLowest) ;
highestY = iHighest;
/// check poly height, and discard null height
uint polyHeight = iLowest - iHighest;
if (polyHeight <= 0)
{
borders.clear();
return;
}
borders.resize(polyHeight);
// iterator to the first vertex that has an y different from the top vertex
TVec2fVect::const_iterator pHighestRight = pHighest;
// we seek this vertex
while (Next(pHighestRight, V)->y == fHighest)
{
pHighestRight = Next(pHighestRight, V);
}
// iterator to the first vertex after pHighestRight, that has the same y than the highest vertex
TVec2fVect::const_iterator pHighestLeft = Next(pHighestRight, V);
// seek the vertex
while (pHighestLeft->y != fHighest)
{
pHighestLeft = Next(pHighestLeft, V);
}
TVec2fVect::const_iterator pPrevHighestLeft = Prev(pHighestLeft, V);
// we need to get the orientation of the polygon
// There are 2 case : flat, and non-flat top
// check for flat top
if (pHighestLeft->x != pHighestRight->x)
{
// compare right and left side
if (pHighestLeft->x > pHighestRight->x)
{
ccw = true; // the list is CCW oriented
std::swap(pHighestLeft, pHighestRight);
}
else
{
ccw = false; // the list is CW oriented
}
}
else
{
// The top of the poly is sharp
// We perform a cross product of the 2 highest vect to get its orientation
const float deltaXN = Next(pHighestRight, V)->x - pHighestRight->x;
const float deltaYN = Next(pHighestRight, V)->y - pHighestRight->y;
const float deltaXP = pPrevHighestLeft->x - pHighestLeft->x;
const float deltaYP = pPrevHighestLeft->y - pHighestLeft->y;
if ((deltaXN * deltaYP - deltaYN * deltaXP) < 0)
{
ccw = true; // the list is CCW oriented
std::swap(pHighestLeft, pHighestRight);
}
else
{
ccw = false; // the list is CW oriented
}
}
// compute borders
TVec2fVect::const_iterator currV, nextV; // current and next vertex
if (!ccw) // clock wise order ?
{
currV = pHighestRight ;
// compute right edge from top to bottom
do
{
nextV = Next(currV, V);
ScanEdge(borders, iHighest, *currV, *nextV, true);
currV = nextV;
}
while (currV != pLowest); // repeat until we reach the bottom vertex
// compute left edge from bottom to top
do
{
nextV = Next(currV, V);
ScanEdge(borders, iHighest, *nextV, *currV, false);
currV = nextV;
}
while (currV != pHighestLeft);
}
else // ccw order
{
currV = pHighestLeft;
// compute left edge from top to bottom
do
{
nextV = Next(currV, V);
ScanEdge(borders, iHighest, *currV, *nextV, false) ;
currV = nextV;
}
while (currV != pLowest) ;
// compute right edge from bottom to top
do
{
nextV = Next(currV, V);
ScanEdge(borders, iHighest, *nextV, *currV, true);
currV = nextV;
}
while (currV != pHighestRight) ;
}
}
//=========================================================================
// scan outer right edge of a poly
static void ScanOuterEdgeRight(CPolygon2D::TRaster *r, float x1, float y1, float x2, float y2, sint minY)
{
CPolygon2D::TRaster *currRaster;
float deltaX, deltaY;
float inverseSlope;
sint32 iInverseSlope, iposx;
sint height;
deltaX = x2 - x1;
height = (sint) (ceilf(y2) - floorf(y1)) ;
if (height <= 0) return;
if (deltaX >= 0.f)
{
if (height == 1)
{
currRaster = r + ((sint) floorf(y1) - minY);
currRaster->second = std::max((sint) floorf(x2), currRaster->second);
}
else
{
deltaY = y2 - y1;
if(deltaY)
inverseSlope = deltaX / deltaY;
else
inverseSlope = 0;
iInverseSlope = (sint32) (65536.0 * inverseSlope);
currRaster = r + ((sint) floorf(y1) - minY);
iposx = (sint32) (65536.0 * (x1 + inverseSlope * (ceilf(y1) - y1))); // sub-pixel accuracy
if (ceilf(y1) == y1)
{
iposx += iInverseSlope;
}
do
{
currRaster->second = std::max((sint) (iposx >> 16), currRaster->second);
iposx += iInverseSlope;
++ currRaster;
-- height;
}
while (height != 1);
// correction for last line
currRaster->second = std::max((sint) floorf(x2), currRaster->second);
}
}
else
{
deltaY = y2 - y1;
if(deltaY)
inverseSlope = deltaX / deltaY;
else
inverseSlope = 0;
iInverseSlope = (sint32) (65536.0 * inverseSlope);
currRaster = r + ((sint) floorf(y1) - minY);
currRaster->second = std::max((sint) floorf(x1), currRaster->second);
++ currRaster;
iposx = (sint32) (65536.0 * (x1 + inverseSlope * (ceilf(y1) - y1))); // sub-pixel accuracy
if (ceilf(y1) == y1)
{
iposx += iInverseSlope;
}
while (--height)
{
currRaster->second = std::max((sint) (iposx >> 16), currRaster->second);
iposx += iInverseSlope;
++ currRaster;
}
}
}
//=========================================================================
// scan outer left edge of a poly
static void ScanOuterEdgeLeft(CPolygon2D::TRaster *r, float x1, float y1, float x2, float y2, sint minY)
{
CPolygon2D::TRaster *currRaster;
float deltaX, deltaY;
float inverseSlope;
sint32 iInverseSlope, iposx;
sint height;
deltaX = x2 - x1;
height = (sint) (ceilf(y2) - floorf(y1)) ;
if (height <= 0) return;
if (deltaX < 0.f)
{
if (height == 1)
{
currRaster = r + ((sint) floorf(y1) - minY);
currRaster->first = std::min((sint) floorf(x2), currRaster->first);
}
else
{
deltaY = y2 - y1;
if(deltaY)
inverseSlope = deltaX / deltaY;
else
inverseSlope = 0;
iInverseSlope = (sint32) (65536.0 * inverseSlope);
currRaster = r + ((sint) floorf(y1) - minY);
iposx = (sint32) (65536.0 * (x1 + inverseSlope * (ceilf(y1) - y1))); // sub-pixel accuracy
if (ceilf(y1) == y1)
{
iposx += iInverseSlope;
}
do
{
currRaster->first = std::min((sint) (iposx >> 16), currRaster->first);
iposx += iInverseSlope;
++ currRaster;
-- height;
}
while (height != 1);
// correction for last line
currRaster->first = std::min((sint) floorf(x2), currRaster->first);
}
}
else
{
deltaY = y2 - y1;
if(deltaY)
inverseSlope = deltaX / deltaY;
else
inverseSlope = 0;
iInverseSlope = (sint32) (65536.0 * inverseSlope);
currRaster = r + ((sint) floorf(y1) - minY);
currRaster->first = std::min((sint) floorf(x1), currRaster->first);
++ currRaster;
iposx = (sint32) (65536.0 * (x1 + inverseSlope * (ceilf(y1) - y1))); // sub-pixel accuracy
if (ceilf(y1) == y1)
{
iposx += iInverseSlope;
}
while (--height)
{
currRaster->first = std::min((sint) (iposx >> 16), currRaster->first);
iposx += iInverseSlope;
++ currRaster;
}
}
}
// *******************************************************************************
void CPolygon2D::computeOuterBorders(TRasterVect &borders, sint &minimumY) const
{
#ifdef NL_DEBUG
checkValidBorders();
#endif
borders.clear();
// NB : this version is not much optimized, because of the min/max test
// during rasterization.
// TODO : optimize if needed ...
if (Vertices.empty())
{
minimumY = -1;
return;
}
const CVector2f *first = &Vertices[0];
const CVector2f *last = first + Vertices.size();
const CVector2f *curr = first, *next, *plowest ,*phighest;
const CVector2f *pHighestRight, *pHighestRightNext, *pHighestLeft;
const CVector2f *pPrevHighestLeft;
double deltaXN, deltaYN, deltaXP, deltaYP;
bool ccw; // true if CCW oriented
sint polyHeight;
sint highest, lowest;
float fright = curr->x;
float fleft = curr->x;
float fhighest = curr->y;
float flowest = curr->y;
plowest = phighest = curr;
// compute highest and lowest pos of the poly
do
{
fright = std::max(fright, curr->x);
fleft = std::min(fleft, curr->x);
if (curr->y > flowest)
{
flowest = curr->y;
plowest = curr;
}
if (curr->y < fhighest)
{
fhighest = curr->y;
phighest = curr;
}
++curr;
}
while (curr != last);
highest = (sint) floorf(fhighest);
lowest = (sint) floorf(flowest);
polyHeight = lowest - highest + 1;
nlassert(polyHeight > 0);
// make room for rasters
borders.resize(polyHeight);
// fill with xmin / xman
sint ileft = (sint) floorf(fleft);
sint iright = (sint) ceilf(fright);
minimumY = highest;
if (flowest == fhighest) // special case : degenerate poly
{
borders.resize(1);
borders.front().first = ileft;
borders.front().second = ileft;
return;
}
//
for(TRasterVect::iterator it = borders.begin(); it != borders.end(); ++it)
{
it->second = ileft;
it->first = iright;
}
pHighestRight = phighest;
for (;;)
{
pHighestRightNext = pHighestRight + 1;
if (pHighestRightNext == last) pHighestRightNext = first;
if (pHighestRightNext->y != pHighestRight->y) break;
pHighestRight = pHighestRightNext;
}
pPrevHighestLeft = pHighestRight;
pHighestLeft = pHighestRight;
++pHighestLeft;
if (pHighestLeft == last) pHighestLeft = first;
while (pHighestLeft->y != fhighest)
{
pPrevHighestLeft = pHighestLeft;
++pHighestLeft;
if (pHighestLeft == last) pHighestLeft = first;
}
// we need to get the orientation of the polygon
// There are 2 case : flat, and non-flat top
// check for flat top
if (pHighestLeft->x != pHighestRight->x)
{
// compare right and left side
if (pHighestLeft->x > pHighestRight->x)
{
ccw = true; // the list is CCW oriented
std::swap(pHighestLeft, pHighestRight);
}
else
{
ccw = false; // the list is CW oriented
}
}
else
{
pHighestRightNext = pHighestRight + 1;
if (pHighestRightNext == last) pHighestRightNext = first;
deltaXN = pHighestRightNext->x - pHighestRight->x;
deltaYN = pHighestRightNext->y - pHighestRight->y;
deltaXP = pPrevHighestLeft->x - pHighestLeft->x;
deltaYP = pPrevHighestLeft->y - pHighestLeft->y;
if ((deltaXN * deltaYP - deltaYN * deltaXP) < 0)
{
ccw = true;
std::swap(pHighestLeft, pHighestRight);
}
else
{
ccw = false;
}
}
if (!ccw)
{
// clock wise oriented list
curr = pHighestRight;
do
{
next = curr + 1;
if (next == last) next = first;
ScanOuterEdgeRight(&borders[0], curr->x, curr->y, next->x, next->y, minimumY);
curr = next;
}
while (curr != plowest);
do
{
next = curr + 1;
if (next == last) next = first;
ScanOuterEdgeLeft(&borders[0], next->x, next->y, curr->x, curr->y, minimumY);
curr = next;
}
while (curr != pHighestLeft);
}
else
{
// ccw oriented
curr = pHighestLeft;
do
{
next = curr + 1;
if (next == last) next = first;
ScanOuterEdgeLeft(&borders[0], curr->x, curr->y, next->x, next->y, minimumY);
curr = next;
}
while (curr != plowest);
do
{
next = curr + 1;
if (next == last) next = first;
ScanOuterEdgeRight(&borders[0], next->x, next->y, curr->x, curr->y, minimumY);
curr = next;
}
while (curr != pHighestRight);
}
}
//=========================================================================
// scan inner right edge of a poly
static void ScanInnerEdge(CPolygon2D::TRaster *r, float x1, float y1, float x2, float y2, sint minY, bool rightEdge)
{
const uint rol16 = 65536;
CPolygon2D::TRaster *currRaster;
float deltaX, deltaY;
float inverseSlope;
sint32 iInverseSlope, iposx;
sint height;
deltaX = x2 - x1;
height = (sint) (ceilf(y2) - floorf(y1));
if (height <= 0) return;
deltaY = y2 - y1;
if(deltaY)
inverseSlope = deltaX / deltaY;
else
inverseSlope = 0;
iInverseSlope = (sint32) (rol16 * inverseSlope);
currRaster = r + ((sint) floorf(y1) - minY);
//
iposx = (sint32) (rol16 * (x1 + inverseSlope * (ceilf(y1) - y1))); // sub-pixel accuracy
if (rightEdge)
{
iposx -= rol16 - 1;
if (deltaX >= 0.f)
{
// start of segment
if (floorf(y1) != y1)
{
currRaster->second = std::min((sint) floorf(x1) - 1, currRaster->second);
++ currRaster;
-- height;
if (height == 0) return;
}
do
{
currRaster->second = std::min((sint) (iposx >> 16), currRaster->second);
iposx += iInverseSlope;
++ currRaster;
}
while (--height);
}
else
{
// start of segment
if (floorf(y1) != y1)
{
currRaster->second = std::min((sint) (iposx >> 16), currRaster->second);
++ currRaster;
-- height;
if (height == 0) return;
}
while (--height)
{
iposx += iInverseSlope;
currRaster->second = std::min((sint) (iposx >> 16), currRaster->second);
++ currRaster;
}
// fill bottom of segment
currRaster->second = std::min((sint) floorf(x2) - 1, currRaster->second);
}
}
else
{
iposx += rol16 - 1;
if (deltaX < 0.f)
{
// start of segment
if (floorf(y1) != y1)
{
currRaster->first = std::max((sint) ceilf(x1), currRaster->first);
++ currRaster;
-- height;
if (height == 0) return;
}
do
{
currRaster->first = std::max((sint) (iposx >> 16), currRaster->first);
iposx += iInverseSlope;
++ currRaster;
}
while (--height);
}
else
{
// start of segment
if (floorf(y1) != y1)
{
currRaster->first = std::max((sint) (iposx >> 16), currRaster->first);
++ currRaster;
-- height;
if (height == 0) return;
}
while (--height)
{
iposx += iInverseSlope;
currRaster->first = std::max((sint) (iposx >> 16), currRaster->first);
++ currRaster;
}
// fill bottom of segment
currRaster->first = std::max((sint) ceilf(x2), currRaster->first);
}
}
}
// *******************************************************************************
void CPolygon2D::computeInnerBorders(TRasterVect &borders, sint &minimumY) const
{
#ifdef NL_DEBUG
checkValidBorders();
#endif
borders.clear();
if (Vertices.empty())
{
minimumY = -1;
return;
}
const CVector2f *first = &Vertices[0];
const CVector2f *last = first + Vertices.size();
const CVector2f *curr = first, *next, *plowest ,*phighest;
const CVector2f *pHighestRight, *pHighestRightNext, *pHighestLeft;
const CVector2f *pPrevHighestLeft;
double deltaXN, deltaYN, deltaXP, deltaYP;
bool ccw; // true if CCW oriented
sint polyHeight;
sint highest, lowest;
float fright = curr->x;
float fleft = curr->x;
float fhighest = curr->y;
float flowest = curr->y;
plowest = phighest = curr;
// compute highest (with lowest y) and lowest (with highest y) points of the poly
do
{
fright = std::max(fright, curr->x);
fleft = std::min(fleft, curr->x);
if (curr->y > flowest)
{
flowest = curr->y;
plowest = curr;
}
if (curr->y < fhighest)
{
fhighest = curr->y;
phighest = curr;
}
++curr;
}
while (curr != last);
if (flowest == fhighest)
{
minimumY = -1;
return;
}
highest = (sint) floorf(fhighest);
lowest = (sint) ceilf(flowest);
polyHeight = lowest - highest;
minimumY = highest;
if (polyHeight == 0)
{
minimumY = -1;
return;
}
// make room for rasters
borders.resize(polyHeight);
// fill with xmin / xman
sint ileft = (sint) floorf(fleft) - 1;
sint iright = (sint) ceilf(fright);
for(TRasterVect::iterator it = borders.begin(); it != borders.end(); ++it)
{
it->second = iright;
it->first = ileft;
}
pHighestRight = phighest;
for (;;)
{
pHighestRightNext = pHighestRight + 1;
if (pHighestRightNext == last) pHighestRightNext = first;
if (pHighestRightNext->y != pHighestRight->y) break;
pHighestRight = pHighestRightNext;
}
pPrevHighestLeft = pHighestRight;
pHighestLeft = pHighestRight;
++pHighestLeft;
if (pHighestLeft == last) pHighestLeft = first;
while (pHighestLeft->y != fhighest)
{
pPrevHighestLeft = pHighestLeft;
++pHighestLeft;
if (pHighestLeft == last) pHighestLeft = first;
}
// we need to get the orientation of the polygon
// There are 2 case : flat, and non-flat top
// check for flat top
if (pHighestLeft->x != pHighestRight->x)
{
// compare right and left side
if (pHighestLeft->x > pHighestRight->x)
{
ccw = true; // the list is CCW oriented
std::swap(pHighestLeft, pHighestRight);
}
else
{
ccw = false; // the list is CW oriented
}
}
else
{
pHighestRightNext = pHighestRight + 1;
if (pHighestRightNext == last) pHighestRightNext = first;
deltaXN = pHighestRightNext->x - pHighestRight->x;
deltaYN = pHighestRightNext->y - pHighestRight->y;
deltaXP = pPrevHighestLeft->x - pHighestLeft->x;
deltaYP = pPrevHighestLeft->y - pHighestLeft->y;
if ((deltaXN * deltaYP - deltaYN * deltaXP) < 0)
{
ccw = true;
std::swap(pHighestLeft, pHighestRight);
}
else
{
ccw = false;
}
}
if (!ccw)
{
// cw oriented
curr = pHighestRight;
do
{
next = curr + 1;
if (next == last) next = first;
ScanInnerEdge(&borders[0], curr->x, curr->y, next->x, next->y, minimumY, true);
curr = next;
}
while (curr != plowest);
do
{
next = curr + 1;
if (next == last) next = first;
ScanInnerEdge(&borders[0], next->x, next->y, curr->x, curr->y, minimumY, false);
curr = next;
}
while (curr != pHighestLeft);
}
else
{
// ccw oriented
curr = pHighestLeft;
do
{
next = curr + 1;
if (next == last) next = first;
ScanInnerEdge(&borders[0], curr->x, curr->y, next->x, next->y, minimumY, false);
curr = next;
}
while (curr != plowest);
do
{
next = curr + 1;
if (next == last) next = first;
ScanInnerEdge(&borders[0], next->x, next->y, curr->x, curr->y, minimumY, true);
curr = next;
}
while (curr != pHighestRight);
}
// fix for top
if (floorf(fhighest) != fhighest)
{
borders[0].first = 1;
borders[0].second = 0;
}
// fix for bottom
if (floorf(flowest) != flowest)
{
borders.back().first = 1;
borders.back().second = 0;
}
}
// *******************************************************************************
void CPolygon2D::checkValidBorders() const
{
for (uint k = 0; k < Vertices.size(); ++k)
{
nlassert(Vertices[k].x >= -32000.f); // coordinate too big !
nlassert(Vertices[k].x < 32000.f); // coordinate too big !
nlassert(Vertices[k].y >= -32000.f); // coordinate too big !
nlassert(Vertices[k].y < 32000.f); // coordinate too big !
}
}
// *******************************************************************************
/// Sum the dot product of this poly vertices against a plane
float CPolygon2D::sumDPAgainstLine(float a, float b, float c) const
{
float sum = 0.f;
for (uint k = 0; k < Vertices.size(); ++k)
{
const CVector2f &p = Vertices[k];
sum += a * p.x + b * p.y + c;
}
return sum;
}
// *******************************************************************************
bool CPolygon2D::getNonNullSeg(uint &index) const
{
nlassert(Vertices.size() > 0);
float bestLength = 0.f;
sint bestIndex = -1;
for (uint k = 0; k < Vertices.size() - 1; ++k)
{
float norm2 = (Vertices[k + 1] - Vertices[k]).sqrnorm();
if ( norm2 > bestLength)
{
bestLength = norm2;
bestIndex = (int) k;
}
}
float norm2 = (Vertices[Vertices.size() - 1] - Vertices[0]).sqrnorm();
if ( norm2 > bestLength)
{
index = (uint)Vertices.size() - 1;
return true;
}
if (bestIndex != -1)
{
index = bestIndex;
return true;
}
else
{
return false;
}
}
// *******************************************************************************
void CPolygon2D::getLineEquation(uint index, float &a, float &b, float &c) const
{
nlassert(index < Vertices.size());
const CVector2f &v0 = getSegRef0(index);
const CVector2f &v1 = getSegRef1(index);
NLMISC::CVector2f seg = v0 - v1;
a = seg.y;
b = - seg.x;
c = - v0.x * a - v0.y * b;
}
// *******************************************************************************
bool CPolygon2D::intersect(const CPolygon2D &other) const
{
nlassert(other.Vertices.size() > 0);
uint nonNullSegIndex;
/// get the orientation of this poly
if (getNonNullSeg(nonNullSegIndex))
{
float a0, b0, c0; /// contains the seg 2d equation
getLineEquation(nonNullSegIndex, a0, b0, c0);
float orient = sumDPAgainstLine(a0, b0, c0);
for (uint k = 0; k < Vertices.size(); ++k)
{
/// don't check against a null segment
if ( (getSegRef0(k) - getSegRef1(k)).sqrnorm() == 0.f) continue;
/// get the line equation of the current segment
float a, b, c; /// contains the seg 2d equation
getLineEquation(k, a, b, c);
uint l;
for (l = 0; l < other.Vertices.size(); ++l)
{
const CVector2f &ov = other.Vertices[l];
if ( orient * (ov.x * a + ov.y * b +c) > 0.f) break;
}
if (l == other.Vertices.size()) // all point on the outside
{
return false; // outside
}
}
return true;
}
else // this poly is just a point
{
return other.contains(Vertices[0]);
}
}
// *******************************************************************************
bool CPolygon2D::contains(const CVector2f &p, bool hintIsConvex /*= true*/) const
{
if (hintIsConvex)
{
uint numVerts = (uint)Vertices.size();
nlassert(numVerts >= 0.f);
for (uint k = 0; k < numVerts; ++k)
{
if (getSegRef0(k) != getSegRef1(k))
{
float a, b, c; /// contains the seg 2d equation
getLineEquation(k, a, b, c);
float orient = a * p.x + b * p.y + c;
for(uint l = k + 1; l < numVerts; ++l)
{
getLineEquation(l, a, b, c);
float newOrient = a * p.x + b * p.y + c;
if (newOrient * orient < 0.f) return false;
}
return true;
}
}
// the poly reduces to a point
return p == Vertices[0];
}
else
{
// concave case
static std::vector<float> xInter;
xInter.clear();
for(uint k = 0; k < Vertices.size(); ++k)
{
const CVector2f &p0 = getSegRef0(k);
const CVector2f &p1 = getSegRef1(k);
if (p0.y == p1.y)
{
if (p.y == p0.y)
{
if ((p.x >= p0.x && p.x <= p1.x)
|| (p.x >= p1.x && p.x <= p0.x))
{
return true;
}
}
}
if ((p.y >= p0.y && p.y < p1.y) ||
(p.y >= p1.y && p.y < p0.y)
)
{
float inter = p0.x + (p.y - p0.y) * (p1.x - p0.x) / (p1.y- p0.y);
xInter.push_back(inter);
}
}
if (xInter.size() < 2) return false;
std::sort(xInter.begin(), xInter.end());
for(uint k = 0; k < xInter.size() - 1; ++k)
{
if (p.x >= xInter[k] && p.x <= xInter[k + 1])
{
return (k & 1) == 0;
}
}
return false;
}
}
// *******************************************************************************
CPolygon2D::CPolygon2D(const CTriangle &tri, const CMatrix &projMat)
{
Vertices.resize(3);
NLMISC::CVector proj[3] = { projMat * tri.V0, projMat * tri.V1, projMat * tri.V2 };
Vertices[0].set(proj[0].x, proj[0].y);
Vertices[1].set(proj[1].x, proj[1].y);
Vertices[2].set(proj[2].x, proj[2].y);
}
// *******************************************************************************
void CPolygon2D::getBoundingRect(CVector2f &minCorner, CVector2f &maxCorner) const
{
nlassert(!Vertices.empty());
minCorner = maxCorner = Vertices[0];
uint numVertices = (uint)Vertices.size();
for(uint k = 0; k < numVertices; ++k)
{
minCorner.minof(minCorner, Vertices[k]);
maxCorner.maxof(minCorner, Vertices[k]);
}
}
// *******************************************************************************
bool operator ==(const CPolygon2D &lhs,const CPolygon2D &rhs)
{
if (lhs.Vertices.size() != rhs.Vertices.size()) return false;
return std::equal(lhs.Vertices.begin(), lhs.Vertices.end(), rhs.Vertices.begin());
}
// *******************************************************************************
bool operator < (const CPolygon2D &lhs, const CPolygon2D &rhs)
{
if (lhs.Vertices.size() != rhs.Vertices.size()) return lhs.Vertices.size() < rhs.Vertices.size();
for(uint k = 0; k < lhs.Vertices.size(); ++k)
{
if (lhs.Vertices[k] != rhs.Vertices[k]) return lhs.Vertices[k] < rhs.Vertices[k];
}
return false;
}
// *******************************************************************************
static inline bool testSegmentIntersection(const CVector2f &a, const CVector2f &b,
const CVector2f &c, const CVector2f &d)
{
double denom = a.x * double(d.y - c.y) +
b.x * double(c.y - d.y) +
d.x * double(b.y - a.y) +
c.x * double(a.y - b.y);
if (denom == 0) return false;
//
double num = a.x * double(d.y - c.y) +
c.x * double(a.y - d.y) +
d.x * double(c.y - a.y);
if (num == 0 || (num == denom)) return false;
double lambda = num / denom;
if (lambda <= 0 || lambda >= 1) return false;
//
num = - (a.x * double(c.y - b.y) +
b.x * double(a.y - c.y) +
c.x * double(b.y - a.y));
if (num == 0 || (num == denom)) return false;
lambda = num / denom;
if (lambda <= 0 || lambda >= 1) return false;
return true;
}
// *******************************************************************************
bool CPolygon2D::selfIntersect() const
{
if (Vertices.size() < 3) return false;
uint numEdges = (uint)Vertices.size();
for(uint k = 0; k < numEdges; ++k)
{
// test intersection with all other edges that don't share a vertex with this one
const CVector2f &p0 = getSegRef0(k);
const CVector2f &p1 = getSegRef1(k);
for(uint l = 0; l < k; ++l)
{
const CVector2f &v0 = getSegRef0(l);
const CVector2f &v1 = getSegRef1(l);
if (v0 == p0 || v0 == p1 || v1 == p0 || v1 == p1) continue;
//
if (testSegmentIntersection(p0, p1, v0, v1)) return true;
}
}
return false;
}
} // NLMISC
Reference in a new issue Copy permalink