0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / STEPConstruct / STEPConstruct_UnitContext.cxx
1 // Created on: 1996-01-18
2 // Created by: Frederic MAUPAS
3 // Copyright (c) 1996-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 //abv 17.11.99: renamed from StepPDR_MakeUnitAndToleranceContext and merged with STEPControl_Unit
18 //abv 30.02.00: ability to write file in units other than MM
19
20 #include <Interface_Static.hxx>
21 #include <StepBasic_ConversionBasedUnit.hxx>
22 #include <StepBasic_ConversionBasedUnitAndAreaUnit.hxx>
23 #include <StepBasic_ConversionBasedUnitAndLengthUnit.hxx>
24 #include <StepBasic_ConversionBasedUnitAndPlaneAngleUnit.hxx>
25 #include <StepBasic_ConversionBasedUnitAndSolidAngleUnit.hxx>
26 #include <StepBasic_ConversionBasedUnitAndVolumeUnit.hxx>
27 #include <StepBasic_DimensionalExponents.hxx>
28 #include <StepBasic_HArray1OfNamedUnit.hxx>
29 #include <StepBasic_HArray1OfUncertaintyMeasureWithUnit.hxx>
30 #include <StepBasic_LengthMeasureWithUnit.hxx>
31 #include <StepBasic_LengthUnit.hxx>
32 #include <StepBasic_MeasureValueMember.hxx>
33 #include <StepBasic_MeasureWithUnit.hxx>
34 #include <StepBasic_NamedUnit.hxx>
35 #include <StepBasic_PlaneAngleMeasureWithUnit.hxx>
36 #include <StepBasic_PlaneAngleUnit.hxx>
37 #include <StepBasic_SiPrefix.hxx>
38 #include <StepBasic_SiUnit.hxx>
39 #include <StepBasic_SiUnitAndAreaUnit.hxx>
40 #include <StepBasic_SiUnitAndLengthUnit.hxx>
41 #include <StepBasic_SiUnitAndPlaneAngleUnit.hxx>
42 #include <StepBasic_SiUnitAndSolidAngleUnit.hxx>
43 #include <StepBasic_SiUnitAndVolumeUnit.hxx>
44 #include <StepBasic_SolidAngleMeasureWithUnit.hxx>
45 #include <StepBasic_SolidAngleUnit.hxx>
46 #include <StepBasic_UncertaintyMeasureWithUnit.hxx>
47 #include <STEPConstruct_UnitContext.hxx>
48 #include <StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.hxx>
49 #include <StepRepr_GlobalUncertaintyAssignedContext.hxx>
50 #include <StepRepr_GlobalUnitAssignedContext.hxx>
51 #include <TCollection_HAsciiString.hxx>
52 #include <UnitsMethods.hxx>
53
54 //=======================================================================
55 //function : STEPConstruct_UnitContext
56 //purpose  : 
57 //=======================================================================
58 STEPConstruct_UnitContext::STEPConstruct_UnitContext()
59 : done(Standard_False),
60   lengthFactor(0.0),
61   planeAngleFactor(0.0),
62   solidAngleFactor(0.0),
63   areaFactor(0.0),
64   volumeFactor(0.0)
65 {
66   lengthDone = planeAngleDone = solidAngleDone = hasUncertainty = 
67     areaDone = volumeDone = Standard_False;
68   //pdn file r_47-sd.stp initalize field.
69   theUncertainty = RealLast();
70 }
71
72 //=======================================================================
73 //function : Init
74 //purpose  : 
75 //=======================================================================
76
77 void STEPConstruct_UnitContext::Init(const Standard_Real Tol3d) 
78 {
79   done = Standard_True;
80
81   GRC = new StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx;
82   Handle(TCollection_HAsciiString) contextID =
83     new TCollection_HAsciiString("Context #1"); // ?????
84   
85   Handle(TCollection_HAsciiString) contextType =
86    new TCollection_HAsciiString("3D Context with UNIT and UNCERTAINTY");
87
88   // Units : LengthUnit and PlaneAngleUnit (no SolidAngleUnit appliable)
89
90   Handle(StepBasic_NamedUnit) lengthUnit;
91   Standard_CString uName = 0;
92   Standard_Boolean hasPref = Standard_True;
93   StepBasic_SiPrefix siPref = StepBasic_spMilli;
94   switch ( Interface_Static::IVal ( "write.step.unit" ) ) {
95   case  1 : uName = "INCH";             break;
96   default :
97   case  2 :                             break;
98   case  4 : uName = "FOOT";             break;
99   case  5 : uName = "MILE";             break;
100   case  6 : hasPref = Standard_False;   break;
101   case  7 : siPref = StepBasic_spKilo;  break;
102   case  8 : uName = "MIL";              break;
103   case  9 : siPref = StepBasic_spMicro; break;
104   case 10 : siPref = StepBasic_spCenti; break;
105   case 11 : uName = "MICROINCH";        break;
106   }
107   
108   Handle(StepBasic_SiUnitAndLengthUnit) siUnit =
109     new StepBasic_SiUnitAndLengthUnit;
110   siUnit->Init(hasPref,siPref,StepBasic_sunMetre);
111
112   if ( uName ) { // for non-metric units, create conversion_based_unit
113     Handle(StepBasic_MeasureValueMember) val = new StepBasic_MeasureValueMember;
114     val->SetName("LENGTH_UNIT");
115     val->SetReal ( UnitsMethods::GetLengthFactorValue ( Interface_Static::IVal ( "write.step.unit" ) ) );
116
117     Handle(StepBasic_LengthMeasureWithUnit) measure = new StepBasic_LengthMeasureWithUnit;
118     StepBasic_Unit Unit;
119     Unit.SetValue ( siUnit );
120     measure->Init ( val, Unit );
121
122     Handle(StepBasic_DimensionalExponents) theDimExp = new StepBasic_DimensionalExponents;
123     theDimExp->Init ( 1., 0., 0., 0., 0., 0., 0. );
124     
125     Handle(TCollection_HAsciiString) convName = new TCollection_HAsciiString ( uName );
126     Handle(StepBasic_ConversionBasedUnitAndLengthUnit) convUnit =
127       new StepBasic_ConversionBasedUnitAndLengthUnit;
128     convUnit->Init ( theDimExp, convName, measure );
129     
130     lengthUnit = convUnit;
131   }
132   else lengthUnit = siUnit;
133   
134   Handle(StepBasic_SiUnitAndPlaneAngleUnit) radianUnit =
135     new StepBasic_SiUnitAndPlaneAngleUnit;
136   radianUnit ->Init(Standard_False,
137                     StepBasic_spMilli,    // the unit is radian, no prefix
138                     StepBasic_sunRadian);
139
140   Handle(StepBasic_HArray1OfNamedUnit) units =
141     new StepBasic_HArray1OfNamedUnit(1, 3);
142
143   Handle(StepBasic_SiUnitAndSolidAngleUnit) sradUnit =
144     new StepBasic_SiUnitAndSolidAngleUnit;
145   sradUnit ->Init(Standard_False,
146                   StepBasic_spMilli,    // the unit is steradian, no prefix
147                   StepBasic_sunSteradian);
148
149   units->SetValue(1, lengthUnit);
150   units->SetValue(2, radianUnit);
151   units->SetValue(3, sradUnit);
152
153   // Uncertainty : 3D confusion Tolerance
154
155   Handle(StepBasic_HArray1OfUncertaintyMeasureWithUnit) Tols = 
156     new StepBasic_HArray1OfUncertaintyMeasureWithUnit(1,1);
157   Handle(StepBasic_UncertaintyMeasureWithUnit) theTol3d = 
158     new StepBasic_UncertaintyMeasureWithUnit;
159   
160   Handle(TCollection_HAsciiString) TolName = 
161     new TCollection_HAsciiString("distance_accuracy_value");
162   Handle(TCollection_HAsciiString) TolDesc =
163     new TCollection_HAsciiString("confusion accuracy");
164   
165   Handle(StepBasic_MeasureValueMember) mvs = new StepBasic_MeasureValueMember;
166   mvs->SetName("LENGTH_MEASURE");
167   mvs->SetReal ( Tol3d / UnitsMethods::LengthFactor() );
168   StepBasic_Unit Unit;
169   Unit.SetValue ( lengthUnit );
170   theTol3d->Init(mvs, Unit, TolName, TolDesc);
171   Tols->SetValue(1, theTol3d);
172
173   GRC->Init(contextID, contextType, 3, units, Tols);
174 }
175   
176 //=======================================================================
177 //function : IsDone
178 //purpose  : 
179 //=======================================================================
180
181 Standard_Boolean STEPConstruct_UnitContext::IsDone() const
182 {
183   return done;
184 }
185
186 //=======================================================================
187 //function : Value
188 //purpose  : 
189 //=======================================================================
190
191 Handle(StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx) STEPConstruct_UnitContext::Value() const
192 {
193   return GRC;
194 }
195
196 // ==========================================================================
197 // Method  : ConvertSiPrefix
198 // Purpose : Computes SiPrefix conversion
199 // ==========================================================================
200
201 Standard_Real STEPConstruct_UnitContext::ConvertSiPrefix (const StepBasic_SiPrefix aPrefix)
202 {
203   switch(aPrefix)
204     {
205     case StepBasic_spExa:      return 1.E+18;
206     case StepBasic_spPeta:     return 1.E+15;
207     case StepBasic_spTera:     return 1.E+12;
208     case StepBasic_spGiga:     return 1.E+9;
209     case StepBasic_spMega:     return 1.E+6;
210     case StepBasic_spKilo:     return 1.E+3;
211     case StepBasic_spHecto:    return 1.E+2;
212     case StepBasic_spDeca:     return 1.E+1;
213     case StepBasic_spDeci:     return 1.E-1;
214     case StepBasic_spCenti:    return 1.E-2;
215     case StepBasic_spMilli:    return 1.E-3;
216     case StepBasic_spMicro:    return 1.E-6;
217     case StepBasic_spNano:     return 1.E-9;
218     case StepBasic_spPico:     return 1.E-12;
219     case StepBasic_spFemto:    return 1.E-15;
220     case StepBasic_spAtto:     return 1.E-18;
221     default:
222       break;
223     }
224   return 1.;
225 }
226
227
228 // ==========================================================================
229 // Method  : STEPConstruct_UnitContext::SiUnitNameFactor
230 // Purpose : 
231 // ==========================================================================
232
233 Standard_Boolean STEPConstruct_UnitContext::SiUnitNameFactor(const Handle(StepBasic_SiUnit)& aSiUnit,
234                                                     Standard_Real& theSIUNFactor) const
235 {
236   theSIUNFactor = 1.;
237   switch ( aSiUnit->Name() )
238   {
239   case StepBasic_sunMetre:
240   case StepBasic_sunRadian:
241   case StepBasic_sunSteradian: 
242     return Standard_True;
243   default:
244 //      std::cout << "Unknown SiUnitName : " << aSiUnit->Name() << std::endl;
245     return Standard_False;
246   }
247 }
248
249 // ==========================================================================
250 // Method  : STEPConstruct_UnitContext::ComputeFactors
251 // Purpose : 
252 // ==========================================================================
253
254 Standard_Integer STEPConstruct_UnitContext::ComputeFactors(const Handle(StepRepr_GlobalUnitAssignedContext)& aContext)
255 {
256   Standard_Integer status = 0;
257
258   // Initialise the default value
259   // status : 0 if OK, else 1 2 3
260   lengthFactor = solidAngleFactor = 1.;
261   planeAngleFactor = M_PI/180.;
262 //  Standard_Real theLExp   = 1.;
263 //  Standard_Real thePAExp  = 0.;
264 //  Standard_Real theSAExp  = 0.;
265   lengthDone = planeAngleDone = solidAngleDone = Standard_False;
266   
267   if (aContext.IsNull()) {
268 #ifdef OCCT_DEBUG
269     std::cout<<" -- STEPConstruct_UnitContext:ComputeFactor, Context undefined -> default"<<std::endl;
270 #endif
271     return 1;
272   }
273
274   // Start Computation
275   Handle(StepBasic_HArray1OfNamedUnit) theUnits = aContext->Units();
276   Standard_Integer nbU = aContext->NbUnits();
277   
278   for (Standard_Integer i = 1; i <= nbU; i++) {
279     Handle(StepBasic_NamedUnit) theNamedUnit = aContext->UnitsValue(i);
280     status = ComputeFactors(theNamedUnit);
281 #ifdef OCCT_DEBUG
282     if(status == -1)
283       std::cout << " -- STEPConstruct_UnitContext:ComputeFactor: Unit item no." << i << " is not recognized" << std::endl;
284 #endif    
285   }
286   return status;
287
288
289
290 Standard_Integer STEPConstruct_UnitContext::ComputeFactors(const Handle(StepBasic_NamedUnit)& aUnit)
291 {
292
293   //:f3 abv 8 Apr 98: ProSTEP TR8 tr8_as_sd_sw: the case of unrecognized entity
294   if ( aUnit.IsNull() ) 
295     return -1;
296
297   Standard_Integer status = 0;
298   Standard_Real theFactor= 0.; 
299   Standard_Real theSIUNF  = 0.;
300   
301   Standard_Real parameter= 0.;
302   Standard_Boolean parameterDone = Standard_False;
303   if(aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnit))) {
304     Handle(StepBasic_ConversionBasedUnit) theCBU =
305       Handle(StepBasic_ConversionBasedUnit)::DownCast(aUnit);
306 //    Handle(StepBasic_DimensionalExponents) theDimExp = theCBU->Dimensions();
307     Handle(StepBasic_MeasureWithUnit) theMWU;
308     if(!theCBU.IsNull()) {
309        theMWU = theCBU->ConversionFactor();
310        // sln 8.10.2001: the case of unrecognized entity
311        if(theMWU.IsNull())
312          return -1;
313       //if (!theMWU->IsKind(STANDARD_TYPE(StepBasic_LengthMeasureWithUnit))) { gka
314       //        return 2;
315       //}
316       Handle(StepBasic_NamedUnit) theTargetUnit = theMWU->UnitComponent().NamedUnit();
317       //StepBasic_Unit theTargetUnit = theMWU->UnitComponent();
318       Standard_Real theSIPFactor = 1.;
319         
320       //:f5 abv 24 Apr 98: ProSTEP TR8 tr8_bv1_tc: INCHES
321 //gka   Handle(StepBasic_SiUnitAndLengthUnit) theSUALU =
322 //      Handle(StepBasic_SiUnitAndLengthUnit)::DownCast(theTargetUnit);
323 //      Handle(StepBasic_SiUnit) theSIU;
324 //      if ( ! theSUALU.IsNull() ) theSIU = Handle(StepBasic_SiUnit)::DownCast(theSUALU);
325     Handle(StepBasic_SiUnit) theSIU =  //f5
326       Handle(StepBasic_SiUnit)::DownCast(theTargetUnit);//f5
327       
328       if (!theSIU.IsNull()) {
329         if (theSIU->HasPrefix()) {
330           // Treat the prefix
331           StepBasic_SiPrefix aPrefix = theSIU->Prefix();
332           theSIPFactor = ConvertSiPrefix(aPrefix); 
333         }
334         // Treat the SiUnitName
335         if (!SiUnitNameFactor(theSIU,theSIUNF)) status = 11; // et continue
336         //std::cout << "The SiUnitNameFactor is :";
337         //std::cout << theSIUNF << std::endl;
338       }
339       else {
340         //      std::cout << "Recursive algo required - Aborted" << std::endl;
341         return 3;
342       }
343       Standard_Real theMVAL = theMWU->ValueComponent();
344       theFactor = theSIPFactor * theMVAL; // * theSIUNF * pow(10.,theLExp)
345     }
346     parameter = theFactor;
347     if(!parameterDone) {
348       parameterDone = Standard_True;
349     }
350     else {
351       status = 14;
352 #ifdef OCCT_DEBUG
353       std::cout << "Error in the file : parameter double defined" << std::endl;
354 #endif
355     }
356   }    
357   else if (aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnit))) {
358     Handle(StepBasic_SiUnit) theSIU = Handle(StepBasic_SiUnit)::DownCast(aUnit);
359     Standard_Real theSIPFactor = 1.;
360     if (theSIU->HasPrefix()) {
361       // Treat the prefix
362       StepBasic_SiPrefix aPrefix = theSIU->Prefix();
363       theSIPFactor = ConvertSiPrefix(aPrefix); 
364     }
365     
366     // Treat the SiUnitName
367     if (!SiUnitNameFactor(theSIU,theSIUNF)) status = 11;
368     
369     // final computation for lengthFactor
370     theFactor = theSIPFactor * theSIUNF;
371     parameter = theFactor;
372     if (!parameterDone) {
373       parameterDone = Standard_True;
374     }
375     else {
376       status = 14;
377 #ifdef OCCT_DEBUG
378       std::cout << "Error in the file : parameter double defined" << std::endl;
379 #endif
380     }
381   }
382   
383   // Defining a type of unit
384   if(!parameterDone) {
385 #ifdef OCCT_DEBUG
386     std::cout << "Unit Type not implemented" << std::endl;
387 #endif 
388     return 0;
389   }
390   
391   if (aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndLengthUnit))||
392       aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndLengthUnit))) {
393 #ifdef METER
394     lengthFactor = parameter;
395 #else
396     lengthFactor = parameter * 1000. / UnitsMethods::GetCasCadeLengthUnit();
397 #endif    
398     if(!lengthDone) 
399       lengthDone = Standard_True;
400     else {
401       status = 14;
402 #ifdef OCCT_DEBUG
403       std::cout << "Error in the file : LengthFactor double defined" << std::endl;
404 #endif    
405     }
406   }  // end of LengthUnit
407   else if (aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndPlaneAngleUnit))||
408            aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndPlaneAngleUnit))) {
409     planeAngleFactor = parameter;
410     planeAngleDone = Standard_True;     
411   }  // end of PlaneAngleUnit
412   else if (aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndSolidAngleUnit))||
413            aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndSolidAngleUnit))) {
414     solidAngleFactor = parameter;
415     solidAngleDone = Standard_True;
416   }  // end of SolidAngleUnit 
417   else if (aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndAreaUnit)) ||
418            aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndAreaUnit))) {
419     Standard_Real af;
420 #ifdef METER   
421     af = parameter;
422 #else
423     af = parameter * 1000. / UnitsMethods::GetCasCadeLengthUnit();
424 #endif    
425     areaDone = Standard_True;
426     areaFactor = pow(af,2);
427   }
428   else if (aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndVolumeUnit)) ||
429            aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndVolumeUnit))) {
430     Standard_Real af;
431 #ifdef METER   
432     af = parameter;
433 #else
434     af = parameter * 1000. / UnitsMethods::GetCasCadeLengthUnit();
435 #endif
436     volumeDone = Standard_True;
437     volumeFactor = pow(af,3);
438   }   
439   return status;
440 }
441
442
443 // ==========================================================================
444 // Method  : STEPConstruct_UnitContext::ComputeTolerance
445 // Purpose : 
446 // ==========================================================================
447
448 Standard_Integer STEPConstruct_UnitContext::ComputeTolerance
449 (const Handle(StepRepr_GlobalUncertaintyAssignedContext)& aContext)
450 {
451   Standard_Integer status = 0;
452     // Decode the Uncertainty information (geometric accuracy)
453
454   hasUncertainty = Standard_False;
455   Standard_Integer nbUncertainty = 0;
456     
457   if (!aContext.IsNull()) nbUncertainty = aContext->NbUncertainty();
458   else return 40;
459
460   for (Standard_Integer un = 1 ; un <= nbUncertainty ; un ++) {
461     Handle(StepBasic_UncertaintyMeasureWithUnit) aUMWU = aContext->UncertaintyValue(un);
462     if (aUMWU.IsNull()) {
463 #ifdef OCCT_DEBUG
464       std::cout<<"BAD Uncertainty Measure with Units, n0."<<un<<std::endl;
465 #endif
466       continue;
467     }
468     // Decode the associated Unit
469     Handle(StepBasic_SiUnitAndLengthUnit) aUnit = 
470       Handle(StepBasic_SiUnitAndLengthUnit)::DownCast(aUMWU->UnitComponent().NamedUnit());
471     if (!aUnit.IsNull()) {
472       // Extract Uncertainty value
473       Standard_Real LengthUncertainty = aUMWU->ValueComponent();
474       // Update it according to the Length Unit Factor
475       //pdn r_47-sd.stp to choose minimal uncertainty
476       if(theUncertainty > LengthUncertainty) theUncertainty =  LengthUncertainty;
477       hasUncertainty = Standard_True;
478
479     } else {
480       Handle(StepBasic_ConversionBasedUnitAndLengthUnit) aCBULU =
481         Handle(StepBasic_ConversionBasedUnitAndLengthUnit)::DownCast(aUMWU->UnitComponent().NamedUnit());
482       if (!aCBULU.IsNull()) {
483         // Extract Uncertainty value
484         Standard_Real LengthUncertainty = aUMWU->ValueComponent();
485         // Update it according to the Length Unit Factor
486         //pdn r_47-sd.stp to choose minimal uncertainty
487         if(theUncertainty > LengthUncertainty) theUncertainty =  LengthUncertainty; // *lengthFactor; fait par appelant
488         hasUncertainty = Standard_True;
489       }
490     }
491   }
492
493 #ifdef OCCT_DEBUG
494   if (hasUncertainty) std::cout << "UNCERTAINTY read as " << theUncertainty << std::endl;
495 #endif
496   return status;
497 }
498
499 // ==========================================================================
500 // Method  : STEPConstruct_UnitContext::LengthFactor
501 // Purpose : 
502 // ==========================================================================
503 Standard_Real STEPConstruct_UnitContext::LengthFactor() const 
504 {  return lengthFactor;  }
505
506 // ==========================================================================
507 // Method  : STEPConstruct_UnitContext::PlaneAngleFactor
508 // Purpose : 
509 // ==========================================================================
510 Standard_Real STEPConstruct_UnitContext::PlaneAngleFactor() const 
511 {  return planeAngleFactor;  }
512
513 // ==========================================================================
514 // Method  : STEPConstruct_UnitContext::SolidAngleFactor
515 // Purpose : 
516 // ==========================================================================
517 Standard_Real STEPConstruct_UnitContext::SolidAngleFactor() const 
518 {  return solidAngleFactor;  }
519
520 // ==========================================================================
521 // Method  : STEPConstruct_UnitContext::Uncertainty
522 // Purpose : 
523 // ==========================================================================
524 Standard_Real STEPConstruct_UnitContext::Uncertainty () const 
525 {  return theUncertainty;  }
526
527 // ==========================================================================
528 // Method  : STEPConstruct_UnitContext::HasUncertainty
529 // Purpose : 
530 // ==========================================================================
531 Standard_Boolean STEPConstruct_UnitContext::HasUncertainty () const 
532 {  return hasUncertainty;  }
533
534 // ==========================================================================
535 // Method  : STEPConstruct_UnitContext::LengthDone
536 // Purpose : 
537 // ==========================================================================
538 Standard_Boolean STEPConstruct_UnitContext::LengthDone() const
539 {  return lengthDone;  }
540
541 // ==========================================================================
542 // Method  : STEPConstruct_UnitContext::PlaneAngleDone
543 // Purpose : 
544 // ==========================================================================
545 Standard_Boolean STEPConstruct_UnitContext::PlaneAngleDone() const
546 {  return planeAngleDone;  }
547
548 // ==========================================================================
549 // Method  : STEPConstruct_UnitContext::SolidAngleDone
550 // Purpose : 
551 // ==========================================================================
552 Standard_Boolean STEPConstruct_UnitContext::SolidAngleDone() const
553 {  return solidAngleDone;  }
554
555 // ==========================================================================
556 // Method  : STEPConstruct_UnitContext::StatusMessage
557 // Purpose : 
558 // ==========================================================================
559 Standard_CString  STEPConstruct_UnitContext::StatusMessage (const Standard_Integer status) const
560 {
561   switch (status) {
562   case  0 : return "";
563   case  1 : return "No GlobalUnitAssignedContext, default taken";
564   case  2 : return "No LengthMeasureWithUnit, default taken";
565   case  3 : return "No SiUnit for LengthMeasure undefined, default taken";
566   case  4 : return "No PlaneAngleMeasureWithUnit, default taken";
567   case  5 : return "No SiUnit for PlaneAngleMeasure undefined, default taken";
568   case  6 : return "No SolidAngleMeasureWithUnit, default taken";
569   case  7 : return "No SiUnit for SolidAngleMeasure undefined, default taken";
570
571   case 11 : return "Length Unit not recognized, default taken";
572   case 12 : return "Plane Angle Unit not recognized, default taken";
573   case 13 : return "Solid Angle Unit not recognized, default taken";
574   case 14 : return "At least one unit is twice defined";
575
576   case 40 : return "Bad GlobalUncertaintyAssignedContext, default unit taken";
577
578   default : break;
579   }
580
581   return "Badly defined units, default taken";
582 }
583
584 Standard_Real STEPConstruct_UnitContext::AreaFactor() const
585 {
586   return areaFactor;
587 }
588
589 Standard_Real STEPConstruct_UnitContext::VolumeFactor() const
590 {
591   return volumeFactor;
592 }
593
594 Standard_Boolean STEPConstruct_UnitContext::AreaDone() const
595 {
596   return areaDone;
597 }
598
599 Standard_Boolean STEPConstruct_UnitContext::VolumeDone() const
600 {
601   return volumeDone;
602 }