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