Commit | Line | Data |
---|---|---|
973c2be1 | 1 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
b311480e | 2 | // |
973c2be1 | 3 | // This file is part of Open CASCADE Technology software library. |
b311480e | 4 | // |
d5f74e42 | 5 | // This library is free software; you can redistribute it and/or modify it under |
6 | // the terms of the GNU Lesser General Public License version 2.1 as published | |
973c2be1 | 7 | // by the Free Software Foundation, with special exception defined in the file |
8 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT | |
9 | // distribution for complete text of the license and disclaimer of any warranty. | |
b311480e | 10 | // |
973c2be1 | 11 | // Alternatively, this file may be used under the terms of Open CASCADE |
12 | // commercial license or contractual agreement. | |
b311480e | 13 | |
7fd59977 | 14 | //:k3 abv 25.11.98 rp1sd.stp |
15 | //:n4 abv 11.02.99 S4132: recognition of GeometricSet (instead of GeometricCurveSet) | |
16 | // gka 05.04.99 S4136: eliminate parameter lastpreci | |
17 | //gka,abv 14.04.99 S4136: maintain unit context, precision and maxtolerance values | |
18 | #include <STEPControl_ActorRead.ixx> | |
19 | #include <OSD_Timer.hxx> | |
20 | ||
21 | // #include <Interface_InterfaceModel.hxx> // pour mise au point | |
22 | ||
23 | #include <StepShape_ShapeDefinitionRepresentation.hxx> | |
24 | #include <StepShape_ShapeRepresentation.hxx> | |
25 | #include <StepShape_FacetedBrepAndBrepWithVoids.hxx> | |
26 | #include <StepShape_FacetedBrep.hxx> | |
27 | #include <StepShape_ShellBasedSurfaceModel.hxx> | |
28 | #include <StepShape_ManifoldSolidBrep.hxx> | |
29 | #include <StepShape_BrepWithVoids.hxx> | |
30 | #include <StepShape_GeometricSet.hxx> | |
31 | ||
32 | // MappedItem : | |
33 | #include <StepRepr_MappedItem.hxx> | |
34 | #include <StepGeom_Axis2Placement3d.hxx> | |
35 | #include <StepRepr_RepresentationMap.hxx> | |
36 | #include <StepToTopoDS_MakeTransformed.hxx> | |
37 | ||
38 | // FaceSurface : | |
39 | #include <StepShape_FaceSurface.hxx> | |
40 | #include <StepToTopoDS_Tool.hxx> | |
41 | #include <StepToTopoDS_DataMapOfTRI.hxx> | |
42 | #include <StepToTopoDS_TranslateFace.hxx> | |
43 | ||
44 | // Unites : | |
45 | #include <StepRepr_RepresentationContext.hxx> | |
46 | #include <StepRepr_GlobalUnitAssignedContext.hxx> | |
47 | #include <StepRepr_GlobalUncertaintyAssignedContext.hxx> | |
48 | //#include <StepBasic_UncertaintyMeasureWithUnit.hxx> | |
49 | #include <StepBasic_ProductRelatedProductCategory.hxx> | |
50 | #include <StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext.hxx> | |
51 | #include <StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.hxx> | |
52 | ||
53 | #include <STEPConstruct_UnitContext.hxx> | |
54 | #include <UnitsMethods.hxx> | |
55 | ||
56 | // Representation Relationship & cie | |
57 | #include <Interface_Graph.hxx> | |
58 | #include <Interface_EntityIterator.hxx> | |
59 | #include <TransferBRep.hxx> | |
60 | #include <StepShape_ContextDependentShapeRepresentation.hxx> | |
61 | #include <StepRepr_ShapeRepresentationRelationship.hxx> | |
62 | #include <StepRepr_ShapeRepresentationRelationshipWithTransformation.hxx> | |
63 | #include <StepRepr_Transformation.hxx> | |
64 | #include <StepRepr_ItemDefinedTransformation.hxx> | |
65 | ||
66 | #include <BRep_Builder.hxx> | |
67 | #include <StepToTopoDS_Builder.hxx> | |
68 | #include <TopoDS_Compound.hxx> | |
69 | #include <TopoDS_Shape.hxx> | |
70 | ||
71 | #include <TransferBRep_ShapeBinder.hxx> | |
72 | ||
73 | #include <Interface_Static.hxx> | |
74 | #include <Interface_Macros.hxx> | |
75 | #include <Interface_InterfaceModel.hxx> | |
76 | ||
77 | #include <StepBasic_ProductDefinition.hxx> | |
78 | #include <StepRepr_ProductDefinitionShape.hxx> | |
79 | #include <StepRepr_NextAssemblyUsageOccurrence.hxx> | |
80 | #include <STEPConstruct_Assembly.hxx> | |
81 | #include <Precision.hxx> | |
82 | #include <StepToGeom_MakeTransformation3d.hxx> | |
83 | #include <StepToGeom_MakeAxis2Placement.hxx> | |
84 | #include <Geom_Axis2Placement.hxx> | |
85 | #include <gp_Ax3.hxx> | |
86 | #include <StepRepr_ShapeAspect.hxx> | |
87 | #include <XSAlgo.hxx> | |
88 | #include <XSAlgo_AlgoContainer.hxx> | |
89 | #include <StepShape_EdgeBasedWireframeModel.hxx> | |
90 | #include <StepShape_FaceBasedSurfaceModel.hxx> | |
91 | ||
92 | #include <StepShape_AdvancedBrepShapeRepresentation.hxx> | |
93 | #include <StepShape_FacetedBrepShapeRepresentation.hxx> | |
94 | #include <StepShape_ManifoldSurfaceShapeRepresentation.hxx> | |
95 | #include <StepShape_EdgeBasedWireframeShapeRepresentation.hxx> | |
96 | #include <StepShape_GeometricallyBoundedSurfaceShapeRepresentation.hxx> | |
97 | #include <StepShape_GeometricallyBoundedWireframeShapeRepresentation.hxx> | |
98 | ||
99 | #include <TColStd_HSequenceOfTransient.hxx> | |
100 | #include <Message_ProgressSentry.hxx> | |
101 | #include <Message_Messenger.hxx> | |
102 | #include <StepRepr_HSequenceOfRepresentationItem.hxx> | |
103 | #include <StepBasic_ProductDefinition.hxx> | |
104 | #include <Standard_Failure.hxx> | |
105 | #include <Standard_ErrorHandler.hxx> | |
106 | #include <StepDimTol_DatumFeature.hxx> | |
107 | #include <StepDimTol_GeometricTolerance.hxx> | |
108 | #include <StepDimTol_GeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol.hxx> | |
109 | ||
110 | // For non-manifold topology processing (ssv; 12.11.2010) | |
111 | #include <StepShape_NonManifoldSurfaceShapeRepresentation.hxx> | |
112 | #include <StepRepr_HArray1OfRepresentationItem.hxx> | |
113 | #include <TopTools_MapOfShape.hxx> | |
114 | #include <TopTools_ListOfShape.hxx> | |
115 | #include <TopoDS_Iterator.hxx> | |
116 | #include <TopTools_ListIteratorOfListOfShape.hxx> | |
117 | #include <TopoDS_Solid.hxx> | |
118 | #include <BRepCheck_Shell.hxx> | |
119 | #include <BRepCheck_Status.hxx> | |
120 | #include <TopoDS.hxx> | |
121 | #include <TopoDS_Shell.hxx> | |
122 | #include <TopoDS_Face.hxx> | |
123 | #include <TopExp_Explorer.hxx> | |
124 | #include <StepData_StepModel.hxx> | |
125 | #include <HeaderSection_FileName.hxx> | |
126 | ||
127 | #define TRANSLOG | |
128 | ||
129 | // ============================================================================ | |
130 | // Function: DumpWhatIs | |
131 | // Purpose: Use it in DEB mode to dump your shapes | |
132 | // ============================================================================ | |
133 | ||
498ce76b | 134 | #ifdef DEB |
7fd59977 | 135 | static void DumpWhatIs(const TopoDS_Shape& S) { |
136 | ||
137 | TopTools_MapOfShape aMapOfShape; | |
138 | aMapOfShape.Add(S); | |
139 | TopTools_ListOfShape aListOfShape; | |
140 | aListOfShape.Append(S); | |
141 | TopTools_ListIteratorOfListOfShape itL(aListOfShape); | |
142 | Standard_Integer nbSolids = 0, | |
143 | nbShells = 0, | |
144 | nbOpenShells = 0, | |
145 | nbFaces = 0, | |
146 | nbWires = 0, | |
147 | nbEdges = 0, | |
bd05fabf S |
148 | nbVertexes = 0, |
149 | nbCompounds = 0; | |
150 | ||
151 | if (S.ShapeType() == TopAbs_COMPOUND) | |
152 | nbCompounds++; | |
7fd59977 | 153 | |
154 | for( ; itL.More(); itL.Next() ) { | |
155 | TopoDS_Iterator it( itL.Value() ); | |
156 | for ( ; it.More(); it.Next() ) { | |
157 | TopoDS_Shape aSubShape = it.Value(); | |
158 | if ( !aMapOfShape.Add(aSubShape) ) | |
159 | continue; | |
160 | aListOfShape.Append(aSubShape); | |
bd05fabf S |
161 | if (aSubShape.ShapeType() == TopAbs_COMPOUND) |
162 | nbCompounds++; | |
7fd59977 | 163 | if (aSubShape.ShapeType() == TopAbs_SOLID) |
164 | nbSolids++; | |
165 | if (aSubShape.ShapeType() == TopAbs_SHELL) { | |
166 | if ( !aSubShape.Closed() ) | |
167 | nbOpenShells++; | |
168 | nbShells++; | |
169 | } | |
170 | if (aSubShape.ShapeType() == TopAbs_FACE) | |
171 | nbFaces++; | |
172 | if (aSubShape.ShapeType() == TopAbs_WIRE) | |
173 | nbWires++; | |
174 | if (aSubShape.ShapeType() == TopAbs_EDGE) | |
175 | nbEdges++; | |
176 | if (aSubShape.ShapeType() == TopAbs_VERTEX) | |
177 | nbVertexes++; | |
178 | } | |
179 | } | |
498ce76b | 180 | |
bd05fabf | 181 | cout << "//What is?// NB COMPOUNDS: " << nbCompounds << endl; |
7fd59977 | 182 | cout << "//What is?// NB SOLIDS: " << nbSolids << endl; |
183 | cout << "//What is?// NB SHELLS: " << nbShells << endl; | |
184 | cout << "//What is?// OPEN SHELLS: " << nbOpenShells << endl; | |
185 | cout << "//What is?// CLOSED SHELLS: " << nbShells - nbOpenShells << endl; | |
186 | cout << "//What is?// NB FACES: " << nbFaces << endl; | |
187 | cout << "//What is?// NB WIRES: " << nbWires << endl; | |
188 | cout << "//What is?// NB EDGES: " << nbEdges << endl; | |
189 | cout << "//What is?// NB VERTEXES: " << nbVertexes << endl; | |
7fd59977 | 190 | } |
498ce76b | 191 | #endif |
7fd59977 | 192 | |
bd05fabf S |
193 | namespace { |
194 | // Set global var to inform outer methods that current representation item is non-manifold. | |
195 | // The better way is to pass this information via binder or via TopoDS_Shape itself, however, | |
196 | // this is very specific info to do so... | |
197 | Standard_Boolean NM_DETECTED = Standard_False; | |
198 | }; | |
199 | ||
7fd59977 | 200 | // ============================================================================ |
201 | // Method : STEPControl_ActorRead::STEPControl_ActorRead () | |
202 | // Purpose : Empty constructor | |
203 | // ============================================================================ | |
204 | ||
205 | STEPControl_ActorRead::STEPControl_ActorRead() {} | |
206 | ||
207 | // ============================================================================ | |
208 | // Method : STEPControl_ActorRead::Recognize | |
209 | // Purpose : tells if an entity is valid for transfer by this Actor | |
210 | // ============================================================================ | |
211 | ||
212 | Standard_Boolean STEPControl_ActorRead::Recognize | |
213 | (const Handle(Standard_Transient)& start) | |
214 | { | |
215 | if (start.IsNull()) return Standard_False; | |
216 | ||
217 | if (start->IsKind(STANDARD_TYPE(StepBasic_ProductDefinition))) return Standard_True; | |
218 | ||
219 | if (start->IsKind(STANDARD_TYPE(StepRepr_NextAssemblyUsageOccurrence))) return Standard_True; | |
220 | ||
221 | TCollection_AsciiString aProdMode = Interface_Static::CVal("read.step.product.mode"); | |
222 | if(!aProdMode.IsEqual("ON")) | |
223 | if(start->IsKind(STANDARD_TYPE(StepShape_ShapeDefinitionRepresentation))) return Standard_True; | |
224 | ||
225 | DeclareAndCast(StepShape_ShapeRepresentation,sr,start); | |
226 | if (!sr.IsNull()) { | |
227 | Standard_Integer i,nb = sr->NbItems(); | |
228 | for (i = 1; i <= nb; i ++) { | |
229 | if (Recognize (sr->ItemsValue(i)) ) return Standard_True; | |
230 | } | |
231 | return Standard_False; | |
232 | } | |
233 | ||
234 | if (start->IsKind(STANDARD_TYPE(StepShape_FacetedBrep))) return Standard_True; | |
235 | if (start->IsKind(STANDARD_TYPE(StepShape_BrepWithVoids))) return Standard_True; | |
236 | if (start->IsKind(STANDARD_TYPE(StepShape_ManifoldSolidBrep))) return Standard_True; | |
237 | if (start->IsKind(STANDARD_TYPE(StepShape_ShellBasedSurfaceModel))) return Standard_True; | |
238 | if (start->IsKind(STANDARD_TYPE(StepShape_FacetedBrepAndBrepWithVoids))) return Standard_True; | |
239 | if (start->IsKind(STANDARD_TYPE(StepShape_GeometricSet))) return Standard_True; | |
240 | if (start->IsKind(STANDARD_TYPE(StepRepr_MappedItem))) return Standard_True; | |
241 | if (start->IsKind(STANDARD_TYPE(StepShape_FaceSurface))) return Standard_True; | |
242 | if (start->IsKind(STANDARD_TYPE(StepShape_EdgeBasedWireframeModel))) return Standard_True; | |
243 | if (start->IsKind(STANDARD_TYPE(StepShape_FaceBasedSurfaceModel))) return Standard_True; | |
244 | ||
245 | ||
246 | // REPRESENTATION_RELATIONSHIP et consorts : on regarde le contenu ... | |
247 | // On prend WithTransformation ou non ... | |
248 | ||
249 | if (start->IsKind (STANDARD_TYPE(StepRepr_ShapeRepresentationRelationship))) { | |
250 | DeclareAndCast(StepRepr_ShapeRepresentationRelationship,und,start); | |
251 | ||
252 | // On prend son contenu | |
253 | ||
254 | if (Recognize(und->Rep1()) || Recognize(und->Rep2())) return Standard_True; | |
255 | return Standard_False; | |
256 | } | |
257 | ||
258 | if (start->IsKind(STANDARD_TYPE(StepShape_ContextDependentShapeRepresentation))) { | |
259 | // DeclareAndCast(StepShape_ContextDependentShapeRepresentation,CDSR,start); | |
260 | // return Recognize (CDSR->RepresentationRelation()); | |
261 | return Standard_True; | |
262 | // on fait le pari que, si ce n est pas transferable tel quel, | |
263 | // des CDSR implicitement references le sont ... | |
264 | // Sinon cette entite n aurait pas grand sens ... | |
265 | } | |
266 | ||
267 | return Standard_False; | |
268 | } | |
269 | ||
270 | ||
271 | // ============================================================================ | |
272 | // Method : STEPControl_ActorRead::Transfer | |
273 | // Purpose : recursive method that acces to the root entities and start the | |
274 | // mapping | |
275 | // ============================================================================ | |
276 | ||
277 | Handle(Transfer_Binder) STEPControl_ActorRead::Transfer | |
278 | (const Handle(Standard_Transient)& start, | |
279 | const Handle(Transfer_TransientProcess)& TP) | |
280 | { | |
281 | // [BEGIN] Get version of preprocessor (to detect I-Deas case) (ssv; 23.11.2010) | |
282 | Handle(StepData_StepModel) aStepModel = Handle(StepData_StepModel)::DownCast ( TP->Model() ); | |
283 | Interface_EntityIterator anEntIt = aStepModel->Header(); | |
284 | for ( anEntIt.Start(); anEntIt.More(); anEntIt.Next() ) { | |
285 | DeclareAndCast( HeaderSection_FileName, aFileNameEntity, anEntIt.Value() ); | |
286 | if ( !aFileNameEntity.IsNull() ) { | |
287 | Handle(TCollection_HAsciiString) aPPVersion = aFileNameEntity->PreprocessorVersion(); | |
d6320495 | 288 | if(aPPVersion.IsNull()) |
289 | continue; | |
7fd59977 | 290 | #ifdef DEB |
291 | cout << "Preprocessor version detected: " << aPPVersion->ToCString() << endl; | |
292 | #endif | |
293 | Standard_Integer anIDeasResult = aPPVersion->Search("I-DEAS"); | |
294 | if (anIDeasResult != -1) { | |
295 | #ifdef DEB | |
296 | cout << "Recognized as I-DEAS STP" << endl; | |
297 | #endif | |
298 | myNMTool.SetIDEASCase(Standard_True); | |
299 | } | |
300 | } | |
301 | } | |
302 | // [END] Get version of preprocessor (to detect I-Deas case) (ssv; 23.11.2010) | |
303 | return TransferShape (start,TP); | |
304 | } | |
305 | ||
306 | ||
307 | // ============================================================================ | |
308 | // auxiliary function : ApplyTransformation | |
309 | // ============================================================================ | |
310 | static void ApplyTransformation (TopoDS_Shape& shape, const gp_Trsf &Trsf) | |
311 | { | |
312 | if ( Trsf.Form() == gp_Identity ) return; | |
313 | TopLoc_Location theLoc ( Trsf ); | |
314 | shape.Move (theLoc); | |
315 | } | |
316 | ||
317 | ||
318 | // ============================================================================ | |
319 | // auxiliary function : FindContext | |
320 | // ============================================================================ | |
321 | static Handle(StepRepr_Representation) FindContext (const Handle(Standard_Transient) &start, | |
322 | const Handle(Transfer_TransientProcess) &TP, | |
323 | const Standard_Integer level=10 ) | |
324 | { | |
325 | Handle(StepRepr_Representation) rep; | |
326 | const Interface_Graph& graph = TP->Graph(); | |
327 | Interface_EntityIterator subs = graph.Sharings(start); | |
328 | for (subs.Start(); subs.More() && rep.IsNull(); subs.Next()) { | |
329 | rep = Handle(StepRepr_Representation)::DownCast(subs.Value()); | |
330 | if ( rep.IsNull() && level >0 ) rep = FindContext ( subs.Value(), TP, level-1 ); | |
331 | } | |
332 | return rep; | |
333 | } | |
334 | ||
335 | //======================================================================= | |
336 | //function : FindShapeReprType | |
337 | //purpose : Returns integer corresponding to the type of the representation | |
338 | // as defined in read.step.shape.repr_level parameter | |
339 | //======================================================================= | |
340 | ||
341 | static Standard_Integer FindShapeReprType (const Handle(Standard_Transient) &start) | |
342 | { | |
343 | if(start->IsKind(STANDARD_TYPE(StepShape_AdvancedBrepShapeRepresentation))) | |
344 | return 2; | |
345 | if(start->IsKind(STANDARD_TYPE(StepShape_ManifoldSurfaceShapeRepresentation))) | |
346 | return 3; | |
347 | if(start->IsKind(STANDARD_TYPE(StepShape_GeometricallyBoundedSurfaceShapeRepresentation))) | |
348 | return 4; | |
349 | if(start->IsKind(STANDARD_TYPE(StepShape_FacetedBrepShapeRepresentation))) | |
350 | return 5; | |
351 | if(start->IsKind(STANDARD_TYPE(StepShape_EdgeBasedWireframeShapeRepresentation))) | |
352 | return 6; | |
353 | if(start->IsKind(STANDARD_TYPE(StepShape_GeometricallyBoundedWireframeShapeRepresentation))) | |
354 | return 7; | |
355 | return 8; | |
356 | } | |
357 | ||
358 | //======================================================================= | |
359 | //function : getListSDR | |
360 | //purpose : Get SDRs assigned to ShapeAspect, which may potentially | |
361 | // correspond to hybrid models in AP203 before 1998 | |
362 | //======================================================================= | |
363 | ||
364 | static void getListSDR(const Handle(StepRepr_ShapeAspect)& sa, | |
365 | Handle(TColStd_HSequenceOfTransient)& listSDR, | |
366 | const Handle(Transfer_TransientProcess)& TP) | |
367 | { | |
368 | const Interface_Graph& graph = TP->Graph(); | |
369 | ||
370 | // check whether this ShapeAspect is used in G&DT, and if yes, ignore it | |
371 | if(sa->IsKind(STANDARD_TYPE(StepDimTol_DatumFeature))) return; | |
372 | Interface_EntityIterator subs5 = graph.Sharings(sa); | |
373 | for (subs5.Start(); subs5.More(); subs5.Next()) { | |
374 | if(subs5.Value()->IsKind(STANDARD_TYPE(StepDimTol_GeometricTolerance))) | |
375 | return; | |
376 | } | |
377 | ||
378 | // reiterate by referred entities and take all SDRs; note that SDRs that | |
379 | // refer to sub-shapes of main SDR will be filtered out further during translation | |
380 | subs5 = graph.Sharings(sa); | |
381 | for (subs5.Start(); subs5.More() ; subs5.Next()) { | |
382 | Handle(StepRepr_PropertyDefinition) propd = | |
383 | Handle(StepRepr_PropertyDefinition)::DownCast(subs5.Value()); | |
384 | if(propd.IsNull()) continue; | |
385 | Interface_EntityIterator subs6 = graph.Sharings(propd); | |
386 | for (subs6.Start(); subs6.More() ; subs6.Next()) { | |
387 | Handle(StepShape_ShapeDefinitionRepresentation) sdr = | |
388 | Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(subs6.Value()); | |
389 | if ( ! sdr.IsNull() ) | |
390 | listSDR->Append(sdr); | |
391 | } | |
392 | } | |
393 | } | |
394 | ||
395 | //======================================================================= | |
396 | //function : getSDR | |
397 | //purpose : Find all SDRs related to given PDS | |
398 | //======================================================================= | |
399 | ||
400 | static void getSDR(const Handle(StepRepr_ProductDefinitionShape)& PDS, | |
401 | Handle(TColStd_HSequenceOfTransient)& listSDR, | |
402 | Handle(TColStd_HSequenceOfTransient)& listSDRAspect, | |
403 | const Handle(Transfer_TransientProcess)& TP) | |
404 | { | |
405 | // Flag indicating preferred shape representation type, to be chosen if | |
406 | // several different representations are attached to the same shape | |
407 | Standard_Integer delta = 100; | |
408 | Standard_Integer ICS = Interface_Static::IVal("read.step.shape.repr"); | |
409 | Standard_Integer nbSDR0 = listSDR->Length(); | |
410 | ||
411 | // Iterate by entities referring PDS | |
412 | const Interface_Graph& graph = TP->Graph(); | |
413 | Handle(StepShape_ShapeDefinitionRepresentation) NeedSDR; | |
414 | Interface_EntityIterator subs4 = graph.Sharings(PDS); | |
415 | for (subs4.Start(); subs4.More(); subs4.Next()) { | |
416 | ||
417 | // Directly assigned SDR | |
418 | Handle(StepShape_ShapeDefinitionRepresentation) sdr = | |
419 | Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(subs4.Value()); | |
420 | if ( ! sdr.IsNull() ) { | |
421 | Handle(StepRepr_Representation) rep = sdr->UsedRepresentation(); | |
422 | ||
423 | if ( !rep.IsNull()) { | |
424 | // if specific representation type is preferred, choose the | |
425 | // representations of the closest type | |
426 | if ( ICS == 1 ) // translate all SDRs | |
427 | listSDR->Append(sdr); | |
428 | else { | |
429 | Standard_Integer iDiff = Abs ( FindShapeReprType(rep) - ICS ); | |
430 | // if more suitable representation is found, drop previous if any selected | |
431 | if( iDiff < delta ) { | |
432 | while ( listSDR->Length() > nbSDR0 ) | |
433 | listSDR->Remove(listSDR->Length()); | |
434 | delta = iDiff; | |
435 | } | |
436 | // take all representations of preferred or closest type | |
437 | if ( iDiff <= delta ) | |
438 | listSDR->Append(sdr); | |
439 | } | |
440 | } | |
441 | continue; | |
442 | } | |
443 | ||
444 | // SDRs assigned via ShapeAspect; may correspond to hybrid model in AP203 before 1998 | |
445 | Handle(StepRepr_ShapeAspect) sa = | |
446 | Handle(StepRepr_ShapeAspect)::DownCast(subs4.Value()); | |
447 | if ( ! sa.IsNull() ) { | |
448 | getListSDR(sa,listSDRAspect,TP); | |
449 | continue; | |
450 | } | |
451 | } | |
452 | } | |
453 | ||
454 | ||
455 | //======================================================================= | |
456 | //function : TransferEntity | |
457 | //purpose : | |
458 | //======================================================================= | |
459 | Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepBasic_ProductDefinition)& PD, | |
460 | const Handle(Transfer_TransientProcess)& TP) | |
461 | ||
462 | { | |
463 | Handle(Message_Messenger) sout = TP->Messenger(); | |
464 | Handle(TransferBRep_ShapeBinder) shbinder; | |
465 | ||
466 | TopoDS_Compound Cund; | |
467 | TopoDS_Shape Result1; | |
468 | BRep_Builder B; | |
469 | B.MakeCompound (Cund); | |
470 | ||
471 | // Find subcomponents of assembly (NAUO) | |
472 | // and definitions of shape of the current product (SDR) | |
473 | Handle(TColStd_HSequenceOfTransient) listSDR = new TColStd_HSequenceOfTransient; | |
474 | Handle(TColStd_HSequenceOfTransient) listNAUO = new TColStd_HSequenceOfTransient; | |
475 | Handle(TColStd_HSequenceOfTransient) listSDRAspect = new TColStd_HSequenceOfTransient; | |
476 | const Interface_Graph& graph = TP->Graph(); | |
477 | Interface_EntityIterator subs3 = graph.Sharings(PD); | |
478 | for (subs3.Start(); subs3.More() ; subs3.Next()) { | |
479 | // PDS is used to find shape definitions attached to this product | |
480 | Handle(StepRepr_ProductDefinitionShape) PDS = | |
481 | Handle(StepRepr_ProductDefinitionShape)::DownCast(subs3.Value()); | |
482 | if ( ! PDS.IsNull() ) { | |
483 | getSDR(PDS,listSDR,listSDRAspect,TP); | |
484 | continue; | |
485 | } | |
486 | // NAUO is used to find sub-assemblies | |
487 | Handle(StepRepr_NextAssemblyUsageOccurrence) NAUO = | |
488 | Handle(StepRepr_NextAssemblyUsageOccurrence)::DownCast(subs3.Value()); | |
489 | if ( ! NAUO.IsNull() ) { | |
490 | if ( PD == NAUO->RelatingProductDefinition() ) | |
491 | listNAUO->Append(NAUO); | |
492 | continue; | |
493 | } | |
494 | } | |
495 | ||
496 | // Flag indicating whether SDRs associated with the product`s main SDR | |
497 | // by SRRs (which correspond to hybrid model representation in AP203 since 1998) | |
498 | // should be taken into account | |
499 | Standard_Integer readSRR = Interface_Static::IVal("read.step.shape.relationship"); | |
500 | ||
501 | // Flag indicating whether SDRs associated with the product`s main SDR | |
502 | // by SAs (which correspond to hybrid model representation in AP203 before 1998) | |
503 | // should be taken into account | |
504 | Standard_Integer readSA = Interface_Static::IVal("read.step.shape.aspect"); | |
505 | if ( ! readSA ) | |
506 | listSDRAspect->Clear(); | |
507 | ||
508 | // remember number of normal SDRs (not those found via ShapeAspect) | |
509 | // and merge both lists in one | |
510 | Standard_Integer nbNotAspect = listSDR->Length(); | |
511 | listSDR->Append(listSDRAspect); | |
512 | ||
513 | // Flag indicating level of reading assemblies: only structure (3), | |
514 | // structure with shapes of final parts (2), or everything, including shapes | |
515 | // possibly attached directly to intermediate assemblies (1) | |
516 | // Special mode (4) is used to translate shape attached to this product only, | |
517 | // ignoring sub-assemblies if any | |
518 | Standard_Integer readAssembly = Interface_Static::IVal("read.step.assembly.level"); | |
519 | if ( readAssembly ==3 || ( readAssembly ==2 && listNAUO->Length() >0 ) ) | |
520 | listSDR->Clear(); | |
521 | else if ( readAssembly == 4 ) | |
522 | listNAUO->Clear(); | |
523 | ||
524 | Standard_Integer nbEnt = listSDR->Length() + listNAUO->Length(); | |
525 | if ( nbEnt <=0 ) | |
526 | return shbinder; | |
527 | ||
528 | // common progress indicator for translation of own shapes and sub-assemblies | |
529 | Message_ProgressSentry PS ( TP->GetProgress(), "Part", 0, nbEnt, 1 ); | |
530 | Standard_Integer nbComponents=0, nbShapes=0; | |
531 | ||
532 | // translate sub-assemblies | |
533 | for ( Standard_Integer nbNauo =1; nbNauo <= listNAUO->Length() && PS.More(); nbNauo++, PS.Next()) { | |
534 | Handle(StepRepr_NextAssemblyUsageOccurrence) NAUO = | |
535 | Handle(StepRepr_NextAssemblyUsageOccurrence)::DownCast(listNAUO->Value(nbNauo)); | |
536 | ||
537 | #ifdef TRANSLOG | |
538 | if (TP->TraceLevel() > 1) | |
539 | sout<<" -- Actor : Ent.n0 "<<TP->Model()->Number(PD)<<" -> Shared Ent.no"<<TP->Model()->Number(NAUO)<<endl; | |
540 | #endif | |
541 | Handle(Transfer_Binder) binder; | |
542 | if (!TP->IsBound(NAUO)) binder = TransferEntity(NAUO,TP); | |
543 | else binder = TP->Find(NAUO); | |
544 | ||
545 | TopoDS_Shape theResult = TransferBRep::ShapeResult (binder); | |
546 | if (!theResult.IsNull()) { | |
547 | Result1 = theResult; | |
bd05fabf S |
548 | // [BEGIN] ssv: OCCT#22436: extra compound in NMSSR case |
549 | if (NM_DETECTED && Result1.ShapeType() == TopAbs_COMPOUND) | |
550 | { | |
551 | TopoDS_Iterator it(Result1); | |
552 | for ( ; it.More(); it.Next() ) | |
553 | { | |
554 | TopoDS_Shape aSubShape = it.Value(); | |
555 | B.Add(Cund, aSubShape); | |
556 | } | |
557 | } | |
558 | else | |
559 | B.Add(Cund, theResult); | |
560 | // [END] ssv: OCCT#22436: extra compound in NMSSR case | |
7fd59977 | 561 | nbComponents++; |
562 | } | |
563 | } | |
564 | ||
565 | // translate shapes assigned directly | |
566 | for(Standard_Integer i=1; i <= listSDR->Length() && PS.More(); i++, PS.Next()) { | |
567 | Handle(StepShape_ShapeDefinitionRepresentation) sdr = | |
568 | Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(listSDR->Value(i)); | |
569 | Handle(StepShape_ShapeRepresentation) rep = Handle(StepShape_ShapeRepresentation)::DownCast(sdr->UsedRepresentation()); | |
570 | if ( rep.IsNull() ) | |
571 | continue; | |
572 | ||
573 | // translate SDR representation | |
574 | Standard_Boolean isBound = Standard_True; | |
575 | Handle(Transfer_Binder) binder = TP->Find(rep); | |
576 | if (binder.IsNull()) | |
577 | binder = TransferEntity(rep,TP,isBound); | |
578 | ||
579 | // if SDR is obtained from ShapeAspect and representation items have already been tramnslated, | |
580 | // this means that that ShapeAspect is used to refer to sub-shape of the main shape | |
581 | // (e.g. for validation properties), and we do not need to translate it actually; | |
582 | // otherwise it is considered as part of hybrid representation in AP203 before 1998 | |
583 | if ( i > nbNotAspect && isBound) | |
584 | continue; | |
585 | ||
586 | // record shape resulting from translation | |
587 | TopoDS_Shape theResult; | |
588 | if ( ! binder.IsNull() ) { | |
589 | theResult = TransferBRep::ShapeResult (binder); | |
590 | if (!theResult.IsNull()) { | |
591 | Result1 = theResult; | |
bd05fabf S |
592 | // [BEGIN] ssv: OCCT#22436: extra compound in NMSSR case |
593 | if (NM_DETECTED && Result1.ShapeType() == TopAbs_COMPOUND) | |
594 | { | |
595 | TopoDS_Iterator it(Result1); | |
596 | for ( ; it.More(); it.Next() ) | |
597 | { | |
598 | TopoDS_Shape aSubShape = it.Value(); | |
599 | B.Add(Cund, aSubShape); | |
600 | } | |
601 | } | |
602 | else | |
603 | B.Add(Cund, theResult); | |
604 | // [END] ssv: OCCT#22436: extra compound in NMSSR case | |
7fd59977 | 605 | nbShapes++; |
606 | } | |
607 | } | |
608 | ||
609 | // translate possible shapes related by SRRs, which corresponds to | |
610 | // way of writing hybrid models in AP203 since 1998, and AP209 | |
611 | // Note that both AP203 and AP209 allow main representation to be non-empty | |
612 | if ( readSRR && /*theResult.IsNull() &&*/ i <= nbNotAspect) { | |
613 | Interface_EntityIterator subs1 = graph.Sharings(rep); | |
614 | Handle(Standard_Type) tSRR = STANDARD_TYPE(StepRepr_ShapeRepresentationRelationship); | |
615 | for (subs1.Start(); subs1.More(); subs1.Next()) { | |
616 | Handle(Standard_Transient) anitem = subs1.Value(); | |
617 | if ( anitem->DynamicType() != tSRR ) continue; | |
618 | Handle(StepRepr_ShapeRepresentationRelationship) SRR = | |
619 | Handle(StepRepr_ShapeRepresentationRelationship)::DownCast(anitem); | |
620 | Standard_Integer nbrep = ( rep == SRR->Rep1() ? 2 : 1 ); | |
621 | binder = TransferEntity(SRR, TP, nbrep); | |
622 | if ( ! binder.IsNull() ) { | |
623 | theResult = TransferBRep::ShapeResult (binder); | |
624 | Result1 = theResult; | |
625 | B.Add(Cund, theResult); | |
626 | nbShapes++; | |
627 | } | |
628 | } | |
629 | } | |
630 | } | |
631 | ||
632 | // make a warning if both own shape and sub-assemblies are present | |
633 | if ( nbShapes >0 && nbComponents > 0 ) | |
634 | TP->AddWarning ( PD, "Product has both sub-assemblies and directly assigned shape" ); | |
635 | ||
636 | // if only single shape is read, add it as it is; otherwise add compound | |
637 | if( nbShapes == 1 && nbComponents == 0 ) | |
638 | shbinder = new TransferBRep_ShapeBinder (Result1); | |
639 | else | |
640 | shbinder = new TransferBRep_ShapeBinder (Cund); | |
641 | ||
642 | //TP->Unbind( PD ); //:j3: unbind start (let it be bound by TransferProcess) | |
643 | TP->Bind(PD, shbinder); | |
644 | return shbinder; | |
645 | } | |
646 | ||
647 | //======================================================================= | |
648 | //function : TransferEntity | |
649 | //purpose : | |
650 | //======================================================================= | |
651 | ||
652 | Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepRepr_NextAssemblyUsageOccurrence)& NAUO , | |
653 | const Handle(Transfer_TransientProcess)& TP) | |
654 | { | |
655 | Handle(TransferBRep_ShapeBinder) shbinder; | |
656 | Handle(StepBasic_ProductDefinition) PD; | |
657 | const Interface_Graph& graph = TP->Graph(); | |
658 | gp_Trsf Trsf; | |
659 | Standard_Boolean iatrsf=Standard_False, SRRReversed=Standard_False, IsDepend=Standard_False; | |
660 | Handle(StepRepr_ShapeRepresentationRelationship) SRR; | |
661 | Interface_EntityIterator subs1 = graph.Sharings(NAUO); | |
662 | for (subs1.Start(); subs1.More(); subs1.Next()) { | |
663 | Handle(StepRepr_ProductDefinitionShape) PDS = | |
664 | Handle(StepRepr_ProductDefinitionShape)::DownCast(subs1.Value()); | |
665 | if(PDS.IsNull()) continue; | |
666 | //IsPDS=Standard_True; | |
667 | Interface_EntityIterator subs2 = graph.Sharings(PDS); | |
668 | for (subs2.Start(); subs2.More(); subs2.Next()) { | |
669 | Handle(StepShape_ContextDependentShapeRepresentation) CDSR = | |
670 | Handle(StepShape_ContextDependentShapeRepresentation)::DownCast(subs2.Value()); | |
671 | if (CDSR.IsNull()) continue; | |
672 | IsDepend=Standard_True; | |
673 | Handle(StepRepr_RepresentationRelationship) RR = CDSR->RepresentationRelation(); | |
674 | if (RR.IsNull()) continue; | |
675 | SRRReversed = STEPConstruct_Assembly::CheckSRRReversesNAUO ( TP->Model(), CDSR ); | |
676 | Handle(StepRepr_Representation) rep = ( SRRReversed ? RR->Rep2() : RR->Rep1() ); | |
677 | iatrsf = ComputeSRRWT ( RR, TP, Trsf ); | |
678 | // find real ProductDefinition used rep | |
679 | Interface_EntityIterator subs3 = TP->Graph().Sharings(rep); | |
680 | for (subs3.Start(); subs3.More(); subs3.Next()) { | |
681 | if ( subs3.Value()->IsKind(STANDARD_TYPE(StepShape_ShapeDefinitionRepresentation))) { | |
682 | DeclareAndCast(StepShape_ShapeDefinitionRepresentation,SDR,subs3.Value()); | |
683 | Handle(StepRepr_ProductDefinitionShape) PDS1 = | |
684 | Handle(StepRepr_ProductDefinitionShape)::DownCast(SDR->Definition().PropertyDefinition()); | |
685 | //Handle(StepRepr_PropertyDefinition) PD = SDR->Definition().PropertyDefinition(); | |
686 | if(PDS1.IsNull()) continue; | |
687 | Interface_EntityIterator subs4 = graph.Shareds(PDS1); | |
688 | for (subs4.Start(); subs4.More(); subs4.Next()) { | |
689 | Handle(StepBasic_ProductDefinition) PD1 = | |
690 | Handle(StepBasic_ProductDefinition)::DownCast(subs4.Value()); | |
691 | if(PD1.IsNull()) continue; | |
692 | PD=PD1; | |
693 | } | |
694 | } | |
695 | else if(subs3.Value()->IsKind(STANDARD_TYPE(StepRepr_ShapeRepresentationRelationship))) { | |
696 | SRR = Handle(StepRepr_ShapeRepresentationRelationship)::DownCast(subs3.Value()); | |
697 | } | |
698 | } | |
699 | } | |
700 | } | |
701 | ||
702 | Handle(Transfer_Binder) binder; | |
703 | TopoDS_Shape theResult; | |
704 | shbinder.Nullify(); | |
705 | ||
706 | if(IsDepend) { | |
707 | ||
708 | if(!PD.IsNull()) { | |
709 | binder = TP->Find(PD); | |
710 | if ( binder.IsNull() ) binder = TransferEntity(PD,TP); | |
711 | theResult = TransferBRep::ShapeResult(binder); | |
712 | if (!theResult.IsNull()) { | |
713 | if (iatrsf) { | |
714 | if ( SRRReversed ) ApplyTransformation ( theResult, Trsf.Inverted() ); | |
715 | else ApplyTransformation ( theResult, Trsf ); | |
716 | } | |
717 | shbinder = new TransferBRep_ShapeBinder (theResult); | |
718 | } | |
719 | } | |
720 | ||
721 | if ( theResult.IsNull() && !SRR.IsNull() ) { | |
722 | binder = TP->Find(SRR); | |
723 | if ( binder.IsNull() ) { | |
724 | binder = TransferEntity(SRR,TP); | |
725 | theResult = TransferBRep::ShapeResult (binder); | |
726 | if (!theResult.IsNull()) | |
727 | shbinder = new TransferBRep_ShapeBinder (theResult); | |
728 | } | |
729 | } | |
730 | ||
731 | } | |
732 | TP->Bind(NAUO, shbinder); | |
733 | return shbinder; | |
734 | ||
735 | } | |
736 | //======================================================================= | |
737 | //function : TransferEntity | |
738 | //purpose : | |
739 | //======================================================================= | |
740 | ||
741 | Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepShape_ShapeRepresentation)& sr, | |
742 | const Handle(Transfer_TransientProcess)& TP, | |
743 | Standard_Boolean& isBound) | |
744 | { | |
bd05fabf | 745 | NM_DETECTED = Standard_False; |
7fd59977 | 746 | Handle(TransferBRep_ShapeBinder) shbinder; |
747 | if(!Recognize(sr)) | |
748 | return shbinder; | |
749 | isBound = Standard_False; | |
750 | Standard_Integer i,nb = sr->NbItems(); | |
751 | // Used in XSAlgo::AlgoContainer()->ProcessShape (ssv; 13.11.2010) | |
752 | Standard_Integer nbTPitems = TP->NbMapped(); | |
753 | Handle(Message_Messenger) sout = TP->Messenger(); | |
754 | #ifdef TRANSLOG | |
755 | if (TP->TraceLevel() > 2) | |
756 | sout<<" -- Actor : case ShapeRepr. NbItems="<<nb<<endl; | |
757 | #endif | |
758 | ||
759 | // Compute unit convertion factors and geometric Accuracy | |
760 | Handle(StepRepr_Representation) oldSRContext = mySRContext; //:S4136 | |
761 | PrepareUnits(sr,TP); | |
762 | ||
763 | BRep_Builder B; | |
764 | TopoDS_Compound comp; | |
765 | B.MakeCompound (comp); | |
766 | TopoDS_Shape OneResult; | |
767 | Standard_Integer nsh = 0; | |
768 | Message_ProgressSentry PS ( TP->GetProgress(), "Sub-assembly", 0, nb, 1 ); | |
769 | ||
770 | // [BEGIN] Proceed with non-manifold topology (ssv; 12.11.2010) | |
771 | Standard_Boolean isNMMode = Interface_Static::IVal("read.step.nonmanifold"); | |
772 | Standard_Boolean isManifold = Standard_True; | |
773 | if ( isNMMode && sr->IsKind(STANDARD_TYPE(StepShape_NonManifoldSurfaceShapeRepresentation)) ) { | |
774 | isManifold = Standard_False; | |
bd05fabf | 775 | NM_DETECTED = Standard_True; |
7fd59977 | 776 | #ifdef DEB |
777 | Standard_Integer NMSSRItemsLen = sr->Items()->Length(); | |
778 | cout << "NMSSR with " << NMSSRItemsLen << " items detected" << endl; | |
779 | #endif | |
780 | } | |
781 | // Special processing for I-DEAS STP case (ssv; 15.11.2010) | |
782 | else { | |
783 | Standard_Integer isIDeasMode = Interface_Static::IVal("read.step.ideas"); | |
784 | if (isNMMode && myNMTool.IsIDEASCase() && isIDeasMode) { | |
785 | isManifold = Standard_False; | |
bd05fabf | 786 | NM_DETECTED = Standard_True; |
7fd59977 | 787 | #ifdef DEB |
788 | cout << "I-DEAS post processing for non-manifold topology ENABLED" << endl; | |
789 | #endif | |
790 | } | |
791 | #ifdef DEB | |
792 | else if ( myNMTool.IsIDEASCase() ) | |
793 | cout << "I-DEAS post processing for non-manifold topology DISABLED" << endl; | |
794 | #endif | |
795 | } | |
796 | myNMTool.CleanUp(); | |
797 | // Don't use NM tool in manifold cases (ssv; 24.11.2010) | |
798 | myNMTool.SetActive(!isManifold && isNMMode); | |
799 | // [END] Proceed with non-manifold topology (ssv; 12.11.2010) | |
800 | ||
801 | for (i = 1; i <= nb && PS.More(); i ++,PS.Next()) { | |
802 | //for (i = 1; i <= nb ; i ++) { | |
803 | #ifdef TRANSLOG | |
804 | if (TP->TraceLevel() > 2) | |
805 | sout<<" -- Actor, shape_representation.item n0. "<<i<<endl; | |
806 | #endif | |
807 | Handle(StepRepr_RepresentationItem) anitem = sr->ItemsValue(i); | |
808 | Handle(Transfer_Binder) binder; | |
809 | if (!TP->IsBound(anitem)) { | |
810 | binder = TransferShape(anitem, TP, isManifold); | |
811 | } | |
812 | else { | |
813 | isBound = Standard_True; | |
814 | binder = TP->Find(anitem); | |
815 | } | |
816 | TopoDS_Shape theResult = TransferBRep::ShapeResult (binder); | |
817 | if (!theResult.IsNull()) { | |
818 | OneResult = theResult; | |
819 | B.Add(comp, theResult); | |
820 | nsh ++; | |
821 | } | |
822 | } | |
823 | ||
824 | // [BEGIN] Proceed with non-manifold topology (ssv; 12.11.2010) | |
825 | if (!isManifold) { | |
826 | Handle(Standard_Transient) info; | |
827 | // IMPORTANT: any fixing on non-manifold topology must be done after the shape is transferred from STEP | |
828 | TopoDS_Shape fixedResult = | |
b485ee79 KD |
829 | XSAlgo::AlgoContainer()->ProcessShape( comp, myPrecision, myMaxTol, |
830 | "read.step.resource.name", | |
831 | "read.step.sequence", info, | |
832 | TP->GetProgress() ); | |
7fd59977 | 833 | XSAlgo::AlgoContainer()->MergeTransferInfo(TP, info, nbTPitems); |
834 | ||
835 | BRep_Builder brepBuilder; | |
836 | ||
837 | // [BEGIN] Try to close OPEN Shells in I-DEAS case (ssv; 17.11.2010) | |
838 | if ( myNMTool.IsIDEASCase() ) { | |
839 | ||
840 | // ========================================================== | |
841 | // For each Shell (always OPEN in I-DEAS case) find all | |
842 | // the possibilities to close it with adjacent non-manifold | |
843 | // Shells which are stored separately in I-DEAS-like STP | |
844 | // ========================================================== | |
845 | ||
846 | TopTools_IndexedDataMapOfShapeListOfShape shellClosingsMap; | |
847 | // Find possible closings for each shell | |
848 | this->computeIDEASClosings(comp, shellClosingsMap); | |
849 | ||
850 | // Make compound to store closed Shells | |
851 | TopoDS_Compound compWithClosings; | |
852 | brepBuilder.MakeCompound(compWithClosings); | |
853 | ||
854 | // Attempt to close Shells one-by-one | |
855 | for (Standard_Integer i = 1; i <= shellClosingsMap.Extent(); i++) { | |
856 | TopoDS_Shell adjustedShell = this->closeIDEASShell( TopoDS::Shell( shellClosingsMap.FindKey(i) ), | |
857 | shellClosingsMap.FindFromIndex(i) ); | |
858 | brepBuilder.Add(compWithClosings, adjustedShell); | |
859 | } | |
860 | // Put not suspected open Shells as they are (updated 23.11.2010) | |
861 | TopExp_Explorer allShellsExp(comp, TopAbs_SHELL); | |
862 | for ( ; allShellsExp.More(); allShellsExp.Next() ) { | |
863 | TopoDS_Shape aCurrentShell = allShellsExp.Current(); | |
864 | if ( !myNMTool.IsPureNMShell(aCurrentShell) && !shellClosingsMap.Contains(aCurrentShell) ) | |
865 | brepBuilder.Add(compWithClosings, aCurrentShell); | |
866 | } | |
867 | ||
868 | ||
869 | comp = compWithClosings; | |
870 | ||
871 | } | |
872 | // [END] Try to close OPEN Shells in I-DEAS case (ssv; 17.11.2010) | |
873 | ||
874 | // [BEGIN] Reconstruct Solids from Closed Shells (ssv; 15.11.2010) | |
875 | TopoDS_Compound reconstComp; | |
876 | brepBuilder.MakeCompound(reconstComp); | |
877 | ||
878 | TopoDS_Iterator it(comp); | |
879 | for ( ; it.More(); it.Next() ) { | |
880 | TopoDS_Shape aSubShape = it.Value(); | |
881 | if ( aSubShape.ShapeType() == TopAbs_SHELL && aSubShape.Closed() ) { | |
882 | TopoDS_Solid nextSolid; | |
883 | brepBuilder.MakeSolid(nextSolid); | |
884 | brepBuilder.Add(nextSolid, aSubShape); | |
885 | brepBuilder.Add(reconstComp, nextSolid); | |
886 | } | |
887 | else if (aSubShape.ShapeType() == TopAbs_SHELL) | |
888 | brepBuilder.Add(reconstComp, aSubShape); | |
889 | } | |
890 | ||
891 | comp = reconstComp; | |
892 | // [END] Reconstruct Solids from Closed Shells (ssv; 15.11.2010) | |
893 | } | |
894 | ||
895 | // Bind the resulting shape | |
896 | if (nsh == 0) shbinder.Nullify(); | |
897 | else if (nsh == 1) shbinder = new TransferBRep_ShapeBinder (OneResult); | |
898 | else shbinder = new TransferBRep_ShapeBinder (comp); | |
899 | PrepareUnits ( oldSRContext, TP ); //:S4136 | |
900 | TP->Bind(sr, shbinder); | |
901 | ||
902 | ||
903 | #ifdef DEB | |
904 | DumpWhatIs(comp); | |
905 | #endif | |
906 | ||
907 | return shbinder; | |
908 | ||
909 | } | |
910 | //======================================================================= | |
911 | //function : TransferEntity | |
912 | //purpose : | |
913 | //======================================================================= | |
914 | ||
915 | Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepShape_ContextDependentShapeRepresentation)& CDSR, | |
916 | const Handle(Transfer_TransientProcess)& TP) | |
917 | { | |
918 | Handle(TransferBRep_ShapeBinder) shbinder; | |
919 | //:j2: treat SRRs here in order to compare them with NAUO | |
920 | Handle(StepRepr_ShapeRepresentationRelationship) SRR = CDSR->RepresentationRelation(); | |
921 | //DeclareAndCast(StepRepr_RepresentationRelationship,SRR,CDSR->RepresentationRelation()); | |
922 | if ( SRR.IsNull() ) return shbinder; | |
923 | ||
924 | Standard_Boolean SRRReversed = STEPConstruct_Assembly::CheckSRRReversesNAUO ( TP->Model(), CDSR ); | |
925 | Handle(StepRepr_Representation) rep1 = ( SRRReversed ? SRR->Rep2() : SRR->Rep1() ); | |
926 | Handle(StepShape_ShapeRepresentation) rep = Handle(StepShape_ShapeRepresentation)::DownCast(rep1); | |
927 | ||
928 | if ( SRRReversed ) | |
929 | TP->AddWarning ( SRR, "SRR reverses relation defined by NAUO; NAUO definition is taken" ); | |
930 | ||
931 | TopoDS_Shape theResult; | |
932 | ||
933 | gp_Trsf Trsf; | |
934 | Standard_Boolean iatrsf = ComputeSRRWT ( SRR, TP, Trsf ); | |
935 | /* Delete this part does not work gka | |
936 | // use SDR for reading rep in order to handle subassemblies | |
937 | Interface_EntityIterator subs = TP->Graph().Sharings(rep); | |
938 | Standard_Integer nbitem=0; | |
939 | for (subs.Start(); subs.More(); subs.Next()) nbitem++; | |
940 | Message_ProgressSentry PS ( TP->GetProgress(), "Shape", 0, nbitem, 1 ); | |
941 | ||
942 | for (subs.Start(); subs.More() && PS.More() ; subs.Next(),PS.Next()) { | |
943 | if ( subs.Value()->IsKind(STANDARD_TYPE(StepShape_ShapeDefinitionRepresentation))) { | |
944 | DeclareAndCast(StepShape_ShapeDefinitionRepresentation,SDR,subs.Value()); | |
945 | #ifdef TRANSLOG | |
946 | if (TP->TraceLevel() > 1) | |
947 | sout<<" -- Actor : Ent.n0 "<<TP->Model()->Number(CDSR)<<" -> Sharing Ent.no"<<TP->Model()->Number(SDR)<<endl; | |
948 | #endif | |
949 | ||
950 | binder = TP->Find ( SDR ); | |
951 | if ( binder.IsNull() ) binder = TransferEntity(SDR,TP); | |
952 | theResult = TransferBRep::ShapeResult (binder); | |
953 | break; | |
954 | } | |
955 | }*/ | |
956 | //if ( theResult.IsNull() && ! subs.More() ) { | |
957 | Handle(Transfer_Binder) binder; | |
958 | Standard_Boolean isBound = Standard_False; | |
959 | if (!TP->IsBound(rep)) binder = TransferEntity(rep,TP,isBound); | |
960 | else binder = TP->Find(rep); | |
961 | theResult = TransferBRep::ShapeResult (binder); | |
962 | //} | |
963 | ||
964 | if ( ! theResult.IsNull() ) { | |
965 | if ( iatrsf ) { | |
966 | if ( SRRReversed ) ApplyTransformation ( theResult, Trsf.Inverted() ); | |
967 | else ApplyTransformation ( theResult, Trsf ); | |
968 | } | |
969 | shbinder = new TransferBRep_ShapeBinder (theResult); | |
970 | } | |
971 | else shbinder.Nullify(); | |
972 | TP->Bind(CDSR, shbinder); | |
973 | return shbinder; | |
974 | ||
975 | } | |
976 | //======================================================================= | |
977 | //function : TransferEntity | |
978 | //purpose : | |
979 | //======================================================================= | |
980 | ||
981 | Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepRepr_ShapeRepresentationRelationship)& und, | |
982 | const Handle(Transfer_TransientProcess)& TP, | |
983 | const Standard_Integer nbrep) | |
984 | { | |
985 | // REPRESENTATION_RELATIONSHIP et la famille | |
986 | Handle(TransferBRep_ShapeBinder) shbinder; | |
987 | ||
988 | if (und.IsNull()) return shbinder; | |
989 | ||
990 | // On prend son contenu : Rep1 ou Rep2 , that is the question | |
991 | // on prend les 2. Mais quoi faire des axes | |
992 | ||
993 | TopoDS_Compound Cund; | |
994 | TopoDS_Shape OneResult; | |
995 | BRep_Builder B; | |
996 | B.MakeCompound (Cund); | |
997 | Standard_Integer nsh = 0; | |
998 | ||
999 | gp_Trsf Trsf; | |
1000 | Standard_Boolean iatrsf = ComputeSRRWT ( und, TP, Trsf ); | |
1001 | ||
1002 | // Transfert : que faut-il prendre au juste ? | |
1003 | ||
1004 | for (Standard_Integer i = 1; i <= 2; i ++) { | |
1005 | if(nbrep && nbrep != i) | |
1006 | continue; | |
1007 | Handle(StepRepr_Representation) anitemt; | |
1008 | if (i == 1) anitemt = und->Rep1(); | |
1009 | if (i == 2) anitemt = und->Rep2(); | |
1010 | Handle(StepShape_ShapeRepresentation) anitem = Handle(StepShape_ShapeRepresentation)::DownCast(anitemt); | |
1011 | Handle(Transfer_Binder) binder; | |
1012 | Standard_Boolean isBound = Standard_False; | |
1013 | if (!TP->IsBound(anitem)) binder = TransferEntity(anitem,TP,isBound);//TP->Transferring(anitem); | |
1014 | else binder = TP->Find(anitem); | |
1015 | TopoDS_Shape theResult = TransferBRep::ShapeResult (binder); | |
1016 | if (!theResult.IsNull()) { | |
1017 | OneResult = theResult; | |
1018 | B.Add(Cund, theResult); | |
1019 | nsh ++; | |
1020 | } | |
1021 | } | |
1022 | ||
1023 | // La Transformation : selon les cas | |
1024 | ||
1025 | // Appliquer la transformation | |
1026 | ||
1027 | if (iatrsf) { | |
1028 | if (nsh == 1) ApplyTransformation ( OneResult, Trsf ); | |
1029 | else if (nsh > 1) ApplyTransformation ( Cund, Trsf ); | |
1030 | } | |
1031 | if (nsh == 0) shbinder.Nullify(); | |
1032 | else if (nsh == 1) shbinder = new TransferBRep_ShapeBinder (OneResult); | |
1033 | else shbinder = new TransferBRep_ShapeBinder (Cund); | |
1034 | TP->Bind(und, shbinder); | |
1035 | return shbinder; | |
1036 | ||
1037 | } | |
1038 | ||
1039 | //======================================================================= | |
1040 | //function : OldWay | |
1041 | //purpose : | |
1042 | //======================================================================= | |
1043 | //======================================================================= | |
1044 | //function : IsNeedRepresentation | |
1045 | //purpose : | |
1046 | //======================================================================= | |
1047 | ||
1048 | static Standard_Boolean IsNeedRepresentation(const Handle(StepRepr_ShapeAspect)& sa, | |
1049 | const Handle(StepRepr_Representation)&repA , | |
1050 | const Handle(Transfer_TransientProcess)& TP) | |
1051 | { | |
1052 | Standard_Boolean IsSDRaspect=Standard_True; | |
1053 | Handle(StepRepr_ProductDefinitionShape) PDSA = sa->OfShape(); | |
1054 | const Interface_Graph& graph = TP->Graph(); | |
1055 | Interface_EntityIterator subs7 = graph.Sharings(PDSA); | |
1056 | for (subs7.Start(); ! PDSA.IsNull() && subs7.More(); subs7.Next()) { | |
1057 | Handle(StepShape_ShapeDefinitionRepresentation) sdrA = | |
1058 | Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(subs7.Value()); | |
1059 | if ( sdrA.IsNull() ) continue; | |
1060 | // abv 23 Feb 00: use iterator to take into account AP203 hybrid models | |
1061 | Interface_EntityIterator subs8 = graph.Shareds(sdrA); | |
1062 | for (subs8.Start(); subs8.More(); subs8.Next()) { | |
1063 | Handle(StepRepr_Representation) rep2 = | |
1064 | Handle(StepRepr_Representation)::DownCast ( subs8.Value() ); | |
1065 | if ( rep2.IsNull() ) { | |
1066 | Handle(StepRepr_ShapeRepresentationRelationship) SRR = | |
1067 | Handle(StepRepr_ShapeRepresentationRelationship)::DownCast ( subs8.Value() ); | |
1068 | if ( SRR.IsNull() ) continue; | |
1069 | rep2 = ( sdrA->UsedRepresentation() == SRR->Rep1() ? SRR->Rep2() : SRR->Rep1() ); | |
1070 | } | |
1071 | Standard_Integer i, j; // svv Jan 11 2000 : porting on DEC | |
1072 | for ( i=1; i <= repA->NbItems(); i++ ) { | |
1073 | Handle(StepRepr_RepresentationItem) it = repA->ItemsValue(i); | |
1074 | for ( j=1; j <= rep2->NbItems(); j++ ) | |
1075 | if ( it == rep2->ItemsValue(j) ) break; | |
1076 | if ( j > rep2->NbItems() ) break; | |
1077 | } | |
1078 | if ( i > repA->NbItems() ) IsSDRaspect=Standard_False; | |
1079 | } | |
1080 | } | |
1081 | return IsSDRaspect; | |
1082 | } | |
1083 | //======================================================================= | |
1084 | //function : OldWay | |
1085 | //purpose : | |
1086 | //======================================================================= | |
1087 | ||
1088 | Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::OldWay(const Handle(Standard_Transient)& start, | |
1089 | const Handle(Transfer_TransientProcess)& TP) | |
1090 | { | |
1091 | Handle(Message_Messenger) sout = TP->Messenger(); | |
1092 | const Interface_Graph& graph = TP->Graph(); | |
1093 | Handle(TransferBRep_ShapeBinder) shbinder; | |
1094 | DeclareAndCast(StepShape_ShapeDefinitionRepresentation,sdr,start); | |
1095 | Handle(StepRepr_Representation) rep = sdr->UsedRepresentation(); | |
1096 | ||
1097 | // abv 7 Oct 99: TRJ2: skip SDRs used only for defining SHAPE_ASPECT (validation properties) | |
1098 | // BUT ONLY if they have representation duplicated with other SDR, | |
1099 | // (SHAPE_ASPECT also used by some systems to define geometry) | |
1100 | Handle(StepRepr_PropertyDefinition) PD = sdr->Definition().PropertyDefinition(); | |
1101 | if ( ! PD.IsNull() ) { | |
1102 | Handle(StepRepr_ShapeAspect) SA = PD->Definition().ShapeAspect(); | |
1103 | if ( ! SA.IsNull() ) { | |
1104 | if(!IsNeedRepresentation(SA,rep,TP)) | |
1105 | return shbinder; | |
1106 | } | |
1107 | } | |
1108 | ||
1109 | #ifdef TRANSLOG | |
1110 | if (TP->TraceLevel() > 2) | |
1111 | sout<<" -- Actor : case shape_definition_representation."<<endl; | |
1112 | #endif | |
1113 | Handle(Transfer_Binder) binder = TP->Find(rep); | |
1114 | if (binder.IsNull()) binder = TP->Transferring(rep); | |
1115 | //:j2 if (!binder.IsNull()) return binder; | |
1116 | ||
1117 | // SDR designant des CDSR (lien implicite, via la UsedRepr) | |
1118 | ||
1119 | TopoDS_Compound Cund; | |
1120 | TopoDS_Shape OneResult; | |
1121 | BRep_Builder B; | |
1122 | B.MakeCompound (Cund); | |
1123 | Standard_Integer nsh = 0; | |
1124 | ||
1125 | //:j2 | |
1126 | shbinder = new TransferBRep_ShapeBinder; | |
1127 | TP->Bind ( start, shbinder ); //:j3 abv 23 Oct 98: rp1sd.stp: bind something to protect against loops | |
1128 | if (!binder.IsNull()) { | |
1129 | TopoDS_Shape theResult = TransferBRep::ShapeResult (binder); | |
1130 | if (!theResult.IsNull()) { | |
1131 | OneResult = theResult; | |
1132 | B.Add(Cund, theResult); | |
1133 | nsh ++; | |
1134 | shbinder->SetResult (theResult); | |
1135 | } | |
1136 | } | |
1137 | ||
1138 | // process subcomponents of assembly (CDSR) and hybrid models (SRR) | |
1139 | Interface_EntityIterator subs = graph.Shareds(start); | |
1140 | Handle(Standard_Type) tCDSR = STANDARD_TYPE(StepShape_ContextDependentShapeRepresentation); | |
1141 | Handle(Standard_Type) tSRR = STANDARD_TYPE(StepRepr_ShapeRepresentationRelationship); | |
1142 | Standard_Integer nbitem=0; | |
1143 | for (subs.Start();subs.More();subs.Next()) nbitem++; | |
1144 | Message_ProgressSentry PS ( TP->GetProgress(), "Sub", 0, nbitem, 1 ); | |
1145 | for (subs.Start(); subs.More() && PS.More(); subs.Next() ,PS.Next()) { | |
1146 | Handle(Standard_Transient) anitem = subs.Value(); | |
1147 | if ( anitem->DynamicType() != tCDSR && anitem->DynamicType() != tSRR ) continue; | |
1148 | // DeclareAndCast(StepShape_ContextDependentShapeRepresentation,anitem,subs.Value()); | |
1149 | // if (anitem.IsNull()) continue; | |
1150 | #ifdef TRANSLOG | |
1151 | if (TP->TraceLevel() > 1) | |
1152 | sout<<" -- Actor : Ent.n0 "<<TP->Model()->Number(start)<<" -> Shared Ent.no"<<TP->Model()->Number(anitem)<<endl; | |
1153 | #endif | |
1154 | ||
1155 | if (!TP->IsBound(anitem)) binder = TP->Transferring(anitem); | |
1156 | else binder = TP->Find(anitem); | |
1157 | TopoDS_Shape theResult = TransferBRep::ShapeResult (binder); | |
1158 | if (!theResult.IsNull()) { | |
1159 | OneResult = theResult; | |
1160 | B.Add(Cund, theResult); | |
1161 | nsh += 2; //abv 11.10.00: 2 instead of 1 in order to keep assembly structure | |
1162 | } | |
1163 | } | |
1164 | ||
1165 | if (nsh == 0) shbinder = new TransferBRep_ShapeBinder (Cund);//shbinder.Nullify(); | |
1166 | else if (nsh == 1) shbinder = new TransferBRep_ShapeBinder (OneResult); | |
1167 | else shbinder = new TransferBRep_ShapeBinder (Cund); | |
1168 | TP->Unbind( start ); //:j3: unbind start (let it be bound by TransferProcess) | |
1169 | return shbinder; | |
1170 | } | |
1171 | ||
1172 | //======================================================================= | |
1173 | //function : TransferEntity | |
1174 | //purpose : | |
1175 | //======================================================================= | |
1176 | ||
1177 | Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepGeom_GeometricRepresentationItem)& start, | |
1178 | const Handle(Transfer_TransientProcess)& TP, | |
1179 | const Standard_Boolean isManifold) | |
1180 | { | |
1181 | Handle(Message_Messenger) sout = TP->Messenger(); | |
1182 | Handle(TransferBRep_ShapeBinder) shbinder; | |
1183 | Standard_Boolean found = Standard_False; | |
1184 | StepToTopoDS_Builder myShapeBuilder; | |
1185 | TopoDS_Shape mappedShape; | |
1186 | Standard_Integer nbTPitems = TP->NbMapped(); | |
1187 | #ifdef TRANSLOG | |
1188 | OSD_Timer chrono; | |
1189 | if (TP->TraceLevel() > 2) | |
1190 | sout << "Begin transfer STEP -> CASCADE, Type " | |
1191 | << start->DynamicType()->Name() << endl; | |
1192 | chrono.Start(); | |
1193 | #endif | |
1194 | ||
1195 | //:S4136 | |
1196 | Handle(StepRepr_Representation) oldSRContext = mySRContext; | |
1197 | if ( mySRContext.IsNull() ) { // if no context, try to find it (ex: r0701_ug.stp #4790) | |
1198 | Handle(StepRepr_Representation) context = FindContext ( start, TP ); | |
1199 | if ( context.IsNull() ) { | |
1200 | TP->AddWarning ( start, "Entity with no unit context; default units taken" ); | |
1201 | ResetUnits(); | |
1202 | } | |
1203 | else PrepareUnits ( context, TP ); | |
1204 | } | |
1205 | myShapeBuilder.SetPrecision(myPrecision); | |
1206 | myShapeBuilder.SetMaxTol(myMaxTol); | |
b485ee79 KD |
1207 | |
1208 | // Start progress scope (no need to check if progress exists -- it is safe) | |
1209 | Message_ProgressSentry aPSentry(TP->GetProgress(), "Transfer stage", 0, 2, 1); | |
1210 | ||
7fd59977 | 1211 | try { |
1212 | OCC_CATCH_SIGNALS | |
1213 | if (start->IsKind(STANDARD_TYPE(StepShape_FacetedBrep))) { | |
1214 | myShapeBuilder.Init(GetCasted(StepShape_FacetedBrep, start), TP); | |
1215 | found = Standard_True; | |
1216 | } | |
1217 | else if (start->IsKind(STANDARD_TYPE(StepShape_BrepWithVoids))) { | |
1218 | myShapeBuilder.Init(GetCasted(StepShape_BrepWithVoids, start), TP); | |
1219 | found = Standard_True; | |
1220 | } | |
1221 | else if (start->IsKind(STANDARD_TYPE(StepShape_ManifoldSolidBrep))) { | |
1222 | myShapeBuilder.Init(GetCasted(StepShape_ManifoldSolidBrep, start), TP); | |
1223 | found = Standard_True; | |
1224 | } | |
1225 | else if (start->IsKind(STANDARD_TYPE(StepShape_ShellBasedSurfaceModel))) { | |
1226 | myShapeBuilder.Init(GetCasted(StepShape_ShellBasedSurfaceModel, start), TP, myNMTool); | |
1227 | found = Standard_True; | |
1228 | } | |
1229 | else if (start->IsKind(STANDARD_TYPE(StepShape_FacetedBrepAndBrepWithVoids))) { | |
1230 | myShapeBuilder.Init(GetCasted(StepShape_FacetedBrepAndBrepWithVoids, start), TP); | |
1231 | found = Standard_True; | |
1232 | } | |
1233 | else if (start->IsKind(STANDARD_TYPE(StepShape_GeometricSet))) { | |
38deba5d | 1234 | myShapeBuilder.Init(GetCasted(StepShape_GeometricSet, start), TP, this, isManifold); |
7fd59977 | 1235 | found = Standard_True; |
1236 | } | |
1237 | else if (start->IsKind(STANDARD_TYPE(StepShape_EdgeBasedWireframeModel))) { | |
1238 | myShapeBuilder.Init(GetCasted(StepShape_EdgeBasedWireframeModel, start), TP); | |
1239 | found = Standard_True; | |
1240 | } | |
1241 | else if (start->IsKind(STANDARD_TYPE(StepShape_FaceBasedSurfaceModel))) { | |
1242 | myShapeBuilder.Init(GetCasted(StepShape_FaceBasedSurfaceModel, start), TP); | |
1243 | found = Standard_True; | |
1244 | } | |
1245 | } | |
1246 | catch(Standard_Failure) { | |
1247 | TP->AddFail(start,"Exeption is raised. Entity was not translated."); | |
1248 | TP->Bind(start, shbinder); | |
1249 | return shbinder; | |
1250 | } | |
b485ee79 KD |
1251 | |
1252 | aPSentry.Next(); | |
7fd59977 | 1253 | |
1254 | if (found && myShapeBuilder.IsDone()) { | |
1255 | mappedShape = myShapeBuilder.Value(); | |
1256 | // Apply ShapeFix (on manifold shapes only. Non-manifold topology is processed separately: ssv; 13.11.2010) | |
1257 | if (isManifold) { | |
1258 | Handle(Standard_Transient) info; | |
1259 | mappedShape = | |
b485ee79 KD |
1260 | XSAlgo::AlgoContainer()->ProcessShape( mappedShape, myPrecision, myMaxTol, |
1261 | "read.step.resource.name", | |
1262 | "read.step.sequence", info, | |
1263 | TP->GetProgress() ); | |
7fd59977 | 1264 | XSAlgo::AlgoContainer()->MergeTransferInfo(TP, info, nbTPitems); |
1265 | } | |
1266 | } | |
1267 | found = !mappedShape.IsNull(); | |
1268 | if (found && shbinder.IsNull()) shbinder = new TransferBRep_ShapeBinder (mappedShape); | |
1269 | #ifdef TRANSLOG | |
1270 | chrono.Stop(); | |
1271 | if (TP->TraceLevel() > 2) | |
1272 | sout<<"End transfer STEP -> CASCADE :" << (found ? "OK" : " : no result")<<endl; | |
1273 | if (TP->TraceLevel() > 2) | |
1274 | chrono.Show(); | |
1275 | #endif | |
1276 | if ( oldSRContext.IsNull() && ! mySRContext.IsNull() ) //:S4136 | |
1277 | PrepareUnits ( oldSRContext, TP ); | |
1278 | TP->Bind(start, shbinder); | |
1279 | return shbinder; | |
1280 | } | |
1281 | ||
1282 | ||
1283 | //======================================================================= | |
1284 | //function : TransferEntity | |
1285 | //purpose : | |
1286 | //======================================================================= | |
1287 | ||
1288 | Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepRepr_MappedItem)& mapit, | |
1289 | const Handle(Transfer_TransientProcess)& TP) | |
1290 | { | |
1291 | Handle(TransferBRep_ShapeBinder) shbinder; | |
1292 | ||
1293 | // -------------------------------------------------------------- | |
1294 | // On se trouve ici dans un contexte " d'assemblage geometrique " | |
1295 | // - MappedItem | |
1296 | // -------------------------------------------------------------- | |
1297 | ||
1298 | //:S4136: abv 20 Apr 99: as1ug.stp: MAPPED_ITEM transformation computed | |
1299 | // taking into account units of origin and target SHAPE_REPRESENTATIONs | |
1300 | ||
1301 | // La Shape, et la mise en position | |
1302 | Handle(StepShape_ShapeRepresentation) maprep = Handle(StepShape_ShapeRepresentation):: | |
1303 | DownCast(mapit->MappingSource()->MappedRepresentation()); | |
1304 | //Handle(StepRepr_Representation) maprep = mapit->MappingSource()->MappedRepresentation(); | |
1305 | Standard_Boolean isBound = Standard_False; | |
1306 | Handle(Transfer_Binder) binder = TP->Find(maprep); | |
1307 | if (binder.IsNull()) binder = TransferEntity(maprep,TP,isBound); | |
1308 | shbinder = Handle(TransferBRep_ShapeBinder)::DownCast(binder); | |
1309 | if (shbinder.IsNull()) TP->AddWarning(mapit,"No Shape Produced"); | |
1310 | else { | |
1311 | TopoDS_Shape mappedShape = shbinder->Result(); | |
1312 | if ( ! mappedShape.IsNull() ) { | |
1313 | ||
1314 | // Positionnement : 2 formules | |
1315 | // 1/ Ax2 dans Source et comme Target : passage de Source a Target | |
1316 | // 2/ CartesianOperator3d comme Target : on applique | |
1317 | ||
1318 | gp_Trsf Trsf; | |
1319 | Standard_Boolean ok = Standard_False; | |
1320 | ||
1321 | Handle(StepGeom_CartesianTransformationOperator3d) CartOp = | |
1322 | Handle(StepGeom_CartesianTransformationOperator3d)::DownCast(mapit->MappingTarget()); | |
1323 | if ( ! CartOp.IsNull() ) { | |
1324 | ok = StepToGeom_MakeTransformation3d::Convert( CartOp, Trsf ); | |
1325 | } | |
1326 | else { | |
1327 | Handle(StepGeom_Axis2Placement3d) Origin = | |
1328 | Handle(StepGeom_Axis2Placement3d)::DownCast(mapit->MappingSource()->MappingOrigin()); | |
1329 | Handle(StepGeom_Axis2Placement3d) Target = | |
1330 | Handle(StepGeom_Axis2Placement3d)::DownCast(mapit->MappingTarget()); | |
1331 | if ( ! Origin.IsNull() && ! Target.IsNull() ) { | |
1332 | ok = Standard_True; | |
1333 | Handle(StepRepr_Representation) rep = mySRContext; // NOTE: copy of handle ! | |
1334 | ComputeTransformation ( Origin, Target, maprep, rep, TP, Trsf ); | |
1335 | ok = Standard_True; | |
1336 | } | |
1337 | } | |
1338 | ||
1339 | if ( ok ) ApplyTransformation ( mappedShape, Trsf ); | |
1340 | else TP->AddWarning (mapit,"Mapped Item, case not recognized, location ignored"); | |
1341 | ||
1342 | shbinder = new TransferBRep_ShapeBinder (mappedShape); | |
1343 | } | |
1344 | } | |
1345 | TP->Bind(mapit, shbinder); | |
1346 | return shbinder; | |
1347 | } | |
1348 | //======================================================================= | |
1349 | //function : TransferEntity | |
1350 | //purpose : | |
1351 | //======================================================================= | |
1352 | ||
1353 | Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepShape_FaceSurface)& fs, | |
1354 | const Handle(Transfer_TransientProcess)& TP) | |
1355 | { | |
1356 | ||
1357 | // Cas bien utile meme si non reconnu explicitement | |
1358 | Handle(TransferBRep_ShapeBinder) sb; | |
1359 | Standard_Integer nbTPitems = TP->NbMapped(); | |
1360 | try { | |
1361 | OCC_CATCH_SIGNALS | |
1362 | ||
1363 | StepToTopoDS_Tool myTool; | |
1364 | StepToTopoDS_DataMapOfTRI aMap; | |
1365 | ||
1366 | myTool.Init(aMap, TP); | |
1367 | StepToTopoDS_TranslateFace myTF; | |
1368 | myTF.SetPrecision(myPrecision); | |
1369 | myTF.SetMaxTol(myMaxTol); | |
1370 | ||
1371 | // Non-manifold topology is not processed here (ssv; 15.11.2010) | |
1372 | StepToTopoDS_NMTool dummyNMTool; | |
1373 | myTF.Init (fs, myTool, dummyNMTool); | |
1374 | Handle(StepRepr_Representation) oldSRContext = mySRContext; | |
1375 | if ( mySRContext.IsNull() ) { // if no context, try to find it (ex: r0701_ug.stp #4790) | |
1376 | Handle(StepRepr_Representation) context = FindContext ( fs, TP ); | |
1377 | if ( context.IsNull() ) { | |
1378 | TP->AddWarning ( fs, "Entity with no unit context; default units taken" ); | |
1379 | ResetUnits(); | |
1380 | } | |
1381 | else PrepareUnits ( context, TP ); | |
1382 | } | |
1383 | ||
1384 | // Apply ShapeFix | |
1385 | Handle(Transfer_Binder) binder = TP->Find (fs); | |
1386 | sb = Handle(TransferBRep_ShapeBinder)::DownCast ( binder ); | |
1387 | if ( ! sb.IsNull() && ! sb->Result().IsNull() ) { | |
1388 | TopoDS_Shape S = sb->Result(); | |
1389 | ||
1390 | Handle(Standard_Transient) info; | |
1391 | TopoDS_Shape shape = XSAlgo::AlgoContainer()->ProcessShape( S, myPrecision, myMaxTol, | |
b485ee79 KD |
1392 | "read.step.resource.name", |
1393 | "read.step.sequence", info, | |
1394 | TP->GetProgress() ); | |
7fd59977 | 1395 | // TopoDS_Shape shape = XSAlgo::AlgoContainer()->PerformFixShape( S, TP, myPrecision, myMaxTol ); |
1396 | if ( shape != S ) | |
1397 | sb->SetResult ( shape ); | |
1398 | ||
1399 | XSAlgo::AlgoContainer()->MergeTransferInfo(TP, info, nbTPitems); | |
1400 | } | |
1401 | ||
1402 | ||
1403 | if ( oldSRContext.IsNull() && ! mySRContext.IsNull() ) //:S4136 | |
1404 | PrepareUnits ( oldSRContext, TP ); | |
1405 | TP->Bind(fs, sb); | |
1406 | return sb; // TP->Find (start); | |
1407 | } | |
1408 | catch(Standard_Failure) | |
1409 | { | |
1410 | TP->AddFail(fs,"Exeption is raised. Entity was not translated."); | |
1411 | sb.Nullify(); | |
1412 | TP->Bind(fs, sb); | |
1413 | return sb; | |
1414 | } | |
1415 | } | |
1416 | //======================================================================= | |
1417 | //function : TransferShape | |
1418 | //purpose : | |
1419 | //======================================================================= | |
1420 | ||
1421 | Handle(Transfer_Binder) STEPControl_ActorRead::TransferShape(const Handle(Standard_Transient)& start, | |
1422 | const Handle(Transfer_TransientProcess)& TP, | |
1423 | const Standard_Boolean isManifold) | |
1424 | { | |
1425 | if (start.IsNull()) return NullResult(); | |
1426 | XSAlgo::AlgoContainer()->PrepareForTransfer(); | |
1427 | ||
1428 | // myContext.SetModel ( Handle(StepData_StepModel)::DownCast ( TP->Model() ) ); // for asking IsAP203? | |
1429 | ||
1430 | Handle(Message_Messenger) sout = TP->Messenger(); | |
1431 | #ifdef TRANSLOG | |
1432 | // POUR MISE AU POINT, a supprimer ensuite | |
1433 | // sout<<"STEP->Shape, ent n0 "<<TP->Model()->Number(start)<<" Level="<<TP->NestingLevel()<<endl; | |
1434 | if (TP->TraceLevel() > 1) | |
1435 | sout<<" -- Actor : Transfer Ent.n0 "<<TP->Model()->Number(start)<<" Type "<<start->DynamicType()->Name()<<endl; | |
1436 | #endif | |
1437 | ||
1438 | Handle(TransferBRep_ShapeBinder) shbinder; | |
1439 | ||
1440 | ||
1441 | // Product Definition Entities | |
1442 | // They should be treated with Design Manager | |
1443 | // case ShapeDefinitionRepresentation if ProductMode != ON | |
1444 | TCollection_AsciiString aProdMode = Interface_Static::CVal("read.step.product.mode"); | |
1445 | if(!aProdMode.IsEqual("ON") && | |
1446 | start->IsKind(STANDARD_TYPE(StepShape_ShapeDefinitionRepresentation))) | |
1447 | shbinder = OldWay(start,TP); | |
1448 | //skl | |
1449 | ||
1450 | else if(start->IsKind(STANDARD_TYPE(StepBasic_ProductDefinition))) { | |
1451 | Handle(StepBasic_ProductDefinition) PD = | |
1452 | Handle(StepBasic_ProductDefinition)::DownCast(start); | |
1453 | shbinder = TransferEntity(PD,TP); | |
1454 | } | |
1455 | ||
1456 | // NextAssemblyUsageOccurrence | |
1457 | else if (start->IsKind(STANDARD_TYPE(StepRepr_NextAssemblyUsageOccurrence))) { | |
1458 | Handle(StepRepr_NextAssemblyUsageOccurrence) NAUO = | |
1459 | Handle(StepRepr_NextAssemblyUsageOccurrence)::DownCast(start); | |
1460 | shbinder = TransferEntity(NAUO,TP); | |
1461 | } | |
1462 | //end skl | |
1463 | ||
1464 | // Shape Representation | |
1465 | else if (start->IsKind(STANDARD_TYPE(StepShape_ShapeRepresentation))) { | |
1466 | DeclareAndCast(StepShape_ShapeRepresentation,sr,start); | |
1467 | Standard_Boolean isBound = Standard_False; | |
1468 | shbinder = TransferEntity(sr,TP,isBound); | |
1469 | } | |
1470 | ||
1471 | // -------------------------------------------------------------- | |
1472 | // On se trouve ici aussi dans un contexte " d'assemblage geometrique " | |
1473 | // - ShapeRepresentationRelationship + Transformation ou non | |
1474 | // -------------------------------------------------------------- | |
1475 | ||
1476 | else if (start->IsKind(STANDARD_TYPE(StepShape_ContextDependentShapeRepresentation))) { | |
1477 | DeclareAndCast(StepShape_ContextDependentShapeRepresentation,CDSR,start); | |
1478 | shbinder = TransferEntity(CDSR,TP); | |
1479 | } | |
1480 | ||
1481 | else if (start->IsKind (STANDARD_TYPE(StepRepr_ShapeRepresentationRelationship)) ) { | |
1482 | // REPRESENTATION_RELATIONSHIP et la famille | |
1483 | ||
1484 | DeclareAndCast(StepRepr_ShapeRepresentationRelationship,und,start); | |
1485 | shbinder = TransferEntity(und,TP); | |
1486 | } | |
1487 | ||
1488 | else if (start->IsKind (STANDARD_TYPE(StepGeom_GeometricRepresentationItem)) ) { | |
1489 | // Here starts the entity to be treated : Shape Representation Subtype | |
1490 | // It can be also other Root entities | |
1491 | DeclareAndCast(StepGeom_GeometricRepresentationItem,git,start); | |
1492 | shbinder = TransferEntity(git, TP, isManifold); | |
1493 | } | |
1494 | else if (start->IsKind(STANDARD_TYPE(StepRepr_MappedItem))) { | |
1495 | DeclareAndCast(StepRepr_MappedItem,mapit,start); | |
1496 | shbinder= TransferEntity(mapit,TP); | |
1497 | } | |
1498 | else if (start->IsKind(STANDARD_TYPE(StepShape_FaceSurface))) { | |
1499 | DeclareAndCast(StepShape_FaceSurface,fs,start); | |
1500 | shbinder = TransferEntity(fs,TP); | |
1501 | } | |
1502 | ||
1503 | // if (!shbinder.IsNull()) TP->Bind(start,binder); | |
1504 | ||
1505 | return shbinder; | |
1506 | } | |
1507 | // ============================================================================ | |
1508 | // Method : STEPControl_ActorRead::PrepareUnits | |
1509 | // Purpose : Set the unit conversion factors | |
1510 | // ============================================================================ | |
1511 | ||
1512 | void STEPControl_ActorRead::PrepareUnits(const Handle(StepRepr_Representation)& rep, | |
1513 | const Handle(Transfer_TransientProcess)& TP) | |
1514 | { | |
1515 | mySRContext = rep; | |
1516 | ||
1517 | Standard_Integer stat1, stat2 = 0; // sera alimente par STEPControl_Unit | |
1518 | // DeclareAndCast(StepShape_ShapeRepresentation,sr,start); | |
1519 | if (rep.IsNull()) { | |
1520 | // TP->AddWarning(sr,"Not a ShapeRepresentation, default unit taken"); | |
1521 | ResetUnits(); | |
1522 | return; | |
1523 | } | |
1524 | ||
1525 | // Get Units Applied to this model | |
1526 | Handle(StepRepr_RepresentationContext) theRepCont = rep->ContextOfItems(); | |
1527 | if (theRepCont.IsNull()) { | |
1528 | TP->AddWarning(rep,"Bad RepresentationContext, default unit taken"); | |
1529 | ResetUnits(); | |
1530 | return; | |
1531 | } | |
1532 | ||
1533 | // -------------------------------------------------- | |
1534 | // Complex ENTITY : GeometricRepresentationContext && | |
1535 | // GlobalUnitAssignedContext | |
1536 | // -------------------------------------------------- | |
1537 | ||
1538 | STEPConstruct_UnitContext myUnit; | |
1539 | Handle(StepRepr_GlobalUnitAssignedContext) theGUAC; | |
1540 | Handle(StepRepr_GlobalUncertaintyAssignedContext) aTol; | |
1541 | ||
1542 | if (theRepCont->IsKind(STANDARD_TYPE(StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext))) { | |
1543 | DeclareAndCast(StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext, theGRCAGAUC,theRepCont); | |
1544 | theGUAC = theGRCAGAUC->GlobalUnitAssignedContext(); | |
1545 | // TP->AddWarning(theRepCont,"No Length Uncertainty, last defined one is taken"); | |
1546 | } | |
1547 | ||
1548 | // ---------------------------------------------------- | |
1549 | // Complex ENTITY : GeometricRepresentationContext && | |
1550 | // GlobalUnitAssignedContext && | |
1551 | // GlobalUncertaintyAssignedContext | |
1552 | // ---------------------------------------------------- | |
1553 | ||
1554 | if (theRepCont->IsKind(STANDARD_TYPE(StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx))) { | |
1555 | DeclareAndCast(StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx, | |
1556 | theGRCAGAUC,theRepCont); | |
1557 | theGUAC = theGRCAGAUC->GlobalUnitAssignedContext(); | |
1558 | aTol = theGRCAGAUC->GlobalUncertaintyAssignedContext(); | |
1559 | } | |
1560 | ||
1561 | ||
1562 | // ---------------------------------------------------- | |
1563 | // Decoding and Setting the Values | |
1564 | // ---------------------------------------------------- | |
1565 | ||
1566 | if (!theGUAC.IsNull()) { | |
1567 | stat1 = myUnit.ComputeFactors(theGUAC); | |
1568 | Standard_Integer anglemode = Interface_Static::IVal("step.angleunit.mode"); | |
1569 | Standard_Real angleFactor = ( anglemode == 0 ? myUnit.PlaneAngleFactor() : | |
c6541a0c | 1570 | anglemode == 1 ? 1. : M_PI/180. ); |
7fd59977 | 1571 | UnitsMethods::InitializeFactors(myUnit.LengthFactor(), |
1572 | angleFactor, | |
1573 | myUnit.SolidAngleFactor()); | |
1574 | if (stat1 != 0) TP->AddWarning (theRepCont,myUnit.StatusMessage(stat1)); | |
1575 | } | |
1576 | ||
1577 | if (!aTol.IsNull()) { | |
1578 | stat2 = myUnit.ComputeTolerance (aTol); | |
1579 | if (stat2 != 0) TP->AddWarning (theRepCont,myUnit.StatusMessage(stat2)); | |
1580 | } | |
1581 | ||
1582 | // myPrecision = Precision::Confusion(); | |
1583 | if (Interface_Static::IVal("read.precision.mode") == 1) //:i1 gka S4136 05.04.99 | |
1584 | myPrecision = Interface_Static::RVal("read.precision.val"); | |
1585 | else if (myUnit.HasUncertainty()) | |
1586 | myPrecision = myUnit.Uncertainty() * myUnit.LengthFactor(); | |
1587 | else { | |
1588 | TP->AddWarning(theRepCont,"No Length Uncertainty, value of read.precision.val is taken"); | |
1589 | myPrecision = Interface_Static::RVal("read.precision.val"); | |
1590 | } | |
1591 | myMaxTol = Max ( myPrecision, Interface_Static::RVal("read.maxprecision.val") ); | |
1592 | // Assign uncertainty | |
1593 | // Interface_Static::SetRVal("lastpreci",UpdatedValue); | |
1594 | #ifdef TRANSLOG | |
1595 | if (TP->TraceLevel() > 1) | |
1596 | TP->Messenger() <<" Cc1ToTopoDS : Length Unit = "<<myUnit.LengthFactor()<<" Tolerance CASCADE = "<<myPrecision<<endl; | |
1597 | #endif | |
1598 | } | |
1599 | ||
1600 | //======================================================================= | |
1601 | //function : ResetUnits | |
1602 | //purpose : | |
1603 | //======================================================================= | |
1604 | ||
1605 | void STEPControl_ActorRead::ResetUnits () | |
1606 | { | |
1607 | UnitsMethods::InitializeFactors ( 1, 1, 1 ); | |
1608 | myPrecision = Interface_Static::RVal("read.precision.val"); | |
1609 | myMaxTol = Max ( myPrecision, Interface_Static::RVal("read.maxprecision.val") ); | |
1610 | } | |
1611 | ||
1612 | //======================================================================= | |
1613 | //function : ComputeTransformation | |
1614 | //purpose : | |
1615 | //======================================================================= | |
1616 | ||
1617 | //:S4136 abv 20 Apr 99: as1ug.stp: compute transformation taking units into account | |
1618 | Standard_Boolean STEPControl_ActorRead::ComputeTransformation (const Handle(StepGeom_Axis2Placement3d) &Origin, | |
1619 | const Handle(StepGeom_Axis2Placement3d) &Target, | |
1620 | const Handle(StepRepr_Representation) &OrigContext, | |
1621 | const Handle(StepRepr_Representation) &TargContext, | |
1622 | const Handle(Transfer_TransientProcess) &TP, | |
1623 | gp_Trsf &Trsf) | |
1624 | { | |
1625 | Trsf = gp_Trsf(); // reinit | |
1626 | if ( Origin.IsNull() || Target.IsNull() ) return Standard_False; | |
1627 | ||
1628 | //:abv 31.10.01: TEST_MCI_2.step: check that Ax1 and Ax2 belong to | |
1629 | // corresponding reps and fix case of inversion error | |
1630 | Handle(StepGeom_Axis2Placement3d) org = Origin; | |
1631 | Handle(StepGeom_Axis2Placement3d) trg = Target; | |
1632 | Standard_Integer code1=0, code2=0, i; | |
1633 | for ( i=1; code1 != 1 && i <= OrigContext->NbItems(); i++ ) { | |
1634 | if ( OrigContext->ItemsValue(i) == org ) code1 = 1; | |
1635 | else if ( OrigContext->ItemsValue(i) == trg ) code1 = -1; | |
1636 | } | |
1637 | for ( i=1; code2 != 1 && i <= TargContext->NbItems(); i++ ) { | |
1638 | if ( TargContext->ItemsValue(i) == org ) code2 = -1; | |
1639 | else if ( TargContext->ItemsValue(i) == trg ) code2 = 1; | |
1640 | } | |
1641 | if ( code1 != 1 && code2 != 1 ) { | |
1642 | if ( code1 == -1 && code2 == -1 ) { | |
1643 | Handle(StepGeom_Axis2Placement3d) swp = org; org = trg; trg = swp; | |
1644 | TP->AddWarning ( org, "Axis placements are swapped in SRRWT; corrected" ); | |
1645 | } | |
1646 | else { | |
1647 | TP->AddWarning ( ( code1 == 1 ? trg : org ), | |
1648 | "Axis placement used by SRRWT does not belong to corresponding representation" ); | |
1649 | } | |
1650 | } | |
1651 | ||
1652 | // translate axis_placements taking units into account | |
1653 | Handle(StepRepr_Representation) oldSRContext = mySRContext; | |
1654 | if ( OrigContext != oldSRContext ) PrepareUnits(OrigContext,TP); | |
1655 | Handle(Geom_Axis2Placement) theOrig; | |
1656 | StepToGeom_MakeAxis2Placement::Convert(org,theOrig); | |
1657 | if ( TargContext != OrigContext ) PrepareUnits(TargContext,TP); | |
1658 | Handle(Geom_Axis2Placement) theTarg; | |
1659 | StepToGeom_MakeAxis2Placement::Convert(trg,theTarg); | |
1660 | if ( oldSRContext != TargContext ) PrepareUnits(oldSRContext,TP); | |
bd05fabf | 1661 | |
7fd59977 | 1662 | gp_Ax3 ax3Orig(theOrig->Ax2()); |
1663 | gp_Ax3 ax3Targ(theTarg->Ax2()); | |
d2a98d71 | 1664 | |
bd05fabf S |
1665 | // ne pas se tromper de sens ! |
1666 | Trsf.SetTransformation(ax3Targ, ax3Orig); | |
7fd59977 | 1667 | return Trsf.Form() != gp_Identity; |
1668 | } | |
1669 | ||
1670 | //======================================================================= | |
1671 | //function : ReadSRRWT | |
1672 | //purpose : | |
1673 | //======================================================================= | |
1674 | ||
1675 | //:j2 abv 22 Oct 98: auxiliary function: reading transformation from SRRWT | |
1676 | Standard_Boolean STEPControl_ActorRead::ComputeSRRWT (const Handle(StepRepr_RepresentationRelationship) &SRR, | |
1677 | const Handle(Transfer_TransientProcess) &TP, | |
1678 | gp_Trsf &Trsf) | |
1679 | { | |
1680 | Trsf = gp_Trsf(); // init | |
1681 | ||
1682 | DeclareAndCast(StepRepr_ShapeRepresentationRelationshipWithTransformation,srwt,SRR); | |
1683 | if ( srwt.IsNull() ) return Standard_False; | |
1684 | ||
1685 | StepRepr_Transformation SelectTrans = srwt->TransformationOperator(); | |
1686 | ||
1687 | // cartesian transformation | |
1688 | Handle(StepGeom_CartesianTransformationOperator3d) CartOp = | |
1689 | Handle(StepGeom_CartesianTransformationOperator3d)::DownCast(SelectTrans.Value()); | |
1690 | if ( ! CartOp.IsNull() ) { | |
1691 | // reset units (by Rep2 - ?) | |
1692 | Handle(StepRepr_Representation) oldSRContext = mySRContext; | |
1693 | if ( SRR->Rep2() != oldSRContext ) PrepareUnits(SRR->Rep2(),TP); | |
1694 | StepToGeom_MakeTransformation3d::Convert( CartOp, Trsf ); | |
1695 | if ( SRR->Rep2() != oldSRContext ) PrepareUnits(oldSRContext,TP); | |
1696 | return Trsf.Form() != gp_Identity; | |
1697 | } | |
1698 | ||
1699 | // item-defined transformation | |
1700 | Handle(StepRepr_ItemDefinedTransformation) ItemDef = | |
1701 | SelectTrans.ItemDefinedTransformation(); | |
1702 | if ( ItemDef.IsNull() ) return Standard_False; | |
1703 | ||
1704 | Handle(StepGeom_Axis2Placement3d) Ax1 = | |
1705 | Handle(StepGeom_Axis2Placement3d)::DownCast(ItemDef->TransformItem1()); | |
1706 | Handle(StepGeom_Axis2Placement3d) Ax2 = | |
1707 | Handle(StepGeom_Axis2Placement3d)::DownCast(ItemDef->TransformItem2()); | |
1708 | if ( Ax1.IsNull() || Ax2.IsNull() ) return Standard_False; | |
1709 | return ComputeTransformation ( Ax1, Ax2, SRR->Rep1(), SRR->Rep2(), TP, Trsf); | |
1710 | } | |
1711 | ||
1712 | //======================================================================= | |
1713 | // Method : closeIDEASShell | |
1714 | // Purpose : Attempts to close the passed Shell with the passed closing | |
1715 | // Shells. Cuts redundant Faces from the closing Shells if any | |
1716 | //======================================================================= | |
1717 | ||
1718 | TopoDS_Shell STEPControl_ActorRead::closeIDEASShell(const TopoDS_Shell& shell, | |
1719 | const TopTools_ListOfShape& closingShells) { | |
1720 | ||
1721 | // Make Shell to provide closeness adjustments | |
1722 | TopoDS_Shell result; | |
1723 | BRep_Builder brepBuilder; | |
1724 | brepBuilder.MakeShell(result); | |
1725 | ||
1726 | // Firstly, add all existing faces to the new Shell | |
1727 | TopExp_Explorer currentFExp(shell, TopAbs_FACE); | |
1728 | for ( ; currentFExp.More(); currentFExp.Next() ) { | |
1729 | TopoDS_Face currentFace = TopoDS::Face( currentFExp.Current() ); | |
1730 | brepBuilder.Add(result, currentFace); | |
1731 | } | |
1732 | ||
1733 | TopTools_ListIteratorOfListOfShape itL(closingShells); | |
1734 | TopTools_ListOfShape closingFaces; | |
1735 | ||
1736 | // Then add the closing faces | |
1737 | for ( ; itL.More(); itL.Next() ) { | |
1738 | TopoDS_Shape currentClosing = itL.Value(); | |
1739 | TopExp_Explorer faceExp(currentClosing, TopAbs_FACE); | |
1740 | ||
1741 | for ( ; faceExp.More(); faceExp.Next() ) { | |
1742 | TopoDS_Face currentFace = TopoDS::Face( faceExp.Current() ); | |
1743 | brepBuilder.Add(result, currentFace); | |
1744 | // Store each added closing face for subsequent processing | |
1745 | closingFaces.Append(currentFace); | |
1746 | } | |
1747 | } | |
1748 | ||
1749 | // Check if the result is closed | |
1750 | BRepCheck_Shell checker( TopoDS::Shell(result) ); | |
1751 | BRepCheck_Status checkStatus = checker.Closed(); | |
1752 | if (checkStatus == BRepCheck_NoError) | |
1753 | result.Closed(Standard_True); | |
1754 | else | |
1755 | return shell; // Cannot close this shell, skip it so... | |
1756 | ||
1757 | // Try to remove redundant Faces | |
1758 | for ( itL.Initialize(closingFaces); itL.More(); itL.Next() ) { | |
1759 | TopoDS_Face currentFace = TopoDS::Face( itL.Value() ); | |
1760 | // Remove face to see if Shell is still closed | |
1761 | brepBuilder.Remove(result, currentFace); | |
1762 | BRepCheck_Shell subChecker( TopoDS::Shell(result) ); | |
1763 | BRepCheck_Status subCheckStatus = subChecker.Closed(); | |
1764 | // If Shell becomes open, just put the deleted face back | |
1765 | if (subCheckStatus != BRepCheck_NoError) | |
1766 | brepBuilder.Add(result, currentFace); | |
1767 | else { | |
1768 | #ifdef DEB | |
1769 | cout << "Redundant closing face detected: REMOVED from shell"; | |
1770 | #endif | |
1771 | } | |
1772 | } | |
1773 | ||
1774 | return result; | |
1775 | ||
1776 | } | |
1777 | ||
1778 | //======================================================================= | |
1779 | // Method : computeIDEASClosings | |
1780 | // Purpose : For each Shell from the compound passed (comp), find all | |
1781 | // non-manifold adjacent Shells and put the results into | |
1782 | // the passed map (shellClosingMap) | |
1783 | //======================================================================= | |
1784 | ||
1785 | void STEPControl_ActorRead::computeIDEASClosings(const TopoDS_Compound& comp, | |
1786 | TopTools_IndexedDataMapOfShapeListOfShape& shellClosingsMap) { | |
1787 | TopExp_Explorer shellExpA(comp, TopAbs_SHELL); | |
1788 | ||
1789 | for ( ; shellExpA.More(); shellExpA.Next() ) { | |
1790 | TopoDS_Shape shellA = shellExpA.Current(); | |
1791 | TopExp_Explorer shellExpB(comp, TopAbs_SHELL); | |
1792 | TopTools_ListOfShape closingShells; | |
1793 | ||
1794 | for ( ; shellExpB.More(); shellExpB.Next() ) { | |
1795 | TopoDS_Shape shellB = shellExpB.Current(); | |
1796 | if ( shellA.IsSame(shellB) ) | |
1797 | continue; | |
1798 | // Check whether ShellB is non-manifold and adjacent to ShellA. | |
1799 | // If so, ShellA has a chance to be closed with ShellB | |
1800 | if ( myNMTool.IsSuspectedAsClosing(shellA, shellB) ) | |
1801 | closingShells.Append(shellB); | |
1802 | } | |
1803 | ||
1804 | if ( !closingShells.IsEmpty() ) | |
1805 | shellClosingsMap.Add(shellA, closingShells); | |
1806 | } | |
1807 | ||
1808 | } |