Skip to content

Commit 1939a56

Browse files
kleinsimontpaviot
kleinsimon
authored and
tpaviot
committed
implemented numpy interface for MeshDataSource init
1 parent 76ef642 commit 1939a56

4 files changed

Lines changed: 3200 additions & 3 deletions

File tree

‎src/MeshDataSource/MeshDataSource.cpp‎

Lines changed: 148 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -15,14 +15,70 @@ MeshDS_DataSource::MeshDS_DataSource(std::vector<gp_Pnt>& CoordData, std::vector
1515
InitializeFromData(CoordData, Ele2NodeData);
1616
}
1717

18+
19+
MeshDS_DataSource::MeshDS_DataSource(double* Vertices, const int nVerts1, const int nVerts2, int* Faces, const int nFaces1, const int nFaces2)
20+
{
21+
/*
22+
if (nVerts2 != 3 || nFaces2 != 3) {
23+
throw std::invalid_argument("Nx3 array must be provided");
24+
}
25+
26+
std::vector<gp_Pnt> CoordData;
27+
CoordData.resize(nVerts1);
28+
size_t vertIDX = 0;
29+
30+
for (size_t vertID = 0; vertID < nVerts1; vertID++)
31+
{
32+
CoordData[vertID] = gp_Pnt(Vertices[vertIDX], Vertices[vertIDX + 1], Vertices[vertIDX + 2]);
33+
vertIDX += 3;
34+
}
35+
36+
std::vector<std::vector<int>> FVec;
37+
FVec.resize(nFaces1);
38+
size_t faceIDX = 0;
39+
40+
for (size_t faceID = 0; faceID < nFaces1; faceID++)
41+
{
42+
FVec[faceID] = std::vector<int>{ Faces[faceIDX], Faces[faceIDX + 1] ,Faces[faceIDX + 2] };
43+
faceIDX += 3;
44+
}
45+
46+
InitializeFromData(CoordData, FVec);
47+
*/
48+
49+
InitializeFromData(Vertices, nVerts1, nVerts2, Faces, nFaces1, nFaces2);
50+
}
51+
52+
53+
MeshDS_DataSource::MeshDS_DataSource(double Vertices[][3], int Faces[][3])
54+
{
55+
//size_t nVerts = Vertices.size();
56+
const size_t nVerts = sizeof Vertices / 3;
57+
std::vector<gp_Pnt> CoordData;
58+
CoordData.resize(nVerts);
59+
60+
for (size_t vertID = 0; vertID < nVerts; vertID++)
61+
{
62+
CoordData[vertID] = gp_Pnt(Vertices[vertID][0], Vertices[vertID][1], Vertices[vertID][2]);
63+
}
64+
65+
std::vector<std::vector<int>> FVec =
66+
{
67+
std::vector<int>(std::begin(Faces[0]), std::end(Faces[0])),
68+
std::vector<int>(std::begin(Faces[1]), std::end(Faces[1])),
69+
std::vector<int>(std::begin(Faces[2]), std::end(Faces[2])),
70+
};
71+
72+
InitializeFromData(CoordData, FVec);
73+
}
74+
1875
MeshDS_DataSource::MeshDS_DataSource(const Handle(Poly_Triangulation)& polyTri)
1976
{
2077
// initialize arrays
2178
std::vector<gp_Pnt> CoordData;
2279
std::vector<std::vector<int>> Ele2NodeData;
2380
CoordData.resize(polyTri->NbNodes());
2481
Ele2NodeData.resize(polyTri->NbTriangles());
25-
//convert node data
2682
const TColgp_Array1OfPnt& nodes = polyTri->Nodes();
2783
for (Standard_Integer nodeId = nodes.Lower(); nodeId <= nodes.Upper(); nodeId++) {
2884
const gp_Pnt& node = nodes.Value(nodeId);
@@ -229,7 +285,7 @@ void MeshDS_DataSource::InitializeFromData
229285
myElemNodes = new TColStd_HArray2OfInteger(1, Ele2NodeData.size(), 1, 4);
230286
myElemNumberNodes = new TColStd_HArray1OfInteger(1, Ele2NodeData.size());
231287
myElemNormals = new TColStd_HArray2OfReal(1, Ele2NodeData.size(), 1, 3);
232-
myNodeNormals = new TColStd_HArray2OfReal(1, Ele2NodeData.size(), 1, 12);
288+
myNodeNormals = new TColStd_HArray2OfReal(1, Ele2NodeData.size(), 1, 12);
233289
// fill node ids and coordinates
234290
for (size_t nodeId = 1; nodeId <= CoordData.size(); nodeId++)
235291
{
@@ -297,4 +353,94 @@ void MeshDS_DataSource::InitializeFromData
297353
myNodeNormals->SetValue(ElementId + 1, 3 * rankNode + 3, aN.Z());
298354
}
299355
}
356+
}
357+
358+
//================================================================
359+
// Function : InitializeFromData
360+
// Purpose : Initialize from 2D Pointer Arrays, for numpy compatibility
361+
//================================================================
362+
void MeshDS_DataSource::InitializeFromData
363+
(double* Vertices, const int nVerts1, const int nVerts2, int* Faces, const int nFaces1, const int nFaces2)
364+
{
365+
//initialize arrays
366+
myNodeCoords = new TColStd_HArray2OfReal(1, nVerts1, 1, 3);
367+
myElemNodes = new TColStd_HArray2OfInteger(1, nFaces1, 1, 4);
368+
myElemNumberNodes = new TColStd_HArray1OfInteger(1, nFaces1);
369+
myElemNormals = new TColStd_HArray2OfReal(1, nFaces1, 1, 3);
370+
myNodeNormals = new TColStd_HArray2OfReal(1, nFaces1, 1, 12);
371+
372+
// fill node ids and coordinates
373+
for (size_t nodeId = 1; nodeId <= nVerts1; nodeId++)
374+
{
375+
size_t vertIdx = (nodeId-1) * 3;
376+
myNodes.Add(nodeId);
377+
myNodeCoords->SetValue(nodeId, 1, Vertices[vertIdx + 0]);
378+
myNodeCoords->SetValue(nodeId, 2, Vertices[vertIdx + 1]);
379+
myNodeCoords->SetValue(nodeId, 3, Vertices[vertIdx + 2]);
380+
}
381+
382+
// fill element ids, number of nodes, associated node ids and normals
383+
for (size_t ElementId = 1; ElementId <= nFaces1; ElementId++)
384+
{
385+
size_t faceIdx = (ElementId-1) * 3;
386+
int nNodes = std::min(4, nFaces2);
387+
myElements.Add(ElementId);
388+
myElemNumberNodes->SetValue(ElementId, nNodes);
389+
for (Standard_Integer rankNode = 1; rankNode <= nNodes; rankNode++)
390+
{
391+
Standard_Integer nodeId = Faces[faceIdx + rankNode - 1] + 1;
392+
myElemNodes->SetValue(ElementId, rankNode, nodeId);
393+
}
394+
// compute face normal
395+
size_t p1Idx = Faces[faceIdx + 0] * 3;
396+
size_t p2Idx = Faces[faceIdx + 1] * 3;
397+
size_t p3Idx = Faces[faceIdx + 2] * 3;
398+
const gp_Pnt aP1 = gp_Pnt(Vertices[p1Idx], Vertices[p1Idx + 1], Vertices[p1Idx + 2]);
399+
const gp_Pnt aP2 = gp_Pnt(Vertices[p2Idx], Vertices[p2Idx + 1], Vertices[p2Idx + 2]);
400+
const gp_Pnt aP3 = gp_Pnt(Vertices[p3Idx], Vertices[p3Idx + 1], Vertices[p3Idx + 2]);
401+
gp_Vec aV1(aP1, aP2);
402+
gp_Vec aV2(aP2, aP3);
403+
gp_Vec aN = aV1.Crossed(aV2);
404+
if (aN.SquareMagnitude() > Precision::SquareConfusion())
405+
aN.Normalize();
406+
else
407+
aN.SetCoord(0.0, 0.0, 0.0);
408+
myElemNormals->SetValue(ElementId, 1, aN.X());
409+
myElemNormals->SetValue(ElementId, 2, aN.Y());
410+
myElemNormals->SetValue(ElementId, 3, aN.Z());
411+
}
412+
// compute node normal
413+
std::vector<std::vector<int>> Node2EleData;
414+
Node2EleData.resize(nVerts1);
415+
for (size_t ElementId = 0; ElementId < nFaces1; ElementId++) {
416+
for (size_t rankNode = 0; rankNode < nFaces2; rankNode++) {
417+
int nodeId = Faces[ElementId * 3 + rankNode];
418+
Node2EleData[nodeId].push_back(ElementId);
419+
}
420+
}
421+
std::vector<gp_Vec> nodeNormals;
422+
nodeNormals.resize(nVerts1);
423+
for (size_t nodeId = 0; nodeId < Node2EleData.size(); nodeId++) {
424+
gp_Vec aN = gp_Vec(0, 0, 0);
425+
for (size_t rankEle = 0; rankEle < Node2EleData[nodeId].size(); rankEle++) {
426+
int ElementId = Node2EleData[nodeId][rankEle] + 1;
427+
aN += gp_Vec(myElemNormals->Value(ElementId, 1), myElemNormals->Value(ElementId, 2), myElemNormals->Value(ElementId, 3));
428+
}
429+
if (aN.SquareMagnitude() > Precision::SquareConfusion())
430+
aN.Normalize();
431+
else
432+
aN.SetCoord(0.0, 0.0, 0.0);
433+
nodeNormals[nodeId] = aN;
434+
}
435+
for (size_t ElementId = 0; ElementId < nFaces1; ElementId++)
436+
{
437+
for (size_t rankNode = 0; rankNode < nFaces2; rankNode++)
438+
{
439+
int nodeId = Faces[ElementId * 3 + rankNode];
440+
gp_Vec aN = nodeNormals[nodeId];
441+
myNodeNormals->SetValue(ElementId + 1, 3 * rankNode + 1, aN.X());
442+
myNodeNormals->SetValue(ElementId + 1, 3 * rankNode + 2, aN.Y());
443+
myNodeNormals->SetValue(ElementId + 1, 3 * rankNode + 3, aN.Z());
444+
}
445+
}
300446
}

‎src/MeshDataSource/MeshDataSource.h‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,13 @@ class MeshDS_DataSource : public MeshVS_DataSource
3535
//! Node normals are calculated averaging the normals of the neighboring elements
3636
MeshDS_DataSource(std::vector<gp_Pnt>& CoordData, std::vector<std::vector<int>>& Ele2NodeData);
3737

38+
//! Initialize data source from vector of vertices and vector of faces (triangles)
39+
//!
40+
//!
41+
MeshDS_DataSource(double Vertices[][3], int Faces[][3]);
42+
43+
MeshDS_DataSource(double* Vertices, int nVerts1, int nVerts2, int* Faces, int nFaces1, int nFaces2);
44+
3845
//! Initialize data source from STL triangulation
3946
//! Face normals are calculated using the three nodes of each element
4047
//! Node normals are calculated averaging the normals of the neighboring elements
@@ -89,6 +96,7 @@ class MeshDS_DataSource : public MeshVS_DataSource
8996
Handle(TColStd_HArray2OfReal) myElemNormals;
9097
Handle(TColStd_HArray2OfReal) myNodeNormals;
9198
void InitializeFromData(std::vector<gp_Pnt>& CoordData, std::vector<std::vector<int>>& Ele2NodeData);
99+
void InitializeFromData(double* Vertices, const int nVerts1, const int nVerts2, int* Faces, const int nFaces1, const int nFaces2);
92100
};
93101

94102
#endif

0 commit comments

Comments
 (0)