mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-10 18:51:21 +03:00
9c355a6123
0033099: Data Exchange, Step Import - Wrong PMI values in GDT measure_with_unit entity is changed to be translated as Handle(Standard_Transient) and to be processed later, depending on the underlying type being used. 0033484: Data Exchange, Step Import - Pretessellated geometry is translated incompletely Added proper translation for TessellatedCurveSet and ComplexTriangulatedSurfaceSet. 0030024: Data Exchange - STEP, IGES export support of BRep shapes based on tessellated geometry Support of reading and writing tessellated geometry is added for the following STEP entities: - triangulated face - complex triangulated face - tessellated shell - tessellated solid - tessellated shape representation Models without BRep geometry (mesh formats like STL, OBJ and so on) are supported for writing to STEP. New parameters are added to enable/disable tessellated geometry reading and writing: - read.step.tessellated (On/Off/OnNoBRep) (On by default) - write.step.tessellated (On/Off/OnNoBRep) (OnNoBRep by default) OnNoBRep - tessellation is read/written only for entities for which there is no BRep representation. Faces with poly triangulation are written in STEP as triangulated face entities with one coordinates list per face. Only one poly triangulation per face (returned by BRep_Tool::Triangulation) is written to STEP.
624 lines
22 KiB
C++
624 lines
22 KiB
C++
// Created on: 1996-01-18
|
|
// Created by: Frederic MAUPAS
|
|
// Copyright (c) 1996-1999 Matra Datavision
|
|
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
|
//
|
|
// This file is part of Open CASCADE Technology software library.
|
|
//
|
|
// This library is free software; you can redistribute it and/or modify it under
|
|
// the terms of the GNU Lesser General Public License version 2.1 as published
|
|
// by the Free Software Foundation, with special exception defined in the file
|
|
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
|
// distribution for complete text of the license and disclaimer of any warranty.
|
|
//
|
|
// Alternatively, this file may be used under the terms of Open CASCADE
|
|
// commercial license or contractual agreement.
|
|
|
|
//abv 17.11.99: renamed from StepPDR_MakeUnitAndToleranceContext and merged with STEPControl_Unit
|
|
//abv 30.02.00: ability to write file in units other than MM
|
|
|
|
#include <Interface_Static.hxx>
|
|
#include <StepBasic_ConversionBasedUnit.hxx>
|
|
#include <StepBasic_ConversionBasedUnitAndAreaUnit.hxx>
|
|
#include <StepBasic_ConversionBasedUnitAndLengthUnit.hxx>
|
|
#include <StepBasic_ConversionBasedUnitAndPlaneAngleUnit.hxx>
|
|
#include <StepBasic_ConversionBasedUnitAndSolidAngleUnit.hxx>
|
|
#include <StepBasic_ConversionBasedUnitAndVolumeUnit.hxx>
|
|
#include <StepBasic_DimensionalExponents.hxx>
|
|
#include <StepBasic_HArray1OfNamedUnit.hxx>
|
|
#include <StepBasic_HArray1OfUncertaintyMeasureWithUnit.hxx>
|
|
#include <StepBasic_LengthMeasureWithUnit.hxx>
|
|
#include <StepBasic_LengthUnit.hxx>
|
|
#include <StepBasic_MeasureValueMember.hxx>
|
|
#include <StepBasic_MeasureWithUnit.hxx>
|
|
#include <StepBasic_NamedUnit.hxx>
|
|
#include <StepBasic_PlaneAngleMeasureWithUnit.hxx>
|
|
#include <StepBasic_PlaneAngleUnit.hxx>
|
|
#include <StepBasic_SiPrefix.hxx>
|
|
#include <StepBasic_SiUnit.hxx>
|
|
#include <StepBasic_SiUnitAndAreaUnit.hxx>
|
|
#include <StepBasic_SiUnitAndLengthUnit.hxx>
|
|
#include <StepBasic_SiUnitAndPlaneAngleUnit.hxx>
|
|
#include <StepBasic_SiUnitAndSolidAngleUnit.hxx>
|
|
#include <StepBasic_SiUnitAndVolumeUnit.hxx>
|
|
#include <StepBasic_SolidAngleMeasureWithUnit.hxx>
|
|
#include <StepBasic_SolidAngleUnit.hxx>
|
|
#include <StepBasic_UncertaintyMeasureWithUnit.hxx>
|
|
#include <STEPConstruct_UnitContext.hxx>
|
|
#include <StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.hxx>
|
|
#include <StepRepr_GlobalUncertaintyAssignedContext.hxx>
|
|
#include <StepRepr_GlobalUnitAssignedContext.hxx>
|
|
#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
|
|
#include <TCollection_HAsciiString.hxx>
|
|
#include <UnitsMethods.hxx>
|
|
|
|
//=======================================================================
|
|
//function : STEPConstruct_UnitContext
|
|
//purpose :
|
|
//=======================================================================
|
|
STEPConstruct_UnitContext::STEPConstruct_UnitContext()
|
|
: done(Standard_False),
|
|
lengthFactor(0.0),
|
|
planeAngleFactor(0.0),
|
|
solidAngleFactor(0.0),
|
|
areaFactor(0.0),
|
|
volumeFactor(0.0)
|
|
{
|
|
lengthDone = planeAngleDone = solidAngleDone = hasUncertainty =
|
|
areaDone = volumeDone = Standard_False;
|
|
//pdn file r_47-sd.stp initalize field.
|
|
theUncertainty = RealLast();
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Init
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void STEPConstruct_UnitContext::Init(const Standard_Real Tol3d)
|
|
{
|
|
done = Standard_True;
|
|
|
|
GRC = new StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx;
|
|
Handle(TCollection_HAsciiString) contextID =
|
|
new TCollection_HAsciiString("Context #1"); // ?????
|
|
|
|
Handle(TCollection_HAsciiString) contextType =
|
|
new TCollection_HAsciiString("3D Context with UNIT and UNCERTAINTY");
|
|
|
|
// Units : LengthUnit and PlaneAngleUnit (no SolidAngleUnit appliable)
|
|
|
|
Handle(StepBasic_NamedUnit) lengthUnit;
|
|
Standard_CString uName = 0;
|
|
Standard_Boolean hasPref = Standard_True;
|
|
StepBasic_SiPrefix siPref = StepBasic_spMilli;
|
|
switch ( Interface_Static::IVal ( "write.step.unit" ) ) {
|
|
case 1 : uName = "INCH"; break;
|
|
default :
|
|
case 2 : break;
|
|
case 4 : uName = "FOOT"; break;
|
|
case 5 : uName = "MILE"; break;
|
|
case 6 : hasPref = Standard_False; break;
|
|
case 7 : siPref = StepBasic_spKilo; break;
|
|
case 8 : uName = "MIL"; break;
|
|
case 9 : siPref = StepBasic_spMicro; break;
|
|
case 10 : siPref = StepBasic_spCenti; break;
|
|
case 11 : uName = "MICROINCH"; break;
|
|
}
|
|
|
|
Handle(StepBasic_SiUnitAndLengthUnit) siUnit =
|
|
new StepBasic_SiUnitAndLengthUnit;
|
|
siUnit->Init(hasPref,siPref,StepBasic_sunMetre);
|
|
|
|
if ( uName ) { // for non-metric units, create conversion_based_unit
|
|
Handle(StepBasic_MeasureValueMember) val = new StepBasic_MeasureValueMember;
|
|
val->SetName("LENGTH_UNIT");
|
|
val->SetReal ( UnitsMethods::GetLengthFactorValue ( Interface_Static::IVal ( "write.step.unit" ) ) );
|
|
|
|
Handle(StepBasic_LengthMeasureWithUnit) measure = new StepBasic_LengthMeasureWithUnit;
|
|
StepBasic_Unit Unit;
|
|
Unit.SetValue ( siUnit );
|
|
measure->Init ( val, Unit );
|
|
|
|
Handle(StepBasic_DimensionalExponents) theDimExp = new StepBasic_DimensionalExponents;
|
|
theDimExp->Init ( 1., 0., 0., 0., 0., 0., 0. );
|
|
|
|
Handle(TCollection_HAsciiString) aConvName = new TCollection_HAsciiString(uName);
|
|
Handle(StepBasic_ConversionBasedUnitAndLengthUnit) aConvUnit =
|
|
new StepBasic_ConversionBasedUnitAndLengthUnit;
|
|
aConvUnit->Init(theDimExp, aConvName, measure);
|
|
|
|
lengthUnit = aConvUnit;
|
|
}
|
|
else lengthUnit = siUnit;
|
|
|
|
Handle(StepBasic_SiUnitAndPlaneAngleUnit) radianUnit =
|
|
new StepBasic_SiUnitAndPlaneAngleUnit;
|
|
radianUnit ->Init(Standard_False,
|
|
StepBasic_spMilli, // the unit is radian, no prefix
|
|
StepBasic_sunRadian);
|
|
|
|
Handle(StepBasic_HArray1OfNamedUnit) units =
|
|
new StepBasic_HArray1OfNamedUnit(1, 3);
|
|
|
|
Handle(StepBasic_SiUnitAndSolidAngleUnit) sradUnit =
|
|
new StepBasic_SiUnitAndSolidAngleUnit;
|
|
sradUnit ->Init(Standard_False,
|
|
StepBasic_spMilli, // the unit is steradian, no prefix
|
|
StepBasic_sunSteradian);
|
|
|
|
units->SetValue(1, lengthUnit);
|
|
units->SetValue(2, radianUnit);
|
|
units->SetValue(3, sradUnit);
|
|
|
|
// Uncertainty : 3D confusion Tolerance
|
|
|
|
Handle(StepBasic_HArray1OfUncertaintyMeasureWithUnit) Tols =
|
|
new StepBasic_HArray1OfUncertaintyMeasureWithUnit(1,1);
|
|
Handle(StepBasic_UncertaintyMeasureWithUnit) theTol3d =
|
|
new StepBasic_UncertaintyMeasureWithUnit;
|
|
|
|
Handle(TCollection_HAsciiString) TolName =
|
|
new TCollection_HAsciiString("distance_accuracy_value");
|
|
Handle(TCollection_HAsciiString) TolDesc =
|
|
new TCollection_HAsciiString("confusion accuracy");
|
|
|
|
Handle(StepBasic_MeasureValueMember) mvs = new StepBasic_MeasureValueMember;
|
|
mvs->SetName("LENGTH_MEASURE");
|
|
mvs->SetReal ( Tol3d / UnitsMethods::LengthFactor() );
|
|
StepBasic_Unit Unit;
|
|
Unit.SetValue ( lengthUnit );
|
|
theTol3d->Init(mvs, Unit, TolName, TolDesc);
|
|
Tols->SetValue(1, theTol3d);
|
|
|
|
GRC->Init(contextID, contextType, 3, units, Tols);
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : IsDone
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
Standard_Boolean STEPConstruct_UnitContext::IsDone() const
|
|
{
|
|
return done;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Value
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
Handle(StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx) STEPConstruct_UnitContext::Value() const
|
|
{
|
|
return GRC;
|
|
}
|
|
|
|
// ==========================================================================
|
|
// Method : ConvertSiPrefix
|
|
// Purpose : Computes SiPrefix conversion
|
|
// ==========================================================================
|
|
|
|
Standard_Real STEPConstruct_UnitContext::ConvertSiPrefix (const StepBasic_SiPrefix aPrefix)
|
|
{
|
|
switch(aPrefix)
|
|
{
|
|
case StepBasic_spExa: return 1.E+18;
|
|
case StepBasic_spPeta: return 1.E+15;
|
|
case StepBasic_spTera: return 1.E+12;
|
|
case StepBasic_spGiga: return 1.E+9;
|
|
case StepBasic_spMega: return 1.E+6;
|
|
case StepBasic_spKilo: return 1.E+3;
|
|
case StepBasic_spHecto: return 1.E+2;
|
|
case StepBasic_spDeca: return 1.E+1;
|
|
case StepBasic_spDeci: return 1.E-1;
|
|
case StepBasic_spCenti: return 1.E-2;
|
|
case StepBasic_spMilli: return 1.E-3;
|
|
case StepBasic_spMicro: return 1.E-6;
|
|
case StepBasic_spNano: return 1.E-9;
|
|
case StepBasic_spPico: return 1.E-12;
|
|
case StepBasic_spFemto: return 1.E-15;
|
|
case StepBasic_spAtto: return 1.E-18;
|
|
default:
|
|
break;
|
|
}
|
|
return 1.;
|
|
}
|
|
|
|
|
|
// ==========================================================================
|
|
// Method : STEPConstruct_UnitContext::SiUnitNameFactor
|
|
// Purpose :
|
|
// ==========================================================================
|
|
|
|
Standard_Boolean STEPConstruct_UnitContext::SiUnitNameFactor(const Handle(StepBasic_SiUnit)& aSiUnit,
|
|
Standard_Real& theSIUNFactor) const
|
|
{
|
|
theSIUNFactor = 1.;
|
|
switch ( aSiUnit->Name() )
|
|
{
|
|
case StepBasic_sunMetre:
|
|
case StepBasic_sunRadian:
|
|
case StepBasic_sunSteradian:
|
|
return Standard_True;
|
|
default:
|
|
// std::cout << "Unknown SiUnitName : " << aSiUnit->Name() << std::endl;
|
|
return Standard_False;
|
|
}
|
|
}
|
|
|
|
// ==========================================================================
|
|
// Method : STEPConstruct_UnitContext::ComputeFactors
|
|
// Purpose :
|
|
// ==========================================================================
|
|
|
|
Standard_Integer STEPConstruct_UnitContext::ComputeFactors(const Handle(StepRepr_GlobalUnitAssignedContext)& aContext)
|
|
{
|
|
Standard_Integer status = 0;
|
|
|
|
// Initialise the default value
|
|
// status : 0 if OK, else 1 2 3
|
|
lengthFactor = solidAngleFactor = 1.;
|
|
planeAngleFactor = M_PI/180.;
|
|
// Standard_Real theLExp = 1.;
|
|
// Standard_Real thePAExp = 0.;
|
|
// Standard_Real theSAExp = 0.;
|
|
lengthDone = planeAngleDone = solidAngleDone = Standard_False;
|
|
|
|
if (aContext.IsNull()) {
|
|
#ifdef OCCT_DEBUG
|
|
std::cout<<" -- STEPConstruct_UnitContext:ComputeFactor, Context undefined -> default"<<std::endl;
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
// Start Computation
|
|
Handle(StepBasic_HArray1OfNamedUnit) theUnits = aContext->Units();
|
|
Standard_Integer nbU = aContext->NbUnits();
|
|
|
|
for (Standard_Integer i = 1; i <= nbU; i++) {
|
|
Handle(StepBasic_NamedUnit) theNamedUnit = aContext->UnitsValue(i);
|
|
status = ComputeFactors(theNamedUnit);
|
|
#ifdef OCCT_DEBUG
|
|
if(status == -1)
|
|
std::cout << " -- STEPConstruct_UnitContext:ComputeFactor: Unit item no." << i << " is not recognized" << std::endl;
|
|
#endif
|
|
}
|
|
return status;
|
|
}
|
|
|
|
|
|
Standard_Integer STEPConstruct_UnitContext::ComputeFactors(const Handle(StepBasic_NamedUnit)& theUnit)
|
|
{
|
|
//:f3 abv 8 Apr 98: ProSTEP TR8 tr8_as_sd_sw: the case of unrecognized entity
|
|
if (theUnit.IsNull())
|
|
return -1;
|
|
|
|
Standard_Integer status = 0;
|
|
Standard_Real theFactor = 0.;
|
|
Standard_Real theSIUNF = 0.;
|
|
|
|
Standard_Real parameter= 0.;
|
|
Standard_Boolean parameterDone = Standard_False;
|
|
if(theUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnit)))
|
|
{
|
|
Handle(StepBasic_ConversionBasedUnit) aCBU =
|
|
Handle(StepBasic_ConversionBasedUnit)::DownCast(theUnit);
|
|
// Handle(StepBasic_DimensionalExponents) theDimExp = theCBU->Dimensions();
|
|
Handle(StepBasic_MeasureWithUnit) aMWU;
|
|
if(!aCBU.IsNull())
|
|
{
|
|
Handle(Standard_Transient) aConvFactor = aCBU->ConversionFactor();
|
|
if (aConvFactor->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)))
|
|
{
|
|
aMWU = Handle(StepBasic_MeasureWithUnit)::DownCast(aConvFactor);
|
|
}
|
|
else if (aConvFactor->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)))
|
|
{
|
|
Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
|
|
Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aConvFactor);
|
|
aMWU = aReprMeasureItem->GetMeasureWithUnit();
|
|
}
|
|
// sln 8.10.2001: the case of unrecognized entity
|
|
if(aMWU.IsNull())
|
|
return -1;
|
|
//if (!theMWU->IsKind(STANDARD_TYPE(StepBasic_LengthMeasureWithUnit))) { gka
|
|
// return 2;
|
|
//}
|
|
Handle(StepBasic_NamedUnit) theTargetUnit = aMWU->UnitComponent().NamedUnit();
|
|
//StepBasic_Unit theTargetUnit = theMWU->UnitComponent();
|
|
Standard_Real theSIPFactor = 1.;
|
|
|
|
//:f5 abv 24 Apr 98: ProSTEP TR8 tr8_bv1_tc: INCHES
|
|
//gka
|
|
//Handle(StepBasic_SiUnitAndLengthUnit) theSUALU =
|
|
//Handle(StepBasic_SiUnitAndLengthUnit)::DownCast(theTargetUnit);
|
|
//Handle(StepBasic_SiUnit) theSIU;
|
|
//if ( ! theSUALU.IsNull() ) theSIU = Handle(StepBasic_SiUnit)::DownCast(theSUALU);
|
|
Handle(StepBasic_SiUnit) theSIU = Handle(StepBasic_SiUnit)::DownCast(theTargetUnit); //f5
|
|
|
|
if (!theSIU.IsNull())
|
|
{
|
|
if (theSIU->HasPrefix())
|
|
{
|
|
// Treat the prefix
|
|
StepBasic_SiPrefix aPrefix = theSIU->Prefix();
|
|
theSIPFactor = ConvertSiPrefix(aPrefix);
|
|
}
|
|
// Treat the SiUnitName
|
|
if (!SiUnitNameFactor(theSIU,theSIUNF)) status = 11; // et continue
|
|
//std::cout << "The SiUnitNameFactor is :";
|
|
//std::cout << theSIUNF << std::endl;
|
|
}
|
|
else
|
|
{
|
|
//std::cout << "Recursive algo required - Aborted" << std::endl;
|
|
return 3;
|
|
}
|
|
Standard_Real theMVAL = aMWU->ValueComponent();
|
|
theFactor = theSIPFactor * theMVAL; // * theSIUNF * pow(10.,theLExp)
|
|
}
|
|
parameter = theFactor;
|
|
if(!parameterDone) {
|
|
parameterDone = Standard_True;
|
|
}
|
|
else {
|
|
status = 14;
|
|
#ifdef OCCT_DEBUG
|
|
std::cout << "Error in the file : parameter double defined" << std::endl;
|
|
#endif
|
|
}
|
|
}
|
|
else if (theUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnit)))
|
|
{
|
|
Handle(StepBasic_SiUnit) theSIU = Handle(StepBasic_SiUnit)::DownCast(theUnit);
|
|
Standard_Real theSIPFactor = 1.;
|
|
if (theSIU->HasPrefix()) {
|
|
// Treat the prefix
|
|
StepBasic_SiPrefix aPrefix = theSIU->Prefix();
|
|
theSIPFactor = ConvertSiPrefix(aPrefix);
|
|
}
|
|
|
|
// Treat the SiUnitName
|
|
if (!SiUnitNameFactor(theSIU,theSIUNF)) status = 11;
|
|
|
|
// final computation for lengthFactor
|
|
theFactor = theSIPFactor * theSIUNF;
|
|
parameter = theFactor;
|
|
if (!parameterDone) {
|
|
parameterDone = Standard_True;
|
|
}
|
|
else {
|
|
status = 14;
|
|
#ifdef OCCT_DEBUG
|
|
std::cout << "Error in the file : parameter double defined" << std::endl;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// Defining a type of unit
|
|
if(!parameterDone) {
|
|
#ifdef OCCT_DEBUG
|
|
std::cout << "Unit Type not implemented" << std::endl;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
if (theUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndLengthUnit))||
|
|
theUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndLengthUnit)))
|
|
{
|
|
#ifdef METER
|
|
lengthFactor = parameter;
|
|
#else
|
|
lengthFactor = parameter * 1000. / UnitsMethods::GetCasCadeLengthUnit();
|
|
#endif
|
|
if(!lengthDone)
|
|
lengthDone = Standard_True;
|
|
else {
|
|
status = 14;
|
|
#ifdef OCCT_DEBUG
|
|
std::cout << "Error in the file : LengthFactor double defined" << std::endl;
|
|
#endif
|
|
}
|
|
} // end of LengthUnit
|
|
else if (theUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)) ||
|
|
theUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndPlaneAngleUnit)))
|
|
{
|
|
planeAngleFactor = parameter;
|
|
planeAngleDone = Standard_True;
|
|
} // end of PlaneAngleUnit
|
|
else if (theUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndSolidAngleUnit)) ||
|
|
theUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndSolidAngleUnit)))
|
|
{
|
|
solidAngleFactor = parameter;
|
|
solidAngleDone = Standard_True;
|
|
} // end of SolidAngleUnit
|
|
else if (theUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndAreaUnit)) ||
|
|
theUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndAreaUnit)))
|
|
{
|
|
Standard_Real af;
|
|
#ifdef METER
|
|
af = parameter;
|
|
#else
|
|
af = parameter * 1000. / UnitsMethods::GetCasCadeLengthUnit();
|
|
#endif
|
|
areaDone = Standard_True;
|
|
areaFactor = pow(af,2);
|
|
}
|
|
else if (theUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndVolumeUnit)) ||
|
|
theUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndVolumeUnit)))
|
|
{
|
|
Standard_Real af;
|
|
#ifdef METER
|
|
af = parameter;
|
|
#else
|
|
af = parameter * 1000. / UnitsMethods::GetCasCadeLengthUnit();
|
|
#endif
|
|
volumeDone = Standard_True;
|
|
volumeFactor = pow(af,3);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
|
|
// ==========================================================================
|
|
// Method : STEPConstruct_UnitContext::ComputeTolerance
|
|
// Purpose :
|
|
// ==========================================================================
|
|
|
|
Standard_Integer STEPConstruct_UnitContext::ComputeTolerance
|
|
(const Handle(StepRepr_GlobalUncertaintyAssignedContext)& aContext)
|
|
{
|
|
Standard_Integer status = 0;
|
|
// Decode the Uncertainty information (geometric accuracy)
|
|
|
|
hasUncertainty = Standard_False;
|
|
Standard_Integer nbUncertainty = 0;
|
|
|
|
if (!aContext.IsNull()) nbUncertainty = aContext->NbUncertainty();
|
|
else return 40;
|
|
|
|
for (Standard_Integer un = 1 ; un <= nbUncertainty ; un ++) {
|
|
Handle(StepBasic_UncertaintyMeasureWithUnit) aUMWU = aContext->UncertaintyValue(un);
|
|
if (aUMWU.IsNull()) {
|
|
#ifdef OCCT_DEBUG
|
|
std::cout<<"BAD Uncertainty Measure with Units, n0."<<un<<std::endl;
|
|
#endif
|
|
continue;
|
|
}
|
|
// Decode the associated Unit
|
|
Handle(StepBasic_SiUnitAndLengthUnit) aUnit =
|
|
Handle(StepBasic_SiUnitAndLengthUnit)::DownCast(aUMWU->UnitComponent().NamedUnit());
|
|
if (!aUnit.IsNull()) {
|
|
// Extract Uncertainty value
|
|
Standard_Real LengthUncertainty = aUMWU->ValueComponent();
|
|
// Update it according to the Length Unit Factor
|
|
//pdn r_47-sd.stp to choose minimal uncertainty
|
|
if(theUncertainty > LengthUncertainty) theUncertainty = LengthUncertainty;
|
|
hasUncertainty = Standard_True;
|
|
|
|
} else {
|
|
Handle(StepBasic_ConversionBasedUnitAndLengthUnit) aCBULU =
|
|
Handle(StepBasic_ConversionBasedUnitAndLengthUnit)::DownCast(aUMWU->UnitComponent().NamedUnit());
|
|
if (!aCBULU.IsNull()) {
|
|
// Extract Uncertainty value
|
|
Standard_Real LengthUncertainty = aUMWU->ValueComponent();
|
|
// Update it according to the Length Unit Factor
|
|
//pdn r_47-sd.stp to choose minimal uncertainty
|
|
if(theUncertainty > LengthUncertainty) theUncertainty = LengthUncertainty; // *lengthFactor; fait par appelant
|
|
hasUncertainty = Standard_True;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (hasUncertainty) std::cout << "UNCERTAINTY read as " << theUncertainty << std::endl;
|
|
#endif
|
|
return status;
|
|
}
|
|
|
|
// ==========================================================================
|
|
// Method : STEPConstruct_UnitContext::LengthFactor
|
|
// Purpose :
|
|
// ==========================================================================
|
|
Standard_Real STEPConstruct_UnitContext::LengthFactor() const
|
|
{ return lengthFactor; }
|
|
|
|
// ==========================================================================
|
|
// Method : STEPConstruct_UnitContext::PlaneAngleFactor
|
|
// Purpose :
|
|
// ==========================================================================
|
|
Standard_Real STEPConstruct_UnitContext::PlaneAngleFactor() const
|
|
{ return planeAngleFactor; }
|
|
|
|
// ==========================================================================
|
|
// Method : STEPConstruct_UnitContext::SolidAngleFactor
|
|
// Purpose :
|
|
// ==========================================================================
|
|
Standard_Real STEPConstruct_UnitContext::SolidAngleFactor() const
|
|
{ return solidAngleFactor; }
|
|
|
|
// ==========================================================================
|
|
// Method : STEPConstruct_UnitContext::Uncertainty
|
|
// Purpose :
|
|
// ==========================================================================
|
|
Standard_Real STEPConstruct_UnitContext::Uncertainty () const
|
|
{ return theUncertainty; }
|
|
|
|
// ==========================================================================
|
|
// Method : STEPConstruct_UnitContext::HasUncertainty
|
|
// Purpose :
|
|
// ==========================================================================
|
|
Standard_Boolean STEPConstruct_UnitContext::HasUncertainty () const
|
|
{ return hasUncertainty; }
|
|
|
|
// ==========================================================================
|
|
// Method : STEPConstruct_UnitContext::LengthDone
|
|
// Purpose :
|
|
// ==========================================================================
|
|
Standard_Boolean STEPConstruct_UnitContext::LengthDone() const
|
|
{ return lengthDone; }
|
|
|
|
// ==========================================================================
|
|
// Method : STEPConstruct_UnitContext::PlaneAngleDone
|
|
// Purpose :
|
|
// ==========================================================================
|
|
Standard_Boolean STEPConstruct_UnitContext::PlaneAngleDone() const
|
|
{ return planeAngleDone; }
|
|
|
|
// ==========================================================================
|
|
// Method : STEPConstruct_UnitContext::SolidAngleDone
|
|
// Purpose :
|
|
// ==========================================================================
|
|
Standard_Boolean STEPConstruct_UnitContext::SolidAngleDone() const
|
|
{ return solidAngleDone; }
|
|
|
|
// ==========================================================================
|
|
// Method : STEPConstruct_UnitContext::StatusMessage
|
|
// Purpose :
|
|
// ==========================================================================
|
|
Standard_CString STEPConstruct_UnitContext::StatusMessage (const Standard_Integer status) const
|
|
{
|
|
switch (status) {
|
|
case 0 : return "";
|
|
case 1 : return "No GlobalUnitAssignedContext, default taken";
|
|
case 2 : return "No LengthMeasureWithUnit, default taken";
|
|
case 3 : return "No SiUnit for LengthMeasure undefined, default taken";
|
|
case 4 : return "No PlaneAngleMeasureWithUnit, default taken";
|
|
case 5 : return "No SiUnit for PlaneAngleMeasure undefined, default taken";
|
|
case 6 : return "No SolidAngleMeasureWithUnit, default taken";
|
|
case 7 : return "No SiUnit for SolidAngleMeasure undefined, default taken";
|
|
|
|
case 11 : return "Length Unit not recognized, default taken";
|
|
case 12 : return "Plane Angle Unit not recognized, default taken";
|
|
case 13 : return "Solid Angle Unit not recognized, default taken";
|
|
case 14 : return "At least one unit is twice defined";
|
|
|
|
case 40 : return "Bad GlobalUncertaintyAssignedContext, default unit taken";
|
|
|
|
default : break;
|
|
}
|
|
|
|
return "Badly defined units, default taken";
|
|
}
|
|
|
|
Standard_Real STEPConstruct_UnitContext::AreaFactor() const
|
|
{
|
|
return areaFactor;
|
|
}
|
|
|
|
Standard_Real STEPConstruct_UnitContext::VolumeFactor() const
|
|
{
|
|
return volumeFactor;
|
|
}
|
|
|
|
Standard_Boolean STEPConstruct_UnitContext::AreaDone() const
|
|
{
|
|
return areaDone;
|
|
}
|
|
|
|
Standard_Boolean STEPConstruct_UnitContext::VolumeDone() const
|
|
{
|
|
return volumeDone;
|
|
}
|