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