0027772: Foundation Classes - define Standard_Boolean using C++ type "bool" instead...
[occt.git] / src / STEPControl / STEPControl_Reader.cxx
1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
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
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.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14
15 #include <Interface_EntityIterator.hxx>
16 #include <Interface_Graph.hxx>
17 #include <Interface_ShareFlags.hxx>
18 #include <Interface_Static.hxx>
19 #include <StepBasic_ApplicationContext.hxx>
20 #include <StepBasic_ConversionBasedUnit.hxx>
21 #include <StepBasic_DocumentProductEquivalence.hxx>
22 #include <StepBasic_HArray1OfNamedUnit.hxx>
23 #include <StepBasic_LengthMeasureWithUnit.hxx>
24 #include <StepBasic_MeasureWithUnit.hxx>
25 #include <StepBasic_NamedUnit.hxx>
26 #include <StepBasic_PlaneAngleMeasureWithUnit.hxx>
27 #include <StepBasic_ProductDefinition.hxx>
28 #include <StepBasic_ProductDefinitionContext.hxx>
29 #include <StepBasic_ProductDefinitionFormation.hxx>
30 #include <StepBasic_ProductDefinitionFormationRelationship.hxx>
31 #include <StepBasic_ProductDefinitionWithAssociatedDocuments.hxx>
32 #include <StepBasic_SiPrefix.hxx>
33 #include <StepBasic_SiUnit.hxx>
34 #include <StepBasic_SiUnitAndLengthUnit.hxx>
35 #include <StepBasic_SiUnitAndPlaneAngleUnit.hxx>
36 #include <StepBasic_SiUnitAndSolidAngleUnit.hxx>
37 #include <StepBasic_SiUnitName.hxx>
38 #include <StepBasic_SolidAngleMeasureWithUnit.hxx>
39 #include <StepBasic_SolidAngleUnit.hxx>
40 #include <STEPConstruct_UnitContext.hxx>
41 #include <STEPControl_Controller.hxx>
42 #include <STEPControl_Reader.hxx>
43 #include <StepData_StepModel.hxx>
44 #include <StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext.hxx>
45 #include <StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.hxx>
46 #include <StepRepr_GlobalUncertaintyAssignedContext.hxx>
47 #include <StepRepr_GlobalUnitAssignedContext.hxx>
48 #include <StepRepr_MappedItem.hxx>
49 #include <StepRepr_NextAssemblyUsageOccurrence.hxx>
50 #include <StepRepr_ProductDefinitionShape.hxx>
51 #include <StepRepr_PropertyDefinition.hxx>
52 #include <StepRepr_RepresentationContext.hxx>
53 #include <StepRepr_RepresentationMap.hxx>
54 #include <StepRepr_RepresentationRelationship.hxx>
55 #include <StepRepr_ShapeAspect.hxx>
56 #include <StepShape_ManifoldSolidBrep.hxx>
57 #include <StepShape_ShapeDefinitionRepresentation.hxx>
58 #include <StepShape_ShapeRepresentation.hxx>
59 #include <StepShape_ShellBasedSurfaceModel.hxx>
60 #include <TCollection_AsciiString.hxx>
61 #include <TColStd_Array1OfAsciiString.hxx>
62 #include <TColStd_Array1OfReal.hxx>
63 #include <TColStd_HSequenceOfTransient.hxx>
64 #include <TColStd_MapOfAsciiString.hxx>
65 #include <TColStd_SequenceOfAsciiString.hxx>
66 #include <Transfer_TransientProcess.hxx>
67 #include <XSControl_Controller.hxx>
68 #include <XSControl_TransferReader.hxx>
69 #include <XSControl_WorkSession.hxx>
70
71 //=======================================================================
72 //function : STEPControl_Reader
73 //purpose  : 
74 //=======================================================================
75 STEPControl_Reader::STEPControl_Reader ()
76 {
77   STEPControl_Controller::Init();
78   SetNorm ("STEP");
79 }
80
81 //=======================================================================
82 //function : STEPControl_Reader
83 //purpose  : 
84 //=======================================================================
85
86 STEPControl_Reader::STEPControl_Reader
87   (const Handle(XSControl_WorkSession)& WS, const Standard_Boolean scratch)
88 {
89   STEPControl_Controller::Init();
90   SetWS (WS,scratch);
91   SetNorm ("STEP");
92 }
93
94 //=======================================================================
95 //function : StepModel
96 //purpose  : 
97 //=======================================================================
98
99 Handle(StepData_StepModel) STEPControl_Reader::StepModel () const
100 {
101   return Handle(StepData_StepModel)::DownCast(Model());
102 }
103
104 //=======================================================================
105 //function : TransferRoot
106 //purpose  : 
107 //=======================================================================
108
109 Standard_Boolean STEPControl_Reader::TransferRoot (const Standard_Integer num)
110 {
111   return TransferOneRoot (num);
112 }
113
114 //=======================================================================
115 //function : NbRootsForTransfer
116 //purpose  : 
117 //=======================================================================
118
119 Standard_Integer STEPControl_Reader::NbRootsForTransfer() 
120 {
121   if (therootsta) return theroots.Length();
122   therootsta = Standard_True;
123
124   //theroots.Clear();
125   Standard_Integer nb = Model()->NbEntities();
126   for (Standard_Integer i = 1; i <= nb; i ++) {
127     Handle(Standard_Transient) ent = Model()->Value(i);
128     if (Interface_Static::IVal("read.step.all.shapes") == 1) {
129       // Special case to read invalid shape_representation without links to shapes.
130       if (ent->IsKind(STANDARD_TYPE(StepShape_ManifoldSolidBrep))) {
131         Interface_EntityIterator aShareds = WS()->Graph().Sharings(ent);
132         if (!aShareds.More()) {
133           theroots.Append(ent);
134           WS()->TransferReader()->TransientProcess()->RootsForTransfer()->Append(ent);
135         }
136       }
137       if (ent->IsKind(STANDARD_TYPE(StepShape_ShellBasedSurfaceModel))) {
138         Interface_EntityIterator aShareds = WS()->Graph().Sharings(ent);
139         if (!aShareds.More()) {
140           theroots.Append(ent);
141           WS()->TransferReader()->TransientProcess()->RootsForTransfer()->Append(ent);
142         }
143       }
144     }
145     if(ent->IsKind(STANDARD_TYPE(StepBasic_ProductDefinition))) {
146       // PTV 31.01.2003 TRJ11 exclude Product Definition With Associated Document from roots
147       if (ent->IsKind(STANDARD_TYPE(StepBasic_ProductDefinitionWithAssociatedDocuments))) {
148         // check if PDWAD-> PDF <-Document_Product_Equivalence.
149         Standard_Boolean iSexclude = Standard_False;
150         Handle(StepBasic_ProductDefinitionWithAssociatedDocuments) PDWAD =
151           Handle(StepBasic_ProductDefinitionWithAssociatedDocuments)::DownCast(ent);
152         Interface_EntityIterator PDWADsubs = WS()->Graph().Shareds(PDWAD);
153         for (PDWADsubs.Start(); PDWADsubs.More(); PDWADsubs.Next()) {
154           if ( !PDWADsubs.Value()->IsKind(STANDARD_TYPE(StepBasic_ProductDefinitionFormation)))
155             continue;
156           Handle(StepBasic_ProductDefinitionFormation) localPDF = 
157             Handle(StepBasic_ProductDefinitionFormation)::DownCast(PDWADsubs.Value());
158           Interface_EntityIterator PDFsubs = WS()->Graph().Sharings(localPDF);
159           for( PDFsubs.Start(); PDFsubs.More(); PDFsubs.Next() )
160             if (PDFsubs.Value()->IsKind(STANDARD_TYPE(StepBasic_DocumentProductEquivalence))) {
161               iSexclude = Standard_True;
162               break;
163             }
164           if (iSexclude)
165             break;
166         }
167         if (iSexclude) {
168 #ifdef OCCT_DEBUG
169           cout << "Warning: STEPControl_Reader::NbRootsForTransfer exclude PDWAD from roots" << endl;
170 #endif
171           continue;
172         }
173       }
174       Handle(StepBasic_ProductDefinition) PD = 
175         Handle(StepBasic_ProductDefinition)::DownCast(ent);
176       Standard_Boolean IsRoot = Standard_True;
177       const Interface_Graph& graph = WS()->Graph();
178       // determinate roots used NextAssemblyUsageOccurrence
179       Interface_EntityIterator subs = graph.Sharings(PD);
180       for(subs.Start(); subs.More(); subs.Next()) {
181         Handle(StepRepr_NextAssemblyUsageOccurrence) NAUO = 
182           Handle(StepRepr_NextAssemblyUsageOccurrence)::DownCast(subs.Value());
183         if (NAUO.IsNull()) continue;
184         if (PD==NAUO->RelatedProductDefinition()) IsRoot=Standard_False;
185       }
186       // determinate roots used ProductDefinitionContext
187       if(IsRoot) {
188         const char *str1 = Interface_Static::CVal("read.step.product.context");
189         Standard_Integer ICS = Interface_Static::IVal("read.step.product.context");
190         if(ICS>1) {
191           subs = graph.Shareds(PD);
192           for(subs.Start(); subs.More(); subs.Next()) {
193             Handle(StepBasic_ProductDefinitionContext) PDC = 
194               Handle(StepBasic_ProductDefinitionContext)::DownCast(subs.Value());
195             if (PDC.IsNull()) continue;
196             const char *str2 = PDC->LifeCycleStage()->String().ToCString();
197             const char *str3 = PDC->Name()->String().ToCString();
198             if( !( strcasecmp(str1,str2)==0 || strcasecmp(str1,str3)==0 ) )
199               IsRoot=Standard_False;
200           }
201         }
202       }
203       // determinate roots used ProductDefinitionFormationRelationship
204       //subs = graph.Shareds(PD);
205       //for(subs.Start(); subs.More(); subs.Next()) {
206       //  Handle(StepBasic_ProductDefinitionFormation) PDF = 
207       //    Handle(StepBasic_ProductDefinitionFormation)::DownCast(subs.Value());
208       //  if (PDF.IsNull()) continue;
209       //  Interface_EntityIterator subs1 = graph.Sharings(PDF);
210       //  for(subs1.Start(); subs1.More(); subs1.Next()) {
211       //    Handle(StepBasic_ProductDefinitionFormationRelationship) PDFR = 
212       //      Handle(StepBasic_ProductDefinitionFormationRelationship)::DownCast(subs1.Value());
213       //    if (PDFR.IsNull()) continue;
214       //    if (PDF==PDFR->RelatedProductDefinition()) IsRoot=Standard_False;
215       //  }
216       //}
217       if (IsRoot) {
218         theroots.Append(ent);
219         WS()->TransferReader()->TransientProcess()->RootsForTransfer()->Append(ent);
220       }
221     }
222     TCollection_AsciiString aProdMode = Interface_Static::CVal("read.step.product.mode");
223     if(!aProdMode.IsEqual("ON")) {
224       if(ent->IsKind(STANDARD_TYPE(StepShape_ShapeDefinitionRepresentation))) {
225         Standard_Boolean IsRoot = Standard_True;
226         Handle(StepShape_ShapeDefinitionRepresentation) SDR =
227           Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(ent);
228         Handle(StepRepr_PropertyDefinition) PropDef = SDR->Definition().PropertyDefinition();
229         if(!PropDef.IsNull()) {
230           Handle(StepBasic_ProductDefinition) PD = PropDef->Definition().ProductDefinition();
231           if(!PD.IsNull()) IsRoot = Standard_False;
232           if(IsRoot) {
233             Handle(StepRepr_ShapeAspect) SA = PropDef->Definition().ShapeAspect();
234             if(!SA.IsNull()) {
235               Handle(StepRepr_ProductDefinitionShape) PDS = SA->OfShape();
236               PD = PDS->Definition().ProductDefinition();
237               if(!PD.IsNull()) IsRoot = Standard_False;
238             }
239           }
240           if(IsRoot) {
241             Handle(StepRepr_NextAssemblyUsageOccurrence) NAUO =
242               Handle(StepRepr_NextAssemblyUsageOccurrence)::DownCast(PropDef->Definition().ProductDefinitionRelationship());
243             if(!NAUO.IsNull()) IsRoot = Standard_False;
244           }
245           if(IsRoot) {
246             Handle(StepShape_ShapeRepresentation) SR =
247               Handle(StepShape_ShapeRepresentation)::DownCast(SDR->UsedRepresentation());
248             if(SR.IsNull()) IsRoot = Standard_False;
249           }
250         }
251         if(IsRoot) {
252           theroots.Append(ent);
253           WS()->TransferReader()->TransientProcess()->RootsForTransfer()->Append(ent);
254         }
255       }
256       if(ent->IsKind(STANDARD_TYPE(StepShape_ShapeRepresentation))) {
257         Standard_Boolean IsRoot = Standard_True;
258         Handle(StepShape_ShapeRepresentation) SR =
259           Handle(StepShape_ShapeRepresentation)::DownCast(ent);
260         const Interface_Graph& graph = WS()->Graph();
261         Interface_EntityIterator subs = graph.Sharings(SR);
262         for(subs.Start(); subs.More() && IsRoot; subs.Next()) {
263           Handle(StepShape_ShapeDefinitionRepresentation) SDR = 
264             Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(subs.Value());
265           if(!SDR.IsNull()) IsRoot = Standard_False;
266           if(IsRoot) {
267             Handle(StepRepr_RepresentationRelationship) RR =
268               Handle(StepRepr_RepresentationRelationship)::DownCast(subs.Value());
269             if(!RR.IsNull()) {
270               Handle(StepShape_ShapeRepresentation) SR2 =
271                 Handle(StepShape_ShapeRepresentation)::DownCast(RR->Rep1());
272               if(SR==SR2)
273                 SR2 = Handle(StepShape_ShapeRepresentation)::DownCast(RR->Rep2());
274               Interface_EntityIterator subs2 = graph.Sharings(SR2);
275               for(subs2.Start(); subs2.More(); subs2.Next()) {
276                 Handle(StepShape_ShapeDefinitionRepresentation) SDR2 = 
277                   Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(subs2.Value());
278                 if(!SDR2.IsNull()) IsRoot = Standard_False;
279                 //else {
280                 //  if(SR==SRR->Rep2()) IsRoot = Standard_False;
281                 //}
282               }
283             }
284           }
285           if(IsRoot) {
286             Handle(StepRepr_RepresentationMap) RM =
287               Handle(StepRepr_RepresentationMap)::DownCast(subs.Value());
288             if(!RM.IsNull()) {
289               Interface_EntityIterator subs2 = graph.Sharings(RM);
290               for(subs2.Start(); subs2.More(); subs2.Next()) {
291                 Handle(StepRepr_MappedItem) MI = Handle(StepRepr_MappedItem)::DownCast(subs2.Value());
292                 if(!MI.IsNull()) {
293                   Interface_EntityIterator subs3 = graph.Sharings(MI);
294                   for(subs3.Start(); subs3.More(); subs3.Next()) {
295                     Handle(StepShape_ShapeRepresentation) SR2 =
296                       Handle(StepShape_ShapeRepresentation)::DownCast(subs3.Value());
297                     if(!SR2.IsNull()) IsRoot = Standard_False;
298                   }
299                 }
300               }
301             }
302           }
303         }
304         if(IsRoot) {
305           theroots.Append(ent);
306           WS()->TransferReader()->TransientProcess()->RootsForTransfer()->Append(ent);
307         }
308       }
309     }
310
311   }
312
313
314   return theroots.Length();
315 }
316
317 //=======================================================================
318 //function : FileUnits
319 //purpose  : 
320 //=======================================================================
321
322 void STEPControl_Reader::FileUnits( TColStd_SequenceOfAsciiString& theUnitLengthNames,
323                                    TColStd_SequenceOfAsciiString& theUnitAngleNames,
324                                    TColStd_SequenceOfAsciiString& theUnitSolidAngleNames) 
325 {
326   Standard_Integer nbroots = NbRootsForTransfer();
327   if(!nbroots)
328     return;
329   enum
330   {
331     LENGTH = 0,
332     ANLGE =  1,
333     SOLID_ANGLE = 2
334   };
335   const Interface_Graph& graph = WS()->Graph();
336   TColStd_MapOfAsciiString aMapUnits[3];
337
338   for(Standard_Integer i = 1; i <= nbroots; i++)
339   {
340     Handle(Standard_Transient) anEnt = theroots(i);
341     Standard_Integer num   = graph.EntityNumber(anEnt);
342     if(!num )
343       continue;
344     Handle(StepBasic_ProductDefinition) aProdDef = 
345       Handle(StepBasic_ProductDefinition)::DownCast(anEnt);
346     Handle(StepShape_ShapeDefinitionRepresentation) aShapeDefRepr;
347     if(!aProdDef.IsNull())
348     {
349       Interface_EntityIterator subsPD = graph.Sharings(aProdDef);
350       for(subsPD.Start(); subsPD.More() && aShapeDefRepr.IsNull(); subsPD.Next()) 
351       {
352         Handle(StepRepr_ProductDefinitionShape) aProdDefShape =
353           Handle(StepRepr_ProductDefinitionShape)::DownCast(subsPD.Value());
354         if(aProdDefShape.IsNull())
355           continue;
356         Interface_EntityIterator subsSR = graph.Sharings(aProdDefShape);
357         Handle(StepShape_ShapeRepresentation) SR;
358         for(subsSR.Start(); subsSR.More() && aShapeDefRepr.IsNull(); subsSR.Next())
359         {
360           Handle(StepShape_ShapeDefinitionRepresentation) aCurShapeDefRepr =
361             Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(subsSR.Value());
362           if(aCurShapeDefRepr.IsNull()) 
363             continue;
364           Handle(StepRepr_Representation) aUseRepr = aCurShapeDefRepr->UsedRepresentation();
365           if(aUseRepr.IsNull())
366             continue;
367           Handle(StepShape_ShapeRepresentation) aShapeRepr = 
368             Handle(StepShape_ShapeRepresentation)::DownCast(aUseRepr);
369           if(aShapeRepr.IsNull()) 
370             continue;
371           aShapeDefRepr = aCurShapeDefRepr;
372
373         }
374
375
376       }
377
378     }
379     else
380       aShapeDefRepr = Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(anEnt);
381     if(!aShapeDefRepr.IsNull())
382     {
383       Handle(StepShape_ShapeRepresentation) aShapeRepr =
384         Handle(StepShape_ShapeRepresentation)::DownCast(aShapeDefRepr->UsedRepresentation());
385       Handle(StepRepr_RepresentationContext) aRepCont = aShapeRepr->ContextOfItems();
386       if (aRepCont.IsNull())
387         continue;
388       TColStd_Array1OfAsciiString aNameUnits(1,3);
389       TColStd_Array1OfReal aFactorUnits(1,3);
390       if(findUnits(aRepCont,aNameUnits,aFactorUnits))
391       {
392         Standard_Integer k = LENGTH;
393         for ( ; k <= SOLID_ANGLE ; k++)
394         {
395           if(!aMapUnits[k].Contains(aNameUnits(k+1)))
396           {
397             aMapUnits[k].Add(aNameUnits(k+1));
398             TColStd_SequenceOfAsciiString& anUnitSeq = (k == LENGTH ? 
399                 theUnitLengthNames : ( k == ANLGE ? theUnitAngleNames : theUnitSolidAngleNames ));
400             anUnitSeq.Append(aNameUnits(k+1));
401           }
402         }
403       }
404
405     }
406
407   }
408   //for case when units was not found through PDF or SDR
409   if(theUnitLengthNames.IsEmpty())
410   {
411     const Handle(Interface_InterfaceModel) &aModel = WS()->Model();
412     if(aModel.IsNull())
413       return;
414     Standard_Integer nb = aModel->NbEntities();
415     for(Standard_Integer i = 1; i <= nb; i++)
416     {
417       Handle(Standard_Transient) anEnt = aModel->Value(i);
418       Handle(StepRepr_RepresentationContext) aRepCont = Handle(StepRepr_RepresentationContext)::DownCast(anEnt);
419       if (aRepCont.IsNull())
420         continue;
421       TColStd_Array1OfAsciiString aNameUnits(1,3);
422       TColStd_Array1OfReal aFactorUnits(1,3);
423       if(findUnits(aRepCont,aNameUnits,aFactorUnits))
424       {
425         Standard_Integer k = LENGTH;
426         for ( ; k <= SOLID_ANGLE ; k++)
427         {
428           if(!aMapUnits[k].Contains(aNameUnits(k+1)))
429           {
430             aMapUnits[k].Add(aNameUnits(k+1));
431             TColStd_SequenceOfAsciiString& anUnitSeq = (k == LENGTH ? 
432                theUnitLengthNames : ( k == ANLGE ? theUnitAngleNames : theUnitSolidAngleNames ));
433             anUnitSeq.Append(aNameUnits(k+1));
434           }
435         }
436       }
437     }
438   }
439 }
440
441 //=======================================================================
442 //function : getSiName
443 //purpose  : 
444 //=======================================================================
445
446 inline static TCollection_AsciiString getSiName(const Handle(StepBasic_SiUnit)& theUnit)
447 {
448  
449   TCollection_AsciiString aName;
450   if (theUnit->HasPrefix()) {
451     switch (theUnit->Prefix()) {
452       case StepBasic_spExa:   aName += "exa"; break;
453       case StepBasic_spPeta: aName += "peta"; break;
454       case StepBasic_spTera: aName += "tera"; break;
455       case StepBasic_spGiga: aName += "giga"; break;
456       case StepBasic_spMega:  aName += "mega"; break;
457       case StepBasic_spHecto: aName += "hecto"; break;
458       case StepBasic_spDeca:  aName += "deca"; break;
459       case StepBasic_spDeci:  aName += "deci"; break;
460       
461       case StepBasic_spPico:  aName += "pico"; break;
462       case StepBasic_spFemto: aName += "femto"; break;
463       case StepBasic_spAtto:  aName += "atto"; break;
464       
465       case StepBasic_spKilo : aName += "kilo"; break;
466       case StepBasic_spCenti :aName += "centi"; break;
467       case StepBasic_spMilli :aName += "milli"; break;
468       case StepBasic_spMicro :aName += "micro"; break;
469       case StepBasic_spNano :aName += "nano"; break;
470       default: break;
471     };
472   }
473   
474   switch(theUnit->Name()) {
475     case StepBasic_sunMetre : aName += "metre"; break;
476     case StepBasic_sunRadian : aName += "radian"; break;
477     case StepBasic_sunSteradian : aName += "steradian"; break; 
478     default: break;
479   };
480   return aName;
481 }
482
483 //=======================================================================
484 //function : findUnits
485 //purpose  : 
486 //=======================================================================
487
488 Standard_Boolean STEPControl_Reader::findUnits(
489        const Handle(StepRepr_RepresentationContext)& theRepCont,
490        TColStd_Array1OfAsciiString& theNameUnits,
491        TColStd_Array1OfReal& theFactorUnits)
492 {
493    Handle(StepRepr_GlobalUnitAssignedContext) aContext;
494   Handle(StepRepr_GlobalUncertaintyAssignedContext) aTol;
495
496   if (theRepCont->IsKind(STANDARD_TYPE(StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext))) {
497     aContext = Handle(StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext)::
498       DownCast(theRepCont)->GlobalUnitAssignedContext();
499   }
500
501  
502   if (theRepCont->IsKind(STANDARD_TYPE(StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx))) {
503     aContext = Handle(StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx)::
504       DownCast(theRepCont)->GlobalUnitAssignedContext();
505    
506   }
507   if(aContext.IsNull())
508     return Standard_False;
509   // Start Computation
510   Handle(StepBasic_HArray1OfNamedUnit) anUnits = aContext->Units();
511   Standard_Integer nbU = aContext->NbUnits();
512   Standard_Integer nbFind = 0;
513   for (Standard_Integer i = 1; i <= nbU; i++) {
514     Handle(StepBasic_NamedUnit) aNamedUnit = aContext->UnitsValue(i);
515     Handle(StepBasic_ConversionBasedUnit) aConvUnit =
516       Handle(StepBasic_ConversionBasedUnit)::DownCast(aNamedUnit);
517     Standard_Integer anInd = 0;
518     TCollection_AsciiString aName;
519     Standard_Real anUnitFact = 0;
520     if( !aConvUnit.IsNull() )
521     {
522       Handle(StepBasic_MeasureWithUnit) aMeasWithUnit = 
523         aConvUnit->ConversionFactor();
524       
525        if(aMeasWithUnit.IsNull())
526          continue;
527        
528        if( aMeasWithUnit->IsKind(STANDARD_TYPE(StepBasic_LengthMeasureWithUnit)) )
529          anInd = 1;
530        else if( aMeasWithUnit->IsKind(STANDARD_TYPE(StepBasic_PlaneAngleMeasureWithUnit)) )
531          anInd = 2;
532        else if( aMeasWithUnit->IsKind(STANDARD_TYPE(StepBasic_SolidAngleMeasureWithUnit)) )
533          anInd = 3;
534       if(!anInd)
535         continue;
536       aName = aConvUnit->Name()->String(); 
537       anUnitFact = aMeasWithUnit->ValueComponent();
538     }
539     else
540     {
541       Handle(StepBasic_SiUnit) aSiUnit = Handle(StepBasic_SiUnit)::DownCast(aNamedUnit);
542       if( aSiUnit.IsNull())
543         continue;
544       if(aSiUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndLengthUnit)))
545         anInd =1;
546       else if(aSiUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndPlaneAngleUnit)))
547         anInd = 2;
548       else if(aSiUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndSolidAngleUnit)))
549         anInd = 3;
550       if( !anInd )
551          continue;
552       anUnitFact = (!aSiUnit->HasPrefix()  ? 
553                     1. : STEPConstruct_UnitContext::ConvertSiPrefix(aSiUnit->Prefix()));
554       aName = getSiName(aSiUnit);
555       
556            
557     }
558     if( !anInd )
559       continue;
560  
561    theNameUnits.SetValue(anInd, aName);
562    theFactorUnits.SetValue(anInd, anUnitFact);
563     nbFind++;
564        
565    }
566
567   return nbFind != 0;
568 }