projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0025153: Retrieval of arguments of selection crashes the application
[occt.git] / src / STEPControl / STEPControl_ActorRead.cxx
CommitLineData
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 135static 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		 193namespace {
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
205STEPControl_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
212Standard_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
277Handle(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// ============================================================================
310static 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// ============================================================================
321static 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
341static 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
364static 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
400static 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
652Handle(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
741Handle(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
915Handle(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
981Handle(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
1048static 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
1088Handle(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
1177Handle(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))) {
1234 myShapeBuilder.Init(GetCasted(StepShape_GeometricSet, start), TP);
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
1288Handle(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
1353Handle(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
1421Handle(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
1512void 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
1605void 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
1618Standard_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
1676Standard_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
1718TopoDS_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
1785void 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}
Open CASCADE Technology repository