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