OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-05 18:16:23 +03:00
Code Packages Releases Activity

0031137: Modeling Data, BinTools_ShapeSet - avoid allocation of temporary arrays

Browse Source 
BinTools_ShapeSet now defines maps with proper types instead of Standard_Transient.
BinTools_ShapeSet now avoids allocation of temporary arrays while reading
triangulation and polygonal data.

Classes Poly_Triangle, Poly_PolygonOnTriangulation, Poly_Polygon3D and Poly_Polygon2D
have been cleared from .lxx files and extended by new methods for preallocating and filling array,
as alternative to passing arrays by copy.

wavefront command - export "f" instead of obsolete "fo" keys into file.
BinTools - added missing tools for reading/writing short reals.
This commit is contained in:
kgv 2019-11-06 19:26:24 +03:00 committed by bugmaster
parent 08b438b076
commit 6b467e52bb
18 changed files with 482 additions and 804 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
src/BinTools/BinTools.cxx
View File

@ -49,17 +49,34 @@ Standard_OStream& BinTools::PutInteger(Standard_OStream& OS, const Standard_Inte
//=======================================================================
//function : PutReal
//purpose :
//purpose :
//=======================================================================
Standard_OStream& BinTools::PutReal(Standard_OStream& OS, const Standard_Real aValue)
Standard_OStream& BinTools::PutReal (Standard_OStream& theOS,
const Standard_Real& theValue)
{
Standard_Real aRValue = aValue;
#if DO_INVERSE
aRValue = InverseReal (aValue);
const Standard_Real aRValue = InverseReal (theValue);
theOS.write((char*)&aRValue, sizeof(Standard_Real));
#else
theOS.write((char*)&theValue, sizeof(Standard_Real));
#endif
OS.write((char*)&aRValue, sizeof(Standard_Real));
return OS;
return theOS;
}
//=======================================================================
//function : PutShortReal
//purpose :
//=======================================================================
Standard_OStream& BinTools::PutShortReal (Standard_OStream& theOS,
const Standard_ShortReal& theValue)
{
#if DO_INVERSE
const Standard_ShortReal aValue = InverseShortReal (theValue);
theOS.write ((char*)&aValue, sizeof(Standard_ShortReal));
#else
theOS.write ((char*)&theValue, sizeof(Standard_ShortReal));
#endif
return theOS;
}
//=======================================================================
@ -76,19 +93,39 @@ Standard_OStream& BinTools::PutExtChar(Standard_OStream& OS, const Standard_ExtC
OS.write((char*)&aSValue, sizeof(Standard_ExtCharacter));
return OS;
}
//=======================================================================
//function : GetReal
//purpose :
//purpose :
//=======================================================================
Standard_IStream& BinTools::GetReal(Standard_IStream& IS, Standard_Real& aValue)
Standard_IStream& BinTools::GetReal (Standard_IStream& theIS,
Standard_Real& theValue)
{
if(!IS.read ((char*)&aValue, sizeof(Standard_Real)))
if (!theIS.read ((char*)&theValue, sizeof(Standard_Real)))
{
throw Storage_StreamTypeMismatchError();
}
#if DO_INVERSE
aValue = InverseReal (aValue);
theValue = InverseReal (theValue);
#endif
return IS;
return theIS;
}
//=======================================================================
//function : GetShortReal
//purpose :
//=======================================================================
Standard_IStream& BinTools::GetShortReal (Standard_IStream& theIS,
Standard_ShortReal& theValue)
{
if (!theIS.read ((char*)&theValue, sizeof(Standard_ShortReal)))
{
throw Storage_StreamTypeMismatchError();
}
#if DO_INVERSE
theValue = InverseShortReal (theValue);
#endif
return theIS;
}
//=======================================================================

11
src/BinTools/BinTools.hxx
View File

@ -42,9 +42,10 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT static Standard_OStream& PutReal (Standard_OStream& OS, const Standard_Real theValue);
Standard_EXPORT static Standard_OStream& PutReal (Standard_OStream& OS, const Standard_Real& theValue);
Standard_EXPORT static Standard_OStream& PutShortReal (Standard_OStream& OS, const Standard_ShortReal& theValue);
Standard_EXPORT static Standard_OStream& PutInteger (Standard_OStream& OS, const Standard_Integer theValue);
Standard_EXPORT static Standard_OStream& PutBool (Standard_OStream& OS, const Standard_Boolean theValue);
@ -52,7 +53,9 @@ public:
Standard_EXPORT static Standard_OStream& PutExtChar (Standard_OStream& OS, const Standard_ExtCharacter theValue);
Standard_EXPORT static Standard_IStream& GetReal (Standard_IStream& IS, Standard_Real& theValue);
Standard_EXPORT static Standard_IStream& GetShortReal (Standard_IStream& IS, Standard_ShortReal& theValue);
Standard_EXPORT static Standard_IStream& GetInteger (Standard_IStream& IS, Standard_Integer& theValue);
Standard_EXPORT static Standard_IStream& GetBool (Standard_IStream& IS, Standard_Boolean& theValue);

487
src/BinTools/BinTools_ShapeSet.cxx
View File

@ -725,7 +725,7 @@ void BinTools_ShapeSet::WriteGeometry(const TopoDS_Shape& S,
const TopoDS_Face& F = TopoDS::Face(S);
// Write the surface geometry
Standard_Boolean aNatRes = (BRep_Tool::NaturalRestriction(F)) ? Standard_True : Standard_False;
Standard_Boolean aNatRes = BRep_Tool::NaturalRestriction(F);
BinTools::PutBool (OS, aNatRes);
BinTools::PutReal (OS, TF->Tolerance());
BinTools::PutInteger (OS, !TF->Surface().IsNull()
@ -797,7 +797,7 @@ void BinTools_ShapeSet::ReadGeometry(const TopAbs_ShapeEnum T,
BRep_ListOfPointRepresentation& lpr = TV->ChangePoints();
TopLoc_Location L;
Standard_Boolean aNewF = (myFormatNb > 2) ? Standard_True : Standard_False;
Standard_Boolean aNewF = (myFormatNb > 2);
do {
if(aNewF) {
val = (Standard_Integer)IS.get();//case {0|1|2|3}
@ -1034,8 +1034,8 @@ void BinTools_ShapeSet::ReadGeometry(const TopAbs_ShapeEnum T,
case 5 : // -5- Polygon3D
BinTools::GetInteger(IS, c);
BinTools::GetInteger(IS, l);
//??? Bug? myBuilder.UpdateEdge(E,Handle(Poly_Polygon3D)::DownCast(myPolygons3D(c)));
myBuilder.UpdateEdge(E,Handle(Poly_Polygon3D)::DownCast(myPolygons3D(c)), Locations().Location(l));
//??? Bug? myBuilder.UpdateEdge(E,myPolygons3D(c));
myBuilder.UpdateEdge(E, myPolygons3D(c), Locations().Location(l));
break;
case 6 : // -6- Polygon on triangulation
@ -1047,18 +1047,13 @@ void BinTools_ShapeSet::ReadGeometry(const TopAbs_ShapeEnum T,
BinTools::GetInteger(IS, t);
BinTools::GetInteger(IS, l);
if (closed) {
myBuilder.UpdateEdge
(E, Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(pt)),
Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(pt2)),
Handle(Poly_Triangulation)::DownCast(myTriangulations(t)),
Locations().Location(l));
if (closed)
{
myBuilder.UpdateEdge (E, myNodes(pt), myNodes(pt2), myTriangulations(t), Locations().Location(l));
}
else {
myBuilder.UpdateEdge
(E,Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(pt)),
Handle(Poly_Triangulation)::DownCast(myTriangulations(t)),
Locations().Location(l));
else
{
myBuilder.UpdateEdge (E, myNodes(pt), myTriangulations(t), Locations().Location(l));
}
// range
break;
@ -1107,8 +1102,7 @@ void BinTools_ShapeSet::ReadGeometry(const TopAbs_ShapeEnum T,
// cas triangulation
if(aByte == 2) {
BinTools::GetInteger(IS, s);
myBuilder.UpdateFace(TopoDS::Face(S),
Handle(Poly_Triangulation)::DownCast(myTriangulations(s)));
myBuilder.UpdateFace(TopoDS::Face(S), myTriangulations(s));
}
}
break;
@ -1182,197 +1176,213 @@ void BinTools_ShapeSet::AddShapes(TopoDS_Shape& S1,
//=======================================================================
//function : WritePolygonOnTriangulation
//purpose :
//purpose :
//=======================================================================
void BinTools_ShapeSet::WritePolygonOnTriangulation(Standard_OStream& OS) const
{
Standard_Integer i, j, nbpOntri = myNodes.Extent();
OS << "PolygonOnTriangulations " << nbpOntri << "\n";
Handle(Poly_PolygonOnTriangulation) Poly;
Handle(TColStd_HArray1OfReal) Param;
try {
const Standard_Integer aNbPol = myNodes.Extent();
OS << "PolygonOnTriangulations " << aNbPol << "\n";
try
{
OCC_CATCH_SIGNALS
for (i=1; i<=nbpOntri; i++) {
Poly = Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(i));
const TColStd_Array1OfInteger& Nodes = Poly->Nodes();
BinTools::PutInteger(OS, Nodes.Length());
for (j=1; j <= Nodes.Length(); j++)
BinTools::PutInteger(OS, Nodes.Value(j));
// writing parameters:
Param = Poly->Parameters();
// write the deflection
BinTools::PutReal(OS, Poly->Deflection());
if (!Param.IsNull()) {
BinTools::PutBool(OS, Standard_True);
for (j=1; j <= Param->Length(); j++)
BinTools::PutReal(OS, Param->Value(j));
for (Standard_Integer aPolIter = 1; aPolIter <= aNbPol; ++aPolIter)
{
const Handle(Poly_PolygonOnTriangulation)& aPoly = myNodes.FindKey (aPolIter);
const TColStd_Array1OfInteger& aNodes = aPoly->Nodes();
BinTools::PutInteger(OS, aNodes.Length());
for (Standard_Integer aNodeIter = 1; aNodeIter <= aNodes.Length(); ++aNodeIter)
{
BinTools::PutInteger(OS, aNodes.Value (aNodeIter));
}
// write the deflection
BinTools::PutReal(OS, aPoly->Deflection());
// writing parameters
if (const Handle(TColStd_HArray1OfReal)& aParam = aPoly->Parameters())
{
BinTools::PutBool(OS, Standard_True);
for (Standard_Integer aNodeIter = 1; aNodeIter <= aParam->Length(); ++aNodeIter)
{
BinTools::PutReal(OS, aParam->Value (aNodeIter));
}
}
else
{
BinTools::PutBool(OS, Standard_False);
}
else
BinTools::PutBool(OS, Standard_False);
}
}
catch(Standard_Failure const& anException) {
catch (Standard_Failure const& anException)
{
Standard_SStream aMsg;
aMsg << "EXCEPTION in BinTools_ShapeSet::WritePolygonOnTriangulation(..)" << std::endl;
aMsg << anException << std::endl;
aMsg << "EXCEPTION in BinTools_ShapeSet::WritePolygonOnTriangulation(..)\n" << anException << "\n";
throw Standard_Failure(aMsg.str().c_str());
}
}
//=======================================================================
//function : ReadPolygonOnTriangulation
//purpose :
//purpose :
//=======================================================================
void BinTools_ShapeSet::ReadPolygonOnTriangulation(Standard_IStream& IS)
{
char buffer[255];
IS >> buffer;
if (IS.fail() || (strstr(buffer,"PolygonOnTriangulations") == NULL)) {
char aHeader[255];
IS >> aHeader;
if (IS.fail() || (strstr(aHeader,"PolygonOnTriangulations") == NULL))
{
throw Standard_Failure("BinTools_ShapeSet::ReadPolygonOnTriangulation: Not a PolygonOnTriangulation section");
}
Standard_Integer i, j, val, nbpol = 0, nbnodes =0;
Standard_Boolean hasparameters;
Standard_Real par;
Handle(TColStd_HArray1OfReal) Param;
Handle(Poly_PolygonOnTriangulation) Poly;
IS >> nbpol;
IS.get();//remove LF
try {
OCC_CATCH_SIGNALS
for (i=1; i<=nbpol; i++) {
BinTools::GetInteger(IS, nbnodes);
TColStd_Array1OfInteger Nodes(1, nbnodes);
for (j = 1; j <= nbnodes; j++) {
BinTools::GetInteger(IS, val);
Nodes(j) = val;
Standard_Integer aNbPol = 0;
IS >> aNbPol;
IS.get();//remove LF
try
{
OCC_CATCH_SIGNALS
for (Standard_Integer aPolIter = 1; aPolIter <= aNbPol; ++aPolIter)
{
Standard_Integer aNbNodes = 0;
BinTools::GetInteger(IS, aNbNodes);
Handle(Poly_PolygonOnTriangulation) aPoly = new Poly_PolygonOnTriangulation (aNbNodes, Standard_False);
TColStd_Array1OfInteger& aNodes = aPoly->ChangeNodes();
for (Standard_Integer aNodeIter = 1; aNodeIter <= aNbNodes; ++aNodeIter)
{
BinTools::GetInteger(IS, aNodes.ChangeValue (aNodeIter));
}
Standard_Real def;
BinTools::GetReal(IS, def);
BinTools::GetBool(IS, hasparameters);
if (hasparameters) {
TColStd_Array1OfReal Param1(1, nbnodes);
for (j = 1; j <= nbnodes; j++) {
BinTools::GetReal(IS, par);
Param1(j) = par;
}
Poly = new Poly_PolygonOnTriangulation(Nodes, Param1);
Standard_Real aDefl = 0.0;
BinTools::GetReal(IS, aDefl);
aPoly->Deflection (aDefl);
Standard_Boolean hasParameters = Standard_False;
BinTools::GetBool(IS, hasParameters);
if (hasParameters)
{
Handle(TColStd_HArray1OfReal) aParams = new TColStd_HArray1OfReal (1, aNbNodes);
for (Standard_Integer aNodeIter = 1; aNodeIter <= aNbNodes; ++aNodeIter)
{
BinTools::GetReal(IS, aParams->ChangeValue (aNodeIter));
}
aPoly->SetParameters (aParams);
}
else Poly = new Poly_PolygonOnTriangulation(Nodes);
Poly->Deflection(def);
myNodes.Add(Poly);
myNodes.Add (aPoly);
}
}
catch(Standard_Failure const& anException) {
catch (Standard_Failure const& anException)
{
Standard_SStream aMsg;
aMsg << "EXCEPTION in BinTools_ShapeSet::ReadPolygonOnTriangulation(..)" << std::endl;
aMsg << anException << std::endl;
aMsg << "EXCEPTION in BinTools_ShapeSet::ReadPolygonOnTriangulation(..)\n" << anException << "\n";
throw Standard_Failure(aMsg.str().c_str());
}
}
//=======================================================================
//function : WritePolygon3D
//purpose :
//purpose :
//=======================================================================
void BinTools_ShapeSet::WritePolygon3D(Standard_OStream& OS)const
{
Standard_Integer i, j, nbpol = myPolygons3D.Extent();
OS << "Polygon3D " << nbpol << "\n";
Handle(Poly_Polygon3D) P;
try {
const Standard_Integer aNbPol = myPolygons3D.Extent();
OS << "Polygon3D " << aNbPol << "\n";
try
{
OCC_CATCH_SIGNALS
for (i = 1; i <= nbpol; i++) {
P = Handle(Poly_Polygon3D)::DownCast(myPolygons3D(i));
BinTools::PutInteger(OS, P->NbNodes());
BinTools::PutBool(OS, P->HasParameters()? 1:0);
for (Standard_Integer aPolIter = 1; aPolIter <= aNbPol; ++aPolIter)
{
const Handle(Poly_Polygon3D)& aPoly = myPolygons3D.FindKey (aPolIter);
BinTools::PutInteger(OS, aPoly->NbNodes());
BinTools::PutBool(OS, aPoly->HasParameters());
// write the deflection
BinTools::PutReal(OS, P->Deflection());
// write the deflection
BinTools::PutReal(OS, aPoly->Deflection());
// write the nodes
Standard_Integer i1, nbNodes = P->NbNodes();
const TColgp_Array1OfPnt& Nodes = P->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());
// write the nodes
const Standard_Integer aNbNodes = aPoly->NbNodes();
const TColgp_Array1OfPnt& aNodes = aPoly->Nodes();
for (Standard_Integer aNodeIter = 1; aNodeIter <= aNbNodes; ++aNodeIter)
{
const gp_Pnt& aPnt = aNodes.Value (aNodeIter);
BinTools::PutReal(OS, aPnt.X());
BinTools::PutReal(OS, aPnt.Y());
BinTools::PutReal(OS, aPnt.Z());
}
if (P->HasParameters()) {
const TColStd_Array1OfReal& Param = P->Parameters();
for ( i1 = 1; i1 <= nbNodes; i1++ ) {
BinTools::PutReal(OS, Param(i1));
}
if (aPoly->HasParameters())
{
const TColStd_Array1OfReal& aParam = aPoly->Parameters();
for (Standard_Integer aNodeIter = 1; aNodeIter <= aNbNodes; ++aNodeIter)
{
BinTools::PutReal(OS, aParam.Value (aNodeIter));
}
}
}
}
catch(Standard_Failure const& anException) {
catch (Standard_Failure const& anException)
{
Standard_SStream aMsg;
aMsg << "EXCEPTION in BinTools_ShapeSet::WritePolygon3D(..)" << std::endl;
aMsg << anException << std::endl;
aMsg << "EXCEPTION in BinTools_ShapeSet::WritePolygon3D(..)\n" << anException << "\n";
throw Standard_Failure(aMsg.str().c_str());
}
}
//=======================================================================
//function : ReadPolygon3D
//purpose :
//purpose :
//=======================================================================
void BinTools_ShapeSet::ReadPolygon3D(Standard_IStream& IS)
{
char buffer[255];
Standard_Integer i, j, p, nbpol=0, nbnodes =0;
Standard_Boolean hasparameters = Standard_False;
Standard_Real d, x, y, z;
IS >> buffer;
char aHeader[255];
IS >> aHeader;
if (IS.fail() || strstr(buffer,"Polygon3D") == NULL) {
if (IS.fail() || strstr(aHeader,"Polygon3D") == NULL)
{
#ifdef OCCT_DEBUG
std::cout <<"Buffer: " << buffer << std::endl;
std::cout <<"Buffer: " << aHeader << std::endl;
#endif
throw Standard_Failure("BinTools_ShapeSet::ReadPolygon3D: Not a Polygon3D section");
}
Handle(Poly_Polygon3D) P;
IS >> nbpol;
IS.get();//remove LF
try {
Standard_Integer aNbPol = 0;
IS >> aNbPol;
IS.get();//remove LF
try
{
OCC_CATCH_SIGNALS
for (i=1; i<=nbpol; i++) {
BinTools::GetInteger(IS, nbnodes);
BinTools::GetBool(IS, hasparameters);
TColgp_Array1OfPnt Nodes(1, nbnodes);
BinTools::GetReal(IS, d);
for (j = 1; j <= nbnodes; j++) {
BinTools::GetReal(IS, x);
BinTools::GetReal(IS, y);
BinTools::GetReal(IS, z);
Nodes(j).SetCoord(x,y,z);
}
if (hasparameters) {
TColStd_Array1OfReal Param(1,nbnodes);
for (p = 1; p <= nbnodes; p++)
BinTools::GetReal(IS, Param(p));
for (Standard_Integer aPolIter = 1; aPolIter <= aNbPol; ++aPolIter)
{
Standard_Integer aNbNodes = 0;
Standard_Boolean hasParameters = Standard_False;
Standard_Real aDefl = 0.0;
BinTools::GetInteger(IS, aNbNodes);
BinTools::GetBool(IS, hasParameters);
BinTools::GetReal(IS, aDefl);
P = new Poly_Polygon3D(Nodes, Param);
Handle(Poly_Polygon3D) aPoly = new Poly_Polygon3D (aNbNodes, hasParameters);
aPoly->Deflection (aDefl);
TColgp_Array1OfPnt& aNodes = aPoly->ChangeNodes();
for (Standard_Integer aNodeIter = 1; aNodeIter <= aNbNodes; ++aNodeIter)
{
gp_XYZ& aPnt = aNodes.ChangeValue (aNodeIter).ChangeCoord();
BinTools::GetReal(IS, aPnt.ChangeCoord (1));
BinTools::GetReal(IS, aPnt.ChangeCoord (2));
BinTools::GetReal(IS, aPnt.ChangeCoord (3));
}
else P = new Poly_Polygon3D(Nodes);
P->Deflection(d);
myPolygons3D.Add(P);
if (hasParameters)
{
TColStd_Array1OfReal& aParam = aPoly->ChangeParameters();
for (Standard_Integer aNodeIter = 1; aNodeIter <= aNbNodes; ++aNodeIter)
{
BinTools::GetReal(IS, aParam.ChangeValue (aNodeIter));
}
}
myPolygons3D.Add (aPoly);
}
}
catch(Standard_Failure const& anException) {
catch (Standard_Failure const& anException)
{
Standard_SStream aMsg;
aMsg << "EXCEPTION in BinTools_ShapeSet::ReadPolygon3D(..)" << std::endl;
aMsg << anException << std::endl;
aMsg << "EXCEPTION in BinTools_ShapeSet::ReadPolygon3D(..)\n" << anException << "\n";
throw Standard_Failure(aMsg.str().c_str());
}
}
@ -1380,125 +1390,134 @@ void BinTools_ShapeSet::ReadPolygon3D(Standard_IStream& IS)
//=======================================================================
//function : WriteTriangulation
//purpose :
//purpose :
//=======================================================================
void BinTools_ShapeSet::WriteTriangulation(Standard_OStream& OS) const
{
Standard_Integer i, j, nbNodes, nbtri = myTriangulations.Extent();
Standard_Integer nbTriangles = 0, n1, n2, n3;
OS << "Triangulations " << nbtri << "\n";
Handle(Poly_Triangulation) T;
try {
OCC_CATCH_SIGNALS
for (i = 1; i <= nbtri; i++) {
T = Handle(Poly_Triangulation)::DownCast(myTriangulations(i));
BinTools::PutInteger(OS, T->NbNodes());
BinTools::PutInteger(OS, T->NbTriangles());
BinTools::PutBool(OS, T->HasUVNodes()? 1:0);
// write the deflection
BinTools::PutReal(OS, T->Deflection());
const Standard_Integer aNbTriangulations = myTriangulations.Extent();
OS << "Triangulations " << aNbTriangulations << "\n";
// 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());
try
{
OCC_CATCH_SIGNALS
for (Standard_Integer aTriangulationIter = 1; aTriangulationIter <= aNbTriangulations; ++aTriangulationIter)
{
const Handle(Poly_Triangulation)& aTriangulation = myTriangulations.FindKey (aTriangulationIter);
const Standard_Integer aNbNodes = aTriangulation->NbNodes();
const Standard_Integer aNbTriangles = aTriangulation->NbTriangles();
BinTools::PutInteger(OS, aNbNodes);
BinTools::PutInteger(OS, aNbTriangles);
BinTools::PutBool(OS, aTriangulation->HasUVNodes() ? 1 : 0);
BinTools::PutReal(OS, aTriangulation->Deflection());
// write the 3d nodes
const TColgp_Array1OfPnt& aNodes = aTriangulation->Nodes();
for (Standard_Integer aNodeIter = 1; aNodeIter <= aNbNodes; ++aNodeIter)
{
const gp_Pnt& aPnt = aNodes.Value (aNodeIter);
BinTools::PutReal(OS, aPnt.X());
BinTools::PutReal(OS, aPnt.Y());
BinTools::PutReal(OS, aPnt.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());
}
if (aTriangulation->HasUVNodes())
{
const TColgp_Array1OfPnt2d& aUVNodes = aTriangulation->UVNodes();
for (Standard_Integer aNodeIter = 1; aNodeIter <= aNbNodes; ++aNodeIter)
{
const gp_Pnt2d aUV = aUVNodes.Value (aNodeIter);
BinTools::PutReal(OS, aUV.X());
BinTools::PutReal(OS, aUV.Y());
}
}
nbTriangles = T->NbTriangles();
const Poly_Array1OfTriangle& Triangles = T->Triangles();
for (j = 1; j <= nbTriangles; j++) {
Triangles(j).Get(n1, n2, n3);
BinTools::PutInteger(OS, n1);
BinTools::PutInteger(OS, n2);
BinTools::PutInteger(OS, n3);
const Poly_Array1OfTriangle& aTriangles = aTriangulation->Triangles();
for (Standard_Integer aTriIter = 1; aTriIter <= aNbTriangles; ++aTriIter)
{
const Poly_Triangle& aTri = aTriangles.Value (aTriIter);
BinTools::PutInteger(OS, aTri.Value (1));
BinTools::PutInteger(OS, aTri.Value (2));
BinTools::PutInteger(OS, aTri.Value (3));
}
}
}
catch(Standard_Failure const& anException) {
catch (Standard_Failure const& anException)
{
Standard_SStream aMsg;
aMsg << "EXCEPTION in BinTools_ShapeSet::WriteTriangulation(..)" << std::endl;
aMsg << anException << std::endl;
aMsg << "EXCEPTION in BinTools_ShapeSet::WriteTriangulation(..)\n" << anException << "\n";
throw Standard_Failure(aMsg.str().c_str());
}
}
//=======================================================================
//function : ReadTriangulation
//purpose :
//purpose :
//=======================================================================
void BinTools_ShapeSet::ReadTriangulation(Standard_IStream& IS)
void BinTools_ShapeSet::ReadTriangulation (Standard_IStream& IS)
{
char buffer[255];
Standard_Integer i, j, nbtri =0;
Standard_Real d, x, y, z;
Standard_Integer nbNodes =0, nbTriangles=0;
Standard_Boolean hasUV = Standard_False;
Handle(Poly_Triangulation) T;
IS >> buffer;
if (IS.fail() || (strstr(buffer,"Triangulations") == NULL)) {
char aHeader[255];
IS >> aHeader;
if (IS.fail() || (strstr(aHeader, "Triangulations") == NULL))
{
throw Standard_Failure("BinTools_ShapeSet::Triangulation: Not a Triangulation section");
}
IS >> nbtri;
Standard_Integer aNbTriangulations = 0;
IS >> aNbTriangulations;
IS.get();// remove LF
try {
try
{
OCC_CATCH_SIGNALS
for (i=1; i<=nbtri; i++) {
BinTools::GetInteger(IS, nbNodes);
BinTools::GetInteger(IS, nbTriangles);
TColgp_Array1OfPnt Nodes(1, nbNodes);
for (Standard_Integer aTriangulationIter = 1; aTriangulationIter <= aNbTriangulations; ++aTriangulationIter)
{
Standard_Integer aNbNodes = 0, aNbTriangles = 0;
Standard_Boolean hasUV = Standard_False;
Standard_Real aDefl = 0.0;
BinTools::GetInteger(IS, aNbNodes);
BinTools::GetInteger(IS, aNbTriangles);
BinTools::GetBool(IS, hasUV);
TColgp_Array1OfPnt2d UVNodes(1, nbNodes);
BinTools::GetReal(IS, d); //deflection
for (j = 1; j <= nbNodes; j++) {
BinTools::GetReal(IS, x);
BinTools::GetReal(IS, y);
BinTools::GetReal(IS, z);
Nodes(j).SetCoord(x,y,z);
BinTools::GetReal(IS, aDefl); //deflection
Handle(Poly_Triangulation) aTriangulation = new Poly_Triangulation (aNbNodes, aNbTriangles, hasUV);
aTriangulation->Deflection (aDefl);
TColgp_Array1OfPnt& aNodes = aTriangulation->ChangeNodes();
for (Standard_Integer aNodeIter = 1; aNodeIter <= aNbNodes; ++aNodeIter)
{
Standard_Real* anXYZ = aNodes.ChangeValue (aNodeIter).ChangeCoord().ChangeData();
BinTools::GetReal(IS, anXYZ[0]);
BinTools::GetReal(IS, anXYZ[1]);
BinTools::GetReal(IS, anXYZ[2]);
}
if (hasUV) {
for (j = 1; j <= nbNodes; j++) {
BinTools::GetReal(IS, x);
BinTools::GetReal(IS, y);
UVNodes(j).SetCoord(x,y);
}
if (hasUV)
{
TColgp_Array1OfPnt2d& aUVNodes = aTriangulation->ChangeUVNodes();
for (Standard_Integer aNodeIter = 1; aNodeIter <= aNbNodes; ++aNodeIter)
{
gp_XY& anUV = aUVNodes.ChangeValue (aNodeIter).ChangeCoord();
BinTools::GetReal(IS, anUV.ChangeCoord (1));
BinTools::GetReal(IS, anUV.ChangeCoord (2));
}
}
// read the triangles
Standard_Integer n1,n2,n3;
Poly_Array1OfTriangle Triangles(1, nbTriangles);
for (j = 1; j <= nbTriangles; j++) {
BinTools::GetInteger(IS, n1);
BinTools::GetInteger(IS, n2);
BinTools::GetInteger(IS, n3);
Triangles(j).Set(n1,n2,n3);
Poly_Array1OfTriangle& aTriangles = aTriangulation->ChangeTriangles();
for (Standard_Integer aTriIter = 1; aTriIter <= aNbTriangles; ++aTriIter)
{
Poly_Triangle& aTri = aTriangles.ChangeValue (aTriIter);
BinTools::GetInteger(IS, aTri.ChangeValue (1));
BinTools::GetInteger(IS, aTri.ChangeValue (2));
BinTools::GetInteger(IS, aTri.ChangeValue (3));
}
if (hasUV) T = new Poly_Triangulation(Nodes,UVNodes,Triangles);
else T = new Poly_Triangulation(Nodes,Triangles);
T->Deflection(d);
myTriangulations.Add(T);
myTriangulations.Add (aTriangulation);
}
}
catch(Standard_Failure const& anException) {
catch (Standard_Failure const& anException)
{
Standard_SStream aMsg;
aMsg << "EXCEPTION in BinTools_ShapeSet::ReadTriangulation(..)" << std::endl;
aMsg << anException << std::endl;
aMsg << "EXCEPTION in BinTools_ShapeSet::ReadTriangulation(..)\n" << anException << "\n";
throw Standard_Failure(aMsg.str().c_str());
}
}

26
src/BinTools/BinTools_ShapeSet.hxx
View File

@ -171,19 +171,8 @@ public:
//! be read back by Read.
Standard_EXPORT void WritePolygonOnTriangulation (Standard_OStream& OS) const;
protected:
private:
TopTools_IndexedMapOfShape myShapes;
BinTools_LocationSet myLocations;
Standard_Integer myFormatNb;
@ -191,19 +180,12 @@ private:
BinTools_SurfaceSet mySurfaces;
BinTools_CurveSet myCurves;
BinTools_Curve2dSet myCurves2d;
TColStd_IndexedMapOfTransient myPolygons2D;
TColStd_IndexedMapOfTransient myPolygons3D;
TColStd_IndexedMapOfTransient myTriangulations;
TColStd_IndexedMapOfTransient myNodes;
NCollection_IndexedMap<Handle(Poly_Polygon2D), TColStd_MapTransientHasher> myPolygons2D;
NCollection_IndexedMap<Handle(Poly_Polygon3D), TColStd_MapTransientHasher> myPolygons3D;
NCollection_IndexedMap<Handle(Poly_Triangulation), TColStd_MapTransientHasher> myTriangulations;
NCollection_IndexedMap<Handle(Poly_PolygonOnTriangulation), TColStd_MapTransientHasher> myNodes;
Standard_Boolean myWithTriangles;
};
#endif // _BinTools_ShapeSet_HeaderFile

2
src/MeshTest/MeshTest.cxx
View File

@ -805,7 +805,7 @@ static Standard_Integer wavefront(Draw_Interpretor&, Standard_Integer nbarg, con
k1 = n1+totalnodes;
k2 = n2+totalnodes;
k3 = n3+totalnodes;
fprintf(outfile, "%s %d%s%d %d%s%d %d%s%d\n", "fo", k1,"//", k1, k2,"//", k2, k3,"//", k3);
fprintf(outfile, "f %d%s%d %d%s%d %d%s%d\n", k1,"//", k1, k2,"//", k2, k3,"//", k3);
}
nbpolygons += nbTriangles;
totalnodes += nbNodes;

5
src/Poly/FILES
View File

@ -19,15 +19,10 @@ Poly_MakeLoops.cxx
Poly_MakeLoops.hxx
Poly_Polygon2D.cxx
Poly_Polygon2D.hxx
Poly_Polygon2D.lxx
Poly_Polygon3D.cxx
Poly_Polygon3D.hxx
Poly_Polygon3D.lxx
Poly_PolygonOnTriangulation.cxx
Poly_PolygonOnTriangulation.hxx
Poly_PolygonOnTriangulation.lxx
Poly_Triangle.cxx
Poly_Triangle.hxx
Poly_Triangle.lxx
Poly_Triangulation.cxx
Poly_Triangulation.hxx

49
src/Poly/Poly_Polygon2D.cxx
View File

@ -14,17 +14,24 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <gp_Pnt2d.hxx>
#include <Poly_Polygon2D.hxx>
#include <Standard_NullObject.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Poly_Polygon2D,Standard_Transient)
//=======================================================================
//function : Poly_Polygon2D
//purpose :
//purpose :
//=======================================================================
Poly_Polygon2D::Poly_Polygon2D (const Standard_Integer theNbNodes)
: myDeflection (0.0),
myNodes (1, theNbNodes)
{
//
}
//=======================================================================
//function : Poly_Polygon2D
//purpose :
//=======================================================================
Poly_Polygon2D::Poly_Polygon2D(const TColgp_Array1OfPnt2d& Nodes):
myDeflection(0.),
@ -34,35 +41,3 @@ Poly_Polygon2D::Poly_Polygon2D(const TColgp_Array1OfPnt2d& Nodes):
for (i = Nodes.Lower(); i <= Nodes.Upper(); i++)
myNodes(j++) = Nodes(i);
}
//=======================================================================
//function : Deflection
//purpose :
//=======================================================================
Standard_Real Poly_Polygon2D::Deflection() const
{
return myDeflection;
}
//=======================================================================
//function : Deflection
//purpose :
//=======================================================================
void Poly_Polygon2D::Deflection(const Standard_Real D)
{
myDeflection = D;
}
//=======================================================================
//function : Nodes
//purpose :
//=======================================================================
const TColgp_Array1OfPnt2d& Poly_Polygon2D::Nodes() const
{
return myNodes;
}

48
src/Poly/Poly_Polygon2D.hxx
View File

@ -17,17 +17,10 @@
#ifndef _Poly_Polygon2D_HeaderFile
#define _Poly_Polygon2D_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class Standard_NullObject;
class Poly_Polygon2D;
DEFINE_STANDARD_HANDLE(Poly_Polygon2D, Standard_Transient)
//! Provides a polygon in 2D space (for example, in the
@ -38,13 +31,14 @@ DEFINE_STANDARD_HANDLE(Poly_Polygon2D, Standard_Transient)
//! repeated at the end of the table of nodes.
class Poly_Polygon2D : public Standard_Transient
{
public:
//! Constructs a 2D polygon with specified number of nodes.
Standard_EXPORT explicit Poly_Polygon2D (const Standard_Integer theNbNodes);
//! Constructs a 2D polygon defined by the table of points, <Nodes>.
Standard_EXPORT Poly_Polygon2D(const TColgp_Array1OfPnt2d& Nodes);
//! Returns the deflection of this polygon.
//! Deflection is used in cases where the polygon is an
//! approximate representation of a curve. Deflection
@ -64,44 +58,30 @@ public:
//! deflection to each polygon. In this case, the Deflection
//! function is used to set a value on each polygon, and
//! later to fetch the value.
Standard_EXPORT Standard_Real Deflection() const;
//! Sets the deflection of this polygon to D
Standard_EXPORT void Deflection (const Standard_Real D);
Standard_Real Deflection() const { return myDeflection; }
//! Sets the deflection of this polygon.
void Deflection (const Standard_Real theDefl) { myDeflection = theDefl; }
//! Returns the number of nodes in this polygon.
//! Note: If the polygon is closed, the point of closure is
//! repeated at the end of its table of nodes. Thus, on a closed
//! triangle, the function NbNodes returns 4.
Standard_Integer NbNodes() const;
Standard_Integer NbNodes() const { return myNodes.Length(); }
//! Returns the table of nodes for this polygon.
Standard_EXPORT const TColgp_Array1OfPnt2d& Nodes() const;
const TColgp_Array1OfPnt2d& Nodes() const { return myNodes; }
//! Returns the table of nodes for this polygon.
TColgp_Array1OfPnt2d& ChangeNodes() { return myNodes; }
DEFINE_STANDARD_RTTIEXT(Poly_Polygon2D,Standard_Transient)
protected:
private:
Standard_Real myDeflection;
TColgp_Array1OfPnt2d myNodes;
};
#include <Poly_Polygon2D.lxx>
#endif // _Poly_Polygon2D_HeaderFile

26
src/Poly/Poly_Polygon2D.lxx
View File

@ -1,26 +0,0 @@
// Created on: 1995-03-09
// 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.
//=======================================================================
//function : NbNodes
//purpose :
//=======================================================================
inline Standard_Integer Poly_Polygon2D::NbNodes() const
{
return myNodes.Length();
}

83
src/Poly/Poly_Polygon3D.cxx
View File

@ -14,14 +14,25 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <gp_Pnt.hxx>
#include <Poly_Polygon3D.hxx>
#include <Standard_NullObject.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Poly_Polygon3D,Standard_Transient)
//=======================================================================
//function : Poly_Polygon3D
//purpose :
//=======================================================================
Poly_Polygon3D::Poly_Polygon3D (const Standard_Integer theNbNodes,
const Standard_Boolean theHasParams)
: myDeflection (0.0),
myNodes (1, theNbNodes)
{
if (theHasParams)
{
myParameters = new TColStd_HArray1OfReal (1, theNbNodes);
}
}
//=======================================================================
//function : Poly_Polygon3D
//purpose :
@ -70,67 +81,3 @@ Handle(Poly_Polygon3D) Poly_Polygon3D::Copy() const
aCopy->Deflection(myDeflection);
return aCopy;
}
//=======================================================================
//function : Deflection
//purpose :
//=======================================================================
Standard_Real Poly_Polygon3D::Deflection() const
{
return myDeflection;
}
//=======================================================================
//function : Deflection
//purpose :
//=======================================================================
void Poly_Polygon3D::Deflection(const Standard_Real D)
{
myDeflection = D;
}
//=======================================================================
//function : Nodes
//purpose :
//=======================================================================
const TColgp_Array1OfPnt& Poly_Polygon3D::Nodes() const
{
return myNodes;
}
//=======================================================================
//function : HasParameters
//purpose :
//=======================================================================
Standard_Boolean Poly_Polygon3D::HasParameters() const
{
return !myParameters.IsNull();
}
//=======================================================================
//function : Parameters
//purpose :
//=======================================================================
const TColStd_Array1OfReal& Poly_Polygon3D::Parameters() const
{
return myParameters->Array1();
}
//=======================================================================
//function : ChangeParameters
//purpose :
//=======================================================================
TColStd_Array1OfReal& Poly_Polygon3D::ChangeParameters() const
{
return myParameters->ChangeArray1();
}

64
src/Poly/Poly_Polygon3D.hxx
View File

@ -17,20 +17,12 @@
#ifndef _Poly_Polygon3D_HeaderFile
#define _Poly_Polygon3D_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Standard_Transient.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class Standard_NullObject;
#include <TColStd_HArray1OfReal.hxx>
class Poly_Polygon3D;
DEFINE_STANDARD_HANDLE(Poly_Polygon3D, Standard_Transient)
//! This class Provides a polygon in 3D space. It is generally an approximate representation of a curve.
@ -42,11 +34,13 @@ DEFINE_STANDARD_HANDLE(Poly_Polygon3D, Standard_Transient)
//! parameter of the corresponding point on the curve.
class Poly_Polygon3D : public Standard_Transient
{
public:
//! onstructs a 3D polygon defined by the table of points, Nodes.
//! Constructs a 3D polygon with specific number of nodes.
Standard_EXPORT Poly_Polygon3D (const Standard_Integer theNbNodes,
const Standard_Boolean theHasParams);
//! Constructs a 3D polygon defined by the table of points, Nodes.
Standard_EXPORT Poly_Polygon3D(const TColgp_Array1OfPnt& Nodes);
//! Constructs a 3D polygon defined by
@ -63,59 +57,45 @@ public:
Standard_EXPORT virtual Handle(Poly_Polygon3D) Copy() const;
//! Returns the deflection of this polygon
Standard_EXPORT Standard_Real Deflection() const;
//! Sets the deflection of this polygon to D. See more on deflection in Poly_Polygon2D
Standard_EXPORT void Deflection (const Standard_Real D);
Standard_Real Deflection() const { return myDeflection; }
//! Sets the deflection of this polygon. See more on deflection in Poly_Polygon2D
void Deflection (const Standard_Real theDefl) { myDeflection = theDefl; }
//! Returns the number of nodes in this polygon.
//! Note: If the polygon is closed, the point of closure is
//! repeated at the end of its table of nodes. Thus, on a closed
//! triangle the function NbNodes returns 4.
Standard_Integer NbNodes() const;
Standard_Integer NbNodes() const { return myNodes.Length(); }
//! Returns the table of nodes for this polygon.
Standard_EXPORT const TColgp_Array1OfPnt& Nodes() const;
const TColgp_Array1OfPnt& Nodes() const { return myNodes; }
//! Returns the table of nodes for this polygon.
TColgp_Array1OfPnt& ChangeNodes() { return myNodes; }
//! Returns the table of the parameters associated with each node in this polygon.
//! HasParameters function checks if parameters are associated with the nodes of this polygon.
Standard_EXPORT Standard_Boolean HasParameters() const;
Standard_Boolean HasParameters() const { return !myParameters.IsNull(); }
//! Returns true if parameters are associated with the nodes
//! in this polygon.
Standard_EXPORT const TColStd_Array1OfReal& Parameters() const;
const TColStd_Array1OfReal& Parameters() const { return myParameters->Array1(); }
//! Returns the table of the parameters associated with each node in this polygon.
//! ChangeParameters function returnes the array as shared. Therefore if the table is selected by
//! reference you can, by simply modifying it, directly modify
//! the data structure of this polygon.
Standard_EXPORT TColStd_Array1OfReal& ChangeParameters() const;
TColStd_Array1OfReal& ChangeParameters() const { return myParameters->ChangeArray1(); }
DEFINE_STANDARD_RTTIEXT(Poly_Polygon3D,Standard_Transient)
protected:
private:
Standard_Real myDeflection;
TColgp_Array1OfPnt myNodes;
Handle(TColStd_HArray1OfReal) myParameters;
};
#include <Poly_Polygon3D.lxx>
#endif // _Poly_Polygon3D_HeaderFile

26
src/Poly/Poly_Polygon3D.lxx
View File

@ -1,26 +0,0 @@
// Created on: 1995-03-09
// 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.
//=======================================================================
//function : NbNodes
//purpose :
//=======================================================================
inline Standard_Integer Poly_Polygon3D::NbNodes() const
{
return myNodes.Length();
}

75
src/Poly/Poly_PolygonOnTriangulation.cxx
View File

@ -14,13 +14,25 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Poly_PolygonOnTriangulation.hxx>
#include <Standard_NullObject.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Poly_PolygonOnTriangulation,Standard_Transient)
//=======================================================================
//function : Poly_PolygonOnTriangulation
//purpose :
//=======================================================================
Poly_PolygonOnTriangulation::Poly_PolygonOnTriangulation (const Standard_Integer theNbNodes,
const Standard_Boolean theHasParams)
: myDeflection (0.0),
myNodes (1, theNbNodes)
{
if (theHasParams)
{
myParameters = new TColStd_HArray1OfReal (1, theNbNodes);
}
}
//=======================================================================
//function : Poly_PolygonOnTriangulation
//purpose :
@ -66,53 +78,16 @@ Handle(Poly_PolygonOnTriangulation) Poly_PolygonOnTriangulation::Copy() const
}
//=======================================================================
//function : Deflection
//purpose :
//function : SetParameters
//purpose :
//=======================================================================
Standard_Real Poly_PolygonOnTriangulation::Deflection() const
void Poly_PolygonOnTriangulation::SetParameters (const Handle(TColStd_HArray1OfReal)& theParameters)
{
return myDeflection;
if (!theParameters.IsNull()
&& (theParameters->Lower() != myNodes.Lower()
|| theParameters->Upper() != myNodes.Upper()))
{
throw Standard_OutOfRange ("Poly_PolygonOnTriangulation::SetParameters() - invalid array size");
}
myParameters = theParameters;
}
//=======================================================================
//function : Deflection
//purpose :
//=======================================================================
void Poly_PolygonOnTriangulation::Deflection(const Standard_Real D)
{
myDeflection = D;
}
//=======================================================================
//function : Nodes
//purpose :
//=======================================================================
const TColStd_Array1OfInteger& Poly_PolygonOnTriangulation::Nodes() const
{
return myNodes;
}
//=======================================================================
//function : HasParameters
//purpose :
//=======================================================================
Standard_Boolean Poly_PolygonOnTriangulation::HasParameters() const
{
return (!myParameters.IsNull());
}
//=======================================================================
//function : Parameters
//purpose :
//=======================================================================
Handle(TColStd_HArray1OfReal) Poly_PolygonOnTriangulation::Parameters() const
{
return myParameters;
}

66
src/Poly/Poly_PolygonOnTriangulation.hxx
View File

@ -17,20 +17,13 @@
#ifndef _Poly_PolygonOnTriangulation_HeaderFile
#define _Poly_PolygonOnTriangulation_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Standard_Transient.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class Standard_NullObject;
#include <TColStd_HArray1OfReal.hxx>
class Poly_PolygonOnTriangulation;
DEFINE_STANDARD_HANDLE(Poly_PolygonOnTriangulation, Standard_Transient)
//! This class provides a polygon in 3D space, based on the triangulation
@ -47,14 +40,15 @@ DEFINE_STANDARD_HANDLE(Poly_PolygonOnTriangulation, Standard_Transient)
//! curve.represents a 3d Polygon
class Poly_PolygonOnTriangulation : public Standard_Transient
{
public:
//! Constructs a 3D polygon on the triangulation of a shape with specified size of nodes.
Standard_EXPORT Poly_PolygonOnTriangulation (const Standard_Integer theNbNodes,
const Standard_Boolean theHasParams);
//! Constructs a 3D polygon on the triangulation of a shape,
//! defined by the table of nodes, <Nodes>.
Standard_EXPORT Poly_PolygonOnTriangulation(const TColStd_Array1OfInteger& Nodes);
//! Constructs a 3D polygon on the triangulation of a shape, defined by:
//! - the table of nodes, Nodes, and the table of parameters, <Parameters>.
@ -73,59 +67,51 @@ public:
Standard_EXPORT virtual Handle(Poly_PolygonOnTriangulation) Copy() const;
//! Returns the deflection of this polygon
Standard_EXPORT Standard_Real Deflection() const;
//! Sets the deflection of this polygon to D.
Standard_Real Deflection() const { return myDeflection; }
//! Sets the deflection of this polygon.
//! See more on deflection in Poly_Polygones2D.
Standard_EXPORT void Deflection (const Standard_Real D);
void Deflection (const Standard_Real theDefl) { myDeflection = theDefl; }
//! Returns the number of nodes for this polygon.
//! Note: If the polygon is closed, the point of closure is
//! repeated at the end of its table of nodes. Thus, on a closed
//! triangle, the function NbNodes returns 4.
Standard_Integer NbNodes() const;
Standard_Integer NbNodes() const { return myNodes.Length(); }
//! Returns the table of nodes for this polygon. A node value
//! is an index in the table of nodes specific to an existing
//! triangulation of a shape.
Standard_EXPORT const TColStd_Array1OfInteger& Nodes() const;
const TColStd_Array1OfInteger& Nodes() const { return myNodes; }
//! Returns the table of nodes for this polygon for modification.
TColStd_Array1OfInteger& ChangeNodes() { return myNodes; }
//! Returns true if parameters are associated with the nodes in this polygon.
Standard_EXPORT Standard_Boolean HasParameters() const;
Standard_Boolean HasParameters() const { return !myParameters.IsNull(); }
//! Returns the table of the parameters associated with each node in this polygon.
//! Warning
//! Use the function HasParameters to check if parameters
//! are associated with the nodes in this polygon.
Standard_EXPORT Handle(TColStd_HArray1OfReal) Parameters() const;
const Handle(TColStd_HArray1OfReal)& Parameters() const { return myParameters; }
//! Returns the table of the parameters associated with each node in this polygon.
//! Warning! HasParameters() should be called beforehand to check if parameters array is allocated.
TColStd_Array1OfReal& ChangeParameters() { return myParameters->ChangeArray1(); }
//! Sets the table of the parameters associated with each node in this polygon.
//! Raises exception if array size doesn't much number of polygon nodes.
Standard_EXPORT void SetParameters (const Handle(TColStd_HArray1OfReal)& theParameters);
DEFINE_STANDARD_RTTIEXT(Poly_PolygonOnTriangulation,Standard_Transient)
protected:
private:
Standard_Real myDeflection;
TColStd_Array1OfInteger myNodes;
Handle(TColStd_HArray1OfReal) myParameters;
};
#include <Poly_PolygonOnTriangulation.lxx>
#endif // _Poly_PolygonOnTriangulation_HeaderFile

24
src/Poly/Poly_PolygonOnTriangulation.lxx
View File

@ -1,24 +0,0 @@
// Copyright (c) 1996-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.
//=======================================================================
//function : NbNodes
//purpose :
//=======================================================================
inline Standard_Integer Poly_PolygonOnTriangulation::NbNodes() const
{
return myNodes.Length();
}

71
src/Poly/Poly_Triangle.cxx
View File

@ -1,71 +0,0 @@
// 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.
#include <Poly_Triangle.hxx>
#include <Standard_OutOfRange.hxx>
//=======================================================================
//function : Poly_Triangle
//purpose :
//=======================================================================
Poly_Triangle::Poly_Triangle()
{
myNodes[0] = myNodes[1] = myNodes[2] = 0;
}
//=======================================================================
//function : Poly_Triangle
//purpose :
//=======================================================================
Poly_Triangle::Poly_Triangle(const Standard_Integer N1,
const Standard_Integer N2,
const Standard_Integer N3)
{
myNodes[0] = N1;
myNodes[1] = N2;
myNodes[2] = N3;
}
//=======================================================================
//function : Set
//purpose :
//=======================================================================
void Poly_Triangle::Set(const Standard_Integer N1,
const Standard_Integer N2,
const Standard_Integer N3)
{
myNodes[0] = N1;
myNodes[1] = N2;
myNodes[2] = N3;
}
//=======================================================================
//function : Get
//purpose :
//=======================================================================
void Poly_Triangle::Get(Standard_Integer& N1,
Standard_Integer& N2,
Standard_Integer& N3) const
{
N1 = myNodes[0];
N2 = myNodes[1];
N3 = myNodes[2];
}

108
src/Poly/Poly_Triangle.hxx
View File

@ -20,81 +20,79 @@
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
class Standard_OutOfRange;
#include <Standard_OutOfRange.hxx>
//! Describes a component triangle of a triangulation
//! (Poly_Triangulation object).
//! A Triangle is defined by a triplet of nodes. Each node is an
//! index in the table of nodes specific to an existing
//! Describes a component triangle of a triangulation (Poly_Triangulation object).
//! A Triangle is defined by a triplet of nodes.
//! Each node is an index in the table of nodes specific to an existing
//! triangulation of a shape, and represents a point on the surface.
class Poly_Triangle
class Poly_Triangle
{
public:
DEFINE_STANDARD_ALLOC
//! Constructs a triangle and sets all indices to zero.
Standard_EXPORT Poly_Triangle();
//! Constructs a triangle and sets its three indices
//! to N1, N2 and N3 respectively, where these node values
//! are indices in the table of nodes specific to an existing
//! triangulation of a shape.
Standard_EXPORT Poly_Triangle(const Standard_Integer N1, const Standard_Integer N2, const Standard_Integer N3);
//! Sets the value of the three nodes of this triangle to N1, N2 and N3 respectively.
Standard_EXPORT void Set (const Standard_Integer N1, const Standard_Integer N2, const Standard_Integer N3);
//! Sets the value of the Indexth node of this triangle to Node.
//! Raises OutOfRange if Index is not in 1,2,3
void Set (const Standard_Integer Index, const Standard_Integer Node);
//! Returns the node indices of this triangle in N1, N2 and N3.
Standard_EXPORT void Get (Standard_Integer& N1, Standard_Integer& N2, Standard_Integer& N3) const;
Poly_Triangle() { myNodes[0] = myNodes[1] = myNodes[2] = 0; }
//! Constructs a triangle and sets its three indices,
//! where these node values are indices in the table of nodes specific to an existing triangulation of a shape.
Poly_Triangle (const Standard_Integer theN1, const Standard_Integer theN2, const Standard_Integer theN3)
{
myNodes[0] = theN1;
myNodes[1] = theN2;
myNodes[2] = theN3;
}
//! Sets the value of the three nodes of this triangle.
void Set (const Standard_Integer theN1, const Standard_Integer theN2, const Standard_Integer theN3)
{
myNodes[0] = theN1;
myNodes[1] = theN2;
myNodes[2] = theN3;
}
//! Sets the value of node with specified index of this triangle.
//! Raises Standard_OutOfRange if index is not in 1,2,3
void Set (const Standard_Integer theIndex, const Standard_Integer theNode)
{
Standard_OutOfRange_Raise_if(theIndex < 1 || theIndex > 3, "Poly_Triangle::Set(), invalid index");
myNodes[theIndex - 1] = theNode;
}
//! Returns the node indices of this triangle.
void Get (Standard_Integer& theN1, Standard_Integer& theN2, Standard_Integer& theN3) const
{
theN1 = myNodes[0];
theN2 = myNodes[1];
theN3 = myNodes[2];
}
//! Get the node of given Index.
//! Raises OutOfRange from Standard if Index is not in 1,2,3
Standard_Integer Value (const Standard_Integer Index) const;
Standard_Integer operator() (const Standard_Integer Index) const
{
return Value(Index);
}
Standard_Integer Value (const Standard_Integer theIndex) const
{
Standard_OutOfRange_Raise_if(theIndex < 1 || theIndex > 3, "Poly_Triangle::Value(), invalid index");
return myNodes[theIndex - 1];
}
Standard_Integer operator() (const Standard_Integer Index) const { return Value(Index); }
//! Get the node of given Index.
//! Raises OutOfRange if Index is not in 1,2,3
Standard_Integer& ChangeValue (const Standard_Integer Index);
Standard_Integer& operator() (const Standard_Integer Index)
{
return ChangeValue(Index);
}
protected:
Standard_Integer& ChangeValue (const Standard_Integer theIndex)
{
Standard_OutOfRange_Raise_if(theIndex < 1 || theIndex > 3, "Poly_Triangle::ChangeValue(), invalid index");
return myNodes[theIndex - 1];
}
Standard_Integer& operator() (const Standard_Integer Index) { return ChangeValue(Index); }
private:
Standard_Integer myNodes[3];
};
#include <Poly_Triangle.lxx>
#endif // _Poly_Triangle_HeaderFile

52
src/Poly/Poly_Triangle.lxx
View File

@ -1,52 +0,0 @@
// 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.
#include <Standard_OutOfRange.hxx>
//=======================================================================
//function : Set
//purpose :
//=======================================================================
inline void Poly_Triangle::Set(const Standard_Integer Index, const Standard_Integer Node)
{
Standard_OutOfRange_Raise_if(Index < 1 || Index > 3,NULL);
myNodes[Index-1] = Node;
}
//=======================================================================
//function : Value
//purpose :
//=======================================================================
inline Standard_Integer Poly_Triangle::Value(const Standard_Integer Index) const
{
Standard_OutOfRange_Raise_if(Index < 1 || Index > 3,NULL);
return myNodes[Index-1];
}
//=======================================================================
//function : ChangeValue
//purpose :
//=======================================================================
inline Standard_Integer& Poly_Triangle::ChangeValue
(const Standard_Integer Index)
{
Standard_OutOfRange_Raise_if(Index < 1 || Index > 3,NULL);
return myNodes[Index-1];
}