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