Branch data Line data Source code
1 : : // File: OCCShapeAttributeSet.cxx
2 : : // Created: Thur Jul 10 2008
3 : : // Author: Jane Hu
4 : :
5 : : #include <Standard_Stream.hxx>
6 : : #include <BRepTools.hxx>
7 : : #include "OCCShapeAttributeSet.hpp"
8 : : #include "CubitSimpleAttrib.hpp"
9 : : #include "OCCAttribSet.hpp"
10 : : #include "OCCQueryEngine.hpp"
11 : : //#include <Poly.hxx>
12 : : #include <TopoDS.hxx>
13 : : #include <TColStd_Array1OfReal.hxx>
14 : : #include <TColStd_HArray1OfInteger.hxx>
15 : : #include <TColgp_Array1OfPnt2d.hxx>
16 : : #include <BRep_GCurve.hxx>
17 : : #include <Handle_BRep_CurveOnClosedSurface.hxx>
18 : : #include <Handle_BRep_CurveOnSurface.hxx>
19 : : #include <TopAbs_ShapeEnum.hxx>
20 : : //#include <BRep_TFace.hxx>
21 : : //#include <BRep_TEdge.hxx>
22 : : //#include <BRep_TVertex.hxx>
23 : : #include <Handle_BRep_GCurve.hxx>
24 : : #include <BRep_Tool.hxx>
25 : : #include <TDF_ChildIterator.hxx>
26 : : #include <TopTools_LocationSet.hxx>
27 : : #include <TopTools_IndexedMapOfShape.hxx>
28 : : #include <TopoDS_Iterator.hxx>
29 : : //#include <BRep_CurveRepresentation.hxx>
30 : : #include <Poly_Polygon3D.hxx>
31 : : //#include <BRep_Polygon3D.hxx>
32 : : //#include <BRep_PolygonOnSurface.hxx>
33 : : //#include <BRep_PolygonOnClosedSurface.hxx>
34 : : //#include <BRep_PolygonOnTriangulation.hxx>
35 : : //#include <BRep_PolygonOnClosedTriangulation.hxx>
36 : : #include <BRep_CurveOnSurface.hxx>
37 : : #include <BRep_CurveOnClosedSurface.hxx>
38 : : //#include <BRep_ListOfCurveRepresentation.hxx>
39 : : //#include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
40 : : #include <BRep_PointOnCurve.hxx>
41 : : #include <BRep_PointOnCurveOnSurface.hxx>
42 : : #include <BRep_PointOnSurface.hxx>
43 : : //#include <BRep_ListIteratorOfListOfPointRepresentation.hxx>
44 : : #include <TDF_Label.hxx>
45 : : #include <TopTools_DataMapOfShapeInteger.hxx>
46 : :
47 : : #ifndef OCC_VERSION_MINOR
48 : : #include "Standard_Version.hxx"
49 : : #endif
50 : : #if OCC_VERSION_MINOR < 5
51 : : #include <TDataStd_Shape.hxx>
52 : : typedef TDataStd_Shape TDataXtd_Shape;
53 : : typedef Handle_TDataStd_Shape Handle_TDataXtd_Shape;
54 : : #else
55 : : #include <TDataXtd_Shape.hxx>
56 : : #endif
57 : :
58 : : #include <Handle_TDataStd_Name.hxx>
59 : : #include <TDataStd_Name.hxx>
60 : : #include <Handle_TDataStd_ExtStringArray.hxx>
61 : : #include <TDataStd_ExtStringArray.hxx>
62 : : #include <TCollection_ExtendedString.hxx>
63 : : #include <Handle_TDataStd_IntegerArray.hxx>
64 : : #include <TDataStd_IntegerArray.hxx>
65 : : #include <Handle_TDataStd_RealArray.hxx>
66 : : #include <TDataStd_RealArray.hxx>
67 : : #include <Handle_BRep_TVertex.hxx>
68 : : #include <BRep_ListIteratorOfListOfPointRepresentation.hxx>
69 : : #include <BRep_TVertex.hxx>
70 : : #include <BRep_PointRepresentation.hxx>
71 : : #include <Handle_BRep_TEdge.hxx>
72 : : #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
73 : : #include <Handle_BRep_TFace.hxx>
74 : : #include <BRep_TFace.hxx>
75 : : #include <BRep_TEdge.hxx>
76 : : #include <BRep_CurveRepresentation.hxx>
77 : :
78 : : #include <TopoDS_Vertex.hxx>
79 : :
80 : : //#include <TColgp_HArray1OfPnt.hxx>
81 : : //#include <TColgp_HArray1OfPnt2d.hxx>
82 : : #include <TColStd_HArray1OfReal.hxx>
83 : : #include <Poly_Triangulation.hxx>
84 : : #include <Poly_PolygonOnTriangulation.hxx>
85 : :
86 : :
87 : : #ifdef MacOS
88 : : #define strcasecmp(p,q) strcmp(p,q)
89 : : #elseif WNT
90 : : #define strcasecmp strcmp
91 : : #elseif AIX
92 : : #include <string.h>
93 : : #endif
94 : :
95 : : const char* dVersion = "CASCADE Topology V1, (c) Matra-Datavision";
96 : : const char* dVersion2 = "CASCADE Topology V2, (c) Matra-Datavision";
97 : :
98 : : //=======================================================================
99 : : //function : PrintShapeEnum
100 : : //purpose :
101 : : //=======================================================================
102 : :
103 : 20196 : static void PrintShapeEnum(const TopAbs_ShapeEnum T,
104 : : Standard_OStream& S,
105 : : Standard_Boolean C)
106 : : {
107 [ + + + + : 20196 : switch(T) {
+ + - + -
- ]
108 : :
109 : : case TopAbs_VERTEX :
110 [ + - ]: 6029 : if (C) S << "Ve"; else S << "VERTEX ";
111 : 6029 : break;
112 : :
113 : : case TopAbs_EDGE :
114 [ + - ]: 7553 : if (C) S << "Ed"; else S << "EDGE ";
115 : 7553 : break;
116 : :
117 : : case TopAbs_WIRE :
118 [ + - ]: 2841 : if (C) S << "Wi"; else S << "WIRE ";
119 : 2841 : break;
120 : :
121 : : case TopAbs_FACE :
122 [ + - ]: 2770 : if (C) S << "Fa"; else S << "FACE ";
123 : 2770 : break;
124 : :
125 : : case TopAbs_SHELL :
126 [ + - ]: 370 : if (C) S << "Sh"; else S << "SHELL ";
127 : 370 : break;
128 : :
129 : : case TopAbs_SOLID :
130 [ + - ]: 370 : if (C) S << "So"; else S << "SOLID ";
131 : 370 : break;
132 : :
133 : : case TopAbs_COMPSOLID :
134 [ # # ]: 0 : if (C) S << "CS"; else S << "COMPSOLID";
135 : 0 : break;
136 : :
137 : : case TopAbs_COMPOUND :
138 [ + - ]: 263 : if (C) S << "Co"; else S << "COMPOUND ";
139 : 263 : break;
140 : :
141 : : case TopAbs_SHAPE :
142 [ # # ]: 0 : if (C) S << "Sp"; else S << "SHAPE";
143 : 0 : break;
144 : : }
145 : 20196 : }
146 : :
147 : : //=======================================================================
148 : : //function : PrintRegularity
149 : : //purpose :
150 : : //=======================================================================
151 : :
152 : 150 : static void PrintRegularity(const GeomAbs_Shape C,
153 : : Standard_OStream& OS)
154 : : {
155 [ - - - - : 150 : switch (C) {
- - + - ]
156 : :
157 : : case GeomAbs_C0 :
158 : 0 : OS << "C0";
159 : 0 : break;
160 : :
161 : : case GeomAbs_G1 :
162 : 0 : OS << "G1";
163 : 0 : break;
164 : :
165 : : case GeomAbs_C1 :
166 : 0 : OS << "C1";
167 : 0 : break;
168 : :
169 : : case GeomAbs_G2 :
170 : 0 : OS << "G2";
171 : 0 : break;
172 : :
173 : : case GeomAbs_C2 :
174 : 0 : OS << "C2";
175 : 0 : break;
176 : :
177 : : case GeomAbs_C3 :
178 : 0 : OS << "C3";
179 : 0 : break;
180 : :
181 : : case GeomAbs_CN :
182 : 150 : OS << "CN";
183 : 150 : break;
184 : :
185 : : }
186 : 150 : }
187 : :
188 : : //=======================================================================
189 : : //function : PrintOrientation
190 : : //purpose :
191 : : //=======================================================================
192 : :
193 : 34648 : static void PrintOrientation(const TopAbs_Orientation O,
194 : : Standard_OStream& S,
195 : : Standard_Boolean C)
196 : : {
197 [ + + - - : 34648 : switch(O) {
- ]
198 : :
199 : : case TopAbs_FORWARD :
200 [ + - ]: 19602 : if (C) S << "+"; else S << "FORWARD";
201 : 19602 : break;
202 : :
203 : : case TopAbs_REVERSED :
204 [ + - ]: 15046 : if (C) S << "-"; else S << "REVERSED";
205 : 15046 : break;
206 : :
207 : : case TopAbs_INTERNAL :
208 [ # # ]: 0 : if (C) S << "i"; else S << "INTERNAL";
209 : 0 : break;
210 : :
211 : : case TopAbs_EXTERNAL :
212 [ # # ]: 0 : if (C) S << "e"; else S << "EXTERNAL";
213 : 0 : break;
214 : : }
215 : 34648 : }
216 : :
217 : : //=======================================================================
218 : : //function : ReadShapeEnum
219 : : //purpose :
220 : : //=======================================================================
221 : :
222 : 19987 : static TopAbs_ShapeEnum ReadShapeEnum(Standard_IStream& IS)
223 : : {
224 [ + - ]: 19987 : std::string buffer;
225 [ + - ]: 19987 : IS >> buffer;
226 : :
227 [ + - ][ + + : 19987 : switch (buffer[0]) {
+ + + +
- ]
228 : :
229 : : case 'V' :
230 : 4852 : return TopAbs_VERTEX;
231 : :
232 : : case 'E' :
233 : 7498 : return TopAbs_EDGE;
234 : :
235 : : case 'W' :
236 : 3501 : return TopAbs_WIRE;
237 : :
238 : : case 'F' :
239 : 3309 : return TopAbs_FACE;
240 : :
241 : : case 'S' :
242 [ + - ][ + + ]: 652 : if (buffer[1] == 'h')
243 : 326 : return TopAbs_SHELL;
244 : : else
245 : 326 : return TopAbs_SOLID;
246 : :
247 : : case 'C' :
248 [ + - ][ - + ]: 175 : if (buffer[1] == 'S')
249 : 0 : return TopAbs_COMPSOLID;
250 : : else
251 : 175 : return TopAbs_COMPOUND;
252 : :
253 : : }
254 [ + - ]: 19987 : return TopAbs_COMPOUND;
255 : : }
256 : :
257 : : //=======================================================================
258 : : //function : ReadRegularity
259 : : //purpose :
260 : : //=======================================================================
261 : :
262 : 2273 : static GeomAbs_Shape ReadRegularity(Standard_IStream& IS)
263 : : {
264 [ + - ]: 2273 : std::string buffer;
265 [ + - ]: 2273 : IS >> buffer;
266 [ + - ]: 2273 : switch (buffer[0]) {
[ + + - ]
267 : :
268 : : case 'C' :
269 [ + - ][ - - : 117 : switch (buffer[1]) {
- - + - ]
270 : :
271 : : case '0' :
272 : 0 : return GeomAbs_C0;
273 : :
274 : : case '1' :
275 : 0 : return GeomAbs_C1;
276 : :
277 : : case '2' :
278 : 0 : return GeomAbs_C2;
279 : :
280 : : case '3' :
281 : 0 : return GeomAbs_C3;
282 : :
283 : : case 'N' :
284 : 117 : return GeomAbs_CN;
285 : : }
286 : 0 : break;
287 : :
288 : : case 'G' :
289 [ + - ]: 2156 : switch (buffer[1]) {
[ + - - ]
290 : :
291 : : case '1' :
292 : 2156 : return GeomAbs_G1;
293 : :
294 : : case '2' :
295 : 0 : return GeomAbs_G2;
296 : :
297 : : }
298 : 0 : break;
299 : : }
300 [ + - ]: 2273 : return GeomAbs_C0;
301 : : }
302 : :
303 : : //=======================================================================
304 : : //function : OCCShapeAttributeSet
305 : : //purpose :
306 : : //=======================================================================
307 : :
308 : 427 : OCCShapeAttributeSet::OCCShapeAttributeSet()
309 [ + - ][ + - ]: 427 : :myFormatNb(1)
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
310 : : {
311 : 427 : }
312 : :
313 : : //=======================================================================
314 : : //function : OCCShapeAttributeSet
315 : : //purpose :
316 : : //=======================================================================
317 : :
318 : 0 : OCCShapeAttributeSet::OCCShapeAttributeSet (const BRep_Builder& B)
319 [ # # ][ # # ]: 0 : :myBuilder(B)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
320 : : {
321 : 0 : }
322 : : //=======================================================================
323 : : //function : Add
324 : : //purpose :
325 : : //=======================================================================
326 : :
327 : 34648 : Standard_Integer OCCShapeAttributeSet::Add(const TopoDS_Shape& S)
328 : : {
329 [ + - ][ - + ]: 34648 : if (S.IsNull()) return 0;
330 [ + - ][ + - ]: 34648 : myLocations.Add(S.Location());
331 [ + - ]: 34648 : TopoDS_Shape S2 = S;
332 [ + - ][ + - ]: 34648 : S2.Location(TopLoc_Location());
[ + - ]
333 [ + - ]: 34648 : Standard_Integer index = myShapes.FindIndex(S2);
334 [ + + ]: 34648 : if (index == 0) {
335 [ + - ]: 20196 : AddGeometry(S2);
336 : :
337 [ + - ][ + - ]: 54603 : for (TopoDS_Iterator its(S2,Standard_False,Standard_False);
[ + + ]
338 [ + - ]: 34407 : its.More(); its.Next())
339 [ + - ][ + - ]: 54603 : Add(its.Value());
[ + - ]
340 [ + - ]: 20196 : index = myShapes.Add(S2);
341 : : }
342 : :
343 [ + - ]: 34648 : return index;
344 : : }
345 : :
346 : : //=======================================================================
347 : : //function : AddGeometry
348 : : //purpose :
349 : : //=======================================================================
350 : :
351 : 20196 : void OCCShapeAttributeSet::AddGeometry(const TopoDS_Shape& S)
352 : : {
353 : : // Add the geometry
354 : :
355 [ + + ]: 20196 : if (S.ShapeType() == TopAbs_VERTEX) {
356 : :
357 [ + - ][ + - ]: 6029 : Handle(BRep_TVertex) TV = Handle(BRep_TVertex)::DownCast(S.TShape());
358 [ + - ][ + - ]: 6029 : BRep_ListIteratorOfListOfPointRepresentation itrp(TV->Points());
[ + - ]
359 : :
360 [ + - ][ - + ]: 6029 : while (itrp.More()) {
361 [ # # ]: 0 : const Handle(BRep_PointRepresentation)& PR = itrp.Value();
362 : :
363 [ # # ][ # # ]: 0 : if (PR->IsPointOnCurve()) {
[ # # ]
364 [ # # ][ # # ]: 0 : myCurves.Add(PR->Curve());
[ # # ]
365 : : }
366 : :
367 [ # # ][ # # ]: 0 : else if (PR->IsPointOnCurveOnSurface()) {
[ # # ]
368 [ # # ][ # # ]: 0 : myCurves2d.Add(PR->PCurve());
[ # # ]
369 [ # # ][ # # ]: 0 : mySurfaces.Add(PR->Surface());
[ # # ]
370 : : }
371 : :
372 [ # # ][ # # ]: 0 : else if (PR->IsPointOnSurface()) {
[ # # ]
373 [ # # ][ # # ]: 0 : mySurfaces.Add(PR->Surface());
[ # # ]
374 : : }
375 : :
376 [ # # ][ # # ]: 0 : myLocations.Add(PR->Location());
[ # # ]
377 [ # # ]: 0 : itrp.Next();
378 [ + - ]: 6029 : }
379 : :
380 : : }
381 [ + + ]: 14167 : else if (S.ShapeType() == TopAbs_EDGE) {
382 : :
383 : : // Add the curve geometry
384 [ + - ][ + - ]: 7553 : Handle(BRep_TEdge) TE = Handle(BRep_TEdge)::DownCast(S.TShape());
385 [ + - ][ + - ]: 7553 : BRep_ListIteratorOfListOfCurveRepresentation itrc(TE->Curves());
[ + - ]
386 : :
387 [ + - ][ + + ]: 27762 : while (itrc.More()) {
388 [ + - ]: 20209 : const Handle(BRep_CurveRepresentation)& CR = itrc.Value();
389 [ + - ][ + - ]: 20209 : if (CR->IsCurve3D()) {
[ + + ]
390 [ + - ][ + - ]: 7553 : if (!CR->Curve3D().IsNull()) {
[ + - ][ + + ]
391 [ + - ][ + - ]: 7531 : myCurves.Add(CR->Curve3D());
[ + - ]
392 [ + - ][ + - ]: 7531 : myLocations.Add(CR->Location());
[ + - ]
393 : : }
394 : : }
395 [ + - ][ + - ]: 12656 : else if (CR->IsCurveOnSurface()) {
[ + + ]
396 [ + - ][ + - ]: 12590 : mySurfaces.Add(CR->Surface());
[ + - ]
397 [ + - ][ + - ]: 12590 : myCurves2d.Add(CR->PCurve());
[ + - ]
398 [ + - ][ + - ]: 12590 : myLocations.Add(CR->Location());
[ + - ]
399 [ + - ][ + - ]: 12590 : if (CR->IsCurveOnClosedSurface())
[ + + ]
400 [ + - ][ + - ]: 84 : myCurves2d.Add(CR->PCurve2());
[ + - ]
401 : : }
402 [ + - ][ + - ]: 66 : else if (CR->IsRegularity()) {
[ + - ]
403 [ + - ][ + - ]: 66 : mySurfaces.Add(CR->Surface());
[ + - ]
404 [ + - ][ + - ]: 66 : myLocations.Add(CR->Location());
[ + - ]
405 [ + - ][ + - ]: 66 : mySurfaces.Add(CR->Surface2());
[ + - ]
406 [ + - ][ + - ]: 66 : myLocations.Add(CR->Location2());
[ + - ]
407 : : }
408 [ + - ]: 20209 : itrc.Next();
409 [ + - ]: 7553 : }
410 : : }
411 : :
412 [ + + ]: 6614 : else if (S.ShapeType() == TopAbs_FACE) {
413 : :
414 : : // Add the surface geometry
415 [ + - ][ + - ]: 2770 : Handle(BRep_TFace) TF = Handle(BRep_TFace)::DownCast(S.TShape());
416 [ + - ][ + - ]: 2770 : if (!TF->Surface().IsNull()) mySurfaces.Add(TF->Surface());
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
417 : :
418 [ + - ][ + - ]: 2770 : myLocations.Add(TF->Location());
[ + - ][ + - ]
419 : : }
420 : 20196 : }
421 : :
422 : : //=======================================================================
423 : : //function : ReadAttribute
424 : : //purpose :
425 : : //=======================================================================
426 : :
427 : 3093 : void OCCShapeAttributeSet::ReadAttribute(TopoDS_Shape& S,
428 : : Standard_IStream& IS,
429 : : TDF_Label& l_attr)
430 : : {
431 [ + - ][ + - ]: 6186 : std::string buffer, type, stringdata;
[ + - ][ + - ]
[ + - ]
432 [ + - ][ + - ]: 6186 : std::vector<CubitString> strings;
433 [ + - ][ + - ]: 6186 : std::vector<double> doubles;
434 [ + - ][ + - ]: 6186 : std::vector<int> ints;
435 : : int c_num, length;
436 : : char s;
437 [ + + ]: 5355 : do {
438 [ + - ]: 5355 : IS >> c_num; //length of name string
439 [ + - ]: 5355 : IS.get(); //' '
440 [ + - ]: 5355 : type.clear();
441 [ + + ]: 59598 : for(int j = 0; j < c_num; j ++)
442 : : {
443 [ + - ]: 54243 : IS.get(s);
444 [ + - ]: 54243 : type.push_back(s);
445 : : }
446 : :
447 [ + - ]: 5355 : strings.clear();
448 [ + - ][ + - ]: 5355 : strings.push_back(type.c_str());
[ + - ][ + - ]
449 : :
450 [ + - ]: 5355 : IS >> length; //number of strings
451 [ + + ]: 6708 : for(int i =0; i < length; i++)
452 : : {
453 [ + - ]: 1353 : IS >> c_num ; //length of each string
454 [ + - ]: 1353 : IS.get(); //' '
455 [ + - ]: 1353 : stringdata.clear();
456 [ + + ]: 15220 : for(int j = 0; j < c_num; j ++)
457 : : {
458 [ + - ]: 13867 : IS.get(s);
459 [ + - ]: 13867 : stringdata.push_back(s);
460 : : }
461 [ + - ][ + - ]: 1353 : strings.push_back(stringdata.c_str());
[ + - ][ + - ]
462 : : }
463 : :
464 : : int tmp_int;
465 : : double tmp_dbl;
466 [ + - ]: 5355 : IS >> length; //number of ints
467 [ + - ]: 5355 : ints.clear();
468 [ + + ]: 17738 : for (int i = 0; i < length ; i++)
469 : : {
470 [ + - ]: 12383 : IS >> tmp_int;
471 [ + - ]: 12383 : ints.push_back( tmp_int );
472 : : }
473 : :
474 [ + - ]: 5355 : IS >> length; //number of doubles
475 [ + - ]: 5355 : doubles.clear();
476 [ + + ]: 5595 : for (int i = 0; i < length ; i++)
477 : : {
478 [ + - ]: 240 : IS >> tmp_dbl;
479 [ + - ]: 240 : doubles.push_back( tmp_dbl );
480 : : }
481 : :
482 [ + - ]: 5355 : CubitSimpleAttrib tmp_attrib(&strings, &doubles, &ints);
483 : :
484 [ + - ]: 5355 : OCCAttribSet::append_attribute(tmp_attrib, S);
485 : :
486 [ + - ][ + - ]: 5355 : IS >> buffer;
487 [ + - ][ + - ]: 8448 : }while(buffer[0] != '*');
488 : 3093 : }
489 : :
490 : : //=======================================================================
491 : : //function : WriteAttribute
492 : : //purpose :
493 : : //=======================================================================
494 : :
495 : 20196 : void OCCShapeAttributeSet::WriteAttribute(const TopoDS_Shape& S,
496 : : Standard_OStream& OS,
497 : : TDF_Label& l_attr)
498 : : {
499 [ + - ][ - + ]: 20196 : if(l_attr.IsNull())
500 : 20196 : return;
501 : :
502 : 20196 : Standard_Boolean found = Standard_False;
503 [ + - ]: 20196 : TDF_Label myLabel;
504 [ + - ][ + - ]: 1296593 : for (TDF_ChildIterator it1(l_attr,Standard_False); it1.More(); it1.Next())
[ + - ][ + + ]
505 : : {
506 : : //find the same shape attribute first
507 [ + - ]: 1284517 : myLabel = it1.Value();
508 : :
509 [ + - ]: 1284517 : Handle_TDataXtd_Shape attr_shape;
510 : :
511 [ + - ][ + - ]: 2569034 : TopoDS_Shape exsiting_shape;
[ + + + ]
512 : :
513 [ + - ][ + + ]: 1284517 : if(TDataXtd_Shape::Find(myLabel, attr_shape))
514 [ + - ][ + - ]: 839600 : exsiting_shape = attr_shape->Get(myLabel);
[ + - ][ + - ]
515 : :
516 [ + - ][ + + ]: 1284517 : if(!exsiting_shape.IsNull())
517 : : {
518 [ + - ][ + + ]: 839600 : if(exsiting_shape.IsPartner(S))
519 : : {
520 : : //It's possible that the myLabel found in this way wasn't the bounded
521 : : //lable with the shape. Find the bounded one now.
522 [ + - ][ + - ]: 8900 : if(!OCCQueryEngine::instance()->OCCMap->IsBound(exsiting_shape))
[ + + ]
523 : 780 : continue;
524 : :
525 [ + - ][ + - ]: 8120 : int k = OCCQueryEngine::instance()->OCCMap->Find(exsiting_shape);
526 : : std::map<int, TDF_Label>::iterator it =
527 [ + - ][ + - ]: 8120 : OCCQueryEngine::instance()->Shape_Label_Map->find(k);
528 [ + - ][ + - ]: 8120 : if(it != OCCQueryEngine::instance()->Shape_Label_Map->end())
[ + - ][ + - ]
529 : : {
530 : 8120 : found = Standard_True;
531 [ + - ]: 8120 : myLabel = (*it).second;
532 [ + - ]: 1284517 : break;
[ + + + ]
533 : : }
534 : : }
535 : : }
536 : 1284517 : }
537 [ + + ]: 20196 : if(!found)
538 : : {
539 [ + - ]: 12076 : OS << "\n*";
540 : 12076 : return;
541 : : }
542 : :
543 [ + - ][ - + ]: 8120 : if(!myLabel.HasChild())
544 : : {
545 [ # # ]: 0 : OS << "\n*";
546 : 0 : return;
547 : : }
548 : :
549 [ + - ][ + - ]: 26811 : for (TDF_ChildIterator it2(myLabel,Standard_False); it2.More(); it2.Next())
[ + - ][ + + ]
550 : : {
551 [ + - ]: 18691 : TDF_Label child = it2.Value();
552 : : //Write out all attributes
553 [ + - ]: 18691 : Handle_TDataStd_Name attr_name;
554 [ + - ][ + - ]: 37382 : TCollection_ExtendedString name_string;
[ + + ]
555 [ + - ][ + - ]: 18691 : if(child.FindAttribute(TDataStd_Name::GetID(), attr_name))
[ + + ]
556 : : {
557 [ + - ]: 11163 : OS << "\n";
558 [ + - ]: 11163 : OS << "CGM_ATTRIB ";
559 [ + - ][ + - ]: 11163 : name_string = attr_name->Get();
[ + - ]
560 [ + - ]: 11163 : int length = name_string.Length();
561 [ + - ][ + - ]: 11163 : OS << length << ' ';
562 [ + - ]: 11163 : name_string.Print(OS);
563 [ + - ]: 11163 : OS << ' ' ;
564 : : }
565 : : else
566 : 7528 : continue;
567 : :
568 [ + - ][ + - ]: 29854 : Handle_TDataStd_ExtStringArray attr_strings;
[ + - ][ + + ]
569 [ + - ][ + - ]: 11163 : if(child.FindAttribute(TDataStd_ExtStringArray::GetID(), attr_strings))
[ + + ]
570 : : {
571 [ + - ][ + - ]: 1031 : Standard_Integer i = attr_strings->Lower();
572 [ + - ]: 1031 : TCollection_ExtendedString string;
573 [ + - ][ + - ]: 1031 : int size = attr_strings->Upper();
574 [ + - ][ + - ]: 1031 : OS << size -i + 1 << " ";
575 [ + + ]: 2483 : for(; i <= size; i++)
576 : : {
577 [ + - ][ + - ]: 1452 : string = attr_strings->Value(i);
[ + - ]
578 [ + - ]: 1452 : int length = string.Length();
579 [ + - ][ + - ]: 1452 : OS << length << ' ';
580 [ + - ]: 1452 : string.Print(OS);
581 [ + - ]: 1452 : OS << ' ';
582 [ + - ]: 1031 : }
583 : : }
584 : : else
585 [ + - ]: 10132 : OS << "0 " ;
586 : :
587 [ + - ][ + - ]: 22326 : Handle_TDataStd_IntegerArray attr_ints;
588 : :
589 [ + - ][ + - ]: 11163 : if(child.FindAttribute(TDataStd_IntegerArray::GetID(), attr_ints))
[ + + ]
590 : : {
591 [ + - ][ + - ]: 10337 : Standard_Integer i = attr_ints->Lower();
592 [ + - ][ + - ]: 10337 : int size = attr_ints->Upper();
593 [ + - ][ + - ]: 10337 : OS << size -i + 1 << " ";
594 [ + + ]: 40078 : for(; i <= size; i++)
595 [ + - ][ + - ]: 29741 : OS << attr_ints->Value(i) << ' ';
[ + - ][ + - ]
596 : : }
597 : : else
598 [ + - ]: 826 : OS << "0 " ;
599 : :
600 [ + - ][ + - ]: 22326 : Handle_TDataStd_RealArray attr_doubles;
601 [ + - ][ + - ]: 11163 : if(child.FindAttribute(TDataStd_RealArray::GetID(), attr_doubles))
[ + + ]
602 : : {
603 [ + - ][ + - ]: 80 : Standard_Integer i = attr_doubles->Lower();
604 [ + - ][ + - ]: 80 : Standard_Integer size = attr_doubles->Upper();
605 [ + - ][ + - ]: 80 : OS << size -i + 1 << " ";
606 [ + + ]: 320 : for(;i <= size; i++)
607 [ + - ][ + - ]: 240 : OS << attr_doubles->Value(i) << ' ';
[ + - ][ + - ]
608 : : }
609 : : else
610 [ + - ]: 11083 : OS << "0 " ;
611 : 18691 : }
612 [ + - ]: 8120 : OS << "\n*";
613 : : }
614 : :
615 : : //=======================================================================
616 : : //function : Write
617 : : //purpose :
618 : : //=======================================================================
619 : :
620 : 241 : void OCCShapeAttributeSet::Write(Standard_OStream& OS)
621 : : {
622 : : //on sauvegarde l'ancien LC_NUMERIC
623 : :
624 : : char *oldnum,*plocal ;
625 : 241 : plocal = setlocale(LC_NUMERIC, NULL) ;
626 : 241 : oldnum = new char[strlen(plocal)+1] ;
627 : 241 : strcpy(oldnum,plocal);
628 : :
629 : : // on positionne LC_NUMERIC a "C" (point decimal)
630 : 241 : setlocale(LC_NUMERIC, "C") ;
631 : :
632 : 241 : int prec = OS.precision(15);
633 : :
634 : : // write the copyright
635 [ - + ]: 241 : if (myFormatNb == 2)
636 : 0 : OS << "\n" << dVersion2 << endl;
637 : : else
638 : 241 : OS << "\n" << dVersion << endl;
639 : :
640 : : //-----------------------------------------
641 : : // write the locations
642 : : //-----------------------------------------
643 : 241 : myLocations.Write(OS);
644 : :
645 : : //-----------------------------------------
646 : : // write the geometry
647 : : //-----------------------------------------
648 : :
649 : 241 : WriteGeometry(OS);
650 : :
651 : : //-----------------------------------------
652 : : // write the shapes
653 : : //-----------------------------------------
654 : 241 : Standard_Integer i, nbShapes = myShapes.Extent();
655 : :
656 : 241 : OS << "\nTShapes " << nbShapes << "\n";
657 : :
658 : :
659 : : // subshapes are written first
660 [ + + ]: 20437 : for (i = 1; i <= nbShapes; i++) {
661 : :
662 [ + - ]: 20196 : const TopoDS_Shape& S = myShapes(i);
663 : :
664 : : // Type
665 [ + - ][ + - ]: 20196 : PrintShapeEnum(S.ShapeType(),OS,Standard_True);
666 [ + - ]: 20196 : OS << "\n";
667 : :
668 : : // Geometry
669 [ + - ]: 20196 : WriteGeometry(S,OS);
670 : :
671 : : // Flags
672 [ + - ]: 20196 : OS << "\n";
673 [ + - ][ + + ]: 20196 : OS << (S.Free() ? 1 : 0);
[ + - ]
674 [ + - ][ + - ]: 20196 : OS << (S.Modified() ? 1 : 0);
[ + - ]
675 [ + - ][ + + ]: 20196 : OS << (S.Checked() ? 1 : 0);
[ + - ]
676 [ + - ][ + + ]: 20196 : OS << (S.Orientable() ? 1 : 0);
[ + - ]
677 [ + - ][ + + ]: 20196 : OS << (S.Closed() ? 1 : 0);
[ + - ]
678 [ + - ][ - + ]: 20196 : OS << (S.Infinite() ? 1 : 0);
[ + - ]
679 [ + - ][ + + ]: 20196 : OS << (S.Convex() ? 1 : 0);
[ + - ]
680 [ + - ]: 20196 : OS << "\n";
681 : :
682 : : // sub-shapes
683 : :
684 : 20196 : Standard_Integer l = 0;
685 [ + - ]: 20196 : TopoDS_Iterator its(S,Standard_False,Standard_False);
686 [ + - ][ + + ]: 54603 : while (its.More()) {
687 [ + - ][ + - ]: 34407 : Write(its.Value(),OS);
688 : 34407 : l++;
689 [ + + ]: 34407 : if (l == 10) {
690 [ + - ]: 263 : OS << "\n";
691 : 263 : l = 0;
692 : : }
693 [ + - ]: 34407 : its.Next();
694 : : }
695 [ + - ][ + - ]: 20196 : Write(TopoDS_Shape(),OS); // Null shape to end the list
[ + - ]
696 [ + - ]: 20196 : OS << "\n";
697 [ + - ]: 20196 : }
698 : :
699 : 241 : OS << endl;
700 : 241 : OS.precision(prec);
701 : :
702 : : // on remet le LC_NUMERIC a la precedente valeur
703 : 241 : setlocale(LC_NUMERIC, oldnum) ;
704 [ + - ]: 241 : delete[] oldnum;
705 : 241 : }
706 : :
707 : : //=======================================================================
708 : : //function : Read
709 : : //purpose :
710 : : //=======================================================================
711 : :
712 : 186 : void OCCShapeAttributeSet::Read(Standard_IStream& IS, bool print_results)
713 : : {
714 : : // on sauvegarde l'ancien LC_NUMERIC
715 : : char *oldnum,*plocal ;
716 : 186 : plocal = setlocale(LC_NUMERIC, NULL) ;
717 [ + - ]: 186 : oldnum = new char[strlen(plocal)+1] ;
718 : 186 : strcpy(oldnum,plocal);
719 : :
720 [ + - ]: 186 : Clear();
721 : :
722 : : // Check the version
723 : : char vers[101];
724 [ + + ]: 558 : do {
725 [ + - ]: 558 : IS.getline(vers,100,'\n');
726 : : // BUC60769 PTV 18.10.2000: remove possible '\r' at the end of the line
727 : : //Standard_Integer lv = strlen(vers);
728 : : //char *pm;
729 : : //if(pm = strchr(vers,'\r'))
730 : : // *pm ='\0';
731 : :
732 [ + + ][ - + ]: 558 : for (Standard_Integer lv = (strlen(vers)- 1); lv > 1 && (vers[lv] == '\r' || vers[lv] == '\n') ;lv--)
[ - + ]
733 : 0 : vers[lv] = '\0';
734 : :
735 [ + - ][ + - ]: 558 : } while ( ! IS.fail() && strcmp(vers,dVersion) && strcmp(vers,dVersion2) );
[ + + ][ + - ]
736 [ + - ][ - + ]: 186 : if (IS.fail()) {
737 [ # # ]: 0 : if (print_results)
738 [ # # ][ # # ]: 0 : cout << "File was not written with this version of the topology"<<endl;
739 : 0 : setlocale(LC_NUMERIC, oldnum) ;
740 [ # # ]: 0 : delete[] oldnum;
741 : 186 : return;
742 : : }
743 [ - + ]: 186 : if (strcmp(vers,dVersion2) == 0) myFormatNb = 2;
744 : 186 : else myFormatNb = 1;
745 : :
746 : : //-----------------------------------------
747 : : // read the locations
748 : : //-----------------------------------------
749 : :
750 [ + - ]: 186 : myLocations.Read(IS);
751 : :
752 : : //-----------------------------------------
753 : : // read the geometry
754 : : //-----------------------------------------
755 : :
756 [ + - ]: 186 : ReadGeometry(IS);
757 : :
758 : : //-----------------------------------------
759 : : // read the shapes
760 : : //-----------------------------------------
761 : :
762 [ + - ]: 186 : std::string buffer;
763 [ + - ]: 186 : IS >> buffer;
764 [ + - ][ - + ]: 186 : if (buffer != "TShapes") {
765 [ # # ]: 0 : if (print_results)
766 [ # # ][ # # ]: 0 : cout << "Not a TShape table"<<endl;
767 : 0 : setlocale(LC_NUMERIC, oldnum) ;
768 [ # # ]: 0 : delete[] oldnum;
769 : 0 : return;
770 : : }
771 : :
772 : : Standard_Integer i, nbShapes;
773 [ + - ]: 186 : IS >> nbShapes;
774 : :
775 [ + + ]: 20173 : for (i = 1; i <= nbShapes; i++) {
776 : :
777 [ + - ]: 19987 : TopoDS_Shape S;
778 : :
779 : : //Read type and create empty shape.
780 [ + - ]: 19987 : TopAbs_ShapeEnum T = ReadShapeEnum(IS);
781 [ + - ]: 19987 : ReadGeometry(T,IS,S);
782 : :
783 : : // Set the flags
784 [ + - ]: 19987 : IS >> buffer;
785 : :
786 : : // sub-shapes
787 [ + - ][ + - ]: 39974 : TopoDS_Shape SS;
788 [ + + ]: 57419 : do {
789 [ + - ]: 57419 : Read(SS,IS,nbShapes);
790 [ + - ][ + + ]: 57419 : if (!SS.IsNull())
791 [ + - ]: 37432 : myBuilder.Add(S,SS);
792 [ + - ]: 57419 : } while(!SS.IsNull());
793 : :
794 [ + - ][ + - ]: 19987 : S.Free (buffer[0] == '1');
795 [ + - ][ + - ]: 19987 : S.Modified (buffer[1] == '1');
796 : :
797 [ - + ]: 19987 : if (myFormatNb == 2)
798 [ # # ][ # # ]: 0 : S.Checked (buffer[2] == '1');
799 : : else
800 [ + - ]: 19987 : S.Checked (Standard_False); // force check at reading..
801 : :
802 [ + - ][ + - ]: 19987 : S.Orientable(buffer[3] == '1');
803 [ + - ][ + - ]: 19987 : S.Closed (buffer[4] == '1');
804 [ + - ][ + - ]: 19987 : S.Infinite (buffer[5] == '1');
805 [ + - ][ + - ]: 19987 : S.Convex (buffer[6] == '1');
806 : :
807 : : // check
808 : :
809 [ + - ]: 19987 : if (myFormatNb == 1)
810 [ + - ]: 19987 : Check(T,S);
811 : :
812 [ + - ]: 19987 : myShapes.Add(S);
813 [ + - ]: 19987 : }
814 : :
815 : 186 : setlocale(LC_NUMERIC, oldnum) ;
816 [ + - ][ + - ]: 186 : delete[] oldnum;
[ + - ]
817 : : }
818 : :
819 : : //=======================================================================
820 : : //function : WriteGeometry
821 : : //purpose :
822 : : //=======================================================================
823 : :
824 : 241 : void OCCShapeAttributeSet::WriteGeometry(Standard_OStream& OS)
825 : : {
826 : 241 : myCurves2d.Write(OS);
827 : 241 : myCurves.Write(OS);
828 : 241 : WritePolygon3D(OS);
829 : 241 : WritePolygonOnTriangulation(OS);
830 : 241 : mySurfaces.Write(OS);
831 : 241 : WriteTriangulation(OS);
832 : 241 : }
833 : :
834 : : //=======================================================================
835 : : //function : ReadGeometry
836 : : //purpose :
837 : : //=======================================================================
838 : :
839 : 186 : void OCCShapeAttributeSet::ReadGeometry(Standard_IStream& IS)
840 : : {
841 : 186 : myCurves2d.Read(IS);
842 : 186 : myCurves.Read(IS);
843 : 186 : ReadPolygon3D(IS);
844 : 186 : ReadPolygonOnTriangulation(IS);
845 : 186 : mySurfaces.Read(IS);
846 : 186 : ReadTriangulation(IS);
847 : 186 : }
848 : :
849 : : //=======================================================================
850 : : //function : WritePolygon3D
851 : : //purpose :
852 : : //=======================================================================
853 : :
854 : 241 : void OCCShapeAttributeSet::WritePolygon3D(Standard_OStream& OS,
855 : : const Standard_Boolean Compact)
856 : : {
857 [ + - ]: 241 : Standard_Integer i, j, nbpol = myPolygons3D.Extent();
858 [ + - ]: 241 : if (Compact)
859 [ + - ][ + - ]: 241 : OS << "Polygon3D " << nbpol << endl;
[ + - ]
860 : : else {
861 [ # # ]: 0 : OS << " -------\n";
862 [ # # ][ # # ]: 0 : OS <<"Dump of " << nbpol << " Polygon3Ds\n";
[ # # ]
863 [ # # ]: 0 : OS << " -------\n";
864 : : }
865 : :
866 [ + - ]: 241 : Handle(Poly_Polygon3D) P;
867 [ - + ]: 241 : for (i = 1; i <= nbpol; i++) {
868 [ # # ][ # # ]: 0 : P = Handle(Poly_Polygon3D)::DownCast(myPolygons3D(i));
[ # # ][ # # ]
869 [ # # ]: 0 : if (Compact) {
870 [ # # ][ # # ]: 0 : OS << P->NbNodes() << " ";
[ # # ][ # # ]
871 [ # # ][ # # ]: 0 : OS << ((P->HasParameters()) ? "1" : "0") << "\n";
[ # # ][ # # ]
[ # # ]
872 : : }
873 : : else {
874 [ # # ][ # # ]: 0 : OS << " "<< i << " : Polygon3D with " << P->NbNodes() << " Nodes\n";
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
875 [ # # ][ # # ]: 0 : OS << ((P->HasParameters()) ? "with" : "without") << " parameters\n";
[ # # ][ # # ]
[ # # ]
876 : : }
877 : :
878 : :
879 : : // write the deflection
880 [ # # ][ # # ]: 0 : if (!Compact) OS << "Deflection : ";
881 [ # # ][ # # ]: 0 : OS << P->Deflection() << "\n";
[ # # ][ # # ]
882 : :
883 : : // write the nodes
884 [ # # ][ # # ]: 0 : if (!Compact) OS << "\nNodes :\n";
885 : :
886 [ # # ][ # # ]: 0 : Standard_Integer i1, nbNodes = P->NbNodes();
887 [ # # ][ # # ]: 0 : const TColgp_Array1OfPnt& Nodes = P->Nodes();
888 [ # # ]: 0 : for (j = 1; j <= nbNodes; j++) {
889 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(10) << j << " : ";
[ # # ][ # # ]
[ # # ]
890 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(17);
[ # # ]
891 [ # # ][ # # ]: 0 : OS << Nodes(j).X() << " ";
[ # # ][ # # ]
892 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(17);
[ # # ]
893 [ # # ][ # # ]: 0 : OS << Nodes(j).Y() << " ";
[ # # ][ # # ]
894 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(17);
[ # # ]
895 [ # # ][ # # ]: 0 : OS << Nodes(j).Z();
[ # # ]
896 [ # # ][ # # ]: 0 : if (!Compact) OS << "\n";
897 [ # # ]: 0 : else OS << " ";
898 : : }
899 [ # # ]: 0 : OS <<"\n";
900 : :
901 [ # # ][ # # ]: 0 : if (P->HasParameters()) {
[ # # ]
902 [ # # ][ # # ]: 0 : if (!Compact) OS << "\nParameters :\n";
903 [ # # ][ # # ]: 0 : const TColStd_Array1OfReal& Param = P->Parameters();
904 [ # # ]: 0 : for ( i1 = 1; i1 <= nbNodes; i1++ ) {
905 [ # # ][ # # ]: 0 : OS << Param(i1) << " ";
[ # # ]
906 : : }
907 [ # # ]: 0 : OS <<"\n";
908 : : }
909 [ + - ]: 241 : }
910 : 241 : }
911 : :
912 : : //=======================================================================
913 : : //function : WritePolygonOnTriangulation
914 : : //purpose :
915 : : //=======================================================================
916 : :
917 : 241 : void OCCShapeAttributeSet::WritePolygonOnTriangulation(
918 : : Standard_OStream& OS,
919 : : const Standard_Boolean Compact)
920 : : {
921 [ + - ]: 241 : Standard_Integer i, j, nbpOntri = myNodes.Extent();
922 [ + - ]: 241 : if (Compact)
923 [ + - ][ + - ]: 241 : OS << "PolygonOnTriangulations " << nbpOntri << endl;
[ + - ]
924 : : else {
925 [ # # ]: 0 : OS << " -------\n";
926 [ # # ][ # # ]: 0 : OS <<"Dump of " << nbpOntri << " PolygonOnTriangulations\n";
[ # # ]
927 [ # # ]: 0 : OS << " -------\n";
928 : : }
929 : :
930 [ + - ]: 241 : Handle(Poly_PolygonOnTriangulation) Poly;
931 [ + - ][ + - ]: 482 : Handle(TColStd_HArray1OfReal) Param;
932 : :
933 [ - + ]: 241 : for (i=1; i<=nbpOntri; i++) {
934 [ # # ][ # # ]: 0 : Poly = Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(i));
[ # # ][ # # ]
935 [ # # ][ # # ]: 0 : const TColStd_Array1OfInteger& Nodes = Poly->Nodes();
936 [ # # ]: 0 : if (!Compact) {
937 [ # # ][ # # ]: 0 : OS << " "<< i << " : PolygonOnTriangulation with " << Nodes.Length() << " Nodes\n";
[ # # ][ # # ]
[ # # ][ # # ]
938 : : }
939 [ # # ][ # # ]: 0 : else OS << Nodes.Length()<<" ";
[ # # ]
940 [ # # ][ # # ]: 0 : if (!Compact) OS <<" ";
941 [ # # ][ # # ]: 0 : for (j=1; j <= Nodes.Length(); j++) OS << Nodes.Value(j) << " ";
[ # # ][ # # ]
[ # # ]
942 [ # # ]: 0 : OS << "\n";
943 : :
944 : : // writing parameters:
945 [ # # ][ # # ]: 0 : Param = Poly->Parameters();
[ # # ][ # # ]
946 [ # # ][ # # ]: 0 : if (Compact) OS <<"p ";
947 : :
948 : : // write the deflection
949 [ # # ][ # # ]: 0 : if (!Compact) OS << " Deflection : ";
950 [ # # ][ # # ]: 0 : OS <<Poly->Deflection() << " ";
[ # # ][ # # ]
951 [ # # ][ # # ]: 0 : if (!Compact) OS << "\n";
952 : :
953 [ # # ][ # # ]: 0 : if (!Param.IsNull()) {
954 [ # # ]: 0 : if (!Compact) {
955 [ # # ][ # # ]: 0 : OS << " "<< "Parameters :";
956 : : }
957 [ # # ]: 0 : else OS << "1 " ;
958 [ # # ][ # # ]: 0 : if (!Compact) OS <<" ";
959 [ # # ][ # # ]: 0 : for (j=1; j <= Param->Length(); j++) OS << Param->Value(j) << " ";
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
960 [ # # ]: 0 : OS << "\n";
961 : : }
962 [ # # ]: 0 : else OS <<"0 \n";
963 [ + - ]: 241 : }
964 : :
965 : 241 : }
966 : :
967 : : //=======================================================================
968 : : //function : WriteTriangulation
969 : : //purpose :
970 : : //=======================================================================
971 : :
972 : 241 : void OCCShapeAttributeSet::WriteTriangulation(Standard_OStream& OS,
973 : : const Standard_Boolean Compact)
974 : : {
975 [ + - ]: 241 : Standard_Integer i, j, nbNodes, nbtri = myTriangulations.Extent();
976 : 241 : Standard_Integer nbTriangles = 0, n1, n2, n3;
977 [ + - ]: 241 : if (Compact)
978 [ + - ][ + - ]: 241 : OS << "Triangulations " << nbtri << endl;
[ + - ]
979 : : else {
980 [ # # ]: 0 : OS << " -------\n";
981 [ # # ][ # # ]: 0 : OS <<"Dump of " << nbtri << " Triangulations\n";
[ # # ]
982 [ # # ]: 0 : OS << " -------\n";
983 : : }
984 : :
985 [ + - ]: 241 : Handle(Poly_Triangulation) T;
986 [ - + ]: 241 : for (i = 1; i <= nbtri; i++) {
987 [ # # ][ # # ]: 0 : T = Handle(Poly_Triangulation)::DownCast(myTriangulations(i));
[ # # ][ # # ]
988 [ # # ]: 0 : if (Compact) {
989 [ # # ][ # # ]: 0 : OS << T->NbNodes() << " " << T->NbTriangles() << " ";
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
990 [ # # ][ # # ]: 0 : OS << ((T->HasUVNodes()) ? "1" : "0") << " ";
[ # # ][ # # ]
[ # # ]
991 : : }
992 : : else {
993 [ # # ][ # # ]: 0 : OS << " "<< i << " : Triangulation with " << T->NbNodes() << " Nodes and "
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
994 [ # # ][ # # ]: 0 : << T->NbTriangles() <<" Triangles\n";
[ # # ][ # # ]
995 [ # # ][ # # ]: 0 : OS << " "<<((T->HasUVNodes()) ? "with" : "without") << " UV nodes\n";
[ # # ][ # # ]
[ # # ][ # # ]
996 : : }
997 : :
998 : : // write the deflection
999 : :
1000 [ # # ][ # # ]: 0 : if (!Compact) OS << " Deflection : ";
1001 [ # # ][ # # ]: 0 : OS <<T->Deflection() << "\n";
[ # # ][ # # ]
1002 : :
1003 : : // write the 3d nodes
1004 : :
1005 [ # # ][ # # ]: 0 : if (!Compact) OS << "\n3D Nodes :\n";
1006 : :
1007 [ # # ][ # # ]: 0 : nbNodes = T->NbNodes();
1008 [ # # ][ # # ]: 0 : const TColgp_Array1OfPnt& Nodes = T->Nodes();
1009 [ # # ]: 0 : for (j = 1; j <= nbNodes; j++) {
1010 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(10) << j << " : ";
[ # # ][ # # ]
[ # # ]
1011 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(17);
[ # # ]
1012 [ # # ][ # # ]: 0 : OS << Nodes(j).X() << " ";
[ # # ][ # # ]
1013 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(17);
[ # # ]
1014 [ # # ][ # # ]: 0 : OS << Nodes(j).Y() << " ";
[ # # ][ # # ]
1015 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(17);
[ # # ]
1016 [ # # ][ # # ]: 0 : OS << Nodes(j).Z();
[ # # ]
1017 [ # # ][ # # ]: 0 : if (!Compact) OS << "\n";
1018 [ # # ]: 0 : else OS << " ";
1019 : : }
1020 : :
1021 [ # # ][ # # ]: 0 : if (T->HasUVNodes()) {
[ # # ]
1022 [ # # ][ # # ]: 0 : if (!Compact) OS << "\nUV Nodes :\n";
1023 [ # # ][ # # ]: 0 : const TColgp_Array1OfPnt2d& UVNodes = T->UVNodes();
1024 [ # # ]: 0 : for (j = 1; j <= nbNodes; j++) {
1025 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(10) << j << " : ";
[ # # ][ # # ]
[ # # ]
1026 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(17);
[ # # ]
1027 [ # # ][ # # ]: 0 : OS << UVNodes(j).X() << " ";
[ # # ][ # # ]
1028 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(17);
[ # # ]
1029 [ # # ][ # # ]: 0 : OS << UVNodes(j).Y();
[ # # ]
1030 [ # # ][ # # ]: 0 : if (!Compact) OS << "\n";
1031 [ # # ]: 0 : else OS << " ";
1032 : : }
1033 : : }
1034 : :
1035 [ # # ][ # # ]: 0 : if (!Compact) OS << "\nTriangles :\n";
1036 [ # # ][ # # ]: 0 : nbTriangles = T->NbTriangles();
1037 [ # # ][ # # ]: 0 : const Poly_Array1OfTriangle& Triangles = T->Triangles();
1038 [ # # ]: 0 : for (j = 1; j <= nbTriangles; j++) {
1039 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(10) << j << " : ";
[ # # ][ # # ]
[ # # ]
1040 [ # # ][ # # ]: 0 : Triangles(j).Get(n1, n2, n3);
1041 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(10);
[ # # ]
1042 [ # # ][ # # ]: 0 : OS << n1 << " ";
1043 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(10);
[ # # ]
1044 [ # # ][ # # ]: 0 : OS << n2 << " ";
1045 [ # # ][ # # ]: 0 : if (!Compact) OS << setw(10);
[ # # ]
1046 [ # # ]: 0 : OS << n3;
1047 [ # # ][ # # ]: 0 : if (!Compact) OS << "\n";
1048 [ # # ]: 0 : else OS << " ";
1049 : : }
1050 [ # # ]: 0 : OS << "\n";
1051 [ + - ]: 241 : }
1052 : :
1053 : 241 : }
1054 : : //=======================================================================
1055 : : //function : WriteGeometry
1056 : : //purpose :
1057 : : //=======================================================================
1058 : :
1059 : 20196 : void OCCShapeAttributeSet::WriteGeometry(const TopoDS_Shape& S,
1060 : : Standard_OStream& OS)
1061 : : {
1062 : : // Write the geometry
1063 : :
1064 [ + + ]: 20196 : if (S.ShapeType() == TopAbs_VERTEX) {
1065 : :
1066 : : // Write the point geometry
1067 [ + - ][ + - ]: 6029 : TopoDS_Vertex V = TopoDS::Vertex(S);
1068 [ + - ][ + - ]: 6029 : OS << BRep_Tool::Tolerance(V) << "\n";
[ + - ]
1069 [ + - ]: 6029 : gp_Pnt p = BRep_Tool::Pnt(V);
1070 [ + - ][ + - ]: 6029 : OS<<p.X()<<" "<<p.Y()<<" "<<p.Z()<<"\n";
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
1071 : :
1072 [ + - ][ + - ]: 12058 : Handle(BRep_TVertex) TV = Handle(BRep_TVertex)::DownCast(S.TShape());
[ + - ]
1073 [ + - ][ + - ]: 6029 : BRep_ListIteratorOfListOfPointRepresentation itrp(TV->Points());
[ + - ]
1074 : :
1075 [ + - ][ - + ]: 6029 : while (itrp.More()) {
1076 [ # # ]: 0 : const Handle(BRep_PointRepresentation)& PR = itrp.Value();
1077 : :
1078 [ # # ][ # # ]: 0 : OS << PR->Parameter();
[ # # ]
1079 [ # # ][ # # ]: 0 : if (PR->IsPointOnCurve()) {
[ # # ]
1080 [ # # ][ # # ]: 0 : OS << " 1 " << myCurves.Index(PR->Curve());
[ # # ][ # # ]
[ # # ]
1081 : : }
1082 : :
1083 [ # # ][ # # ]: 0 : else if (PR->IsPointOnCurveOnSurface()) {
[ # # ]
1084 [ # # ][ # # ]: 0 : OS << " 2 " << myCurves2d.Index(PR->PCurve());
[ # # ][ # # ]
[ # # ]
1085 [ # # ][ # # ]: 0 : OS << " " << mySurfaces.Index(PR->Surface());
[ # # ][ # # ]
[ # # ]
1086 : : }
1087 : :
1088 [ # # ][ # # ]: 0 : else if (PR->IsPointOnSurface()) {
[ # # ]
1089 [ # # ][ # # ]: 0 : OS << " 3 " << PR->Parameter2() << " ";
[ # # ][ # # ]
[ # # ]
1090 [ # # ][ # # ]: 0 : OS << mySurfaces.Index(PR->Surface());
[ # # ][ # # ]
1091 : : }
1092 : :
1093 [ # # ][ # # ]: 0 : OS << " " << myLocations.Index(PR->Location());
[ # # ][ # # ]
[ # # ]
1094 [ # # ]: 0 : OS << "\n";
1095 : :
1096 [ # # ]: 0 : itrp.Next();
1097 : : }
1098 : :
1099 [ + - ][ + - ]: 12058 : OS << "0 0\n"; // end representations
1100 : :
1101 : : }
1102 : :
1103 [ + + ]: 14167 : else if (S.ShapeType() == TopAbs_EDGE) {
1104 : :
1105 : : // Write the curve geometry
1106 : :
1107 [ + - ][ + - ]: 7553 : Handle(BRep_TEdge) TE = Handle(BRep_TEdge)::DownCast(S.TShape());
1108 : :
1109 [ + - ][ + - ]: 7553 : OS << " " << TE->Tolerance() << " ";
[ + - ][ + - ]
[ + - ]
1110 [ + - ][ + - ]: 7553 : OS << ((TE->SameParameter()) ? 1 : 0) << " ";
[ + - ][ + - ]
[ + - ]
1111 [ + - ][ + - ]: 7553 : OS << ((TE->SameRange()) ? 1 : 0) << " ";
[ + - ][ + - ]
[ + - ]
1112 [ + - ][ + - ]: 7553 : OS << ((TE->Degenerated()) ? 1 : 0) << "\n";
[ + + ][ + - ]
[ + - ]
1113 : :
1114 : : Standard_Real first, last;
1115 [ + - ][ + - ]: 7553 : BRep_ListIteratorOfListOfCurveRepresentation itrc = TE->Curves();
[ + - ]
1116 [ + - ][ + + ]: 27762 : while (itrc.More()) {
1117 [ + - ]: 20209 : const Handle(BRep_CurveRepresentation)& CR = itrc.Value();
1118 [ + - ][ + - ]: 20209 : if (CR->IsCurve3D()) {
[ + + ]
1119 [ + - ][ + - ]: 7553 : if (!CR->Curve3D().IsNull()) {
[ + - ][ + + ]
1120 [ + - ][ + - ]: 7531 : Handle(BRep_GCurve) GC = Handle(BRep_GCurve)::DownCast(itrc.Value());
1121 [ + - ][ + - ]: 7531 : GC->Range(first, last);
1122 [ + - ]: 7531 : OS << "1 "; // -1- Curve 3D
1123 [ + - ][ + - ]: 7531 : OS << " "<<myCurves.Index(CR->Curve3D());
[ + - ][ + - ]
[ + - ]
1124 [ + - ][ + - ]: 7531 : OS << " "<<myLocations.Index(CR->Location());
[ + - ][ + - ]
[ + - ]
1125 [ + - ][ + - ]: 7531 : OS << " "<<first<<" "<<last;
[ + - ][ + - ]
1126 [ + - ][ + - ]: 7553 : OS << "\n";
1127 : : }
1128 : : }
1129 [ + - ][ + - ]: 12656 : else if (CR->IsCurveOnSurface()) {
[ + + ]
1130 [ + - ][ + - ]: 12590 : Handle(BRep_GCurve) GC = Handle(BRep_GCurve)::DownCast(itrc.Value());
1131 [ + - ][ + - ]: 12590 : GC->Range(first, last);
1132 [ + - ][ + - ]: 12590 : if (!CR->IsCurveOnClosedSurface())
[ + + ]
1133 [ + - ]: 12506 : OS << "2 "; // -2- Curve on surf
1134 : : else
1135 [ + - ]: 84 : OS << "3 "; // -3- Curve on closed surf
1136 [ + - ][ + - ]: 12590 : OS <<" "<<myCurves2d.Index(CR->PCurve());
[ + - ][ + - ]
[ + - ]
1137 [ + - ][ + - ]: 12590 : if (CR->IsCurveOnClosedSurface()) {
[ + + ]
1138 [ + - ][ + - ]: 84 : OS <<" " << myCurves2d.Index(CR->PCurve2());
[ + - ][ + - ]
[ + - ]
1139 [ + - ][ + - ]: 84 : PrintRegularity(CR->Continuity(),OS);
[ + - ]
1140 : : }
1141 [ + - ][ + - ]: 12590 : OS << " " << mySurfaces.Index(CR->Surface());
[ + - ][ + - ]
[ + - ]
1142 [ + - ][ + - ]: 12590 : OS << " " << myLocations.Index(CR->Location());
[ + - ][ + - ]
[ + - ]
1143 [ + - ][ + - ]: 12590 : OS << " "<<first<<" "<<last;
[ + - ][ + - ]
1144 [ + - ]: 12590 : OS << "\n";
1145 : :
1146 : : // Write UV Points // for XML Persistence higher performance
1147 [ - + ]: 12590 : if (myFormatNb == 2)
1148 : : {
1149 [ # # ][ # # ]: 0 : gp_Pnt2d Pf,Pl;
1150 [ # # ][ # # ]: 0 : if (CR->IsCurveOnClosedSurface()) {
[ # # ]
1151 : : Handle(BRep_CurveOnClosedSurface) COCS =
1152 [ # # ]: 0 : Handle(BRep_CurveOnClosedSurface)::DownCast(CR);
1153 [ # # ][ # # ]: 0 : COCS->UVPoints2(Pf,Pl);
[ # # ]
1154 : : }
1155 : : else {
1156 : : Handle(BRep_CurveOnSurface) COS =
1157 [ # # ]: 0 : Handle(BRep_CurveOnSurface)::DownCast(CR);
1158 [ # # ][ # # ]: 0 : COS->UVPoints(Pf,Pl);
[ # # ]
1159 : : }
1160 [ # # ][ # # ]: 0 : OS << Pf.X() << " " << Pf.Y() << " " << Pl.X() << " " << Pl.Y() << "\n";
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
1161 [ + - ]: 12590 : }
1162 : : }
1163 [ + - ][ + - ]: 66 : else if (CR->IsRegularity()) {
[ + - ]
1164 [ + - ]: 66 : OS << "4 "; // -4- Regularity
1165 [ + - ][ + - ]: 66 : PrintRegularity(CR->Continuity(),OS);
[ + - ]
1166 [ + - ][ + - ]: 66 : OS << " "<<mySurfaces.Index(CR->Surface());
[ + - ][ + - ]
[ + - ]
1167 [ + - ][ + - ]: 66 : OS << " "<<myLocations.Index(CR->Location());
[ + - ][ + - ]
[ + - ]
1168 [ + - ][ + - ]: 66 : OS << " "<<mySurfaces.Index(CR->Surface2());
[ + - ][ + - ]
[ + - ]
1169 [ + - ][ + - ]: 66 : OS << " "<<myLocations.Index(CR->Location2());
[ + - ][ + - ]
[ + - ]
1170 [ + - ]: 66 : OS << "\n";
1171 : : }
1172 [ + - ]: 20209 : itrc.Next();
1173 : : }
1174 [ + - ][ + - ]: 7553 : OS << "0\n"; // end of the list of representations
1175 : : }
1176 [ + + ]: 6614 : else if (S.ShapeType() == TopAbs_FACE) {
1177 : :
1178 [ + - ][ + - ]: 2770 : Handle(BRep_TFace) TF = Handle(BRep_TFace)::DownCast(S.TShape());
1179 [ + - ]: 2770 : const TopoDS_Face& F = TopoDS::Face(S);
1180 : :
1181 [ + - ][ + - ]: 2770 : if (!(TF->Surface()).IsNull()) {
[ + - ][ + - ]
1182 [ + - ][ - + ]: 2770 : OS << ((BRep_Tool::NaturalRestriction(F)) ? 1 : 0);
[ + - ]
1183 [ + - ]: 2770 : OS << " ";
1184 : : // Write the surface geometry
1185 [ + - ][ + - ]: 2770 : OS << " " <<TF->Tolerance();
[ + - ][ + - ]
1186 [ + - ][ + - ]: 2770 : OS << " " <<mySurfaces.Index(TF->Surface());
[ + - ][ + - ]
[ + - ]
1187 [ + - ][ + - ]: 2770 : OS << " " <<myLocations.Index(TF->Location());
[ + - ][ + - ]
[ + - ]
1188 [ + - ]: 2770 : OS << "\n";
1189 [ + - ]: 2770 : }
1190 : : }
1191 : :
1192 : 20196 : }
1193 : :
1194 : :
1195 : : //=======================================================================
1196 : : //function : Write
1197 : : //purpose :
1198 : : //=======================================================================
1199 : :
1200 : 54844 : void OCCShapeAttributeSet::Write(const TopoDS_Shape& S,
1201 : : Standard_OStream& OS,
1202 : : TDF_Label* l_attr)
1203 : : {
1204 [ + + ]: 54844 : if (S.IsNull()) OS << "*";
1205 : : else {
1206 : 34648 : PrintOrientation(S.Orientation(),OS,Standard_True);
1207 [ + - ][ + - ]: 34648 : OS << myShapes.Extent() - myShapes.FindIndex(S.Located(TopLoc_Location())) + 1;
[ + - ][ + - ]
1208 : 34648 : OS << " " << myLocations.Index(S.Location()) << " ";
1209 : : }
1210 : : //Write Attributes
1211 : 54844 : Standard_Integer i, nbShapes = myShapes.Extent();
1212 [ + + ]: 54844 : if(l_attr != NULL)
1213 : : {
1214 [ + + ]: 20437 : for ( i = 1; i <= nbShapes; i++)
1215 : : {
1216 : 20196 : const TopoDS_Shape& Sh = myShapes(i);
1217 : 20196 : WriteAttribute(Sh, OS, *l_attr);
1218 : : }
1219 : : }
1220 : 54844 : }
1221 : :
1222 : :
1223 : : //=======================================================================
1224 : : //function : ReadGeometry
1225 : : //purpose :
1226 : : //=======================================================================
1227 : :
1228 : 19987 : void OCCShapeAttributeSet::ReadGeometry(const TopAbs_ShapeEnum T,
1229 : : Standard_IStream& IS,
1230 : : TopoDS_Shape& S)
1231 : : {
1232 : : // Read the geometry
1233 : :
1234 : : Standard_Integer val,c,pc,pc2,s,s2,l,l2,t, pt, pt2;
1235 : : Standard_Real tol,X,Y,Z,first,last,p1,p2;
1236 : : Standard_Real PfX,PfY,PlX,PlY;
1237 [ + - ][ + - ]: 19987 : gp_Pnt2d aPf, aPl;
1238 : : Standard_Boolean closed;
1239 : : #ifndef DEB
1240 : 19987 : GeomAbs_Shape reg = GeomAbs_C0;
1241 : : #else
1242 : : GeomAbs_Shape reg;
1243 : : #endif
1244 [ + + + + : 19987 : switch (T) {
+ + - +
- ]
1245 : :
1246 : :
1247 : : //---------
1248 : : // vertex
1249 : : //---------
1250 : :
1251 : : case TopAbs_VERTEX :
1252 : : {
1253 [ + - ]: 4852 : TopoDS_Vertex& V = TopoDS::Vertex(S);
1254 : :
1255 : : // Read the point geometry
1256 [ + - ]: 4852 : IS >> tol;
1257 [ + - ][ + - ]: 4852 : IS >> X >> Y >> Z;
[ + - ]
1258 [ + - ][ + - ]: 4852 : myBuilder.MakeVertex(V,gp_Pnt(X,Y,Z),tol);
1259 [ + - ][ + - ]: 4852 : Handle(BRep_TVertex) TV = Handle(BRep_TVertex)::DownCast(V.TShape());
1260 : :
1261 [ + - ][ + - ]: 4852 : BRep_ListOfPointRepresentation& lpr = TV->ChangePoints();
1262 [ + - ][ + - ]: 9704 : TopLoc_Location L;
1263 : :
1264 [ - + ]: 4852 : do {
1265 [ + - ][ + - ]: 4852 : IS >> p1 >> val;
1266 : :
1267 [ + - ]: 4852 : Handle(BRep_PointRepresentation) PR;
1268 [ - - - + ]: 4852 : switch (val) {
1269 : :
1270 : : case 1 :
1271 : : {
1272 [ # # ]: 0 : IS >> c;
1273 : :
1274 [ # # ][ # # ]: 0 : if (myCurves.Curve(c).IsNull())
[ # # ][ # # ]
1275 : 0 : break;
1276 : :
1277 : : Handle(BRep_PointOnCurve) POC =
1278 : : new BRep_PointOnCurve(p1,
1279 : : myCurves.Curve(c),
1280 [ # # ][ # # ]: 0 : L);
[ # # ][ # # ]
[ # # ]
1281 [ # # ][ # # ]: 0 : PR = POC;
1282 : : }
1283 : 0 : break;
1284 : :
1285 : : case 2 :
1286 : : {
1287 [ # # ][ # # ]: 0 : IS >> pc >> s;
1288 : :
1289 [ # # ][ # # ]: 0 : if (myCurves2d.Curve2d(pc).IsNull() ||
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
1290 [ # # ][ # # ]: 0 : mySurfaces.Surface(s).IsNull())
[ # # ][ # # ]
[ # # ]
1291 : 0 : break;
1292 : :
1293 : : Handle(BRep_PointOnCurveOnSurface) POC =
1294 : : new BRep_PointOnCurveOnSurface(p1,
1295 : : myCurves2d.Curve2d(pc),
1296 : : mySurfaces.Surface(s),
1297 [ # # ][ # # ]: 0 : L);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1298 [ # # ][ # # ]: 0 : PR = POC;
1299 : : }
1300 : 0 : break;
1301 : :
1302 : : case 3 :
1303 : : {
1304 [ # # ][ # # ]: 0 : IS >> p2 >> s;
1305 : :
1306 [ # # ][ # # ]: 0 : if (mySurfaces.Surface(s).IsNull())
[ # # ][ # # ]
1307 : 0 : break;
1308 : :
1309 : : Handle(BRep_PointOnSurface) POC =
1310 : : new BRep_PointOnSurface(p1,p2,
1311 : : mySurfaces.Surface(s),
1312 [ # # ][ # # ]: 0 : L);
[ # # ][ # # ]
[ # # ]
1313 [ # # ][ # # ]: 0 : PR = POC;
1314 : : }
1315 : 0 : break;
1316 : : }
1317 : :
1318 [ - + ]: 4852 : if (val > 0) {
1319 [ # # ]: 0 : IS >> l;
1320 [ # # ][ # # ]: 0 : if (!PR.IsNull()) {
1321 [ # # ][ # # ]: 0 : PR->Location(myLocations.Location(l));
[ # # ]
1322 [ # # ]: 0 : lpr.Append(PR);
1323 : : }
1324 [ + - ]: 4852 : }
1325 [ + - ]: 4852 : } while (val > 0);
1326 : : }
1327 : 4852 : break;
1328 : :
1329 : :
1330 : : //---------
1331 : : // edge
1332 : : //---------
1333 : :
1334 : :
1335 : : case TopAbs_EDGE :
1336 : :
1337 : : // Create an edge
1338 : : {
1339 [ + - ]: 7498 : TopoDS_Edge& E = TopoDS::Edge(S);
1340 : :
1341 [ + - ]: 7498 : myBuilder.MakeEdge(E);
1342 : :
1343 : : // Read the curve geometry
1344 [ + - ]: 7498 : IS >> tol;
1345 [ + - ]: 7498 : IS >> val;
1346 [ + - ]: 7498 : myBuilder.SameParameter(E,(val == 1));
1347 [ + - ]: 7498 : IS >> val;
1348 [ + - ]: 7498 : myBuilder.SameRange(E,(val == 1));
1349 [ + - ]: 7498 : IS >> val;
1350 [ + - ]: 7498 : myBuilder.Degenerated(E,(val == 1));
1351 : :
1352 [ + + ]: 38267 : do {
1353 [ + - ]: 38267 : IS >> val;
1354 [ + + + - : 38267 : switch (val) {
+ + ]
1355 : :
1356 : : case 1 : // -1- Curve 3D
1357 [ + - ][ + - ]: 7487 : IS >> c >> l;
1358 [ + - ][ + - ]: 7487 : if (!myCurves.Curve(c).IsNull()) {
[ + - ][ + - ]
1359 : : myBuilder.UpdateEdge(E,myCurves.Curve(c),
1360 [ + - ][ + - ]: 7487 : myLocations.Location(l),tol);
[ + - ][ + - ]
1361 : : }
1362 [ + - ][ + - ]: 7487 : IS >> first >> last;
1363 [ + - ][ + - ]: 7487 : if (!myCurves.Curve(c).IsNull()) {
[ + - ][ + - ]
1364 : 7487 : Standard_Boolean Only3d = Standard_True;
1365 [ + - ]: 7487 : myBuilder.Range(E,first,last,Only3d);
1366 : : }
1367 : 7487 : break;
1368 : :
1369 : :
1370 : : case 2 : // -2- Curve on surf
1371 : : case 3 : // -3- Curve on closed surf
1372 : 14988 : closed = (val == 3);
1373 [ + - ]: 14988 : IS >> pc;
1374 [ + + ]: 14988 : if (closed) {
1375 [ + - ]: 106 : IS >> pc2;
1376 [ + - ]: 106 : reg = ReadRegularity(IS);
1377 : : }
1378 : :
1379 : : // surface, location
1380 [ + - ][ + - ]: 14988 : IS >> s >> l;
1381 : :
1382 : : // range
1383 [ + - ][ + - ]: 14988 : IS >> first >> last;
1384 : :
1385 : : // read UV Points // for XML Persistence higher performance
1386 [ - + ]: 14988 : if (myFormatNb == 2)
1387 : : {
1388 [ # # ][ # # ]: 0 : IS >> PfX >> PfY >> PlX >> PlY;
[ # # ][ # # ]
1389 [ # # ]: 0 : aPf = gp_Pnt2d(PfX,PfY);
1390 [ # # ]: 0 : aPl = gp_Pnt2d(PlX,PlY);
1391 : : }
1392 : :
1393 [ + - ][ + - ]: 44964 : if (myCurves2d.Curve2d(pc).IsNull() ||
[ + + ][ + - ]
[ + - ]
[ - + # # ]
1394 [ + - ][ + - ]: 45070 : (closed && myCurves2d.Curve2d(pc2).IsNull()) ||
[ + - ][ + - ]
[ - + ][ + + ]
[ + - ][ # # ]
1395 [ + - ][ + - ]: 29976 : mySurfaces.Surface(s).IsNull())
[ + - ][ + - ]
[ # # ]
1396 : 0 : break;
1397 : :
1398 [ + + ]: 14988 : if (closed) {
1399 [ - + ]: 106 : if (myFormatNb == 2)
1400 : : myBuilder.UpdateEdge(E,myCurves2d.Curve2d(pc),
1401 : : myCurves2d.Curve2d(pc2),
1402 : : mySurfaces.Surface(s),
1403 [ # # ]: 0 : myLocations.Location(l),tol,
1404 [ # # ][ # # ]: 0 : aPf, aPl);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1405 : : else
1406 : : myBuilder.UpdateEdge(E,myCurves2d.Curve2d(pc),
1407 : : myCurves2d.Curve2d(pc2),
1408 : : mySurfaces.Surface(s),
1409 [ + - ][ + - ]: 106 : myLocations.Location(l),tol);
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
1410 : :
1411 : : myBuilder.Continuity(E,
1412 : : mySurfaces.Surface(s),
1413 : : mySurfaces.Surface(s),
1414 [ + - ]: 106 : myLocations.Location(l),
1415 [ + - ]: 106 : myLocations.Location(l),
1416 [ + - ][ + - ]: 106 : reg);
[ + - ][ + - ]
[ + - ]
1417 : : }
1418 : : else
1419 : : {
1420 [ - + ]: 14882 : if (myFormatNb == 2)
1421 : : myBuilder.UpdateEdge(E,myCurves2d.Curve2d(pc),
1422 : : mySurfaces.Surface(s),
1423 [ # # ]: 0 : myLocations.Location(l),tol,
1424 [ # # ][ # # ]: 0 : aPf, aPl);
[ # # ][ # # ]
[ # # ]
1425 : : else
1426 : : myBuilder.UpdateEdge(E,myCurves2d.Curve2d(pc),
1427 : : mySurfaces.Surface(s),
1428 [ + - ][ + - ]: 14882 : myLocations.Location(l),tol);
[ + - ][ + - ]
[ + - ][ + - ]
1429 : : }
1430 : : myBuilder.Range(E,
1431 : : mySurfaces.Surface(s),
1432 [ + - ]: 14988 : myLocations.Location(l),
1433 [ + - ][ + - ]: 14988 : first,last);
[ + - ]
1434 : 14988 : break;
1435 : :
1436 : : case 4 : // -4- Regularity
1437 [ + - ]: 2167 : reg = ReadRegularity(IS);
1438 [ + - ][ + - ]: 2167 : IS >> s >> l >> s2 >> l2;
[ + - ][ + - ]
1439 [ + - ][ + - ]: 6501 : if (mySurfaces.Surface(s).IsNull() ||
[ + - ][ - + ]
[ + - ][ + - ]
[ - + # # ]
1440 [ + - ][ + - ]: 4334 : mySurfaces.Surface(s2).IsNull())
[ + - ][ + - ]
[ # # ]
1441 : 0 : break;
1442 : : myBuilder.Continuity(E,
1443 : : mySurfaces.Surface(s),
1444 : : mySurfaces.Surface(s2),
1445 [ + - ]: 2167 : myLocations.Location(l),
1446 [ + - ]: 2167 : myLocations.Location(l2),
1447 [ + - ][ + - ]: 2167 : reg);
[ + - ][ + - ]
[ + - ]
1448 : 2167 : break;
1449 : :
1450 : : case 5 : // -5- Polygon3D
1451 [ # # ][ # # ]: 0 : IS >> c >> l;
1452 [ # # ][ # # ]: 0 : myBuilder.UpdateEdge(E,Handle(Poly_Polygon3D)::DownCast(myPolygons3D(c)), myLocations.Location(l));
[ # # ][ # # ]
[ # # ]
1453 : 0 : break;
1454 : :
1455 : : case 6 :
1456 : : case 7 :
1457 : 6127 : closed = (val == 7);
1458 [ + - ]: 6127 : IS >> pt;
1459 [ + + ]: 6127 : if (closed) {
1460 [ + - ]: 66 : IS >> pt2;
1461 : : }
1462 [ + - ][ + - ]: 6127 : IS >> t >> l;
1463 [ + + ]: 6127 : if (closed) {
1464 : : myBuilder.UpdateEdge
1465 [ + - ]: 66 : (E, Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(pt)),
1466 [ + - ]: 66 : Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(pt2)),
1467 [ + - ]: 66 : Handle(Poly_Triangulation)::DownCast(myTriangulations(t)),
1468 [ + - ][ + - ]: 264 : myLocations.Location(l));
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
1469 : : }
1470 : : else {
1471 : : myBuilder.UpdateEdge
1472 [ + - ]: 6061 : (E,Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(pt)),
1473 [ + - ]: 6061 : Handle(Poly_Triangulation)::DownCast(myTriangulations(t)),
1474 [ + - ][ + - ]: 18183 : myLocations.Location(l));
[ + - ][ + - ]
[ + - ][ + - ]
1475 : : }
1476 : : // range
1477 : :
1478 : 6127 : break;
1479 : :
1480 : : }
1481 : 38267 : } while (val > 0);
1482 : : }
1483 : 7498 : break;
1484 : :
1485 : :
1486 : : //---------
1487 : : // wire
1488 : : //---------
1489 : :
1490 : : case TopAbs_WIRE :
1491 [ + - ][ + - ]: 3501 : myBuilder.MakeWire(TopoDS::Wire(S));
1492 : 3501 : break;
1493 : :
1494 : :
1495 : : //---------
1496 : : // face
1497 : : //---------
1498 : : case TopAbs_FACE :
1499 : : {
1500 : : // create a face :
1501 [ + - ]: 3309 : TopoDS_Face& F = TopoDS::Face(S);
1502 [ + - ]: 3309 : myBuilder.MakeFace(F);
1503 : :
1504 [ + - ]: 3309 : IS >> val; // natural restriction
1505 [ - + ][ # # ]: 3309 : if (val == 0 || val == 1) {
1506 [ + - ][ + - ]: 3309 : IS >> tol >> s >> l;
[ + - ]
1507 [ + - ][ + - ]: 3309 : if (!mySurfaces.Surface(s).IsNull()) {
[ + - ][ + - ]
1508 [ + - ]: 3309 : myBuilder.UpdateFace(TopoDS::Face(S),
1509 : : mySurfaces.Surface(s),
1510 [ + - ][ + - ]: 6618 : myLocations.Location(l),tol);
[ + - ][ + - ]
1511 [ + - ][ + - ]: 3309 : myBuilder.NaturalRestriction(TopoDS::Face(S),(val == 1));
1512 : : }
1513 : : }
1514 : :
1515 : : // BUC60769
1516 [ + - ]: 3309 : std::string line;
1517 [ + - ]: 3309 : std::getline( IS, line );
1518 [ + - ]: 3309 : std::getline( IS, line );
1519 [ + - ][ + - ]: 6618 : std::istringstream str( line );
1520 : :
1521 [ + - ][ + + ]: 3309 : if (str.get() == '2') {
1522 : : // cas triangulation
1523 [ + - ]: 1452 : str >> s;
1524 [ + - ]: 1452 : myBuilder.UpdateFace(TopoDS::Face(S),
1525 [ + - ][ + - ]: 2904 : Handle(Poly_Triangulation)::DownCast(myTriangulations(s)));
[ + - ][ + - ]
1526 [ + - ]: 3309 : }
1527 : : // else IS.seekg(pos);
1528 : : }
1529 : 3309 : break;
1530 : :
1531 : :
1532 : : //---------
1533 : : // shell
1534 : : //---------
1535 : :
1536 : : case TopAbs_SHELL :
1537 [ + - ][ + - ]: 326 : myBuilder.MakeShell(TopoDS::Shell(S));
1538 : 326 : break;
1539 : :
1540 : :
1541 : : //---------
1542 : : // solid
1543 : : //---------
1544 : :
1545 : : case TopAbs_SOLID :
1546 [ + - ][ + - ]: 326 : myBuilder.MakeSolid(TopoDS::Solid(S));
1547 : 326 : break;
1548 : :
1549 : :
1550 : : //---------
1551 : : // compsolid
1552 : : //---------
1553 : :
1554 : : case TopAbs_COMPSOLID :
1555 [ # # ][ # # ]: 0 : myBuilder.MakeCompSolid(TopoDS::CompSolid(S));
1556 : 0 : break;
1557 : :
1558 : :
1559 : : //---------
1560 : : // compound
1561 : : //---------
1562 : :
1563 : : case TopAbs_COMPOUND :
1564 [ + - ][ + - ]: 175 : myBuilder.MakeCompound(TopoDS::Compound(S));
1565 : 175 : break;
1566 : :
1567 : : default:
1568 : 0 : break;
1569 : : }
1570 : :
1571 : 19987 : }
1572 : :
1573 : : //=======================================================================
1574 : : //function : ReadPolygonOnTriangulation
1575 : : //purpose :
1576 : : //=======================================================================
1577 : :
1578 : 186 : void OCCShapeAttributeSet::ReadPolygonOnTriangulation(Standard_IStream& IS)
1579 : : {
1580 [ + - ]: 186 : std::string buffer;
1581 [ + - ]: 186 : IS >> buffer;
1582 [ + - ][ - + ]: 186 : if (buffer.find("PolygonOnTriangulations") == std::string::npos)
1583 : 186 : return;
1584 : :
1585 : 186 : Standard_Integer i, j, val, nbpol = 0, nbnodes =0;
1586 : : Standard_Integer hasparameters;
1587 : : Standard_Real par;
1588 [ + - ][ + - ]: 372 : Handle(TColStd_HArray1OfReal) Param;
[ + - ][ + - ]
1589 [ + - ][ + - ]: 372 : Handle(Poly_PolygonOnTriangulation) Poly;
1590 [ + - ]: 186 : IS >> nbpol;
1591 [ + + ]: 6379 : for (i=1; i<=nbpol; i++) {
1592 [ + - ]: 6193 : IS >> nbnodes;
1593 [ + - ]: 6193 : TColStd_Array1OfInteger Nodes(1, nbnodes);
1594 [ + + ]: 49027 : for (j = 1; j <= nbnodes; j++) {
1595 [ + - ]: 42834 : IS >> val;
1596 [ + - ]: 42834 : Nodes(j) = val;
1597 : : }
1598 [ + - ]: 6193 : IS >> buffer;
1599 : : Standard_Real def;
1600 [ + - ]: 6193 : IS >> def;
1601 [ + - ]: 6193 : IS >> hasparameters;
1602 [ + - ]: 6193 : if (hasparameters) {
1603 [ + - ]: 6193 : TColStd_Array1OfReal Param1(1, nbnodes);
1604 [ + + ]: 49027 : for (j = 1; j <= nbnodes; j++) {
1605 [ + - ]: 42834 : IS >> par;
1606 [ + - ]: 42834 : Param1(j) = par;
1607 : : }
1608 [ + - ][ + - ]: 6193 : Poly = new Poly_PolygonOnTriangulation(Nodes, Param1);
[ + - ][ + - ]
1609 : : }
1610 [ # # ][ # # ]: 0 : else Poly = new Poly_PolygonOnTriangulation(Nodes);
[ # # ]
1611 [ + - ][ + - ]: 6193 : Poly->Deflection(def);
1612 [ + - ]: 6193 : myNodes.Add(Poly);
1613 [ + - ]: 6379 : }
1614 : : }
1615 : :
1616 : : //=======================================================================
1617 : : //function : ReadPolygon3D
1618 : : //purpose :
1619 : : //=======================================================================
1620 : :
1621 : 186 : void OCCShapeAttributeSet::ReadPolygon3D(Standard_IStream& IS)
1622 : : {
1623 [ + - ]: 186 : std::string buffer;
1624 : : // Standard_Integer i, j, p, val, nbpol, nbnodes, hasparameters;
1625 : 186 : Standard_Integer i, j, p, nbpol=0, nbnodes =0, hasparameters = Standard_False; Standard_Real d, x, y, z;
1626 : :
1627 [ + - ]: 186 : IS >> buffer;
1628 [ + - ][ - + ]: 186 : if (buffer.find("Polygon3D") == std::string::npos)
1629 : 186 : return;
1630 : :
1631 [ + - ][ + - ]: 372 : Handle(Poly_Polygon3D) P;
[ + - ][ + - ]
1632 [ + - ]: 186 : IS >> nbpol;
1633 [ - + ]: 186 : for (i=1; i<=nbpol; i++) {
1634 [ # # ]: 0 : IS >> nbnodes;
1635 [ # # ]: 0 : IS >> hasparameters;
1636 [ # # ]: 0 : TColgp_Array1OfPnt Nodes(1, nbnodes);
1637 [ # # ]: 0 : IS >> d;
1638 [ # # ]: 0 : for (j = 1; j <= nbnodes; j++) {
1639 [ # # ][ # # ]: 0 : IS >> x >> y >> z;
[ # # ]
1640 [ # # ][ # # ]: 0 : Nodes(j).SetCoord(x,y,z);
1641 : : }
1642 [ # # ]: 0 : if (hasparameters) {
1643 [ # # ]: 0 : TColStd_Array1OfReal Param(1,nbnodes);
1644 [ # # ]: 0 : for (p = 1; p <= nbnodes; p++) {
1645 [ # # ][ # # ]: 0 : IS >> Param(p);
1646 : : }
1647 [ # # ][ # # ]: 0 : P = new Poly_Polygon3D(Nodes, Param);
[ # # ][ # # ]
1648 : : }
1649 [ # # ][ # # ]: 0 : else P = new Poly_Polygon3D(Nodes);
[ # # ]
1650 [ # # ][ # # ]: 0 : P->Deflection(d);
1651 [ # # ]: 0 : myPolygons3D.Add(P);
1652 [ # # ]: 186 : }
1653 : : }
1654 : :
1655 : : //=======================================================================
1656 : : //function : ReadTriangulation
1657 : : //purpose :
1658 : : //=======================================================================
1659 : :
1660 : 186 : void OCCShapeAttributeSet::ReadTriangulation(Standard_IStream& IS)
1661 : : {
1662 [ + - ]: 186 : std::string buffer;
1663 : : // Standard_Integer i, j, val, nbtri;
1664 : 186 : Standard_Integer i, j, nbtri =0;
1665 : : Standard_Real d, x, y, z;
1666 : 186 : Standard_Integer nbNodes =0, nbTriangles=0;
1667 : 186 : Standard_Boolean hasUV= Standard_False;
1668 : :
1669 [ + - ][ + - ]: 372 : Handle(Poly_Triangulation) T;
1670 : :
1671 [ + - ]: 186 : IS >> buffer;
1672 [ + - ][ + - ]: 186 : if (buffer.find("Triangulations") != std::string::npos) {
1673 [ + - ]: 186 : IS >> nbtri;
1674 [ + + ]: 1638 : for (i=1; i<=nbtri; i++) {
1675 [ + - ][ + - ]: 1452 : IS >> nbNodes >> nbTriangles >> hasUV;
[ + - ]
1676 [ + - ]: 1452 : IS >> d;
1677 : :
1678 [ + - ]: 1452 : TColgp_Array1OfPnt Nodes(1, nbNodes);
1679 [ + - ][ + - ]: 2904 : TColgp_Array1OfPnt2d UVNodes(1, nbNodes);
1680 : :
1681 [ + + ]: 51062 : for (j = 1; j <= nbNodes; j++) {
1682 [ + - ][ + - ]: 49610 : IS >> x >> y >> z;
[ + - ]
1683 [ + - ][ + - ]: 49610 : Nodes(j).SetCoord(x,y,z);
1684 : : }
1685 : :
1686 [ + - ]: 1452 : if (hasUV) {
1687 [ + + ]: 51062 : for (j = 1; j <= nbNodes; j++) {
1688 [ + - ][ + - ]: 49610 : IS >> x >> y;
1689 [ + - ][ + - ]: 49610 : UVNodes(j).SetCoord(x,y);
1690 : : }
1691 : : }
1692 : :
1693 : :
1694 : : // read the triangles
1695 : : Standard_Integer n1,n2,n3;
1696 [ + - ][ + - ]: 2904 : Poly_Array1OfTriangle Triangles(1, nbTriangles);
1697 [ + + ]: 58531 : for (j = 1; j <= nbTriangles; j++) {
1698 [ + - ][ + - ]: 57079 : IS >> n1 >> n2 >> n3;
[ + - ]
1699 [ + - ][ + - ]: 57079 : Triangles(j).Set(n1,n2,n3);
1700 : : }
1701 : :
1702 [ + - ][ + - ]: 1452 : if (hasUV) T = new Poly_Triangulation(Nodes,UVNodes,Triangles);
[ + - ][ + - ]
1703 [ # # ][ # # ]: 0 : else T = new Poly_Triangulation(Nodes,Triangles);
[ # # ]
1704 : :
1705 [ + - ][ + - ]: 1452 : T->Deflection(d);
1706 : :
1707 [ + - ]: 1452 : myTriangulations.Add(T);
1708 [ + - ]: 1452 : }
1709 [ + - ]: 186 : }
1710 : 186 : }
1711 : :
1712 : : //=======================================================================
1713 : : //function : Clear
1714 : : //purpose :
1715 : : //=======================================================================
1716 : :
1717 : 613 : void OCCShapeAttributeSet::Clear()
1718 : : {
1719 : 613 : mySurfaces.Clear();
1720 : 613 : myCurves.Clear();
1721 : 613 : myCurves2d.Clear();
1722 : 613 : myPolygons3D.Clear();
1723 : 613 : myPolygons2D.Clear();
1724 : 613 : myNodes.Clear();
1725 : 613 : myTriangulations.Clear();
1726 : 613 : myShapes.Clear();
1727 : 613 : my_ShapeNum_Location.clear();
1728 : 613 : myLocations.Clear();
1729 : 613 : }
1730 : :
1731 : : //=======================================================================
1732 : : //function : Read
1733 : : //purpose :
1734 : : //=======================================================================
1735 : :
1736 : 57605 : void OCCShapeAttributeSet::Read(TopoDS_Shape& S,
1737 : : Standard_IStream& IS,
1738 : : const int nbshapes,
1739 : : TDF_Label* label )
1740 : : {
1741 [ + - ][ + - ]: 115210 : std::string buffer, buffer_attr;
[ + - ]
1742 [ + - ]: 57605 : IS >> buffer;
1743 [ + - ]: 57605 : std::map<int,int>::iterator it;
1744 [ + - ][ + + ]: 57605 : if (buffer[0] == '*')
1745 [ + - ][ + - ]: 19987 : S = TopoDS_Shape();
[ + - ]
1746 : : else {
1747 : : char type;
1748 : : int num;
1749 [ + - ]: 37618 : std::istringstream buffstr(buffer);
1750 [ + - ][ + - ]: 37618 : buffstr >> type >> num;
1751 [ + - ][ + - ]: 37618 : S = myShapes(nbshapes - num + 1);
1752 [ + + - - : 37618 : switch (type) {
- ]
1753 : :
1754 : : case '+' :
1755 [ + - ]: 20592 : S.Orientation(TopAbs_FORWARD);
1756 : 20592 : break;
1757 : :
1758 : : case '-' :
1759 [ + - ]: 17026 : S.Orientation(TopAbs_REVERSED);
1760 : 17026 : break;
1761 : :
1762 : : case 'i' :
1763 [ # # ]: 0 : S.Orientation(TopAbs_INTERNAL);
1764 : 0 : break;
1765 : :
1766 : : case 'e' :
1767 [ # # ]: 0 : S.Orientation(TopAbs_EXTERNAL);
1768 : 0 : break;
1769 : : }
1770 : :
1771 : : Standard_Integer l;
1772 [ + - ]: 37618 : IS >> l;
1773 [ + - ][ + - ]: 37618 : S.Location(myLocations.Location(l));
1774 : :
1775 : 37618 : int shape_num = nbshapes - num + 1;
1776 : : typedef std::pair <int,int> sh_loc_pair;
1777 [ + - ]: 37618 : it = my_ShapeNum_Location.find(shape_num);
1778 [ + - ][ + - ]: 37618 : if(it == my_ShapeNum_Location.end())
[ + + ]
1779 [ + - ][ + - ]: 37618 : my_ShapeNum_Location.insert(sh_loc_pair(shape_num, l));
[ + - ][ + - ]
1780 : : }
1781 [ + + ]: 57605 : if(label != NULL)
1782 : : {
1783 [ + - ]: 186 : Standard_Integer i, nbShapes = myShapes.Extent();
1784 [ + + ]: 11186 : for ( i = 1; i <= nbShapes; i++)
1785 : : {
1786 [ + - ][ + - ]: 11000 : TopoDS_Shape Sh = myShapes(i);
1787 [ + - ]: 11000 : IS >> buffer_attr;
1788 [ + - ][ + + ]: 11000 : if(buffer_attr[0] != '*' && buffer_attr[0] != 'C')
[ + - ][ + + ]
[ + + ]
1789 : 44 : break;
1790 [ + - ][ + + ]: 10956 : if(buffer_attr[0] == '*') //empty attributes for this shape
1791 : 7863 : continue;
1792 [ + - ]: 3093 : it = my_ShapeNum_Location.find(i);
1793 [ + - ][ + - ]: 3093 : if(it != my_ShapeNum_Location.end())
[ + - ]
1794 : : {
1795 [ + - ]: 3093 : int loc_num = it->second;
1796 [ + + ]: 3093 : if (loc_num > 0)
1797 [ + - ][ + - ]: 3093 : Sh.Location(myLocations.Location(loc_num));
1798 : : }
1799 [ + - ][ + - ]: 11000 : ReadAttribute(Sh, IS,*label);
[ + + + ]
1800 : 11000 : }
1801 [ + - ]: 57605 : }
1802 : 57605 : }
1803 : :
1804 : : //=======================================================================
1805 : : //function : Check
1806 : : //purpose :
1807 : : //=======================================================================
1808 : :
1809 : 19987 : void OCCShapeAttributeSet::Check(const TopAbs_ShapeEnum T,
1810 : : TopoDS_Shape& S)
1811 : : {
1812 [ + + ]: 19987 : if (T == TopAbs_FACE) {
1813 : 3309 : const TopoDS_Face& F = TopoDS::Face(S);
1814 : 3309 : BRepTools::Update(F);
1815 : : }
1816 : 19987 : }
1817 : :
1818 : : //=======================================================================
1819 : : //function : NbShapes
1820 : : //purpose :
1821 : : //=======================================================================
1822 : :
1823 : 186 : int OCCShapeAttributeSet::NbShapes()
1824 : : {
1825 : 186 : return myShapes.Extent();
1826 [ + - ][ + - ]: 6364 : }
1827 : :
|
