void H2PolygonTriangulater::triangulateSubpolygon(const std::vector<uint> &indices)
{
if (indices.size() == 3)
{
if (*std::min_element(indices.begin(),indices.end())==indices[0])
{
triangles.push_back(TriangulationTriangle(indices[0], indices[1], indices[2]));
} else if (*std::min_element(indices.begin(),indices.end())==indices[1])
{
triangles.push_back(TriangulationTriangle(indices[1], indices[2], indices[0]));
} else if (*std::min_element(indices.begin(),indices.end())==indices[2])
{
triangles.push_back(TriangulationTriangle(indices[2], indices[0], indices[1]));
}
}
else
{
uint cut1, cut2;
findCutInSubpolygon2(indices, cut1, cut2);
std::vector<uint> list1, list2;
splitIndicesList(indices, cut1, cut2, list1, list2);
triangulateSubpolygon(list1);
triangulateSubpolygon(list2);
}
}
template<class Real> int
Triangulation<Real>::addTriangle (const int& p1, const int& p2, const int& p3)
{
hash_map<long long, int>::iterator iter;
int tIdx, eIdx, p[3];
p[0] = p1;
p[1] = p2;
p[2] = p3;
triangles.push_back (TriangulationTriangle ());
tIdx = int (triangles.size ()) - 1;
for (int i = 0; i < 3; i++)
{
long long e = EdgeIndex (p[i], p[(i + 1) % 3]);
iter = edgeMap.find (e);
if (iter == edgeMap.end ())
{
TriangulationEdge edge;
edge.pIndex[0] = p[i];
edge.pIndex[1] = p[(i + 1) % 3];
edges.push_back (edge);
eIdx = int (edges.size ()) - 1;
edgeMap[e] = eIdx;
edges[eIdx].tIndex[0] = tIdx;
}
else
{
eIdx = edgeMap[e];
if (edges[eIdx].pIndex[0] == p[i])
{
if (edges[eIdx].tIndex[0] < 0)
{
edges[eIdx].tIndex[0] = tIdx;
}
else
{
printf ("Edge Triangle in use 1\n");
return 0;
}
}
else
{
if (edges[eIdx].tIndex[1] < 0)
{
edges[eIdx].tIndex[1] = tIdx;
}
else
{
printf ("Edge Triangle in use 2\n");
return 0;
}
}
}
triangles[tIdx].eIndex[i] = eIdx;
}
return tIdx;
}
bool H2PolygonTriangulater::attemptFlip()
{
TriangulationTriangle leftTriangle, rightTriangle;
uint sharedIndex1, sharedIndex2, unsharedIndexLeft, unsharedIndexRight, leftTriangleIndex, rightTriangleIndex;
bool out = false;
std::vector<uint> quadrilateralIndices;
quadrilateralIndices.reserve(4);
uint l1, l2, l3, k1, k2, k3;
bool rightTriangleCheats = false;
uint cutIndex=0;
while (!out && cutIndex<cuts.size())
{
quadrilateralIndices.clear();
sharedIndex1 = cuts[cutIndex].vertexIndex1;
sharedIndex2 = cuts[cutIndex].vertexIndex2;
leftTriangleIndex = cuts[cutIndex].leftTriangleIndex;
rightTriangleIndex = cuts[cutIndex].rightTriangleIndex;
leftTriangle = triangles[leftTriangleIndex];
rightTriangle = triangles[rightTriangleIndex];
leftTriangle.getVertices(sharedIndex1, unsharedIndexLeft, sharedIndex2);
rightTriangle.getVertices(l1, l2, l3);
if (l1==cuts[cutIndex].vertexIndex1)
{
rightTriangleCheats = false;
rightTriangle.getVertices(sharedIndex1, sharedIndex2, unsharedIndexRight);
}
else if (l2==cuts[cutIndex].vertexIndex1)
{
rightTriangleCheats = true;
rightTriangle.getVertices(unsharedIndexRight, sharedIndex1, sharedIndex2);
}
else
{
throw(QString("ERROR in H2PolygonTriangulater::testQuadrilateralForFlipLengths: A triangle abutting a cut doesn't have vertices compatible with the desired cut"));
}
quadrilateralIndices.push_back(sharedIndex1);
quadrilateralIndices.push_back(unsharedIndexLeft);
quadrilateralIndices.push_back(sharedIndex2);
quadrilateralIndices.push_back(unsharedIndexRight);
//if (testQuadrilateralForFlipLengths(quadrilateralIndices) && !sameSide(unsharedIndex1,unsharedIndex2))
if (testQuadrilateralForFlipAngles(quadrilateralIndices) && !sameSide(unsharedIndexLeft,unsharedIndexRight))
{
getCutsFromTriangle(leftTriangleIndex, l1, l2, l3);
getCutsFromTriangle(rightTriangleIndex, k1, k2, k3);
if (l1 < cuts.size())
{
cuts[l1].rightTriangleIndex = rightTriangleIndex;
}
else
{
sideTrianglesIndices[sharedIndex1] = rightTriangleIndex;
sideTrianglesBoundarySideIndices[sharedIndex1] = 0;
}
if (l3 < cuts.size())
{
cuts[l3].rightTriangleIndex = leftTriangleIndex;
}
else
{
sideTrianglesIndices[unsharedIndexLeft] = leftTriangleIndex;
sideTrianglesBoundarySideIndices[unsharedIndexLeft] = 0;
}
if (!rightTriangleCheats)
{
if (k2 < cuts.size())
{
cuts[k2].leftTriangleIndex = rightTriangleIndex;
}
else
{
sideTrianglesIndices[unsharedIndexRight] = rightTriangleIndex;
sideTrianglesBoundarySideIndices[unsharedIndexRight] = 2;
}
if (k3 < cuts.size())
{
cuts[k3].rightTriangleIndex = leftTriangleIndex;
} else
{
sideTrianglesIndices[sharedIndex2] = leftTriangleIndex;
sideTrianglesBoundarySideIndices[unsharedIndexRight] = 1;
}
}
else
{
if (k1 < cuts.size())
{
cuts[k1].rightTriangleIndex = rightTriangleIndex;
}
else
{
sideTrianglesIndices[unsharedIndexRight] = rightTriangleIndex;
sideTrianglesBoundarySideIndices[unsharedIndexRight] = 0;
}
if (k2 < cuts.size())
{
cuts[k2].leftTriangleIndex = leftTriangleIndex;
} else
{
sideTrianglesIndices[sharedIndex2] = leftTriangleIndex;
sideTrianglesBoundarySideIndices[unsharedIndexRight] = 2;
}
}
if (!rightTriangleCheats)
{
triangles[leftTriangleIndex] = TriangulationTriangle(unsharedIndexLeft,sharedIndex2,unsharedIndexRight);
triangles[rightTriangleIndex] = TriangulationTriangle(sharedIndex1,unsharedIndexLeft,unsharedIndexRight);
}
else
{
triangles[leftTriangleIndex] = TriangulationTriangle(unsharedIndexRight,unsharedIndexLeft,sharedIndex2);
triangles[rightTriangleIndex] = TriangulationTriangle(unsharedIndexRight,sharedIndex1,unsharedIndexLeft);
}
if (!rightTriangleCheats)
{
cuts[cutIndex] = TriangulationCut(unsharedIndexLeft,unsharedIndexRight,leftTriangleIndex,rightTriangleIndex);
}
else
{
cuts[cutIndex] = TriangulationCut(unsharedIndexRight,unsharedIndexLeft,rightTriangleIndex,leftTriangleIndex);
}
return true;
}
++cutIndex;
}
return false;
}
