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.
//=======================================================================
//function : PutReal
-//purpose :
+//purpose :
//=======================================================================
+Standard_OStream& BinTools::PutReal (Standard_OStream& theOS,
+ const Standard_Real& theValue)
+{
+#if DO_INVERSE
+ const Standard_Real aRValue = InverseReal (theValue);
+ theOS.write((char*)&aRValue, sizeof(Standard_Real));
+#else
+ theOS.write((char*)&theValue, sizeof(Standard_Real));
+#endif
+ return theOS;
+}
-Standard_OStream& BinTools::PutReal(Standard_OStream& OS, const Standard_Real aValue)
+//=======================================================================
+//function : PutShortReal
+//purpose :
+//=======================================================================
+Standard_OStream& BinTools::PutShortReal (Standard_OStream& theOS,
+ const Standard_ShortReal& theValue)
{
- Standard_Real aRValue = aValue;
#if DO_INVERSE
- aRValue = InverseReal (aValue);
+ const Standard_ShortReal aValue = InverseShortReal (theValue);
+ theOS.write ((char*)&aValue, sizeof(Standard_ShortReal));
+#else
+ theOS.write ((char*)&theValue, sizeof(Standard_ShortReal));
#endif
- OS.write((char*)&aRValue, sizeof(Standard_Real));
- return OS;
+ return theOS;
}
//=======================================================================
OS.write((char*)&aSValue, sizeof(Standard_ExtCharacter));
return OS;
}
+
//=======================================================================
//function : GetReal
-//purpose :
+//purpose :
//=======================================================================
+Standard_IStream& BinTools::GetReal (Standard_IStream& theIS,
+ Standard_Real& theValue)
+{
+ if (!theIS.read ((char*)&theValue, sizeof(Standard_Real)))
+ {
+ throw Storage_StreamTypeMismatchError();
+ }
+#if DO_INVERSE
+ theValue = InverseReal (theValue);
+#endif
+ return theIS;
+}
-Standard_IStream& BinTools::GetReal(Standard_IStream& IS, Standard_Real& aValue)
+//=======================================================================
+//function : GetShortReal
+//purpose :
+//=======================================================================
+Standard_IStream& BinTools::GetShortReal (Standard_IStream& theIS,
+ Standard_ShortReal& theValue)
{
- if(!IS.read ((char*)&aValue, sizeof(Standard_Real)))
+ if (!theIS.read ((char*)&theValue, sizeof(Standard_ShortReal)))
+ {
throw Storage_StreamTypeMismatchError();
+ }
#if DO_INVERSE
- aValue = InverseReal (aValue);
+ theValue = InverseShortReal (theValue);
#endif
- return IS;
+ return theIS;
}
//=======================================================================
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);
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);
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()
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}
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
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;
// 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;
//=======================================================================
//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);
-
- // write the deflection
- BinTools::PutReal(OS, P->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());
+ 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, aPoly->Deflection());
+
+ // 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);
+ 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);
+
+ 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));
}
- if (hasparameters) {
- TColStd_Array1OfReal Param(1,nbnodes);
- for (p = 1; p <= nbnodes; p++)
- BinTools::GetReal(IS, Param(p));
-
- P = new Poly_Polygon3D(Nodes, Param);
+ if (hasParameters)
+ {
+ TColStd_Array1OfReal& aParam = aPoly->ChangeParameters();
+ for (Standard_Integer aNodeIter = 1; aNodeIter <= aNbNodes; ++aNodeIter)
+ {
+ BinTools::GetReal(IS, aParam.ChangeValue (aNodeIter));
+ }
}
- else P = new Poly_Polygon3D(Nodes);
- P->Deflection(d);
- myPolygons3D.Add(P);
+
+ 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());
}
}
//=======================================================================
//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 {
+ const Standard_Integer aNbTriangulations = myTriangulations.Extent();
+ OS << "Triangulations " << aNbTriangulations << "\n";
+
+ 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());
-
- // 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());
+ 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());
}
}
//! be read back by Read.
Standard_EXPORT void WritePolygonOnTriangulation (Standard_OStream& OS) const;
-
-
-
-protected:
-
-
-
-
-
private:
-
-
TopTools_IndexedMapOfShape myShapes;
BinTools_LocationSet myLocations;
Standard_Integer myFormatNb;
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
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;
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
// 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.),
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;
-}
-
-
#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
//! 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
//! 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;
-
- //! Returns the table of nodes for this polygon.
- Standard_EXPORT const TColgp_Array1OfPnt2d& Nodes() const;
-
+ Standard_Integer NbNodes() const { return myNodes.Length(); }
+ //! Returns the table of nodes for this polygon.
+ 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
+++ /dev/null
-// 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();
-}
-
// 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 :
//=======================================================================
Poly_Polygon3D::Poly_Polygon3D(const TColgp_Array1OfPnt& Nodes):
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();
-}
-
-
#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.
//! 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
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
+++ /dev/null
-// 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();
-}
-
// 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 :
//=======================================================================
Poly_PolygonOnTriangulation::Poly_PolygonOnTriangulation
}
//=======================================================================
-//function : Deflection
-//purpose :
-//=======================================================================
-
-Standard_Real Poly_PolygonOnTriangulation::Deflection() const
-{
- return myDeflection;
-}
-
-//=======================================================================
-//function : Deflection
-//purpose :
+//function : SetParameters
+//purpose :
//=======================================================================
-
-void Poly_PolygonOnTriangulation::Deflection(const Standard_Real D)
+void Poly_PolygonOnTriangulation::SetParameters (const Handle(TColStd_HArray1OfReal)& theParameters)
{
- myDeflection = D;
+ if (!theParameters.IsNull()
+ && (theParameters->Lower() != myNodes.Lower()
+ || theParameters->Upper() != myNodes.Upper()))
+ {
+ throw Standard_OutOfRange ("Poly_PolygonOnTriangulation::SetParameters() - invalid array size");
+ }
+ myParameters = theParameters;
}
-
-//=======================================================================
-//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;
-}
-
#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_Type.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
//! 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>.
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
+++ /dev/null
-// 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();
-}
-
+++ /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.
-
-
-#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];
-}
-
#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);
-}
-
- //! 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 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 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
+++ /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.
-
-#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];
-}
-
projects / occt.git / commitdiff