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