kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Mesh: Apply clang-format

Browse Source
This commit is contained in:
wmayer
2023-09-22 19:59:39 +02:00
committed by wwmayer
parent 14cbc5f1e5
commit 4e328682d9
116 changed files with 15683 additions and 12447 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
src/Mod/Mesh/App/Core/Trim.cpp
View File

@@ -22,38 +22,40 @@
#include "PreCompiled.h"
#ifndef _PreComp_
# include <algorithm>
#include <algorithm>
#endif
#include <Base/Sequencer.h>
#include "Trim.h"
#include "Grid.h"
#include "Iterator.h"
#include "Trim.h"
using namespace MeshCore;
MeshTrimming::MeshTrimming(MeshKernel &rclM, const Base::ViewProjMethod* pclProj,
MeshTrimming::MeshTrimming(MeshKernel& rclM,
const Base::ViewProjMethod* pclProj,
const Base::Polygon2d& rclPoly)
: myMesh(rclM), myProj(pclProj), myPoly(rclPoly)
{
}
: myMesh(rclM)
, myProj(pclProj)
, myPoly(rclPoly)
{}
void MeshTrimming::SetInnerOrOuter(TMode tMode)
{
switch (tMode)
{
case INNER:
myInner = true;
break;
case OUTER:
myInner = false;
break;
switch (tMode) {
case INNER:
myInner = true;
break;
case OUTER:
myInner = false;
break;
}
}
void MeshTrimming::CheckFacets(const MeshFacetGrid& rclGrid, std::vector<FacetIndex> &raulFacets) const
void MeshTrimming::CheckFacets(const MeshFacetGrid& rclGrid,
std::vector<FacetIndex>& raulFacets) const
{
std::vector<FacetIndex>::iterator it;
MeshFacetIterator clIter(myMesh, 0);
@@ -79,14 +81,16 @@ void MeshTrimming::CheckFacets(const MeshFacetGrid& rclGrid, std::vector<FacetIn
// remove double elements
std::sort(aulAllElements.begin(), aulAllElements.end());
aulAllElements.erase(std::unique(aulAllElements.begin(), aulAllElements.end()), aulAllElements.end());
aulAllElements.erase(std::unique(aulAllElements.begin(), aulAllElements.end()),
aulAllElements.end());
Base::SequencerLauncher seq("Check facets for intersection...", aulAllElements.size());
for (it = aulAllElements.begin(); it != aulAllElements.end(); ++it) {
MeshGeomFacet clFacet = myMesh.GetFacet(*it);
if (HasIntersection(clFacet))
if (HasIntersection(clFacet)) {
raulFacets.push_back(*it);
}
seq.next();
}
}
@@ -94,8 +98,9 @@ void MeshTrimming::CheckFacets(const MeshFacetGrid& rclGrid, std::vector<FacetIn
else {
Base::SequencerLauncher seq("Check facets for intersection...", myMesh.CountFacets());
for (clIter.Init(); clIter.More(); clIter.Next()) {
if (HasIntersection(*clIter))
if (HasIntersection(*clIter)) {
raulFacets.push_back(clIter.Position());
}
seq.next();
}
}
@@ -108,30 +113,34 @@ bool MeshTrimming::HasIntersection(const MeshGeomFacet& rclFacet) const
Base::Vector2d S;
// is corner of facet inside the polygon
for (auto pnt : rclFacet._aclPoints) {
Base::Vector3f clPt2d = myProj->operator ()(pnt);
if (myPoly.Contains(Base::Vector2d(clPt2d.x, clPt2d.y)) == myInner)
Base::Vector3f clPt2d = myProj->operator()(pnt);
if (myPoly.Contains(Base::Vector2d(clPt2d.x, clPt2d.y)) == myInner) {
return true;
else
}
else {
clPoly.Add(Base::Vector2d(clPt2d.x, clPt2d.y));
}
}
// is corner of polygon inside the facet
for (size_t j=0; j<myPoly.GetCtVectors(); j++) {
if (clPoly.Contains(myPoly[j]))
for (size_t j = 0; j < myPoly.GetCtVectors(); j++) {
if (clPoly.Contains(myPoly[j])) {
return true;
}
}
// check for other intersections
for (size_t j=0; j<myPoly.GetCtVectors(); j++) {
for (size_t j = 0; j < myPoly.GetCtVectors(); j++) {
clPolyLine.clV1 = myPoly[j];
clPolyLine.clV2 = myPoly[(j+1)%myPoly.GetCtVectors()];
clPolyLine.clV2 = myPoly[(j + 1) % myPoly.GetCtVectors()];
for (size_t i=0; i<3; i++) {
for (size_t i = 0; i < 3; i++) {
clFacLine.clV1 = clPoly[i];
clFacLine.clV2 = clPoly[(i+1)%3];
clFacLine.clV2 = clPoly[(i + 1) % 3];
if (clPolyLine.IntersectAndContain(clFacLine, S))
if (clPolyLine.IntersectAndContain(clFacLine, S)) {
return true;
}
}
}
@@ -141,12 +150,13 @@ bool MeshTrimming::HasIntersection(const MeshGeomFacet& rclFacet) const
bool MeshTrimming::PolygonContainsCompleteFacet(bool bInner, FacetIndex ulIndex) const
{
const MeshFacet &rclFacet = myMesh._aclFacetArray[ulIndex];
const MeshFacet& rclFacet = myMesh._aclFacetArray[ulIndex];
for (PointIndex ptIndex : rclFacet._aulPoints) {
const MeshPoint &rclFacPt = myMesh._aclPointArray[ptIndex];
const MeshPoint& rclFacPt = myMesh._aclPointArray[ptIndex];
Base::Vector3f clPt = (*myProj)(rclFacPt);
if (myPoly.Contains(Base::Vector2d(clPt.x, clPt.y)) != bInner)
if (myPoly.Contains(Base::Vector2d(clPt.x, clPt.y)) != bInner) {
return false;
}
}
return true;
@@ -155,9 +165,9 @@ bool MeshTrimming::PolygonContainsCompleteFacet(bool bInner, FacetIndex ulIndex)
bool MeshTrimming::IsPolygonPointInFacet(FacetIndex ulIndex, Base::Vector3f& clPoint)
{
Base::Vector2d A, B, C, P;
float u,v,w, fDetPAC, fDetPBC, fDetPAB, fDetABC;
float u, v, w, fDetPAC, fDetPBC, fDetPAB, fDetABC;
Base::Polygon2d clFacPoly;
const MeshGeomFacet &rclFacet = myMesh.GetFacet(ulIndex);
const MeshGeomFacet& rclFacet = myMesh.GetFacet(ulIndex);
for (auto pnt : rclFacet._aclPoints) {
Base::Vector3f clPt = (*myProj)(pnt);
@@ -167,24 +177,30 @@ bool MeshTrimming::IsPolygonPointInFacet(FacetIndex ulIndex, Base::Vector3f& clP
A = clFacPoly[0];
B = clFacPoly[1];
C = clFacPoly[2];
fDetABC = static_cast<float>(A.x*B.y+A.y*C.x+B.x*C.y-(B.y*C.x+A.y*B.x+A.x*C.y));
fDetABC =
static_cast<float>(A.x * B.y + A.y * C.x + B.x * C.y - (B.y * C.x + A.y * B.x + A.x * C.y));
for (size_t j=0; j<myPoly.GetCtVectors(); j++) {
for (size_t j = 0; j < myPoly.GetCtVectors(); j++) {
// facet contains a polygon point -> calculate the corresponding 3d-point
if (clFacPoly.Contains(myPoly[j])) {
P = myPoly[j];
fDetPAC = static_cast<float>(A.x*P.y+A.y*C.x+P.x*C.y-(P.y*C.x+A.y*P.x+A.x*C.y));
fDetPBC = static_cast<float>(P.x*B.y+P.y*C.x+B.x*C.y-(B.y*C.x+P.y*B.x+P.x*C.y));
fDetPAB = static_cast<float>(A.x*B.y+A.y*P.x+B.x*P.y-(B.y*P.x+A.y*B.x+A.x*P.y));
fDetPAC = static_cast<float>(A.x * P.y + A.y * C.x + P.x * C.y
- (P.y * C.x + A.y * P.x + A.x * C.y));
fDetPBC = static_cast<float>(P.x * B.y + P.y * C.x + B.x * C.y
- (B.y * C.x + P.y * B.x + P.x * C.y));
fDetPAB = static_cast<float>(A.x * B.y + A.y * P.x + B.x * P.y
- (B.y * P.x + A.y * B.x + A.x * P.y));
u = fDetPBC / fDetABC;
v = fDetPAC / fDetABC;
w = fDetPAB / fDetABC;
// point is on edge or no valid convex combination
if (u == 0.0f || v == 0.0f || w == 0.0f || fabs(u+v+w-1.0f) >= 0.001f)
if (u == 0.0f || v == 0.0f || w == 0.0f || fabs(u + v + w - 1.0f) >= 0.001f) {
return false;
}
// 3d point
clPoint = u*rclFacet._aclPoints[0]+v*rclFacet._aclPoints[1]+w*rclFacet._aclPoints[2];
clPoint = u * rclFacet._aclPoints[0] + v * rclFacet._aclPoints[1]
+ w * rclFacet._aclPoints[2];
return true;
}
@@ -193,29 +209,33 @@ bool MeshTrimming::IsPolygonPointInFacet(FacetIndex ulIndex, Base::Vector3f& clP
return false;
}
bool MeshTrimming::GetIntersectionPointsOfPolygonAndFacet(FacetIndex ulIndex, int& iSide, std::vector<Base::Vector3f>& raclPoints) const
bool MeshTrimming::GetIntersectionPointsOfPolygonAndFacet(
FacetIndex ulIndex,
int& iSide,
std::vector<Base::Vector3f>& raclPoints) const
{
MeshGeomFacet clFac(myMesh.GetFacet(ulIndex));
Base::Vector2d S;
Base::Line2d clFacLine, clPolyLine;
int iIntersections=0;
int iIntsctWithEdge0=0, iIntsctWithEdge1=0, iIntsctWithEdge2=0;
int iIntersections = 0;
int iIntsctWithEdge0 = 0, iIntsctWithEdge1 = 0, iIntsctWithEdge2 = 0;
// Edge with no intersection
iSide = -1;
for (size_t i=0; i<myPoly.GetCtVectors(); i++) {
for (size_t i = 0; i < myPoly.GetCtVectors(); i++) {
// totally only four intersections allowed
if (iIntersections == 4)
if (iIntersections == 4) {
break;
}
Base::Vector2d P3(myPoly[i]), P4(myPoly[(i+1)%myPoly.GetCtVectors()]);
Base::Vector2d P3(myPoly[i]), P4(myPoly[(i + 1) % myPoly.GetCtVectors()]);
clPolyLine.clV1 = P3;
clPolyLine.clV2 = P4;
for (int j=0; j<3; j++) {
for (int j = 0; j < 3; j++) {
Base::Vector3f clP1((*myProj)(clFac._aclPoints[j]));
Base::Vector3f clP2((*myProj)(clFac._aclPoints[(j+1)%3]));
Base::Vector3f clP2((*myProj)(clFac._aclPoints[(j + 1) % 3]));
Base::Vector2d P1(clP1.x, clP1.y);
Base::Vector2d P2(clP2.x, clP2.y);
clFacLine.clV1 = P1;
@@ -230,14 +250,14 @@ bool MeshTrimming::GetIntersectionPointsOfPolygonAndFacet(FacetIndex ulIndex, in
iIntersections++;
}
else if (clPolyLine.Intersect(clFacLine, S)) {
bool bPushBack=true;
float fP1P2 = static_cast<float>((P2-P1).Length());
float fSP1 = static_cast<float>((P1-S).Length());
float fSP2 = static_cast<float>((P2-S).Length());
bool bPushBack = true;
float fP1P2 = static_cast<float>((P2 - P1).Length());
float fSP1 = static_cast<float>((P1 - S).Length());
float fSP2 = static_cast<float>((P2 - S).Length());
float fP3P4 = static_cast<float>((P4-P3).Length());
float fSP3 = static_cast<float>((P3-S).Length());
float fSP4 = static_cast<float>((P4-S).Length());
float fP3P4 = static_cast<float>((P4 - P3).Length());
float fSP3 = static_cast<float>((P3 - S).Length());
float fSP4 = static_cast<float>((P4 - S).Length());
// compute proportion of length
float l = fSP1 / fP1P2;
float m = fSP2 / fP1P2;
@@ -246,62 +266,79 @@ bool MeshTrimming::GetIntersectionPointsOfPolygonAndFacet(FacetIndex ulIndex, in
float s = fSP4 / fP3P4;
// is intersection point convex combination?
if ((fabs(l+m-1.0f) < 0.001f) && (fabs(r+s-1.0f) < 0.001f)) {
Base::Vector3f clIntersection(m*clFac._aclPoints[j]+l*clFac._aclPoints[(j+1)%3]);
if ((fabs(l + m - 1.0f) < 0.001f) && (fabs(r + s - 1.0f) < 0.001f)) {
Base::Vector3f clIntersection(m * clFac._aclPoints[j]
+ l * clFac._aclPoints[(j + 1) % 3]);
iIntersections++;
// only two intersections points per edge allowed
if (j == 0) {
if (iIntsctWithEdge0 == 2)
if (iIntsctWithEdge0 == 2) {
bPushBack = false;
else
}
else {
iIntsctWithEdge0++;
}
}
else if (j == 1) {
if (iIntsctWithEdge1 == 2)
if (iIntsctWithEdge1 == 2) {
bPushBack = false;
else
}
else {
iIntsctWithEdge1++;
}
}
else {
if (iIntsctWithEdge2 == 2)
if (iIntsctWithEdge2 == 2) {
bPushBack = false;
else
}
else {
iIntsctWithEdge2++;
}
}
if (bPushBack)
if (bPushBack) {
raclPoints.push_back(clIntersection);
}
}
}
}
}
// check for rotating facet later
if (iIntsctWithEdge0 == 0)
if (iIntsctWithEdge0 == 0) {
iSide = 0;
else if (iIntsctWithEdge1 == 0)
}
else if (iIntsctWithEdge1 == 0) {
iSide = 1;
else if (iIntsctWithEdge2 == 0)
}
else if (iIntsctWithEdge2 == 0) {
iSide = 2;
}
// further check (for rotating the facet)
if (iIntsctWithEdge0 == 0 && iIntsctWithEdge1 == 0)
if (iIntsctWithEdge0 == 0 && iIntsctWithEdge1 == 0) {
iSide = 1;
else if (iIntsctWithEdge0 == 0 && iIntsctWithEdge2 == 0)
}
else if (iIntsctWithEdge0 == 0 && iIntsctWithEdge2 == 0) {
iSide = 0;
else if (iIntsctWithEdge1 == 0 && iIntsctWithEdge2 == 0)
}
else if (iIntsctWithEdge1 == 0 && iIntsctWithEdge2 == 0) {
iSide = 2;
}
// and last another check
if (iIntsctWithEdge0 * iIntsctWithEdge1 * iIntsctWithEdge2 > 0) {
if (iIntsctWithEdge0 == 2)
if (iIntsctWithEdge0 == 2) {
iSide = 2;
else if (iIntsctWithEdge1 == 2)
}
else if (iIntsctWithEdge1 == 2) {
iSide = 0;
else if (iIntsctWithEdge2 == 2)
}
else if (iIntsctWithEdge2 == 2) {
iSide = 1;
}
}
return iIntersections > 0;
@@ -333,33 +370,40 @@ void MeshTrimming::AdjustFacet(MeshFacet& facet, int iInd)
}
}
bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vector<Base::Vector3f>& raclPoints, std::vector<MeshGeomFacet>& aclNewFacets)
bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos,
int iSide,
const std::vector<Base::Vector3f>& raclPoints,
std::vector<MeshGeomFacet>& aclNewFacets)
{
MeshGeomFacet clFac;
// no valid triangulation possible
if (iSide == -1)
if (iSide == -1) {
return false;
}
// no intersection point found => triangle is only touched at a corner point
if (raclPoints.empty()) {
MeshFacet& facet = myMesh._aclFacetArray[ulFacetPos];
int iCtPtsIn=0;
int iCtPtsOn=0;
int iCtPtsIn = 0;
int iCtPtsOn = 0;
Base::Vector3f clFacPnt;
Base::Vector2d clProjPnt;
for (PointIndex ptIndex : facet._aulPoints) {
clFacPnt = (*myProj)(myMesh._aclPointArray[ptIndex]);
clProjPnt = Base::Vector2d(clFacPnt.x, clFacPnt.y);
if (myPoly.Intersect(clProjPnt, double(MESH_MIN_PT_DIST)))
if (myPoly.Intersect(clProjPnt, double(MESH_MIN_PT_DIST))) {
++iCtPtsOn;
else if (myPoly.Contains(clProjPnt) == myInner)
}
else if (myPoly.Contains(clProjPnt) == myInner) {
++iCtPtsIn;
}
}
// in this case we can use the original triangle
if (iCtPtsIn != (3 - iCtPtsOn))
if (iCtPtsIn != (3 - iCtPtsOn)) {
aclNewFacets.push_back(myMesh.GetFacet(ulFacetPos));
}
}
// one intersection point found => triangle is also touched at a corner point
else if (raclPoints.size() == 1) {
@@ -370,9 +414,9 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
// determine the edge containing the intersection point
Base::Line2d clFacLine;
for (int j=0; j<3; j++) {
for (int j = 0; j < 3; j++) {
Base::Vector3f clP1((*myProj)(clFac._aclPoints[j]));
Base::Vector3f clP2((*myProj)(clFac._aclPoints[(j+1)%3]));
Base::Vector3f clP2((*myProj)(clFac._aclPoints[(j + 1) % 3]));
Base::Vector2d P1(clP1.x, clP1.y);
Base::Vector2d P2(clP2.x, clP2.y);
clFacLine.clV1 = P1;
@@ -382,15 +426,15 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
if (myPoly.Contains(P1) == myInner) {
MeshGeomFacet clNew;
clNew._aclPoints[0] = raclPoints[0];
clNew._aclPoints[1] = clFac._aclPoints[(j+1)%3];
clNew._aclPoints[2] = clFac._aclPoints[(j+2)%3];
clNew._aclPoints[1] = clFac._aclPoints[(j + 1) % 3];
clNew._aclPoints[2] = clFac._aclPoints[(j + 2) % 3];
aclNewFacets.push_back(clNew);
break;
}
else if (myPoly.Contains(P2) == myInner) {
MeshGeomFacet clNew;
clNew._aclPoints[0] = raclPoints[0];
clNew._aclPoints[1] = clFac._aclPoints[(j+2)%3];
clNew._aclPoints[1] = clFac._aclPoints[(j + 2) % 3];
clNew._aclPoints[2] = clFac._aclPoints[j];
aclNewFacets.push_back(clNew);
break;
@@ -411,14 +455,15 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
}
// check which facets can be inserted
int iCtPts=0;
int iCtPts = 0;
Base::Vector3f clFacPnt;
Base::Vector2d clProjPnt;
for (PointIndex ptIndex : facet._aulPoints) {
clFacPnt = (*myProj)(myMesh._aclPointArray[ptIndex]);
clProjPnt = Base::Vector2d(clFacPnt.x, clFacPnt.y);
if (myPoly.Contains(clProjPnt) == myInner)
if (myPoly.Contains(clProjPnt) == myInner) {
++iCtPts;
}
}
if (iCtPts == 2) {
@@ -440,8 +485,9 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
clFac._aclPoints[2] = clP2;
aclNewFacets.push_back(clFac);
}
else
else {
return false;
}
}
// four intersection points found
else if (raclPoints.size() == 4) {
@@ -450,17 +496,19 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
clFac = myMesh.GetFacet(ulFacetPos);
// intersection points
Base::Vector3f clP1(raclPoints[0]), clP2(raclPoints[1]), clP3(raclPoints[2]), clP4(raclPoints[3]);
Base::Vector3f clP1(raclPoints[0]), clP2(raclPoints[1]), clP3(raclPoints[2]),
clP4(raclPoints[3]);
// check which facets can be inserted
int iCtPts=0;
int iCtPts = 0;
Base::Vector3f clFacPnt;
Base::Vector2d clProjPnt;
for (PointIndex ptIndex : facet._aulPoints) {
clFacPnt = (*myProj)(myMesh._aclPointArray[ptIndex]);
clProjPnt = Base::Vector2d(clFacPnt.x, clFacPnt.y);
if (myPoly.Contains(clProjPnt) == myInner)
if (myPoly.Contains(clProjPnt) == myInner) {
++iCtPts;
}
}
// sort the intersection points in a certain order
@@ -473,13 +521,13 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
clP4 = raclPoints[2];
}
if ((clP1-clFac._aclPoints[1]).Length() > (clP3-clFac._aclPoints[1]).Length()) {
if ((clP1 - clFac._aclPoints[1]).Length() > (clP3 - clFac._aclPoints[1]).Length()) {
// swap P1 and P3
Base::Vector3f tmp(clP1);
clP1 = clP3;
clP3 = tmp;
}
if ((clP2-clFac._aclPoints[0]).Length() > (clP4-clFac._aclPoints[0]).Length()) {
if ((clP2 - clFac._aclPoints[0]).Length() > (clP4 - clFac._aclPoints[0]).Length()) {
// swap P2 and P4
Base::Vector3f tmp(clP2);
clP2 = clP4;
@@ -489,8 +537,10 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
else {
if (iSide == 0) {
Base::Vector3f clNormal(clFac.GetNormal());
MeshGeomFacet clTmpFac; clTmpFac._aclPoints[0] = clFac._aclPoints[1];
clTmpFac._aclPoints[1] = clP2; clTmpFac._aclPoints[2] = clP1;
MeshGeomFacet clTmpFac;
clTmpFac._aclPoints[0] = clFac._aclPoints[1];
clTmpFac._aclPoints[1] = clP2;
clTmpFac._aclPoints[2] = clP1;
if (clTmpFac.GetNormal() * clNormal > 0) {
Base::Vector3f tmp(clP1);
clP1 = clP2;
@@ -505,7 +555,7 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
}
}
else if (iSide == 1) {
if ((clP2-clFac._aclPoints[1]).Length() > (clP4-clFac._aclPoints[1]).Length()) {
if ((clP2 - clFac._aclPoints[1]).Length() > (clP4 - clFac._aclPoints[1]).Length()) {
Base::Vector3f tmp(clP1);
clP1 = clP4;
clP4 = tmp;
@@ -523,7 +573,7 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
}
}
else {
if ((clP1-clFac._aclPoints[1]).Length() > (clP3-clFac._aclPoints[1]).Length()) {
if ((clP1 - clFac._aclPoints[1]).Length() > (clP3 - clFac._aclPoints[1]).Length()) {
Base::Vector3f tmp(clP1);
clP1 = clP3;
clP3 = tmp;
@@ -594,18 +644,23 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
aclNewFacets.push_back(clFac);
}
}
else
else {
return false;
}
return true;
}
bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vector<Base::Vector3f>& raclPoints, Base::Vector3f& clP3,
bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos,
int iSide,
const std::vector<Base::Vector3f>& raclPoints,
Base::Vector3f& clP3,
std::vector<MeshGeomFacet>& aclNewFacets)
{
// no valid triangulation possible
if (iSide == -1 || raclPoints.size() < 2)
if (iSide == -1 || raclPoints.size() < 2) {
return false;
}
Base::Vector3f clP1(raclPoints[0]);
Base::Vector3f clP2(raclPoints[1]);
@@ -615,12 +670,12 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
MeshGeomFacet clFac;
float fDistEdgeP1 = clP1.DistanceToLineSegment(
myMesh._aclPointArray[facet._aulPoints[1]],
myMesh._aclPointArray[facet._aulPoints[2]]).Length();
float fDistEdgeP2 = clP2.DistanceToLineSegment(
myMesh._aclPointArray[facet._aulPoints[1]],
myMesh._aclPointArray[facet._aulPoints[2]]).Length();
float fDistEdgeP1 = clP1.DistanceToLineSegment(myMesh._aclPointArray[facet._aulPoints[1]],
myMesh._aclPointArray[facet._aulPoints[2]])
.Length();
float fDistEdgeP2 = clP2.DistanceToLineSegment(myMesh._aclPointArray[facet._aulPoints[1]],
myMesh._aclPointArray[facet._aulPoints[2]])
.Length();
// swap P1 and P2
if (fDistEdgeP2 < fDistEdgeP1) {
@@ -630,18 +685,19 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
}
// check which facets should be inserted
int iCtPts=0;
int iCtPts = 0;
Base::Vector3f clFacPnt;
Base::Vector2d clProjPnt;
for (PointIndex ptIndex : facet._aulPoints) {
clFacPnt = (*myProj)(myMesh._aclPointArray[ptIndex]);
clProjPnt = Base::Vector2d(clFacPnt.x, clFacPnt.y);
if (myPoly.Contains(clProjPnt) == myInner)
if (myPoly.Contains(clProjPnt) == myInner) {
++iCtPts;
}
}
if (iCtPts == 3) {
clFac = myMesh.GetFacet(ulFacetPos);
if ((clP1-clFac._aclPoints[1]).Length() > (clP2-clFac._aclPoints[1]).Length()) {
if ((clP1 - clFac._aclPoints[1]).Length() > (clP2 - clFac._aclPoints[1]).Length()) {
Base::Vector3f tmp(clP1);
clP1 = clP2;
clP2 = tmp;
@@ -683,7 +739,7 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
}
else if (iCtPts == 0) {
clFac = myMesh.GetFacet(ulFacetPos);
if ((clP1-clFac._aclPoints[1]).Length() > (clP2-clFac._aclPoints[1]).Length()) {
if ((clP1 - clFac._aclPoints[1]).Length() > (clP2 - clFac._aclPoints[1]).Length()) {
Base::Vector3f tmp(clP1);
clP1 = clP2;
clP2 = tmp;
@@ -713,7 +769,8 @@ bool MeshTrimming::CreateFacets(FacetIndex ulFacetPos, int iSide, const std::vec
return true;
}
void MeshTrimming::TrimFacets(const std::vector<FacetIndex>& raulFacets, std::vector<MeshGeomFacet>& aclNewFacets)
void MeshTrimming::TrimFacets(const std::vector<FacetIndex>& raulFacets,
std::vector<MeshGeomFacet>& aclNewFacets)
{
Base::Vector3f clP;
std::vector<Base::Vector3f> clIntsct;
@@ -726,15 +783,17 @@ void MeshTrimming::TrimFacets(const std::vector<FacetIndex>& raulFacets, std::ve
// facet must be trimmed
if (!PolygonContainsCompleteFacet(myInner, index)) {
// generate new facets
if (GetIntersectionPointsOfPolygonAndFacet(index, iSide, clIntsct))
if (GetIntersectionPointsOfPolygonAndFacet(index, iSide, clIntsct)) {
CreateFacets(index, iSide, clIntsct, myTriangles);
}
}
}
// facet contains a polygon point
else {
// generate new facets
if (GetIntersectionPointsOfPolygonAndFacet(index, iSide, clIntsct))
if (GetIntersectionPointsOfPolygonAndFacet(index, iSide, clIntsct)) {
CreateFacets(index, iSide, clIntsct, clP, myTriangles);
}
}
seq.next();
}