X-Git-Url: http://git.dev.opencascade.org/gitweb/?p=occt.git;a=blobdiff_plain;f=src%2FBinTools%2FBinTools_ShapeSet.cxx;h=35bc4ea11b39622022b4f823d37f13059d14e8c4;hb=6b467e52bb05a771e22356db3a78adf306c58fbf;hpb=08b438b07684090e1a9b77f5ac9d152d4bec10c6 diff --git a/src/BinTools/BinTools_ShapeSet.cxx b/src/BinTools/BinTools_ShapeSet.cxx index 4299960299..35bc4ea11b 100644 --- a/src/BinTools/BinTools_ShapeSet.cxx +++ b/src/BinTools/BinTools_ShapeSet.cxx @@ -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); - - // 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()); } } @@ -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 { + 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()); } }