Replaced all arrays in Poly_Triangulation to NCollection_Vector.
Poly_Triangulation now does not provide access to whole arrays stored inside it. Only by one element.
New classes Poly_Element, Poly_Mesh.
switch (aMode)
{
case 0:
- const TColgp_Array1OfPnt& nodes = myTriangulation->Nodes(); //Nodes
- const Poly_Array1OfTriangle& triangles = myTriangulation->Triangles(); //Triangle
-
Standard_Boolean hasVNormals = myTriangulation->HasNormals();
Standard_Boolean hasVColors = (myFlagColor == 1);
Handle(Graphic3d_AspectFillArea3d) aspect = myDrawer->ShadingAspect()->Aspect();
Standard_Integer i;
- Standard_Integer j;
Standard_Real ambient = aspect->FrontMaterial().Ambient();
if (hasVNormals)
{
- const TShort_Array1OfShortReal& normals = myTriangulation->Normals();
if (hasVColors)
{
const TColStd_Array1OfInteger& colors = myColor->Array1();
- for ( i = nodes.Lower(); i <= nodes.Upper(); i++ )
+ for ( i = 1; i <= myTriangulation->NbNodes(); i++ )
{
- j = (i - nodes.Lower()) * 3;
- anArray->AddVertex(nodes(i), AttenuateColor(colors(i), ambient));
- anArray->SetVertexNormal(i, normals(j+1), normals(j+2), normals(j+3));
+ anArray->AddVertex(myTriangulation->Node (i), AttenuateColor(colors(i), ambient));
+ anArray->SetVertexNormal(i, myTriangulation->Normal (i));
}
}
else // !hasVColors
{
- for ( i = nodes.Lower(); i <= nodes.Upper(); i++ )
+ for ( i = 1; i <= myTriangulation->NbNodes(); i++ )
{
- j = (i - nodes.Lower()) * 3;
- anArray->AddVertex(nodes(i));
- anArray->SetVertexNormal(i, normals(j+1), normals(j+2), normals(j+3));
+ anArray->AddVertex(myTriangulation->Node (i));
+ anArray->SetVertexNormal(i, myTriangulation->Normal (i));
}
}
}
if (hasVColors)
{
const TColStd_Array1OfInteger& colors = myColor->Array1();
- for ( i = nodes.Lower(); i <= nodes.Upper(); i++ )
+ for ( i = 1; i <= myTriangulation->NbNodes(); i++ )
{
- anArray->AddVertex(nodes(i), AttenuateColor(colors(i), ambient));
+ anArray->AddVertex(myTriangulation->Node (i), AttenuateColor(colors(i), ambient));
}
}
else // !hasVColors
{
- for ( i = nodes.Lower(); i <= nodes.Upper(); i++ )
+ for ( i = 1; i <= myTriangulation->NbNodes(); i++ )
{
- anArray->AddVertex(nodes(i));
+ anArray->AddVertex(myTriangulation->Node (i));
}
}
}
Standard_Integer indexTriangle[3] = {0,0,0};
- for ( i = triangles.Lower(); i<= triangles.Upper(); i++ ) {
- triangles(i).Get(indexTriangle[0], indexTriangle[1], indexTriangle[2]);
+ for ( i = 1; i<= myTriangulation->NbTriangles(); i++ ) {
+ myTriangulation->Triangle (i).Get(indexTriangle[0], indexTriangle[1], indexTriangle[2]);
anArray->AddEdge(indexTriangle[0]);
anArray->AddEdge(indexTriangle[1]);
anArray->AddEdge(indexTriangle[2]);
if (useTriangulation && !T.IsNull())
{
nbNodes = T->NbNodes();
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
for (i = 1; i <= nbNodes; i++) {
- if (l.IsIdentity()) B.Add(Nodes(i));
- else B.Add(Nodes(i).Transformed(l));
+ if (l.IsIdentity()) B.Add(T->Node (i));
+ else B.Add(T->Node (i).Transformed(l));
}
// B.Enlarge(T->Deflection());
B.Enlarge(T->Deflection() + BRep_Tool::Tolerance(F));
if (useTriangulation && !Poly.IsNull())
{
const TColStd_Array1OfInteger& Indices = Poly->Nodes();
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
nbNodes = Indices.Length();
for (i = 1; i <= nbNodes; i++)
{
- if (l.IsIdentity()) B.Add(Nodes(Indices(i)));
- else B.Add(Nodes(Indices(i)).Transformed(l));
+ if (l.IsIdentity()) B.Add(T->Node (Indices(i)));
+ else B.Add(T->Node (Indices(i)).Transformed(l));
}
// B.Enlarge(T->Deflection());
B.Enlarge(Poly->Deflection() + BRep_Tool::Tolerance(E));
aCR->PolygonOnTriangulation2() :
aCR->PolygonOnTriangulation();
const TColStd_Array1OfInteger& anIndices = aPOnTriag->Nodes();
- const TColgp_Array1OfPnt& Nodes = aTriang->Nodes();
const Standard_Integer aNbNodes = anIndices.Length();
const Standard_Real aTol = aPOnTriag->Deflection() +
{
const Standard_Real aParam = aPOnTriag->Parameters()->Value(i);
const gp_Pnt aPE(aBC.Value(aParam)),
- aPT(Nodes(anIndices(i)).Transformed(aLL));
+ aPT(aTriang->Node (anIndices(i)).Transformed(aLL));
const Standard_Real aSQDist = aPE.SquareDistance(aPT);
if(aSQDist > aTol*aTol)
for (Standard_Integer i = 1; i <= aNbNodes; i++)
{
if (aLL.IsIdentity())
- aB.Add(Nodes(anIndices(i)));
+ aB.Add(aTriang->Node (anIndices(i)));
else
- aB.Add(Nodes(anIndices(i)).Transformed(aLL));
+ aB.Add(aTriang->Node (anIndices(i)).Transformed(aLL));
}
aB.Enlarge(aTol);
Tr = BRep_Tool::Triangulation(F,L);
if (!Tr.IsNull())
{
- const TColgp_Array1OfPnt& Nod = Tr->Nodes();
n = Tr->NbNodes();
for (i = 1; i <= n; i++)
{
nbn1++;
- TP1.SetValue(nbn1,Nod(i).Transformed(L));
+ TP1.SetValue(nbn1,Tr->Node (i).Transformed(L));
}
}
}
Tr = BRep_Tool::Triangulation(F,L);
if (!Tr.IsNull())
{
- const TColgp_Array1OfPnt& Nod = Tr->Nodes();
n = Tr->NbNodes();
for (i = 1; i <= n; i++)
{
nbn2++;
- TP2.SetValue(nbn2,Nod(i).Transformed(L));
+ TP2.SetValue(nbn2,Tr->Node (i).Transformed(L));
}
}
}
for (Standard_Integer aVertIdx = 1; aVertIdx <= aTriangulation->NbNodes(); ++aVertIdx)
{
- gp_Pnt aVertex = aTriangulation->Nodes().Value (aVertIdx);
+ gp_Pnt aVertex = aTriangulation->Node (aVertIdx);
aVertex.Transform (aLocation.Transformation());
aVertex.Y(),
aVertex.Z()));
- const Standard_Real aU = aTriangulation->UVNodes().Value (aVertIdx).X();
- const Standard_Real aV = aTriangulation->UVNodes().Value (aVertIdx).Y();
+ const Standard_Real aU = aTriangulation->UVNode (aVertIdx).X();
+ const Standard_Real aV = aTriangulation->UVNode (aVertIdx).Y();
myVertUVArray.push_back (BVH_Vec2d (aU, aV));
}
Standard_Integer aVertex2;
Standard_Integer aVertex3;
- aTriangulation->Triangles().Value (aTriIdx).Get (aVertex1,
- aVertex2,
- aVertex3);
+ aTriangulation->Triangle (aTriIdx).Get (aVertex1,
+ aVertex2,
+ aVertex3);
myTriangles.push_back (BVH_Vec4i (aVertex1 + aVertOffset,
aVertex2 + aVertOffset,
#include <BRepMesh_PairOfIndex.hxx>
#include <BRepMesh_Circle.hxx>
#include <TopTools_ShapeMapHasher.hxx>
-#include <Handle_Poly_Triangulation.hxx>
+#include <Poly_Triangulation.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shape.hxx>
class BRepMesh_VertexInspector;
class BRepMesh_CircleInspector;
class BRepMesh_Classifier;
-class Poly_Triangulation;
class BRepMesh_VertexTool;
namespace BRepMesh
const TopLoc_Location& theLocation)
: myProvider(theEdge, theFace, thePolygon->Parameters()),
myPCurve(thePCurve),
- myNodes(theTriangulation->Nodes()),
+ myTriangulation(theTriangulation),
myIndices(thePolygon->Nodes()),
myLoc(theLocation)
{
gp_Pnt& thePoint,
gp_Pnt2d& theUV)
{
- const gp_Pnt& theRefPnt = myNodes(myIndices(theIndex));
+ const gp_Pnt& theRefPnt = myTriangulation->Node (myIndices(theIndex));
thePoint = BRepMesh_ShapeTool::UseLocation(theRefPnt, myLoc);
theParameter = myProvider.Parameter(theIndex, thePoint);
#include <BRepMesh_EdgeParameterProvider.hxx>
#include <Handle_Geom2d_Curve.hxx>
#include <Handle_Poly_PolygonOnTriangulation.hxx>
-#include <Handle_Poly_Triangulation.hxx>
+#include <Poly_Triangulation.hxx>
#include <TopLoc_Location.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfInteger.hxx>
-class Poly_Triangulation;
class Poly_PolygonOnTriangulation;
class TopoDS_Edge;
class TopoDS_Face;
BRepMesh_EdgeParameterProvider myProvider;
const Handle(Geom2d_Curve)& myPCurve;
- const TColgp_Array1OfPnt& myNodes;
+ Handle(Poly_Triangulation) myTriangulation;
const TColStd_Array1OfInteger& myIndices;
const TopLoc_Location myLoc;
};
if (aPolygon->Deflection() > 1.1 * theDefEdge)
continue;
- const TColgp_Array1OfPnt& aNodes = aTriangulation->Nodes();
const TColStd_Array1OfInteger& aIndices = aPolygon->Nodes();
Handle(TColStd_HArray1OfReal) aParams = aPolygon->Parameters();
aEAttr.FirstVExtractor = new PolyVExplorer(aEAttr.FirstVertex,
- aEAttr.IsSameUV, aEAttr.LastVertex, aIndices(1), aNodes, aLoc);
+ aEAttr.IsSameUV, aEAttr.LastVertex, aIndices(1), aTriangulation, aLoc);
aEAttr.LastVExtractor = new PolyVExplorer(aEAttr.LastVertex,
- aEAttr.IsSameUV, aEAttr.FirstVertex, aIndices(aIndices.Length()), aNodes, aLoc);
+ aEAttr.IsSameUV, aEAttr.FirstVertex, aIndices(aIndices.Length()), aTriangulation, aLoc);
aEdgeTool = new BRepMesh_EdgeTessellationExtractor(theEdge, theC2d,
aFace, aTriangulation, aPolygon, aLoc);
const Standard_Boolean isSameUV,
const TopoDS_Vertex& theSameVertex,
const Standard_Integer theVertexIndex,
- const TColgp_Array1OfPnt& thePolygon,
+ const Handle(Poly_Triangulation)& theTriangulation,
const TopLoc_Location& theLoc)
: TopoDSVExplorer(theVertex, isSameUV, theSameVertex),
myVertexIndex(theVertexIndex),
- myPolygon(thePolygon),
+ myTriangulation(theTriangulation),
myLoc(theLoc)
{
}
virtual gp_Pnt Point() const
{
- return BRepMesh_ShapeTool::UseLocation(myPolygon(myVertexIndex), myLoc);
+ return BRepMesh_ShapeTool::UseLocation(myTriangulation->Node (myVertexIndex), myLoc);
}
private:
}
private:
- Standard_Integer myVertexIndex;
- const TColgp_Array1OfPnt& myPolygon;
- const TopLoc_Location myLoc;
+ Standard_Integer myVertexIndex;
+ Handle(Poly_Triangulation) myTriangulation;
+ const TopLoc_Location myLoc;
};
//! Structure keeps common parameters of edge
Handle(Poly_Triangulation) aNewTriangulation =
new Poly_Triangulation(aVerticesNb, aTrianglesNb, Standard_True);
- Poly_Array1OfTriangle& aPolyTrianges = aNewTriangulation->ChangeTriangles();
-
Standard_Integer aTriangeId = 1;
BRepMesh::MapOfInteger::Iterator aTriIt(aTriangles);
for (; aTriIt.More(); aTriIt.Next())
for (Standard_Integer i = 0; i < 3; ++i)
aNodeId[i] = aVetrexEdgeMap->FindIndex(aNode[i]);
- aPolyTrianges(aTriangeId++).Set(aNodeId[0], aNodeId[1], aNodeId[2]);
+ aNewTriangulation->ChangeTriangle (aTriangeId++).Set(aNodeId[0], aNodeId[1], aNodeId[2]);
}
// Store mesh nodes
- TColgp_Array1OfPnt& aNodes = aNewTriangulation->ChangeNodes();
- TColgp_Array1OfPnt2d& aNodes2d = aNewTriangulation->ChangeUVNodes();
for (Standard_Integer i = 1; i <= aVerticesNb; ++i)
{
const BRepMesh_Vertex& aVertex = aStructure->GetNode(aVertexId);
const gp_Pnt& aPoint = myAttribute->GetPoint(aVertex);
- aNodes(i) = aPoint;
- aNodes2d(i) = aVertex.Coord();
+ aNewTriangulation->ChangeNode (i) = aPoint;
+ aNewTriangulation->ChangeUVNode (i) = aVertex.Coord();
}
aNewTriangulation->Deflection(myAttribute->GetDefFace());
#include <Standard_Transient.hxx>
#include <TopTools_MutexForShapeProvider.hxx>
#include <Handle_BRepAdaptor_HSurface.hxx>
-#include <Handle_Poly_Triangulation.hxx>
+#include <Poly_Triangulation.hxx>
#include <BRepMesh_Delaun.hxx>
#include <BRepMesh_Triangle.hxx>
#include <BRepMesh_Classifier.hxx>
class TopoDS_Vertex;
class BRepAdaptor_HSurface;
class TopoDS_Edge;
-class Poly_Triangulation;
class TopLoc_Location;
class gp_XY;
class gp_Pnt2d;
// #25080: check that indices of links forming triangles are in range.
Standard_Boolean isTriangulationConsistent = Standard_True;
const Standard_Integer aNodesNb = aTriangulation->NbNodes();
- const Poly_Array1OfTriangle& aTriangles = aTriangulation->Triangles();
- Standard_Integer i = aTriangles.Lower();
- for (; i <= aTriangles.Upper() && isTriangulationConsistent; ++i)
+ Standard_Integer i = 1;
+ for (; i <= aTriangulation->NbTriangles() && isTriangulationConsistent; ++i)
{
- const Poly_Triangle& aTriangle = aTriangles(i);
+ const Poly_Triangle& aTriangle = aTriangulation->Triangle (i);
Standard_Integer n[3];
aTriangle.Get(n[0], n[1], n[2]);
for (Standard_Integer j = 0; j < 3 && isTriangulationConsistent; ++j)
#include <TopTools_MapOfShape.hxx>
#include <TopTools_DataMapOfShapeReal.hxx>
#include <BRepMesh_DiscretRoot.hxx>
-#include <Handle_Poly_Triangulation.hxx>
+#include <Poly_Triangulation.hxx>
#include <BRepMesh.hxx>
#include <vector>
-class Poly_Triangulation;
class TopoDS_Shape;
class TopoDS_Edge;
class TopoDS_Face;
gp_Trsf aTrsf = aLoc.Transformation();
aTrsf.Invert();
- TColgp_Array1OfPnt& aNodes = theTriangulation->ChangeNodes();
- for (Standard_Integer i = aNodes.Lower(); i <= aNodes.Upper(); ++i)
- aNodes(i).Transform(aTrsf);
+ for (Standard_Integer i = 1; i <= theTriangulation->NbNodes(); ++i)
+ theTriangulation->ChangeNode (i).Transform(aTrsf);
}
BRep_Builder aBuilder;
#include <Handle_BRepAdaptor_HSurface.hxx>
#include <BRepMesh_FaceAttribute.hxx>
#include <BRepMesh.hxx>
-#include <Handle_Poly_Triangulation.hxx>
+#include <Poly_Triangulation.hxx>
class TopoDS_Face;
class TopoDS_Edge;
if (!Compact) OS << "\n3D Nodes :\n";
nbNodes = T->NbNodes();
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
for (j = 1; j <= nbNodes; j++) {
if (!Compact) OS << setw(10) << j << " : ";
if (!Compact) OS << setw(17);
- OS << Nodes(j).X() << " ";
+ OS << T->Node (j).X() << " ";
if (!Compact) OS << setw(17);
- OS << Nodes(j).Y() << " ";
+ OS << T->Node (j).Y() << " ";
if (!Compact) OS << setw(17);
- OS << Nodes(j).Z();
+ OS << T->Node (j).Z();
if (!Compact) OS << "\n";
else OS << " ";
}
if (T->HasUVNodes()) {
if (!Compact) OS << "\nUV Nodes :\n";
- const TColgp_Array1OfPnt2d& UVNodes = T->UVNodes();
for (j = 1; j <= nbNodes; j++) {
if (!Compact) OS << setw(10) << j << " : ";
if (!Compact) OS << setw(17);
- OS << UVNodes(j).X() << " ";
+ OS << T->UVNode (j).X() << " ";
if (!Compact) OS << setw(17);
- OS << UVNodes(j).Y();
+ OS << T->UVNode (j).Y();
if (!Compact) OS << "\n";
else OS << " ";
}
if (!Compact) OS << "\nTriangles :\n";
nbTriangles = T->NbTriangles();
- const Poly_Array1OfTriangle& Triangles = T->Triangles();
for (j = 1; j <= nbTriangles; j++) {
if (!Compact) OS << setw(10) << j << " : ";
- Triangles(j).Get(n1, n2, n3);
+ T->Triangle (j).Get(n1, n2, n3);
if (!Compact) OS << setw(10);
OS << n1 << " ";
if (!Compact) OS << setw(10);
// write the 3d nodes
nbNodes = T->NbNodes();
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
for (j = 1; j <= nbNodes; j++) {
- BinTools::PutReal(OS, Nodes(j).X());
- BinTools::PutReal(OS, Nodes(j).Y());
- BinTools::PutReal(OS, Nodes(j).Z());
+ BinTools::PutReal(OS, T->Node (j).X());
+ BinTools::PutReal(OS, T->Node (j).Y());
+ BinTools::PutReal(OS, T->Node (j).Z());
}
if (T->HasUVNodes()) {
- const TColgp_Array1OfPnt2d& UVNodes = T->UVNodes();
for (j = 1; j <= nbNodes; j++) {
- BinTools::PutReal(OS, UVNodes(j).X());
- BinTools::PutReal(OS, UVNodes(j).Y());
+ BinTools::PutReal(OS, T->UVNode (j).X());
+ BinTools::PutReal(OS, T->UVNode (j).Y());
}
}
nbTriangles = T->NbTriangles();
- const Poly_Array1OfTriangle& Triangles = T->Triangles();
for (j = 1; j <= nbTriangles; j++) {
- Triangles(j).Get(n1, n2, n3);
+ T->Triangle (j).Get(n1, n2, n3);
BinTools::PutInteger(OS, n1);
BinTools::PutInteger(OS, n2);
BinTools::PutInteger(OS, n3);
BRep_Tool::PolygonOnTriangulation(E->Edge(), Poly, Tr, loc);
if (!Poly.IsNull()) {
const TColStd_Array1OfInteger& Indices = Poly->Nodes();
- const TColgp_Array1OfPnt& Nodes = Tr->Nodes();
for (i=Indices.Lower()+1; i<=Indices.Upper(); i++) {
- dis.Draw(Nodes(Indices(i-1)).Transformed(loc),
- Nodes(Indices(i)).Transformed(loc));
+ dis.Draw(Tr->Node (Indices(i-1)).Transformed(loc),
+ Tr->Node (Indices(i)).Transformed(loc));
if (dis.HasPicked()) {
pickshape = E->Edge();
upick = 0;
TColStd_DataMapOfIntegerInteger Internal;
Standard_Integer fr = 1, in = 1;
- const Poly_Array1OfTriangle& triangles = T->Triangles();
Standard_Integer n[3];
for (i = 1; i <= nbTriangles; i++) {
pc.Triangles(i,t[0],t[1],t[2]);
- triangles(i).Get(n[0],n[1],n[2]);
+ T->Triangle (i).Get(n[0],n[1],n[2]);
for (j = 0; j < 3; j++) {
Standard_Integer k = (j+1) % 3;
if (t[j] == 0) {
}
// Display the edges
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
-// cout<<"nb nodes = "<<Nodes.Length()<<endl;
-
// free edges
Standard_Integer nn;
dis.SetColor(Draw_rouge);
nn = Free.Length() / 2;
for (i = 1; i <= nn; i++) {
- dis.Draw(Nodes(Free(2*i-1)).Transformed(tr),
- Nodes(Free(2*i)).Transformed(tr));
+ dis.Draw(T->Node (Free(2*i-1)).Transformed(tr),
+ T->Node (Free(2*i)).Transformed(tr));
}
// internal edges
//alvays pair is put
aIt.Next();
Standard_Integer n2 = aIt.Value();
- dis.Draw(Nodes(n1).Transformed(tr),
- Nodes(n2).Transformed(tr));
+ dis.Draw(T->Node (n1).Transformed(tr),
+ T->Node (n2).Transformed(tr));
}
}
TColStd_Array1OfInteger& Internal = myInternals->ChangeArray1();
Standard_Integer fr = 1, in = 1;
- const Poly_Array1OfTriangle& triangles = T->Triangles();
Standard_Integer n[3];
for (i = 1; i <= nbTriangles; i++) {
pc.Triangles(i,t[0],t[1],t[2]);
- triangles(i).Get(n[0],n[1],n[2]);
+ T->Triangle (i).Get(n[0],n[1],n[2]);
for (j = 0; j < 3; j++) {
Standard_Integer k = (j+1) % 3;
if (t[j] == 0) {
// Display the edges
Standard_Integer i,n;
- const TColgp_Array1OfPnt& Nodes = myTriangulation->Nodes();
-
// free edges
dis.SetColor(Draw_rouge);
const TColStd_Array1OfInteger& Free = myFree->Array1();
n = Free.Length() / 2;
for (i = 1; i <= n; i++) {
- dis.Draw(Nodes(Free(2*i-1)),Nodes(Free(2*i)));
+ dis.Draw(myTriangulation->Node (Free(2*i-1)),myTriangulation->Node (Free(2*i)));
}
// internal edges
const TColStd_Array1OfInteger& Internal = myInternals->Array1();
n = Internal.Length() / 2;
for (i = 1; i <= n; i++) {
- dis.Draw(Nodes(Internal(2*i-1)),Nodes(Internal(2*i)));
+ dis.Draw(myTriangulation->Node (Internal(2*i-1)),myTriangulation->Node (Internal(2*i)));
}
// texts
n = myTriangulation->NbNodes();
for (i = 1; i <= n; i++) {
Sprintf(text,"%d",i);
- dis.DrawString(Nodes(i),text);
+ dis.DrawString(myTriangulation->Node (i),text);
}
}
dis.SetColor(Draw_vert);
n = myTriangulation->NbTriangles();
Standard_Integer t[3],j;
- const Poly_Array1OfTriangle& triangle = myTriangulation->Triangles();
for (i = 1; i <= n; i++) {
- triangle(i).Get(t[0],t[1],t[2]);
+ myTriangulation->Triangle (i).Get(t[0],t[1],t[2]);
gp_Pnt P(0,0,0);
gp_XYZ& bary = P.ChangeCoord();
for (j = 0; j < 3; j++)
- bary.Add(Nodes(t[j]).Coord());
+ bary.Add(myTriangulation->Node (t[j]).Coord());
bary.Multiply(1./3.);
Sprintf(text,"%d",i);
TColStd_Array1OfInteger& Internal = myInternals->ChangeArray1();
Standard_Integer fr = 1, in = 1;
- const Poly_Array1OfTriangle& triangles = T->Triangles();
Standard_Integer n[3];
for (i = 1; i <= nbTriangles; i++) {
pc.Triangles(i,t[0],t[1],t[2]);
- triangles(i).Get(n[0],n[1],n[2]);
+ T->Triangle(i).Get(n[0],n[1],n[2]);
for (j = 0; j < 3; j++) {
Standard_Integer k = (j+1) % 3;
if (t[j] == 0) {
// Display the edges
Standard_Integer i,n;
if (myTriangulation->HasUVNodes()) {
-
- const TColgp_Array1OfPnt2d& Nodes = myTriangulation->UVNodes();
-
+
// free edges
dis.SetColor(Draw_rouge);
const TColStd_Array1OfInteger& Free = myFree->Array1();
n = Free.Length() / 2;
for (i = 1; i <= n; i++) {
- dis.Draw(Nodes(Free(2*i-1)),Nodes(Free(2*i)));
+ dis.Draw(myTriangulation->UVNode (Free(2*i-1)), myTriangulation->UVNode (Free(2*i)));
}
// internal edges
const TColStd_Array1OfInteger& Internal = myInternals->Array1();
n = Internal.Length() / 2;
for (i = 1; i <= n; i++) {
- dis.Draw(Nodes(Internal(2*i-1)),Nodes(Internal(2*i)));
+ dis.Draw(myTriangulation->UVNode (Internal(2*i-1)), myTriangulation->UVNode (Internal(2*i)));
}
}
TTMa[2][0] = ttma.Value(3,1);
TTMa[2][1] = ttma.Value(3,2);
TTMa[2][2] = ttma.Value(3,3);
- Poly_Array1OfTriangle & Tri = Tr->ChangeTriangles();
- TColgp_Array1OfPnt & Nod = Tr->ChangeNodes();
- Standard_Integer nbN = Nod.Upper();
- Standard_Integer nbT = Tri.Upper();
+ Standard_Integer nbN = Tr->NbNodes();
+ Standard_Integer nbT = Tr->NbTriangles();
PD (f) = new HLRAlgo_PolyData();
psd->PolyData().ChangeValue(iFace) = PD(f);
PID(f) = new HLRAlgo_PolyInternalData(nbN,nbT);
Standard_Address TData = &pid->TData();
Standard_Address PISeg = &pid->PISeg();
Standard_Address PINod = &pid->PINod();
- Poly_Triangle * OT = &(Tri.ChangeValue(1));
HLRAlgo_TriangleData* NT =
&(((HLRAlgo_Array1OfTData*)TData)->ChangeValue(1));
for (i = 1; i <= nbT; i++) {
Standard_Address Tri2Indices = NT->Indices();
- OT->Get(Tri2Node1,Tri2Node2,Tri2Node3);
+ Tr->Triangle (i).Get(Tri2Node1, Tri2Node2, Tri2Node3);
Tri2Flags = 0;
if (reversed) {
j = Tri2Node1;
Tri2Node1 = Tri2Node3;
Tri2Node3 = j;
}
- OT++;
NT++;
}
- gp_Pnt * ON = &(Nod.ChangeValue(1));
Handle(HLRAlgo_PolyInternalNode)* NN =
&(((HLRAlgo_Array1OfPINod*)PINod)->ChangeValue(1));
const Standard_Address Nod1Indices = (*NN)->Indices();
Nod1NdSg = 0;
Nod1Flag = 0;
- Nod1PntX = ON->X();
- Nod1PntY = ON->Y();
- Nod1PntZ = ON->Z();
+ Nod1PntX = Tr->Node (i).X();
+ Nod1PntY = Tr->Node(i).Y();
+ Nod1PntZ = Tr->Node(i).Z();
TTMultiply(Nod1PntX,Nod1PntY,Nod1PntZ);
- ON++;
NN++;
}
pid->UpdateLinks(TData,PISeg,PINod);
if (Tr->HasUVNodes()) {
myBSurf.Initialize(F,Standard_False);
- TColgp_Array1OfPnt2d & UVN = Tr->ChangeUVNodes();
- gp_Pnt2d* OUVN = &(UVN.ChangeValue(1));
NN = &(((HLRAlgo_Array1OfPINod*)PINod)->
ChangeValue(1));
for (i = 1; i <= nbN; i++) {
const Standard_Address Nod1Indices = (*NN)->Indices();
const Standard_Address Nod1RValues = (*NN)->RValues();
- Nod1PntU = OUVN->X();
- Nod1PntV = OUVN->Y();
+ Nod1PntU = Tr->UVNode (i).X();
+ Nod1PntV = Tr->UVNode (i).Y();
if (Normal(i,Nod1Indices,Nod1RValues,
TData,PISeg,PINod,Standard_False))
Nod1Flag |= NMskNorm;
Nod1Flag &= ~NMskNorm;
Nod1Scal = 0;
}
- OUVN++;
NN++;
}
}
BRepMesh_MapOfCouple aMap;
//count number of links
- Poly_Array1OfTriangle& Trian = T->ChangeTriangles();
- for(Standard_Integer i = 1; i<=Trian.Length();i++) {
+ for(Standard_Integer i = 1; i<=T->NbTriangles();i++) {
Standard_Integer v1, v2, v3;
- Trian(i).Get(v1,v2,v3);
+ T->Triangle (i).Get(v1,v2,v3);
AddLink(aMap, v1, v2);
AddLink(aMap, v2, v3);
if (!aTriangulation.IsNull())
{
const Standard_Integer aLength = aTriangulation->NbNodes();
- const TColgp_Array1OfPnt& aNodes = aTriangulation->Nodes();
for (Standard_Integer i = 1; i <= aLength; ++i)
- aBox.Add(aNodes(i));
+ aBox.Add(aTriangulation->Node (i));
}
}
Standard_Real deflemax = 0, deflemin = 1.e100;
if (!T.IsNull()) {
Standard_Real defstock = T->Deflection();
- const Poly_Array1OfTriangle& triangles = T->Triangles();
- const TColgp_Array1OfPnt2d& Nodes2d = T->UVNodes();
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
S = BRep_Tool::Surface(F, L);
- for(i = 1; i <= triangles.Length(); i++) {
+ for(i = 1; i <= T->NbTriangles(); i++) {
if (F.Orientation() == TopAbs_REVERSED)
- triangles(i).Get(n1,n3,n2);
+ T->Triangle (i).Get(n1,n3,n2);
else
- triangles(i).Get(n1,n2,n3);
+ T->Triangle (i).Get(n1,n2,n3);
- const gp_XY& xy1 = Nodes2d(n1).XY();
- const gp_XY& xy2 = Nodes2d(n2).XY();
- const gp_XY& xy3 = Nodes2d(n3).XY();
+ const gp_XY& xy1 = T->UVNode (n1).XY();
+ const gp_XY& xy2 = T->UVNode (n2).XY();
+ const gp_XY& xy3 = T->UVNode (n3).XY();
mi2d1.SetCoord((xy2.X()+xy3.X())*0.5,
(xy2.Y()+xy3.Y())*0.5);
mi2d3.SetCoord((xy1.X()+xy2.X())*0.5,
(xy1.Y()+xy2.Y())*0.5);
- gp_XYZ p1 = Nodes(n1).Transformed(L.Transformation()).XYZ();
- gp_XYZ p2 = Nodes(n2).Transformed(L.Transformation()).XYZ();
- gp_XYZ p3 = Nodes(n3).Transformed(L.Transformation()).XYZ();
+ gp_XYZ p1 = T->Node (n1).Transformed (L.Transformation()).XYZ();
+ gp_XYZ p2 = T->Node (n2).Transformed (L.Transformation()).XYZ();
+ gp_XYZ p3 = T->Node (n3).Transformed (L.Transformation()).XYZ();
vecEd1=p2-p1;
vecEd2=p3-p2;
TColStd_Array1OfInteger Internal(0,2*nInternal);
Standard_Integer fr = 1, in = 1;
- const Poly_Array1OfTriangle& triangles = T->Triangles();
Standard_Integer nodes[3];
for (i = 1; i <= nbTriangles; i++) {
pc.Triangles(i,t[0],t[1],t[2]);
- triangles(i).Get(nodes[0],nodes[1],nodes[2]);
+ T->Triangle (i).Get(nodes[0],nodes[1],nodes[2]);
for (j = 0; j < 3; j++) {
Standard_Integer k = (j+1) % 3;
if (t[j] == 0) {
// Display the edges
if (T->HasUVNodes()) {
- const TColgp_Array1OfPnt2d& Nodes2d = T->UVNodes();
-
Handle(Draw_Segment2D) Seg;
// free edges
Standard_Integer nn;
nn = Free.Length() / 2;
for (i = 1; i <= nn; i++) {
- Seg = new Draw_Segment2D(Nodes2d(Free(2*i-1)),
- Nodes2d(Free(2*i)),
+ Seg = new Draw_Segment2D(T->UVNode (Free(2*i-1)),
+ T->UVNode (Free(2*i)),
Draw_rouge);
dout << Seg;
}
nn = nInternal;
for (i = 1; i <= nn; i++) {
- Seg = new Draw_Segment2D(Nodes2d(Internal(2*i-1)),
- Nodes2d(Internal(2*i)),
+ Seg = new Draw_Segment2D(T->UVNode (Internal(2*i-1)),
+ T->UVNode (Internal(2*i)),
Draw_bleu);
dout << Seg;
}
if (!Tr.IsNull()) {
nbNodes = Tr->NbNodes();
- const TColgp_Array1OfPnt& Nodes = Tr->Nodes();
// les noeuds.
for (i = 1; i <= nbNodes; i++) {
- gp_Pnt Pnt = Nodes(i).Transformed(L.Transformation());
+ gp_Pnt Pnt = Tr->Node (i).Transformed(L.Transformation());
x = Pnt.X();
y = Pnt.Y();
z = Pnt.Z();
// les normales.
if (Tr->HasUVNodes()) {
- const TColgp_Array1OfPnt2d& UVNodes = Tr->UVNodes();
BRepAdaptor_Surface BS(F, Standard_False);
for (i = 1; i <= nbNodes; i++) {
- U = UVNodes(i).X();
- V = UVNodes(i).Y();
+ U = Tr->UVNode (i).X();
+ V = Tr->UVNode (i).Y();
BS.D1(U,V,P,D1U,D1V);
CSLib::Normal(D1U,D1V,Precision::Angular(),Status,Nor);
// les triangles.
Standard_Integer nbTriangles = Tr->NbTriangles();
- const Poly_Array1OfTriangle& triangles = Tr->Triangles();
-
for (i = 1; i <= nbTriangles; i++) {
if (F.Orientation() == TopAbs_REVERSED)
- triangles(i).Get(n1, n3, n2);
+ Tr->Triangle (i).Get(n1, n3, n2);
else
- triangles(i).Get(n1, n2, n3);
+ Tr->Triangle (i).Get(n1, n2, n3);
k1 = n1+totalnodes;
k2 = n2+totalnodes;
k3 = n3+totalnodes;
BRep_Tool::PolygonOnTriangulation(TopoDS::Edge(it.Key()), aPoly, aT, aLoc);
if ( aT.IsNull() || aPoly.IsNull() )
continue;
-
- const TColgp_Array1OfPnt& Nodes = aT->Nodes();
+
const TColStd_Array1OfInteger& Indices = aPoly->Nodes();
const Standard_Integer nbnodes = Indices.Length();
for( Standard_Integer j = 1; j <= nbnodes; j++ )
{
- gp_Pnt P3d = Nodes(Indices(j));
+ gp_Pnt P3d = aT->Node (Indices(j));
if( !aLoc.IsIdentity() )
P3d.Transform(aLoc.Transformation());
// check distances between corresponding points
Standard_Real aDefle = Max(aT1->Deflection(), aT2->Deflection());
- const TColgp_Array1OfPnt& aPoints1 = aT1->Nodes();
- const TColgp_Array1OfPnt& aPoints2 = aT2->Nodes();
Standard_Integer iF1 = aMapF.FindIndex(aFace1);
Standard_Integer iF2 = aMapF.FindIndex(aFace2);
Standard_Integer i1 = aNodes1.Lower();
gp_Trsf aTrsf1 = aFace1.Location().Transformation();
gp_Trsf aTrsf2 = aFace2.Location().Transformation();
for (; i1 <= aNodes1.Upper(); i1++, i2++) {
- gp_Pnt aP1 = aPoints1(aNodes1(i1)).Transformed(aTrsf1);
- gp_Pnt aP2 = aPoints2(aNodes2(i2)).Transformed(aTrsf2);
+ gp_Pnt aP1 = aT1->Node (aNodes1(i1)).Transformed(aTrsf1);
+ gp_Pnt aP2 = aT2->Node (aNodes2(i2)).Transformed(aTrsf2);
Standard_Real aDist = aP1.Distance(aP2);
if (aDist > aDefle) {
myErrors.Append(iF1);
// check of free links and nodes
Poly_Connect aConn(aT);
- const Poly_Array1OfTriangle& aTriangles = aT->Triangles();
Standard_Integer nbTri = aT->NbTriangles(), i, j, n[3], t[3];
for (i = 1; i <= nbTri; i++) {
- aTriangles(i).Get(n[0], n[1], n[2]);
+ aT->Triangle (i).Get(n[0], n[1], n[2]);
aUsedNodes.Add (n[0]);
aUsedNodes.Add (n[1]);
// Count number of links
BRepMesh_MapOfLinks aMap;
- const Poly_Array1OfTriangle& aTriangles = aTriangulation->Triangles();
- for (Standard_Integer i = 1, v[3]; i <= aTriangles.Length(); ++i)
+ for (Standard_Integer i = 1, v[3]; i <= aTriangulation->NbTriangles(); ++i)
{
- aTriangles(i).Get(v[0], v[1], v[2]);
+ aTriangulation->Triangle (i).Get(v[0], v[1], v[2]);
addLink(v[0], v[1], aMap);
addLink(v[1], v[2], aMap);
cout << "face "<<i<<" has no triangulation"<<endl;
continue;
}
- const Poly_Array1OfTriangle& triangles = aPoly->Triangles();
- const TColgp_Array1OfPnt& nodes = aPoly->Nodes();
- for (int j=triangles.Lower(); j <= triangles.Upper(); j++) {
- const Poly_Triangle& tri = triangles(j);
+ for (int j = 1; j <= aPoly->NbTriangles(); j++) {
+ const Poly_Triangle& tri = aPoly->Triangle (j);
int n1, n2, n3;
tri.Get (n1, n2, n3);
- const gp_Pnt& p1 = nodes(n1);
- const gp_Pnt& p2 = nodes(n2);
- const gp_Pnt& p3 = nodes(n3);
+ const gp_Pnt& p1 = aPoly->Node (n1);
+ const gp_Pnt& p2 = aPoly->Node (n2);
+ const gp_Pnt& p3 = aPoly->Node (n3);
gp_Vec v1(p1, p2);
gp_Vec v2(p1, p3);
double ar = v1.CrossMagnitude(v2);
const TopoDS_Face& aFace = TopoDS::Face(aShape);
TopLoc_Location aLoc;
Handle(Poly_Triangulation) aT = BRep_Tool::Triangulation(aFace, aLoc);
- const TColgp_Array1OfPnt& aPoints = aT->Nodes();
- const TColgp_Array1OfPnt2d& aPoints2d = aT->UVNodes();
const gp_Trsf& trsf = aLoc.Transformation();
TColgp_Array1OfPnt pnts(1,2);
Standard_Integer n1, n2;
aCheck.GetFreeLink(k, i, n1, n2);
di << "{" << n1 << " " << n2 << "} ";
- pnts(1) = aPoints(n1).Transformed(trsf);
- pnts(2) = aPoints(n2).Transformed(trsf);
+ pnts(1) = aT->Node (n1).Transformed(trsf);
+ pnts(2) = aT->Node (n2).Transformed(trsf);
Handle(Poly_Polygon3D) poly = new Poly_Polygon3D (pnts);
DrawTrSurf::Set (name, poly);
DrawTrSurf::Set (name, pnts(1));
DrawTrSurf::Set (name, pnts(2));
- pnts2d(1) = aPoints2d(n1);
- pnts2d(2) = aPoints2d(n2);
+ pnts2d(1) = aT->UVNode (n1);
+ pnts2d(2) = aT->UVNode (n2);
Handle(Poly_Polygon2D) poly2d = new Poly_Polygon2D (pnts2d);
DrawTrSurf::Set (name, poly2d);
DrawTrSurf::Set (name, pnts2d(1));
break;
}
- const Poly_Array1OfTriangle& aTris = aT->Triangles();
NCollection_Map<BRepMesh_Edge> aFreeEdgeMap;
- Standard_Integer aTriNum = aTris.Length();
+ Standard_Integer aTriNum = aT->NbTriangles();
for ( Standard_Integer aTriIndx = 1; aTriIndx <= aTriNum; aTriIndx++ )
{
- const Poly_Triangle& aTri = aTris(aTriIndx);
+ const Poly_Triangle& aTri = aT->Triangle (aTriIndx);
Standard_Integer aTriNodes[3] = { aTri.Value(1), aTri.Value(2), aTri.Value(3)};
for (Standard_Integer i = 1; i <= 3; ++i)
}
//=======================================================================
+//function : CopyNodes
+//purpose : Copy the gp_Pnt
+// from an Poly_Triangulation
+// to an HArray1 from PColgp (PCollection)
+//=======================================================================
+
+static Handle(PColgp_HArray1OfPnt) CopyNodes
+ (const Handle(Poly_Triangulation)& theTriangulation)
+{
+ Standard_Integer Lower = 1;
+ Standard_Integer Upper = theTriangulation->NbNodes();
+ Standard_Integer Index;
+ Handle(PColgp_HArray1OfPnt) PArray = new PColgp_HArray1OfPnt(Lower, Upper);
+ for (Index = Lower; Index <= Upper; Index++) {
+ PArray->SetValue(Index, theTriangulation->Node (Index));
+ }
+ return PArray;
+}
+
+//=======================================================================
//function : ArrayCopy
//purpose : Copy the gp_Pnt
// from an HArray1 from PColgp (PCollection)
}
//=======================================================================
+//function : CopyUVNodes
+//purpose : Copy the gp_Pnt2d
+// from an Poly_Triangulation
+// to an Array1 from PColgp (PCollection)
+//=======================================================================
+
+static Handle(PColgp_HArray1OfPnt2d) CopyUVNodes
+ (const Handle(Poly_Triangulation)& theTriangulation)
+{
+ Standard_Integer Lower = 1;
+ Standard_Integer Upper = theTriangulation->NbNodes();
+ Standard_Integer Index;
+ Handle(PColgp_HArray1OfPnt2d) PArray =
+ new PColgp_HArray1OfPnt2d(Lower, Upper);
+ for (Index = Lower; Index <= Upper; Index++) {
+ PArray->SetValue(Index, theTriangulation->UVNode (Index));
+ }
+ return PArray;
+}
+
+//=======================================================================
//function : ArrayCopy
//purpose : Copy the gp_Pnt2d
// from an HArray1 from PColgp (PCollection)
//=======================================================================
-//function : ArrayCopy
+//function : CopyTriangles
//purpose : Copy the Triangle
-// from an Array1 from Poly (TCollection)
+// from an from Poly_Triangulation
// to an HArray1 from PPoly (PCollection)
//=======================================================================
-static Handle(PPoly_HArray1OfTriangle) ArrayCopy
-(const Poly_Array1OfTriangle& TArray)
+static Handle(PPoly_HArray1OfTriangle) CopyTriangles
+(const Handle(Poly_Triangulation)& theTrinagulation)
{
- Standard_Integer Lower = TArray.Lower();
- Standard_Integer Upper = TArray.Upper();
+ Standard_Integer Lower = 1;
+ Standard_Integer Upper = theTrinagulation->NbTriangles();
Standard_Integer Index;
Handle(PPoly_HArray1OfTriangle) PArray =
new PPoly_HArray1OfTriangle(Lower, Upper);
for (Index = Lower; Index <= Upper; Index++) {
- PPoly_Triangle aPTriangle = MgtPoly::Translate(TArray(Index));
+ PPoly_Triangle aPTriangle = MgtPoly::Translate(theTrinagulation->Triangle (Index));
PArray->SetValue(Index, aPTriangle);
}
return PArray;
}
else {
// myNodes
- const TColgp_Array1OfPnt& TNodes = TObj->Nodes();
Handle(PColgp_HArray1OfPnt) PNodes =
- new PColgp_HArray1OfPnt(TNodes.Lower(),
- TNodes.Upper());
- PNodes = ArrayCopy(TNodes);
+ new PColgp_HArray1OfPnt(1,
+ TObj->NbNodes());
+ PNodes = CopyNodes(TObj);
// myTriangles
- const Poly_Array1OfTriangle& TTriangle = TObj->Triangles();
Handle(PPoly_HArray1OfTriangle) PTriangle =
- new PPoly_HArray1OfTriangle(TTriangle.Lower(),
- TTriangle.Upper());
- PTriangle = ArrayCopy(TTriangle);
+ new PPoly_HArray1OfTriangle(1,
+ TObj->NbTriangles());
+ PTriangle = CopyTriangles(TObj);
// myUVNodes
Handle(PColgp_HArray1OfPnt2d) PUVNodes;
if (TObj->HasUVNodes()) {
- const TColgp_Array1OfPnt2d& TUVNodes = TObj->UVNodes();
PUVNodes =
- new PColgp_HArray1OfPnt2d(TUVNodes.Lower(),
- TUVNodes.Upper());
- PUVNodes = ArrayCopy(TUVNodes);
+ new PColgp_HArray1OfPnt2d(1,
+ TObj->NbNodes());
+ PUVNodes = CopyUVNodes(TObj);
}
// Constructor + Deflection
PT = new PPoly_Triangulation(TObj->Deflection(),
// Copy the data from the original triangulation.
Standard_Integer i, iN(0), iT(0);
- const Poly_Array1OfTriangle& arrTri = theTri->Triangles();
- const TColgp_Array1OfPnt& arrNodes = theTri->Nodes();
- for (i = arrTri.Lower(); i <= arrTri.Upper(); i++) {
+ for (i = 1; i <= theTri->NbTriangles(); i++) {
Standard_Integer iNode[3];
- arrTri(i).Get(iNode[0], iNode[1], iNode[2]);
- gp_XYZ aNorm = ((arrNodes(iNode[1]).XYZ() - arrNodes(iNode[0]).XYZ()) ^
- (arrNodes(iNode[2]).XYZ() - arrNodes(iNode[0]).XYZ()));
+ theTri->Triangle (i).Get(iNode[0], iNode[1], iNode[2]);
+ gp_XYZ aNorm = ((theTri->Node (iNode[1]).XYZ() - theTri->Node (iNode[0]).XYZ()) ^
+ (theTri->Node (iNode[2]).XYZ() - theTri->Node (iNode[0]).XYZ()));
const Standard_Real aMagn = aNorm.Modulus();
if (aMagn > Precision::Confusion())
aNorm /= aMagn;
else
aNorm.SetCoord(0., 0., 1.);
- mypNodes[iN+0] = static_cast<Standard_ShortReal>(arrNodes(iNode[0]).X());
- mypNodes[iN+1] = static_cast<Standard_ShortReal>(arrNodes(iNode[0]).Y());
- mypNodes[iN+2] = static_cast<Standard_ShortReal>(arrNodes(iNode[0]).Z());
- mypNodes[iN+3] = static_cast<Standard_ShortReal>(arrNodes(iNode[1]).X());
- mypNodes[iN+4] = static_cast<Standard_ShortReal>(arrNodes(iNode[1]).Y());
- mypNodes[iN+5] = static_cast<Standard_ShortReal>(arrNodes(iNode[1]).Z());
- mypNodes[iN+6] = static_cast<Standard_ShortReal>(arrNodes(iNode[2]).X());
- mypNodes[iN+7] = static_cast<Standard_ShortReal>(arrNodes(iNode[2]).Y());
- mypNodes[iN+8] = static_cast<Standard_ShortReal>(arrNodes(iNode[2]).Z());
+ mypNodes[iN+0] = static_cast<Standard_ShortReal>(theTri->Node (iNode[0]).X());
+ mypNodes[iN+1] = static_cast<Standard_ShortReal>(theTri->Node (iNode[0]).Y());
+ mypNodes[iN+2] = static_cast<Standard_ShortReal>(theTri->Node (iNode[0]).Z());
+ mypNodes[iN+3] = static_cast<Standard_ShortReal>(theTri->Node (iNode[1]).X());
+ mypNodes[iN+4] = static_cast<Standard_ShortReal>(theTri->Node (iNode[1]).Y());
+ mypNodes[iN+5] = static_cast<Standard_ShortReal>(theTri->Node (iNode[1]).Z());
+ mypNodes[iN+6] = static_cast<Standard_ShortReal>(theTri->Node (iNode[2]).X());
+ mypNodes[iN+7] = static_cast<Standard_ShortReal>(theTri->Node (iNode[2]).Y());
+ mypNodes[iN+8] = static_cast<Standard_ShortReal>(theTri->Node(iNode[2]).Z());
mypNormals[iN+0] = static_cast<Standard_ShortReal>(aNorm.X());
mypNormals[iN+1] = static_cast<Standard_ShortReal>(aNorm.Y());
mypNormals[iN+2] = static_cast<Standard_ShortReal>(aNorm.Z());
Standard_Boolean isReverse = (aFace.Orientation() == TopAbs_REVERSED);
// Store all nodes of the current face in the data model
- const TColgp_Array1OfPnt& tabNode = aTriangulation->Nodes();
- const TColgp_Array1OfPnt2d& tabUV = aTriangulation->UVNodes();
- for (i = tabNode.Lower(); i <= tabNode.Upper(); i++)
+ for (i = 1; i <= aTriangulation->NbNodes(); i++)
{
Standard_Real t[3];
- tabNode(i).Transformed(aTrf).Coord (t[0], t[1], t[2]);
+ aTriangulation->Node (i).Transformed(aTrf).Coord (t[0], t[1], t[2]);
// write node to mesh data
mypNodes[3*aNodeInd + 0] = static_cast<Standard_ShortReal>(t[0]);
mypNodes[3*aNodeInd + 1] = static_cast<Standard_ShortReal>(t[1]);
if (aTriangulation->HasNormals()) {
// Retrieve the normal direction from the triangulation
- aNorm.SetCoord(aTriangulation->Normals().Value(3*i-2),
- aTriangulation->Normals().Value(3*i-1),
- aTriangulation->Normals().Value(3*i-0));
+ aNorm = aTriangulation->Normal (i).XYZ();
} else if (aSurf.IsNull() == Standard_False)
{
// Compute the surface normal at the Node.
- aSurf->D1(tabUV(i).X(), tabUV(i).Y(), aP, aD1U, aD1V);
+ aSurf->D1(aTriangulation->UVNode (i).X(), aTriangulation->UVNode (i).Y(), aP, aD1U, aD1V);
aNorm = (aD1U.Crossed(aD1V)).XYZ();
}
}
const Standard_Integer nNodes1 = nNodes - 1;
// Store all triangles of the current face in the data model
- const Poly_Array1OfTriangle& tabTri = aTriangulation->Triangles();
- for (i = tabTri.Lower(); i <= tabTri.Upper(); i++)
+ for (i = 1; i <= aTriangulation->NbTriangles(); i++)
{
Standard_Integer aN[3];
- tabTri(i).Get (aN[0], aN[1], aN[2]);
+ aTriangulation->Triangle (i).Get (aN[0], aN[1], aN[2]);
Standard_Integer * pTriangle = &mypTriangles[nTriangles*3];
pTriangle[0] = aN[0] + nNodes1;
if (isReverse) {
Standard_Integer aLen = arrNode.Length();
Standard_Integer * pEdge = static_cast<Standard_Integer *>
(myAlloc->Allocate(sizeof(Standard_Integer) * (aLen + 1)));
- const gp_Pnt* pLast = &tabNode(arrNode(arrNode.Lower()));
+ const gp_Pnt* pLast = &aTriangulation->Node (arrNode(arrNode.Lower()));
pEdge[1] = arrNode(arrNode.Lower()) + nNodes1;
Standard_Integer iPNode(arrNode.Lower() + 1), iENode(1);
for (; iPNode <= arrNode.Upper(); iPNode++)
{
const Standard_Integer aN(arrNode(iPNode));
- if (pLast->SquareDistance(tabNode(aN)) < eps2)
+ if (pLast->SquareDistance(aTriangulation->Node (aN)) < eps2)
{
aLen--;
} else {
- pLast = &tabNode(aN);
+ pLast = &aTriangulation->Node (aN);
pEdge[++iENode] = aN + nNodes1;
}
}
}
}
}
- nNodes += tabNode.Length();
+ nNodes += aTriangulation->NbNodes();
}
}
myNTriangles = nTriangles;
Poly_MakeLoops.hxx
Poly_MakeLoops.cxx
Poly_ListOfTriangulation.hxx
+Poly_Triangulation.hxx
+Poly_Triangulation.cxx
+Poly_Element.hxx
+Poly_Element.cxx
+Poly_Mesh.hxx
+Poly_Mesh.cxx
instantiates HArray1 from TCollection(Triangle from Poly,
Array1OfTriangle from Poly);
- class Triangulation;
+ imported transient class Triangulation;
+ imported transient class Mesh;
+ imported Element;
class Polygon3D;
Standard_Integer i, iNode[3];
nNodes = 0;
nTrian = 0;
- TColgp_Array1OfPnt& arrNode = aResult->ChangeNodes();
- Poly_Array1OfTriangle& arrTrian = aResult->ChangeTriangles();
for (anIter.Init(lstTri); anIter.More(); anIter.Next()) {
const Handle(Poly_Triangulation)& aTri = anIter.Value();
if (aTri.IsNull() == Standard_False) {
- const TColgp_Array1OfPnt& srcNode = aTri->Nodes();
- const Poly_Array1OfTriangle& srcTrian = aTri->Triangles();
const Standard_Integer nbNodes = aTri->NbNodes();
const Standard_Integer nbTrian = aTri->NbTriangles();
for (i = 1; i <= nbNodes; i++) {
- arrNode.SetValue(i + nNodes, srcNode(i));
+ aResult->ChangeNode (i + nNodes) = aTri->Node (i);
}
for (i = 1; i <= nbTrian; i++) {
- srcTrian(i).Get(iNode[0], iNode[1], iNode[2]);
- arrTrian.SetValue(i + nTrian, Poly_Triangle(iNode[0] + nNodes,
+ aTri->Triangle (i).Get(iNode[0], iNode[1], iNode[2]);
+ aResult->ChangeTriangle (i + nTrian) = Poly_Triangle(iNode[0] + nNodes,
iNode[1] + nNodes,
- iNode[2] + nNodes));
+ iNode[2] + nNodes);
}
nNodes += nbNodes;
nTrian += nbTrian;
if (!Compact) OS << "\n3D Nodes :\n";
Standard_Integer i, nbNodes = T->NbNodes();
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
for (i = 1; i <= nbNodes; i++) {
if (!Compact) OS << setw(10) << i << " : ";
if (!Compact) OS << setw(17);
- OS << Nodes(i).X() << " ";
+ OS << T->Node (i).X() << " ";
if (!Compact) OS << setw(17);
- OS << Nodes(i).Y() << " ";
+ OS << T->Node (i).Y() << " ";
if (!Compact) OS << setw(17);
- OS << Nodes(i).Z() << "\n";
+ OS << T->Node (i).Z() << "\n";
}
if (T->HasUVNodes()) {
if (!Compact) OS << "\nUV Nodes :\n";
- const TColgp_Array1OfPnt2d& UVNodes = T->UVNodes();
for (i = 1; i <= nbNodes; i++) {
if (!Compact) OS << setw(10) << i << " : ";
if (!Compact) OS << setw(17);
- OS << UVNodes(i).X() << " ";
+ OS << T->UVNode (i).X() << " ";
if (!Compact) OS << setw(17);
- OS << UVNodes(i).Y() << "\n";
+ OS << T->UVNode (i).Y() << "\n";
}
}
if (!Compact) OS << "\nTriangles :\n";
Standard_Integer nbTriangles = T->NbTriangles();
Standard_Integer n1, n2, n3;
- const Poly_Array1OfTriangle& Triangles = T->Triangles();
for (i = 1; i <= nbTriangles; i++) {
if (!Compact) OS << setw(10) << i << " : ";
- Triangles(i).Get(n1, n2, n3);
+ T->Triangle(i).Get(n1, n2, n3);
if (!Compact) OS << setw(10);
OS << n1 << " ";
if (!Compact) OS << setw(10);
void Poly::ComputeNormals(const Handle(Poly_Triangulation)& Tri)
{
- const TColgp_Array1OfPnt& arrNodes = Tri->Nodes();
- const Poly_Array1OfTriangle & arrTri = Tri->Triangles();
Standard_Integer nbNormVal = Tri->NbNodes() * 3;
const Handle(TShort_HArray1OfShortReal) Normals =
new TShort_HArray1OfShortReal(1, nbNormVal);
Standard_Integer iN, iTri;
const Standard_Real eps2 = Precision::SquareConfusion();
- for (iTri = 1; iTri <= arrTri.Length(); iTri++) {
+ for (iTri = 1; iTri <= Tri->NbTriangles(); iTri++) {
// Get the nodes of the current triangle
- arrTri(iTri).Get (iNode[0], iNode[1], iNode[2]);
+ Tri->Triangle (iTri).Get (iNode[0], iNode[1], iNode[2]);
const gp_XYZ aVec[2] = {
- arrNodes(iNode[1]).XYZ() - arrNodes(iNode[0]).XYZ(),
- arrNodes(iNode[2]).XYZ() - arrNodes(iNode[0]).XYZ()
+ Tri->Node (iNode[1]).XYZ() - Tri->Node (iNode[0]).XYZ(),
+ Tri->Node (iNode[2]).XYZ() - Tri->Node (iNode[0]).XYZ()
};
// Find the normal vector of the current triangle
: theAlloc)
{
if (theTriangulation.IsNull() == Standard_False) {
- const TColgp_Array1OfPnt& arrNodes = theTriangulation->Nodes();
- const Poly_Array1OfTriangle& arrTriangle = theTriangulation->Triangles();
const Standard_Integer nNodes = theTriangulation->NbNodes();
- const Standard_Integer nTri = theTriangulation->NbTriangles();
Standard_Integer i;
// Copy the nodes
for (i = 0; i < nNodes; i++) {
- const Standard_Integer anOldInd = i + arrNodes.Lower();
- const Standard_Integer aNewInd = SetNode(arrNodes(anOldInd).XYZ(), i);
+ const Standard_Integer anOldInd = i + 1;
+ const Standard_Integer aNewInd = SetNode(theTriangulation->Node (anOldInd).XYZ(), i);
Poly_CoherentNode& aCopiedNode = myNodes(aNewInd);
aCopiedNode.SetIndex(anOldInd);
}
// Copy the triangles
- for (i = 0; i < nTri; i++) {
+ for (i = 1; i <= theTriangulation->NbTriangles(); i++) {
Standard_Integer iNode[3];
- arrTriangle(i + arrTriangle.Lower()).Get(iNode[0], iNode[1], iNode[2]);
+ theTriangulation->Triangle (i).Get(iNode[0], iNode[1], iNode[2]);
if (iNode[0] != iNode[1] && iNode[1] != iNode[2] && iNode[2] != iNode[0])
AddTriangle (iNode[0]-1, iNode[1]-1, iNode[2]-1);
}
// Copy UV coordinates of nodes
if (theTriangulation->HasUVNodes()) {
- const TColgp_Array1OfPnt2d& arrNodes2d = theTriangulation->UVNodes();
for (i = 0; i < nNodes; i++) {
- const gp_Pnt2d& anUV = arrNodes2d(i + arrNodes2d.Lower());
+ const gp_Pnt2d& anUV = theTriangulation->UVNode (i + 1);
myNodes(i).SetUV(anUV.X(), anUV.Y());
}
}
// Copy the normals at nodes
if (theTriangulation->HasNormals()) {
- const TShort_Array1OfShortReal& arrNorm = theTriangulation->Normals();
for (i = 0; i < nNodes; i++) {
- const gp_XYZ aNormal (arrNorm(3 * i + 0 + arrNorm.Lower()),
- arrNorm(3 * i + 1 + arrNorm.Lower()),
- arrNorm(3 * i + 2 + arrNorm.Lower()));
+ const gp_XYZ aNormal = theTriangulation->Normal (i + 1).XYZ();
myNodes(i).SetNormal(aNormal);
}
}
new TShort_HArray1OfShortReal(1, 3 * nNodes);
Standard_ShortReal * arrNormal = &harrNormal->ChangeValue(1);
- TColgp_Array1OfPnt& arrNodes = aResult->ChangeNodes();
- TColgp_Array1OfPnt2d& arrNodesUV = aResult->ChangeUVNodes();
- Poly_Array1OfTriangle& arrTriangle = aResult->ChangeTriangles();
NCollection_Vector<Standard_Integer> vecNodeId;
Standard_Integer i, aCount(0);
Standard_Boolean hasUV (Standard_False);
arrNormal[3 * aCount + 2] = static_cast<Standard_ShortReal>(aNormal.Z());
vecNodeId.SetValue(i, ++aCount);
- arrNodes.SetValue(aCount, aNode);
+ aResult->ChangeNode (aCount) = aNode;
- arrNodesUV.SetValue(aCount, gp_Pnt2d(aNode.GetU(), aNode.GetV()));
+ aResult->ChangeUVNode (aCount) = gp_Pnt2d(aNode.GetU(), aNode.GetV());
if (aNode.GetU()*aNode.GetU() + aNode.GetV()*aNode.GetV() >
Precision::Confusion())
hasUV = Standard_True;
for (; anIterT.More(); anIterT.Next()) {
const Poly_CoherentTriangle& aTri = anIterT.Value();
if (aTri.IsEmpty() == Standard_False) {
- const Poly_Triangle aPolyTriangle (vecNodeId(aTri.Node(0)),
- vecNodeId(aTri.Node(1)),
- vecNodeId(aTri.Node(2)));
- arrTriangle.SetValue(++aCount, aPolyTriangle);
+ aResult->ChangeTriangle (++aCount) = Poly_Triangle (vecNodeId(aTri.Node(0)),
+ vecNodeId(aTri.Node(1)),
+ vecNodeId(aTri.Node(2)));;
}
}
if (hasNormals)
// loop on the triangles
Standard_Integer j,k,n[3],n1,n2;
- const Poly_Array1OfTriangle& triangles = myTriangulation->Triangles();
for (i = 1; i <= nbTriangles; i++) {
// get the nodes
- triangles(i).Get(n[0],n[1],n[2]);
+ myTriangulation->Triangle (i).Get(n[0],n[1],n[2]);
// Update the myTriangles array
myTriangles(n[0]) = i;
for (i = 1; i <= nbTriangles; i++) {
// get the nodes
- triangles(i).Get(n[0],n[1],n[2]);
+ myTriangulation->Triangle (i).Get(n[0],n[1],n[2]);
// fore each edge
for (j = 0; j < 3; j++) {
if (mymore)
{
Standard_Integer i, no[3];
- const Poly_Array1OfTriangle& triangles = myTriangulation->Triangles();
- triangles(myfirst).Get(no[0], no[1], no[2]);
+ myTriangulation->Triangle (myfirst).Get(no[0], no[1], no[2]);
for (i = 0; i < 3; i++)
if (no[i] == mynode) break;
myothernode = no[(i+2)%3];
Standard_Integer i, j;
Standard_Integer n[3];
Standard_Integer t[3];
- const Poly_Array1OfTriangle& triangles = myTriangulation->Triangles();
Triangles(mytr, t[0], t[1], t[2]);
if (mysense) {
for (i = 0; i < 3; i++) {
if (t[i] != 0) {
- triangles(t[i]).Get(n[0], n[1], n[2]);
+ myTriangulation->Triangle (t[i]).Get(n[0], n[1], n[2]);
for (j = 0; j < 3; j++) {
if ((n[j] == mynode) && (n[(j+1)%3] == myothernode)) {
mytr = t[i];
}
}
// sinon, depart vers la gauche.
- triangles(myfirst).Get(n[0], n[1], n[2]);
+ myTriangulation->Triangle (myfirst).Get(n[0], n[1], n[2]);
for (i = 0; i < 3; i++)
if (n[i] == mynode) break;
myothernode = n[(i+1)%3];
if (!mysense) {
for (i = 0; i < 3; i++) {
if (t[i] != 0) {
- triangles(t[i]).Get(n[0], n[1], n[2]);
+ myTriangulation->Triangle (t[i]).Get(n[0], n[1], n[2]);
for (j = 0; j < 3; j++) {
if ((n[j] == mynode) && (n[(j+2)%3] == myothernode)) {
mytr = t[i];
-// Created on: 1995-03-06
-// Created by: Laurent PAINNOT
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
+// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
+#include <Poly_Element.hxx>
+
//=======================================================================
-//function : NbNodes
-//purpose :
+//function : Poly_Element
+//purpose :
//=======================================================================
-inline Standard_Integer Poly_Triangulation::NbNodes() const
+Poly_Element::Poly_Element()
{
- return myNbNodes;
+ myTriangles[0] = myTriangles[1] = 0;
}
//=======================================================================
-//function : NbTriangles
-//purpose :
+//function : Poly_Element
+//purpose :
//=======================================================================
-inline Standard_Integer Poly_Triangulation::NbTriangles() const
+Poly_Element::Poly_Element (const Standard_Integer theTriangle1,
+ const Standard_Integer theTriangle2)
{
- return myNbTriangles;
+ myTriangles[0] = theTriangle1;
+ myTriangles[1] = theTriangle2;
}
//=======================================================================
-//function : HasUVNodes
-//purpose :
+//function : Set
+//purpose :
//=======================================================================
-inline Standard_Boolean Poly_Triangulation::HasUVNodes() const
+void Poly_Element::Set (const Standard_Integer theTriangle1,
+ const Standard_Integer theTriangle2)
{
- return !myUVNodes.IsNull();
+ myTriangles[0] = theTriangle1;
+ myTriangles[1] = theTriangle2;
}
+//=======================================================================
+//function : Get
+//purpose :
+//=======================================================================
+
+void Poly_Element::Get (Standard_Integer& theTriangle1,
+ Standard_Integer& theTriangle2)
+{
+ theTriangle1 = myTriangles[0];
+ theTriangle2 = myTriangles[1];
+}
--- /dev/null
+// Copyright (c) 2015 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _Poly_Element_HeaderFile
+#define _Poly_Element_HeaderFile
+
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Integer.hxx>
+#include <Standard_OutOfRange.hxx>
+
+//! Describes an element on mesh.
+//! It can be defined as triangle index (in this case second index will be 0)
+//! or as a pair of triangles indices that make up the quad.
+class Poly_Element
+{
+
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Constructs an element and sets all indices to zero.
+ Standard_EXPORT Poly_Element();
+
+ //! Constructs an element and sets it indices.
+ Standard_EXPORT Poly_Element (const Standard_Integer theTriangle1,
+ const Standard_Integer theTriangle2);
+
+ //! Sets the value of triangles indices.
+ Standard_EXPORT void Set (const Standard_Integer theTriangle1,
+ const Standard_Integer theTriangle2);
+
+ //! Returns the triangles indices of this element in theTriangle1, theTriangle2.
+ Standard_EXPORT void Get (Standard_Integer& theTriangle1,
+ Standard_Integer& theTriangle2);
+
+ //! @return the triangle index of given element theIndex.
+ //! Raises OutOfRange from Standard if theIndex is not in 1,2.
+ Standard_Integer Value (const Standard_Integer theIndex) const
+ {
+ Standard_OutOfRange_Raise_if (theIndex < 1 || theIndex > 2, NULL);
+ return myTriangles[theIndex - 1];
+ }
+
+ Standard_Integer operator() (const Standard_Integer theIndex) const { return Value (theIndex); }
+
+ //! @return the triangle index of given element theIndex.
+ //! Raises OutOfRange from Standard if theIndex is not in 1,2.
+ Standard_Integer& ChangeValue (const Standard_Integer theIndex)
+ {
+ Standard_OutOfRange_Raise_if (theIndex < 1 || theIndex > 2, NULL);
+ return myTriangles[theIndex - 1];
+ }
+
+ Standard_Integer& operator() (const Standard_Integer theIndex) { return ChangeValue (theIndex); }
+
+ //! @return Standard_True if the first element index > 0 and the second index == 0.
+ Standard_Boolean IsTriangle()
+ {
+ return (myTriangles[0] > 0 && myTriangles[1] == 0);
+ }
+
+ //! @return Standard_True if the first and the second element indices > 0.
+ Standard_Boolean IsQuad()
+ {
+ return (myTriangles[0] > 0 && myTriangles[1] > 0);
+ }
+
+private:
+
+ Standard_Integer myTriangles[2];
+
+};
+
+#endif // _Poly_Element_HeaderFile
--- /dev/null
+// Copyright (c) 2015 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <Poly_Mesh.hxx>
+
+#include <Standard_DefineHandle.hxx>
+
+IMPLEMENT_STANDARD_HANDLE (Poly_Mesh, Poly_Triangulation)
+IMPLEMENT_STANDARD_RTTIEXT (Poly_Mesh, Poly_Triangulation)
+
+//=======================================================================
+//function : Poly_Mesh
+//purpose :
+//=======================================================================
+
+Poly_Mesh::Poly_Mesh (const Standard_Boolean theHasUVNodes)
+: Poly_Triangulation (0, 0, theHasUVNodes),
+ myNbQuads (0)
+{}
+
+//=======================================================================
+//function : AddTriangle
+//purpose :
+//=======================================================================
+
+Standard_Integer Poly_Mesh::AddTriangle (const Poly_Triangle& theTriangle)
+{
+ Standard_Integer anIndex = Poly_Triangulation::AddTriangle (theTriangle);
+ return AddElement (Poly_Element (anIndex, 0));
+}
+
+//=======================================================================
+//function : AddElement
+//purpose :
+//=======================================================================
+
+Standard_Integer Poly_Mesh::AddElement (const Poly_Element& theElement)
+{
+ myElements.Append (theElement);
+ if (theElement.Value (2) != 0)
+ {
+ myNbQuads++;
+ }
+ return myElements.Size();
+}
+
+//=======================================================================
+//function : Element
+//purpose :
+//=======================================================================
+
+const Poly_Element& Poly_Mesh::Element (const Standard_Integer theIndex)
+{
+ Standard_OutOfRange_Raise_if (theIndex < 1 || theIndex > myElements.Size(),
+ "Poly_Element::Element : index out of range");
+ return myElements.Value (theIndex - 1);
+}
+
+//=======================================================================
+//function : SetElement
+//purpose :
+//=======================================================================
+
+void Poly_Mesh::SetElement (const Standard_Integer theIndex, const Poly_Element& theElement)
+{
+ Standard_OutOfRange_Raise_if (theIndex < 1 || theIndex > myElements.Size(),
+ "Poly_Element::SetElement : index out of range");
+
+ if (myElements.Value (theIndex - 1).Value (2) == 0 && theElement.Value (2) != 0)
+ {
+ myNbQuads++;
+ }
+ else if (myElements.Value (theIndex - 1).Value (2) != 0 && theElement.Value (2) == 0)
+ {
+ myNbQuads--;
+ }
+
+ myElements.SetValue (theIndex - 1, theElement);
+}
--- /dev/null
+// Copyright (c) 2015 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _Poly_Mesh_HeaderFile
+#define _Poly_Mesh_HeaderFile
+
+#include <Poly_Element.hxx>
+#include <Poly_Triangulation.hxx>
+
+//! This class is extension for Poly_Triangulation.
+//! It allows to store mesh with quad polygons as table of Poly_Element.
+//! Keep in mind that when you add a triangle, it is also added to the table of elements
+//! as Poly_Element. And it will have first index set to triangle index from Poly_Triangulation
+//! and second index will be set to 0.
+class Poly_Mesh : public Poly_Triangulation
+{
+
+public:
+
+ //! Constructs an empty mesh.
+ //! theHasUVNodes flag indicates whether 2D nodes will be associated with 3D ones, (i.e. to enable a 2D representation).
+ Standard_EXPORT Poly_Mesh (const Standard_Boolean theHasUVNodes = Standard_False);
+
+ //! Adds triangle to the mesh.
+ //! @return index of the added element.
+ Standard_EXPORT Standard_Integer AddTriangle (const Poly_Triangle& theTriangle) Standard_OVERRIDE;
+
+ //! Adds element to the mesh.
+ //! @return index of the added element.
+ //! Raises exception if at least one of the element indices is less than 1 or greater than NbTriangles.
+ Standard_EXPORT Standard_Integer AddElement (const Poly_Element& theElement);
+
+ //! @return the number of elements for this mesh.
+ Standard_Integer NbElements() const { return myElements.Size(); }
+
+ //! @return the number of quads for this mesh.
+ Standard_Integer NbQuads() const { return myNbQuads; }
+
+ //! @return element at the given index.
+ //! Raises Standard_OutOfRange exception if theIndex is less than 1 or greater than NbElements.
+ Standard_EXPORT const Poly_Element& Element (const Standard_Integer theIndex);
+
+ //! Give access to the element at the given index.
+ //! Raises Standard_OutOfRange exception if theIndex is less than 1 or greater than NbElements.
+ Standard_EXPORT void SetElement (const Standard_Integer theIndex, const Poly_Element& theElement);
+
+private:
+
+ NCollection_Vector<Poly_Element> myElements;
+ Standard_Integer myNbQuads;
+
+public:
+
+ DEFINE_STANDARD_RTTI(Poly_Mesh)
+
+};
+
+DEFINE_STANDARD_HANDLE(Poly_Mesh, Poly_Triangulation)
+
+#endif // _Poly_Mesh_HeaderFile
---C++: return const &
raises NullObject from Standard;
-
+
+ Node(me; theIndex: Integer from Standard) returns Integer from Standard;
+ ---Purpose: @return node at the given index.
+ -- Raises exception if theIndex is less than NodesLowerIndex or bigger than NodesUpperIndex.
+
+ SetNode(me: mutable; theIndex: Integer from Standard; theNode: Integer from Standard);
+ ---Purpose: Sets node at the given index.
+ -- Raises exception if theIndex is less than NodesLowerIndex or bigger than NodesUpperIndex.
+
HasParameters(me) returns Boolean from Standard;
---Purpose:
-- Returns true if parameters are associated with the nodes in this polygon.
-- are associated with the nodes in this polygon.
--
raises NullObject from Standard;
-
-
+
+ Parameter(me; theIndex: Integer from Standard) returns Real from Standard;
+ ---Purpose: @return parameter at the given index.
+ -- Raises Standard_NullObject exception if parameters has not been initialized.
+ -- Raises Standard_OutOfRange exception if theIndex is less than ParametersLowerIndex or bigger than ParametersUpperIndex.
+
+ SetParameter(me: mutable; theIndex: Integer from Standard; theValue: Real from Standard);
+ ---Purpose: Sets parameter at the given index.
+ -- Raises Standard_NullObject exception if parameters has not been initialized.
+ -- Raises Standard_OutOfRange exception if theIndex is less than ParametersLowerIndex or bigger than ParametersUpperIndex.
+
fields
myDeflection : Real from Standard;
return myNodes;
}
+//=======================================================================
+//function : Node
+//purpose :
+//=======================================================================
+
+Standard_Integer Poly_PolygonOnTriangulation::Node (const Standard_Integer theIndex) const
+{
+ Standard_OutOfRange_Raise_if ((theIndex < 1 || theIndex > myNodes.Length()),
+ "Poly_PolygonOnTriangulation::Node : index out of range");
+ return myNodes.Value (theIndex);
+}
+
+//=======================================================================
+//function : SetNode
+//purpose :
+//=======================================================================
+
+void Poly_PolygonOnTriangulation::SetNode (const Standard_Integer theIndex, const Standard_Integer theNode)
+{
+ Standard_OutOfRange_Raise_if ((theIndex < 1 || theIndex > myNodes.Length()),
+ "Poly_PolygonOnTriangulation::SetNode : index out of range");
+ myNodes.SetValue (theIndex, theNode);
+}
//=======================================================================
//function : HasParameters
return myParameters;
}
+//=======================================================================
+//function : Parameter
+//purpose :
+//=======================================================================
+
+Standard_Real Poly_PolygonOnTriangulation::Parameter (const Standard_Integer theIndex) const
+{
+ Standard_NullObject_Raise_if (myParameters.IsNull(),
+ "Poly_PolygonOnTriangulation::Parameter : parameters is NULL");
+ Standard_OutOfRange_Raise_if ((theIndex < 1 || theIndex > myParameters->Length()),
+ "Poly_PolygonOnTriangulation::Parameter : index out of range");
+ return myParameters->Value (theIndex);
+}
+
+//=======================================================================
+//function : SetParameter
+//purpose :
+//=======================================================================
+
+void Poly_PolygonOnTriangulation::SetParameter (const Standard_Integer theIndex, const Standard_Real theValue)
+{
+ Standard_NullObject_Raise_if (myParameters.IsNull(),
+ "Poly_PolygonOnTriangulation::Parameter : parameters is NULL");
+ Standard_OutOfRange_Raise_if ((theIndex < 1 || theIndex > myParameters->Length()),
+ "Poly_PolygonOnTriangulation::Parameter : index out of range");
+ myParameters->SetValue (theIndex, theValue);
+}
\ No newline at end of file
+++ /dev/null
--- Created on: 1995-03-06
--- Created by: Laurent PAINNOT
--- Copyright (c) 1995-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
-class Triangulation from Poly inherits TShared from MMgt
-
- ---Purpose: Provides a triangulation for a surface, a set of surfaces, or
- -- more generally a shape.
- -- A triangulation consists of an approximate representation
- -- of the actual shape, using a collection of points and
- -- triangles. The points are located on the surface. The
- -- edges of the triangles connect adjacent points with a
- -- straight line that approximates the true curve on the surface.
- -- A triangulation comprises:
- -- - A table of 3D nodes (3D points on the surface).
- -- - A table of triangles. Each triangle (Poly_Triangle
- -- object) comprises a triplet of indices in the table of 3D
- -- nodes specific to the triangulation.
- -- - A table of 2D nodes (2D points), parallel to the table of
- -- 3D nodes. This table is optional. If it exists, the
- -- coordinates of a 2D point are the (u, v) parameters
- -- of the corresponding 3D point on the surface
- -- approximated by the triangulation.
- -- - A deflection (optional), which maximizes the distance
- -- from a point on the surface to the corresponding point
- -- on its approximate triangulation.
- -- In many cases, algorithms do not need to work with the
- -- exact representation of a surface. A triangular
- -- representation induces simpler and more robust adjusting,
- -- faster performances, and the results are as good.
- -- This is a Transient class.
-
-uses
- HArray1OfPnt2d from TColgp,
- Array1OfPnt from TColgp,
- Array1OfPnt2d from TColgp,
- Array1OfTriangle from Poly,
- HArray1OfShortReal from TShort,
- Array1OfShortReal from TShort
-
-raises
- DomainError from Standard,
- NullObject from Standard
-
-is
-
- Create(nbNodes, nbTriangles: Integer; UVNodes: Boolean)
- returns Triangulation from Poly;
- ---Purpose: Constructs a triangulation from a set of triangles. The
- -- triangulation is initialized without a triangle or a node, but capable of
- -- containing nbNodes nodes, and nbTriangles
- -- triangles. Here the UVNodes flag indicates whether
- -- 2D nodes will be associated with 3D ones, (i.e. to
- -- enable a 2D representation).
-
- Create(Nodes: Array1OfPnt from TColgp;
- Triangles: Array1OfTriangle from Poly)
- returns Triangulation from Poly;
- ---Purpose: Constructs a triangulation from a set of triangles. The
- -- triangulation is initialized with 3D points from Nodes and triangles
- -- from Triangles.
-
- Create(Nodes: Array1OfPnt from TColgp;
- UVNodes: Array1OfPnt2d from TColgp;
- Triangles: Array1OfTriangle from Poly)
- returns Triangulation from Poly;
- ---Purpose: Constructs a triangulation from a set of triangles. The
- -- triangulation is initialized with 3D points from Nodes, 2D points from
- -- UVNodes and triangles from Triangles, where
- -- coordinates of a 2D point from UVNodes are the
- -- (u, v) parameters of the corresponding 3D point
- -- from Nodes on the surface approximated by the
- -- constructed triangulation.
-
- Deflection(me) returns Real;
- ---Purpose: Returns the deflection of this triangulation.
- Deflection(me : mutable; D : Real);
- ---Purpose: Sets the deflection of this triangulation to D.
- -- See more on deflection in Polygon2D
- RemoveUVNodes(me : mutable);
- ---Purpose: Deallocates the UV nodes.
-
- NbNodes(me) returns Integer;
- ---Purpose: Returns the number of nodes for this triangulation.
- -- Null if the nodes are not yet defined.
- ---C++: inline
-
-
- NbTriangles(me) returns Integer;
- ---Purpose: Returns the number of triangles for this triangulation.
- -- Null if the Triangles are not yet defined.
- ---C++: inline
-
- HasUVNodes(me) returns Boolean;
- ---Purpose: Returns true if 2D nodes are associated with 3D nodes for
- -- this triangulation.
- ---C++: inline
-
-
- Nodes(me) returns Array1OfPnt from TColgp
- ---Purpose: Returns the table of 3D nodes (3D points) for this triangulation.
- ---C++: return const &
- raises NullObject from Standard;
-
- ChangeNodes(me : mutable) returns Array1OfPnt from TColgp
- ---Purpose: Returns the table of 3D nodes (3D points) for this triangulation.
- -- The returned array is
- -- shared. Therefore if the table is selected by reference, you
- -- can, by simply modifying it, directly modify the data
- -- structure of this triangulation.
- ---C++: return &
- raises NullObject from Standard;
-
- UVNodes(me) returns Array1OfPnt2d from TColgp
- ---Purpose: Returns the table of 2D nodes (2D points) associated with
- -- each 3D node of this triangulation.
- -- The function HasUVNodes checks if 2D nodes
- -- are associated with the 3D nodes of this triangulation.
- -- Const reference on the 2d nodes values.
- ---C++: return const &
- raises NullObject from Standard;
-
- ChangeUVNodes(me : mutable) returns Array1OfPnt2d from TColgp
- ---Purpose: Returns the table of 2D nodes (2D points) associated with
- -- each 3D node of this triangulation.
- -- Function ChangeUVNodes shares the returned array.
- -- Therefore if the table is selected by reference,
- -- you can, by simply modifying it, directly modify the data
- -- structure of this triangulation.
- ---C++: return &
- raises NullObject from Standard;
-
- Triangles(me) returns Array1OfTriangle from Poly
- ---Purpose: Returns the table of triangles for this triangulation.
- ---C++: return const &
- raises NullObject from Standard;
-
- ChangeTriangles(me : mutable) returns Array1OfTriangle from Poly
- ---Purpose: Returns the table of triangles for this triangulation.
- -- Function ChangeUVNodes shares the returned array.
- -- Therefore if the table is selected by reference,
- -- you can, by simply modifying it, directly modify the data
- -- structure of this triangulation.
- ---C++: return &
- raises NullObject from Standard;
-
- SetNormals(me : mutable; theNormals : HArray1OfShortReal from TShort)
- ---Purpose: Sets the table of node normals.
- -- raises exception if length of theNormals != 3*NbNodes
- raises DomainError from Standard;
-
- Normals(me) returns Array1OfShortReal from TShort
- ---C++: return const &
- -- raises exception if array of normals is empty or
- -- its length != 3*NbNodes
- raises NullObject from Standard;
-
- ChangeNormals(me : mutable) returns Array1OfShortReal from TShort
- ---C++: return &
- -- raises exception if array of normals is empty or
- -- its length != 3*NbNodes
- raises NullObject from Standard;
-
- HasNormals(me) returns Boolean from Standard;
-
-fields
-
- myDeflection : Real;
- myNbNodes : Integer;
- myNbTriangles : Integer;
- myNodes : Array1OfPnt from TColgp;
- myUVNodes : HArray1OfPnt2d from TColgp;
- myTriangles : Array1OfTriangle from Poly;
-
- ---- Optional normals ---
- myNormals : HArray1OfShortReal from TShort;
-
-end Triangulation;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-#include <Poly_Triangulation.ixx>
+#include <Poly_Triangulation.hxx>
+
#include <gp_Pnt.hxx>
-#include <Poly_Triangle.hxx>
+#include <Standard_NullObject.hxx>
+#include <TColgp_HArray1OfPnt2d.hxx>
+#include <TShort_HArray1OfShortReal.hxx>
+IMPLEMENT_STANDARD_HANDLE (Poly_Triangulation, MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT (Poly_Triangulation, MMgt_TShared)
//=======================================================================
//function : Poly_Triangulation
//purpose :
//=======================================================================
-Poly_Triangulation::Poly_Triangulation(const Standard_Integer NbNodes,
- const Standard_Integer NbTriangles,
- const Standard_Boolean UVNodes) :
- myDeflection(0),
- myNbNodes(NbNodes),
- myNbTriangles(NbTriangles),
- myNodes(1, NbNodes),
- myTriangles(1, NbTriangles)
+Poly_Triangulation::Poly_Triangulation (const Standard_Integer theNbNodes,
+ const Standard_Integer theNbTriangles,
+ const Standard_Boolean theHasUVNodes)
+: myHasUVNodes (theHasUVNodes),
+ myDeflection (0)
{
- if (UVNodes) myUVNodes = new TColgp_HArray1OfPnt2d(1, myNbNodes);
+ if (theNbNodes > 0)
+ {
+ myNodes.SetValue (theNbNodes - 1, gp_Pnt());
+ if (myHasUVNodes)
+ {
+ myUVNodes.SetValue (theNbNodes - 1, gp_Pnt2d());
+ }
+ }
+ if (theNbTriangles > 0)
+ {
+ myTriangles.SetValue (theNbTriangles - 1, Poly_Triangle());
+ }
}
//=======================================================================
//purpose :
//=======================================================================
-Poly_Triangulation::Poly_Triangulation(const TColgp_Array1OfPnt& Nodes,
- const Poly_Array1OfTriangle& Triangles) :
- myDeflection(0),
- myNbNodes(Nodes.Length()),
- myNbTriangles(Triangles.Length()),
- myNodes(1, Nodes.Length()),
- myTriangles(1, Triangles.Length())
+Poly_Triangulation::Poly_Triangulation (const TColgp_Array1OfPnt& theNodes,
+ const Poly_Array1OfTriangle& theTriangles)
+: myHasUVNodes (Standard_False),
+ myDeflection (0)
{
- myNodes = Nodes;
- myTriangles = Triangles;
+ for (Standard_Integer anIndex = theNodes.Upper(); anIndex >= theNodes.Lower(); anIndex--)
+ {
+ myNodes.SetValue (anIndex - 1, theNodes (anIndex));
+ }
+ for (Standard_Integer anIndex = theTriangles.Upper(); anIndex >= theTriangles.Lower(); anIndex--)
+ {
+ myTriangles.SetValue (anIndex - 1, theTriangles (anIndex));
+ }
}
//purpose :
//=======================================================================
-Poly_Triangulation::Poly_Triangulation(const TColgp_Array1OfPnt& Nodes,
- const TColgp_Array1OfPnt2d& UVNodes,
- const Poly_Array1OfTriangle& Triangles) :
- myDeflection(0),
- myNbNodes(Nodes.Length()),
- myNbTriangles(Triangles.Length()),
- myNodes(1, Nodes.Length()),
- myTriangles(1, Triangles.Length())
+Poly_Triangulation::Poly_Triangulation (const TColgp_Array1OfPnt& theNodes,
+ const TColgp_Array1OfPnt2d& theUVNodes,
+ const Poly_Array1OfTriangle& theTriangles)
+: myHasUVNodes (theNodes.Length() == theUVNodes.Length()),
+ myDeflection (0)
{
- myNodes = Nodes;
- myTriangles = Triangles;
- myUVNodes = new TColgp_HArray1OfPnt2d(1, myNbNodes);
- myUVNodes->ChangeArray1() = UVNodes;
+ for (Standard_Integer anIndex = theNodes.Upper(); anIndex >= theNodes.Lower(); anIndex--)
+ {
+ myNodes.SetValue (anIndex - 1, theNodes (anIndex));
+ }
+ if (myHasUVNodes)
+ {
+ for (Standard_Integer anIndex = theUVNodes.Upper(); anIndex >= theUVNodes.Lower(); anIndex--)
+ {
+ myUVNodes.SetValue (anIndex - 1, theUVNodes (anIndex));
+ }
+ }
+ for (Standard_Integer anIndex = theTriangles.Upper(); anIndex >= theTriangles.Lower(); anIndex--)
+ {
+ myTriangles.SetValue (anIndex - 1, theTriangles (anIndex));
+ }
}
//=======================================================================
//purpose :
//=======================================================================
-Standard_Real Poly_Triangulation::Deflection() const
+Standard_Real Poly_Triangulation::Deflection() const
{
return myDeflection;
}
//purpose :
//=======================================================================
-void Poly_Triangulation::Deflection(const Standard_Real D)
+void Poly_Triangulation::Deflection (const Standard_Real theDeflection)
{
- myDeflection = D;
+ myDeflection = theDeflection;
}
void Poly_Triangulation::RemoveUVNodes()
{
- myUVNodes.Nullify();
+ myUVNodes.Clear();
+ myHasUVNodes = Standard_False;
}
//=======================================================================
-//function : Nodes
+//function : AddNode
//purpose :
//=======================================================================
-
-const TColgp_Array1OfPnt& Poly_Triangulation::Nodes() const
+Standard_Integer Poly_Triangulation::AddNode (const gp_Pnt& theNode)
{
- return myNodes;
+ myNodes.Append (theNode);
+
+ if (myHasUVNodes)
+ {
+ myUVNodes.Append (gp_Pnt2d());
+ }
+
+ if (!myNormals.IsEmpty())
+ {
+ Standard_Integer aNbNormals = myNodes.Size();
+ myNormals.SetValue (aNbNormals + 2, 0.0);
+ myNormals.SetValue (aNbNormals + 1, 0.0);
+ myNormals.SetValue (aNbNormals, 0.0);
+ }
+
+ return myNodes.Size();
}
//=======================================================================
-//function : ChangeNodes
+//function : Node
//purpose :
//=======================================================================
-TColgp_Array1OfPnt& Poly_Triangulation::ChangeNodes()
+const gp_Pnt& Poly_Triangulation::Node (const Standard_Integer theIndex) const
{
- return myNodes;
+ if (theIndex < 1 || theIndex > myNodes.Size())
+ {
+ Standard_OutOfRange::Raise ("Poly_Triangulation::Node : index out of range");
+ }
+ return myNodes.Value (theIndex - 1);
}
//=======================================================================
-//function : UVNodes
+//function : ChangeNode
//purpose :
//=======================================================================
-const TColgp_Array1OfPnt2d& Poly_Triangulation::UVNodes() const
+gp_Pnt& Poly_Triangulation::ChangeNode (const Standard_Integer theIndex)
{
- return myUVNodes->Array1();
+ if (theIndex < 1 || theIndex > myNodes.Size())
+ {
+ Standard_OutOfRange::Raise ("Poly_Triangulation::ChangeNode : index out of range");
+ }
+ return myNodes.ChangeValue (theIndex - 1);
}
//=======================================================================
-//function : ChangeUVNodes
+//function : UVNode
//purpose :
//=======================================================================
-TColgp_Array1OfPnt2d& Poly_Triangulation::ChangeUVNodes()
+const gp_Pnt2d& Poly_Triangulation::UVNode (const Standard_Integer theIndex) const
{
- return myUVNodes->ChangeArray1();
+ if (myUVNodes.IsEmpty() || theIndex < 1 || theIndex > myUVNodes.Size())
+ {
+ Standard_OutOfRange::Raise ("Poly_Triangulation::UVNode : index out of range");
+ }
+ return myUVNodes.Value (theIndex - 1);
}
//=======================================================================
-//function : Triangles
+//function : ChangeUVNode
//purpose :
//=======================================================================
-const Poly_Array1OfTriangle& Poly_Triangulation::Triangles() const
+gp_Pnt2d& Poly_Triangulation::ChangeUVNode (const Standard_Integer theIndex)
{
- return myTriangles;
+ if (myUVNodes.IsEmpty() || theIndex < 1 || theIndex > myUVNodes.Size())
+ {
+ Standard_OutOfRange::Raise ("Poly_Triangulation::ChangeUVNode : index out of range");
+ }
+ return myUVNodes.ChangeValue (theIndex - 1);
}
//=======================================================================
-//function : ChangeTriangles
+//function : Triangle
//purpose :
//=======================================================================
-Poly_Array1OfTriangle& Poly_Triangulation::ChangeTriangles()
+Standard_Integer Poly_Triangulation::AddTriangle (const Poly_Triangle& theTriangle)
{
- return myTriangles;
+ myTriangles.Append (theTriangle);
+ return myTriangles.Size();
}
-
//=======================================================================
-//function : SetNormals
+//function : Triangle
//purpose :
//=======================================================================
-void Poly_Triangulation::SetNormals
- (const Handle(TShort_HArray1OfShortReal)& theNormals)
+const Poly_Triangle& Poly_Triangulation::Triangle (const Standard_Integer theIndex) const
{
-
- if(theNormals.IsNull() || theNormals->Length() != 3*myNbNodes) {
- Standard_DomainError::Raise("Poly_Triangulation::SetNormals : wrong length");
+ if (theIndex < 1 || theIndex > myTriangles.Size())
+ {
+ Standard_OutOfRange::Raise ("Poly_Triangulation::Triangle : index out of range");
}
+ return myTriangles.Value (theIndex - 1);
+}
- myNormals = theNormals;
+//=======================================================================
+//function : ChangeTriangle
+//purpose :
+//=======================================================================
+Poly_Triangle& Poly_Triangulation::ChangeTriangle (const Standard_Integer theIndex)
+{
+ if (theIndex < 1 || theIndex > myTriangles.Size())
+ {
+ Standard_OutOfRange::Raise ("Poly_Triangulation::ChangeTriangle : index out of range");
+ }
+ return myTriangles.ChangeValue (theIndex - 1);
}
//=======================================================================
-//function : Normals
+//function : SetNormals
//purpose :
//=======================================================================
-const TShort_Array1OfShortReal& Poly_Triangulation::Normals() const
+void Poly_Triangulation::SetNormals (const Handle(TShort_HArray1OfShortReal)& theNormals)
{
-
- if(myNormals.IsNull() || myNormals->Length() != 3*myNbNodes) {
- Standard_NullObject::Raise("Poly_Triangulation::Normals : "
- "wrong length or null array");
+ if (theNormals.IsNull() || theNormals->Length() != 3 * NbNodes())
+ {
+ Standard_DomainError::Raise("Poly_Triangulation::SetNormals : wrong length");
}
- return myNormals->Array1();
-
+ for (Standard_Integer anIndex = theNormals->Upper(); anIndex >= theNormals->Lower(); anIndex--)
+ {
+ myNormals.SetValue (anIndex, (theNormals->Value (anIndex)));
+ }
}
//=======================================================================
-//function : ChangeNormals
+//function : SetNormal
//purpose :
//=======================================================================
-TShort_Array1OfShortReal& Poly_Triangulation::ChangeNormals()
+void Poly_Triangulation::SetNormal (const Standard_Integer theIndex, const gp_Dir& theNormal)
{
-
- if(myNormals.IsNull() || myNormals->Length() != 3*myNbNodes) {
- Standard_NullObject::Raise("Poly_Triangulation::ChangeNormals : "
- "wrong length or null array");
+ if (myNormals.IsEmpty() || theIndex < 1 || theIndex > myNodes.Size())
+ {
+ Standard_NullObject::Raise("Poly_Triangulation::SetNormal : empty array or index out of range");
}
- return myNormals->ChangeArray1();
-
+ Standard_Integer anIndex = (theIndex - 1) * 3;
+ myNormals.ChangeValue (anIndex) = (Standard_ShortReal) theNormal.X();
+ myNormals.ChangeValue (anIndex + 1) = (Standard_ShortReal) theNormal.Y();
+ myNormals.ChangeValue (anIndex + 2) = (Standard_ShortReal) theNormal.Z();
}
//=======================================================================
Standard_Boolean Poly_Triangulation::HasNormals() const
{
-
- if(myNormals.IsNull() || myNormals->Length() != 3*myNbNodes) {
+ if (myNormals.IsEmpty() || myNormals.Length() != 3 * NbNodes())
+ {
return Standard_False;
}
return Standard_True;
}
+//=======================================================================
+//function : Normal
+//purpose :
+//=======================================================================
+const gp_Dir Poly_Triangulation::Normal (const Standard_Integer theIndex) const
+{
+ if (myNormals.IsEmpty() || theIndex < 1 || theIndex > myNodes.Size())
+ {
+ Standard_NullObject::Raise("Poly_Triangulation::Normal : empty array or index out of range");
+ }
+ Standard_Integer anIndex = (theIndex - 1) * 3;
+ return gp_Dir (myNormals (anIndex),
+ myNormals (anIndex + 1),
+ myNormals (anIndex + 2));
+}
--- /dev/null
+// Copyright (c) 2015 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _Poly_Triangulation_HeaderFile
+#define _Poly_Triangulation_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineHandle.hxx>
+#include <Standard_Real.hxx>
+#include <Standard_Integer.hxx>
+#include <TColgp_Array1OfPnt.hxx>
+#include <Handle_TColgp_HArray1OfPnt2d.hxx>
+#include <Poly_Array1OfTriangle.hxx>
+#include <Handle_TShort_HArray1OfShortReal.hxx>
+#include <MMgt_TShared.hxx>
+#include <Standard_Boolean.hxx>
+#include <NCollection_Vector.hxx>
+#include <Poly_Triangle.hxx>
+
+class TColgp_HArray1OfPnt2d;
+class TShort_HArray1OfShortReal;
+class Standard_DomainError;
+class Standard_NullObject;
+class TColgp_Array1OfPnt;
+class Poly_Array1OfTriangle;
+class TColgp_Array1OfPnt2d;
+class TShort_Array1OfShortReal;
+
+//! Provides a triangulation for a surface, a set of surfaces, or more generally a shape.
+//! A triangulation consists of an approximate representation of the actual shape, using a collection of points and triangles.
+//! The points are located on the surface. The edges of the triangles connect adjacent points with a
+//! straight line that approximates the true curve on the surface.
+//! A triangulation comprises:
+//! - A table of 3D nodes (3D points on the surface).
+//! - A table of triangles. Each triangle (Poly_Triangle object) comprises a triplet of indices in the table of 3D
+//! nodes specific to the triangulation.
+//! - A table of 2D nodes (2D points), parallel to the table of 3D nodes. This table is optional.
+//! If it exists, the coordinates of a 2D point are the (u, v) parameters of the corresponding 3D point on the surface approximated by the triangulation.
+//! - A deflection (optional), which maximizes the distance from a point on the surface to the corresponding point on its approximate triangulation.
+//! In many cases, algorithms do not need to work with the exact representation of a surface.
+//! A triangular representation induces simpler and more robust adjusting, faster performances, and the results are as good.
+class Poly_Triangulation : public MMgt_TShared
+{
+
+public:
+
+ //! Constructs a triangulation from a set of triangles.
+ //! The triangulation is initialized without a triangle or a node, but capable of containing theNbNodes nodes, and theNbTriangles triangles.
+ //! Here theHasUVNodes flag indicates whether 2D nodes will be associated with 3D ones, (i.e. to enable a 2D representation).
+ Standard_EXPORT Poly_Triangulation (const Standard_Integer theNbNodes,
+ const Standard_Integer theNbTriangles,
+ const Standard_Boolean theHasUVNodes);
+
+ //! Constructs a triangulation from a set of triangles.
+ //! The triangulation is initialized with 3D points from Nodes and triangles from Triangles.
+ Standard_EXPORT Poly_Triangulation (const TColgp_Array1OfPnt& theNodes,
+ const Poly_Array1OfTriangle& theTriangles);
+
+ //! Constructs a triangulation from a set of triangles.
+ //! The triangulation is initialized with 3D points from Nodes, 2D points from theUVNodes and triangles from theTriangles,
+ //! where coordinates of a 2D point from theUVNodes are the (u, v) parameters of the corresponding 3D point
+ //! from theNodes on the surface approximated by the constructed triangulation. If size of theUVNodes != size of theNodes
+ //! then triangulation will be created without theUVNodes.
+ Standard_EXPORT Poly_Triangulation (const TColgp_Array1OfPnt& theNodes,
+ const TColgp_Array1OfPnt2d& theUVNodes,
+ const Poly_Array1OfTriangle& theTriangles);
+
+ //! Returns the deflection of this triangulation.
+ Standard_EXPORT Standard_Real Deflection() const;
+
+ //! Sets the deflection of this triangulation to theDeflection.
+ //! See more on deflection in Polygon2D
+ Standard_EXPORT void Deflection (const Standard_Real theDeflection);
+
+ //! Deallocates the UV nodes.
+ Standard_EXPORT void RemoveUVNodes();
+
+ //! @return the number of nodes for this triangulation.
+ Standard_Integer NbNodes() const { return myNodes.Size(); }
+
+ //! @return the number of triangles for this triangulation.
+ Standard_Integer NbTriangles() const { return myTriangles.Size(); }
+
+ //! @return Standard_True if 2D nodes are associated with 3D nodes for this triangulation.
+ Standard_Boolean HasUVNodes() const { return myHasUVNodes; }
+
+ //! Adds Node to the triangulation. If triangulation has UVNodes or Normals
+ //! they will be expanded and set to zero values to match the new number of nodes.
+ //! @return index of the added Node.
+ Standard_EXPORT Standard_Integer AddNode (const gp_Pnt& theNode);
+
+ //! @return node at the given index.
+ //! Raises Standard_OutOfRange exception if theIndex is less than 1 or greater than NbNodes.
+ Standard_EXPORT const gp_Pnt& Node (const Standard_Integer theIndex) const;
+
+ //! Give access to the node at the given index.
+ //! Raises Standard_OutOfRange exception if theIndex is less than 1 or greater than NbNodes.
+ Standard_EXPORT gp_Pnt& ChangeNode (const Standard_Integer theIndex);
+
+ //! @return UVNode at the given index.
+ //! Raises Standard_OutOfRange exception if theIndex is less than 1 or greater than NbNodes.
+ Standard_EXPORT const gp_Pnt2d& UVNode (const Standard_Integer theIndex) const;
+
+ //! Give access to the UVNode at the given index.
+ //! Raises Standard_OutOfRange exception if theIndex is less than 1 or greater than NbNodes.
+ Standard_EXPORT gp_Pnt2d& ChangeUVNode (const Standard_Integer theIndex);
+
+ //! Adds triangle to the triangulation.
+ //! @return index of the added triangle.
+ Standard_EXPORT virtual Standard_Integer AddTriangle (const Poly_Triangle& theTriangle);
+
+ //! @return triangle at the given index.
+ //! Raises Standard_OutOfRange exception if theIndex is less than 1 or greater than NbTriangles.
+ Standard_EXPORT const Poly_Triangle& Triangle (const Standard_Integer theIndex) const;
+
+ //! Give access to the triangle at the given index.
+ //! Raises Standard_OutOfRange exception if theIndex is less than 1 or greater than NbTriangles.
+ Standard_EXPORT Poly_Triangle& ChangeTriangle (const Standard_Integer theIndex);
+
+ //! Sets the table of node normals.
+ //! Raises exception if length of theNormals != 3 * NbNodes
+ Standard_EXPORT void SetNormals (const Handle(TShort_HArray1OfShortReal)& theNormals);
+
+ //! Changes normal at the given index.
+ //! Raises Standard_OutOfRange exception.
+ Standard_EXPORT void SetNormal (const Standard_Integer theIndex,
+ const gp_Dir& theNormal);
+
+ //! Returns Standard_True if nodal normals are defined.
+ Standard_EXPORT Standard_Boolean HasNormals() const;
+
+ //! @return normal at the given index.
+ //! Raises Standard_OutOfRange exception.
+ Standard_EXPORT const gp_Dir Normal (const Standard_Integer theIndex) const;
+
+private:
+
+ Standard_Boolean myHasUVNodes;
+ Standard_Real myDeflection;
+ NCollection_Vector<gp_Pnt> myNodes;
+ NCollection_Vector<gp_Pnt2d> myUVNodes;
+ NCollection_Vector<Poly_Triangle> myTriangles;
+ NCollection_Vector<Standard_ShortReal> myNormals;
+
+public:
+
+ DEFINE_STANDARD_RTTI(Poly_Triangulation)
+
+};
+
+DEFINE_STANDARD_HANDLE(Poly_Triangulation, MMgt_TShared)
+
+#endif // _Poly_Triangulation_HeaderFile
if (!aHIndices.IsNull())
{
const TColStd_Array1OfInteger& anIndices = aHIndices->Nodes();
- const TColgp_Array1OfPnt& aNodes = aTriangulation->Nodes();
Standard_Integer anIndex = anIndices.Lower();
if (aLocation.IsIdentity())
{
for (; anIndex <= anIndices.Upper(); ++anIndex)
{
- thePoints.Append (aNodes (anIndices (anIndex)));
+ thePoints.Append (aTriangulation->Node (anIndices (anIndex)));
}
}
else
{
for (; anIndex <= anIndices.Upper(); ++anIndex)
{
- thePoints.Append (aNodes (anIndices (anIndex)).Transformed (aLocation));
+ thePoints.Append (aTriangulation->Node (anIndices (anIndex)).Transformed (aLocation));
}
}
return Standard_True;
Handle(Poly_Triangulation) T = aTool.CurrentTriangulation (aLocation);
if (!T.IsNull())
{
- const TColgp_Array1OfPnt& aNodes = T->Nodes();
// Build the connect tool
Poly_Connect aPolyConnect (T);
TColStd_Array1OfInteger anInternal (0, 2 * aNbInternal);
Standard_Integer aFreeIndex = 1, anIntIndex = 1;
- const Poly_Array1OfTriangle& aTriangles = T->Triangles();
for (anI = 1; anI <= aNbTriangles; ++anI)
{
aPolyConnect.Triangles (anI, aT[0], aT[1], aT[2]);
- aTriangles (anI).Get (aN[0], aN[1], aN[2]);
+ T->Triangle (anI).Get (aN[0], aN[1], aN[2]);
for (aJ = 0; aJ < 3; aJ++)
{
Standard_Integer k = (aJ + 1) % 3;
Standard_Integer aFreeHalfNb = aFree.Length() / 2;
for (anI = 1; anI <= aFreeHalfNb; ++anI)
{
- gp_Pnt aPoint1 = aNodes (aFree (2 * anI - 1)).Transformed (aLocation);
- gp_Pnt aPoint2 = aNodes (aFree (2 * anI )).Transformed (aLocation);
+ gp_Pnt aPoint1 = T->Node (aFree (2 * anI - 1)).Transformed (aLocation);
+ gp_Pnt aPoint2 = T->Node (aFree (2 * anI )).Transformed (aLocation);
aSurfPoints.Append (aPoint1);
aSurfPoints.Append (aPoint2);
}
myDetectedTr (-1)
{
mySensType = theIsInterior ? Select3D_TOS_INTERIOR : Select3D_TOS_BOUNDARY;
- const Poly_Array1OfTriangle& aTriangles = myTriangul->Triangles();
- const TColgp_Array1OfPnt& aNodes = myTriangul->Nodes();
Standard_Integer aNbTriangles (myTriangul->NbTriangles());
gp_XYZ aCenter (0.0, 0.0, 0.0);
for (Standard_Integer aTriangleIdx = 1; aTriangleIdx <= aNbTriangles; aTriangleIdx++)
{
aPoly.Triangles (aTriangleIdx, aTriangle[0], aTriangle[1], aTriangle[2]);
- aTriangles (aTriangleIdx).Get (aTrNodeIdx[0], aTrNodeIdx[1], aTrNodeIdx[2]);
- aCenter += (aNodes (aTrNodeIdx[0]).XYZ() + aNodes (aTrNodeIdx[1]).XYZ()+ aNodes (aTrNodeIdx[2]).XYZ()) / 3.0;
+ myTriangul->Triangle (aTriangleIdx).Get (aTrNodeIdx[0], aTrNodeIdx[1], aTrNodeIdx[2]);
+ aCenter += (myTriangul->Node (aTrNodeIdx[0]).XYZ() + myTriangul->Node (aTrNodeIdx[1]).XYZ()+ myTriangul->Node (aTrNodeIdx[2]).XYZ()) / 3.0;
for (Standard_Integer aVertIdx = 0; aVertIdx < 3; aVertIdx++)
{
Standard_Integer aNextVert = (aVertIdx + 1) % 3;
Standard_Integer aTrNodeIdx[3];
for (Standard_Integer aTrIdx = 1; aTrIdx <= aNbTriangles; aTrIdx++)
{
- aTriangles (aTrIdx).Get (aTrNodeIdx[0], aTrNodeIdx[1], aTrNodeIdx[2]);
- aCenter += (aNodes (aTrNodeIdx[0]).XYZ() + aNodes (aTrNodeIdx[1]).XYZ()+ aNodes (aTrNodeIdx[2]).XYZ()) / 3.0;
+ myTriangul->Triangle (aTrIdx).Get (aTrNodeIdx[0], aTrNodeIdx[1], aTrNodeIdx[2]);
+ aCenter += (myTriangul->Node (aTrNodeIdx[0]).XYZ() + myTriangul->Node (aTrNodeIdx[1]).XYZ()+ myTriangul->Node (aTrNodeIdx[2]).XYZ()) / 3.0;
}
}
if (aNbTriangles != 0)
myBndBox.Clear();
for (Standard_Integer aNodeIdx = 1; aNodeIdx <= myTriangul->NbNodes(); ++aNodeIdx)
{
- myBndBox.Add (SelectMgr_Vec3 (aNodes (aNodeIdx).X(),
- aNodes (aNodeIdx).Y(),
- aNodes (aNodeIdx).Z()));
+ myBndBox.Add (SelectMgr_Vec3 (myTriangul->Node (aNodeIdx).X(),
+ myTriangul->Node (aNodeIdx).Y(),
+ myTriangul->Node (aNodeIdx).Z()));
}
if (theIsInterior)
myDetectedTr (-1)
{
mySensType = theIsInterior ? Select3D_TOS_INTERIOR : Select3D_TOS_BOUNDARY;
- myPrimitivesNb = theIsInterior ? theTrg->Triangles().Length() : theFreeEdges->Length() / 2;
+ myPrimitivesNb = theIsInterior ? theTrg->NbTriangles() : theFreeEdges->Length() / 2;
myBVHPrimIndexes = new TColStd_HArray1OfInteger(0, myPrimitivesNb - 1);
if (theIsInterior)
{
if (mySensType == Select3D_TOS_INTERIOR)
{
Standard_Integer aNode1, aNode2, aNode3;
- myTriangul->Triangles() (aPrimIdx + 1).Get (aNode1, aNode2, aNode3);
+ myTriangul->Triangle (aPrimIdx + 1).Get (aNode1, aNode2, aNode3);
- gp_Pnt aPnt1 = hasInitLoc ? myTriangul->Nodes().Value (aNode1).Transformed (myInitLocation.Transformation())
- : myTriangul->Nodes().Value (aNode1);
- gp_Pnt aPnt2 = hasInitLoc ? myTriangul->Nodes().Value (aNode2).Transformed (myInitLocation.Transformation())
- : myTriangul->Nodes().Value (aNode2);
- gp_Pnt aPnt3 = hasInitLoc ? myTriangul->Nodes().Value (aNode3).Transformed (myInitLocation.Transformation())
- : myTriangul->Nodes().Value (aNode3);
+ gp_Pnt aPnt1 = hasInitLoc ? myTriangul->Node (aNode1).Transformed (myInitLocation.Transformation())
+ : myTriangul->Node (aNode1);
+ gp_Pnt aPnt2 = hasInitLoc ? myTriangul->Node (aNode2).Transformed (myInitLocation.Transformation())
+ : myTriangul->Node (aNode2);
+ gp_Pnt aPnt3 = hasInitLoc ? myTriangul->Node (aNode3).Transformed (myInitLocation.Transformation())
+ : myTriangul->Node (aNode3);
aMinPnt = SelectMgr_Vec3 (Min (aPnt1.X(), Min (aPnt2.X(), aPnt3.X())),
Min (aPnt1.Y(), Min (aPnt2.Y(), aPnt3.Y())),
{
Standard_Integer aNodeIdx1 = myFreeEdges->Value (myFreeEdges->Lower() + aPrimIdx);
Standard_Integer aNodeIdx2 = myFreeEdges->Value (myFreeEdges->Lower() + aPrimIdx + 1);
- gp_Pnt aNode1 = hasInitLoc ? myTriangul->Nodes().Value (aNodeIdx1).Transformed (myInitLocation.Transformation())
- : myTriangul->Nodes().Value (aNodeIdx1);
- gp_Pnt aNode2 = hasInitLoc ? myTriangul->Nodes().Value (aNodeIdx2).Transformed (myInitLocation.Transformation())
- : myTriangul->Nodes().Value (aNodeIdx2);
+ gp_Pnt aNode1 = hasInitLoc ? myTriangul->Node (aNodeIdx1).Transformed (myInitLocation.Transformation())
+ : myTriangul->Node (aNodeIdx1);
+ gp_Pnt aNode2 = hasInitLoc ? myTriangul->Node (aNodeIdx2).Transformed (myInitLocation.Transformation())
+ : myTriangul->Node (aNodeIdx2);
aMinPnt = SelectMgr_Vec3 (Min (aNode1.X(), aNode2.X()),
Min (aNode1.Y(), aNode2.Y()),
Standard_Integer aSegmStartIdx = myFreeEdges->Value (aPrimitiveIdx * 2 + 1);
Standard_Integer aSegmEndIdx = myFreeEdges->Value (aPrimitiveIdx * 2 + 2);
Handle(TColgp_HArray1OfPnt) anEdgePnts = new TColgp_HArray1OfPnt (1, 2);
- gp_Pnt aSegmStart = hasInitLoc ? myTriangul->Nodes().Value (aSegmStartIdx).Transformed (myInitLocation.Transformation())
- : myTriangul->Nodes().Value (aSegmStartIdx);
- gp_Pnt aSegmEnd = hasInitLoc ? myTriangul->Nodes().Value (aSegmEndIdx).Transformed (myInitLocation.Transformation())
- : myTriangul->Nodes().Value (aSegmEndIdx);
+ gp_Pnt aSegmStart = hasInitLoc ? myTriangul->Node (aSegmStartIdx).Transformed (myInitLocation.Transformation())
+ : myTriangul->Node (aSegmStartIdx);
+ gp_Pnt aSegmEnd = hasInitLoc ? myTriangul->Node (aSegmEndIdx).Transformed (myInitLocation.Transformation())
+ : myTriangul->Node (aSegmEndIdx);
anEdgePnts->SetValue (1, aSegmStart);
anEdgePnts->SetValue (2, aSegmEnd);
Standard_Boolean isMatched = theMgr.Overlaps (anEdgePnts, Select3D_TOS_BOUNDARY, theMatchDepth);
}
else
{
- const Poly_Array1OfTriangle& aTriangles = myTriangul->Triangles();
Standard_Integer aNode1, aNode2, aNode3;
- aTriangles (aPrimitiveIdx + 1).Get (aNode1, aNode2, aNode3);
- gp_Pnt aPnt1 = hasInitLoc ? myTriangul->Nodes().Value (aNode1).Transformed (myInitLocation.Transformation())
- : myTriangul->Nodes().Value (aNode1);
- gp_Pnt aPnt2 = hasInitLoc ? myTriangul->Nodes().Value (aNode2).Transformed (myInitLocation.Transformation())
- : myTriangul->Nodes().Value (aNode2);
- gp_Pnt aPnt3 = hasInitLoc ? myTriangul->Nodes().Value (aNode3).Transformed (myInitLocation.Transformation())
- : myTriangul->Nodes().Value (aNode3);
+ myTriangul->Triangle (aPrimitiveIdx + 1).Get (aNode1, aNode2, aNode3);
+ gp_Pnt aPnt1 = hasInitLoc ? myTriangul->Node (aNode1).Transformed (myInitLocation.Transformation())
+ : myTriangul->Node (aNode1);
+ gp_Pnt aPnt2 = hasInitLoc ? myTriangul->Node (aNode2).Transformed (myInitLocation.Transformation())
+ : myTriangul->Node (aNode2);
+ gp_Pnt aPnt3 = hasInitLoc ? myTriangul->Node (aNode3).Transformed (myInitLocation.Transformation())
+ : myTriangul->Node (aNode3);
return theMgr.Overlaps (aPnt1, aPnt2, aPnt3, Select3D_TOS_INTERIOR, theMatchDepth);
}
}
if (myBndBox.IsValid())
return applyTransformation();
- const Standard_Integer aLower = myTriangul->Nodes().Lower();
- const Standard_Integer anUpper = myTriangul->Nodes().Upper();
Select3D_BndBox3d aBndBox;
- for (Standard_Integer aNodeIdx = aLower; aNodeIdx <= anUpper; ++aNodeIdx)
+ for (Standard_Integer aNodeIdx = 1; aNodeIdx <= myTriangul->NbNodes(); ++aNodeIdx)
{
- const gp_Pnt& aNode = myTriangul->Nodes().Value (aNodeIdx);
+ const gp_Pnt& aNode = myTriangul->Node (aNodeIdx);
const SelectMgr_Vec3 aNodeTransf = SelectMgr_Vec3 (aNode.X(), aNode.Y(), aNode.Z());
aBndBox.Add (aNodeTransf);
}
//=======================================================================
Standard_Integer Select3D_SensitiveTriangulation::NbSubElements()
{
- return myTriangul->Nodes().Length();
+ return myTriangul->NbNodes();
}
#include <Standard_DefineHandle.hxx>
#include <Standard_Type.hxx>
-#include <Handle_Poly_Triangulation.hxx>
+#include <Poly_Triangulation.hxx>
#include <TopLoc_Location.hxx>
#include <gp_Trsf.hxx>
#include <gp_Pnt.hxx>
Poly_Connect aPolyConnect (aT);
// Extracts vertices & normals from nodes
- const TColgp_Array1OfPnt& aNodes = aT->Nodes();
- const TColgp_Array1OfPnt2d& aUVNodes = aT->UVNodes();
- TColgp_Array1OfDir aNormals (aNodes.Lower(), aNodes.Upper());
+ TColgp_Array1OfDir aNormals (1, aT->NbNodes());
StdPrs_ToolShadedShape::Normal (aFace, aPolyConnect, aNormals);
if (theHasTexels)
}
const Standard_Integer aDecal = anArray->VertexNumber();
- for (Standard_Integer aNodeIter = aNodes.Lower(); aNodeIter <= aNodes.Upper(); ++aNodeIter)
+ for (Standard_Integer aNodeIter = 1; aNodeIter <= aT->NbNodes(); ++aNodeIter)
{
- aPoint = aNodes (aNodeIter);
+ aPoint = aT->Node (aNodeIter);
if (!aLoc.IsIdentity())
{
aPoint.Transform (aTrsf);
aNormals (aNodeIter) = aNormals (aNodeIter).Transformed (aTrsf);
}
- if (theHasTexels && aUVNodes.Upper() == aNodes.Upper())
+ if (theHasTexels && aT->HasUVNodes())
{
- const gp_Pnt2d aTexel = gp_Pnt2d ((-theUVOrigin.X() + (theUVRepeat.X() * (aUVNodes (aNodeIter).X() - aUmin)) / dUmax) / theUVScale.X(),
- (-theUVOrigin.Y() + (theUVRepeat.Y() * (aUVNodes (aNodeIter).Y() - aVmin)) / dVmax) / theUVScale.Y());
+ const gp_Pnt2d aTexel = gp_Pnt2d ((-theUVOrigin.X() + (theUVRepeat.X() * (aT->UVNode (aNodeIter).X() - aUmin)) / dUmax) / theUVScale.X(),
+ (-theUVOrigin.Y() + (theUVRepeat.Y() * (aT->UVNode (aNodeIter).Y() - aVmin)) / dVmax) / theUVScale.Y());
anArray->AddVertex (aPoint, aNormals (aNodeIter), aTexel);
}
else
}
// Fill array with vertex and edge visibility info
- const Poly_Array1OfTriangle& aTriangles = aT->Triangles();
Standard_Integer anIndex[3];
for (Standard_Integer aTriIter = 1; aTriIter <= aT->NbTriangles(); ++aTriIter)
{
if ((aFace.Orientation() == TopAbs_REVERSED) ^ isMirrored)
{
- aTriangles (aTriIter).Get (anIndex[0], anIndex[2], anIndex[1]);
+ aT->Triangle (aTriIter).Get (anIndex[0], anIndex[2], anIndex[1]);
}
else
{
- aTriangles (aTriIter).Get (anIndex[0], anIndex[1], anIndex[2]);
+ aT->Triangle (aTriIter).Get (anIndex[0], anIndex[1], anIndex[2]);
}
- gp_Pnt aP1 = aNodes (anIndex[0]);
- gp_Pnt aP2 = aNodes (anIndex[1]);
- gp_Pnt aP3 = aNodes (anIndex[2]);
+ gp_Pnt aP1 = aT->Node (anIndex[0]);
+ gp_Pnt aP2 = aT->Node (anIndex[1]);
+ gp_Pnt aP3 = aT->Node (anIndex[2]);
gp_Vec aV1 (aP1, aP2);
if (aV1.SquareMagnitude() <= aPreci)
continue;
// get edge nodes indexes from face triangulation
- const TColgp_Array1OfPnt& aTriNodes = aTriangulation->Nodes ();
const TColStd_Array1OfInteger& anEdgeNodes = anEdgePoly->Nodes ();
if (anEdgeNodes.Length () < 2)
Standard_Integer aTriIndex = anEdgeNodes.Value (aNodeIdx);
// get node and apply location transformation to the node
- gp_Pnt aTriNode = aTriNodes.Value (aTriIndex);
+ gp_Pnt aTriNode = aTriangulation->Node (aTriIndex);
if (!aTrsf.IsIdentity ())
aTriNode.Transform (aTrsf);
TColgp_Array1OfDir& theNormals)
{
const Handle(Poly_Triangulation)& aPolyTri = thePolyConnect.Triangulation();
- const TColgp_Array1OfPnt& aNodes = aPolyTri->Nodes();
if (aPolyTri->HasNormals())
{
// normals pre-computed in triangulation structure
- const TShort_Array1OfShortReal& aNormals = aPolyTri->Normals();
- const Standard_ShortReal* aNormArr = &(aNormals.Value (aNormals.Lower()));
- for (Standard_Integer aNodeIter = aNodes.Lower(); aNodeIter <= aNodes.Upper(); ++aNodeIter)
+ for (Standard_Integer aNodeIter = 1; aNodeIter <= aPolyTri->NbNodes(); ++aNodeIter)
{
- const Standard_Integer anId = 3 * (aNodeIter - aNodes.Lower());
- const gp_Dir aNorm (aNormArr[anId + 0],
- aNormArr[anId + 1],
- aNormArr[anId + 2]);
- theNormals (aNodeIter) = aNorm;
+ theNormals (aNodeIter) = aPolyTri->Normal (aNodeIter);
}
if (theFace.Orientation() == TopAbs_REVERSED)
{
- for (Standard_Integer aNodeIter = aNodes.Lower(); aNodeIter <= aNodes.Upper(); ++aNodeIter)
+ for (Standard_Integer aNodeIter = 1; aNodeIter <= aPolyTri->NbNodes(); ++aNodeIter)
{
theNormals.ChangeValue (aNodeIter).Reverse();
}
Handle(Geom_Surface) aSurf = BRep_Tool::Surface (aZeroFace);
const Standard_Real aTol = Precision::Confusion();
Handle(TShort_HArray1OfShortReal) aNormals = new TShort_HArray1OfShortReal (1, aPolyTri->NbNodes() * 3);
- const Poly_Array1OfTriangle& aTriangles = aPolyTri->Triangles();
- const TColgp_Array1OfPnt2d* aNodesUV = aPolyTri->HasUVNodes() && !aSurf.IsNull()
- ? &aPolyTri->UVNodes()
- : NULL;
+ Standard_Boolean hasUVNodes = aPolyTri->HasUVNodes() && !aSurf.IsNull();
Standard_Integer aTri[3];
- for (Standard_Integer aNodeIter = aNodes.Lower(); aNodeIter <= aNodes.Upper(); ++aNodeIter)
+ for (Standard_Integer aNodeIter = 1; aNodeIter <= aPolyTri->NbNodes(); ++aNodeIter)
{
// try to retrieve normal from real surface first, when UV coordinates are available
- if (aNodesUV == NULL
- || GeomLib::NormEstim (aSurf, aNodesUV->Value (aNodeIter), aTol, theNormals (aNodeIter)) > 1)
+ if (hasUVNodes == Standard_False
+ || GeomLib::NormEstim (aSurf, aPolyTri->UVNode (aNodeIter), aTol, theNormals (aNodeIter)) > 1)
{
// compute flat normals
gp_XYZ eqPlan (0.0, 0.0, 0.0);
for (thePolyConnect.Initialize (aNodeIter); thePolyConnect.More(); thePolyConnect.Next())
{
- aTriangles (thePolyConnect.Value()).Get (aTri[0], aTri[1], aTri[2]);
- const gp_XYZ v1 (aNodes (aTri[1]).Coord() - aNodes (aTri[0]).Coord());
- const gp_XYZ v2 (aNodes (aTri[2]).Coord() - aNodes (aTri[1]).Coord());
+ aPolyTri->Triangle (thePolyConnect.Value()).Get (aTri[0], aTri[1], aTri[2]);
+ const gp_XYZ v1 (aPolyTri->Node (aTri[1]).Coord() - aPolyTri->Node (aTri[0]).Coord());
+ const gp_XYZ v2 (aPolyTri->Node (aTri[2]).Coord() - aPolyTri->Node (aTri[1]).Coord());
const gp_XYZ vv = v1 ^ v2;
const Standard_Real aMod = vv.Modulus();
if (aMod >= aTol)
theNormals (aNodeIter) = (aModMax > aTol) ? gp_Dir (eqPlan) : gp::DZ();
}
- const Standard_Integer anId = (aNodeIter - aNodes.Lower()) * 3;
+ const Standard_Integer anId = (aNodeIter - 1) * 3;
aNormals->SetValue (anId + 1, (Standard_ShortReal )theNormals (aNodeIter).X());
aNormals->SetValue (anId + 2, (Standard_ShortReal )theNormals (aNodeIter).Y());
aNormals->SetValue (anId + 3, (Standard_ShortReal )theNormals (aNodeIter).Z());
if (theFace.Orientation() == TopAbs_REVERSED)
{
- for (Standard_Integer aNodeIter = aNodes.Lower(); aNodeIter <= aNodes.Upper(); ++aNodeIter)
+ for (Standard_Integer aNodeIter = 1; aNodeIter <= aPolyTri->NbNodes(); ++aNodeIter)
{
theNormals.ChangeValue (aNodeIter).Reverse();
}
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Macro.hxx>
-#include <Handle_Poly_Triangulation.hxx>
+#include <Poly_Triangulation.hxx>
class TopoDS_Shape;
-class Poly_Triangulation;
class TopoDS_Face;
class TopLoc_Location;
class Poly_Connect;
if (isOK)
{
const TColStd_Array1OfInteger& anIndices = anHIndices->Nodes();
- const TColgp_Array1OfPnt& aNodes = aTriangulation->Nodes();
aResultPoints = new TColgp_HArray1OfPnt (1, anIndices.Length());
{
for (Standard_Integer anIndex (anIndices.Lower()), aPntId (1); anIndex <= anIndices.Upper(); ++anIndex, ++aPntId)
{
- aResultPoints->SetValue (aPntId, aNodes (anIndices (anIndex)));
+ aResultPoints->SetValue (aPntId, aTriangulation->Node (anIndices (anIndex)));
}
}
else
{
for (Standard_Integer anIndex (anIndices.Lower()), aPntId (1); anIndex <= anIndices.Upper(); ++anIndex, ++aPntId)
{
- aResultPoints->SetValue (aPntId, aNodes (anIndices (anIndex)).Transformed (aLocation));
+ aResultPoints->SetValue (aPntId, aTriangulation->Node (anIndices (anIndex)).Transformed (aLocation));
}
}
return aResultPoints;
const Handle(Poly_Triangulation)& PT =
(*((Handle(Select3D_SensitiveTriangulation)*) &Ent))->Triangulation();
- const Poly_Array1OfTriangle& triangles = PT->Triangles();
- const TColgp_Array1OfPnt& Nodes = PT->Nodes();
Standard_Integer n[3];
TopLoc_Location iloc, bidloc;
Standard_Integer i;
for (i = 1; i <= PT->NbTriangles(); i++)
{
- triangles (i).Get (n[0], n[1], n[2]);
- gp_Pnt P1 (Nodes (n[0]).Transformed (iloc));
- gp_Pnt P2 (Nodes (n[1]).Transformed (iloc));
- gp_Pnt P3 (Nodes (n[2]).Transformed (iloc));
+ PT->Triangle (i).Get (n[0], n[1], n[2]);
+ gp_Pnt P1 (PT->Node (n[0]).Transformed (iloc));
+ gp_Pnt P2 (PT->Node (n[1]).Transformed (iloc));
+ gp_Pnt P3 (PT->Node (n[2]).Transformed (iloc));
gp_XYZ V1 (P1.XYZ());
gp_XYZ V2 (P2.XYZ());
gp_XYZ V3 (P3.XYZ());
for (i = 1; i <= PT->NbTriangles(); i++)
{
pc.Triangles (i, t[0], t[1], t[2]);
- triangles (i).Get (n[0], n[1], n[2]);
+ PT->Triangle (i).Get (n[0], n[1], n[2]);
for (j = 0; j < 3; j++)
{
Standard_Integer k = (j + 1) % 3;
}
for (Standard_Integer ifri = 1; ifri <= FreeE.Length(); ifri += 2)
{
- gp_Pnt pe1 (Nodes (FreeE (ifri)).Transformed (iloc)), pe2 (Nodes (FreeE (ifri + 1)).Transformed (iloc));
+ gp_Pnt pe1 (PT->Node (FreeE (ifri)).Transformed (iloc)), pe2 (PT->Node (FreeE (ifri + 1)).Transformed (iloc));
aSeqFree.Append(pe1);
aSeqFree.Append(pe2);
}
CSLib_DerivativeStatus Status;
CSLib_NormalStatus NStat;
S.Initialize(aFace, Standard_False);
- const TColgp_Array1OfPnt2d& UVNodes = T->UVNodes();
if (S.GetType() != GeomAbs_Plane) {
- for (i = UVNodes.Lower(); i <= UVNodes.Upper(); i++) {
- U = UVNodes(i).X();
- V = UVNodes(i).Y();
+ for (i = 1; i <= T->NbNodes(); i++) {
+ U = T->UVNode (i).X();
+ V = T->UVNode (i).Y();
S.D1(U,V,P,D1U,D1V);
CSLib::Normal(D1U,D1V,Precision::Angular(),Status,Nor(i));
if (Status != CSLib_Done) {
}
else {
gp_Dir NPlane;
- U = UVNodes(UVNodes.Lower()).X();
- V = UVNodes(UVNodes.Lower()).Y();
+ U = T->UVNode (1).X();
+ V = T->UVNode (1).Y();
S.D1(U,V,P,D1U,D1V);
CSLib::Normal(D1U,D1V,Precision::Angular(),Status,NPlane);
if (Status != CSLib_Done) {
}
}
else {
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
Standard_Integer n[3];
- const Poly_Array1OfTriangle& triangles = T->Triangles();
-
- for (i = Nodes.Lower(); i <= Nodes.Upper(); i++) {
+
+ for (i = 1; i <= T->NbNodes(); i++) {
gp_XYZ eqPlan(0, 0, 0);
for (pc.Initialize(i); pc.More(); pc.Next()) {
- triangles(pc.Value()).Get(n[0], n[1], n[2]);
- gp_XYZ v1(Nodes(n[1]).Coord()-Nodes(n[0]).Coord());
- gp_XYZ v2(Nodes(n[2]).Coord()-Nodes(n[1]).Coord());
+ T->Triangle (pc.Value()).Get(n[0], n[1], n[2]);
+ gp_XYZ v1(T->Node (n[1]).Coord() - T->Node (n[0]).Coord());
+ gp_XYZ v2(T->Node (n[2]).Coord() - T->Node (n[1]).Coord());
eqPlan += (v1^v2).Normalized();
}
Nor(i) = gp_Dir(eqPlan);
TopLoc_Location Loc, loc;
Handle(Poly_Triangulation) theTriangulation = BRep_Tool::Triangulation(face, Loc);
if (theTriangulation.IsNull()) continue; //Meshing was not done for this face!
- Poly_Array1OfTriangle theTriangles(1,theTriangulation->NbTriangles());
- theTriangles.Assign(theTriangulation->Triangles());
Mesh->AddDomain (theTriangulation->Deflection());
-
- TColgp_Array1OfPnt thePoints(1, theTriangulation->NbNodes());
- thePoints.Assign(theTriangulation->Nodes());
+
//compute normal of face
- const TColgp_Array1OfPnt& Nodes = theTriangulation->Nodes();
- TColgp_Array1OfDir NORMAL(Nodes.Lower(), Nodes.Upper());
+ TColgp_Array1OfDir NORMAL(1, theTriangulation->NbNodes());
Poly_Connect pc(theTriangulation);
Normal(face, pc, NORMAL);
Standard_Integer i;
- for(i=1;i<=thePoints.Length();i++) {
+ for(i=1;i<=theTriangulation->NbNodes();i++) {
Standard_Real X1, Y1, Z1;
- gp_Pnt p = thePoints.Value(i);
+ gp_Pnt p = theTriangulation->Node (i);
p.Transform(Loc.Transformation());
p.Coord (X1, Y1, Z1);
Mesh->AddVertex (X1, Y1, Z1);
}
try {
OCC_CATCH_SIGNALS
- for (i=1;i<=theTriangles.Length();i++) {
+ for (i=1;i<=theTriangulation->NbTriangles();i++) {
Standard_Integer V1, V2, V3;
- Poly_Triangle triangle = theTriangles.Value(i);
+ Poly_Triangle triangle = theTriangulation->Triangle (i);
triangle.Get(V1, V2, V3);
gp_Pnt P1, P2, P3;
P1 = Mesh->Vertices(Mesh->NbDomains()).Value(V1);
}
Handle( Poly_Triangulation ) polyTriangulation = new Poly_Triangulation(number_pointArray, number_triangle, false);
- TColgp_Array1OfPnt& PointsOfArray = polyTriangulation->ChangeNodes();
- Poly_Array1OfTriangle& pArrayTriangle = polyTriangulation->ChangeTriangles();
if ( mStartPhi <= 0.0 ){
x[0] = mCenter[0];
x[1] = mCenter[1];
x[2] = mCenter[2] + mRadius;
- PointsOfArray.SetValue(1,gp_Pnt(x[0],x[1],x[2]));
+ polyTriangulation->ChangeNode (1) = gp_Pnt(x[0],x[1],x[2]);
}
// Create south pole if needed
x[0] = mCenter[0];
x[1] = mCenter[1];
x[2] = mCenter[2] - mRadius;
- PointsOfArray.SetValue(2,gp_Pnt(x[0],x[1],x[2]));
+ polyTriangulation->ChangeNode (2) = gp_Pnt(x[0],x[1],x[2]);
}
number_point = 3;
x[0] = n[0] + mCenter[0];
x[1] = n[1] + mCenter[1];
x[2] = n[2] + mCenter[2];
- PointsOfArray.SetValue(number_point,gp_Pnt(x[0],x[1],x[2]));
+ polyTriangulation->ChangeNode (number_point) = gp_Pnt(x[0],x[1],x[2]);
number_point++;
}
}
pts[0] = phiResolution*i + numPoles;
pts[1] = (phiResolution*(i+1) % base) + numPoles;
pts[2] = 1;
- pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
+ polyTriangulation->ChangeTriangle (number_triangle) = Poly_Triangle(pts[0],pts[1],pts[2]);
number_triangle++;
}
}
pts[0] = phiResolution*i + numOffset;
pts[2] = ((phiResolution*(i+1)) % base) + numOffset;
pts[1] = numPoles - 1;
- pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
+ polyTriangulation->ChangeTriangle (number_triangle) = Poly_Triangle(pts[0],pts[1],pts[2]);
number_triangle++;
}
}
pts[0] = phiResolution*i + j + numPoles;
pts[1] = pts[0] + 1;
pts[2] = ((phiResolution*(i+1)+j) % base) + numPoles + 1;
- pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
+ polyTriangulation->ChangeTriangle (number_triangle) = Poly_Triangle(pts[0],pts[1],pts[2]);
number_triangle++;
pts[1] = pts[2];
pts[2] = pts[1] - 1;
- pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
+ polyTriangulation->ChangeTriangle (number_triangle) = Poly_Triangle(pts[0],pts[1],pts[2]);
number_triangle++;
}
}
Standard_Real Tol = Precision::Confusion();
gp_Dir Nor;
- for (i = PointsOfArray.Lower(); i <= PointsOfArray.Upper(); i++) {
+ for (i = 1; i <= polyTriangulation->NbNodes(); i++) {
gp_XYZ eqPlan(0, 0, 0);
for ( pc->Initialize(i); pc->More(); pc->Next()) {
- pArrayTriangle(pc->Value()).Get(index[0], index[1], index[2]);
- gp_XYZ v1(PointsOfArray(index[1]).Coord()-PointsOfArray(index[0]).Coord());
- gp_XYZ v2(PointsOfArray(index[2]).Coord()-PointsOfArray(index[1]).Coord());
+ polyTriangulation->Triangle (pc->Value()).Get(index[0], index[1], index[2]);
+ gp_XYZ v1(polyTriangulation->Node (index[1]).Coord() - polyTriangulation->Node (index[0]).Coord());
+ gp_XYZ v2(polyTriangulation->Node (index[2]).Coord() - polyTriangulation->Node (index[1]).Coord());
gp_XYZ vv = v1^v2;
Standard_Real mod = vv.Modulus();
if(mod < Tol) continue;
else
Nor = gp_Dir(0., 0., 1.);
- Standard_Integer j = (i - PointsOfArray.Lower()) * 3;
+ Standard_Integer j = (i - 1) * 3;
Normals->SetValue(j + 1, (Standard_ShortReal)Nor.X());
Normals->SetValue(j + 2, (Standard_ShortReal)Nor.Y());
Normals->SetValue(j + 3, (Standard_ShortReal)Nor.Z());
= new AIS_Triangulation (CalculationOfSphere (aCenterX, aCenterY, aCenterZ,
aResolution,
aRadius));
- Standard_Integer aNumberPoints = aShape->GetTriangulation()->Nodes().Length();
- Standard_Integer aNumberTriangles = aShape->GetTriangulation()->Triangles().Length();
+ Standard_Integer aNumberPoints = aShape->GetTriangulation()->NbNodes();
+ Standard_Integer aNumberTriangles = aShape->GetTriangulation()->NbTriangles();
// stupid initialization of Green color in RGBA space as integer
// probably wrong for big-endian CPUs
continue;
}
- const TColgp_Array1OfPnt& aNodes = aTriangulation->Nodes();
const gp_Trsf& aTrsf = aLocation.Transformation();
// extract normals from nodes
- TColgp_Array1OfDir aNormals (aNodes.Lower(), hasNormals ? aNodes.Upper() : aNodes.Lower());
+ TColgp_Array1OfDir aNormals (1, hasNormals ? aTriangulation->NbNodes() : 1);
if (hasNormals)
{
Poly_Connect aPolyConnect (aTriangulation);
StdPrs_ToolShadedShape::Normal (aFace, aPolyConnect, aNormals);
}
- for (Standard_Integer aNodeIter = aNodes.Lower(); aNodeIter <= aNodes.Upper(); ++aNodeIter)
+ for (Standard_Integer aNodeIter = 1; aNodeIter <= aTriangulation->NbNodes(); ++aNodeIter)
{
- gp_Pnt aPoint = aNodes (aNodeIter);
+ gp_Pnt aPoint = aTriangulation->Node (aNodeIter);
if (!aLocation.IsIdentity())
{
aPoint.Transform (aTrsf);
if (transform)
trsf = L.Transformation();
- const TColgp_Array1OfPnt& nodes = T->Nodes();
- const Poly_Array1OfTriangle& triangles = T->Triangles();
- Standard_Integer itriangle = triangles.Lower(), nb_triangles = triangles.Upper();
+ Standard_Integer itriangle = 1, nb_triangles = T->NbTriangles();
for (; itriangle <= nb_triangles; itriangle++)
{
ithread_triangle++;
return Standard_True;
}
- const Poly_Triangle& t = triangles.Value(itriangle);
+ const Poly_Triangle& t = T->Triangle (itriangle);
t.Get(n1, n2, n3);
- gp_Pnt p1 = nodes.Value(n1);
- gp_Pnt p2 = nodes.Value(n2);
- gp_Pnt p3 = nodes.Value(n3);
+ gp_Pnt p1 = T->Node (n1);
+ gp_Pnt p2 = T->Node (n2);
+ gp_Pnt p3 = T->Node (n3);
if (transform)
{
p1.Transform(trsf);
if (transform)
trsf = L.Transformation();
- const TColgp_Array1OfPnt& nodes = T->Nodes();
- const Poly_Array1OfTriangle& triangles = T->Triangles();
- Standard_Integer itriangle = triangles.Lower(), nb_triangles = triangles.Upper();
+ Standard_Integer itriangle = 1, nb_triangles = T->NbTriangles();
for (; itriangle <= nb_triangles; itriangle++)
{
ithread_triangle++;
return Standard_True;
}
- const Poly_Triangle& t = triangles.Value(itriangle);
+ const Poly_Triangle& t = T->Triangle (itriangle);
t.Get(n1, n2, n3);
- gp_Pnt p1 = nodes.Value(n1);
- gp_Pnt p2 = nodes.Value(n2);
- gp_Pnt p3 = nodes.Value(n3);
+ gp_Pnt p1 = T->Node (n1);
+ gp_Pnt p2 = T->Node (n2);
+ gp_Pnt p3 = T->Node (n3);
if (transform)
{
p1.Transform(trsf);
// number of triangles:
if (T.IsNull()) continue; //smh
nnn = T->NbTriangles();
-
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
- // getting a triangle. It is a triplet of indices in the node table:
- const Poly_Array1OfTriangle& triangles = T->Triangles();
-
+
// Taking the nodes of the triangle, taking into account the orientation
// of the triangle.
for (nt = 1; nt <= nnn; nt++) {
if (F.Orientation() == TopAbs_REVERSED)
- triangles(nt).Get(n1,n3,n2);
+ T->Triangle (nt).Get(n1,n3,n2);
else
- triangles(nt).Get(n1,n2,n3);
+ T->Triangle (nt).Get(n1,n2,n3);
- const gp_Pnt& P1 = Nodes(n1);
- const gp_Pnt& P2 = Nodes(n2);
- const gp_Pnt& P3 = Nodes(n3);
+ const gp_Pnt& P1 = T->Node (n1);
+ const gp_Pnt& P2 = T->Node (n2);
+ const gp_Pnt& P3 = T->Node (n3);
// controlling whether the triangle correct from a 3d point of
// view: (the triangle may exist in the UV space but the
// in the 3d space a dimension is null for example)
// 1 - Building HAV1 - array of all XYZ of nodes for Vrml_Coordinate3 from the triangles
// and HAV2 - array of all normals of nodes for Vrml_Normal
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
- TColgp_Array1OfDir NORMAL(Nodes.Lower(), Nodes.Upper());
+ TColgp_Array1OfDir NORMAL(1, T->NbNodes());
decal = nnv-1;
- for (j= Nodes.Lower(); j<= Nodes.Upper(); j++) {
- p = Nodes(j).Transformed(theLocation.Transformation());
+ for (j= 1; j<= T->NbNodes(); j++) {
+ p = T->Node (j).Transformed(theLocation.Transformation());
V.SetX(p.X()); V.SetY(p.Y()); V.SetZ(p.Z());
HAV1->SetValue(nnv,V);
// 2 - Building HAI1 - array of indexes of all triangles and
// HAI3 - array of indexes of all normales for Vrml_IndexedFaceSet
nbTriangles = T->NbTriangles();
- const Poly_Array1OfTriangle& triangles = T->Triangles();
for (i = 1; i <= nbTriangles; i++) {
pc.Triangles(i,t[0],t[1],t[2]);
if (F.Orientation() == TopAbs_REVERSED)
- triangles(i).Get(n[0],n[2],n[1]);
+ T->Triangle (i).Get(n[0],n[2],n[1]);
else
- triangles(i).Get(n[0],n[1],n[2]);
- const gp_Pnt& P1 = Nodes(n[0]);
- const gp_Pnt& P2 = Nodes(n[1]);
- const gp_Pnt& P3 = Nodes(n[2]);
+ T->Triangle (i).Get(n[0],n[1],n[2]);
+ const gp_Pnt& P1 = T->Node (n[0]);
+ const gp_Pnt& P2 = T->Node (n[1]);
+ const gp_Pnt& P3 = T->Node (n[2]);
gp_Vec V1(P1,P2);
if (V1.SquareMagnitude() > 1.e-10) {
gp_Vec V2(P2,P3);
CSLib_DerivativeStatus Status;
CSLib_NormalStatus NStat;
S.Initialize(aFace);
- const TColgp_Array1OfPnt2d& UVNodes = T->UVNodes();
- for (i = UVNodes.Lower(); i <= UVNodes.Upper(); i++) {
- U = UVNodes(i).X();
- V = UVNodes(i).Y();
+ for (i = 1; i <= T->NbNodes(); i++) {
+ U = T->UVNode (i).X();
+ V = T->UVNode (i).Y();
S.D1(U,V,P,D1U,D1V);
CSLib::Normal(D1U,D1V,Precision::Angular(),Status,Nor(i));
if (Status != CSLib_Done) {
}
}
else {
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
Standard_Integer n[3];
- const Poly_Array1OfTriangle& triangles = T->Triangles();
- for (i = Nodes.Lower(); i <= Nodes.Upper(); i++) {
+ for (i = 1; i <= T->NbNodes(); i++) {
gp_XYZ eqPlan(0, 0, 0);
for (pc.Initialize(i); pc.More(); pc.Next()) {
- triangles(pc.Value()).Get(n[0], n[1], n[2]);
- gp_XYZ v1(Nodes(n[1]).Coord()-Nodes(n[0]).Coord());
- gp_XYZ v2(Nodes(n[2]).Coord()-Nodes(n[1]).Coord());
+ T->Triangle (pc.Value()).Get(n[0], n[1], n[2]);
+ gp_XYZ v1(T->Node (n[1]).Coord() - T->Node (n[0]).Coord());
+ gp_XYZ v2(T->Node (n[2]).Coord() - T->Node (n[1]).Coord());
eqPlan += (v1^v2).Normalized();
}
Nor(i) = gp_Dir(eqPlan);
myTShape = aFace;
// Copy the triangulation vertices
- TColgp_Array1OfPnt& aNodes = aTriangulation->ChangeNodes();
NCollection_DataMap <int, int>::Iterator anIterN(mapNodeId);
for (i = 1; anIterN.More(); anIterN.Next()) {
const int aKey = anIterN.Key();
const gp_XYZ& aNodePnt = arrNodes[aKey];
- aNodes(i) = gp_Pnt (aNodePnt);
+ aTriangulation->ChangeNode (i) = gp_Pnt (aNodePnt);
anIterN.ChangeValue() = i++;
}
// Copy the triangles. Only the triangle-type polygons are supported.
// In this loop we also get rid of any possible degenerated triangles.
- Poly_Array1OfTriangle& aTriangles = aTriangulation->ChangeTriangles();
nTri = 0;
for (i = 0; i < (int)myNbPolygons; i++) {
const Standard_Integer * arrIndice;
arrIndice[0] < nNodes &&
arrIndice[1] < nNodes &&
arrIndice[2] < nNodes) // check to avoid previously skipped faces
- aTriangles(++nTri).Set (mapNodeId(arrIndice[0]),
- mapNodeId(arrIndice[1]),
- mapNodeId(arrIndice[2]));
+ aTriangulation->ChangeTriangle (++nTri).Set (mapNodeId(arrIndice[0]),
+ mapNodeId(arrIndice[1]),
+ mapNodeId(arrIndice[2]));
}
// Normals should be defined; if they are not, compute them
Standard_Integer i;
const Standard_Integer nNodes (theTri->NbNodes());
const Standard_Integer nTriangles (theTri->NbTriangles());
- const TColgp_Array1OfPnt& arrPolyNodes = theTri->Nodes();
- const Poly_Array1OfTriangle& arrTriangles = theTri->Triangles();
const Handle(VrmlData_IndexedFaceSet) aFaceSet =
new VrmlData_IndexedFaceSet (myScene,
Standard_Integer * aPolygon = static_cast<Standard_Integer *>
(anAlloc->Allocate (4*sizeof(Standard_Integer)));
aPolygon[0] = 3;
- arrTriangles(i+1).Get (aPolygon[1],aPolygon[2],aPolygon[3]);
+ theTri->Triangle (i+1).Get (aPolygon[1],aPolygon[2],aPolygon[3]);
aPolygon[1]--;
if (isReverse) {
const Standard_Integer aTmp = aPolygon[2]-1;
gp_XYZ * arrNodes = static_cast <gp_XYZ *>
(anAlloc->Allocate (nNodes * sizeof(gp_XYZ)));
for (i = 0; i < nNodes; i++)
- arrNodes[i] = arrPolyNodes(i+1).XYZ() * myScale;
+ arrNodes[i] = theTri->Node (i+1).XYZ() * myScale;
const Handle(VrmlData_Coordinate) aCoordNode =
new VrmlData_Coordinate (myScene, 0L, nNodes, arrNodes);
if(theTri->HasNormals()) {
gp_XYZ * arrVec = static_cast <gp_XYZ *>
(anAlloc->Allocate (nNodes * sizeof(gp_XYZ)));
- const TShort_Array1OfShortReal& Norm = theTri->Normals();
- Standard_Integer j;
- for (i = 0, j = 1; i < nNodes; i++, j += 3) {
-
- gp_XYZ aNormal(Norm(j), Norm(j+1), Norm(j+2));
- arrVec[i] = aNormal;
-
+ for (i = 0; i < nNodes; i++)
+ {
+ arrVec[i] = theTri->Normal (i + 1).XYZ();
}
const Handle(VrmlData_Normal) aNormalNode =
new VrmlData_Normal (myScene, 0L, nNodes, arrVec);
Handle(TShort_HArray1OfShortReal) Normals =
new TShort_HArray1OfShortReal(1, nbNormVal);
- const TColgp_Array1OfPnt2d& arrUV = theTri->UVNodes();
gp_XYZ * arrVec = static_cast <gp_XYZ *>
(anAlloc->Allocate (nNodes * sizeof(gp_XYZ)));
// Compute the normal vectors
Standard_Real Tol = Sqrt(aConf2);
for (i = 0; i < nNodes; i++) {
- const gp_Pnt2d& aUV = arrUV(i+1);
+ const gp_Pnt2d& aUV = theTri->UVNode (i+1);
gp_Dir aNormal;
gp_XYZ eqPlan(0., 0., 0.);
for (PC.Initialize(i+1); PC.More(); PC.Next()) {
- arrTriangles(PC.Value()).Get(n[0], n[1], n[2]);
- gp_XYZ v1(arrPolyNodes(n[1]).Coord()-arrPolyNodes(n[0]).Coord());
- gp_XYZ v2(arrPolyNodes(n[2]).Coord()-arrPolyNodes(n[1]).Coord());
+ theTri->Triangle (PC.Value()).Get(n[0], n[1], n[2]);
+ gp_XYZ v1(theTri->Node (n[1]).Coord() - theTri->Node (n[0]).Coord());
+ gp_XYZ v2(theTri->Node (n[2]).Coord() - theTri->Node (n[1]).Coord());
gp_XYZ vv = v1^v2;
Standard_Real mod = vv.Modulus();
facing = BRep_Tool::Triangulation(F,L);
}
- TColgp_Array1OfPnt tab(1,(facing->NbNodes()));
- tab = facing->Nodes();
- Poly_Array1OfTriangle tri(1,facing->NbTriangles());
- tri = facing->Triangles();
for (Standard_Integer i=1;i<=(facing->NbTriangles());i++)
{
- Poly_Triangle trian = tri.Value(i);
+ Poly_Triangle trian = facing->Triangle (i);
Standard_Integer index1,index2,index3;//M,N;
if( F.Orientation() == TopAbs_REVERSED )
trian.Get(index1,index3,index2);
else
trian.Get(index1,index2,index3);
- curVolume = TetraVol(aRefPoint, tab.Value(index1),
- tab.Value(index2), tab.Value(index3));
+ curVolume = TetraVol(aRefPoint, facing->Node (index1),
+ facing->Node (index2), facing->Node (index3));
myVolume += curVolume;
- curCentroid = TetraCen(aRefPoint, tab.Value(index1),
- tab.Value(index2), tab.Value(index3));
+ curCentroid = TetraCen(aRefPoint, facing->Node (index1),
+ facing->Node (index2), facing->Node (index3));
localCentroid = localCentroid + curCentroid*curVolume;
}
BRep_Tool::Triangulation(aFace, aLoc);
const Standard_Integer aLength = aTriangulation->NbNodes();
- const TColgp_Array1OfPnt& aNodes = aTriangulation->Nodes();
for ( Standard_Integer i = 1; i <= aLength; ++i )
{
- const gp_Pnt& aPoint = aNodes(i);
+ const gp_Pnt& aPoint = aTriangulation->Node (i);
anOut << " "
<< aPoint.X() << " "
BRep_Tool::Triangulation(aFace, aLoc);
const Standard_Integer aNbTriangles = aTriangulation->NbTriangles();
- const Poly_Array1OfTriangle& aTriangles = aTriangulation->Triangles();
for ( Standard_Integer i = 1, v[3]; i <= aNbTriangles; ++i )
{
- aTriangles(i).Get(v[0], v[1], v[2]);
+ aTriangulation->Triangle (i).Get(v[0], v[1], v[2]);
anOut << " "
<< v[0] - 1 << ", "
projects / occt.git / commitdiff