0025748: Parallel version of progress indicator
[occt.git] / src / BRepTools / BRepTools_ShapeSet.cxx
1 // Created on: 1993-07-19
2 // Created by: Remi LEQUETTE
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 // Modifed:     Portage NT 7-5-97 DPF (strcasecmp)
18
19 #include <BRep_Builder.hxx>
20 #include <BRep_CurveOnClosedSurface.hxx>
21 #include <BRep_CurveOnSurface.hxx>
22 #include <BRep_CurveRepresentation.hxx>
23 #include <BRep_GCurve.hxx>
24 #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
25 #include <BRep_ListIteratorOfListOfPointRepresentation.hxx>
26 #include <BRep_ListOfCurveRepresentation.hxx>
27 #include <BRep_PointOnCurve.hxx>
28 #include <BRep_PointOnCurveOnSurface.hxx>
29 #include <BRep_PointOnSurface.hxx>
30 #include <BRep_Polygon3D.hxx>
31 #include <BRep_PolygonOnClosedSurface.hxx>
32 #include <BRep_PolygonOnClosedTriangulation.hxx>
33 #include <BRep_PolygonOnSurface.hxx>
34 #include <BRep_PolygonOnTriangulation.hxx>
35 #include <BRep_TEdge.hxx>
36 #include <BRep_TFace.hxx>
37 #include <BRep_Tool.hxx>
38 #include <BRep_TVertex.hxx>
39 #include <BRepTools.hxx>
40 #include <BRepTools_ShapeSet.hxx>
41 #include <GeomTools.hxx>
42 #include <Message_ProgressScope.hxx>
43 #include <Poly.hxx>
44 #include <Poly_Polygon2D.hxx>
45 #include <Poly_Polygon3D.hxx>
46 #include <Poly_PolygonOnTriangulation.hxx>
47 #include <Poly_Triangulation.hxx>
48 #include <Precision.hxx>
49 #include <Standard_Stream.hxx>
50 #include <TColgp_HArray1OfPnt.hxx>
51 #include <TColgp_HArray1OfPnt2d.hxx>
52 #include <TColStd_HArray1OfInteger.hxx>
53 #include <TColStd_HArray1OfReal.hxx>
54 #include <TopoDS.hxx>
55 #include <TopoDS_Shape.hxx>
56 #include <TopoDS_Vertex.hxx>
57
58 #ifdef MacOS
59 #define strcasecmp(p,q) strcmp(p,q)
60 #elseif _WIN32
61 #define strcasecmp strcmp
62 #elseif AIX
63 #include <string.h>
64 #endif
65
66 // Modified:    02 Nov 2000: BUC60769. JMB, PTV.  In order to be able to read BRep 
67 //              files that came from a platform different from where CasCade 
68 //              is run, we need the following modifications.
69 //
70 //              On NT platforms (in BRepTools_ShapeSet):
71 //              ----------------
72 //                In Visual C++ 5 (or higher) the std::fstream::tellg method is not 
73 //                conform to Standard C++ because it modifies the file pointer
74 //                position and returns a wrong position. After that the next
75 //                readings are shifted and the reading process stop with errors.
76 //                
77 //                Workaround is following: Now we don`t use tellg for get position in stream.
78 //                Now able to read file (when reading TopAbs_FACE) without tellg. 
79 //                We simple check the next string if there are value that equal 2 
80 //               (It means a parametr for triangulation).
81
82
83 //=======================================================================
84 //function : BRepTools_ShapeSet
85 //purpose  : 
86 //=======================================================================
87
88 BRepTools_ShapeSet::BRepTools_ShapeSet(const Standard_Boolean isWithTriangles)
89      :myWithTriangles(isWithTriangles)
90 {
91 }
92
93 //=======================================================================
94 //function : BRepTools_ShapeSet
95 //purpose  : 
96 //=======================================================================
97
98 BRepTools_ShapeSet::BRepTools_ShapeSet (const BRep_Builder& B,
99                                         const Standard_Boolean isWithTriangles) :
100        myBuilder(B), myWithTriangles(isWithTriangles)
101 {
102 }
103
104
105 //=======================================================================
106 //function : Clear
107 //purpose  : 
108 //=======================================================================
109
110 void  BRepTools_ShapeSet::Clear()
111 {
112   mySurfaces.Clear();
113   myCurves.Clear();
114   myCurves2d.Clear();
115   myPolygons3D.Clear();
116   myPolygons2D.Clear();
117   myNodes.Clear();
118   myTriangulations.Clear();
119   TopTools_ShapeSet::Clear();
120 }
121
122
123 //=======================================================================
124 //function : AddGeometry
125 //purpose  : 
126 //=======================================================================
127
128 void BRepTools_ShapeSet::AddGeometry(const TopoDS_Shape& S)
129 {
130   // Add the geometry
131   
132   if (S.ShapeType() == TopAbs_VERTEX) {
133     
134     Handle(BRep_TVertex) TV = Handle(BRep_TVertex)::DownCast(S.TShape());
135     BRep_ListIteratorOfListOfPointRepresentation itrp(TV->Points());
136     
137     while (itrp.More()) {
138       const Handle(BRep_PointRepresentation)& PR = itrp.Value();
139
140       if (PR->IsPointOnCurve()) {
141         myCurves.Add(PR->Curve());
142       }
143
144       else if (PR->IsPointOnCurveOnSurface()) {
145         myCurves2d.Add(PR->PCurve());
146         mySurfaces.Add(PR->Surface());
147       }
148
149       else if (PR->IsPointOnSurface()) {
150         mySurfaces.Add(PR->Surface());
151       }
152
153       ChangeLocations().Add(PR->Location());
154       itrp.Next();
155     }
156
157   }
158   else if (S.ShapeType() == TopAbs_EDGE) {
159
160     // Add the curve geometry
161     Handle(BRep_TEdge) TE = Handle(BRep_TEdge)::DownCast(S.TShape());
162     BRep_ListIteratorOfListOfCurveRepresentation itrc(TE->Curves());
163
164     while (itrc.More()) {
165       const Handle(BRep_CurveRepresentation)& CR = itrc.Value();
166       if (CR->IsCurve3D()) {
167         if (!CR->Curve3D().IsNull()) {
168           myCurves.Add(CR->Curve3D());
169           ChangeLocations().Add(CR->Location());
170         }
171       }
172       else if (CR->IsCurveOnSurface()) {
173         mySurfaces.Add(CR->Surface());
174         myCurves2d.Add(CR->PCurve());
175         ChangeLocations().Add(CR->Location());
176         if (CR->IsCurveOnClosedSurface())
177           myCurves2d.Add(CR->PCurve2());
178       }
179       else if (CR->IsRegularity()) {
180         mySurfaces.Add(CR->Surface());
181         ChangeLocations().Add(CR->Location());
182         mySurfaces.Add(CR->Surface2());
183         ChangeLocations().Add(CR->Location2());
184       }
185       else if (myWithTriangles) { // for XML Persistence
186         if (CR->IsPolygon3D()) {
187           if (!CR->Polygon3D().IsNull()) {
188             myPolygons3D.Add(CR->Polygon3D());
189             ChangeLocations().Add(CR->Location());
190           }
191         }
192         else if (CR->IsPolygonOnTriangulation()) {
193           myTriangulations.Add(CR->Triangulation());
194           myNodes.Add(CR->PolygonOnTriangulation());
195           ChangeLocations().Add(CR->Location());
196           if (CR->IsPolygonOnClosedTriangulation())
197             myNodes.Add(CR->PolygonOnTriangulation2());
198         }
199         else if (CR->IsPolygonOnSurface()) {
200           mySurfaces.Add(CR->Surface());
201           myPolygons2D.Add(CR->Polygon());
202           ChangeLocations().Add(CR->Location());
203           if (CR->IsPolygonOnClosedSurface())
204           myPolygons2D.Add(CR->Polygon2());
205         }
206       }
207       itrc.Next();
208     }
209   }
210
211   else if (S.ShapeType() == TopAbs_FACE) {
212
213     // Add the surface geometry
214     Handle(BRep_TFace) TF = Handle(BRep_TFace)::DownCast(S.TShape());
215     if (!TF->Surface().IsNull())  mySurfaces.Add(TF->Surface());
216
217     if (myWithTriangles || TF->Surface().IsNull()) { // for XML Persistence
218       Handle(Poly_Triangulation) Tr = TF->Triangulation();
219       if (!Tr.IsNull()) myTriangulations.Add(Tr);
220     }
221
222     ChangeLocations().Add(TF->Location());
223   }
224 }
225
226
227 //=======================================================================
228 //function : DumpGeometry
229 //purpose  : 
230 //=======================================================================
231
232 void  BRepTools_ShapeSet::DumpGeometry (Standard_OStream& OS)const 
233 {
234   myCurves2d.Dump(OS);
235   myCurves.Dump(OS);
236   DumpPolygon3D(OS);
237   DumpPolygonOnTriangulation(OS);
238   mySurfaces.Dump(OS);
239   DumpTriangulation(OS);
240 }
241
242
243 //=======================================================================
244 //function : WriteGeometry
245 //purpose  : 
246 //=======================================================================
247
248 void  BRepTools_ShapeSet::WriteGeometry(Standard_OStream& OS, const Message_ProgressRange& theProgress)
249 {
250   // Make nested progress scope for processing geometry
251   Message_ProgressScope aPS(theProgress, "Geometry", 100);
252
253   myCurves2d.Write(OS, aPS.Next(20));
254   if (aPS.UserBreak()) return;
255
256   myCurves.Write(OS, aPS.Next(20));
257   if (aPS.UserBreak()) return;
258
259   WritePolygon3D(OS, Standard_True, aPS.Next(10));
260   if (aPS.UserBreak()) return;
261   
262   WritePolygonOnTriangulation(OS, Standard_True, aPS.Next(10));
263   if (aPS.UserBreak()) return;
264   
265   mySurfaces.Write(OS, aPS.Next(20));
266   if (aPS.UserBreak()) return;
267   
268   WriteTriangulation(OS, Standard_True, aPS.Next(20));
269 }
270
271
272 //=======================================================================
273 //function : ReadGeometry
274 //purpose  : 
275 //=======================================================================
276
277 void  BRepTools_ShapeSet::ReadGeometry(Standard_IStream& IS, const Message_ProgressRange& theProgress)
278 {
279   // Make nested progress scope for processing geometry
280   Message_ProgressScope aPS(theProgress, "Geometry", 100);
281
282   myCurves2d.Read(IS, aPS.Next(20));
283   if (aPS.UserBreak()) return;
284
285   myCurves.Read(IS, aPS.Next(20));
286   if (aPS.UserBreak()) return;
287
288   ReadPolygon3D(IS, aPS.Next(15));
289   if (aPS.UserBreak()) return;
290   
291   ReadPolygonOnTriangulation(IS, aPS.Next(15));
292   if (aPS.UserBreak()) return;
293
294   mySurfaces.Read(IS, aPS.Next(15));
295   if (aPS.UserBreak()) return;
296
297   ReadTriangulation(IS, aPS.Next(15));
298 }
299
300 //=======================================================================
301 //function : PrintRegularity
302 //purpose  : 
303 //=======================================================================
304
305 static void PrintRegularity(const GeomAbs_Shape C,
306                             Standard_OStream& OS)
307 {
308   switch (C) {
309
310   case GeomAbs_C0 :
311     OS << "C0";
312     break;
313
314   case GeomAbs_G1 :
315     OS << "G1";
316     break;
317
318   case GeomAbs_C1 :
319     OS << "C1";
320     break;
321
322   case GeomAbs_G2 :
323     OS << "G2";
324     break;
325
326   case GeomAbs_C2 :
327     OS << "C2";
328     break;
329
330   case GeomAbs_C3 :
331     OS << "C3";
332     break;
333
334   case GeomAbs_CN :
335     OS << "CN";
336     break;
337
338   }
339 }
340
341 //=======================================================================
342 //function : DumpGeometry
343 //purpose  : 
344 //=======================================================================
345
346 void  BRepTools_ShapeSet::DumpGeometry(const TopoDS_Shape& S, 
347                                        Standard_OStream&   OS)const 
348 {
349   // Dump the geometry
350   
351   if (S.ShapeType() == TopAbs_VERTEX) {
352
353     // Dump the point geometry
354     TopoDS_Vertex V = TopoDS::Vertex(S);
355     OS << "    Tolerance : " << BRep_Tool::Tolerance(V) << "\n";
356     gp_Pnt p = BRep_Tool::Pnt(V);
357     OS << "    - Point 3D : "<<p.X()<<", "<<p.Y()<<", "<<p.Z()<<"\n";
358
359     Handle(BRep_TVertex) TV = Handle(BRep_TVertex)::DownCast(S.TShape());
360     BRep_ListIteratorOfListOfPointRepresentation itrp(TV->Points());
361     
362     while (itrp.More()) {
363       const Handle(BRep_PointRepresentation)& PR = itrp.Value();
364
365       OS << "    - Parameter : "<< PR->Parameter();
366       if (PR->IsPointOnCurve()) {
367         OS << " on curve " << myCurves.Index(PR->Curve());
368       }
369
370       else if (PR->IsPointOnCurveOnSurface()) {
371         OS << " on pcurve " <<  myCurves2d.Index(PR->PCurve());
372         OS << " on surface " << mySurfaces.Index(PR->Surface());
373       }
374
375       else if (PR->IsPointOnSurface()) {
376         OS << ", " << PR->Parameter2() << " on surface ";
377         OS << mySurfaces.Index(PR->Surface());
378       }
379
380       if (!PR->Location().IsIdentity())
381         OS << " location " << Locations().Index(PR->Location());
382       OS << "\n";
383
384       itrp.Next();
385     }
386
387   }
388
389   else if (S.ShapeType() == TopAbs_EDGE) {
390
391     Handle(BRep_TEdge) TE = Handle(BRep_TEdge)::DownCast(S.TShape());
392     gp_Pnt2d Pf,Pl;
393
394     // Dump the curve geometry 
395     OS << "    Tolerance : " << TE->Tolerance() << "\n";
396     if (TE->SameParameter()) OS << "     same parametrisation of curves\n";
397     if (TE->SameRange())     OS << "     same range on curves\n";
398     if (TE->Degenerated())   OS << "     degenerated\n";
399     
400     Standard_Real first, last;
401     BRep_ListIteratorOfListOfCurveRepresentation itrc = TE->Curves();
402     while (itrc.More()) {
403       const Handle(BRep_CurveRepresentation)& CR = itrc.Value();
404       if (CR->IsCurve3D()) {
405         Handle(BRep_GCurve) GC = Handle(BRep_GCurve)::DownCast(itrc.Value());
406         GC->Range(first, last);
407         if (!CR->Curve3D().IsNull()) {
408           OS << "    - Curve 3D : "<<myCurves.Index(CR->Curve3D());
409           if (!CR->Location().IsIdentity())
410             OS << " location "<<Locations().Index(CR->Location());
411           OS <<", range : " << first << " " << last <<"\n";
412         }
413       }
414       else if (CR->IsCurveOnSurface()) {
415         Handle(BRep_GCurve) GC = Handle(BRep_GCurve)::DownCast(itrc.Value());
416         GC->Range(first, last);
417         OS <<"    - PCurve : "<<myCurves2d.Index(CR->PCurve());
418         if (CR->IsCurveOnClosedSurface()) {
419           OS <<", " << myCurves2d.Index(CR->PCurve2());
420           OS << " (";
421           PrintRegularity(CR->Continuity(),OS);
422           OS <<")";
423         }
424         OS << " on surface "<<mySurfaces.Index(CR->Surface());
425         if (!CR->Location().IsIdentity())
426           OS << " location "<<Locations().Index(CR->Location());
427         OS <<", range : " << first << " " << last <<"\n";
428         
429         Handle(BRep_CurveOnSurface) COS = 
430           Handle(BRep_CurveOnSurface)::DownCast(CR);
431         COS->UVPoints(Pf,Pl);
432         OS << "  UV Points : " <<Pf.X()<<", "<<Pf.Y()<<" ";
433         OS << Pl.X()<<", "<<Pl.Y()<<"\n";
434         if (CR->IsCurveOnClosedSurface()) {
435           Handle(BRep_CurveOnClosedSurface) COCS = 
436             Handle(BRep_CurveOnClosedSurface)::DownCast(CR);
437           COCS->UVPoints2(Pf,Pl);
438           OS << "  UV Points : " <<Pf.X()<<", "<<Pf.Y()<<" ";
439           OS << Pl.X()<<", "<<Pl.Y()<<"\n";
440         }
441       }
442       else if (CR->IsRegularity()) {
443         OS << "    - Regularity ";
444         PrintRegularity(CR->Continuity(),OS);
445         OS << "   on surfaces : "<<mySurfaces.Index(CR->Surface());
446         if (!CR->Location().IsIdentity())
447           OS << " location "<<Locations().Index(CR->Location());
448         OS << ", "<<mySurfaces.Index(CR->Surface2());
449         if (!CR->Location2().IsIdentity())
450           OS << " location "<<Locations().Index(CR->Location2());
451         OS << "\n";
452       }
453       else if (CR->IsPolygon3D()) {
454         Handle(BRep_Polygon3D) GC = Handle(BRep_Polygon3D)::DownCast(itrc.Value());
455         if (!GC->Polygon3D().IsNull()) {
456           OS << "    - Polygon 3D : "<<myPolygons3D.FindIndex(CR->Polygon3D());
457           if (!CR->Location().IsIdentity())
458             OS << " location "<<Locations().Index(CR->Location());
459         }
460       }
461       else if (CR->IsPolygonOnTriangulation()) {
462         OS << "    - PolygonOnTriangulation " << myNodes.FindIndex(CR->PolygonOnTriangulation());
463         if (CR->IsPolygonOnClosedTriangulation()) {
464           OS << " " << myNodes.FindIndex(CR->PolygonOnTriangulation2());
465         }
466         OS << " on triangulation " << myTriangulations.FindIndex(CR->Triangulation());
467         if (!CR->Location().IsIdentity())
468           OS << " location "<<Locations().Index(CR->Location());
469         OS << "\n";
470       }
471       itrc.Next();
472     }
473   }
474
475   else if (S.ShapeType() == TopAbs_FACE) {
476
477     const TopoDS_Face& F = TopoDS::Face(S);
478     if (BRep_Tool::NaturalRestriction(F))
479       OS << "NaturalRestriction\n";
480
481     // Dump the surface geometry
482     Handle(BRep_TFace) TF = Handle(BRep_TFace)::DownCast(S.TShape());
483     if (!TF->Surface().IsNull()) {
484       OS << "    Tolerance : " <<TF->Tolerance() << "\n";
485       OS << "    - Surface : "<<mySurfaces.Index(TF->Surface());
486       if (!S.Location().IsIdentity())
487         OS << " location "<<Locations().Index(S.Location());
488       OS << "\n";
489     }
490     if (!(TF->Triangulation()).IsNull()) {
491       // Dump the triangulation
492       OS << "    - Triangulation : " <<myTriangulations.FindIndex(TF->Triangulation());
493       if (!S.Location().IsIdentity())
494         OS << " location " <<Locations().Index(TF->Location());
495       OS << "\n";
496     }
497   }
498  
499   OS << "\n";
500 }
501
502
503 //=======================================================================
504 //function : WriteGeometry
505 //purpose  : 
506 //=======================================================================
507
508 void  BRepTools_ShapeSet::WriteGeometry (const TopoDS_Shape& S, Standard_OStream& OS)const
509 {
510   // Write the geometry
511   
512   if (S.ShapeType() == TopAbs_VERTEX) {
513
514     // Write the point geometry
515     TopoDS_Vertex V = TopoDS::Vertex(S);
516     OS << BRep_Tool::Tolerance(V) << "\n";
517     gp_Pnt p = BRep_Tool::Pnt(V);
518     OS<<p.X()<<" "<<p.Y()<<" "<<p.Z()<<"\n";
519
520     Handle(BRep_TVertex) TV = Handle(BRep_TVertex)::DownCast(S.TShape());
521     BRep_ListIteratorOfListOfPointRepresentation itrp(TV->Points());
522     
523     while (itrp.More()) {
524       const Handle(BRep_PointRepresentation)& PR = itrp.Value();
525
526       OS << PR->Parameter();
527       if (PR->IsPointOnCurve()) {
528         OS << " 1 " << myCurves.Index(PR->Curve());
529       }
530
531       else if (PR->IsPointOnCurveOnSurface()) {
532         OS << " 2 " <<  myCurves2d.Index(PR->PCurve());
533         OS << " " << mySurfaces.Index(PR->Surface());
534       }
535
536       else if (PR->IsPointOnSurface()) {
537         OS << " 3 " << PR->Parameter2() << " ";
538         OS << mySurfaces.Index(PR->Surface());
539       }
540
541       OS << " " << Locations().Index(PR->Location());
542       OS << "\n";
543       
544       itrp.Next();
545     }
546     
547     OS << "0 0\n"; // end representations
548
549   }
550
551   else if (S.ShapeType() == TopAbs_EDGE) {
552
553     // Write the curve geometry 
554
555     Handle(BRep_TEdge) TE = Handle(BRep_TEdge)::DownCast(S.TShape());
556
557     OS << " " << TE->Tolerance() << " ";
558     OS << ((TE->SameParameter()) ? 1 : 0) << " ";
559     OS << ((TE->SameRange())     ? 1 : 0) << " ";
560     OS << ((TE->Degenerated())   ? 1 : 0) << "\n";
561     
562     Standard_Real first, last;
563     BRep_ListIteratorOfListOfCurveRepresentation itrc = TE->Curves();
564     while (itrc.More()) {
565       const Handle(BRep_CurveRepresentation)& CR = itrc.Value();
566       if (CR->IsCurve3D()) {
567         if (!CR->Curve3D().IsNull()) {
568           Handle(BRep_GCurve) GC = Handle(BRep_GCurve)::DownCast(itrc.Value());
569           GC->Range(first, last);
570           OS << "1 ";                               // -1- Curve 3D
571           OS << " "<<myCurves.Index(CR->Curve3D());
572           OS << " "<<Locations().Index(CR->Location());
573           OS << " "<<first<<" "<<last;
574           OS << "\n";
575         }
576       }
577       else if (CR->IsCurveOnSurface()) {
578         Handle(BRep_GCurve) GC = Handle(BRep_GCurve)::DownCast(itrc.Value());
579         GC->Range(first, last);
580         if (!CR->IsCurveOnClosedSurface())
581           OS << "2 ";                             // -2- Curve on surf
582         else
583           OS << "3 ";                             // -3- Curve on closed surf
584         OS <<" "<<myCurves2d.Index(CR->PCurve());
585         if (CR->IsCurveOnClosedSurface()) {
586           OS <<" " << myCurves2d.Index(CR->PCurve2());
587           PrintRegularity(CR->Continuity(),OS);
588         }
589         OS << " " << mySurfaces.Index(CR->Surface());
590         OS << " " << Locations().Index(CR->Location());
591         OS << " "<<first<<" "<<last;
592         OS << "\n";
593
594         // Write UV Points // for XML Persistence higher performance
595         if (FormatNb() == 2)
596         {
597           gp_Pnt2d Pf,Pl;
598           if (CR->IsCurveOnClosedSurface()) {
599             Handle(BRep_CurveOnClosedSurface) COCS = 
600               Handle(BRep_CurveOnClosedSurface)::DownCast(CR);
601             COCS->UVPoints2(Pf,Pl);
602           }
603           else {
604             Handle(BRep_CurveOnSurface) COS = 
605               Handle(BRep_CurveOnSurface)::DownCast(CR);
606             COS->UVPoints(Pf,Pl);
607           }
608           OS << Pf.X() << " " << Pf.Y() << " " << Pl.X() << " " << Pl.Y() << "\n";
609         }
610       }
611       else if (CR->IsRegularity()) {
612         OS << "4 ";                              // -4- Regularity
613         PrintRegularity(CR->Continuity(),OS);
614         OS << " "<<mySurfaces.Index(CR->Surface());
615         OS << " "<<Locations().Index(CR->Location());
616         OS << " "<<mySurfaces.Index(CR->Surface2());
617         OS << " "<<Locations().Index(CR->Location2());
618         OS << "\n";
619       }
620
621       else if (myWithTriangles) { // for XML Persistence
622         if (CR->IsPolygon3D()) {
623           Handle(BRep_Polygon3D) GC = Handle(BRep_Polygon3D)::DownCast(itrc.Value());
624           if (!GC->Polygon3D().IsNull()) {
625             OS << "5 ";                            // -5- Polygon3D
626             OS << " "<<myPolygons3D.FindIndex(CR->Polygon3D());
627             OS << " "<<Locations().Index(CR->Location());
628             OS << "\n";
629           }
630         }
631         else if (CR->IsPolygonOnTriangulation()) {
632           Handle(BRep_PolygonOnTriangulation) PT = 
633             Handle(BRep_PolygonOnTriangulation)::DownCast(itrc.Value());
634           if (!CR->IsPolygonOnClosedTriangulation())
635             OS << "6 ";                            // -6- Polygon on triangulation
636           else
637             OS << "7 ";                            // -7- Polygon on closed triangulation
638           OS << " " <<  myNodes.FindIndex(PT->PolygonOnTriangulation());
639           if (CR->IsPolygonOnClosedTriangulation()) {
640             OS << " " << myNodes.FindIndex(PT->PolygonOnTriangulation2());
641           }
642           OS << " " << myTriangulations.FindIndex(PT->Triangulation());
643           OS << " "<<Locations().Index(CR->Location());
644           OS << "\n";
645         }
646       }
647       
648       itrc.Next();
649     }
650     OS << "0\n"; // end of the list of representations
651   }
652   
653   else if (S.ShapeType() == TopAbs_FACE) {
654
655     Handle(BRep_TFace) TF = Handle(BRep_TFace)::DownCast(S.TShape());
656     const TopoDS_Face& F = TopoDS::Face(S);
657
658     if (!(TF->Surface()).IsNull()) {
659       OS << ((BRep_Tool::NaturalRestriction(F)) ? 1 : 0);
660       OS << " ";
661       // Write the surface geometry
662       OS << " " <<TF->Tolerance();
663       OS << " " <<mySurfaces.Index(TF->Surface());
664       OS << " " <<Locations().Index(TF->Location());
665       OS << "\n";
666     }
667     else //For correct reading of null face
668       {
669         OS << 0;
670         OS << " ";
671         OS << " " <<TF->Tolerance();
672         OS << " " << 0;
673         OS << " " << 0;
674         OS << "\n";
675       }
676     if (myWithTriangles || TF->Surface().IsNull()) { // for XML Persistence
677       if (!(TF->Triangulation()).IsNull()) {
678         OS << 2;
679         OS << " ";
680         // Write the triangulation
681         OS << " " <<myTriangulations.FindIndex(TF->Triangulation());
682       }
683     }
684   }
685   
686 }
687
688 //=======================================================================
689 //function : ReadRegularity
690 //purpose  : 
691 //=======================================================================
692
693 static GeomAbs_Shape ReadRegularity(Standard_IStream& IS)
694 {
695   char buffer[255];
696   IS >> buffer;
697   switch (buffer[0]) {
698
699   case 'C' :
700     switch (buffer[1]) {
701       
702     case '0' :
703       return GeomAbs_C0;
704       
705     case '1' :
706       return GeomAbs_C1;
707       
708     case '2' :
709       return GeomAbs_C2;
710       
711     case '3' :
712       return GeomAbs_C3;
713       
714     case 'N' :
715       return GeomAbs_CN;
716     }
717     break;
718
719   case 'G' :
720     switch (buffer[1]) {
721       
722     case '1' :
723       return GeomAbs_G1;
724       
725     case '2' :
726       return GeomAbs_G2;
727       
728     }
729     break;
730   }
731   return GeomAbs_C0;
732 }
733
734 //=======================================================================
735 //function : ReadGeometry
736 //purpose  : 
737 //=======================================================================
738
739 void  BRepTools_ShapeSet::ReadGeometry (const TopAbs_ShapeEnum T, 
740                                         Standard_IStream&      IS, 
741                                         TopoDS_Shape&          S)
742 {
743   // Read the geometry
744
745   Standard_Integer val,c,pc,pc2 = 0,s,s2,l,l2,t, pt, pt2 = 0;
746   Standard_Real tol,X,Y,Z,first,last,p1,p2;
747   Standard_Real PfX,PfY,PlX,PlY;
748   gp_Pnt2d aPf, aPl;
749   Standard_Boolean closed;
750   GeomAbs_Shape reg = GeomAbs_C0;
751   switch (T) {
752
753
754     //---------
755     // vertex
756     //---------
757
758   case TopAbs_VERTEX :
759     {
760       TopoDS_Vertex& V = TopoDS::Vertex(S);
761       
762       // Read the point geometry
763       GeomTools::GetReal(IS, tol);
764       GeomTools::GetReal(IS, X);
765       GeomTools::GetReal(IS, Y);
766       GeomTools::GetReal(IS, Z);
767       myBuilder.MakeVertex(V,gp_Pnt(X,Y,Z),tol);
768       Handle(BRep_TVertex) TV = Handle(BRep_TVertex)::DownCast(V.TShape());
769
770       BRep_ListOfPointRepresentation& lpr = TV->ChangePoints();
771       TopLoc_Location L;
772
773       do {
774         GeomTools::GetReal(IS, p1);
775         IS >> val;
776         
777         Handle(BRep_PointRepresentation) PR;
778         switch (val) {
779
780         case 1 :
781           {
782             IS >> c;
783
784 //  Modified by Sergey KHROMOV - Wed Apr 24 13:59:09 2002 Begin
785             if (myCurves.Curve(c).IsNull())
786               break;
787 //  Modified by Sergey KHROMOV - Wed Apr 24 13:59:13 2002 End
788
789             Handle(BRep_PointOnCurve) POC =
790               new BRep_PointOnCurve(p1,
791                                     myCurves.Curve(c),
792                                     L);
793             PR = POC;
794           }
795           break;
796
797         case 2 :
798           {
799             IS >> pc >> s;
800
801 //  Modified by Sergey KHROMOV - Wed Apr 24 13:59:09 2002 Begin
802             if (myCurves2d.Curve2d(pc).IsNull() ||
803                 mySurfaces.Surface(s).IsNull())
804               break;
805 //  Modified by Sergey KHROMOV - Wed Apr 24 13:59:13 2002 End
806
807             Handle(BRep_PointOnCurveOnSurface) POC =
808               new BRep_PointOnCurveOnSurface(p1,
809                                              myCurves2d.Curve2d(pc),
810                                              mySurfaces.Surface(s),
811                                              L);
812             PR = POC;
813           }
814           break;
815
816         case 3 :
817           {
818             GeomTools::GetReal(IS, p2);
819             IS >> s;
820
821 //  Modified by Sergey KHROMOV - Wed Apr 24 13:59:09 2002 Begin
822             if (mySurfaces.Surface(s).IsNull())
823               break;
824 //  Modified by Sergey KHROMOV - Wed Apr 24 13:59:13 2002 End
825
826             Handle(BRep_PointOnSurface) POC =
827               new BRep_PointOnSurface(p1,p2,
828                                       mySurfaces.Surface(s),
829                                       L);
830             PR = POC;
831           }
832           break;
833         }
834
835         if (val > 0) {
836           IS >> l;
837           if (!PR.IsNull()) {
838             PR->Location(Locations().Location(l));
839             lpr.Append(PR);
840           }
841         }
842       } while (val > 0);
843     }
844     break;
845       
846
847     //---------
848     // edge
849     //---------
850
851
852     case TopAbs_EDGE :
853
854       // Create an edge
855       {
856         TopoDS_Edge& E = TopoDS::Edge(S);
857         
858         myBuilder.MakeEdge(E);
859         
860         // Read the curve geometry 
861         GeomTools::GetReal(IS, tol);
862         IS >> val;
863         myBuilder.SameParameter(E,(val == 1));
864         IS >> val;
865         myBuilder.SameRange(E,(val == 1));
866         IS >> val;
867         myBuilder.Degenerated(E,(val == 1));
868         
869         do {
870           IS >> val;
871           switch (val) {
872             
873           case 1 :                               // -1- Curve 3D
874             IS >> c >> l;
875             if (!myCurves.Curve(c).IsNull()) {
876               myBuilder.UpdateEdge(E,myCurves.Curve(c),
877                                    Locations().Location(l),tol);
878             }
879             GeomTools::GetReal(IS, first);
880             GeomTools::GetReal(IS, last);
881             if (!myCurves.Curve(c).IsNull()) {
882               Standard_Boolean Only3d = Standard_True;
883               myBuilder.Range(E,first,last,Only3d);
884             }
885             break;
886             
887             
888           case 2 :                               // -2- Curve on surf
889           case 3 :                               // -3- Curve on closed surf
890             closed = (val == 3);
891             IS >> pc;
892             if (closed) {
893               IS >> pc2;
894               reg = ReadRegularity(IS);
895             }
896
897             // surface, location
898             IS >> s >> l;
899
900             // range
901             GeomTools::GetReal(IS, first);
902             GeomTools::GetReal(IS, last);
903
904             // read UV Points // for XML Persistence higher performance
905             if (FormatNb() == 2)
906             {
907               GeomTools::GetReal(IS, PfX);
908               GeomTools::GetReal(IS, PfY);
909               GeomTools::GetReal(IS, PlX);
910               GeomTools::GetReal(IS, PlY);
911               aPf = gp_Pnt2d(PfX,PfY);
912               aPl = gp_Pnt2d(PlX,PlY);
913             }
914
915 //  Modified by Sergey KHROMOV - Wed Apr 24 12:11:16 2002 Begin
916             if (myCurves2d.Curve2d(pc).IsNull() ||
917                 (closed && myCurves2d.Curve2d(pc2).IsNull()) ||
918                 mySurfaces.Surface(s).IsNull())
919               break;
920 //  Modified by Sergey KHROMOV - Wed Apr 24 12:11:17 2002 End
921
922             if (closed) {
923               if (FormatNb() == 2)
924                 myBuilder.UpdateEdge(E,myCurves2d.Curve2d(pc),
925                                      myCurves2d.Curve2d(pc2),
926                                      mySurfaces.Surface(s),
927                                      Locations().Location(l),tol,
928                                      aPf, aPl);
929               else
930                 myBuilder.UpdateEdge(E,myCurves2d.Curve2d(pc),
931                                      myCurves2d.Curve2d(pc2),
932                                      mySurfaces.Surface(s),
933                                      Locations().Location(l),tol);
934
935               myBuilder.Continuity(E,
936                                    mySurfaces.Surface(s),
937                                    mySurfaces.Surface(s),
938                                    Locations().Location(l),
939                                    Locations().Location(l),
940                                    reg);
941             }
942             else
943             {
944               if (FormatNb() == 2)
945                 myBuilder.UpdateEdge(E,myCurves2d.Curve2d(pc),
946                                      mySurfaces.Surface(s),
947                                      Locations().Location(l),tol,
948                                      aPf, aPl);
949               else
950                 myBuilder.UpdateEdge(E,myCurves2d.Curve2d(pc),
951                                      mySurfaces.Surface(s),
952                                      Locations().Location(l),tol);
953             }
954             myBuilder.Range(E,
955                             mySurfaces.Surface(s),
956                             Locations().Location(l),
957                             first,last);
958             break;
959             
960           case 4 :                               // -4- Regularity
961             reg = ReadRegularity(IS);
962             IS >> s >> l >> s2 >> l2;
963 //  Modified by Sergey KHROMOV - Wed Apr 24 12:39:13 2002 Begin
964             if (mySurfaces.Surface(s).IsNull() ||
965                 mySurfaces.Surface(s2).IsNull())
966               break;
967 //  Modified by Sergey KHROMOV - Wed Apr 24 12:39:14 2002 End
968             myBuilder.Continuity(E,
969                                  mySurfaces.Surface(s),
970                                  mySurfaces.Surface(s2),
971                                  Locations().Location(l),
972                                  Locations().Location(l2),
973                                  reg);
974             break;
975
976           case 5 :   // -5- Polygon3D                            
977             IS >> c >> l;
978 //szy-02.05.2004            myBuilder.UpdateEdge(E,Handle(Poly_Polygon3D)::DownCast(myPolygons3D(c)));
979                         if (c > 0 && c <= myPolygons3D.Extent())
980                   myBuilder.UpdateEdge(E,Handle(Poly_Polygon3D)::DownCast(myPolygons3D(c)), Locations().Location(l));
981             break;
982
983           case 6 :
984           case 7 :
985             closed = (val == 7);
986             IS >> pt;
987             if (closed) {
988               IS >> pt2;
989             }
990             IS >> t >> l;
991             if (closed) {
992                       if (t > 0 && t <= myTriangulations.Extent() &&
993                                   pt > 0 && pt <= myNodes.Extent() &&
994                                   pt2 > 0 && pt2 <= myNodes.Extent())
995                 myBuilder.UpdateEdge
996                   (E, Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(pt)),
997                    Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(pt2)),
998                    Handle(Poly_Triangulation)::DownCast(myTriangulations(t)),
999                    Locations().Location(l));
1000             }
1001             else {
1002                       if (t > 0 && t <= myTriangulations.Extent() &&
1003                                   pt > 0 && pt <= myNodes.Extent())
1004                 myBuilder.UpdateEdge
1005                   (E,Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(pt)),
1006                    Handle(Poly_Triangulation)::DownCast(myTriangulations(t)),
1007                    Locations().Location(l));
1008             }
1009             // range
1010             
1011             break;
1012             
1013           }
1014         } while (val > 0);
1015       }
1016     break;
1017
1018
1019     //---------
1020     // wire
1021     //---------
1022
1023   case TopAbs_WIRE :
1024     myBuilder.MakeWire(TopoDS::Wire(S));
1025     break;
1026
1027
1028     //---------
1029     // face
1030     //---------
1031
1032   case TopAbs_FACE :
1033     {
1034     // create a face :
1035     TopoDS_Face& F = TopoDS::Face(S);
1036 //    std::streampos pos;
1037     myBuilder.MakeFace(F);
1038
1039     IS >> val; // natural restriction
1040     if (val == 0 || val == 1) {
1041       GeomTools::GetReal(IS, tol);
1042       IS >> s >> l;
1043 //  Modified by Sergey KHROMOV - Wed Apr 24 12:39:13 2002 Begin
1044       if (!mySurfaces.Surface(s).IsNull()) {
1045 //  Modified by Sergey KHROMOV - Wed Apr 24 12:39:14 2002 End
1046         myBuilder.UpdateFace(TopoDS::Face(S),
1047                              mySurfaces.Surface(s),
1048                              Locations().Location(l),tol);
1049         myBuilder.NaturalRestriction(TopoDS::Face(S),(val == 1));
1050       }
1051 //      pos = IS.tellg();
1052 //      IS >> val;
1053     }
1054     else if(val == 2) {
1055       //only triangulation
1056       IS >> s;
1057       myBuilder.UpdateFace(TopoDS::Face(S),
1058                            Handle(Poly_Triangulation)::DownCast(myTriangulations(s)));
1059     }
1060 //    else pos = IS.tellg();
1061     
1062     // BUC60769
1063
1064     if(val == 2) break;
1065
1066     char string[260];
1067     IS.getline ( string, 256, '\n' );
1068     IS.getline ( string, 256, '\n' );
1069
1070     if (string[0] == '2') {
1071       // cas triangulation
1072       s = atoi ( &string[2] );
1073           if (s > 0 && s <= myTriangulations.Extent())
1074         myBuilder.UpdateFace(TopoDS::Face(S),
1075                              Handle(Poly_Triangulation)::DownCast(myTriangulations(s)));
1076     }
1077 //    else IS.seekg(pos);
1078     }
1079     break;
1080
1081
1082     //---------
1083     // shell
1084     //---------
1085
1086   case TopAbs_SHELL :
1087     myBuilder.MakeShell(TopoDS::Shell(S));
1088     break;
1089
1090
1091     //---------
1092     // solid
1093     //---------
1094
1095   case TopAbs_SOLID :
1096     myBuilder.MakeSolid(TopoDS::Solid(S));
1097     break;
1098
1099
1100     //---------
1101     // compsolid
1102     //---------
1103
1104   case TopAbs_COMPSOLID :
1105     myBuilder.MakeCompSolid(TopoDS::CompSolid(S));
1106     break;
1107
1108
1109     //---------
1110     // compound
1111     //---------
1112
1113   case TopAbs_COMPOUND :
1114     myBuilder.MakeCompound(TopoDS::Compound(S));
1115     break;
1116
1117   default:
1118     break;
1119   }
1120   
1121 }
1122
1123
1124
1125 //=======================================================================
1126 //function : AddShapes
1127 //purpose  : 
1128 //=======================================================================
1129
1130 void  BRepTools_ShapeSet::AddShapes(TopoDS_Shape&       S1, 
1131                                     const TopoDS_Shape& S2)
1132 {
1133   myBuilder.Add(S1,S2);
1134 }
1135
1136 //=======================================================================
1137 //function : Check
1138 //purpose  : 
1139 //=======================================================================
1140
1141 void BRepTools_ShapeSet::Check(const TopAbs_ShapeEnum T,
1142                                TopoDS_Shape&          S)
1143 {
1144   if (T == TopAbs_FACE) {
1145     const TopoDS_Face& F = TopoDS::Face(S);
1146     BRepTools::Update(F);
1147   }
1148 }
1149
1150
1151
1152 //=======================================================================
1153 //function : WritePolygonOnTriangulation
1154 //purpose  : 
1155 //=======================================================================
1156
1157 void BRepTools_ShapeSet::WritePolygonOnTriangulation(Standard_OStream&      OS,
1158                                                      const Standard_Boolean Compact,
1159                                                      const Message_ProgressRange& theProgress)const
1160 {
1161   Standard_Integer i, j, nbpOntri = myNodes.Extent();
1162
1163   Message_ProgressScope aPS(theProgress, "Polygons On Triangulation", nbpOntri);
1164   if (Compact)
1165     OS << "PolygonOnTriangulations " << nbpOntri << "\n";
1166   else {
1167     OS << " -------\n";
1168     OS <<"Dump of " << nbpOntri << " PolygonOnTriangulations\n";
1169     OS << " -------\n";
1170   }
1171
1172   Handle(Poly_PolygonOnTriangulation) Poly;
1173   Handle(TColStd_HArray1OfReal) Param;
1174   for (i=1; i<=nbpOntri && aPS.More(); i++, aPS.Next()) {
1175     Poly = Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(i));
1176     const TColStd_Array1OfInteger& Nodes = Poly->Nodes();
1177     if (!Compact) {
1178       OS << "  "<< i << " : PolygonOnTriangulation with " << Nodes.Length() << " Nodes\n";
1179     }
1180     else OS << Nodes.Length()<<" ";
1181     if (!Compact) OS <<"  ";
1182     for (j=1; j <= Nodes.Length(); j++) OS << Nodes.Value(j) << " ";
1183     OS << "\n";
1184
1185     // writing parameters:
1186     Param = Poly->Parameters();
1187     if (Compact) OS <<"p ";
1188
1189     // write the deflection
1190     if (!Compact) OS << "  Deflection : ";
1191     OS <<Poly->Deflection() << " ";
1192     if (!Compact) OS << "\n";
1193     
1194     if (!Param.IsNull()) {
1195       if (!Compact) {
1196         OS << "  Parameters :";
1197       }
1198       else OS << "1 " ;
1199       if (!Compact) OS <<"  ";
1200       for (j=1; j <= Param->Length(); j++) OS << Param->Value(j) << " ";
1201       OS << "\n";
1202     }
1203     else OS <<"0 \n";
1204   }
1205 }
1206
1207 //=======================================================================
1208 //function : DumpPolygonOnTriangulation
1209 //purpose  : 
1210 //=======================================================================
1211
1212 void BRepTools_ShapeSet::DumpPolygonOnTriangulation(Standard_OStream& OS)const
1213 {
1214   WritePolygonOnTriangulation(OS, Standard_False);
1215 }
1216
1217 //=======================================================================
1218 //function : ReadPolygonOnTriangulation
1219 //purpose  : 
1220 //=======================================================================
1221
1222 void BRepTools_ShapeSet::ReadPolygonOnTriangulation(Standard_IStream& IS,
1223                                                     const Message_ProgressRange& theProgress)
1224 {
1225   char buffer[255];
1226   IS >> buffer;
1227   if (strstr(buffer,"PolygonOnTriangulations") == NULL) return;
1228   Standard_Integer i, j, val, nbpol = 0, nbnodes =0;
1229   Standard_Integer hasparameters;
1230   Standard_Real par;
1231   Handle(TColStd_HArray1OfReal) Param;
1232   Handle(Poly_PolygonOnTriangulation) Poly;
1233   IS >> nbpol;
1234   //OCC19559
1235   Message_ProgressScope aPS(theProgress, "Polygons On Triangulation", nbpol);
1236   for (i=1; i<=nbpol&& aPS.More(); i++, aPS.Next()) {
1237     IS >> nbnodes;
1238     TColStd_Array1OfInteger Nodes(1, nbnodes);
1239     for (j = 1; j <= nbnodes; j++) {
1240       IS >> val;
1241       Nodes(j) = val;
1242     }
1243     IS >> buffer;
1244 //      if (!strcasecmp(buffer, "p")) {
1245       Standard_Real def;
1246       GeomTools::GetReal(IS, def);
1247       IS >> hasparameters;
1248       if (hasparameters) {
1249         TColStd_Array1OfReal Param1(1, nbnodes);
1250         for (j = 1; j <= nbnodes; j++) {
1251           GeomTools::GetReal(IS, par);
1252           Param1(j) = par;
1253         }
1254         Poly = new Poly_PolygonOnTriangulation(Nodes, Param1);
1255       }
1256       else Poly = new Poly_PolygonOnTriangulation(Nodes);
1257       Poly->Deflection(def);
1258 //      }
1259 //      else {
1260 //      IS.seekg(ppp);
1261 //      Poly = new Poly_PolygonOnTriangulation(Nodes);
1262 //      }
1263     myNodes.Add(Poly);
1264   }
1265 //  }
1266 //  else IS.seekg(pos);
1267 }
1268
1269
1270
1271 //=======================================================================
1272 //function : WritePolygon3D
1273 //purpose  : 
1274 //=======================================================================
1275
1276 void BRepTools_ShapeSet::WritePolygon3D(Standard_OStream&      OS,
1277                                         const Standard_Boolean Compact,
1278                                         const Message_ProgressRange& theProgress)const
1279 {
1280   Standard_Integer i, j, nbpol = myPolygons3D.Extent();
1281   
1282   Message_ProgressScope aPS(theProgress, "3D Polygons", nbpol);
1283
1284   if (Compact)
1285     OS << "Polygon3D " << nbpol << "\n";
1286   else {
1287     OS << " -------\n";
1288     OS <<"Dump of " << nbpol << " Polygon3Ds\n";
1289     OS << " -------\n";
1290   }
1291   
1292   Handle(Poly_Polygon3D) P;
1293   for (i = 1; i <= nbpol && aPS.More(); i++, aPS.Next()) {
1294     P = Handle(Poly_Polygon3D)::DownCast(myPolygons3D(i));
1295     if (Compact) {
1296       OS << P->NbNodes() << " ";
1297       OS << ((P->HasParameters()) ? "1" : "0") << "\n";
1298     }
1299     else {
1300       OS << "  "<< i << " : Polygon3D with " << P->NbNodes() << " Nodes\n";
1301       OS << ((P->HasParameters()) ? "with" : "without") << " parameters\n";
1302     }
1303     
1304
1305     // write the deflection
1306     if (!Compact) OS << "Deflection : ";
1307     OS << P->Deflection() << "\n";
1308     
1309     // write the nodes
1310     if (!Compact) OS << "\nNodes :\n";
1311     
1312     Standard_Integer i1, nbNodes = P->NbNodes();
1313     const TColgp_Array1OfPnt& Nodes = P->Nodes();
1314     for (j = 1; j <= nbNodes; j++) {
1315       if (!Compact) OS << std::setw(10) << j << " : ";
1316       if (!Compact) OS << std::setw(17);
1317       OS << Nodes(j).X() << " ";
1318       if (!Compact) OS << std::setw(17);
1319       OS << Nodes(j).Y() << " ";
1320       if (!Compact) OS << std::setw(17);
1321       OS << Nodes(j).Z();
1322       if (!Compact) OS << "\n";
1323       else OS << " ";
1324     }
1325     OS <<"\n";
1326   
1327     if (P->HasParameters()) {
1328       if (!Compact) OS << "\nParameters :\n";
1329       const TColStd_Array1OfReal& Param = P->Parameters();
1330       for ( i1 = 1; i1 <= nbNodes; i1++ ) {
1331         OS << Param(i1) << " ";
1332       }
1333       OS <<"\n";
1334     }
1335   }
1336 }
1337
1338 //=======================================================================
1339 //function : DumpPolygon3D
1340 //purpose  : 
1341 //=======================================================================
1342
1343 void BRepTools_ShapeSet::DumpPolygon3D(Standard_OStream& OS)const
1344 {
1345   WritePolygon3D(OS, Standard_False);
1346 }
1347
1348
1349 //=======================================================================
1350 //function : ReadPolygon3D
1351 //purpose  : 
1352 //=======================================================================
1353
1354 void BRepTools_ShapeSet::ReadPolygon3D(Standard_IStream& IS, const Message_ProgressRange& theProgress)
1355 {
1356   char buffer[255];
1357   //  Standard_Integer i, j, p, val, nbpol, nbnodes, hasparameters;
1358   Standard_Integer i, j, p, nbpol=0, nbnodes =0, hasparameters = Standard_False;
1359   Standard_Real d, x, y, z;
1360
1361   IS >> buffer;
1362   if (strstr(buffer,"Polygon3D") == NULL) return;
1363   Handle(Poly_Polygon3D) P;
1364   IS >> nbpol;
1365   //OCC19559
1366   Message_ProgressScope aPS(theProgress, "3D Polygons", nbpol);
1367   for (i=1; i<=nbpol && aPS.More(); i++, aPS.Next()) {
1368     IS >> nbnodes;
1369     IS >> hasparameters;
1370     TColgp_Array1OfPnt Nodes(1, nbnodes);
1371     GeomTools::GetReal(IS, d);
1372     for (j = 1; j <= nbnodes; j++) {
1373       GeomTools::GetReal(IS, x);
1374       GeomTools::GetReal(IS, y);
1375       GeomTools::GetReal(IS, z);
1376       Nodes(j).SetCoord(x,y,z);
1377     }
1378     if (hasparameters) {
1379       TColStd_Array1OfReal Param(1,nbnodes);
1380       for (p = 1; p <= nbnodes; p++) {
1381         GeomTools::GetReal(IS, Param(p));
1382       }
1383       P = new Poly_Polygon3D(Nodes, Param);
1384     }
1385     else P = new Poly_Polygon3D(Nodes);
1386     P->Deflection(d);
1387     myPolygons3D.Add(P);
1388   }
1389 }
1390
1391
1392
1393 //=======================================================================
1394 //function : WriteTriangulation
1395 //purpose  : 
1396 //=======================================================================
1397
1398 void BRepTools_ShapeSet::WriteTriangulation(Standard_OStream&      OS,
1399                                             const Standard_Boolean Compact,
1400                                             const Message_ProgressRange& theProgress)const
1401 {
1402   Standard_Integer i, j, nbNodes, nbtri = myTriangulations.Extent();
1403   Standard_Integer nbTriangles = 0, n1, n2, n3;
1404
1405   Message_ProgressScope aPS(theProgress, "Triangulations", nbtri);
1406
1407   if (Compact)
1408     OS << "Triangulations " << nbtri << "\n";
1409   else {
1410     OS << " -------\n";
1411     OS <<"Dump of " << nbtri << " Triangulations\n";
1412     OS << " -------\n";
1413   }
1414
1415   Handle(Poly_Triangulation) T;
1416   for (i = 1; i <= nbtri && aPS.More(); i++, aPS.Next()) {
1417
1418     T = Handle(Poly_Triangulation)::DownCast(myTriangulations(i));
1419     if (Compact) {
1420       OS << T->NbNodes() << " " << T->NbTriangles() << " ";
1421       OS << ((T->HasUVNodes()) ? "1" : "0") << " ";
1422     }
1423     else {
1424       OS << "  "<< i << " : Triangulation with " << T->NbNodes() << " Nodes and "
1425          << T->NbTriangles() <<" Triangles\n";
1426       OS << "      "<<((T->HasUVNodes()) ? "with" : "without") << " UV nodes\n";
1427
1428     }
1429     
1430     // write the deflection
1431     
1432     if (!Compact) OS << "  Deflection : ";
1433     OS <<T->Deflection() << "\n";
1434     
1435     // write the 3d nodes
1436     
1437     if (!Compact) OS << "\n3D Nodes :\n";
1438     
1439     nbNodes = T->NbNodes();
1440     const TColgp_Array1OfPnt& Nodes = T->Nodes();
1441     for (j = 1; j <= nbNodes; j++) {
1442       if (!Compact) OS << std::setw(10) << j << " : ";
1443       if (!Compact) OS << std::setw(17);
1444       OS << Nodes(j).X() << " ";
1445       if (!Compact) OS << std::setw(17);
1446       OS << Nodes(j).Y() << " ";
1447       if (!Compact) OS << std::setw(17);
1448       OS << Nodes(j).Z();
1449       if (!Compact) OS << "\n";
1450       else OS << " ";
1451     }
1452     
1453     if (T->HasUVNodes()) {
1454       if (!Compact) OS << "\nUV Nodes :\n";
1455       const TColgp_Array1OfPnt2d& UVNodes = T->UVNodes();
1456       for (j = 1; j <= nbNodes; j++) {
1457         if (!Compact) OS << std::setw(10) << j << " : ";
1458         if (!Compact) OS << std::setw(17);
1459         OS << UVNodes(j).X() << " ";
1460         if (!Compact) OS << std::setw(17);
1461         OS << UVNodes(j).Y();
1462         if (!Compact) OS << "\n";
1463         else OS << " ";
1464       }
1465     }
1466     
1467     if (!Compact) OS << "\nTriangles :\n";
1468     nbTriangles = T->NbTriangles();
1469     const Poly_Array1OfTriangle& Triangles = T->Triangles();
1470     for (j = 1; j <= nbTriangles; j++) {
1471       if (!Compact) OS << std::setw(10) << j << " : ";
1472       Triangles(j).Get(n1, n2, n3);
1473       if (!Compact) OS << std::setw(10);
1474       OS << n1 << " ";
1475       if (!Compact) OS << std::setw(10);
1476       OS << n2 << " ";
1477       if (!Compact) OS << std::setw(10);
1478       OS << n3;
1479       if (!Compact) OS << "\n";
1480       else OS << " ";
1481     }
1482     OS << "\n";
1483   }
1484 }
1485
1486 //=======================================================================
1487 //function : DumpTriangulation
1488 //purpose  : 
1489 //=======================================================================
1490
1491 void BRepTools_ShapeSet::DumpTriangulation(Standard_OStream& OS)const
1492 {
1493   WriteTriangulation(OS, Standard_False);
1494 }
1495
1496
1497 //=======================================================================
1498 //function : ReadTriangulation
1499 //purpose  : 
1500 //=======================================================================
1501
1502 void BRepTools_ShapeSet::ReadTriangulation(Standard_IStream& IS, const Message_ProgressRange& theProgress)
1503 {
1504   char buffer[255];
1505   //  Standard_Integer i, j, val, nbtri;
1506   Standard_Integer i, j, nbtri =0;
1507   Standard_Real d, x, y, z;
1508   Standard_Integer nbNodes =0, nbTriangles=0;
1509   Standard_Boolean hasUV= Standard_False;
1510
1511   Handle(Poly_Triangulation) T;
1512
1513   IS >> buffer;
1514   if (strstr(buffer,"Triangulations") == NULL) return;
1515
1516   IS >> nbtri;
1517   //OCC19559
1518   Message_ProgressScope aPS(theProgress, "Triangulations", nbtri);
1519   for (i=1; i<=nbtri && aPS.More();i++, aPS.Next()) {
1520
1521     IS >> nbNodes >> nbTriangles >> hasUV;
1522     GeomTools::GetReal(IS, d);
1523
1524     TColgp_Array1OfPnt Nodes(1, nbNodes);
1525     TColgp_Array1OfPnt2d UVNodes(1, nbNodes);
1526
1527     for (j = 1; j <= nbNodes; j++) {
1528       GeomTools::GetReal(IS, x);
1529       GeomTools::GetReal(IS, y);
1530       GeomTools::GetReal(IS, z);
1531       Nodes(j).SetCoord(x,y,z);
1532     }
1533
1534     if (hasUV) {
1535       for (j = 1; j <= nbNodes; j++) {
1536         GeomTools::GetReal(IS, x);
1537         GeomTools::GetReal(IS, y);
1538         UVNodes(j).SetCoord(x,y);
1539       }
1540     }
1541       
1542     // read the triangles
1543     Standard_Integer n1,n2,n3;
1544     Poly_Array1OfTriangle Triangles(1, nbTriangles);
1545     for (j = 1; j <= nbTriangles; j++) {
1546       IS >> n1 >> n2 >> n3;
1547       Triangles(j).Set(n1,n2,n3);
1548     }
1549       
1550     if (hasUV) T =  new Poly_Triangulation(Nodes,UVNodes,Triangles);
1551     else T = new Poly_Triangulation(Nodes,Triangles);
1552       
1553     T->Deflection(d);
1554       
1555     myTriangulations.Add(T);
1556   }
1557 }