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

MeshPart: apply clang format

Browse Source
This commit is contained in:
wmayer
2023-09-02 01:36:21 +02:00
committed by wwmayer
parent 226d102906
commit c2bda2f756
16 changed files with 1469 additions and 1246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

748
src/Mod/MeshPart/App/MeshAlgos.cpp
View File

@@ -22,13 +22,13 @@
#include "PreCompiled.h"
#ifndef _PreComp_
# ifdef FC_OS_LINUX
# include <unistd.h>
# endif
#ifdef FC_OS_LINUX
#include <unistd.h>
#endif
#endif
#include <Base/Console.h>
#include <Base/Builder3D.h>
#include <Base/Console.h>
#include <Mod/Mesh/App/Core/Evaluation.h>
#include <Mod/Mesh/App/Core/Iterator.h>
#include <Mod/Mesh/App/Core/MeshKernel.h>
@@ -43,66 +43,74 @@ using namespace MeshCore;
void MeshAlgos::offset(MeshCore::MeshKernel* Mesh, float fSize)
{
std::vector<Base::Vector3f> normals = Mesh->CalcVertexNormals();
std::vector<Base::Vector3f> normals = Mesh->CalcVertexNormals();
unsigned int i = 0;
// go through all the Vertex normals
for(std::vector<Base::Vector3f>::iterator It= normals.begin();It != normals.end();++It,i++)
// and move each mesh point in the normal direction
Mesh->MovePoint(i,It->Normalize() * fSize);
Mesh->RecalcBoundBox();
unsigned int i = 0;
// go through all the Vertex normals
for (std::vector<Base::Vector3f>::iterator It = normals.begin(); It != normals.end();
++It, i++) {
// and move each mesh point in the normal direction
Mesh->MovePoint(i, It->Normalize() * fSize);
}
Mesh->RecalcBoundBox();
}
void MeshAlgos::offsetSpecial2(MeshCore::MeshKernel* Mesh, float fSize)
{
Base::Builder3D builder;
std::vector<Base::Vector3f> PointNormals= Mesh->CalcVertexNormals();
std::vector<Base::Vector3f> PointNormals = Mesh->CalcVertexNormals();
std::vector<Base::Vector3f> FaceNormals;
std::set<MeshCore::FacetIndex> fliped;
MeshFacetIterator it(*Mesh);
for ( it.Init(); it.More(); it.Next() )
for (it.Init(); it.More(); it.Next()) {
FaceNormals.push_back(it->GetNormal().Normalize());
}
unsigned int i = 0;
// go through all the Vertex normals
for(std::vector<Base::Vector3f>::iterator It= PointNormals.begin();It != PointNormals.end();++It,i++) {
Base::Line3f line{Mesh->GetPoint(i), Mesh->GetPoint(i) + It->Normalize() * fSize};
for (std::vector<Base::Vector3f>::iterator It = PointNormals.begin(); It != PointNormals.end();
++It, i++) {
Base::Line3f line {Mesh->GetPoint(i), Mesh->GetPoint(i) + It->Normalize() * fSize};
Base::DrawStyle drawStyle;
builder.addNode(Base::LineItem{line, drawStyle});
builder.addNode(Base::LineItem {line, drawStyle});
// and move each mesh point in the normal direction
Mesh->MovePoint(i,It->Normalize() * fSize);
Mesh->MovePoint(i, It->Normalize() * fSize);
}
Mesh->RecalcBoundBox();
MeshTopoAlgorithm alg(*Mesh);
for(int l= 0; l<1 ;l++){
for ( it.Init(),i=0; it.More(); it.Next(),i++ )
{
if(it->IsFlag(MeshFacet::INVALID))
for (int l = 0; l < 1; l++) {
for (it.Init(), i = 0; it.More(); it.Next(), i++) {
if (it->IsFlag(MeshFacet::INVALID)) {
continue;
}
// calculate the angle between them
float angle = acos((FaceNormals[i] * it->GetNormal()) / (it->GetNormal().Length() * FaceNormals[i].Length()));
if (angle > 1.6){
float angle = acos((FaceNormals[i] * it->GetNormal())
/ (it->GetNormal().Length() * FaceNormals[i].Length()));
if (angle > 1.6) {
Base::DrawStyle drawStyle;
drawStyle.pointSize = 4.0F;
Base::PointItem item{it->GetGravityPoint(), drawStyle, Base::ColorRGB{1.0F, 0.0F, 0.0F}};
Base::PointItem item {it->GetGravityPoint(),
drawStyle,
Base::ColorRGB {1.0F, 0.0F, 0.0F}};
builder.addNode(item);
fliped.insert(it.Position());
}
}
// if there are no flipped triangles -> stop
//int f =fliped.size();
if(fliped.empty())
// int f =fliped.size();
if (fliped.empty()) {
break;
}
for(MeshCore::FacetIndex It : fliped)
for (MeshCore::FacetIndex It : fliped) {
alg.CollapseFacet(It);
}
fliped.clear();
}
@@ -110,56 +118,59 @@ void MeshAlgos::offsetSpecial2(MeshCore::MeshKernel* Mesh, float fSize)
// search for intersected facets
MeshCore::MeshEvalSelfIntersection eval(*Mesh);
std::vector<std::pair<MeshCore::FacetIndex, MeshCore::FacetIndex> > faces;
std::vector<std::pair<MeshCore::FacetIndex, MeshCore::FacetIndex>> faces;
eval.GetIntersections(faces);
builder.saveToLog();
}
void MeshAlgos::offsetSpecial(MeshCore::MeshKernel* Mesh, float fSize, float zmax, float zmin)
{
std::vector<Base::Vector3f> normals = Mesh->CalcVertexNormals();
std::vector<Base::Vector3f> normals = Mesh->CalcVertexNormals();
unsigned int i = 0;
// go through all the Vertex normals
for(std::vector<Base::Vector3f>::iterator It= normals.begin();It != normals.end();++It,i++)
{
Base::Vector3f Pnt = Mesh->GetPoint(i);
unsigned int i = 0;
// go through all the Vertex normals
for (std::vector<Base::Vector3f>::iterator It = normals.begin(); It != normals.end();
++It, i++) {
Base::Vector3f Pnt = Mesh->GetPoint(i);
if(Pnt.z < zmax && Pnt.z > zmin)
{
Pnt.z = 0;
Mesh->MovePoint(i,Pnt.Normalize() * fSize);
}else
// and move each mesh point in the normal direction
Mesh->MovePoint(i,It->Normalize() * fSize);
}
if (Pnt.z < zmax && Pnt.z > zmin) {
Pnt.z = 0;
Mesh->MovePoint(i, Pnt.Normalize() * fSize);
}
else {
// and move each mesh point in the normal direction
Mesh->MovePoint(i, It->Normalize() * fSize);
}
}
}
void MeshAlgos::coarsen(MeshCore::MeshKernel* /*Mesh*/, float /*f*/)
{
#ifdef FC_USE_GTS
GtsSurface * surface;
GtsSurface* surface;
// create a GTS surface
surface = MeshAlgos::createGTSSurface(Mesh);
// create a GTS surface
surface = MeshAlgos::createGTSSurface(Mesh);
Mesh->Clear();
Mesh->Clear();
guint stop_number=100000;
gdouble fold = 3.1415 / 180.;
guint stop_number = 100000;
gdouble fold = 3.1415 / 180.;
gts_surface_coarsen (surface,
NULL, NULL,
NULL, NULL,
(GtsStopFunc)gts_coarsen_stop_number,
&stop_number, fold);
gts_surface_coarsen(surface,
NULL,
NULL,
NULL,
NULL,
(GtsStopFunc)gts_coarsen_stop_number,
&stop_number,
fold);
// get the standard mesh
fillMeshFromGTSSurface(Mesh,surface);
// get the standard mesh
fillMeshFromGTSSurface(Mesh, surface);
#endif
}
@@ -170,143 +181,142 @@ MeshCore::MeshKernel* MeshAlgos::boolean(MeshCore::MeshKernel* pMesh1,
int /*Type*/)
{
#ifdef FC_USE_GTS
GtsSurface * s1, * s2, * s3;
GtsSurfaceInter * si;
GNode * tree1, * tree2;
gboolean check_self_intersection = false;
gboolean closed = true, is_open1, is_open2;
GtsSurface *s1, *s2, *s3;
GtsSurfaceInter* si;
GNode *tree1, *tree2;
gboolean check_self_intersection = false;
gboolean closed = true, is_open1, is_open2;
// create a GTS surface
s1 = MeshAlgos::createGTSSurface(pMesh1);
s2 = MeshAlgos::createGTSSurface(pMesh2);
// create a GTS surface
s1 = MeshAlgos::createGTSSurface(pMesh1);
s2 = MeshAlgos::createGTSSurface(pMesh2);
// clear the mesh (memory)
//Mesh1.clear();
//Mesh2.clear();
// clear the mesh (memory)
// Mesh1.clear();
// Mesh2.clear();
/* check that the surfaces are orientable manifolds */
if (!gts_surface_is_orientable (s1)) {
gts_object_destroy (GTS_OBJECT (s1));
gts_object_destroy (GTS_OBJECT (s2));
throw std::runtime_error("surface 1 is not an orientable manifold\n");
}
if (!gts_surface_is_orientable (s2)) {
gts_object_destroy (GTS_OBJECT (s1));
gts_object_destroy (GTS_OBJECT (s2));
throw std::runtime_error("surface 2 is not an orientable manifold\n");
}
/* check that the surfaces are not self-intersecting */
if (check_self_intersection) {
GtsSurface * self_intersects;
self_intersects = gts_surface_is_self_intersecting (s1);
if (self_intersects != NULL) {
// if (verbose)
// gts_surface_print_stats (self_intersects, stderr);
// gts_surface_write (self_intersects, stdout);
gts_object_destroy (GTS_OBJECT (self_intersects));
gts_object_destroy (GTS_OBJECT (s1));
gts_object_destroy (GTS_OBJECT (s2));
throw std::runtime_error("surface is self-intersecting\n");
/* check that the surfaces are orientable manifolds */
if (!gts_surface_is_orientable(s1)) {
gts_object_destroy(GTS_OBJECT(s1));
gts_object_destroy(GTS_OBJECT(s2));
throw std::runtime_error("surface 1 is not an orientable manifold\n");
}
self_intersects = gts_surface_is_self_intersecting (s2);
if (self_intersects != NULL) {
// if (verbose)
// gts_surface_print_stats (self_intersects, stderr);
// gts_surface_write (self_intersects, stdout);
gts_object_destroy (GTS_OBJECT (self_intersects));
gts_object_destroy (GTS_OBJECT (s1));
gts_object_destroy (GTS_OBJECT (s2));
throw std::runtime_error("surface is self-intersecting\n");
if (!gts_surface_is_orientable(s2)) {
gts_object_destroy(GTS_OBJECT(s1));
gts_object_destroy(GTS_OBJECT(s2));
throw std::runtime_error("surface 2 is not an orientable manifold\n");
}
}
/* build bounding box tree for first surface */
tree1 = gts_bb_tree_surface (s1);
is_open1 = gts_surface_volume (s1) < 0. ? true : false;
/* check that the surfaces are not self-intersecting */
if (check_self_intersection) {
GtsSurface* self_intersects;
/* build bounding box tree for second surface */
tree2 = gts_bb_tree_surface (s2);
is_open2 = gts_surface_volume (s2) < 0. ? true : false;
si = gts_surface_inter_new (gts_surface_inter_class (),
s1, s2, tree1, tree2, is_open1, is_open2);
g_assert (gts_surface_inter_check (si, &closed));
if (!closed) {
gts_object_destroy (GTS_OBJECT (s1));
gts_object_destroy (GTS_OBJECT (s2));
gts_bb_tree_destroy (tree1, true);
gts_bb_tree_destroy (tree2, true);
throw"the intersection of 1 and 2 is not a closed curve\n";
}
s3 = gts_surface_new (gts_surface_class (),
gts_face_class (),
gts_edge_class (),
gts_vertex_class ());
if (Type==0) { // union
gts_surface_inter_boolean (si, s3, GTS_1_OUT_2);
gts_surface_inter_boolean (si, s3, GTS_2_OUT_1);
}
else if (Type==1) { // inter
gts_surface_inter_boolean (si, s3, GTS_1_IN_2);
gts_surface_inter_boolean (si, s3, GTS_2_IN_1);
}
else if (Type==2) { //diff
gts_surface_inter_boolean (si, s3, GTS_1_OUT_2);
gts_surface_inter_boolean (si, s3, GTS_2_IN_1);
gts_surface_foreach_face (si->s2, (GtsFunc) gts_triangle_revert, NULL);
gts_surface_foreach_face (s2, (GtsFunc) gts_triangle_revert, NULL);
}
else if (Type==3) { // cut inner
gts_surface_inter_boolean (si, s3, GTS_1_IN_2);
}
else if (Type==4) { // cut outer
gts_surface_inter_boolean (si, s3, GTS_1_OUT_2);
}
// check that the resulting surface is not self-intersecting
if (check_self_intersection) {
GtsSurface * self_intersects;
self_intersects = gts_surface_is_self_intersecting (s3);
if (self_intersects != NULL) {
// if (verbose)
// gts_surface_print_stats (self_intersects, stderr);
// gts_surface_write (self_intersects, stdout);
gts_object_destroy (GTS_OBJECT (self_intersects));
gts_object_destroy (GTS_OBJECT (s1));
gts_object_destroy (GTS_OBJECT (s2));
gts_object_destroy (GTS_OBJECT (s3));
gts_object_destroy (GTS_OBJECT (si));
gts_bb_tree_destroy (tree1, true);
gts_bb_tree_destroy (tree2, true);
throw std::runtime_error("the resulting surface is self-intersecting\n");
self_intersects = gts_surface_is_self_intersecting(s1);
if (self_intersects != NULL) {
// if (verbose)
// gts_surface_print_stats (self_intersects, stderr);
// gts_surface_write (self_intersects, stdout);
gts_object_destroy(GTS_OBJECT(self_intersects));
gts_object_destroy(GTS_OBJECT(s1));
gts_object_destroy(GTS_OBJECT(s2));
throw std::runtime_error("surface is self-intersecting\n");
}
self_intersects = gts_surface_is_self_intersecting(s2);
if (self_intersects != NULL) {
// if (verbose)
// gts_surface_print_stats (self_intersects, stderr);
// gts_surface_write (self_intersects, stdout);
gts_object_destroy(GTS_OBJECT(self_intersects));
gts_object_destroy(GTS_OBJECT(s1));
gts_object_destroy(GTS_OBJECT(s2));
throw std::runtime_error("surface is self-intersecting\n");
}
}
}
// display summary information about the resulting surface
// if (verbose)
// gts_surface_print_stats (s3, stderr);
// write resulting surface to standard output
// get the standard mesh
fillMeshFromGTSSurface(pResult,s3);
/* build bounding box tree for first surface */
tree1 = gts_bb_tree_surface(s1);
is_open1 = gts_surface_volume(s1) < 0. ? true : false;
/* build bounding box tree for second surface */
tree2 = gts_bb_tree_surface(s2);
is_open2 = gts_surface_volume(s2) < 0. ? true : false;
si = gts_surface_inter_new(gts_surface_inter_class(), s1, s2, tree1, tree2, is_open1, is_open2);
g_assert(gts_surface_inter_check(si, &closed));
if (!closed) {
gts_object_destroy(GTS_OBJECT(s1));
gts_object_destroy(GTS_OBJECT(s2));
gts_bb_tree_destroy(tree1, true);
gts_bb_tree_destroy(tree2, true);
throw "the intersection of 1 and 2 is not a closed curve\n";
}
s3 = gts_surface_new(gts_surface_class(),
gts_face_class(),
gts_edge_class(),
gts_vertex_class());
if (Type == 0) {// union
gts_surface_inter_boolean(si, s3, GTS_1_OUT_2);
gts_surface_inter_boolean(si, s3, GTS_2_OUT_1);
}
else if (Type == 1) {// inter
gts_surface_inter_boolean(si, s3, GTS_1_IN_2);
gts_surface_inter_boolean(si, s3, GTS_2_IN_1);
}
else if (Type == 2) {// diff
gts_surface_inter_boolean(si, s3, GTS_1_OUT_2);
gts_surface_inter_boolean(si, s3, GTS_2_IN_1);
gts_surface_foreach_face(si->s2, (GtsFunc)gts_triangle_revert, NULL);
gts_surface_foreach_face(s2, (GtsFunc)gts_triangle_revert, NULL);
}
else if (Type == 3) {// cut inner
gts_surface_inter_boolean(si, s3, GTS_1_IN_2);
}
else if (Type == 4) {// cut outer
gts_surface_inter_boolean(si, s3, GTS_1_OUT_2);
}
// check that the resulting surface is not self-intersecting
if (check_self_intersection) {
GtsSurface* self_intersects;
self_intersects = gts_surface_is_self_intersecting(s3);
if (self_intersects != NULL) {
// if (verbose)
// gts_surface_print_stats (self_intersects, stderr);
// gts_surface_write (self_intersects, stdout);
gts_object_destroy(GTS_OBJECT(self_intersects));
gts_object_destroy(GTS_OBJECT(s1));
gts_object_destroy(GTS_OBJECT(s2));
gts_object_destroy(GTS_OBJECT(s3));
gts_object_destroy(GTS_OBJECT(si));
gts_bb_tree_destroy(tree1, true);
gts_bb_tree_destroy(tree2, true);
throw std::runtime_error("the resulting surface is self-intersecting\n");
}
}
// display summary information about the resulting surface
// if (verbose)
// gts_surface_print_stats (s3, stderr);
// write resulting surface to standard output
// get the standard mesh
fillMeshFromGTSSurface(pResult, s3);
// destroy surfaces
gts_object_destroy (GTS_OBJECT (s1));
gts_object_destroy (GTS_OBJECT (s2));
// gts_object_destroy (GTS_OBJECT (s3));
// gts_object_destroy (GTS_OBJECT (si));
// destroy surfaces
gts_object_destroy(GTS_OBJECT(s1));
gts_object_destroy(GTS_OBJECT(s2));
// gts_object_destroy (GTS_OBJECT (s3));
// gts_object_destroy (GTS_OBJECT (si));
// destroy bounding box trees (including bounding boxes)
// gts_bb_tree_destroy (tree1, true);
// gts_bb_tree_destroy (tree2, true);
// destroy bounding box trees (including bounding boxes)
// gts_bb_tree_destroy (tree1, true);
// gts_bb_tree_destroy (tree2, true);
#endif
return pMesh1;
return pMesh1;
}
@@ -314,70 +324,70 @@ MeshCore::MeshKernel* MeshAlgos::boolean(MeshCore::MeshKernel* pMesh1,
/// helper function - construct a Edge out of two Vertexes if not already there
static GtsEdge * new_edge (GtsVertex * v1, GtsVertex * v2)
static GtsEdge* new_edge(GtsVertex* v1, GtsVertex* v2)
{
GtsSegment * s = gts_vertices_are_connected (v1, v2);
if( s == NULL )
return gts_edge_new (gts_edge_class (), v1, v2);
else
return GTS_EDGE (s);
GtsSegment* s = gts_vertices_are_connected(v1, v2);
if (s == NULL) {
return gts_edge_new(gts_edge_class(), v1, v2);
}
else {
return GTS_EDGE(s);
}
}
GtsSurface* MeshAlgos::createGTSSurface(MeshCore::MeshKernel* Mesh)
{
GtsSurface* Surf = gts_surface_new (gts_surface_class (),
gts_face_class (),
gts_edge_class (),
gts_vertex_class () );
GtsSurface* Surf = gts_surface_new(gts_surface_class(),
gts_face_class(),
gts_edge_class(),
gts_vertex_class());
unsigned long p1,p2,p3;
Base::Vector3f Vertex;
unsigned long p1, p2, p3;
Base::Vector3f Vertex;
// Getting all the points
GtsVertex ** aVertex = (GtsVertex **) malloc(Mesh->CountPoints() * sizeof (GtsVertex *));
for (unsigned int PIter = 0;PIter < Mesh->CountPoints(); PIter++)
{
Vertex = Mesh->GetPoint(PIter);
aVertex[PIter] = gts_vertex_new (gts_vertex_class (), Vertex.x, Vertex.y, Vertex.z);
}
// Getting all the points
GtsVertex** aVertex = (GtsVertex**)malloc(Mesh->CountPoints() * sizeof(GtsVertex*));
for (unsigned int PIter = 0; PIter < Mesh->CountPoints(); PIter++) {
Vertex = Mesh->GetPoint(PIter);
aVertex[PIter] = gts_vertex_new(gts_vertex_class(), Vertex.x, Vertex.y, Vertex.z);
}
// cycling through the facets
for (unsigned int pFIter = 0;pFIter < Mesh->CountFacets(); pFIter++)
{
// getting the three points of the facet
Mesh->GetFacetPoints(pFIter,p1,p2,p3);
for (unsigned int pFIter = 0; pFIter < Mesh->CountFacets(); pFIter++) {
// getting the three points of the facet
Mesh->GetFacetPoints(pFIter, p1, p2, p3);
// creating the edges and add the face to the surface
gts_surface_add_face (Surf,
gts_face_new (Surf->face_class,
new_edge (aVertex[p1],aVertex[p2]),
new_edge (aVertex[p2],aVertex[p3]),
new_edge (aVertex[p3],aVertex[p1])));
}
// creating the edges and add the face to the surface
gts_surface_add_face(Surf,
gts_face_new(Surf->face_class,
new_edge(aVertex[p1], aVertex[p2]),
new_edge(aVertex[p2], aVertex[p3]),
new_edge(aVertex[p3], aVertex[p1])));
}
Base::Console().Log("GTS [%d faces, %d Points, %d Edges,%s ,%s]\n",gts_surface_face_number(Surf),
gts_surface_vertex_number(Surf),
gts_surface_edge_number(Surf),
gts_surface_is_orientable (Surf)?"orientable":"not orientable",
gts_surface_is_self_intersecting(Surf)?"self-intersections":"no self-intersection" );
return Surf;
Base::Console().Log("GTS [%d faces, %d Points, %d Edges,%s ,%s]\n",
gts_surface_face_number(Surf),
gts_surface_vertex_number(Surf),
gts_surface_edge_number(Surf),
gts_surface_is_orientable(Surf) ? "orientable" : "not orientable",
gts_surface_is_self_intersecting(Surf) ? "self-intersections"
: "no self-intersection");
return Surf;
}
/// helper function for the face (triangle iteration
static void onFaces (GtsTriangle * t, std::vector<MeshGeomFacet> *VAry )
static void onFaces(GtsTriangle* t, std::vector<MeshGeomFacet>* VAry)
{
GtsVertex *mv0,*mv1,*mv2;
GtsVertex *mv0, *mv1, *mv2;
gts_triangle_vertices (t,&mv0,&mv1,&mv2);
VAry->push_back(MeshGeomFacet(Base::Vector3f(mv0->p.x,mv0->p.y,mv0->p.z),
Base::Vector3f(mv1->p.x,mv1->p.y,mv1->p.z),
Base::Vector3f(mv2->p.x,mv2->p.y,mv2->p.z)));
gts_triangle_vertices(t, &mv0, &mv1, &mv2);
VAry->push_back(MeshGeomFacet(Base::Vector3f(mv0->p.x, mv0->p.y, mv0->p.z),
Base::Vector3f(mv1->p.x, mv1->p.y, mv1->p.z),
Base::Vector3f(mv2->p.x, mv2->p.y, mv2->p.z)));
}
/*
@@ -388,55 +398,54 @@ static void onVertices(GtsVertex *v, MeshKernel *pKernel )
void MeshAlgos::fillMeshFromGTSSurface(MeshCore::MeshKernel* pMesh, GtsSurface* pSurface)
{
std::vector<MeshGeomFacet> VAry;
std::vector<MeshGeomFacet> VAry;
// remove old mesh
pMesh->Clear();
// remove old mesh
pMesh->Clear();
// gts_surface_foreach_vertex(pSurface,(GtsFunc) onVertices,&MeshK);
gts_surface_foreach_face (pSurface, (GtsFunc) onFaces,&VAry);
// gts_surface_foreach_vertex(pSurface,(GtsFunc) onVertices,&MeshK);
gts_surface_foreach_face(pSurface, (GtsFunc)onFaces, &VAry);
// destroy surfaces
gts_object_destroy (GTS_OBJECT (pSurface));
// put the facets the simple way in the mesh, totp is recalculated!
(*pMesh) = VAry;
// destroy surfaces
gts_object_destroy(GTS_OBJECT(pSurface));
// put the facets the simple way in the mesh, totp is recalculated!
(*pMesh) = VAry;
}
#endif
#include <TopExp_Explorer.hxx>
#include <TopExp.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
#include <TopoDS.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Plane.hxx>
#include <BRep_Tool.hxx>
#include <GeomAPI_IntCS.hxx>
#include <GeomLProp_CLProps.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Plane.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
void MeshAlgos::cutByShape(const TopoDS_Shape &aShape,const MeshCore::MeshKernel* pMesh,MeshCore::MeshKernel* pToolMesh)
void MeshAlgos::cutByShape(const TopoDS_Shape& aShape,
const MeshCore::MeshKernel* pMesh,
MeshCore::MeshKernel* pToolMesh)
{
// calculate the projection for each Edge
// CurveProjectorShape Project(aShape,*pMesh);
CurveProjectorWithToolMesh Project(aShape,*pMesh,*pToolMesh);
//IntersectionLine Lines;
// MeshWithProperty *ResultMesh = new MeshWithProperty();
// boolean(pMesh,ToolMesh,ResultMesh,1);
// calculate the projection for each Edge
// CurveProjectorShape Project(aShape,*pMesh);
CurveProjectorWithToolMesh Project(aShape, *pMesh, *pToolMesh);
// IntersectionLine Lines;
// MeshWithProperty *ResultMesh = new MeshWithProperty();
// boolean(pMesh,ToolMesh,ResultMesh,1);
}
/*
void MeshAlgos::doIntersection(const MeshWithProperty &pMesh,const MeshWithProperty ToolMesh,IntersectionLine &Lines)
void MeshAlgos::doIntersection(const MeshWithProperty &pMesh,const MeshWithProperty
ToolMesh,IntersectionLine &Lines)
{
@@ -444,140 +453,145 @@ void MeshAlgos::doIntersection(const MeshWithProperty &pMesh,const MeshWithPrope
*/
void MeshAlgos::cutByCurve(MeshCore::MeshKernel* pMesh,const std::vector<CurveProjector::FaceSplitEdge> &vSplitEdges)
void MeshAlgos::cutByCurve(MeshCore::MeshKernel* pMesh,
const std::vector<CurveProjector::FaceSplitEdge>& vSplitEdges)
{
MeshTopoAlgorithm cTopAlg(*pMesh);
MeshTopoAlgorithm cTopAlg(*pMesh);
for (const auto & it : vSplitEdges)
{
cTopAlg.SplitFacet( it.ulFaceIndex, it.p1, it.p2 );
}
for (const auto& it : vSplitEdges) {
cTopAlg.SplitFacet(it.ulFaceIndex, it.p1, it.p2);
}
}
class _VertexCompare
{
public:
bool operator () (const TopoDS_Vertex &rclV1, const TopoDS_Vertex &rclV2) const
public:
bool operator()(const TopoDS_Vertex& rclV1, const TopoDS_Vertex& rclV2) const
{
if (rclV1.IsSame(rclV2) == Standard_True)
return false;
if (rclV1.IsSame(rclV2) == Standard_True) {
return false;
}
gp_XYZ clP1 = BRep_Tool::Pnt(rclV1).XYZ();
gp_XYZ clP2 = BRep_Tool::Pnt(rclV2).XYZ();
gp_XYZ clP1 = BRep_Tool::Pnt(rclV1).XYZ();
gp_XYZ clP2 = BRep_Tool::Pnt(rclV2).XYZ();
if (fabs(clP1.X() - clP2.X()) < dE)
{
if (fabs(clP1.Y() - clP2.Y()) < dE)
return clP1.Z() < clP2.Z();
else
return clP1.Y() < clP2.Y();
}
else
return clP1.X() < clP2.X();
if (fabs(clP1.X() - clP2.X()) < dE) {
if (fabs(clP1.Y() - clP2.Y()) < dE) {
return clP1.Z() < clP2.Z();
}
else {
return clP1.Y() < clP2.Y();
}
}
else {
return clP1.X() < clP2.X();
}
}
double dE = 1.0e-5;
};
void MeshAlgos::LoftOnCurve(MeshCore::MeshKernel &ResultMesh, const TopoDS_Shape &Shape, const std::vector<Base::Vector3f> &poly, const Base::Vector3f & up, float MaxSize)
void MeshAlgos::LoftOnCurve(MeshCore::MeshKernel& ResultMesh,
const TopoDS_Shape& Shape,
const std::vector<Base::Vector3f>& poly,
const Base::Vector3f& up,
float MaxSize)
{
TopExp_Explorer Ex;
Standard_Real fBegin, fEnd;
std::vector<MeshGeomFacet> cVAry;
std::map<TopoDS_Vertex,std::vector<Base::Vector3f>,_VertexCompare> ConnectMap;
TopExp_Explorer Ex;
Standard_Real fBegin, fEnd;
std::vector<MeshGeomFacet> cVAry;
std::map<TopoDS_Vertex, std::vector<Base::Vector3f>, _VertexCompare> ConnectMap;
for (Ex.Init(Shape, TopAbs_EDGE); Ex.More(); Ex.Next())
{
// get the edge and the belonging Vertexes
TopoDS_Edge Edge = (TopoDS_Edge&)Ex.Current();
TopoDS_Vertex V1, V2;
TopExp::Vertices(Edge, V1, V2);
bool bBegin = false,bEnd = false;
// getting the geometric curve and the interval
GeomLProp_CLProps prop(BRep_Tool::Curve(Edge,fBegin,fEnd),1,0.0000000001);
int res = int((fEnd - fBegin)/MaxSize);
// do at least 2 segments
if(res < 2)
res = 2;
gp_Dir Tangent;
std::vector<Base::Vector3f> prePoint(poly.size());
std::vector<Base::Vector3f> actPoint(poly.size());
// checking if there is already a end to connect
if(ConnectMap.find(V1) != ConnectMap.end() ){
bBegin = true;
prePoint = ConnectMap[V1];
}
if(ConnectMap.find(V2) != ConnectMap.end() )
bEnd = true;
for (long i = 0; i < res; i++)
{
// get point and tangent at the position, up is fix for the moment
prop.SetParameter(fBegin + ((fEnd - fBegin) * float(i)) / float(res-1));
prop.Tangent(Tangent);
Base::Vector3f Tng((float)Tangent.X(),
(float)Tangent.Y(),
(float)Tangent.Z());
Base::Vector3f Ptn((float)prop.Value().X(),
(float)prop.Value().Y(),
(float)prop.Value().Z());
Base::Vector3f Up (up);
// normalize and calc the third vector of the plane coordinatesystem
Tng.Normalize();
Up.Normalize();
Base::Vector3f Third(Tng%Up);
// Base::Console().Log("Pos: %f %f %f \n",Ptn.x,Ptn.y,Ptn.z);
unsigned int l=0;
std::vector<Base::Vector3f>::const_iterator It;
// got through the profile
for(It=poly.begin();It!=poly.end();++It,l++)
actPoint[l] = ((Third*It->x)+(Up*It->y)+(Tng*It->z)+Ptn);
if(i == res-1 && !bEnd)
// remember the last row to connect to a otger edge with the same vertex
ConnectMap[V2] = actPoint;
if(i==1 && bBegin)
// using the end of an other edge as start
prePoint = ConnectMap[V1];
if(i==0 && !bBegin)
// remember the first row for connection to a edge with the same vertex
ConnectMap[V1] = actPoint;
if(i ) // not the first row or something to connect to
{
for(l=0;l<actPoint.size();l++)
{
if(l) // not first point in row
{
if(i == res-1 && bEnd) // if last row and a end to connect
actPoint = ConnectMap[V2];
Base::Vector3f p1 = prePoint[l-1],
p2 = actPoint[l-1],
p3 = prePoint[l],
p4 = actPoint[l];
cVAry.emplace_back(p1,p2,p3);
cVAry.emplace_back(p3,p2,p4);
}
for (Ex.Init(Shape, TopAbs_EDGE); Ex.More(); Ex.Next()) {
// get the edge and the belonging Vertexes
TopoDS_Edge Edge = (TopoDS_Edge&)Ex.Current();
TopoDS_Vertex V1, V2;
TopExp::Vertices(Edge, V1, V2);
bool bBegin = false, bEnd = false;
// getting the geometric curve and the interval
GeomLProp_CLProps prop(BRep_Tool::Curve(Edge, fBegin, fEnd), 1, 0.0000000001);
int res = int((fEnd - fBegin) / MaxSize);
// do at least 2 segments
if (res < 2) {
res = 2;
}
}
gp_Dir Tangent;
prePoint = actPoint;
std::vector<Base::Vector3f> prePoint(poly.size());
std::vector<Base::Vector3f> actPoint(poly.size());
// checking if there is already a end to connect
if (ConnectMap.find(V1) != ConnectMap.end()) {
bBegin = true;
prePoint = ConnectMap[V1];
}
if (ConnectMap.find(V2) != ConnectMap.end()) {
bEnd = true;
}
for (long i = 0; i < res; i++) {
// get point and tangent at the position, up is fix for the moment
prop.SetParameter(fBegin + ((fEnd - fBegin) * float(i)) / float(res - 1));
prop.Tangent(Tangent);
Base::Vector3f Tng((float)Tangent.X(), (float)Tangent.Y(), (float)Tangent.Z());
Base::Vector3f Ptn((float)prop.Value().X(),
(float)prop.Value().Y(),
(float)prop.Value().Z());
Base::Vector3f Up(up);
// normalize and calc the third vector of the plane coordinatesystem
Tng.Normalize();
Up.Normalize();
Base::Vector3f Third(Tng % Up);
// Base::Console().Log("Pos: %f %f %f \n",Ptn.x,Ptn.y,Ptn.z);
unsigned int l = 0;
std::vector<Base::Vector3f>::const_iterator It;
// got through the profile
for (It = poly.begin(); It != poly.end(); ++It, l++) {
actPoint[l] = ((Third * It->x) + (Up * It->y) + (Tng * It->z) + Ptn);
}
if (i == res - 1 && !bEnd) {
// remember the last row to connect to a otger edge with the same vertex
ConnectMap[V2] = actPoint;
}
if (i == 1 && bBegin) {
// using the end of an other edge as start
prePoint = ConnectMap[V1];
}
if (i == 0 && !bBegin) {
// remember the first row for connection to a edge with the same vertex
ConnectMap[V1] = actPoint;
}
if (i)// not the first row or something to connect to
{
for (l = 0; l < actPoint.size(); l++) {
if (l)// not first point in row
{
if (i == res - 1 && bEnd) {// if last row and a end to connect
actPoint = ConnectMap[V2];
}
Base::Vector3f p1 = prePoint[l - 1], p2 = actPoint[l - 1], p3 = prePoint[l],
p4 = actPoint[l];
cVAry.emplace_back(p1, p2, p3);
cVAry.emplace_back(p3, p2, p4);
}
}
}
prePoint = actPoint;
}
}
}
ResultMesh.AddFacets(cVAry);
ResultMesh.AddFacets(cVAry);
}