#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Vertex.hxx>
+#include <Message_ProgressSentry.hxx>
#include <string.h>
//#define MDTV_DEB 1
{}
//=======================================================================
-//function : Delete
+//function : ~BinTools_ShapeSet
//purpose :
//=======================================================================
-void BinTools_ShapeSet::Delete()
+BinTools_ShapeSet::~BinTools_ShapeSet()
{}
-//=======================================================================
-//function : SetWithTriangles
-//purpose :
-//=======================================================================
-void BinTools_ShapeSet::SetWithTriangles(const Standard_Boolean isWithTriangles)
-{
- myWithTriangles = isWithTriangles;
-}
-
//=======================================================================
//function : SetFormatNb
//purpose :
Handle(BRep_TFace) TF = Handle(BRep_TFace)::DownCast(S.TShape());
if (!TF->Surface().IsNull()) mySurfaces.Add(TF->Surface());
- if (myWithTriangles) {
+ if (myWithTriangles
+ || TF->Surface().IsNull())
+ {
Handle(Poly_Triangulation) Tr = TF->Triangulation();
if (!Tr.IsNull()) myTriangulations.Add(Tr);
}
//purpose :
//=======================================================================
-void BinTools_ShapeSet::WriteGeometry(Standard_OStream& OS)const
+void BinTools_ShapeSet::WriteGeometry (Standard_OStream& OS,
+ const Handle(Message_ProgressIndicator)& theProgress)const
{
- myCurves2d.Write(OS);
- myCurves.Write(OS);
- WritePolygon3D(OS);
- WritePolygonOnTriangulation(OS);
- mySurfaces.Write(OS);
- WriteTriangulation(OS);
+ Message_ProgressSentry aPS(theProgress, "Writing geometry", 0, 6, 1);
+ myCurves2d.Write(OS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
+ myCurves.Write(OS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
+ WritePolygon3D(OS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
+ WritePolygonOnTriangulation(OS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
+ mySurfaces.Write(OS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
+ WriteTriangulation(OS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
}
//=======================================================================
//purpose :
//=======================================================================
-void BinTools_ShapeSet::Write(Standard_OStream& OS)const
+void BinTools_ShapeSet::Write (Standard_OStream& OS,
+ const Handle(Message_ProgressIndicator)& theProgress)const
{
// write the copyright
if (myFormatNb == 3)
- OS << "\n" << Version_3 << endl;
+ OS << "\n" << Version_3 << "\n";
else if (myFormatNb == 2)
- OS << "\n" << Version_2 << endl;
+ OS << "\n" << Version_2 << "\n";
else
- OS << "\n" << Version_1 << endl;
+ OS << "\n" << Version_1 << "\n";
//-----------------------------------------
// write the locations
// write the geometry
//-----------------------------------------
- WriteGeometry(OS);
+ Message_ProgressSentry aPS(theProgress, "Writing geometry", 0, 2, 1);
+ WriteGeometry(OS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
+
//-----------------------------------------
// write the shapes
//-----------------------------------------
Standard_Integer i, nbShapes = myShapes.Extent();
-
+ Message_ProgressSentry aPSinner(theProgress, "Writing shapes", 0, nbShapes, 1);
OS << "\nTShapes " << nbShapes << "\n";
// subshapes are written first
- for (i = 1; i <= nbShapes; i++) {
+ for (i = 1; i <= nbShapes && aPS.More(); i++, aPS.Next()) {
const TopoDS_Shape& S = myShapes(i);
}
Write(TopoDS_Shape(),OS); // Null shape to end the list
}
-
}
//=======================================================================
//purpose :
//=======================================================================
-void BinTools_ShapeSet::Read(Standard_IStream& IS)
+void BinTools_ShapeSet::Read (Standard_IStream& IS,
+ const Handle(Message_ProgressIndicator)& theProgress)
{
Clear();
IS.getline(vers,100,'\n');
// BUC60769 PTV 18.10.2000: remove possible '\r' at the end of the line
- for (Standard_Size lv = (strlen(vers)- 1); lv > 1 && (vers[lv] == '\r' || vers[lv] == '\n') ;lv--)
- vers[lv] = '\0';
+ Standard_Size lv = strlen(vers);
+ if (lv > 0) {
+ for (lv--; lv > 0 && (vers[lv] == '\r' || vers[lv] == '\n'); lv--)
+ vers[lv] = '\0';
+ }
} while ( ! IS.fail() && strcmp(vers,Version_1) && strcmp(vers,Version_2) &&
strcmp(vers,Version_3));
if (IS.fail()) {
- cout << "BinTools_ShapeSet::Read: File was not written with this version of the topology"<<endl;
+ std::cout << "BinTools_ShapeSet::Read: File was not written with this version of the topology"<<std::endl;
return;
}
//-----------------------------------------
// read the geometry
//-----------------------------------------
-
- ReadGeometry(IS);
-
+ Message_ProgressSentry aPSouter(theProgress, "Reading", 0, 2, 1);
+ ReadGeometry(IS, theProgress);
+ if (!aPSouter.More())
+ return;
+ aPSouter.Next();
//-----------------------------------------
// read the shapes
//-----------------------------------------
IS >> buffer;
if (IS.fail() || strcmp(buffer,"TShapes")) {
Standard_SStream aMsg;
- aMsg << "BinTools_ShapeSet::Read: Not a TShape table"<<endl;
- Standard_Failure::Raise(aMsg);
+ aMsg << "BinTools_ShapeSet::Read: Not a TShape table"<<std::endl;
+ throw Standard_Failure(aMsg.str().c_str());
return;
}
-
Standard_Integer nbShapes = 0;
IS >> nbShapes;
IS.get();//remove lf
-
- for (int i = 1; i <= nbShapes; i++) {
+ Message_ProgressSentry aPSinner(theProgress, "Reading Shapes", 0, nbShapes, 1);
+ for (int i = 1; i <= nbShapes && aPSinner.More(); i++, aPSinner.Next()) {
TopoDS_Shape S;
//purpose :
//=======================================================================
-void BinTools_ShapeSet::Write(const TopoDS_Shape& S, Standard_OStream& OS)const
+void BinTools_ShapeSet::Write (const TopoDS_Shape& S,
+ Standard_OStream& OS)const
{
if (S.IsNull())
//purpose :
//=======================================================================
-void BinTools_ShapeSet::Read(TopoDS_Shape& S, Standard_IStream& IS,
- const Standard_Integer nbshapes)const
+void BinTools_ShapeSet::Read (TopoDS_Shape& S, Standard_IStream& IS,
+ const Standard_Integer nbshapes)const
{
Standard_Character aChar = '\0';
IS >> aChar;
//purpose :
//=======================================================================
-void BinTools_ShapeSet::ReadGeometry(Standard_IStream& IS)
+void BinTools_ShapeSet::ReadGeometry (Standard_IStream& IS,
+ const Handle(Message_ProgressIndicator)& theProgress)
{
- myCurves2d.Read(IS);
- myCurves.Read(IS);
- ReadPolygon3D(IS);
- ReadPolygonOnTriangulation(IS);
- mySurfaces.Read(IS);
- ReadTriangulation(IS);
+ Message_ProgressSentry aPS(theProgress, "Reading geomentry", 0, 6, 1);
+ myCurves2d.Read(IS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
+ myCurves.Read(IS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
+ ReadPolygon3D(IS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
+ ReadPolygonOnTriangulation(IS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
+ mySurfaces.Read(IS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
+ ReadTriangulation(IS, theProgress);
+ if (!aPS.More())
+ return;
+ aPS.Next();
}
//=======================================================================
//purpose :
//=======================================================================
-void BinTools_ShapeSet::WriteGeometry(const TopoDS_Shape& S,
+void BinTools_ShapeSet::WriteGeometry (const TopoDS_Shape& S,
Standard_OStream& OS)const
{
// Write the geometry
Handle(BRep_TFace) TF = Handle(BRep_TFace)::DownCast(S.TShape());
const TopoDS_Face& F = TopoDS::Face(S);
-
- if (!(TF->Surface()).IsNull()) {
- Standard_Boolean aNatRes = (BRep_Tool::NaturalRestriction(F)) ? Standard_True : Standard_False;
- BinTools::PutBool(OS, aNatRes);
// Write the surface geometry
- BinTools::PutReal(OS, TF->Tolerance());
- BinTools::PutInteger(OS, mySurfaces.Index(TF->Surface()));
- BinTools::PutInteger(OS, Locations().Index(TF->Location()));
- }
- if (myWithTriangles) {
+ Standard_Boolean aNatRes = BRep_Tool::NaturalRestriction(F);
+ BinTools::PutBool (OS, aNatRes);
+ BinTools::PutReal (OS, TF->Tolerance());
+ BinTools::PutInteger (OS, !TF->Surface().IsNull()
+ ? mySurfaces.Index (TF->Surface())
+ : 0);
+ BinTools::PutInteger (OS, Locations().Index (TF->Location()));
+
+ if (myWithTriangles
+ || TF->Surface().IsNull())
+ {
if (!(TF->Triangulation()).IsNull()) {
OS << (Standard_Byte) 2;
// Write the triangulation
OS << (Standard_Byte) 0;//without triangulation
}
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const& anException) {
Standard_SStream aMsg;
- aMsg << "EXCEPTION in BinTools_ShapeSet::WriteGeometry(S,OS)" << endl;
- Handle(Standard_Failure) anExc = Standard_Failure::Caught();
- aMsg << anExc << endl;
- Standard_Failure::Raise(aMsg);
+ aMsg << "EXCEPTION in BinTools_ShapeSet::WriteGeometry(S,OS)" << std::endl;
+ aMsg << anException << std::endl;
+ throw Standard_Failure(aMsg.str().c_str());
}
}
case TopAbs_VERTEX :
{
// Standard_Integer aPos = IS.tellg();
-// cout << "\nPOS = " << aPos << endl;
+// std::cout << "\nPOS = " << aPos << std::endl;
TopoDS_Vertex& V = TopoDS::Vertex(S);
// Read the point geometry
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}
if (val > 0 && val <= 3)
BinTools::GetReal(IS, p1);
} else {
- streampos aPos = IS.tellg();
+ std::streampos aPos = IS.tellg();
BinTools::GetReal(IS, p1);
val = (Standard_Integer)IS.get();//case {0|1|2|3}
#ifdef OCCT_DEBUG
- cout << "\nVal = " << val <<endl;
+ std::cout << "\nVal = " << val <<std::endl;
#endif
if(val != 1 && val !=2 && val !=3){
IS.seekg(aPos);
default:
{
Standard_SStream aMsg;
- aMsg << "BinTools_SurfaceSet::ReadGeometry: UnExpected BRep_PointRepresentation = "<< val <<endl;
- Standard_Failure::Raise(aMsg);
+ aMsg << "BinTools_SurfaceSet::ReadGeometry: UnExpected BRep_PointRepresentation = "<< val <<std::endl;
+ throw Standard_Failure(aMsg.str().c_str());
}
}
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;
default:
{
Standard_SStream aMsg;
- aMsg <<"Unexpected Curve Representation ="<< val << endl;
- Standard_Failure::Raise(aMsg);
+ aMsg <<"Unexpected Curve Representation ="<< val << std::endl;
+ throw Standard_Failure(aMsg.str().c_str());
}
}
BinTools::GetReal(IS, tol);
BinTools::GetInteger(IS, s); //surface indx
BinTools::GetInteger(IS, l); //location indx
- if (!mySurfaces.Surface(s).IsNull()) {
- myBuilder.UpdateFace(TopoDS::Face(S),
- mySurfaces.Surface(s),
- Locations().Location(l),tol);
- myBuilder.NaturalRestriction(TopoDS::Face(S),bval );
- }
+ myBuilder.UpdateFace (F,
+ s > 0 ? mySurfaces.Surface(s) : Handle(Geom_Surface)(),
+ Locations().Location(l),
+ tol);
+ myBuilder.NaturalRestriction (F, bval);
Standard_Byte aByte = (Standard_Byte)IS.get();
// 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;
default:
{
Standard_SStream aMsg;
- aMsg << "Unexpected topology type = "<< T <<endl;
- Standard_Failure::Raise(aMsg);
+ aMsg << "Unexpected topology type = "<< T <<std::endl;
+ throw Standard_Failure(aMsg.str().c_str());
break;
}
}
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const& anException) {
Standard_SStream aMsg;
- aMsg << "EXCEPTION in BinTools_ShapeSet::ReadGeometry(S,OS)" << endl;
- Handle(Standard_Failure) anExc = Standard_Failure::Caught();
- aMsg << anExc << endl;
- Standard_Failure::Raise(aMsg);
+ aMsg << "EXCEPTION in BinTools_ShapeSet::ReadGeometry(S,OS)" << std::endl;
+ aMsg << anException << std::endl;
+ throw Standard_Failure(aMsg.str().c_str());
}
}
//=======================================================================
//function : WritePolygonOnTriangulation
-//purpose :
+//purpose :
//=======================================================================
-
-void BinTools_ShapeSet::WritePolygonOnTriangulation(Standard_OStream& OS) const
+void BinTools_ShapeSet::WritePolygonOnTriangulation
+ (Standard_OStream& OS,
+ const Handle(Message_ProgressIndicator)& theProgress) const
{
- Standard_Integer i, j, nbpOntri = myNodes.Extent();
-
- OS << "PolygonOnTriangulations " << nbpOntri << endl;
- 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));
+ Message_ProgressSentry aPS(theProgress, "Writing polygons on triangulation", 0, aNbPol, 1);
+ for (Standard_Integer aPolIter = 1; aPolIter <= aNbPol && aPS.More(); ++aPolIter, aPS.Next())
+ {
+ 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) {
+ catch (Standard_Failure const& anException)
+ {
Standard_SStream aMsg;
- aMsg << "EXCEPTION in BinTools_ShapeSet::WritePolygonOnTriangulation(..)" << endl;
- Handle(Standard_Failure) anExc = Standard_Failure::Caught();
- aMsg << anExc << endl;
- Standard_Failure::Raise(aMsg);
+ 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)
+void BinTools_ShapeSet::ReadPolygonOnTriangulation
+ (Standard_IStream& IS,
+ const Handle(Message_ProgressIndicator)& theProgress)
{
- char buffer[255];
- IS >> buffer;
- if (IS.fail() || (strstr(buffer,"PolygonOnTriangulations") == NULL)) {
- Standard_Failure::Raise("BinTools_ShapeSet::ReadPolygonOnTriangulation: Not a PolygonOnTriangulation section");
+ 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
+ Message_ProgressSentry aPS(theProgress, "Reading Polygones on triangulation", 0, aNbPol, 1);
+ for (Standard_Integer aPolIter = 1; aPolIter <= aNbPol && aPS.More(); ++aPolIter, aPS.Next())
+ {
+ 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) {
+ catch (Standard_Failure const& anException)
+ {
Standard_SStream aMsg;
- aMsg << "EXCEPTION in BinTools_ShapeSet::ReadPolygonOnTriangulation(..)" << endl;
- Handle(Standard_Failure) anExc = Standard_Failure::Caught();
- aMsg << anExc << endl;
- Standard_Failure::Raise(aMsg);
+ 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
+void BinTools_ShapeSet::WritePolygon3D(Standard_OStream& OS,
+ const Handle(Message_ProgressIndicator)& theProgress)const
{
- Standard_Integer i, j, nbpol = myPolygons3D.Extent();
- OS << "Polygon3D " << nbpol << endl;
- 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());
+ Message_ProgressSentry aPS(theProgress, "Writing polygons 3D", 0, aNbPol, 1);
+ for (Standard_Integer aPolIter = 1; aPolIter <= aNbPol && aPS.More(); ++aPolIter, aPS.Next())
+ {
+ 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) {
+ catch (Standard_Failure const& anException)
+ {
Standard_SStream aMsg;
- aMsg << "EXCEPTION in BinTools_ShapeSet::WritePolygon3D(..)" << endl;
- Handle(Standard_Failure) anExc = Standard_Failure::Caught();
- aMsg << anExc << endl;
- Standard_Failure::Raise(aMsg);
+ 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)
+void BinTools_ShapeSet::ReadPolygon3D (Standard_IStream& IS,
+ const Handle(Message_ProgressIndicator)& theProgress)
{
- 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
- cout <<"Buffer: " << buffer << endl;
+ std::cout <<"Buffer: " << aHeader << std::endl;
#endif
- Standard_Failure::Raise("BinTools_ShapeSet::ReadPolygon3D: Not a Polygon3D section");
+ 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);
+ Message_ProgressSentry aPS(theProgress, "Reading polygones 3D", 0, aNbPol, 1);
+ for (Standard_Integer aPolIter = 1; aPolIter <= aNbPol && aPS.More(); ++aPolIter, aPS.Next())
+ {
+ 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) {
+ catch (Standard_Failure const& anException)
+ {
Standard_SStream aMsg;
- aMsg << "EXCEPTION in BinTools_ShapeSet::ReadPolygon3D(..)" << endl;
- Handle(Standard_Failure) anExc = Standard_Failure::Caught();
- aMsg << anExc << endl;
- Standard_Failure::Raise(aMsg);
+ 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
+void BinTools_ShapeSet::WriteTriangulation (Standard_OStream& OS,
+ const Handle(Message_ProgressIndicator)& theProgress) const
{
- Standard_Integer i, j, nbNodes, nbtri = myTriangulations.Extent();
- Standard_Integer nbTriangles = 0, n1, n2, n3;
- OS << "Triangulations " << nbtri << endl;
- 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());
+ Message_ProgressSentry aPS(theProgress, "Writing triangulation", 0, aNbTriangulations, 1);
+ for (Standard_Integer aTriangulationIter = 1; aTriangulationIter <= aNbTriangulations && aPS.More(); ++aTriangulationIter, aPS.Next())
+ {
+ 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) {
+ catch (Standard_Failure const& anException)
+ {
Standard_SStream aMsg;
- aMsg << "EXCEPTION in BinTools_ShapeSet::WriteTriangulation(..)" << endl;
- Handle(Standard_Failure) anExc = Standard_Failure::Caught();
- aMsg << anExc << endl;
- Standard_Failure::Raise(aMsg);
+ 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,
+ const Handle(Message_ProgressIndicator)& theProgress)
{
- 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)) {
- Standard_Failure::Raise("BinTools_ShapeSet::Triangulation: Not a Triangulation section");
+ 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);
+ Message_ProgressSentry aPS(theProgress, "Reading triangulation", 0, aNbTriangulations, 1);
+ for (Standard_Integer aTriangulationIter = 1; aTriangulationIter <= aNbTriangulations && aPS.More(); ++aTriangulationIter, aPS.Next())
+ {
+ 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) {
+ catch (Standard_Failure const& anException)
+ {
Standard_SStream aMsg;
- aMsg << "EXCEPTION in BinTools_ShapeSet::ReadTriangulation(..)" << endl;
- Handle(Standard_Failure) anExc = Standard_Failure::Caught();
- aMsg << anExc << endl;
- Standard_Failure::Raise(aMsg);
+ aMsg << "EXCEPTION in BinTools_ShapeSet::ReadTriangulation(..)\n" << anException << "\n";
+ throw Standard_Failure(aMsg.str().c_str());
}
}