{
return myPCurveMode;
}
+
+void BRepToIGES_BREntity::SetConvertSurfaceMode(const Standard_Boolean theVal)
+{
+ Interface_Static::SetIVal("write.convertsurface.mode", theVal);
+ myConvSurface = theVal;
+}
+
+Standard_EXPORT void BRepToIGES_BREntity::SetPCurveMode(const Standard_Boolean theVal)
+{
+ Interface_Static::SetIVal("write.surfacecurve.mode", theVal);
+ myPCurveMode = theVal;
+}
//=======================================================================
//function : ~BRepToIGES_BREntity
//! Returns mode for writing pcurves
//! (value of parameter write.surfacecurve.mode)
Standard_EXPORT Standard_Boolean GetPCurveMode() const;
+
+ Standard_EXPORT void SetConvertSurfaceMode(const Standard_Boolean theVal);
+
+ Standard_EXPORT void SetPCurveMode(const Standard_Boolean theVal);
Standard_EXPORT virtual ~BRepToIGES_BREntity();
+protected:
+
+ Standard_Boolean myConvSurface;
+ Standard_Boolean myPCurveMode;
+
private:
+
Handle(IGESData_IGESModel) TheModel;
Standard_Real TheUnitFactor;
- Standard_Boolean myConvSurface;
- Standard_Boolean myPCurveMode;
Handle(Transfer_FinderProcess) TheMap;
+
};
#endif // _BRepToIGES_BREntity_HeaderFile
GeomToIGES_GeomSurface GS;
//S4181 pdn 17.04.99 Boolean flags in order to define write of elementary surfaces added.
GS.SetBRepMode(Standard_True);
- GS.SetAnalyticMode ( Interface_Static::IVal("write.convertsurface.mode") ==0 );
+ GS.SetAnalyticMode (myConvSurface == 0 );
GS.SetModel(GetModel());
Handle(Geom_Surface) st;
Handle(IGESSolid_EdgeList) myEdgeList;
Handle(IGESSolid_VertexList) myVertexList;
-
};
GeomToIGES_GeomCurve::GeomToIGES_GeomCurve()
:GeomToIGES_GeomEntity()
{
+ myOffsetModeIVal = Interface_Static::IVal("write.iges.offset.mode");
}
(const GeomToIGES_GeomEntity& GE)
:GeomToIGES_GeomEntity(GE)
{
+ myOffsetModeIVal = Interface_Static::IVal("write.iges.offset.mode");
}
if (Precision::IsNegativeInfinite(Udeb)) U1 = -Precision::Infinite();
if (Precision::IsPositiveInfinite(Ufin)) U2 = Precision::Infinite();
- if (Interface_Static::IVal("write.iges.offset.mode") == 0)
+ if (myOffsetModeIVal == 0)
{
res = TransferCurve(GeomConvert::CurveToBSplineCurve(start),U1,U2);
return res;
res = OffsetC;
return res;
}
+
+void GeomToIGES_GeomCurve::SetOffsetModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.iges.offset.mode", theVal);
+ myOffsetModeIVal = theVal;
+}
+
+Standard_Integer GeomToIGES_GeomCurve::GetOffsetModeIVal() const
+{
+ return myOffsetModeIVal;
+}
Standard_EXPORT Handle(IGESData_IGESEntity) TransferCurve (const Handle(Geom_OffsetCurve)& start, const Standard_Real Udeb, const Standard_Real Ufin);
+ Standard_EXPORT void SetOffsetModeIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetOffsetModeIVal() const;
protected:
private:
-
+ Standard_Integer myOffsetModeIVal;
};
{
myBRepMode = Standard_False;
myAnalytic = Standard_False;
+ myPlaneModeIVal = Interface_Static::IVal("write.iges.plane.mode");
}
{
myBRepMode = Standard_False;
myAnalytic = Standard_False;
+ myPlaneModeIVal = Interface_Static::IVal("write.iges.plane.mode");
}
if (start.IsNull()) {
return res;
}
- if (Interface_Static::IVal("write.iges.plane.mode") == 0){
+ if (myPlaneModeIVal == 0){
Handle(IGESGeom_Plane) aPlane = new IGESGeom_Plane;
Standard_Real A,B,C,D;
start->Coefficients(A,B,C,D);
myAnalytic = flag;
}
+void GeomToIGES_GeomSurface::SetPlaneModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.iges.plane.mode", theVal);
+ myPlaneModeIVal = theVal;
+}
+
+Standard_Integer GeomToIGES_GeomSurface::GetPlaneModeIVal() const
+{
+ return myPlaneModeIVal;
+}
//! Setst flag for writing elementary surfaces
Standard_EXPORT void SetAnalyticMode (const Standard_Boolean flag);
+ Standard_EXPORT void SetPlaneModeIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetPlaneModeIVal() const;
protected:
Standard_Real TheLength;
Standard_Boolean myBRepMode;
Standard_Boolean myAnalytic;
+ Standard_Integer myPlaneModeIVal;
};
IMPLEMENT_STANDARD_RTTIEXT(IGESControl_ActorWrite,Transfer_ActorOfFinderProcess)
-IGESControl_ActorWrite::IGESControl_ActorWrite () { ModeTrans() = 0; }
+IGESControl_ActorWrite::IGESControl_ActorWrite ()
+{
+ ModeTrans() = 0;
+ myPrecRVal = Interface_Static::RVal("write.precision.val");
+ myMaxPrecRVal = Interface_Static::RVal("read.maxprecision.val");
+}
Standard_Boolean IGESControl_ActorWrite::Recognize
(const Handle(Transfer_Finder)& start)
if (shape.IsNull()) return NullResult();
// modified by NIZHNY-EAP Tue Aug 29 11:16:54 2000 ___BEGIN___
Handle(Standard_Transient) info;
- Standard_Real Tol = Interface_Static::RVal("write.precision.val");
- Standard_Real maxTol = Interface_Static::RVal("read.maxprecision.val");
+ Standard_Real Tol = myPrecRVal;
+ Standard_Real maxTol = myMaxPrecRVal;
shape = XSAlgo::AlgoContainer()->ProcessShape( shape, Tol, maxTol,
"write.iges.resource.name",
"write.iges.sequence", info,
return NullResult();
}
+
+void IGESControl_ActorWrite::SetPrecRVal(const Standard_Real theVal)
+{
+ Interface_Static::SetRVal("write.precision.val", theVal);
+ myPrecRVal = theVal;
+}
+
+void IGESControl_ActorWrite::SetMaxPrecRVal(const Standard_Real theVal)
+{
+ Interface_Static::SetRVal("read.maxprecision.val", theVal);
+ myMaxPrecRVal = theVal;
+}
+
+Standard_Real IGESControl_ActorWrite::GetPrecRVal() const
+{
+ return myPrecRVal;
+}
+
+Standard_Real IGESControl_ActorWrite::GetMaxPrecRVal() const
+{
+ return myMaxPrecRVal;
+}
const Handle(Transfer_FinderProcess)& FP,
const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
+ Standard_EXPORT void SetPrecRVal(const Standard_Real theVal);
+ Standard_EXPORT void SetMaxPrecRVal(const Standard_Real theVal);
+ Standard_EXPORT Standard_Real GetPrecRVal() const;
+
+ Standard_EXPORT Standard_Real GetMaxPrecRVal() const;
DEFINE_STANDARD_RTTIEXT(IGESControl_ActorWrite,Transfer_ActorOfFinderProcess)
private:
-
+ Standard_Real myPrecRVal;
+ Standard_Real myMaxPrecRVal;
};
//=======================================================================
IGESControl_IGESBoundary::IGESControl_IGESBoundary() : IGESToBRep_IGESBoundary()
{
+ myParModeIVal = Interface_Static::IVal("read.stdsameparameter.mode");
}
//=======================================================================
IGESControl_IGESBoundary::IGESControl_IGESBoundary(const IGESToBRep_CurveAndSurface& CS) :
IGESToBRep_IGESBoundary (CS)
{
+ myParModeIVal = Interface_Static::IVal("read.stdsameparameter.mode");
}
//=======================================================================
#endif
}
//#74 rln 10.03.99 S4135: handling use of BRepLib::SameParameter by new static parameter
- if (Interface_Static::IVal ("read.stdsameparameter.mode")) {
+ if (myParModeIVal) {
Standard_Real first, last;
BRep_Tool::Range(edge3d,first,last);
// pdn 08.04.99 S4135 optimizing in computation of SPTol
return okCurve;
}
+void IGESControl_IGESBoundary::SetParModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.stdsameparameter.mode", theVal);
+ myParModeIVal = theVal;
+}
+
+Standard_Integer IGESControl_IGESBoundary::GetParModeIVal() const
+{
+ return myParModeIVal;
+}
\ No newline at end of file
//! wire to contain only closed representation.
Standard_EXPORT virtual void Check (const Standard_Boolean result, const Standard_Boolean checkclosure, const Standard_Boolean okCurve3d, const Standard_Boolean okCurve2d) Standard_OVERRIDE;
+ Standard_EXPORT void SetParModeIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT Standard_Integer GetParModeIVal() const;
+
DEFINE_STANDARD_RTTIEXT(IGESControl_IGESBoundary,IGESToBRep_IGESBoundary)
protected:
Standard_EXPORT virtual Standard_Boolean Transfer (Standard_Boolean& okCurve, Standard_Boolean& okCurve3d, Standard_Boolean& okCurve2d, const Handle(IGESData_IGESEntity)& icurve3d, const Handle(ShapeExtend_WireData)& scurve3d, const Standard_Boolean usescurve, const Standard_Boolean toreverse3d, const Handle(IGESData_HArray1OfIGESEntity)& curves2d, const Standard_Boolean toreverse2d, const Standard_Integer number, Handle(ShapeExtend_WireData)& lsewd) Standard_OVERRIDE;
+private:
+
+ Standard_Integer myParModeIVal;
+
};
#endif // _IGESControl_IGESBoundary_HeaderFile
SetWS (new XSControl_WorkSession);
SetNorm("IGES");
Standard_Integer onlyvisible = Interface_Static::IVal("read.iges.onlyvisible");
- theReadOnlyVisible = (onlyvisible == 1);
+ myOnlyVisIVal = (onlyvisible == 1);
}
SetWS (WS,scratch);
SetNorm ("IGES");
Standard_Integer onlyvisible = Interface_Static::IVal("read.iges.onlyvisible");
- theReadOnlyVisible = (onlyvisible == 1);
+ myOnlyVisIVal = (onlyvisible == 1);
}
Interface_ShareFlags SH (model,protocol);
// sln 11.06.2002 OCC448
- Interface_Static::SetIVal("read.iges.onlyvisible",theReadOnlyVisible);
+ Interface_Static::SetIVal("read.iges.onlyvisible",myOnlyVisIVal);
Standard_Integer nb = model->NbEntities();
for (Standard_Integer i = 1; i <= nb; i ++) {
Handle(IGESData_IGESEntity) ent = model->Entity(i);
if ( SH.IsShared(ent) || ! actor->Recognize (ent) ) continue;
// on ajoute un traitement pour ne prendre que les entites visibles
- if ( ! theReadOnlyVisible || ent->BlankStatus() == 0 ) {
+ if ( ! myOnlyVisIVal || ent->BlankStatus() == 0 ) {
theroots.Append(ent);
}
}
}
}
}
+
+void IGESControl_Reader::SetOnlyVisibleIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.iges.onlyvisible", theVal);
+ myOnlyVisIVal = theVal;
+}
+
+Standard_Integer IGESControl_Reader::GetOnlyVisibleIVal() const
+{
+ return myOnlyVisIVal;
+}
//! Prints Statistics and check list for Transfer
Standard_EXPORT void PrintTransferInfo (const IFSelect_PrintFail failwarn, const IFSelect_PrintCount mode) const;
+ Standard_EXPORT void SetOnlyVisibleIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetOnlyVisibleIVal() const;
protected:
- Standard_Boolean theReadOnlyVisible;
+ Standard_Boolean myOnlyVisIVal;
};
inline void IGESControl_Reader::SetReadVisible (const Standard_Boolean ReadRoot)
{
- theReadOnlyVisible = ReadRoot;
+ myOnlyVisIVal = ReadRoot;
}
inline Standard_Boolean IGESControl_Reader::GetReadVisible ()const
{
- return theReadOnlyVisible;
+ return myOnlyVisIVal;
}
myIsComputed (Standard_False)
{
// faudrait aussi (?) prendre les parametres par defaut ... ?
+ myUnitCVal = Interface_Static::CVal("write.iges.unit");
+ myBRepModeIVal = Interface_Static::IVal("write.iges.brep.mode");
+ myPrecRVal = Interface_Static::RVal("write.precision.val");
+ myMaxPrecRVal = Interface_Static::RVal("read.maxprecision.val");
+ myPrecModeIVal = Interface_Static::IVal("write.precision.mode");
IGESControl_Controller::Init();
myEditor.Init(IGESSelect_WorkLibrary::DefineProtocol());
- myEditor.SetUnitName(Interface_Static::CVal ("write.iges.unit"));
+ myEditor.SetUnitName(myUnitCVal);
myEditor.ApplyUnit();
- myWriteMode = Interface_Static::IVal ("write.iges.brep.mode");
myModel = myEditor.Model();
}
IGESControl_Writer::IGESControl_Writer
(const Standard_CString unit, const Standard_Integer modecr)
: myTP (new Transfer_FinderProcess(10000)) ,
- myWriteMode (modecr) , myIsComputed (Standard_False)
+ myBRepModeIVal (modecr) , myIsComputed (Standard_False)
{
// faudrait aussi (?) prendre les parametres par defaut ... ?
+ myUnitCVal = Interface_Static::CVal("write.iges.unit");
+ myBRepModeIVal = Interface_Static::IVal("write.iges.brep.mode");
+ myPrecRVal = Interface_Static::RVal("write.precision.val");
+ myMaxPrecRVal = Interface_Static::RVal("read.maxprecision.val");
+ myPrecModeIVal = Interface_Static::IVal("write.precision.mode");
IGESControl_Controller::Init();
myEditor.Init(IGESSelect_WorkLibrary::DefineProtocol());
myEditor.SetUnitName(unit);
: myTP (new Transfer_FinderProcess(10000)) ,
myModel (model) ,
myEditor (model,IGESSelect_WorkLibrary::DefineProtocol()) ,
- myWriteMode (modecr) , myIsComputed (Standard_False) { }
+ myBRepModeIVal (modecr) , myIsComputed (Standard_False)
+{
+ myUnitCVal = Interface_Static::CVal("write.iges.unit");
+ myBRepModeIVal = Interface_Static::IVal("write.iges.brep.mode");
+ myPrecRVal = Interface_Static::RVal("write.precision.val");
+ myMaxPrecRVal = Interface_Static::RVal("read.maxprecision.val");
+ myPrecModeIVal = Interface_Static::IVal("write.precision.mode");
+}
Standard_Boolean IGESControl_Writer::AddShape (const TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress)
Message_ProgressScope aPS(theProgress, NULL, 2);
// modified by NIZHNY-EAP Tue Aug 29 11:16:54 2000 ___BEGIN___
Handle(Standard_Transient) info;
- Standard_Real Tol = Interface_Static::RVal("write.precision.val");
- Standard_Real maxTol = Interface_Static::RVal("read.maxprecision.val");
+ Standard_Real Tol = myPrecRVal;
+ Standard_Real maxTol = myMaxPrecRVal;
TopoDS_Shape Shape = XSAlgo::AlgoContainer()->ProcessShape( theShape, Tol, maxTol,
"write.iges.resource.name",
"write.iges.sequence", info,
// modified by NIZHNY-EAP Tue Aug 29 11:17:01 2000 ___END___
BRepToIGES_BREntity B0; B0.SetTransferProcess(myTP); B0.SetModel(myModel);
BRepToIGESBRep_Entity B1; B1.SetTransferProcess(myTP); B1.SetModel(myModel);
- Handle(IGESData_IGESEntity) ent = myWriteMode?
+ Handle(IGESData_IGESEntity) ent = myBRepModeIVal?
B1.TransferShape (Shape, aPS.Next()) : B0.TransferShape(Shape, aPS.Next());
if (!aPS.More())
return Standard_False;
Standard_Real oldtol = myModel->GlobalSection().Resolution(), newtol;
- Standard_Integer tolmod = Interface_Static::IVal("write.precision.mode");
+ Standard_Integer tolmod = myPrecModeIVal;
if (tolmod == 2)
- newtol = Interface_Static::RVal("write.precision.val");
+ newtol = myPrecRVal;
else {
ShapeAnalysis_ShapeTolerance stu;
Standard_Real Tolv = stu.Tolerance (Shape, tolmod, TopAbs_VERTEX);
return res;
}
+
+void IGESControl_Writer::SetUnitCVal(const Standard_CString& theVal)
+{
+ Interface_Static::SetCVal("write.iges.unit", theVal);
+ myUnitCVal = theVal;
+}
+
+void IGESControl_Writer::SetBRepModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.iges.brep.mode", theVal);
+ myBRepModeIVal = theVal;
+}
+
+void IGESControl_Writer::SetPrecRVal(const Standard_Real theVal)
+{
+ Interface_Static::SetRVal("write.precision.val", theVal);
+ myPrecRVal = theVal;
+}
+
+void IGESControl_Writer::SetMaxPrecRVal(const Standard_Real theVal)
+{
+ Interface_Static::SetRVal("read.maxprecision.val", theVal);
+ myMaxPrecRVal = theVal;
+}
+
+void IGESControl_Writer::SetPrecModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.precision.mode", theVal);
+ myPrecModeIVal = theVal;
+}
+
+Standard_CString IGESControl_Writer::GetUnitCVal() const
+{
+ return myUnitCVal;
+}
+
+Standard_Integer IGESControl_Writer::GetBRepModeIVal() const
+{
+ return myBRepModeIVal;
+}
+
+Standard_Real IGESControl_Writer::GetPrecRVal() const
+{
+ return myPrecRVal;
+}
+
+Standard_Real IGESControl_Writer::GetMaxPrecRVal() const
+{
+ return myMaxPrecRVal;
+}
+Standard_Integer IGESControl_Writer::GetPrecModeIVal() const
+{
+ return myPrecModeIVal;
+}
//! if the processor could not create the file).
Standard_EXPORT Standard_Boolean Write (const Standard_CString file, const Standard_Boolean fnes = Standard_False);
+ Standard_EXPORT void SetUnitCVal(const Standard_CString& theVal);
+
+ Standard_EXPORT void SetBRepModeIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetPrecRVal(const Standard_Real theVal);
+
+ Standard_EXPORT void SetMaxPrecRVal(const Standard_Real theVal);
+
+ Standard_EXPORT void SetPrecModeIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT Standard_CString GetUnitCVal() const;
+
+ Standard_EXPORT Standard_Integer GetBRepModeIVal() const;
+
+ Standard_EXPORT Standard_Real GetPrecRVal() const;
+
+ Standard_EXPORT Standard_Real GetMaxPrecRVal() const;
+
+ Standard_EXPORT Standard_Integer GetPrecModeIVal() const;
+
private:
Handle(Transfer_FinderProcess) myTP;
Handle(IGESData_IGESModel) myModel;
IGESData_BasicEditor myEditor;
- Standard_Integer myWriteMode;
+ Standard_CString myUnitCVal;
+ Standard_Integer myBRepModeIVal;
+ Standard_Real myPrecRVal;
+ Standard_Real myMaxPrecRVal;
+ Standard_Integer myPrecModeIVal;
Standard_Boolean myIsComputed;
};
return Standard_True;
}
- Standard_CString val;
if (param[0] == 'r') {
- val = Interface_Static::CVal("write.iges.header.receiver");
- if (!val || val[0] == '\0') return Standard_False;
- theheader.SetReceiveName (new TCollection_HAsciiString(val));
+ myHeadRecCVal = Interface_Static::CVal("write.iges.header.receiver");
+ if (!myHeadRecCVal || myHeadRecCVal[0] == '\0') return Standard_False;
+ theheader.SetReceiveName (new TCollection_HAsciiString(myHeadRecCVal));
}
if (param[0] == 'a') {
- val = Interface_Static::CVal("write.iges.header.author");
- if (!val || val[0] == '\0') return Standard_False;
- theheader.SetAuthorName (new TCollection_HAsciiString(val));
+ myHeadAuthorCVal = Interface_Static::CVal("write.iges.header.author");
+ if (!myHeadAuthorCVal || myHeadAuthorCVal[0] == '\0') return Standard_False;
+ theheader.SetAuthorName (new TCollection_HAsciiString(myHeadAuthorCVal));
}
if (param[0] == 'c') {
- val = Interface_Static::CVal("write.iges.header.company");
- if (!val || val[0] == '\0') return Standard_False;
- theheader.SetCompanyName (new TCollection_HAsciiString(val));
+ myHeadCompCVal = Interface_Static::CVal("write.iges.header.company");
+ if (!myHeadCompCVal || myHeadCompCVal[0] == '\0') return Standard_False;
+ theheader.SetCompanyName (new TCollection_HAsciiString(myHeadCompCVal));
}
return Standard_True;
}
}
return label;
}
+
+void IGESData_IGESModel::SetHeaderReciever(const Standard_CString& theVal)
+{
+ Interface_Static::SetCVal("write.iges.header.receiver", theVal);
+ myHeadRecCVal = theVal;
+}
+
+void IGESData_IGESModel::SetHeaderAuthor(const Standard_CString& theVal)
+{
+ Interface_Static::SetCVal("write.iges.header.author", theVal);
+ myHeadRecCVal = theVal;
+}
+
+void IGESData_IGESModel::SetHeaderCompany(const Standard_CString& theVal)
+{
+ Interface_Static::SetCVal("write.iges.header.company", theVal);
+ myHeadRecCVal = theVal;
+}
+
+Standard_CString IGESData_IGESModel::GetHeaderReciever() const
+{
+ return myHeadRecCVal;
+}
+
+Standard_CString IGESData_IGESModel::GetHeaderAuthor() const
+{
+ return myHeadAuthorCVal;
+}
+
+Standard_CString IGESData_IGESModel::GetHeaderCompany() const
+{
+ return myHeadCompCVal;
+}
//! i.e. a string "Dnn" with nn = directory entry number (2*N-1)
Standard_EXPORT Handle(TCollection_HAsciiString) StringLabel (const Handle(Standard_Transient)& ent) const Standard_OVERRIDE;
+ Standard_EXPORT void SetHeaderReciever(const Standard_CString& theVal);
+ Standard_EXPORT void SetHeaderAuthor(const Standard_CString& theVal);
+
+ Standard_EXPORT void SetHeaderCompany(const Standard_CString& theVal);
+
+ Standard_EXPORT Standard_CString GetHeaderReciever() const;
+
+ Standard_EXPORT Standard_CString GetHeaderAuthor() const;
+
+ Standard_EXPORT Standard_CString GetHeaderCompany() const;
DEFINE_STANDARD_RTTIEXT(IGESData_IGESModel,Interface_InterfaceModel)
Handle(TColStd_HSequenceOfHAsciiString) thestart;
IGESData_GlobalSection theheader;
+ Standard_CString myHeadRecCVal;
+ Standard_CString myHeadAuthorCVal;
+ Standard_CString myHeadCompCVal;
+
};
//purpose :
//=======================================================================
IGESToBRep_Actor::IGESToBRep_Actor ()
-{ thecontinuity = 0; theeps = 0.0001; }
+{
+ thecontinuity = 0;
+ theeps = 0.0001;
+}
//=======================================================================
{
themodel = model;
theeps = Handle(IGESData_IGESModel)::DownCast(themodel)->GlobalSection().Resolution();
+ myApproxd1IVal = Interface_Static::IVal("read.iges.bspline.approxd1.mode");
+ myFaultyEntIVal = Interface_Static::IVal("read.iges.faulty.entities");
+ myPrecModeIVal = Interface_Static::IVal("read.precision.mode");
+ myPrecRVal = Interface_Static::RVal("read.precision.val");;
+ mySurfaceCurIVal = Interface_Static::IVal("read.surfacecurve.mode");
}
if (mymodel.IsNull() || ent.IsNull()) return NullResult();
Standard_Integer anum = mymodel->Number(start);
- if (Interface_Static::IVal("read.iges.faulty.entities") == 0 && mymodel->IsErrorEntity(anum))
+ if (myFaultyEntIVal == 0 && mymodel->IsErrorEntity(anum))
return NullResult();
TopoDS_Shape shape;
CAS.SetModel(mymodel);
CAS.SetContinuity(thecontinuity);
CAS.SetTransferProcess(TP);
- Standard_Integer Ival = Interface_Static::IVal("read.precision.mode");
+ Standard_Integer Ival = myPrecModeIVal;
if ( Ival == 0)
eps = mymodel->GlobalSection().Resolution();
else
- eps = Interface_Static::RVal("read.precision.val"); //:10 ABV 11 Nov 97
+ eps = myPrecRVal; //:10 ABV 11 Nov 97
//:10 eps = BRepAPI::Precision();
- Ival = Interface_Static::IVal("read.iges.bspline.approxd1.mode");
+ Ival = myApproxd1IVal;
CAS.SetModeApprox ( (Ival > 0) );
- Ival = Interface_Static::IVal("read.surfacecurve.mode");
+ Ival = mySurfaceCurIVal;
CAS.SetSurfaceCurve (Ival);
if (eps > 1.E-08) {
}
- Standard_Real IGESToBRep_Actor::UsedTolerance () const
- { return theeps; }
+Standard_Real IGESToBRep_Actor::UsedTolerance () const
+{
+ return theeps;
+}
+
+void IGESToBRep_Actor::SetApproxd1IVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.iges.bspline.approxd1.mode", theVal);
+ myApproxd1IVal = theVal;
+}
+
+void IGESToBRep_Actor::SetFaultyEntIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.iges.faulty.entities", theVal);
+ myFaultyEntIVal = myFaultyEntIVal;
+}
+
+void IGESToBRep_Actor::SetPrecModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.precision.mode", theVal);
+ myPrecModeIVal = theVal;
+}
+
+void IGESToBRep_Actor::SetPrecRVal(const Standard_Real theVal)
+{
+ Interface_Static::SetRVal("read.precision.val", theVal);
+ myPrecRVal = theVal;
+}
+
+void IGESToBRep_Actor::SetSurfaceCurIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.surfacecurve.mode", theVal);
+ mySurfaceCurIVal = theVal;
+}
+
+Standard_Integer IGESToBRep_Actor::GetApproxd1IVal() const
+{
+ return myApproxd1IVal;
+}
+
+Standard_Integer IGESToBRep_Actor::GetFaultyEntIVal() const
+{
+ return myFaultyEntIVal;
+}
+
+Standard_Integer IGESToBRep_Actor::GetPrecModeIVal() const
+{
+ return myPrecModeIVal;
+}
+
+Standard_Real IGESToBRep_Actor::GetPrecRVal() const
+{
+ return myPrecRVal;
+}
+
+Standard_Integer IGESToBRep_Actor::GetSurfaceCurIVal() const
+{
+ return mySurfaceCurIVal;
+}
//! the file or from statics
Standard_EXPORT Standard_Real UsedTolerance() const;
+ Standard_EXPORT void SetApproxd1IVal(const Standard_Integer theVal);
+ Standard_EXPORT void SetFaultyEntIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetPrecModeIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetPrecRVal(const Standard_Real theVal);
+
+ Standard_EXPORT void SetSurfaceCurIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT Standard_Integer GetApproxd1IVal() const;
+
+ Standard_EXPORT Standard_Integer GetFaultyEntIVal() const;
+
+ Standard_EXPORT Standard_Integer GetPrecModeIVal() const;
+
+ Standard_EXPORT Standard_Real GetPrecRVal() const;
+
+ Standard_EXPORT Standard_Integer GetSurfaceCurIVal() const;
DEFINE_STANDARD_RTTIEXT(IGESToBRep_Actor,Transfer_ActorOfTransientProcess)
Handle(Interface_InterfaceModel) themodel;
Standard_Integer thecontinuity;
Standard_Real theeps;
+ Standard_Integer myApproxd1IVal;
+ Standard_Integer myFaultyEntIVal;
+ Standard_Integer myPrecModeIVal;
+ Standard_Real myPrecRVal;
+ Standard_Integer mySurfaceCurIVal;
};
myIsResolCom (Standard_False),
myTP (new Transfer_TransientProcess())
{
+ myOnlyVisibleIVal = Interface_Static::IVal("read.iges.onlyvisible");
+ myMaxPrecRVal = Interface_Static::RVal("read.maxprecision.val");
UpdateMinMaxTol();
}
myIsResolCom (Standard_False),
myTP (new Transfer_TransientProcess())
{
+ myOnlyVisibleIVal = Interface_Static::IVal("read.iges.onlyvisible");
+ myMaxPrecRVal = Interface_Static::RVal("read.maxprecision.val");
UpdateMinMaxTol();
}
mySurface.Nullify();
myIsResolCom = Standard_False;
myUVResolution = 0.;
+ myOnlyVisibleIVal = Interface_Static::IVal("read.iges.onlyvisible");
+ myMaxPrecRVal = Interface_Static::RVal("read.maxprecision.val");
UpdateMinMaxTol();
}
{
//#74 rln 11.03.99 S4135: Setting maximum tolerances according to
//static parameter
- myMaxTol = Max (Interface_Static::RVal ("read.maxprecision.val"), myEpsGeom * myUnitFactor);
+ myMaxTol = Max (myMaxPrecRVal, myEpsGeom * myUnitFactor);
myMinTol = Precision::Confusion();
+
}
//=======================================================================
// sln 13.06.2002 OCC448: Avoid transferring invisible sub entities which
// logically depend on the one
- Standard_Integer onlyvisible = Interface_Static::IVal("read.iges.onlyvisible");
+ Standard_Integer onlyvisible = myOnlyVisibleIVal;
if (IGESToBRep::IsCurveAndSurface(start)) {
if(onlyvisible && start->BlankStatus() == 1)
return myUVResolution;
}
+void IGESToBRep_CurveAndSurface::SetOnlyVisibleIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.iges.onlyvisible", theVal);
+ myOnlyVisibleIVal = theVal;
+}
+
+void IGESToBRep_CurveAndSurface::SetMaxPrecRVal(const Standard_Real theVal)
+{
+ Interface_Static::SetRVal("read.maxprecision.val", theVal);
+ myMaxPrecRVal = theVal;
+}
+Standard_Integer IGESToBRep_CurveAndSurface::GetOnlyVisibleIVal() const
+{
+ return myOnlyVisibleIVal;
+}
+
+Standard_Real IGESToBRep_CurveAndSurface::GetMaxPrecRVal() const
+{
+ return myMaxPrecRVal;
+}
Standard_EXPORT Standard_Real GetUVResolution();
+ Standard_EXPORT void SetOnlyVisibleIVal(const Standard_Integer theVal);
+ Standard_EXPORT void SetMaxPrecRVal(const Standard_Real theVal);
+
+ Standard_EXPORT Standard_Integer GetOnlyVisibleIVal() const;
+
+ Standard_EXPORT Standard_Real GetMaxPrecRVal() const;
protected:
Standard_Boolean myIsResolCom;
Handle(IGESData_IGESModel) myModel;
Handle(Transfer_TransientProcess) myTP;
+ Standard_Integer myOnlyVisibleIVal;
+ Standard_Real myMaxPrecRVal;
};
theModel = model;
theDone = Standard_False;
theShapes.Clear();
+ myApproxd1IVal = Interface_Static::IVal("read.iges.bspline.approxd1.mode");
+ myBSContinuityIVal = Interface_Static::IVal("read.iges.bspline.continuity");
+ myOnlyVisIVal = Interface_Static::IVal("read.iges.onlyvisible");
+ myPrecModeIVal = Interface_Static::IVal("read.precision.mode");
+ myPrecRVal = Interface_Static::RVal("read.precision.val");
+ mySurfaceCurIVal = Interface_Static::IVal("read.surfacecurve.mode");
if ( theProc.IsNull() )
theProc = new Transfer_TransientProcess (theModel->NbEntities());
else
//function : TransferRoots
//purpose : Transfers all Roots Entities
//=======================================================================
-void IGESToBRep_Reader::TransferRoots (const Standard_Boolean onlyvisible,
+void IGESToBRep_Reader::TransferRoots (const Standard_Boolean theOnlyVisible,
const Message_ProgressRange& theProgress)
{
if (theModel.IsNull() || theProc.IsNull()) return;
theProc->SetRootManagement(Standard_True);
// PrepareTransfer(); -> protocol, actor
theActor->SetModel(theModel);
- Standard_Integer continuity = Interface_Static::IVal("read.iges.bspline.continuity");
+ Standard_Integer continuity = myBSContinuityIVal;
theActor->SetContinuity (continuity);
theProc->SetModel (theModel);
theProc->SetActor (theActor);
ShapeExtend_Explorer SBE;
- Standard_Integer precisionMode = Interface_Static::IVal("read.precision.mode");
+ Standard_Integer precisionMode = myPrecModeIVal;
Message_Msg msg2035("IGES_2035");
msg2035.Arg(precisionMode);
TF->Send (msg2035, Message_Info);
if (precisionMode==1) {
Message_Msg msg2040("IGES_2040");
- msg2040.Arg(Interface_Static::RVal("read.precision.val"));//#70 rln 03.03.99
+ msg2040.Arg(myPrecRVal);//#70 rln 03.03.99
TF->Send (msg2040, Message_Info);
}
Message_Msg msg2045("IGES_2045");
msg2045.Arg(continuity);
TF->Send (msg2045, Message_Info);
Message_Msg msg2050("IGES_2050");
- msg2050.Arg(Interface_Static::IVal("read.surfacecurve.mode"));
+ msg2050.Arg(mySurfaceCurIVal);
TF->Send (msg2050, Message_Info);
// sln 11.06.2002 OCC448
- Interface_Static::SetIVal("read.iges.onlyvisible",onlyvisible);
+ SetOnlyVisIVal(theOnlyVisible);
Message_ProgressScope PS (theProgress, "Root", nb);
for (Standard_Integer i = 1; i <= nb && PS.More(); i++)
TF->Send (msg2070, Message_Info);
}
// on ajoute un traitement pour ne prendre que les entites visibles
- if ( ! onlyvisible || ent->BlankStatus() == 0 ) {
+ if ( ! theOnlyVisible || ent->BlankStatus() == 0 ) {
TopoDS_Shape shape;
theDone = Standard_True;
try {
IGESToBRep_CurveAndSurface CAS;
CAS.SetModel(theModel);
Standard_Real eps;
- Standard_Integer Ival = Interface_Static::IVal("read.precision.mode");
+ Standard_Integer Ival = myPrecModeIVal;
Message_Msg msg2035("IGES_2035");
msg2035.Arg(Ival);
TF->Send (msg2035, Message_Info);
eps = theModel->GlobalSection().Resolution();
else {
//mjm : modif du 19/12/97 pour prise en compte effective du parametre
- eps = Interface_Static::RVal("read.precision.val");
+ eps = myPrecRVal;
Message_Msg msg2040("IGES_2040");
msg2040.Arg(eps);//#70 rln 03.03.99
TF->Send (msg2040, Message_Info);
}
- Ival = Interface_Static::IVal("read.iges.bspline.approxd1.mode");
+ Ival = myApproxd1IVal;
CAS.SetModeApprox ( (Ival > 0) );
Message_Msg msg2045("IGES_2045");
- Ival = Interface_Static::IVal("read.iges.bspline.continuity");
+ Ival = myBSContinuityIVal;
msg2045.Arg(Ival);
TF->Send (msg2045, Message_Info);
CAS.SetContinuity(Ival);
Message_Msg msg2050("IGES_2050");
- Ival = Interface_Static::IVal("read.surfacecurve.mode");
+ Ival = mySurfaceCurIVal;
msg2050.Arg(Ival);
TF->Send (msg2050, Message_Info);
CAS.SetSurfaceCurve (Ival);
return C;
}
}
+
+void IGESToBRep_Reader::SetBSContinuityIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.iges.bspline.continuity", theVal);
+ myBSContinuityIVal = theVal;
+}
+
+void IGESToBRep_Reader::SetPrecModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.precision.mode", theVal);
+ myPrecModeIVal = theVal;
+}
+
+void IGESToBRep_Reader::SetPrecRVal(const Standard_Real theVal)
+{
+ Interface_Static::SetRVal("read.precision.val", theVal);
+ myPrecRVal = theVal;
+}
+
+void IGESToBRep_Reader::SetSurfaceCurIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.surfacecurve.mode", theVal);
+ mySurfaceCurIVal = theVal;
+}
+
+void IGESToBRep_Reader::SetOnlyVisIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.iges.onlyvisible", theVal);
+ myOnlyVisIVal = theVal;
+}
+
+void IGESToBRep_Reader::SetApproxd1IVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.iges.bspline.approxd1.mode", theVal);
+ myApproxd1IVal = theVal;
+}
+
+Standard_Integer IGESToBRep_Reader::GetBSContinuityIVal() const
+{
+ return myBSContinuityIVal;
+}
+
+Standard_Integer IGESToBRep_Reader::GetPrecModeIVal() const
+{
+ return myPrecModeIVal;
+}
+
+Standard_Real IGESToBRep_Reader::GetPrecRVal() const
+{
+ return myPrecRVal;
+}
+
+Standard_Integer IGESToBRep_Reader::GetSurfaceCurIVal() const
+{
+ return mySurfaceCurIVal;
+}
+
+Standard_Integer IGESToBRep_Reader::GetOnlyVisIVal() const
+{
+ return myOnlyVisIVal;
+}
+
+Standard_Integer IGESToBRep_Reader::GetApproxd1IVal() const
+{
+ return myApproxd1IVal;
+}
//! - a compound containing the resulting shapes if there are several.
Standard_EXPORT TopoDS_Shape OneShape() const;
+ Standard_EXPORT void SetBSContinuityIVal(const Standard_Integer theVal);
+ Standard_EXPORT void SetPrecModeIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetPrecRVal(const Standard_Real theVal);
+
+ Standard_EXPORT void SetSurfaceCurIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetOnlyVisIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetApproxd1IVal(const Standard_Integer theVal);
+
+ Standard_EXPORT Standard_Integer GetBSContinuityIVal() const;
+
+ Standard_EXPORT Standard_Integer GetPrecModeIVal() const;
+
+ Standard_EXPORT Standard_Real GetPrecRVal() const;
+
+ Standard_EXPORT Standard_Integer GetSurfaceCurIVal() const;
+
+ Standard_EXPORT Standard_Integer GetOnlyVisIVal() const;
+
+ Standard_EXPORT Standard_Integer GetApproxd1IVal() const;
protected:
TopTools_SequenceOfShape theShapes;
Handle(IGESToBRep_Actor) theActor;
Handle(Transfer_TransientProcess) theProc;
+ Standard_Integer myBSContinuityIVal;
+ Standard_Integer myPrecModeIVal;
+ Standard_Real myPrecRVal;
+ Standard_Integer mySurfaceCurIVal;
+ Standard_Integer myOnlyVisIVal; // setter
+ Standard_Integer myApproxd1IVal;
};
myMatMode(Standard_True),
myViewMode(Standard_True)
{
+ mySubshapesIVal = Interface_Static::IVal("read.stepcaf.subshapes.name");
STEPCAFControl_Controller::Init();
}
myReader.SetWS(WS, scratch);
myFiles.Clear();
myMap.Clear();
+ mySubshapesIVal = Interface_Static::IVal("read.stepcaf.subshapes.name");
}
//=======================================================================
TColStd_MapOfTransient aRepItems;
// Read translation control variables
- Standard_Boolean doReadSNames = (Interface_Static::IVal("read.stepcaf.subshapes.name") > 0);
+ Standard_Boolean doReadSNames = (mySubshapesIVal > 0);
if (!doReadSNames)
return;
{
return myViewMode;
}
+
+void STEPCAFControl_Reader::SetSubshapesIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.stepcaf.subshapes.name", theVal);
+ mySubshapesIVal = theVal;
+}
+
+Standard_Integer STEPCAFControl_Reader::GetSubshapesIVal() const
+{
+ return mySubshapesIVal;
+}
//! Convert name into UNICODE text.
Standard_EXPORT virtual TCollection_ExtendedString convertName (const TCollection_AsciiString& theName) const;
+ Standard_EXPORT void SetSubshapesIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT Standard_Integer GetSubshapesIVal() const;
+
private:
//! Internal method. Import all Datum attributes and set them to XCAF object. Set connection of Datum to GeomTolerance (theGDTL).
void prepareUnits(const Handle(StepData_StepModel)& theModel,
const Handle(TDocStd_Document)& theDoc) const;
+
private:
STEPControl_Reader myReader;
Standard_Boolean myMatMode;
Standard_Boolean myViewMode;
NCollection_DataMap<Handle(Standard_Transient), TDF_Label> myGDTMap;
+ Standard_Integer mySubshapesIVal;
};
myLabels.Clear();
myGDTPresentationDM = new StepVisual_DraughtingModel();
myGDTPrsCurveStyle = new StepVisual_HArray1OfPresentationStyleAssignment(1, 1);
+ myAssemblyModeCVal = Interface_Static::CVal("write.step.assembly");
+ myAssemblyModeIVal = Interface_Static::IVal("write.step.assembly");
+ mySchemaIVal = Interface_Static::IVal("write.step.schema");
+ mySubshapesIVal = Interface_Static::IVal("write.stepcaf.subshapes.name");
}
const Handle(StepData_StepModel) aModel = Handle(StepData_StepModel)::DownCast(writer.WS()->Model());
prepareUnit(labels.First(), aModel); // set local length unit to the model
// translate free top-level shapes of the DECAF document
- Standard_Integer ap = Interface_Static::IVal ("write.step.schema");
+ Standard_Integer anAp = mySchemaIVal;
TDF_LabelSequence sublabels;
Message_ProgressScope aPS(theProgress, "Labels", labels.Length());
for ( Standard_Integer i=1; i <= labels.Length() && aPS.More(); i++)
}
}
*/
- Standard_Integer assemblymode = Interface_Static::IVal ("write.step.assembly");
- Interface_Static::SetCVal ("write.step.assembly", "On");
+ Standard_Integer anAssemblyMode = myAssemblyMode;
+ SetAssemblyCVal("On");
writer.Transfer ( Sass, STEPControl_AsIs, Standard_True, aPS1.Next());
- Interface_Static::SetIVal ("write.step.assembly", assemblymode);
- Interface_Static::SetIVal ("write.step.schema", ap);
+ SetAssemblyIVal(anAssemblyMode);
+ SetSchemaIVal(anAp);
}
}
if (aPS.UserBreak())
// write G&DTs
if(GetDimTolMode()) {
- if (ap == 5) {
+ if (anAp == 5) {
WriteDGTsAP242(writer.WS(), sublabels);
}
else {
if ( GetPropsMode() )
WriteValProps ( writer.WS(), sublabels, multi );
- Interface_Static::SetIVal ("write.step.schema", ap);
+ SetSchemaIVal(anAp);
// refresh graph
writer.WS()->ComputeGraph ( Standard_True );
* Write names for the sub-shapes
* ================================ */
- if (Interface_Static::IVal("write.stepcaf.subshapes.name") != 0)
+ if (mySubshapesIVal != 0)
{
const Handle(XSControl_TransferWriter) &TW = this->ChangeWriter().WS()->TransferWriter();
const Handle(Transfer_FinderProcess) &FP = TW->FinderProcess();
EF->SetWS ( newWS );
EF->SetName ( name );
EF->SetLabel ( L );
- Standard_Integer assemblymode = Interface_Static::IVal ("write.step.assembly");
- Interface_Static::SetCVal ("write.step.assembly", "Off");
+ Standard_Integer anAssemblyMode = myAssemblyMode;
+ SetAssemblyCVal("Off");
const Standard_CString multi = 0;
EF->SetTransferStatus ( Transfer ( sw, Lseq, mode, multi, Standard_True, theProgress) );
- Interface_Static::SetIVal ("write.step.assembly", assemblymode);
+ SetAssemblyIVal(anAssemblyMode);
myLabEF.Bind ( L, EF );
myFiles.Bind ( name->ToCString(), EF );
const Handle(XSControl_TransferWriter) &TW = WS->TransferWriter();
const Handle(Transfer_FinderProcess) &FP = TW->FinderProcess();
STEPConstruct_ExternRefs EFTool ( WS );
- Standard_Integer schema = Interface_Static::IVal("write.step.schema");
+ Standard_Integer aSchema = mySchemaIVal;
for ( Standard_Integer k=1; k <= labels.Length(); k++ ) {
TDF_Label lab = labels(k);
if ( XCAFDoc_ShapeTool::IsAssembly ( lab ) ) continue; // skip assemblies
}
// add extern ref
- const char* format = (schema == 3 ? "STEP AP203" : "STEP AP214");
+ const char* format = (aSchema == 3 ? "STEP AP203" : "STEP AP214");
// try to get PD from SDR
StepRepr_RepresentedDefinition RD = SDR->Definition();
Handle(StepRepr_PropertyDefinition) aPropDef = RD.PropertyDefinition();
}
EFTool.AddExternRef ( EF->GetName()->ToCString(), PD, format );
}
- EFTool.WriteExternRefs(schema);
+ EFTool.WriteExternRefs(aSchema);
return Standard_True;
}
{
return myMatMode;
}
+
+void STEPCAFControl_Writer::SetAssemblyCVal(const Standard_CString& theVal)
+{
+ Interface_Static::SetCVal("write.step.assembly", theVal);
+ myAssemblyModeCVal = theVal;
+}
+
+void STEPCAFControl_Writer::SetAssemblyIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.assembly", theVal);
+ myAssemblyModeIVal = theVal;
+}
+
+void STEPCAFControl_Writer::SetSchemaIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.schema", theVal);
+ mySchemaIVal = theVal;
+}
+
+void STEPCAFControl_Writer::SetSubshapesIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.stepcaf.subshapes.name", theVal);
+ mySubshapesIVal = theVal;
+}
+
+Standard_CString STEPCAFControl_Writer::GetAssemblyCVal() const
+{
+ return myAssemblyModeCVal;
+}
+
+Standard_Integer STEPCAFControl_Writer::GetAssemblyIVal() const
+{
+ return myAssemblyModeIVal;
+}
+
+Standard_Integer STEPCAFControl_Writer::GetSchemaIVal() const
+{
+ return mySchemaIVal;
+}
+
+Standard_Integer STEPCAFControl_Writer::GetSubshapesIVal() const
+{
+ return mySubshapesIVal;
+}
Standard_EXPORT void prepareUnit(const TDF_Label& theLabel,
const Handle(StepData_StepModel)& theModel);
+ Standard_EXPORT void SetAssemblyCVal(const Standard_CString& theVal);
+
+ Standard_EXPORT void SetAssemblyIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetSchemaIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetSubshapesIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT Standard_CString GetAssemblyCVal() const;
+
+ Standard_EXPORT Standard_Integer GetAssemblyIVal() const;
+
+ Standard_EXPORT Standard_Integer GetSchemaIVal() const;
+
+ Standard_EXPORT Standard_Integer GetSubshapesIVal() const;
+
private:
Standard_EXPORT Handle(StepRepr_ShapeAspect) WriteShapeAspect(const Handle(XSControl_WorkSession) &WS,
private:
-
STEPControl_Writer myWriter;
NCollection_DataMap<TCollection_AsciiString, Handle(STEPCAFControl_ExternFile)> myFiles;
STEPCAFControl_DataMapOfLabelShape myLabels;
Handle(StepVisual_DraughtingModel) myGDTPresentationDM;
Handle(StepVisual_HArray1OfPresentationStyleAssignment) myGDTPrsCurveStyle;
Handle(StepRepr_ProductDefinitionShape) myGDTCommonPDS;
+ Standard_Integer myAssemblyModeIVal;
+ Standard_CString myAssemblyModeCVal;
+ Standard_Integer mySchemaIVal;
+ Standard_Integer mySubshapesIVal;
};
// if (thePRPC.IsNull()) thePRPC = GetCasted(StepBasic_ProductRelatedProductCategory, ent);
//}
}
+ myProductNameCVal = Interface_Static::CVal("write.step.product.name");
+ mySchemaIVal = Interface_Static::IVal("write.step.schema");
}
//=======================================================================
Standard_Boolean noapd = theAPD.IsNull();
if (noapd || enforce) theAPD = new StepBasic_ApplicationProtocolDefinition;
- switch (Interface_Static::IVal("write.step.schema")) { //j4
+ switch (mySchemaIVal) { //j4
default:
case 1:
theAPD->SetApplicationProtocolYear (1997);
if (theAPD->Application().IsNull())
theAPD->SetApplication (new StepBasic_ApplicationContext);
Handle(TCollection_HAsciiString) appl;
- switch (Interface_Static::IVal("write.step.schema")) { //j4
+ switch (mySchemaIVal) { //j4
default:
case 1:
case 2: appl = new TCollection_HAsciiString ( "core data for automotive mechanical design processes" );
Standard_Boolean noprpc = thePRPC.IsNull();
if (noprpc || enforce) {
//:i3 abv 1 Sep 98: ProSTEP TR9: generate PRODUCT_TYPE (derived) instead of PRPC
- switch (Interface_Static::IVal("write.step.schema")) { //j4
+ switch (mySchemaIVal) { //j4
default:
case 1:
thePRPC = new StepBasic_ProductType;
Handle(TCollection_HAsciiString) STEPConstruct_ContextTool::GetProductName () const
{
- Handle(TCollection_HAsciiString) PdtName;
- if (Interface_Static::IsSet("write.step.product.name"))
- PdtName = new TCollection_HAsciiString(Interface_Static::CVal("write.step.product.name"));
- else PdtName = new TCollection_HAsciiString("Product");
-
- for ( Standard_Integer i=1; i <= myLevel.Length(); i++ ) {
- PdtName->AssignCat ((char*)( i >1 ? "." : " " ));
+ Handle(TCollection_HAsciiString) aPdtName;
+ if (!myProductNameCVal.IsEmpty())
+ {
+ aPdtName = new TCollection_HAsciiString(myProductNameCVal);
+ }
+ else
+ {
+ aPdtName = new TCollection_HAsciiString("Product");
+ }
+ for ( Standard_Integer i=1; i <= myLevel.Length(); i++ )
+ {
+ aPdtName->AssignCat ((char*)( i >1 ? "." : " " ));
char buf[100];
sprintf ( buf, "%d", myLevel.Value(i) );
- PdtName->AssignCat ( buf );
+ aPdtName->AssignCat ( buf );
}
- return PdtName;
+ return aPdtName;
}
//=======================================================================
if ( ! SDRTool.PRPC().IsNull() ) seq->Append ( SDRTool.PRPC() );
// for AP203, add required product management data
- if ( Interface_Static::IVal("write.step.schema") == 3 ) {
+ if (mySchemaIVal == 3 )
+ {
theAP203.Init ( SDRTool );
seq->Append (theAP203.GetProductCategoryRelationship());
seq->Append (theAP203.GetCreator());
seq->Append ( assembly.ItemValue() );
// for AP203, write required product management data
- if ( Interface_Static::IVal("write.step.schema") == 3 ) {
+ if (mySchemaIVal == 3 )
+ {
theAP203.Init ( assembly.GetNAUO() );
seq->Append (theAP203.GetSecurity());
seq->Append (theAP203.GetClassificationOfficer());
return seq;
}
+void STEPConstruct_ContextTool::SetProductNameCVal(const Standard_CString& theVal)
+{
+ Interface_Static::SetCVal("write.step.product.name", theVal);
+ myProductNameCVal = theVal;
+}
+void STEPConstruct_ContextTool::SetSchemaIVal(Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.schema", theVal);
+ mySchemaIVal = theVal;
+}
+Standard_CString STEPConstruct_ContextTool::GetProductNameCVal() const
+{
+ return myProductNameCVal;
+}
-
+Standard_Integer STEPConstruct_ContextTool::GetSchemaIVal() const
+{
+ return mySchemaIVal;
+}
//! for assembly link identified by assembly (including NAUO and CDSR)
Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetRootsForAssemblyLink (const STEPConstruct_Assembly& assembly);
+ Standard_EXPORT TCollection_HAsciiString GetWriteStepProductName() const;
+ Standard_EXPORT void SetProductNameCVal(const Standard_CString& theVal);
+
+ Standard_EXPORT void SetSchemaIVal(Standard_Integer theVal);
+
+ Standard_EXPORT Standard_Integer GetSchemaIVal() const;
+
+ Standard_EXPORT Standard_CString GetProductNameCVal() const;
protected:
Handle(StepBasic_ApplicationProtocolDefinition) theAPD;
STEPConstruct_AP203Context theAP203;
Handle(StepGeom_Axis2Placement3d) myAxis;
-
+ Standard_CString myProductNameCVal;
+ Standard_Integer mySchemaIVal;
};
STEPConstruct_Part::STEPConstruct_Part()
{
myDone = Standard_False;
+ mySchemaIVal = Interface_Static::IVal("write.step.schema");
}
//=======================================================================
const Handle(StepBasic_ApplicationContext)& AC)
{
// get current schema
- Standard_Integer schema = Interface_Static::IVal("write.step.schema");
+ mySchemaIVal = Interface_Static::IVal("write.step.schema");
// create PC
Handle(StepBasic_ProductContext) PC;
- switch (schema) {
+ switch (mySchemaIVal) {
default :
case 1: PC = new StepBasic_MechanicalContext;
break;
// create PDF
Handle(StepBasic_ProductDefinitionFormation) PDF;
- switch (schema) {
+ switch (mySchemaIVal) {
default:
case 1:
case 2:
// create PDC, depending on current schema
Handle(StepBasic_ProductDefinitionContext) PDC;
Handle(TCollection_HAsciiString) PDCname;
- switch (schema) {
+ switch (mySchemaIVal) {
default:
case 1:
case 2:
// and an associated PRPC
Handle(TCollection_HAsciiString) PRPCName;
- switch (Interface_Static::IVal("write.step.schema")) {
+ switch (mySchemaIVal) {
default:
case 1:
myPRPC = new StepBasic_ProductType;
PRPCproducts->SetValue(1,P);
myPRPC->Init ( PRPCName, Standard_False, 0, PRPCproducts );
+
myDone = Standard_True;
}
myPRPC->SetDescription ( text );
}
+void STEPConstruct_Part::SetSchemaIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.schema", theVal);
+ mySchemaIVal = theVal;
+}
+
+Standard_Integer STEPConstruct_Part::GetSchemaIVal() const
+{
+ return mySchemaIVal;
+}
Standard_EXPORT void SetPRPCdescription (const Handle(TCollection_HAsciiString)& text);
+ Standard_EXPORT void SetSchemaIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetSchemaIVal() const;
protected:
Standard_Boolean myDone;
Handle(StepShape_ShapeDefinitionRepresentation) mySDR;
Handle(StepBasic_ProductRelatedProductCategory) myPRPC;
+ Standard_Integer mySchemaIVal;
};
//=======================================================================
STEPConstruct_Styles::STEPConstruct_Styles ()
{
+ mySchemaIVal = Interface_Static::IVal("write.step.schema")
}
STEPConstruct_Styles::STEPConstruct_Styles (const Handle(XSControl_WorkSession) &WS)
: STEPConstruct_Tool ( WS )
{
+ mySchemaIVal = Interface_Static::IVal("write.step.schema")
}
myMapOfStyles.Clear();
myStyles.Clear();
myPSA.Clear();
+ mySchemaIVal = Interface_Static::IVal("write.step.schema")
return SetWS ( WS );
}
// Model()->AddWithRefs ( Repr ); add into the model upper
// for AP203, add subschema name
- if ( Interface_Static::IVal("write.step.schema") ==3 ) {
+ if (mySchemaIVal == 3)
+ {
APIHeaderSection_MakeHeader mkHdr ( Handle(StepData_StepModel)::DownCast ( Model() ) );
Handle(TCollection_HAsciiString) subSchema =
new TCollection_HAsciiString ( "SHAPE_APPEARANCE_LAYER_MIM" );
return Standard_False;
}
+void STEPConstruct_Styles::SetSchemaIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.schema", theVal);
+ mySchemaIVal = theVal;
+}
+
+Standard_Integer STEPConstruct_Styles::GetSchemaIVal() const
+{
+ return mySchemaIVal;
+}
//! Returns True if OK or False if color is not recognized
Standard_EXPORT static Standard_Boolean DecodeColor (const Handle(StepVisual_Colour)& Colour, Quantity_Color& Col);
+ Standard_EXPORT void SetSchemaIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetSchemaIVal() const;
protected:
TColStd_IndexedDataMapOfTransientTransient myMapOfStyles;
TColStd_IndexedMapOfTransient myStyles;
TColStd_SequenceOfTransient myPSA;
+ Standard_Integer mySchemaIVal;
};
areaDone = volumeDone = Standard_False;
//pdn file r_47-sd.stp initialize field.
theUncertainty = RealLast();
+ myWriteUnitIVal = Interface_Static::IVal("write.step.unit");
}
//=======================================================================
Standard_Boolean hasPref = Standard_True;
StepBasic_SiPrefix siPref = StepBasic_spMilli;
Standard_Real aScale = 1.;
- switch (Interface_Static::IVal("write.step.unit"))
+ myWriteUnitIVal = Interface_Static::IVal("write.step.unit");
+ switch (myWriteUnitIVal)
{
case 1: uName = "INCH"; aScale = 25.4; break;
default:
{
return volumeDone;
}
+
+void STEPConstruct_UnitContext::SetWriteUnitIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.unit", theVal);
+ myWriteUnitIVal = theVal;
+}
+
+Standard_Integer STEPConstruct_UnitContext::GetWriteUnitIVal() const
+{
+ return myWriteUnitIVal;
+}
+
//! real factor (e.g. 1e6 for mega)
Standard_EXPORT static Standard_Real ConvertSiPrefix (const StepBasic_SiPrefix aPrefix);
+ Standard_EXPORT void SetWriteUnitIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetWriteUnitIVal() const;
protected:
Standard_Boolean planeAngleDone;
Standard_Boolean solidAngleDone;
Standard_Boolean hasUncertainty;
-
+ Standard_Integer myWriteUnitIVal;
};
//=======================================================================
STEPConstruct_ValidationProps::STEPConstruct_ValidationProps ()
{
+ mySchemaIVal = Interface_Static::IVal("write.step.schema");
}
//=======================================================================
STEPConstruct_ValidationProps::STEPConstruct_ValidationProps (const Handle(XSControl_WorkSession) &WS)
: STEPConstruct_Tool(WS)
{
+ mySchemaIVal = Interface_Static::IVal("write.step.schema");
}
//=======================================================================
Standard_Boolean STEPConstruct_ValidationProps::Init (const Handle(XSControl_WorkSession) &WS)
{
+ mySchemaIVal = Interface_Static::IVal("write.step.schema");
return SetWS ( WS );
}
Model()->AddWithRefs ( PrDR );
// for AP203, add subschema name
- if ( Interface_Static::IVal("write.step.schema") ==3 ) {
+ if ( mySchemaIVal == 3 )
+ {
APIHeaderSection_MakeHeader mkHdr ( Handle(StepData_StepModel)::DownCast ( Model() ) );
Handle(TCollection_HAsciiString) subSchema =
new TCollection_HAsciiString ( "GEOMETRIC_VALIDATION_PROPERTIES_MIM" );
Handle(TransferBRep_ShapeMapper) mapper = TransferBRep::ShapeMapper(FinderProcess(),shape);
FinderProcess()->FindTypedTransient(mapper,STANDARD_TYPE(StepBasic_ProductDefinition),myAssemblyPD);
}
+
+void STEPConstruct_ValidationProps::SetSchemaIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.schema", theVal);
+ mySchemaIVal = theVal;
+}
+
+Standard_Integer STEPConstruct_ValidationProps::GetSchemaIVal() const
+{
+ return mySchemaIVal;
+}
//! Sets current assembly shape SDR (for FindCDSR calls)
Standard_EXPORT void SetAssemblyShape (const TopoDS_Shape& shape);
+ Standard_EXPORT void SetSchemaIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetSchemaIVal() const;
protected:
StepBasic_Unit areaUnit;
StepBasic_Unit volUnit;
Handle(StepBasic_ProductDefinition) myAssemblyPD;
+ Standard_Integer mySchemaIVal;
};
: myPrecision(0.0),
myMaxTol(0.0)
{
+ myAngleUnitIVal = Interface_Static::IVal("step.angleunit.mode");
+ myStepShapeReprIVal = Interface_Static::IVal("read.step.shape.repr");
+ myRelationshipIVal = Interface_Static::IVal("read.step.shape.relationship");
+ myShapeAspectIVal = Interface_Static::IVal("read.step.shape.aspect");
+ myProductCVal = Interface_Static::CVal("read.step.product.mode");
+ myReadAssemblyIVal = Interface_Static::IVal("read.step.assembly.level");
+ myNonmanifoldIVal = Interface_Static::IVal("read.step.nonmanifold");
+ myIdeasModeIVal = Interface_Static::IVal("read.step.ideas");
+ myConstructiveGeomIVal = Interface_Static::IVal("read.step.constructivegeom.relationship");
+ myRootTransformationIVal = Interface_Static::IVal("read.step.root.transformation");
+ myPrecisionModeIVal = Interface_Static::IVal("read.precision.mode");
+ myPrecisionRVal = Interface_Static::RVal("read.precision.val");
+ myMaxPrecisionRVal = Interface_Static::RVal("read.maxprecision.val");
}
// ============================================================================
// Method : STEPControl_ActorRead::Recognize
if (start->IsKind(STANDARD_TYPE(StepRepr_NextAssemblyUsageOccurrence))) return Standard_True;
- TCollection_AsciiString aProdMode = Interface_Static::CVal("read.step.product.mode");
+ TCollection_AsciiString aProdMode = myProductCVal;
if(!aProdMode.IsEqual("ON"))
if(start->IsKind(STANDARD_TYPE(StepShape_ShapeDefinitionRepresentation))) return Standard_True;
}
}
// [END] Get version of preprocessor (to detect I-Deas case) (ssv; 23.11.2010)
- Standard_Boolean aTrsfUse = (Interface_Static::IVal("read.step.root.transformation") == 1);
+ Standard_Boolean aTrsfUse = (myRootTransformationIVal == 1);
return TransferShape(start, TP, Standard_True, aTrsfUse, theProgress);
}
// Flag indicating whether SDRs associated with the product`s main SDR
// by SRRs (which correspond to hybrid model representation in AP203 since 1998)
// should be taken into account
- Standard_Integer readSRR = Interface_Static::IVal("read.step.shape.relationship");
+ Standard_Integer readSRR = myRelationshipIVal;
- Standard_Integer readConstructiveGeomRR = Interface_Static::IVal("read.step.constructivegeom.relationship");
+ Standard_Integer aReadConstructiveGeomRR = myConstructiveGeomIVal;
// Flag indicating whether SDRs associated with the product`s main SDR
// by SAs (which correspond to hybrid model representation in AP203 before 1998)
// should be taken into account
- Standard_Integer readSA = Interface_Static::IVal("read.step.shape.aspect");
- if ( ! readSA )
+ Standard_Integer aReadSA = myShapeAspectIVal;
+ if ( ! aReadSA )
listSDRAspect->Clear();
// remember number of normal SDRs (not those found via ShapeAspect)
// possibly attached directly to intermediate assemblies (1)
// Special mode (4) is used to translate shape attached to this product only,
// ignoring sub-assemblies if any
- Standard_Integer readAssembly = Interface_Static::IVal("read.step.assembly.level");
- if ( readAssembly ==3 || ( readAssembly ==2 && listNAUO->Length() >0 ) )
+ Standard_Integer aReadAssembly = myReadAssemblyIVal;
+ if ( aReadAssembly ==3 || ( aReadAssembly ==2 && listNAUO->Length() >0 ) )
listSDR->Clear();
- else if ( readAssembly == 4 )
+ else if ( aReadAssembly == 4 )
listNAUO->Clear();
Standard_Integer nbEnt = listSDR->Length() + listNAUO->Length();
nbShapes++;
}
}
- else if(readConstructiveGeomRR && anitem->IsKind(STANDARD_TYPE(StepRepr_ConstructiveGeometryRepresentationRelationship)))
+ else if(aReadConstructiveGeomRR && anitem->IsKind(STANDARD_TYPE(StepRepr_ConstructiveGeometryRepresentationRelationship)))
{
Handle(StepRepr_ConstructiveGeometryRepresentationRelationship) aCSRR =
Handle(StepRepr_ConstructiveGeometryRepresentationRelationship)::DownCast(anitem);
Standard_Integer nsh = 0;
// [BEGIN] Proceed with non-manifold topology (ssv; 12.11.2010)
- Standard_Boolean isNMMode = Interface_Static::IVal("read.step.nonmanifold") != 0;
+ Standard_Boolean isNMMode = myNonmanifoldIVal != 0;
Standard_Boolean isManifold = Standard_True;
if ( isNMMode && sr->IsKind(STANDARD_TYPE(StepShape_NonManifoldSurfaceShapeRepresentation)) ) {
isManifold = Standard_False;
}
// Special processing for I-DEAS STP case (ssv; 15.11.2010)
else {
- Standard_Integer isIDeasMode = Interface_Static::IVal("read.step.ideas");
- if (isNMMode && myNMTool.IsIDEASCase() && isIDeasMode) {
+ Standard_Integer anIsIdeasMode = myIdeasModeIVal;
+ if (isNMMode && myNMTool.IsIDEASCase() && anIsIdeasMode) {
isManifold = Standard_False;
NM_DETECTED = Standard_True;
#ifdef OCCT_DEBUG
return shbinder;
}
+void STEPControl_ActorRead::SetAngleUnitIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("step.angleunit.mode", theVal);
+ myAngleUnitIVal = theVal;
+}
+
+void STEPControl_ActorRead::SetStepShapeReprIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.step.shape.repr", theVal);
+ myStepShapeReprIVal = theVal;
+}
+
+void STEPControl_ActorRead::SetRelationshipIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.step.shape.relationship", theVal);
+ myRelationshipIVal = theVal;
+}
+
+void STEPControl_ActorRead::SetShapeAspectIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.step.shape.aspect", theVal);
+ myShapeAspectIVal = theVal;
+}
+
+void STEPControl_ActorRead::SetProductCVal(const Standard_CString& theVal)
+{
+ Interface_Static::SetCVal("read.step.product.mode", theVal);
+ myProductCVal = theVal;
+}
+
+void STEPControl_ActorRead::SetReadAssemblyIValconst(Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.step.assembly.level", theVal);
+ myReadAssemblyIVal = theVal;
+}
+
+void STEPControl_ActorRead::SetNonmanifoldIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.step.nonmanifold", theVal);
+ myNonmanifoldIVal = theVal;
+}
+
+void STEPControl_ActorRead::SetIdeasModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.step.ideas", theVal);
+ myIdeasModeIVal = theVal;
+}
+
+void STEPControl_ActorRead::SetConstructiveGeomIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.step.constructivegeom.relationship", theVal);
+ myStepShapeReprIVal = theVal;
+}
+
+void STEPControl_ActorRead::SetRootTransformationIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.step.root.transformation", theVal);
+ myRootTransformationIVal = theVal;
+}
+
+void STEPControl_ActorRead::SetPrecisionModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.precision.mode", theVal);
+ myPrecisionModeIVal = theVal;
+}
+
+void STEPControl_ActorRead::SetPrecisionRVal(const Standard_Real theVal)
+{
+ Interface_Static::SetRVal("read.precision.val", theVal);
+ myPrecisionRVal = theVal;
+}
+
+void STEPControl_ActorRead::SetMaxPrecisionRVal(const Standard_Real theVal)
+{
+ Interface_Static::SetRVal("read.maxprecision.val", theVal);
+ myMaxPrecisionRVal = theVal;
+}
+
+Standard_Integer STEPControl_ActorRead::GetAngleUnitIVal() const
+{
+ return myAngleUnitIVal;
+}
+
+Standard_Integer STEPControl_ActorRead::GetStepShapeReprIVal() const
+{
+ return myStepShapeReprIVal;
+}
+
+Standard_Integer STEPControl_ActorRead::GetRelationshipIVal() const
+{
+ return myRelationshipIVal;
+}
+
+Standard_Integer STEPControl_ActorRead::GetShapeAspectIVal() const
+{
+ return myShapeAspectIVal;
+}
+
+Standard_CString STEPControl_ActorRead::GetProductCVal() const
+{
+ return myProductCVal;
+}
+
+Standard_Integer STEPControl_ActorRead::GetReadAssemblyIVal() const
+{
+ return myReadAssemblyIVal;
+}
+
+Standard_Integer STEPControl_ActorRead::GetNonmanifoldIVal() const
+{
+ return myNonmanifoldIVal;
+}
+
+Standard_Integer STEPControl_ActorRead::GetIdeasModeIVal() const
+{
+ return myIdeasModeIVal;
+}
+
+Standard_Integer STEPControl_ActorRead::GetConstructiveGeomIVal() const
+{
+ return myConstructiveGeomIVal;
+}
+
+Standard_Integer STEPControl_ActorRead::GetRootTransformationIVal() const
+{
+ return myRootTransformationIVal;
+}
+
+Standard_Integer STEPControl_ActorRead::GetPrecisionModeIVal() const
+{
+ return myPrecisionModeIVal;
+}
+
+Standard_Real STEPControl_ActorRead::GetPrecisionRVal() const
+{
+ return myPrecisionRVal;
+}
+
+Standard_Real STEPControl_ActorRead::GetMaxPrecisionRVal() const
+{
+ return myMaxPrecisionRVal;
+}
+
//=======================================================================
//function : TransferEntity
//purpose :
// Product Definition Entities
// They should be treated with Design Manager
// case ShapeDefinitionRepresentation if ProductMode != ON
- TCollection_AsciiString aProdMode = Interface_Static::CVal("read.step.product.mode");
+ TCollection_AsciiString aProdMode = myProductCVal;
if(!aProdMode.IsEqual("ON") &&
start->IsKind(STANDARD_TYPE(StepShape_ShapeDefinitionRepresentation)))
shbinder = OldWay(start,TP, theProgress);
if (!theGUAC.IsNull()) {
stat1 = myUnit.ComputeFactors(theGUAC);
- Standard_Integer anglemode = Interface_Static::IVal("step.angleunit.mode");
+ Standard_Integer anglemode = myAngleUnitIVal;
Standard_Real angleFactor = ( anglemode == 0 ? myUnit.PlaneAngleFactor() :
anglemode == 1 ? 1. : M_PI/180. );
StepData_GlobalFactors::Intance().InitializeFactors(myUnit.LengthFactor(),
}
// myPrecision = Precision::Confusion();
- if (Interface_Static::IVal("read.precision.mode") == 1) //:i1 gka S4136 05.04.99
- myPrecision = Interface_Static::RVal("read.precision.val");
+ if (myPrecisionModeIVal == 1) //:i1 gka S4136 05.04.99
+ myPrecision = myPrecisionRVal;
else if (myUnit.HasUncertainty())
myPrecision = myUnit.Uncertainty() * myUnit.LengthFactor();
else {
TP->AddWarning(theRepCont,"No Length Uncertainty, value of read.precision.val is taken");
- myPrecision = Interface_Static::RVal("read.precision.val");
+ myPrecision = myPrecisionRVal;
}
- myMaxTol = Max ( myPrecision, Interface_Static::RVal("read.maxprecision.val") );
+ myMaxTol = Max ( myPrecision, myMaxPrecisionRVal );
// Assign uncertainty
#ifdef TRANSLOG
if (TP->TraceLevel() > 1)
void STEPControl_ActorRead::ResetUnits ()
{
StepData_GlobalFactors::Intance().InitializeFactors ( 1, 1, 1 );
- myPrecision = Interface_Static::RVal("read.precision.val");
- myMaxTol = Max ( myPrecision, Interface_Static::RVal("read.maxprecision.val") );
+ myPrecision = myPrecisionRVal;
+ myMaxTol = Max (myPrecision, myMaxPrecisionRVal);
}
//=======================================================================
const Handle(Transfer_TransientProcess)& TP,
const Message_ProgressRange& theProgress);
+ Standard_EXPORT void SetAngleUnitIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetStepShapeReprIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetRelationshipIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetShapeAspectIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetProductCVal(const Standard_CString& theVal);
+
+ Standard_EXPORT void SetReadAssemblyIValconst(Standard_Integer theVal);
+
+ Standard_EXPORT void SetNonmanifoldIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetIdeasModeIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetConstructiveGeomIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetRootTransformationIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetPrecisionModeIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetPrecisionRVal(const Standard_Real theVal);
+
+ Standard_EXPORT void SetMaxPrecisionRVal(const Standard_Real theVal);
+
+ Standard_EXPORT Standard_Integer GetAngleUnitIVal() const;
+
+ Standard_EXPORT Standard_Integer GetStepShapeReprIVal() const;
+
+ Standard_EXPORT Standard_Integer GetRelationshipIVal() const;
+
+ Standard_EXPORT Standard_Integer GetShapeAspectIVal() const;
+
+ Standard_EXPORT Standard_CString GetProductCVal() const;
+
+ Standard_EXPORT Standard_Integer GetReadAssemblyIVal() const;
+
+ Standard_EXPORT Standard_Integer GetNonmanifoldIVal() const;
+
+ Standard_EXPORT Standard_Integer GetIdeasModeIVal() const;
+
+ Standard_EXPORT Standard_Integer GetConstructiveGeomIVal() const;
+
+ Standard_EXPORT Standard_Integer GetRootTransformationIVal() const;
+
+ Standard_EXPORT Standard_Integer GetPrecisionModeIVal() const;
+
+ Standard_EXPORT Standard_Real GetPrecisionRVal() const;
+
+ Standard_EXPORT Standard_Real GetMaxPrecisionRVal() const;
private:
Standard_Real myPrecision;
Standard_Real myMaxTol;
Handle(StepRepr_Representation) mySRContext;
-
+ Standard_Integer myAngleUnitIVal;
+ Standard_Integer myStepShapeReprIVal;
+ Standard_Integer myRelationshipIVal;
+ Standard_Integer myShapeAspectIVal;
+ Standard_CString myProductCVal;
+ Standard_Integer myReadAssemblyIVal;
+ Standard_Integer myNonmanifoldIVal;
+ Standard_Boolean myIdeasModeIVal;
+ Standard_Integer myConstructiveGeomIVal;
+ Standard_Integer myRootTransformationIVal;
+ Standard_Integer myPrecisionModeIVal;
+ Standard_Real myPrecisionRVal;
+ Standard_Real myMaxPrecisionRVal;
};
STEPControl_ActorWrite::STEPControl_ActorWrite ()
: mygroup (0) , mytoler (-1.)
{
+ myAngleUnitIVal = Interface_Static::IVal("step.angleunit.mode");
+ mySchemaIVal = Interface_Static::IVal("write.step.schema");
+ myPrecisionModeIVal = Interface_Static::IVal("write.precision.mode");
+ myVertexModeIVal = Interface_Static::IVal("write.step.vertex.mode");
+ myNonmanifoldIVal = Interface_Static::IVal("write.step.nonmanifold");
+ myPrecisionRVal = Interface_Static::RVal("write.precision.val");
+ myMaxPrecisionRVal = Interface_Static::RVal("read.maxprecision.val");
SetMode(STEPControl_ShellBasedSurfaceModel);
}
}
Standard_Real aLFactor = model->WriteLengthUnit();
aLFactor /= model->LocalLengthUnit();
- Standard_Integer anglemode = Interface_Static::IVal("step.angleunit.mode");
+ Standard_Integer anglemode = myAngleUnitIVal;
StepData_GlobalFactors::Intance().InitializeFactors (aLFactor, ( anglemode <= 1 ? 1. : M_PI/180. ), 1. );
// create SDR
{
if ( ! GroupMode() || S.ShapeType() != TopAbs_COMPOUND ) return Standard_False;
// PTV 16.09.2002 OCC725 for storing compound of vertices
- if (Interface_Static::IVal("write.step.vertex.mode") == 0) {//bug 23950
+ if (myVertexModeIVal == 0) {//bug 23950
if (S.ShapeType() == TopAbs_COMPOUND ) {
Standard_Boolean IsOnlyVertices = Standard_True;
TopoDS_Iterator anItr( S );
return IsAssembly ( S );
}
+void STEPControl_ActorWrite::SetGetAngleUnitIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("step.angleunit.mode", theVal);
+ myAngleUnitIVal = theVal;
+}
+
+void STEPControl_ActorWrite::SetSchemaIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.schema", theVal);
+ mySchemaIVal = theVal;
+}
+
+void STEPControl_ActorWrite::SetPrecisionModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.precision.mode", theVal);
+ myPrecisionModeIVal = theVal;
+}
+
+void STEPControl_ActorWrite::SetVertexModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.vertex.mode", theVal);
+ myVertexModeIVal = theVal;
+}
+
+void STEPControl_ActorWrite::SetNonmanifoldIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.nonmanifold", theVal);
+ myNonmanifoldIVal = theVal;
+}
+
+void STEPControl_ActorWrite::SetPrecisionRVal(const Standard_Real theVal)
+{
+ Interface_Static::SetRVal("write.precision.val", theVal);
+ myPrecisionRVal = theVal;
+}
+
+void STEPControl_ActorWrite::SetMaxPrecisionRVal(const Standard_Real theVal)
+{
+ Interface_Static::SetRVal("read.maxprecision.val", theVal);
+ myMaxPrecisionRVal = theVal;
+}
+
+Standard_Integer STEPControl_ActorWrite::GetAngleUnitIVal() const
+{
+ return myAngleUnitIVal;
+}
+
+Standard_Integer STEPControl_ActorWrite::GetSchemaIVal() const
+{
+ return mySchemaIVal;
+}
+
+Standard_Integer STEPControl_ActorWrite::GetPrecisionModeIVal() const
+{
+ return myPrecisionModeIVal;
+}
+
+Standard_Integer STEPControl_ActorWrite::GetVertexModeIVal() const
+{
+ return myVertexModeIVal;
+}
+
+Standard_Integer STEPControl_ActorWrite::GetNonmanifoldIVal() const
+{
+ return myNonmanifoldIVal;
+}
+
+Standard_Real STEPControl_ActorWrite::GetPrecisionRVal() const
+{
+ return myPrecisionRVal;
+}
+
+Standard_Real STEPControl_ActorWrite::GetMaxPrecisionRVal() const
+{
+ return myMaxPrecisionRVal;
+}
+
//=======================================================================
//function : TransferShape
//purpose :
Message_ProgressScope aPSRoot(theProgress, NULL, 2);
// [BEGIN] Separate manifold topology from non-manifold in group mode 0 (ssv; 18.11.2010)
- Standard_Boolean isNMMode = Interface_Static::IVal("write.step.nonmanifold") != 0;
+ Standard_Boolean isNMMode = myNonmanifoldIVal != 0;
Handle(Transfer_Binder) aNMBinder;
if (isNMMode && !GroupMode() && theShape.ShapeType() == TopAbs_COMPOUND) {
TopoDS_Compound aNMCompound;
// create a list of items to translate
Handle(TopTools_HSequenceOfShape) RepItemSeq = new TopTools_HSequenceOfShape();
- Standard_Boolean isSeparateVertices =
- Interface_Static::IVal("write.step.vertex.mode") == 0;//bug 23950
+ Standard_Boolean isSeparateVertices = myVertexModeIVal;//bug 23950
// PTV 16.09.2002 OCC725 separate shape from solo vertices.
Standard_Boolean isOnlyVertices = Standard_False;
if (theShape.ShapeType() == TopAbs_COMPOUND) {
// if ( DMT.IsDone() ) aShape = DMT.ModifiedShape ( aShape );
//// aShape = TopoDSToStep::DirectFaces(xShape);
Handle(Standard_Transient) info;
- Standard_Real maxTol = Interface_Static::RVal("read.maxprecision.val");
+ Standard_Real maxTol = myMaxPrecisionRVal;
Message_ProgressScope aPS1 (aPS.Next(), NULL, 2);
GetCasted(StepRepr_RepresentationItem, ItemSeq->Value(rep));
items->SetValue(rep,repit);
}
- Standard_Integer ap = Interface_Static::IVal("write.step.schema");
+ Standard_Integer ap = mySchemaIVal;
Transfer_SequenceOfBinder aSeqBindRelation;
if(ap == 3 && nbs > 1) {
Standard_Integer j = 1;
TopoDS_Shape theShape = mapper->Value();
// Inspect non-manifold topology case (ssv; 10.11.2010)
- Standard_Boolean isNMMode = Interface_Static::IVal("write.step.nonmanifold") != 0;
+ Standard_Boolean isNMMode = myNonmanifoldIVal != 0;
Standard_Boolean isManifold;
if (isNMMode)
isManifold = IsManifoldShape(theShape);
Handle(TopTools_HSequenceOfShape) RepItemSeq = new TopTools_HSequenceOfShape();
// Prepare a collection for non-manifold group of shapes
Handle(TopTools_HSequenceOfShape) NonManifoldGroup = new TopTools_HSequenceOfShape();
- Standard_Boolean isSeparateVertices =
- (Interface_Static::IVal("write.step.vertex.mode") == 0);//bug 23950
+ Standard_Boolean isSeparateVertices = myVertexModeIVal == 0;//bug 23950
// PTV OCC725 17.09.2002 -- begin --
Standard_Integer nbFreeVrtx = 0;
TopoDS_Compound aCompOfVrtx;
//! NOTE: this method can modify shape
Standard_EXPORT virtual Standard_Boolean IsAssembly (TopoDS_Shape& S) const;
+ Standard_EXPORT void SetGetAngleUnitIVal(const Standard_Integer theVal);
+ Standard_EXPORT void SetSchemaIVal(const Standard_Integer theVal);
+ Standard_EXPORT void SetPrecisionModeIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetVertexModeIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetNonmanifoldIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetPrecisionRVal(const Standard_Real theVal);
+
+ Standard_EXPORT void SetMaxPrecisionRVal(const Standard_Real theVal);
+
+ Standard_EXPORT Standard_Integer GetAngleUnitIVal() const;
+
+ Standard_EXPORT Standard_Integer GetSchemaIVal() const;
+
+ Standard_EXPORT Standard_Integer GetPrecisionModeIVal() const;
+
+ Standard_EXPORT Standard_Integer GetVertexModeIVal() const;
+
+ Standard_EXPORT Standard_Integer GetNonmanifoldIVal() const;
+
+ Standard_EXPORT Standard_Real GetPrecisionRVal() const;
+
+ Standard_EXPORT Standard_Real GetMaxPrecisionRVal() const;
DEFINE_STANDARD_RTTIEXT(STEPControl_ActorWrite,Transfer_ActorOfFinderProcess)
Standard_Integer mygroup;
Standard_Real mytoler;
STEPConstruct_ContextTool myContext;
-
+ Standard_Integer myAngleUnitIVal;
+ Standard_Integer mySchemaIVal;
+ Standard_Integer myPrecisionModeIVal;
+ Standard_Integer myVertexModeIVal;
+ Standard_Integer myNonmanifoldIVal;
+ Standard_Real myPrecisionRVal;
+ Standard_Real myMaxPrecisionRVal;
};
RWHeaderSection::Init(); RWStepAP214::Init();
Interface_Static::Init ("step","write.step.product.name",'t',"Open CASCADE STEP translator " OCC_VERSION_STRING);
+ Interface_Static::SetCVal("write.step.product.name", "");
+
Interface_Static::Init ("step","write.step.assembly",'e',"");
Interface_Static::Init ("step","write.step.assembly",'&',"enum 0");
Interface_Static::Init ("step","write.step.assembly",'&',"eval Off");
STEPControl_Reader::STEPControl_Reader ()
{
STEPControl_Controller::Init();
+ myAllShapeIVal = Interface_Static::IVal("read.step.all.shapes");
+ myProductContextCVal = Interface_Static::CVal("read.step.product.context");
+ myProductContextIVal = Interface_Static::IVal("read.step.product.context");
+ myProductModeCVal = Interface_Static::CVal("read.step.product.mode");
SetNorm ("STEP");
}
{
STEPControl_Controller::Init();
SetWS (WS,scratch);
+ myAllShapeIVal = Interface_Static::IVal("read.step.all.shapes");
+ myProductContextCVal = Interface_Static::CVal("read.step.product.context");
+ myProductContextIVal = Interface_Static::IVal("read.step.product.context");
+ myProductModeCVal = Interface_Static::CVal("read.step.product.mode");
SetNorm ("STEP");
}
Standard_Integer nb = Model()->NbEntities();
for (Standard_Integer i = 1; i <= nb; i ++) {
Handle(Standard_Transient) ent = Model()->Value(i);
- if (Interface_Static::IVal("read.step.all.shapes") == 1) {
+ if (myAllShapeIVal == 1) {
// Special case to read invalid shape_representation without links to shapes.
if (ent->IsKind(STANDARD_TYPE(StepShape_ManifoldSolidBrep))) {
Interface_EntityIterator aShareds = WS()->Graph().Sharings(ent);
}
// determinate roots used ProductDefinitionContext
if(IsRoot) {
- const char *str1 = Interface_Static::CVal("read.step.product.context");
- Standard_Integer ICS = Interface_Static::IVal("read.step.product.context");
- if(ICS>1) {
+ const char *aStr1 = myProductContextCVal;
+ Standard_Integer anICS = myProductContextIVal;
+ if(anICS>1) {
subs = graph.Shareds(PD);
for(subs.Start(); subs.More(); subs.Next()) {
Handle(StepBasic_ProductDefinitionContext) PDC =
if (PDC.IsNull()) continue;
const char *str2 = PDC->LifeCycleStage()->String().ToCString();
const char *str3 = PDC->Name()->String().ToCString();
- if( !( strcasecmp(str1,str2)==0 || strcasecmp(str1,str3)==0 ) )
+ if( !( strcasecmp(aStr1,str2)==0 || strcasecmp(aStr1,str3)==0 ) )
IsRoot=Standard_False;
}
}
WS()->TransferReader()->TransientProcess()->RootsForTransfer()->Append(ent);
}
}
- TCollection_AsciiString aProdMode = Interface_Static::CVal("read.step.product.mode");
+ TCollection_AsciiString aProdMode = myProductModeCVal;
if(!aProdMode.IsEqual("ON")) {
if(ent->IsKind(STANDARD_TYPE(StepShape_ShapeDefinitionRepresentation))) {
Standard_Boolean IsRoot = Standard_True;
return nbFind != 0;
}
+
+void STEPControl_Reader::SetAllShapeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.step.all.shapes", theVal);
+ myAllShapeIVal = theVal;
+}
+
+void STEPControl_Reader::SetProductContextCVal(const Standard_CString theVal)
+{
+ Interface_Static::SetCVal("read.step.product.context", theVal);
+ myProductContextCVal = theVal;
+}
+
+void STEPControl_Reader::SetProductContextIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.step.product.context", theVal);
+ myProductContextIVal = theVal;
+}
+
+void STEPControl_Reader::SetProductModeCVal(const Standard_CString theVal)
+{
+ Interface_Static::SetCVal("read.step.product.mode", theVal);
+ myProductModeCVal = theVal;
+}
+
+Standard_Integer STEPControl_Reader::GetAllShapeIVal() const
+{
+ return myAllShapeIVal;
+}
+
+Standard_CString STEPControl_Reader::GetProductContextCVal() const
+{
+ return myProductContextCVal;
+}
+
+Standard_Integer STEPControl_Reader::GetProductContextIVal() const
+{
+ return myProductContextIVal;
+}
+
+Standard_CString STEPControl_Reader::GetProductModeCVal() const
+{
+ return myProductModeCVal;
+}
\ No newline at end of file
//! Returns system length unit used by transfer process
Standard_EXPORT Standard_Real SystemLengthUnit() const;
+ Standard_EXPORT void SetAllShapeIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetProductContextCVal(const Standard_CString theVal);
+
+ Standard_EXPORT void SetProductContextIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT void SetProductModeCVal(const Standard_CString theVal);
+
+ Standard_EXPORT Standard_Integer GetAllShapeIVal() const;
+
+ Standard_EXPORT Standard_CString GetProductContextCVal() const;
+
+ Standard_EXPORT Standard_Integer GetProductContextIVal() const;
+
+ Standard_EXPORT Standard_CString GetProductModeCVal() const;
+
protected:
//! Returns units for length , angle and solidangle for shape representations
Standard_EXPORT Standard_Boolean findUnits (const Handle(StepRepr_RepresentationContext)& theReprContext, TColStd_Array1OfAsciiString& theNameUnits, TColStd_Array1OfReal& theFactorUnits);
-
-
+ Standard_Integer myAllShapeIVal;
+ Standard_CString myProductContextCVal;
+ Standard_Integer myProductContextIVal;
+ Standard_CString myProductModeCVal;
};
types.Bind(STANDARD_TYPE(StepKinematics_MechanismStateRepresentation), 801);
types.Bind(STANDARD_TYPE(StepVisual_RepositionedTessellatedGeometricSet), 802);
types.Bind(STANDARD_TYPE(StepVisual_RepositionedTessellatedItem), 803);
+ mySchemaIVal = Interface_Static::IVal("write.step.schema");
}
Standard_CString StepAP214_Protocol::SchemaName() const
{
- switch (Interface_Static::IVal("write.step.schema")) { //:j4
+ switch (mySchemaIVal) { //:j4
default:
case 1 : return schemaAP214CD; break;
case 2 : return schemaAP214DIS; break;
return HeaderSection::Protocol();
}
+void StepAP214_Protocol::SetSchemaIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.schema", theVal);
+ mySchemaIVal = theVal;
+}
+
+Standard_Integer StepAP214_Protocol::GetSchemaIVal() const
+{
+ return mySchemaIVal;
+}
//! Returns a Resource, given its rank (between 1 and NbResources)
Standard_EXPORT virtual Handle(Interface_Protocol) Resource (const Standard_Integer num) const Standard_OVERRIDE;
+ Standard_EXPORT void SetSchemaIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetSchemaIVal() const;
DEFINE_STANDARD_RTTIEXT(StepAP214_Protocol,StepData_Protocol)
private:
-
+ Standard_Integer mySchemaIVal;
};
StepData_StepModel::StepData_StepModel () :mySourceCodePage((Resource_FormatType)Interface_Static::IVal("read.step.codepage")),
myReadUnitIsInitialized(Standard_False), myWriteUnit (1.)
{
- switch (Interface_Static::IVal("write.step.unit"))
+ myWriteUnitIVal = Interface_Static::IVal("write.step.unit");
+ switch (myWriteUnitIVal)
{
case 1: myWriteUnit = 25.4; break;
case 2: myWriteUnit = 1.; break;
Standard_Real StepData_StepModel::WriteLengthUnit() const
{
return myWriteUnit;
-}
\ No newline at end of file
+}
+
+void StepData_StepModel::SetWriteUnitIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.unit", theVal);
+ myWriteUnitIVal = theVal;
+}
+
+Standard_Integer StepData_StepModel::GetWriteUnitIVal() const
+{
+ return myWriteUnitIVal;
+}
//! False - the unit value was not initialized, the default value is used
Standard_Boolean IsInitializedUnit() const { return myReadUnitIsInitialized; }
+ Standard_EXPORT void SetWriteUnitIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT Standard_Integer GetWriteUnitIVal() const;
+
DEFINE_STANDARD_RTTIEXT(StepData_StepModel,Interface_InterfaceModel)
protected:
Resource_FormatType mySourceCodePage;
Standard_Boolean myReadUnitIsInitialized;
Standard_Real myWriteUnit;
+ Standard_Integer myWriteUnitIVal;
};
Standard_Boolean SurfMode = ( ! S.IsNull() && ! Surf.IsNull() );
Standard_Boolean isClosed = Standard_False;
+ mySurCurModeIVal = Interface_Static::IVal("read.surfacecurve.mode");
- if ( SurfMode ) {
- Standard_Integer modepcurve = Interface_Static::IVal("read.surfacecurve.mode");
- if ( modepcurve ==-3 ) SurfMode = Standard_False;
+ if (SurfMode && mySurCurModeIVal == -3)
+ {
+ SurfMode = Standard_False;
}
Handle(ShapeExtend_WireData) sbwd = new ShapeExtend_WireData;
{
return myWire;
}
+
+void StepToTopoDS_TranslateCompositeCurve::SetSurCurModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.surfacecurve.mode", theVal);
+ mySurCurModeIVal = theVal;
+}
+
+Standard_Integer StepToTopoDS_TranslateCompositeCurve::GetSurCurModeIVal() const
+{
+ return mySurCurModeIVal;
+}
Standard_EXPORT const TopoDS_Wire& Value() const;
//! Returns True if composite_curve contains a segment with infinite parameters.
- Standard_Boolean IsInfiniteSegment() const;
+ Standard_Boolean IsInfiniteSegment() const;
+ Standard_EXPORT void SetSurCurModeIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetSurCurModeIVal() const;
protected:
TopoDS_Wire myWire;
Standard_Boolean myInfiniteSegment;
+ Standard_Integer mySurCurModeIVal
};
done = Standard_True;
return;
}
- Standard_Integer modepcurve = Interface_Static::IVal("read.surfacecurve.mode");
+ mySurCurModeIVal = Interface_Static::IVal("read.surfacecurve.mode");
// 0,1 : suivre le code, 2 : ne prendre que pcurve, 3 : ne prendre que C3D
BRep_Builder B;
// If modepcurve = 3, PCurve are ignored here
// -----------------------------------------
- else if (modepcurve == 3) {
+ else if (mySurCurModeIVal == 3) {
aTool.ComputePCurve(Standard_True);
hasPcurve = Standard_False;
}
return myError;
}
+void StepToTopoDS_TranslateEdgeLoop::SetSurCurModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.surfacecurve.mode", theVal);
+ mySurCurModeIVal = theVal;
+}
+
+Standard_Integer StepToTopoDS_TranslateEdgeLoop::GetSurCurModeIVal() const
+{
+ return mySurCurModeIVal;
+}
Standard_EXPORT StepToTopoDS_TranslateEdgeLoopError Error() const;
+ Standard_EXPORT void SetSurCurModeIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetSurCurModeIVal() const;
protected:
StepToTopoDS_TranslateEdgeLoopError myError;
TopoDS_Shape myResult;
+ Standard_Integer mySurCurModeIVal;
};
aTool.SetCurrentEdge(aEdge);
// [BEGIN] Processing non-manifold topology (ssv; 11.11.2010)
- Standard_Boolean isNMMode = Interface_Static::IVal("write.step.nonmanifold") != 0;
+ myNonmanifoldIVal = Interface_Static::IVal("write.step.nonmanifold");
+ Standard_Boolean isNMMode = myNonmanifoldIVal != 0;
if (isNMMode) {
Handle(StepShape_EdgeCurve) anEC;
Handle(TransferBRep_ShapeMapper) aSTEPMapper = TransferBRep::ShapeMapper(FP, aEdge);
{
return myError;
}
+
+void TopoDSToStep_MakeStepEdge::SetNonmanifoldIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.nonmanifold", theVal);
+ myNonmanifoldIVal = theVal;
+}
+
+Standard_Integer TopoDSToStep_MakeStepEdge::GetNonmanifoldIVal() const
+{
+ return myNonmanifoldIVal;
+}
+
Standard_EXPORT TopoDSToStep_MakeEdgeError Error() const;
+ Standard_EXPORT void SetNonmanifoldIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetNonmanifoldIVal() const;
protected:
Handle(StepShape_TopologicalRepresentationItem) myResult;
TopoDSToStep_MakeEdgeError myError;
+ Standard_Integer myNonmanifoldIVal;
};
// --------------------------------------------------------------
//szv#4:S4163:12Mar99 SGI warns
+ myNonmanifoldIVal = Interface_Static::IVal("write.step.nonmanifold");
TopoDS_Shape sh = aFace.Oriented(TopAbs_FORWARD);
const TopoDS_Face ForwardFace = TopoDS::Face(sh);
aTool.SetCurrentFace(ForwardFace);
new TransferBRep_ShapeMapper(aFace); // on ne sait jamais
// [BEGIN] Processing non-manifold topology (another approach) (ssv; 10.11.2010)
- Standard_Boolean isNMMode = Interface_Static::IVal("write.step.nonmanifold") != 0;
+ Standard_Boolean isNMMode = myNonmanifoldIVal != 0;
if (isNMMode) {
Handle(StepShape_AdvancedFace) anAF;
Handle(TransferBRep_ShapeMapper) aSTEPMapper = TransferBRep::ShapeMapper(FP, aFace);
{
return myError;
}
+
+void TopoDSToStep_MakeStepFace::SetNonmanifoldIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.nonmanifold", theVal);
+ myNonmanifoldIVal = theVal;
+}
+
+Standard_Integer TopoDSToStep_MakeStepFace::GetNonmanifoldIVal() const
+{
+ return myNonmanifoldIVal;
+}
Standard_EXPORT TopoDSToStep_MakeFaceError Error() const;
+ Standard_EXPORT void SetNonmanifoldIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetNonmanifoldIVal() const;
protected:
Handle(StepShape_TopologicalRepresentationItem) myResult;
TopoDSToStep_MakeFaceError myError;
+ Standard_Integer myNonmanifoldIVal;
};
TopoDSToStep_Tool& aTool,
const Handle(Transfer_FinderProcess)& FP)
{
-
+ myNonmanifoldIVal = Interface_Static::IVal("write.step.nonmanifold");
aTool.SetCurrentVertex(aVertex);
// [BEGIN] Processing non-manifold topology (ssv; 11.11.2010)
- Standard_Boolean isNMMode = Interface_Static::IVal("write.step.nonmanifold") != 0;
+ Standard_Boolean isNMMode = myNonmanifoldIVal != 0;
if (isNMMode) {
Handle(StepShape_VertexPoint) aVP;
Handle(TransferBRep_ShapeMapper) aSTEPMapper = TransferBRep::ShapeMapper(FP, aVertex);
return myError;
}
+void TopoDSToStep_MakeStepVertex::SetNonmanifoldIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.nonmanifold", theVal);
+ myNonmanifoldIVal = theVal;
+}
+
+Standard_Integer TopoDSToStep_MakeStepVertex::GetNonmanifoldIVal() const
+{
+ return myNonmanifoldIVal;
+}
Standard_EXPORT TopoDSToStep_MakeVertexError Error() const;
+ Standard_EXPORT void SetNonmanifoldIVal(const Standard_Integer theVal);
+ Standard_EXPORT Standard_Integer GetNonmanifoldIVal() const;
protected:
Handle(StepShape_TopologicalRepresentationItem) myResult;
TopoDSToStep_MakeVertexError myError;
+ Standard_Integer myNonmanifoldIVal;
};
{
return myPCurveMode;
}
+
+void TopoDSToStep_Tool::SetPCurveMode(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.surfacecurve.mode", theVal);
+ myPCurveMode = theVal;
+}
//! (initialized by parameter write.surfacecurve.mode)
Standard_EXPORT Standard_Integer PCurveMode() const;
-
+ Standard_EXPORT void SetPCurveMode(const Standard_Integer theVal);
protected:
//=======================================================================
XSAlgo_AlgoContainer::XSAlgo_AlgoContainer()
{
+ myParModeIVal = Interface_Static::IVal("read.stdsameparameter.mode");
+ myUnitIVal = Interface_Static::IVal("xstep.cascade.unit");
myTC = new XSAlgo_ToolContainer;
}
void XSAlgo_AlgoContainer::PrepareForTransfer() const
{
- UnitsMethods::SetCasCadeLengthUnit(Interface_Static::IVal("xstep.cascade.unit"));
+ UnitsMethods::SetCasCadeLengthUnit(myUnitIVal);
}
//=======================================================================
B.Range(edge,face,w1,w2);
B.SameRange(edge, Standard_False );
//:S4136
- Standard_Integer SPmode = Interface_Static::IVal("read.stdsameparameter.mode");
+ Standard_Integer SPmode = myParModeIVal;
if ( SPmode )
B.SameParameter (edge, Standard_False );
}
}
}
+
+void XSAlgo_AlgoContainer::SetParModeIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("read.stdsameparameter.mode", theVal);
+ myParModeIVal = theVal;
+}
+
+void XSAlgo_AlgoContainer::SetUnitIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("xstep.cascade.unit", theVal);
+ myUnitIVal = theVal;
+}
+
+Standard_Integer XSAlgo_AlgoContainer::GetParModeIVal() const
+{
+ return myParModeIVal;
+}
+
+Standard_EXPORT Standard_Integer XSAlgo_AlgoContainer::GetUnitIVal() const
+{
+ return myUnitIVal;
+}
//! from item startTPitem
Standard_EXPORT virtual void MergeTransferInfo (const Handle(Transfer_FinderProcess)& FP, const Handle(Standard_Transient)& info) const;
+ Standard_EXPORT void SetParModeIVal(const Standard_Integer theVal);
+ Standard_EXPORT void SetUnitIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT Standard_Integer GetParModeIVal() const;
+
+ Standard_EXPORT Standard_Integer GetUnitIVal() const;
DEFINE_STANDARD_RTTIEXT(XSAlgo_AlgoContainer,Standard_Transient)
Handle(XSAlgo_ToolContainer) myTC;
+ Standard_Integer myParModeIVal;
+ Standard_Integer myUnitIVal;
};
inline void XSAlgo_AlgoContainer::SetToolContainer(const Handle(XSAlgo_ToolContainer)& TC)
{
+ myParModeIVal = Interface_Static::IVal("read.stdsameparameter.mode");
+ myUnitIVal = Interface_Static::IVal("xstep.cascade.unit");
myTC = TC;
}
if (theModel.IsNull()) return IFSelect_RetVoid;
TopoDS_Shape aShape = theShape;
- Standard_Boolean isNMMode = Interface_Static::IVal("write.step.nonmanifold") != 0;
+ Standard_Boolean isNMMode = myNonmanifoldIVal != 0;
if (isNMMode)
{
ShapeUpgrade_RemoveLocations aRemLoc;
}
return chl;
}
+
+void XSControl_TransferWriter::SetNonmanifoldIVal(const Standard_Integer theVal)
+{
+ Interface_Static::SetIVal("write.step.nonmanifold", theVal);
+ myNonmanifoldIVal = theVal;
+}
+
+Standard_Integer XSControl_TransferWriter::GetNonmanifoldIVal() const
+{
+ return myNonmanifoldIVal;
+}
#include <Standard_Transient.hxx>
#include <IFSelect_ReturnStatus.hxx>
+#include <Interface_Static.hxx>
#include <Transfer_FinderProcess.hxx>
class XSControl_Controller;
class Interface_InterfaceModel;
void SetController (const Handle(XSControl_Controller)& theCtl)
{
myController = theCtl;
+ myNonmanifoldIVal = Interface_Static::IVal("write.step.nonmanifold");
Clear(-1);
}
//! instead of keeping the original Mapper, whenever known
Standard_EXPORT Interface_CheckIterator ResultCheckList (const Handle(Interface_InterfaceModel)& theModel) const;
+ Standard_EXPORT void SetNonmanifoldIVal(const Standard_Integer theVal);
+
+ Standard_EXPORT Standard_Integer GetNonmanifoldIVal() const;
+
DEFINE_STANDARD_RTTIEXT(XSControl_TransferWriter,Standard_Transient)
private:
Handle(XSControl_Controller) myController;
Handle(Transfer_FinderProcess) myTransferWriter;
Standard_Integer myTransferMode;
+ Standard_Integer myNonmanifoldIVal;
};
#endif // _XSControl_TransferWriter_HeaderFile
projects / occt.git / commitdiff