- Standardizes comment formatting by replacing detailed comment blocks with a uniform "//=================================================================================================" separator
- Removes redundant "function:" and "purpose:" fields that often contained minimal or no useful information
- Maintains code functionality while improving visual consistency across the codebase
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetWithTriangles
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BinMNaming_NamedShapeDriver::SetWithTriangles(const Standard_Boolean isWithTriangles)
{
myShapeSet->SetWithTriangles(isWithTriangles);
}
-//=======================================================================
-// function : SetWithNormals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BinMNaming_NamedShapeDriver::SetWithNormals(const Standard_Boolean isWithNormals)
{
#include <TDF_Attribute.hxx>
-//=======================================================================
-// function : TypeName
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TCollection_AsciiString& BinMDF_ADriver::TypeName() const
{
return myIsError;
}
-//=======================================================================
-// function : PutBoolean
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BinObjMgt_Persistent& BinObjMgt_Persistent::PutBoolean(const Standard_Boolean theValue)
{
return PutInteger((Standard_Integer)theValue);
}
-//=======================================================================
-// function : GetBoolean
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const BinObjMgt_Persistent& BinObjMgt_Persistent::GetBoolean(
Standard_Boolean& theValue) const
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Signature
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer TDataXtd_PatternStd::Signature() const
{
return mySignature;
}
-//=======================================================================
-// function : Axis1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TNaming_NamedShape) TDataXtd_PatternStd::Axis1() const
{
return myAxis1;
}
-//=======================================================================
-// function : Axis2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TNaming_NamedShape) TDataXtd_PatternStd::Axis2() const
{
return myAxis2;
}
-//=======================================================================
-// function : Axis1Reversed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TDataXtd_PatternStd::Axis1Reversed() const
{
return myAxis1Reversed;
}
-//=======================================================================
-// function : Axis2Reversed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TDataXtd_PatternStd::Axis2Reversed() const
{
return myAxis2Reversed;
}
-//=======================================================================
-// function : Value1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TDataStd_Real) TDataXtd_PatternStd::Value1() const
{
return myValue1;
}
-//=======================================================================
-// function : Value2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TDataStd_Real) TDataXtd_PatternStd::Value2() const
{
return myValue2;
}
-//=======================================================================
-// function : NbInstances1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TDataStd_Integer) TDataXtd_PatternStd::NbInstances1() const
{
return myNb1;
}
-//=======================================================================
-// function : NbInstances2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TDataStd_Integer) TDataXtd_PatternStd::NbInstances2() const
{
return myNb2;
}
-//=======================================================================
-// function : Mirror
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TNaming_NamedShape) TDataXtd_PatternStd::Mirror() const
{
return anOld;
}
-//=======================================================================
-// function : TDataXtd_Presentation
-// purpose : Default constructor.
-//=======================================================================
+//=================================================================================================
+
TDataXtd_Presentation::TDataXtd_Presentation()
: myDriverGUID("00000000-0000-0000-0000-000000000000"),
myColor(Quantity_NOC_WHITE),
return TD;
}
-//=======================================================================
-// function : Translates
-// purpose : Topological Location
-//=======================================================================
+//=================================================================================================
TopLoc_Location TNaming_CopyShape::Translate(const TopLoc_Location& L,
TColStd_IndexedDataMapOfTransientTransient& aMap)
#include <TNaming_ShapesSet.hxx>
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TNaming_IteratorOnShapesSet::TNaming_IteratorOnShapesSet() {}
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TNaming_IteratorOnShapesSet::TNaming_IteratorOnShapesSet(const TNaming_ShapesSet& S)
{
Init(S);
}
-//=======================================================================
-// function : Init
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TNaming_IteratorOnShapesSet::Init(const TNaming_ShapesSet& S)
{
myIt.Initialize(S.Map());
}
-//=======================================================================
-// function : More
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TNaming_IteratorOnShapesSet::More() const
{
return (myIt.More());
}
-//=======================================================================
-// function : Next
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TNaming_IteratorOnShapesSet::Next()
{
myIt.Next();
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& TNaming_IteratorOnShapesSet::Value() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : ID
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Standard_GUID& TNaming_NamedShape::ID() const
{
return GetID();
}
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TNaming_Evolution TNaming_NamedShape::Evolution() const
{
return myEvolution;
}
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer TNaming_NamedShape::Version() const
{
return myVersion;
}
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TNaming_NamedShape::SetVersion(const Standard_Integer v)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : More
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TNaming_NewShapeIterator::More() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : More
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TNaming_OldShapeIterator::More() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : TNaming_RefShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TNaming_RefShape::TNaming_RefShape()
: myFirstUse(0)
{
}
-//=======================================================================
-// function : TNaming_RefShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TNaming_RefShape::TNaming_RefShape(const TopoDS_Shape& S)
: myShape(S),
{
}
-//=======================================================================
-// function : FirstUse
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TNaming_RefShape::FirstUse(const TNaming_PtrNode& pdn)
{
myFirstUse = pdn;
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TNaming_RefShape::Shape(const TopoDS_Shape& S)
{
myShape = S;
}
-//=======================================================================
-// function : FirstUse
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TNaming_PtrNode TNaming_RefShape::FirstUse() const
{
return myFirstUse;
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& TNaming_RefShape::Shape() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : More
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TNaming_SameShapeIterator::More() const
{
#include <TopTools_MapOfShape.hxx>
-//=======================================================================
-// function : TNaming_ShapesSet
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TNaming_ShapesSet::TNaming_ShapesSet() {}
-//=======================================================================
-// function : Clear
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TNaming_ShapesSet::Clear()
{
myMap.Clear();
}
-//=======================================================================
-// function : Add
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TNaming_ShapesSet::Add(const TopoDS_Shape& S)
{
return myMap.Add(S);
}
-//=======================================================================
-// function : Standard_Boolean
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TNaming_ShapesSet::Contains(const TopoDS_Shape& S) const
{
return myMap.Contains(S);
}
-//=======================================================================
-// function : Standard_Boolean
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TNaming_ShapesSet::Remove(const TopoDS_Shape& S)
{
return myMap.Remove(S);
}
-//=======================================================================
-// function : IsEmpty
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TNaming_ShapesSet::IsEmpty() const
{
return myMap.IsEmpty();
}
-//=======================================================================
-// function : NbShapes
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer TNaming_ShapesSet::NbShapes() const
{
return myMap.Extent();
}
-//=======================================================================
-// function : ChangeMap
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopTools_MapOfShape& TNaming_ShapesSet::ChangeMap()
{
return myMap;
}
-//=======================================================================
-// function : Map
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_MapOfShape& TNaming_ShapesSet::Map() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Map
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TNaming_DataMapOfShapePtrRefShape& TNaming_UsedShapes::Map()
{
return myMap;
}
-//=======================================================================
-// function : ID
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Standard_GUID& TNaming_UsedShapes::ID() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : GetStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline PCDM_ReaderStatus PCDM_Reader::GetStatus() const
{
#define TDF_DATA_COMMIT_OPTIMIZED
-//=======================================================================
-// function : TDF_Attribute
-// purpose : Initializes fields.
-//=======================================================================
+//=================================================================================================
TDF_Attribute::TDF_Attribute()
: myLabelNode(NULL),
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TDF_CopyLabel::IsDone() const
{
myIDMap.Remove(anID);
}
-//=======================================================================
-// function : Keep
-// purpose : Keeps a list of ID.
-//=======================================================================
+//=================================================================================================
void TDF_IDFilter::Keep(const TDF_IDList& anIDList)
{
return myTreeID;
}
-//=======================================================================
-// TreeNode : TDataStd_TreeNode
-// purpose : Constructor
-//=======================================================================
+//=================================================================================================
TDataStd_TreeNode::TDataStd_TreeNode()
: myFather(NULL),
return O;
}
-//=======================================================================
-// TreeNode : First
-// purpose : Returns first child
-//=======================================================================
+//=================================================================================================
Handle(TDataStd_TreeNode) TDataStd_TreeNode::First() const
{
return Standard_True;
}
-//=======================================================================
-// TreeNode : Restore
-// purpose :
-//=======================================================================
+//=================================================================================================
void TDataStd_TreeNode::Restore(const Handle(TDF_Attribute)& other)
{
}
}
-//=======================================================================
-// TreeNode : Dump
-// purpose : Dump of the TreeNode
-//=======================================================================
+//=================================================================================================
Standard_OStream& TDataStd_TreeNode::Dump(Standard_OStream& anOS) const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : GetDocuments
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TDocStd_SequenceOfDocument& TDocStd_ApplicationDelta::GetDocuments()
{
return myDocuments;
}
-//=======================================================================
-// function : GetName
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TCollection_ExtendedString& TDocStd_ApplicationDelta::GetName() const
{
return myName;
}
-//=======================================================================
-// function : SetName
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TDocStd_ApplicationDelta::SetName(const TCollection_ExtendedString& theName)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : GetUndoLimit
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer TDocStd_MultiTransactionManager::GetUndoLimit() const
{
return myUndoLimit;
}
-//=======================================================================
-// function : GetAvailableUndos
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TDocStd_SequenceOfApplicationDelta& TDocStd_MultiTransactionManager::
GetAvailableUndos() const
return myUndos;
}
-//=======================================================================
-// function : GetAvailableRedos
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TDocStd_SequenceOfApplicationDelta& TDocStd_MultiTransactionManager::
GetAvailableRedos() const
return myRedos;
}
-//=======================================================================
-// function : Documents
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TDocStd_SequenceOfDocument& TDocStd_MultiTransactionManager::Documents() const
{
return myDocuments;
}
-//=======================================================================
-// function : IsNestedTransactionMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TDocStd_MultiTransactionManager::IsNestedTransactionMode() const
{
return myIsNestedTransactionMode;
}
-//=======================================================================
-// function : HasOpenCommand
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TDocStd_MultiTransactionManager::HasOpenCommand() const
{
return Standard_False;
}
-//=======================================================================
-// function : Clear
-// purpose : Removes all drivers
-//=======================================================================
+//=================================================================================================
void TFunction_DriverTable::Clear()
{
void TFunction_Function::References(const Handle(TDF_DataSet)& /*aDataSet*/) const {}
-//=======================================================================
-// function : Dump
-// purpose : Dump of the function
-//=======================================================================
+//=================================================================================================
Standard_OStream& TFunction_Function::Dump(Standard_OStream& anOS) const
{
return TFunction_Scope::Set(myLabel)->GetFunctions();
}
-//=======================================================================
-// function : GetLogbook
-// purpose : Returns the Logbook.
-//=======================================================================
+//=================================================================================================
Handle(TFunction_Logbook) TFunction_IFunction::GetLogbook() const
{
return myFunctions.IsBound2(L);
}
-//=======================================================================
-// function : GetFunction
-// purpose : Returns a function.
-//=======================================================================
+//=================================================================================================
Standard_Integer TFunction_Scope::GetFunction(const TDF_Label& L) const
{
return myFunctions.Find2(L);
}
-//=======================================================================
-// function : GetFunction
-// purpose : Returns a function.
-//=======================================================================
+//=================================================================================================
const TDF_Label& TFunction_Scope::GetFunction(const Standard_Integer ID) const
{
return myFunctions.Find1(ID);
}
-//=======================================================================
-// function : GetLogbook
-// purpose : Returns the Logbook.
-//=======================================================================
+//=================================================================================================
Handle(TFunction_Logbook) TFunction_Scope::GetLogbook() const
{
return Standard_True;
}
-//=======================================================================
-// function : Detach
-// purpose : public static method
-//=======================================================================
+//=================================================================================================
Standard_Boolean TObj_Object::Detach(const TDF_Label& theLabel, const TObj_DeletingMode theMode)
{
aModel->RegisterName(GetName(), GetLabel(), GetDictionary());
}
-//=======================================================================
-// function : BeforeStoring
-// purpose : base implementation
-//=======================================================================
+//=================================================================================================
void TObj_Object::BeforeStoring() {}
getMapOfTypes().Bind(theType, this);
}
-//=======================================================================
-// function : Destructor
-// purpose : Unregister the type
-//=======================================================================
+//=================================================================================================
TObj_Persistence::~TObj_Persistence()
{
myMasterLabel = theMasterLabel;
}
-//=======================================================================
-// function : Set
-// purpose : for persistent only.
-//=======================================================================
+//=================================================================================================
void TObj_TReference::Set(const TDF_Label& theLabel, const TDF_Label& theMasterLabel)
{
}
}
-//=======================================================================
-// function : AfterResume
-// purpose : display if displayed
-//=======================================================================
+//=================================================================================================
+
void TPrsStd_AISPresentation::AfterResume()
{
if (IsDisplayed())
return myDrivers.UnBind(guid);
}
-//=======================================================================
-// function : Clear
-// purpose : Removes all drivers
-//=======================================================================
+//=================================================================================================
void TPrsStd_DriverTable::Clear()
{
return aResult;
}
-//=======================================================================
-// function : doTranslate
-// purpose : shape storage to XML
-//=======================================================================
+//=================================================================================================
static void doTranslate(const TopoDS_Shape& theShape,
XmlMNaming_Shape1& theResult,
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : GetShapesLocations
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline TopTools_LocationSet& XmlMNaming_NamedShapeDriver::GetShapesLocations()
{
return myShapeSet.ChangeLocations();
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Element
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const XmlObjMgt_Element& XmlObjMgt_Array1::Element() const
{
return myElement;
}
-//=======================================================================
-// function : Length
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer XmlObjMgt_Array1::Length() const
{
return myLast - myFirst + 1;
}
-//=======================================================================
-// function : Lower
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer XmlObjMgt_Array1::Lower() const
{
return myFirst;
}
-//=======================================================================
-// function : Upper
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer XmlObjMgt_Array1::Upper() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Element
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const XmlObjMgt_Element& XmlObjMgt_Persistent::Element() const
{
return myElement;
}
-//=======================================================================
-// function : Element
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline XmlObjMgt_Element& XmlObjMgt_Persistent::Element()
{
return myElement;
}
-//=======================================================================
-// function : operator XmlObjMgt_Element
-// purpose :
-//=======================================================================
+//=================================================================================================
inline XmlObjMgt_Persistent::operator const XmlObjMgt_Element&() const
{
return myElement;
}
-//=======================================================================
-// function : operator XmlObjMgt_Element
-// purpose :
-//=======================================================================
+//=================================================================================================
inline XmlObjMgt_Persistent::operator XmlObjMgt_Element&()
{
return myElement;
}
-//=======================================================================
-// function : Id
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer XmlObjMgt_Persistent::Id() const
{
return myID;
return;
}
-//=======================================================================
-// function : Transfer
-// purpose : basic working method
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean IGESCAFControl_Reader::Transfer(const Handle(TDocStd_Document)& doc,
const Message_ProgressRange& theProgress)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetReadVisible
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESControl_Reader::SetReadVisible(const Standard_Boolean ReadRoot)
{
theReadOnlyVisible = ReadRoot;
}
-//=======================================================================
-// function : GetReadVisible
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean IGESControl_Reader::GetReadVisible() const
{
// DefSwitch : represente une definition, soit vide (-> valeur = 0),
// soit comme rang dans une table (-> valeur > 0 ce rang),
// soit comme reference (-> valeur < 0), la reference elle-meme est ailleurs
-//=======================================================================
-// function : IGESData_DefSwitch
-// purpose : Default constructor.
-//=======================================================================
+
+//=================================================================================================
+
IGESData_DefSwitch::IGESData_DefSwitch()
: theval(0)
{
static const Standard_Integer IGESShiftHier = 12;
} // namespace
-//=======================================================================
-// function : IGESData_IGESEntity
-// purpose : Default constructor.
-//=======================================================================
+//=================================================================================================
+
IGESData_IGESEntity::IGESData_IGESEntity()
: theType(0),
theForm(0),
#include <IGESToBRep_AlgoContainer.hxx>
-//=======================================================================
-// function : SetToolContainer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_AlgoContainer::SetToolContainer(const Handle(IGESToBRep_ToolContainer)& TC)
{
myTC = TC;
}
-//=======================================================================
-// function : ToolContainer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(IGESToBRep_ToolContainer) IGESToBRep_AlgoContainer::ToolContainer() const
{
#include <Transfer_TransientProcess.hxx>
#include <IGESData_IGESEntity.hxx>
-//=======================================================================
-// function : SetEpsilon
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetEpsilon(const Standard_Real eps)
{
myEps = eps;
}
-//=======================================================================
-// function : GetEpsilon
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real IGESToBRep_CurveAndSurface::GetEpsilon() const
{
return myEps;
}
-//=======================================================================
-// function : SetEpsCoeff
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetEpsCoeff(const Standard_Real eps)
{
myEpsCoeff = eps;
}
-//=======================================================================
-// function : GetEpsCoeff
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real IGESToBRep_CurveAndSurface::GetEpsCoeff() const
{
return myEpsCoeff;
}
-//=======================================================================
-// function : GetEpsGeom
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real IGESToBRep_CurveAndSurface::GetEpsGeom() const
{
return myEpsGeom;
}
-//=======================================================================
-// function : SetMinTol
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetMinTol(const Standard_Real mintol)
{
myMinTol = mintol;
}
-//=======================================================================
-// function : SetMaxTol
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetMaxTol(const Standard_Real maxtol)
{
myMaxTol = maxtol;
}
-//=======================================================================
-// function : GetMinTol
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real IGESToBRep_CurveAndSurface::GetMinTol() const
{
return myMinTol;
}
-//=======================================================================
-// function : GetMaxTol
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real IGESToBRep_CurveAndSurface::GetMaxTol() const
{
return myMaxTol;
}
-//=======================================================================
-// function : SetModeApprox
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetModeApprox(const Standard_Boolean mode)
{
myModeApprox = mode;
}
-//=======================================================================
-// function : GetModeApprox
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean IGESToBRep_CurveAndSurface::GetModeApprox() const
{
return myModeApprox;
}
-//=======================================================================
-// function : SetModeTransfer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetModeTransfer(const Standard_Boolean mode)
{
myModeIsTopo = mode;
}
-//=======================================================================
-// function : GetModeTransfer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean IGESToBRep_CurveAndSurface::GetModeTransfer() const
{
return myModeIsTopo;
}
-//=======================================================================
-// function : SetOptimized
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetOptimized(const Standard_Boolean optimized)
{
myContIsOpti = optimized;
}
-//=======================================================================
-// function : GetOptimized
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean IGESToBRep_CurveAndSurface::GetOptimized() const
{
return myContIsOpti;
}
-//=======================================================================
-// function : GetUnitFactor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real IGESToBRep_CurveAndSurface::GetUnitFactor() const
{
return myUnitFactor;
}
-//=======================================================================
-// function : SetSurfaceCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetSurfaceCurve(const Standard_Integer ival)
{
mySurfaceCurve = ival;
}
-//=======================================================================
-// function : GetSurfaceCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer IGESToBRep_CurveAndSurface::GetSurfaceCurve() const
{
return mySurfaceCurve;
}
-//=======================================================================
-// function : GetModel
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(IGESData_IGESModel) IGESToBRep_CurveAndSurface::GetModel() const
{
return myModel;
}
-//=======================================================================
-// function : SetContinuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetContinuity(const Standard_Integer continuity)
{
myContinuity = continuity;
}
-//=======================================================================
-// function : GetContinuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer IGESToBRep_CurveAndSurface::GetContinuity() const
{
return myContinuity;
}
-//=======================================================================
-// function : SetTransferProcess
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetTransferProcess(
const Handle(Transfer_TransientProcess)& TP)
myTP = TP;
}
-//=======================================================================
-// function : GetTransferProcess
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Transfer_TransientProcess) IGESToBRep_CurveAndSurface::GetTransferProcess() const
{
return myTP;
}
-//=======================================================================
-// function : SendFail
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SendFail(const Handle(IGESData_IGESEntity)& start,
const Message_Msg& amsg)
GetTransferProcess()->SendFail(start, amsg);
}
-//=======================================================================
-// function : SendWarning
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SendWarning(const Handle(IGESData_IGESEntity)& start,
const Message_Msg& amsg)
GetTransferProcess()->SendWarning(start, amsg);
}
-//=======================================================================
-// function : SendMsg
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SendMsg(const Handle(IGESData_IGESEntity)& start,
const Message_Msg& amsg)
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetWS
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void STEPCAFControl_ExternFile::SetWS(const Handle(XSControl_WorkSession)& WS)
{
myWS = WS;
}
-//=======================================================================
-// function : GetWS
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(XSControl_WorkSession) STEPCAFControl_ExternFile::GetWS() const
{
return myWS;
}
-//=======================================================================
-// function : SetLoadStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void STEPCAFControl_ExternFile::SetLoadStatus(const IFSelect_ReturnStatus stat)
{
myLoadStatus = stat;
}
-//=======================================================================
-// function : GetLoadStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline IFSelect_ReturnStatus STEPCAFControl_ExternFile::GetLoadStatus() const
{
return myLoadStatus;
}
-//=======================================================================
-// function : SetTransferStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void STEPCAFControl_ExternFile::SetTransferStatus(const Standard_Boolean isok)
{
myTransferStatus = isok;
}
-//=======================================================================
-// function : GetTransferStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean STEPCAFControl_ExternFile::GetTransferStatus() const
{
return myTransferStatus;
}
-//=======================================================================
-// function : SetWriteStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void STEPCAFControl_ExternFile::SetWriteStatus(const IFSelect_ReturnStatus stat)
{
myWriteStatus = stat;
}
-//=======================================================================
-// function : GetWriteStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline IFSelect_ReturnStatus STEPCAFControl_ExternFile::GetWriteStatus() const
{
return myWriteStatus;
}
-//=======================================================================
-// function : SetName
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void STEPCAFControl_ExternFile::SetName(const Handle(TCollection_HAsciiString)& name)
{
myName = name;
}
-//=======================================================================
-// function : GetName
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TCollection_HAsciiString) STEPCAFControl_ExternFile::GetName() const
{
}
/*
-//=======================================================================
-//function : SetShape
-//purpose :
-//=======================================================================
+//=================================================================================================
+
inline void STEPCAFControl_ExternFile::SetShape (const TopoDS_Shape &Shape)
{
myShape = Shape;
}
-//=======================================================================
-//function : GetShape
-//purpose :
-//=======================================================================
+//=================================================================================================
+
inline TopoDS_Shape STEPCAFControl_ExternFile::GetShape () const
{
}
*/
-//=======================================================================
-// function : SetLabel
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void STEPCAFControl_ExternFile::SetLabel(const TDF_Label& Label)
{
myLabel = Label;
}
-//=======================================================================
-// function : GetLabel
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TDF_Label STEPCAFControl_ExternFile::GetLabel() const
{
theModel->SetLocalLengthUnit(aScaleFactorMM);
}
-//=======================================================================
-// function : Transfer
-// purpose : basic working method
-//=======================================================================
+//=================================================================================================
Standard_Boolean STEPCAFControl_Reader::Transfer(STEPControl_Reader& reader,
const Standard_Integer nroot,
return myAEIAs.Length();
}
-//=======================================================================
-// function : addAP214ExterRef
-// purpose : PTV 30.01.2003 TRJ11
-//=======================================================================
+//=================================================================================================
Standard_Boolean STEPConstruct_ExternRefs::addAP214ExterRef(
const Handle(StepAP214_AppliedDocumentReference)& ADR,
#include <Transfer_FinderProcess.hxx>
#include <XSControl_WorkSession.hxx>
-//=======================================================================
-// function : WS
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(XSControl_WorkSession)& STEPConstruct_Tool::WS() const
{
return myWS;
}
-//=======================================================================
-// function : Model
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Interface_InterfaceModel) STEPConstruct_Tool::Model() const
{
return myWS->Model();
}
-//=======================================================================
-// function : Graph
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Interface_Graph& STEPConstruct_Tool::Graph(const Standard_Boolean recompute) const
{
return recompute ? myWS->Graph() : myHGraph->Graph();
}
-//=======================================================================
-// function : TransientProcess
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Transfer_TransientProcess)& STEPConstruct_Tool::TransientProcess() const
{
return myTransientProcess;
}
-//=======================================================================
-// function : FinderProcess
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Transfer_FinderProcess)& STEPConstruct_Tool::FinderProcess() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : GetSDR
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(StepShape_ShapeDefinitionRepresentation) STEPSelections_AssemblyComponent::GetSDR()
const
return mySDR;
}
-//=======================================================================
-// function : GetList
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(STEPSelections_HSequenceOfAssemblyLink) STEPSelections_AssemblyComponent::GetList()
const
return myList;
}
-//=======================================================================
-// function : SetSDR
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void STEPSelections_AssemblyComponent::SetSDR(
const Handle(StepShape_ShapeDefinitionRepresentation)& sdr)
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : NbAssemblies
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer STEPSelections_AssemblyExplorer::NbAssemblies() const
{
return myRoots.Length();
}
-//=======================================================================
-// function : Root
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(STEPSelections_AssemblyComponent) STEPSelections_AssemblyExplorer::Root(
const Standard_Integer rank) const
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : GetNAUO
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(StepRepr_NextAssemblyUsageOccurrence) STEPSelections_AssemblyLink::GetNAUO() const
{
return myNAUO;
}
-//=======================================================================
-// function : GetSDSR
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Standard_Transient) STEPSelections_AssemblyLink::GetItem() const
{
return myItem;
}
-//=======================================================================
-// function : GetComponent
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(STEPSelections_AssemblyComponent) STEPSelections_AssemblyLink::GetComponent() const
{
return myComponent;
}
-//=======================================================================
-// function : SetNAUO
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void STEPSelections_AssemblyLink::SetNAUO(
const Handle(StepRepr_NextAssemblyUsageOccurrence)& nauo)
myNAUO = nauo;
}
-//=======================================================================
-// function : SetCDSR
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void STEPSelections_AssemblyLink::SetItem(const Handle(Standard_Transient)& item)
{
myItem = item;
}
-//=======================================================================
-// function : SetComponent
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void STEPSelections_AssemblyLink::SetComponent(
const Handle(STEPSelections_AssemblyComponent)& part)
#include <TopExp_Explorer.hxx>
#include <TopoDS_Shape.hxx>
-// ============================================================================
-// Method : StepToTopoDS_NMTool
-// Purpose : Default constructor
-// ============================================================================
+//=================================================================================================
StepToTopoDS_NMTool::StepToTopoDS_NMTool()
{
#include <StepToTopoDS_Root.hxx>
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean StepToTopoDS_Root::IsDone() const
{
return done;
}
-//=======================================================================
-// function : Precision
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real StepToTopoDS_Root::Precision() const
{
return myPrecision;
}
-//=======================================================================
-// function : SetPrecision
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void StepToTopoDS_Root::SetPrecision(const Standard_Real preci)
{
myPrecision = preci;
}
-//=======================================================================
-// function : MaxTol
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real StepToTopoDS_Root::MaxTol() const
{
return myMaxTol;
}
-//=======================================================================
-// function : SetMaxTol
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void StepToTopoDS_Root::SetMaxTol(const Standard_Real maxpreci)
{
#include <StepToTopoDS_TranslateCompositeCurve.hxx>
-//=======================================================================
-// function : IsInfiniteSegment
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean StepToTopoDS_TranslateCompositeCurve::IsInfiniteSegment() const
{
Standard_Integer myPosition; //!< last processed new-line symbol
};
-// =======================================================================
-// function : Next
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void XCAFPrs_DocumentIdIterator::Next()
{
for (Standard_Integer aCharIndex = myPosition + 1; aCharIndex <= myPath.Length(); ++aCharIndex)
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : MoniTool_Timer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline MoniTool_Timer::MoniTool_Timer()
: myCount(0),
{
}
-//=======================================================================
-// function : Timer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline OSD_Timer& MoniTool_Timer::Timer()
{
return myTimer;
}
-//=======================================================================
-// function : Timer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const OSD_Timer& MoniTool_Timer::Timer() const
{
return myTimer;
}
-//=======================================================================
-// function : Start
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void MoniTool_Timer::Start()
{
myNesting++;
}
-//=======================================================================
-// function : Stop
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void MoniTool_Timer::Stop()
{
// AmendStop();
}
-//=======================================================================
-// function : Reset
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void MoniTool_Timer::Reset()
{
myAmend = 0;
}
-//=======================================================================
-// function : Count
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer MoniTool_Timer::Count() const
{
return myCount;
}
-//=======================================================================
-// function : IsRunning
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer MoniTool_Timer::IsRunning() const
{
return myNesting;
}
-//=======================================================================
-// function : Amend
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real MoniTool_Timer::Amend() const
{
return myAmend;
}
-//=======================================================================
-// function : CPU
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real MoniTool_Timer::CPU()
{
return cpu - myAmend;
}
-//=======================================================================
-// function : Start
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void MoniTool_Timer::Start(const Standard_CString name)
{
Timer(name)->Start();
}
-//=======================================================================
-// function : Stop
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void MoniTool_Timer::Stop(const Standard_CString name)
{
#include <MoniTool_Timer.hxx>
-//=======================================================================
-// function : MoniTool_TimerSentry
-// purpose :
-//=======================================================================
+//=================================================================================================
inline MoniTool_TimerSentry::MoniTool_TimerSentry(const Standard_CString cname)
: myTimer(MoniTool_Timer::Timer(cname))
myTimer->Start();
}
-//=======================================================================
-// function : MoniTool_TimerSentry
-// purpose :
-//=======================================================================
+//=================================================================================================
inline MoniTool_TimerSentry::MoniTool_TimerSentry(const Handle(MoniTool_Timer)& timer)
{
myTimer->Stop();
}
-//=======================================================================
-// function : Timer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(MoniTool_Timer) MoniTool_TimerSentry::Timer() const
{
return myTimer;
}
-//=======================================================================
-// function : Stop
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void MoniTool_TimerSentry::Stop()
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Result
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::Result()
{
return myR;
}
-//=======================================================================
-// function : ResultWarning
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::ResultWarning()
{
return myRW;
}
-//=======================================================================
-// function : ResultFail
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::ResultFail()
{
return myRF;
}
-//=======================================================================
-// function : ResultWarningFail
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::ResultWarningFail()
{
return myRWF;
}
-//=======================================================================
-// function : NoResult
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::NoResult()
{
return myNR;
}
-//=======================================================================
-// function : NoResultWarning
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::NoResultWarning()
{
return myNRW;
}
-//=======================================================================
-// function : NoResultFail
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::NoResultFail()
{
return myNRF;
}
-//=======================================================================
-// function : NoResultWarningFail
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::NoResultWarningFail()
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetSharedLocations
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void XmlMXCAFDoc_LocationDriver::SetSharedLocations(
const TopTools_LocationSetPtr& theLocations)
{
return Standard_False;
}
-//=======================================================================
-// function : Find
-// purpose : Finds an attribute.
-//=======================================================================
+//=================================================================================================
Standard_Boolean DDF::Find(const Handle(TDF_Data)& DF,
const Standard_CString Entry,
// Transaction commands
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//=======================================================================
-// function : OpenTran
-// purpose : Opens a transaction
-//=======================================================================
+//=================================================================================================
static Standard_Integer OpenTran(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
return 0;
}
-//=======================================================================
-// function : AbortTran
-// purpose : Aborts a transaction
-//=======================================================================
+//=================================================================================================
static Standard_Integer AbortTran(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
DrawErase(Label(), this);
}
-//=======================================================================
-// function : AfterResume
-// purpose : display if displayed
-//=======================================================================
+//=================================================================================================
void DDataStd_DrawPresentation::AfterResume()
{
return 1;
}
-//=======================================================================
-// TreeNode : ChildNodeMore
-// purpose : ChildNodeMore
-//=======================================================================
+//=================================================================================================
static Standard_Integer DDataStd_ChildNodeMore(Draw_Interpretor& di,
Standard_Integer /*n*/,
return 0;
}
-//=======================================================================
-// TreeNode : ChildNodeNext
-// purpose : ChildNodeNext
-//=======================================================================
+//=================================================================================================
static Standard_Integer DDataStd_ChildNodeNext(Draw_Interpretor& /*di*/,
Standard_Integer /*n*/,
return 0;
}
-//=======================================================================
-// TreeNode : ChildNodeValue
-// purpose : ChildNodeValue
-//=======================================================================
+//=================================================================================================
static Standard_Integer DDataStd_ChildNodeValue(Draw_Interpretor& di,
Standard_Integer /*n*/,
return 0;
}
-//=======================================================================
-// TreeNode : TreeCommands
-// purpose :
-//=======================================================================
+//=================================================================================================
void DDataStd::TreeCommands(Draw_Interpretor& theCommands)
{
return Standard_True;
}
-//=======================================================================
-// function : Execute
-// purpose : Execute the function
-//=======================================================================
+//=================================================================================================
+
Standard_Integer DNaming_Line3DDriver::Execute(Handle(TFunction_Logbook)& theLog) const
{
Handle(TFunction_Function) aFunction;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Edge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Edge& DBRep_Edge::Edge() const
{
return myEdge;
}
-//=======================================================================
-// function : Edge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void DBRep_Edge::Edge(const TopoDS_Edge& E)
{
myEdge = E;
}
-//=======================================================================
-// function : Color
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Draw_Color& DBRep_Edge::Color() const
{
return myColor;
}
-//=======================================================================
-// function : Color
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void DBRep_Edge::Color(const Draw_Color& C)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Face
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Face& DBRep_Face::Face() const
{
return myFace;
}
-//=======================================================================
-// function : Face
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void DBRep_Face::Face(const TopoDS_Face& F)
{
myFace = F;
}
-//=======================================================================
-// function : NbIsos
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer DBRep_Face::NbIsos() const
{
return myTypes.Upper();
}
-//=======================================================================
-// function : Iso
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void DBRep_Face::Iso(const Standard_Integer I,
const GeomAbs_IsoType T,
myParams(3 * I) = T2;
}
-//=======================================================================
-// function : GetIso
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void DBRep_Face::GetIso(const Standard_Integer I,
GeomAbs_IsoType& T,
T2 = myParams(3 * I);
}
-//=======================================================================
-// function : Color
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Draw_Color& DBRep_Face::Color() const
{
return myColor;
}
-//=======================================================================
-// function : Color
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void DBRep_Face::Color(const Draw_Color& C)
{
return 0;
}
-//=======================================================================
-// function : xwd
-// purpose : xwd file from a view
-//=======================================================================
+//=================================================================================================
extern void Draw_RepaintNowIfNecessary();
{0.94, 0.9, 0.55},
{1.0, 0.5, 0.31}};
-//=======================================================================
-//function : Draw_Window
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Draw_Window::Draw_Window (const char* theTitle,
const NCollection_Vec2<int>& theXY,
const NCollection_Vec2<int>& theSize,
}
}
-//=======================================================================
-//function : init
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::init (const NCollection_Vec2<int>& theXY,
const NCollection_Vec2<int>& theSize)
{
[myWindow setReleasedWhenClosed: NO];
}
-//=======================================================================
-//function : InitBuffer
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::InitBuffer()
{
//
}
-//=======================================================================
-//function : SetPosition
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::SetPosition (Standard_Integer theNewXpos,
Standard_Integer theNewYpos)
{
[myWindow setFrameTopLeftPoint: aNewPosition];
}
-//=======================================================================
-//function : SetDimension
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::SetDimension (Standard_Integer theNewWidth,
Standard_Integer theNewHeight)
{
[myWindow setFrame: aNewContentRect display: YES];
}
-//=======================================================================
-//function : GetPosition
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::GetPosition (Standard_Integer &thePosX,
Standard_Integer &thePosY)
{
thePosY = getScreenBottom() - aWindowRect.origin.y - aWindowRect.size.height;
}
-//=======================================================================
-//function : HeightWin
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer Draw_Window::HeightWin() const
{
NSRect aViewBounds = [myView bounds];
return aViewBounds.size.height;
}
-//=======================================================================
-//function : WidthWin
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer Draw_Window::WidthWin() const
{
NSRect aViewBounds = [myView bounds];
return aViewBounds.size.width;
}
-//=======================================================================
-//function : SetTitle
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::SetTitle (const TCollection_AsciiString& theTitle)
{
NSString* aTitleNs = [[NSString alloc] initWithUTF8String: theTitle.ToCString()];
[aTitleNs release];
}
-//=======================================================================
-//function : GetTitle
-//purpose :
-//=======================================================================
+//=================================================================================================
+
TCollection_AsciiString Draw_Window::GetTitle() const
{
Standard_CString aTitle = [[myWindow title] UTF8String];
return TCollection_AsciiString (aTitle);
}
-//=======================================================================
-//function :DefineColor
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Draw_Window::DefineColor (const Standard_Integer , Standard_CString )
{
return Standard_True; // unused
}
-//=======================================================================
-//function : IsMapped
-//purpose :
-//=======================================================================
+//=================================================================================================
+
bool Draw_Window::IsMapped() const
{
if (Draw_VirtualWindows
return [myWindow isVisible];
}
-//=======================================================================
-//function : DisplayWindow
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::DisplayWindow()
{
if (Draw_VirtualWindows)
}
}
-//=======================================================================
-//function : Hide
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::Hide()
{
if (myWindow != NULL)
}
}
-//=======================================================================
-//function : Destroy
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::Destroy()
{
if (myWindow != NULL)
}
}
-//=======================================================================
-//function : Clear
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::Clear()
{
[myImageBuffer lockFocus];
}
}
-//=======================================================================
-//function : Flush
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::Flush()
{
//
}
-//=======================================================================
-//function : DrawString
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::DrawString (Standard_Integer theXLeft, Standard_Integer theYTop,
const char* theText)
{
}
}
-//=======================================================================
-//function : DrawSegments
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::DrawSegments (const Draw_XSegment* theSegments,
Standard_Integer theNumberOfElements)
{
Draw_IsInZoomingMode = Standard_False;
}
-//=======================================================================
-//function : Redraw
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::Redraw()
{
if (myUseBuffer)
}
}
-//=======================================================================
-//function : SetColor
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::SetColor (Standard_Integer theColor)
{
myCurrentColor = theColor;
}
-//=======================================================================
-//function : SetMode
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Draw_Window::SetMode (Standard_Integer theMode)
{
// unsupported
(void )theMode;
}
-//=======================================================================
-//function : Save
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Draw_Window::Save (Standard_CString theFileName) const
{
Cocoa_LocalPool aLocalPool;
return 0;
}
-//===================================================================
-// Fubction : VtkViewProj
-// Purpose :
-//===================================================================
+//=================================================================================================
+
static Standard_Integer VtkViewProj(Draw_Interpretor&,
Standard_Integer theNbArgs,
const char** theArgVec)
return 0;
}
-//===================================================================
-// Fubction : VtkDump
-// Purpose :
-//===================================================================
+//=================================================================================================
+
static Standard_Integer VtkDump(Draw_Interpretor&, Standard_Integer theArgNum, const char** theArgs)
{
if (!GetInteractor() || !GetInteractor()->IsEnabled())
return 0;
}
-//===================================================================
-// Fubction : VtkBackgroundColor
-// Purpose :
-//===================================================================
+//=================================================================================================
+
static Standard_Integer VtkBackgroundColor(Draw_Interpretor&,
Standard_Integer theArgNum,
const char** theArgs)
}
}
-//=======================================================================
-// function : Attachment
-// purpose : Attachment DF entry
-//=======================================================================
+//=================================================================================================
static Standard_Integer QADNaming_Attachment(Draw_Interpretor& di,
Standard_Integer n,
g);
}
-//=======================================================================
-// class : BOPTest_Interf
-// purpose : Auxiliary class
-//=======================================================================
+//=================================================================================================
+
class BOPTest_Interf
{
public:
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Show
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTest_DrawablePolyEdgeTool::Show()
{
myHideMode = Standard_False;
}
-//=======================================================================
-// function : Hide
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTest_DrawablePolyEdgeTool::Hide()
{
myHideMode = Standard_True;
}
-//=======================================================================
-// function : DisplayRg1Line
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTest_DrawablePolyEdgeTool::DisplayRg1Line(const Standard_Boolean B)
{
myDispRg1 = B;
}
-//=======================================================================
-// function : DisplayRg1Line
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRTest_DrawablePolyEdgeTool::DisplayRg1Line() const
{
return myDispRg1;
}
-//=======================================================================
-// function : DisplayRgNLine
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTest_DrawablePolyEdgeTool::DisplayRgNLine(const Standard_Boolean B)
{
myDispRgN = B;
}
-//=======================================================================
-// function : DisplayRgNLine
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRTest_DrawablePolyEdgeTool::DisplayRgNLine() const
{
return myDispRgN;
}
-//=======================================================================
-// function : DisplayHidden
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTest_DrawablePolyEdgeTool::DisplayHidden(const Standard_Boolean B)
{
myDispHid = B;
}
-//=======================================================================
-// function : DisplayHidden
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRTest_DrawablePolyEdgeTool::DisplayHidden() const
{
return myDispHid;
}
-//=======================================================================
-// function : Debug
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTest_DrawablePolyEdgeTool::Debug(const Standard_Boolean B)
{
myDebug = B;
}
-//=======================================================================
-// function : Debug
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRTest_DrawablePolyEdgeTool::Debug() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : OutLiner
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(HLRTopoBRep_OutLiner) HLRTest_OutLiner::OutLiner() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : VisibleColor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTest_ShapeData::VisibleColor(const Draw_Color& CVis)
{
myVColor = CVis;
}
-//=======================================================================
-// function : VisibleOutLineColor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTest_ShapeData::VisibleOutLineColor(const Draw_Color& COVis)
{
myVOColor = COVis;
}
-//=======================================================================
-// function : VisibleIsoColor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTest_ShapeData::VisibleIsoColor(const Draw_Color& CIVis)
{
myVIColor = CIVis;
}
-//=======================================================================
-// function : HiddenColor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTest_ShapeData::HiddenColor(const Draw_Color& CHid)
{
myHColor = CHid;
}
-//=======================================================================
-// function : HiddenOutLineColor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTest_ShapeData::HiddenOutLineColor(const Draw_Color& COHid)
{
myHOColor = COHid;
}
-//=======================================================================
-// function : HiddenIsoColor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTest_ShapeData::HiddenIsoColor(const Draw_Color& CIHid)
{
myHIColor = CIHid;
}
-//=======================================================================
-// function : VisibleColor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Draw_Color HLRTest_ShapeData::VisibleColor() const
{
return myVColor;
}
-//=======================================================================
-// function : VisibleOutLineColor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Draw_Color HLRTest_ShapeData::VisibleOutLineColor() const
{
return myVOColor;
}
-//=======================================================================
-// function : VisibleIsoColor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Draw_Color HLRTest_ShapeData::VisibleIsoColor() const
{
return myVIColor;
}
-//=======================================================================
-// function : HiddenColor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Draw_Color HLRTest_ShapeData::HiddenColor() const
{
return myHColor;
}
-//=======================================================================
-// function : HiddenOutLineColor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Draw_Color HLRTest_ShapeData::HiddenOutLineColor() const
{
return myHOColor;
}
-//=======================================================================
-// function : HiddenIsoColor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Draw_Color HLRTest_ShapeData::HiddenIsoColor() const
{
extern NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)> ViewerTest_myViews;
-// =======================================================================
-// function : GetCocoaScreenResolution
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void GetCocoaScreenResolution (Standard_Integer& theWidth, Standard_Integer& theHeight)
{
NSRect aRect = [[NSScreen mainScreen] visibleFrame];
theHeight = (Standard_Integer )aRect.size.height;
}
-// =======================================================================
-// function : FindViewId
-// purpose :
-// =======================================================================
+//=================================================================================================
+
TCollection_AsciiString FindViewId (const NSWindow* theWindow)
{
TCollection_AsciiString aViewId = "";
@end
-// =======================================================================
-// function : ViewerMainLoop
-// purpose :
-// =======================================================================
+//=================================================================================================
+
int ViewerMainLoop (Standard_Integer, const char** )
{
// unused
return 0;
}
-// =======================================================================
-// function : ViewerTest_SetCocoaEventManagerView
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void ViewerTest_SetCocoaEventManagerView (const Handle(Cocoa_Window)& theWindow)
{
if (theWindow.IsNull())
@implementation ViewerTest_CocoaEventManagerView
-// =======================================================================
-// function : setFrameSize
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (void )setFrameSize: (NSSize )theNewSize
{
[super setFrameSize: theNewSize];
ViewerTest::CurrentEventManager()->ProcessConfigure();
}
-// =======================================================================
-// function : drawRect
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (void )drawRect: (NSRect )theDirtyRect
{
(void )theDirtyRect;
}
}
-// =======================================================================
-// function : mouseMoved
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (void )mouseMoved: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
-// =======================================================================
-// function : acceptsFirstResponder
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (BOOL )acceptsFirstResponder
{
return YES;
}
-// =======================================================================
-// function : mouseDown
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (void )mouseDown: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
-// =======================================================================
-// function : mouseUp
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (void )mouseUp: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
-// =======================================================================
-// function : mouseDragged
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (void )mouseDragged: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
-// =======================================================================
-// function : rightMouseDown
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (void )rightMouseDown: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
-// =======================================================================
-// function : rightMouseUp
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (void )rightMouseUp: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
-// =======================================================================
-// function : rightMouseDragged
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (void )rightMouseDragged: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
-// =======================================================================
-// function : scrollWheel
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (void )scrollWheel: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
-// =======================================================================
-// function : keyDown
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (void )keyDown: (NSEvent* )theEvent
{
unsigned int aKeyCode = [theEvent keyCode];
//}
}
-// =======================================================================
-// function : keyUp
-// purpose :
-// =======================================================================
+//=================================================================================================
+
- (void )keyUp: (NSEvent* )theEvent
{
unsigned int aKeyCode = [theEvent keyCode];
return 0;
}
-//=======================================================================
-// function : noteUsername
-// purpose : gets a note username
-//=======================================================================
+//=================================================================================================
+
static const cmd XNoteUsername = {"XNoteUsername", 3, "XNoteUsername Doc note"};
static Standard_Integer noteUsername(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
return 0;
}
-//=======================================================================
-// function : noteDump
-// purpose : dump a note contents
-//=======================================================================
+//=================================================================================================
+
static const cmd XNoteDump = {"XNoteDump", 3, "XNoteDump Doc note"};
static Standard_Integer noteDump(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
-//=======================================================================
-// function : MaxDegree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer BSplCLib::MaxDegree()
{
return 25;
}
-//=======================================================================
-// function : NoWeights
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TColStd_Array1OfReal* BSplCLib::NoWeights()
{
return NULL;
}
-//=======================================================================
-// function : NoMults
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TColStd_Array1OfInteger* BSplCLib::NoMults()
{
return NULL;
}
-//=======================================================================
-// function : CoefsD0
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplCLib::CoefsD0(const Standard_Real U,
const TColgp_Array1OfPnt& Poles,
BSplCLib::CacheD0(U, Poles.Length() - 1, 0., 1., Poles, Weights, P);
}
-//=======================================================================
-// function : CoefsD0
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplCLib::CoefsD0(const Standard_Real U,
const TColgp_Array1OfPnt2d& Poles,
BSplCLib::CacheD0(U, Poles.Length() - 1, 0., 1., Poles, Weights, P);
}
-//=======================================================================
-// function : CoefsD1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplCLib::CoefsD1(const Standard_Real U,
const TColgp_Array1OfPnt& Poles,
BSplCLib::CacheD1(U, Poles.Length() - 1, 0., 1., Poles, Weights, P, Vec);
}
-//=======================================================================
-// function : CoefsD1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplCLib::CoefsD1(const Standard_Real U,
const TColgp_Array1OfPnt2d& Poles,
BSplCLib::CacheD1(U, Poles.Length() - 1, 0., 1., Poles, Weights, P, Vec);
}
-//=======================================================================
-// function : CoefsD2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplCLib::CoefsD2(const Standard_Real U,
const TColgp_Array1OfPnt& Poles,
BSplCLib::CacheD2(U, Poles.Length() - 1, 0., 1., Poles, Weights, P, Vec1, Vec2);
}
-//=======================================================================
-// function : CoefsD2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplCLib::CoefsD2(const Standard_Real U,
const TColgp_Array1OfPnt2d& Poles,
BSplCLib::CacheD2(U, Poles.Length() - 1, 0., 1., Poles, Weights, P, Vec1, Vec2);
}
-//=======================================================================
-// function : CoefsD3
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplCLib::CoefsD3(const Standard_Real U,
const TColgp_Array1OfPnt& Poles,
BSplCLib::CacheD3(U, Poles.Length() - 1, 0., 1., Poles, Weights, P, Vec1, Vec2, Vec3);
}
-//=======================================================================
-// function : CoefsD3
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplCLib::CoefsD3(const Standard_Real U,
const TColgp_Array1OfPnt2d& Poles,
BSplCLib::CacheD3(U, Poles.Length() - 1, 0., 1., Poles, Weights, P, Vec1, Vec2, Vec3);
}
-//=======================================================================
-// function : PolesCoefficients
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplCLib::PolesCoefficients(const TColgp_Array1OfPnt& Poles,
TColgp_Array1OfPnt& CachePoles)
BSplCLib::PolesCoefficients(Poles, PLib::NoWeights(), CachePoles, PLib::NoWeights());
}
-//=======================================================================
-// function : PolesCoefficients
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplCLib::PolesCoefficients(const TColgp_Array1OfPnt2d& Poles,
TColgp_Array1OfPnt2d& CachePoles)
Standard_Real ders[Dimension_gen*4];
};
-//=======================================================================
-//function : Reverse
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::Reverse(Array1OfPoints& Poles,
const Standard_Integer L)
// CURVES MODIFICATIONS
//
-//=======================================================================
-//function : RemoveKnot
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean BSplCLib::RemoveKnot
(const Standard_Integer Index,
else PLib::GetPoles(newpoles,NewPoles);
}
-//=======================================================================
-//function : InsertKnot
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::InsertKnot(const Standard_Integer ,
const Standard_Real U,
k,&m,NewPoles,NewWeights,nk,nm,Epsilon(U));
}
-//=======================================================================
-//function : RaiseMultiplicity
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::RaiseMultiplicity(const Standard_Integer KnotIndex,
const Standard_Integer Mult,
k,&m,NewPoles,NewWeights,nk,nm,Epsilon(k(1)));
}
-//=======================================================================
-//function : IncreaseDegree
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::IncreaseDegree
(const Standard_Integer Degree,
else PLib::GetPoles(newpoles,NewPoles);
}
-//=======================================================================
-//function : Unperiodize
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::Unperiodize
(const Standard_Integer Degree,
else PLib::GetPoles(newpoles,NewPoles);
}
-//=======================================================================
-//function : Trimming
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::Trimming(const Standard_Integer Degree,
const Standard_Boolean Periodic,
}
}
-//=======================================================================
-//function : D0
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::D0
(const Standard_Real U,
CoordsToPoint (P, dc.poles, );
}
-//=======================================================================
-//function : D1
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::D1
(const Standard_Real U,
CoordsToPoint (V, result + Dimension_gen, );
}
-//=======================================================================
-//function : D2
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::D2
(const Standard_Real U,
CoordsToPoint (V2, result + 2 * Dimension_gen, );
}
-//=======================================================================
-//function : D3
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::D3
(const Standard_Real U,
CoordsToPoint (V3, result + 3 * Dimension_gen, );
}
-//=======================================================================
-//function : DN
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::DN
(const Standard_Real U,
}
}
-//=======================================================================
-//function : Solves a LU factored Matrix
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer
BSplCLib::SolveBandedSystem(const math_Matrix& Matrix,
theCacheArray.SetValue(theCacheArray.LowerRow(), theCacheArray.LowerCol() + aCacheShift - 1, 1.0);
}
-//=======================================================================
-//function : Interpolate
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::Interpolate(const Standard_Integer Degree,
const TColStd_Array1OfReal& FlatKnots,
InversionProblem) ;
}
-//=======================================================================
-//function : Interpolate
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::Interpolate(const Standard_Integer Degree,
const TColStd_Array1OfReal& FlatKnots,
// given u as parameter) to reach a new position
//=======================================================================
-//=======================================================================
-//function : MovePointAndTangent
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::MovePointAndTangent (const Standard_Real U,
const Vector& Delta,
ErrorStatus) ;
}
-//=======================================================================
-//function : Resolution
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::Resolution(const Array1OfPoints& Poles,
const TColStd_Array1OfReal* Weights,
UTolerance) ;
}
-//=======================================================================
-//function : FunctionMultiply
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::FunctionMultiply
(const BSplCLib_EvaluatorFunction & FunctionPtr,
theStatus);
}
-//=======================================================================
-//function : FunctionReparameterise
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void BSplCLib::FunctionReparameterise
(const BSplCLib_EvaluatorFunction & FunctionPtr,
#include <TColgp_Array2OfPnt.hxx>
#include <TColStd_Array2OfReal.hxx>
-//=======================================================================
-// function : CoefsD0
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplSLib::CoefsD0(const Standard_Real U,
const Standard_Real V,
Point);
}
-//=======================================================================
-// function : CoefsD1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplSLib::CoefsD1(const Standard_Real U,
const Standard_Real V,
VecV);
}
-//=======================================================================
-// function : CoefsD2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplSLib::CoefsD2(const Standard_Real U,
const Standard_Real V,
VecVV);
}
-//=======================================================================
-// function : PolesCoefficients
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BSplSLib::PolesCoefficients(const TColgp_Array2OfPnt& Poles,
TColgp_Array2OfPnt& CachePoles)
BSplSLib::PolesCoefficients(Poles, BSplSLib::NoWeights(), CachePoles, BSplSLib::NoWeights());
}
-//=======================================================================
-// function : NoWeights
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TColStd_Array2OfReal* BSplSLib::NoWeights()
{
}
} // namespace BVH
-// =======================================================================
-// function : EstimateSAH
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N>
T BVH_Tree<T, N, BVH_BinaryTree>::EstimateSAH() const
{
return aSAH;
}
-// =======================================================================
-// function : CollapseToQuadTree
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N>
BVH_Tree<T, N, BVH_QuadTree>* BVH_Tree<T, N, BVH_BinaryTree>::CollapseToQuadTree() const
{
// clang-format on
};
-// =======================================================================
-// function : getSubVolumes
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N, int Bins>
void BVH_BinnedBuilder<T, N, Bins>::getSubVolumes(BVH_Set<T, N>* theSet,
BVH_Tree<T, N>* theBVH,
};
} // namespace BVH
-// =======================================================================
-// function : buildNode
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N, int Bins>
typename BVH_QueueBuilder<T, N>::BVH_ChildNodes BVH_BinnedBuilder<T, N, Bins>::buildNode(
BVH_Set<T, N>* theSet,
};
} // namespace BVH
-// =======================================================================
-// function : Combine
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N>
void BVH_Box<T, N>::Combine(const BVH_Box& theBox)
{
}
}
-// =======================================================================
-// function : Area
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N>
T BVH_Box<T, N>::Area() const
{
: BVH::SurfaceCalculator<T, N>::Area(myMaxPoint - myMinPoint);
}
-// =======================================================================
-// function : Center
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N>
T BVH_Box<T, N>::Center(const Standard_Integer theAxis) const
{
#include <OSD_Parallel.hxx>
#include <BVH_Distance.hxx>
-// =======================================================================
-// function : BVH_DistanceField
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N>
BVH_DistanceField<T, N>::BVH_DistanceField(const Standard_Integer theMaximumSize,
const Standard_Boolean theComputeSign)
Standard_Integer theDigit) const;
};
-// =======================================================================
-// function : BVH_LinearBuilder
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N>
BVH_LinearBuilder<T, N>::BVH_LinearBuilder(const Standard_Integer theLeafNodeSize,
const Standard_Integer theMaxTreeDepth)
};
} // namespace BVH
-// =======================================================================
-// function : Build
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N>
void BVH_LinearBuilder<T, N>::Build(BVH_Set<T, N>* theSet,
BVH_Tree<T, N>* theBVH,
};
} // namespace BVH
-// =======================================================================
-// function : SetTransform
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N>
void BVH_Transform<T, N>::SetTransform(const BVH_MatNt& theTransform)
{
BVH::MatrixOp<T, N>::Inverse(myTransform, myTransformInversed);
}
-// =======================================================================
-// function : Apply
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N>
BVH_Box<T, N> BVH_Transform<T, N>::Apply(const BVH_Box<T, N>& theBox) const
{
Standard_Integer myNumOfThreads; //!< Number of threads used to build BVH
};
-// =======================================================================
-// function : addChildren
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N>
void BVH_QueueBuilder<T, N>::addChildren(
BVH_Tree<T, N>* theBVH,
};
} // namespace BVH
-// =======================================================================
-// function : Perform
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T, int N>
void BVH_RadixSorter<T, N>::Perform(BVH_Set<T, N>* theSet,
const Standard_Integer theStart,
};
} // namespace
-// =======================================================================
-// function : BVH_Traverse::Select
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class NumType, int Dimension, class BVHSetType, class MetricType>
Standard_Integer BVH_Traverse<NumType, Dimension, BVHSetType, MetricType>::Select(
const opencascade::handle<BVH_Tree<NumType, Dimension>>& theBVH)
};
} // namespace
-// =======================================================================
-// function : BVH_PairTraverse::Select
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class NumType, int Dimension, class BVHSetType, class MetricType>
Standard_Integer BVH_PairTraverse<NumType, Dimension, BVHSetType, MetricType>::Select(
const opencascade::handle<BVH_Tree<NumType, Dimension>>& theBVH1,
return aResult;
}
-//=======================================================================
-//function : Transformed
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Bnd_B2x Bnd_B2x::Transformed (const gp_Trsf2d& theTrsf) const
{
return aResult;
}
-//=======================================================================
-//function : Transformed
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Bnd_B3x Bnd_B3x::Transformed (const gp_Trsf& theTrsf) const
{
return aResult;
}
-//=======================================================================
-//function : IsOut
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Bnd_B3x::IsOut (const gp_Ax3& thePlane) const
{
return ((aDist0 + aDist1) * (aDist0 - aDist1) > 0.);
}
-//=======================================================================
-//function : IsOut
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Bnd_B3x::IsOut (const gp_Ax1& theLine,
const Standard_Boolean isRay,
gp_Pnt operator[](Standard_Integer theIndex) const { return Value(theIndex); }
};
-// =======================================================================
-// function : Value
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Pnt Poly_ArrayOfNodes::Value(Standard_Integer theIndex) const
{
if (myStride == (Standard_Integer)sizeof(gp_Pnt))
}
}
-// =======================================================================
-// function : SetValue
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void Poly_ArrayOfNodes::SetValue(Standard_Integer theIndex, const gp_Pnt& theValue)
{
if (myStride == (Standard_Integer)sizeof(gp_Pnt))
gp_Pnt2d operator[](Standard_Integer theIndex) const { return Value(theIndex); }
};
-// =======================================================================
-// function : Value
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Pnt2d Poly_ArrayOfUVNodes::Value(Standard_Integer theIndex) const
{
if (myStride == (Standard_Integer)sizeof(gp_Pnt2d))
}
}
-// =======================================================================
-// function : SetValue
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void Poly_ArrayOfUVNodes::SetValue(Standard_Integer theIndex, const gp_Pnt2d& theValue)
{
if (myStride == (Standard_Integer)sizeof(gp_Pnt2d))
#include <TopLoc_Location.hxx>
#include <TopLoc_SListOfItemLocation.hxx>
-//=======================================================================
-// function : TopLoc_Location
-// purpose : constructor Identity
-//=======================================================================
+//=================================================================================================
TopLoc_Location::TopLoc_Location() {}
#include <TopLoc_Datum3D.hxx>
#include <TopLoc_ItemLocation.hxx>
-//=======================================================================
-// function : IsIdentity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopLoc_Location::IsIdentity() const
{
return myItems.IsEmpty();
}
-//=======================================================================
-// function : Identity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopLoc_Location::Identity()
{
myItems.Clear();
}
-//=======================================================================
-// function : FirstDatum
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(TopLoc_Datum3D)& TopLoc_Location::FirstDatum() const
{
return myItems.Value().myDatum;
}
-//=======================================================================
-// function : FirstPower
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer TopLoc_Location::FirstPower() const
{
return myItems.Value().myPower;
}
-//=======================================================================
-// function : NextLocation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopLoc_Location& TopLoc_Location::NextLocation() const
{
return (*(TopLoc_Location*)&(myItems.Tail()));
}
-//=======================================================================
-// function : HashCode
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline size_t TopLoc_Location::HashCode() const
{
// Hashing base on IsEqual function
return aHash;
}
-//=======================================================================
-// function : ShallowDump
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void ShallowDump(const TopLoc_Location& me, Standard_OStream& S)
{
me.ShallowDump(S);
gp_Dir vxdir;
};
-// =======================================================================
-// function : SetAxis
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax2::SetAxis(const gp_Ax1& theA1)
{
Standard_Real a = theA1.Direction() * vxdir;
}
}
-// =======================================================================
-// function : SetDirection
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax2::SetDirection(const gp_Dir& theV)
{
Standard_Real a = theV * vxdir;
}
}
-// =======================================================================
-// function : IsCoplanar
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Boolean gp_Ax2::IsCoplanar(const gp_Ax2& theOther,
const Standard_Real theLinearTolerance,
const Standard_Real theAngularTolerance) const
return D1 <= theLinearTolerance && axis.IsParallel(theOther.axis, theAngularTolerance);
}
-// =======================================================================
-// function : IsCoplanar
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Boolean gp_Ax2::IsCoplanar(const gp_Ax1& theA,
const Standard_Real theLinearTolerance,
const Standard_Real theAngularTolerance) const
gp_Dir2d vxdir;
};
-// =======================================================================
-// function : SetDirection
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax22d::SetXAxis(const gp_Ax2d& theA1)
{
Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
}
}
-// =======================================================================
-// function : SetDirection
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax22d::SetYAxis(const gp_Ax2d& theA1)
{
Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
}
}
-// =======================================================================
-// function : SetXDirection
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax22d::SetXDirection(const gp_Dir2d& theVx)
{
Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
}
}
-// =======================================================================
-// function : SetYDirection
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax22d::SetYDirection(const gp_Dir2d& theVy)
{
Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
}
}
-// =======================================================================
-// function : Rotate
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax22d::Rotate(const gp_Pnt2d& theP, const Standard_Real theAng)
{
gp_Pnt2d aTemp = point;
vydir.Rotate(theAng);
}
-// =======================================================================
-// function : Scale
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax22d::Scale(const gp_Pnt2d& theP, const Standard_Real theS)
{
gp_Pnt2d aTemp = point;
}
}
-// =======================================================================
-// function : Transform
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax22d::Transform(const gp_Trsf2d& theT)
{
gp_Pnt2d aTemp = point;
gp_Dir vxdir;
};
-// =======================================================================
-// function : gp_Ax3
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Ax3::gp_Ax3(const gp_Ax2& theA)
: axis(theA.Axis()),
vydir(theA.YDirection()),
{
}
-// =======================================================================
-// function : Ax2
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Ax2 gp_Ax3::Ax2() const
{
gp_Dir aZz = axis.Direction();
return gp_Ax2(axis.Location(), aZz, vxdir);
}
-// =======================================================================
-// function : SetAxis
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax3::SetAxis(const gp_Ax1& theA1)
{
axis.SetLocation(theA1.Location());
SetDirection(theA1.Direction());
}
-// =======================================================================
-// function : SetDirection
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax3::SetDirection(const gp_Dir& theV)
{
Standard_Real aDot = theV.Dot(vxdir);
}
}
-// =======================================================================
-// function : SetXDirection
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax3::SetXDirection(const gp_Dir& theVx)
{
Standard_Real aDot = theVx.Dot(axis.Direction());
}
}
-// =======================================================================
-// function : SetYDirection
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Ax3::SetYDirection(const gp_Dir& theVy)
{
Standard_Real aDot = theVy.Dot(axis.Direction());
}
}
-// =======================================================================
-// function : IsCoplanar
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Boolean gp_Ax3::IsCoplanar(const gp_Ax3& theOther,
const Standard_Real theLinearTolerance,
const Standard_Real theAngularTolerance) const
&& axis.IsParallel(theOther.axis, theAngularTolerance));
}
-// =======================================================================
-// function : IsCoplanar
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Boolean gp_Ax3::IsCoplanar(const gp_Ax1& theA1,
const Standard_Real theLinearTolerance,
const Standard_Real theAngularTolerance) const
Standard_Real radius;
};
-// =======================================================================
-// function : Scale
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Circ::Scale(const gp_Pnt& theP, const Standard_Real theS)
{
radius *= theS;
pos.Scale(theP, theS);
}
-// =======================================================================
-// function : Scaled
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Circ gp_Circ::Scaled(const gp_Pnt& theP, const Standard_Real theS) const
{
gp_Circ aC = *this;
return aC;
}
-// =======================================================================
-// function : Transform
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Circ::Transform(const gp_Trsf& theT)
{
radius *= theT.ScaleFactor();
pos.Transform(theT);
}
-// =======================================================================
-// function : Transformed
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Circ gp_Circ::Transformed(const gp_Trsf& theT) const
{
gp_Circ aC = *this;
Standard_Real radius;
};
-// =======================================================================
-// function : Coefficients
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Circ2d::Coefficients(Standard_Real& theA,
Standard_Real& theB,
Standard_Real& theC,
theF = aXc * aXc + anYc * anYc - radius * radius;
}
-// =======================================================================
-// function : Distance
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Circ2d::Distance(const gp_Pnt2d& theP) const
{
gp_XY aCoord = theP.XY();
return aD;
}
-// =======================================================================
-// function : Reversed
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Circ2d gp_Circ2d::Reversed() const
{
gp_Circ2d aCirc = *this;
return aCirc;
}
-// =======================================================================
-// function : SquareDistance
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Circ2d::SquareDistance(const gp_Pnt2d& theP) const
{
gp_XY aCoord = theP.XY();
return aD * aD;
}
-// =======================================================================
-// function : Scale
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Circ2d::Scale(const gp_Pnt2d& theP, const Standard_Real theS)
{
radius *= theS;
pos.Scale(theP, theS);
}
-// =======================================================================
-// function : Scaled
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Circ2d gp_Circ2d::Scaled(const gp_Pnt2d& theP, const Standard_Real theS) const
{
gp_Circ2d aCirc = *this;
return aCirc;
}
-// =======================================================================
-// function : Transform
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Circ2d::Transform(const gp_Trsf2d& theT)
{
radius *= theT.ScaleFactor();
pos.Transform(theT);
}
-// =======================================================================
-// function : Transformed
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Circ2d gp_Circ2d::Transformed(const gp_Trsf2d& theT) const
{
gp_Circ2d aCirc = *this;
Standard_Real semiAngle;
};
-// =======================================================================
-// function : gp_Cone
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Cone::gp_Cone(const gp_Ax3& theA3,
const Standard_Real theAng,
const Standard_Real theRadius)
"gp_Cone() - invalid construction parameters");
}
-// =======================================================================
-// function : SetSemiAngle
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Cone::SetSemiAngle(const Standard_Real theAng)
{
Standard_Real aVal = theAng;
semiAngle = theAng;
}
-// =======================================================================
-// function : Scale
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Cone::Scale(const gp_Pnt& theP, const Standard_Real theS)
{
pos.Scale(theP, theS);
}
}
-// =======================================================================
-// function : Scaled
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Cone gp_Cone::Scaled(const gp_Pnt& theP, const Standard_Real theS) const
{
gp_Cone aC = *this;
return aC;
}
-// =======================================================================
-// function : Transform
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Cone::Transform(const gp_Trsf& theT)
{
pos.Transform(theT);
}
}
-// =======================================================================
-// function : Transformed
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Cone gp_Cone::Transformed(const gp_Trsf& theT) const
{
gp_Cone aC = *this;
Standard_Real radius;
};
-// =======================================================================
-// function : Scale
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Cylinder::Scale(const gp_Pnt& theP, const Standard_Real theS)
{
pos.Scale(theP, theS);
}
}
-// =======================================================================
-// function : Scaled
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Cylinder gp_Cylinder::Scaled(const gp_Pnt& theP, const Standard_Real theS) const
{
gp_Cylinder aCyl = *this;
return aCyl;
}
-// =======================================================================
-// function : Transform
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Cylinder::Transform(const gp_Trsf& theT)
{
pos.Transform(theT);
}
}
-// =======================================================================
-// function : Transformed
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Cylinder gp_Cylinder::Transformed(const gp_Trsf& theT) const
{
gp_Cylinder aCyl = *this;
#include <gp_Trsf.hxx>
-// =======================================================================
-// function : gp_Dir
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Dir::gp_Dir(const gp_Vec& theV)
{
const gp_XYZ& aXYZ = theV.XYZ();
coord.SetZ(aZ / aD);
}
-// =======================================================================
-// function : gp_Dir
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Dir::gp_Dir(const gp_XYZ& theXYZ)
{
Standard_Real aX = theXYZ.X();
coord.SetZ(aZ / aD);
}
-// =======================================================================
-// function : gp_Dir
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Dir::gp_Dir(const Standard_Real theXv,
const Standard_Real theYv,
const Standard_Real theZv)
coord.SetZ(theZv / aD);
}
-// =======================================================================
-// function : SetCoord
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir::SetCoord(const Standard_Integer theIndex, const Standard_Real theXi)
{
Standard_Real aX = coord.X();
coord.SetZ(aZ / aD);
}
-// =======================================================================
-// function : SetCoord
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir::SetCoord(const Standard_Real theXv,
const Standard_Real theYv,
const Standard_Real theZv)
coord.SetZ(theZv / aD);
}
-// =======================================================================
-// function : SetX
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir::SetX(const Standard_Real theX)
{
Standard_Real anY = coord.Y();
coord.SetZ(aZ / aD);
}
-// =======================================================================
-// function : SetY
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir::SetY(const Standard_Real theY)
{
Standard_Real aZ = coord.Z();
coord.SetZ(aZ / aD);
}
-// =======================================================================
-// function : SetZ
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir::SetZ(const Standard_Real theZ)
{
Standard_Real aX = coord.X();
coord.SetZ(theZ / aD);
}
-// =======================================================================
-// function : SetXYZ
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir::SetXYZ(const gp_XYZ& theXYZ)
{
Standard_Real aX = theXYZ.X();
coord.SetZ(aZ / aD);
}
-// =======================================================================
-// function : Cross
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir::Cross(const gp_Dir& theRight)
{
coord.Cross(theRight.coord);
coord.Divide(aD);
}
-// =======================================================================
-// function : Crossed
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Dir gp_Dir::Crossed(const gp_Dir& theRight) const
{
gp_Dir aV = *this;
return aV;
}
-// =======================================================================
-// function : CrossCross
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir::CrossCross(const gp_Dir& theV1, const gp_Dir& theV2)
{
coord.CrossCross(theV1.coord, theV2.coord);
coord.Divide(aD);
}
-// =======================================================================
-// function : CrossCrossed
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Dir gp_Dir::CrossCrossed(const gp_Dir& theV1, const gp_Dir& theV2) const
{
gp_Dir aV = *this;
return aV;
}
-// =======================================================================
-// function : Rotate
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir::Rotate(const gp_Ax1& theA1, const Standard_Real theAng)
{
gp_Trsf aT;
#include <gp_Ax2d.hxx>
#include <gp_Trsf2d.hxx>
-// =======================================================================
-// function : gp_Dir2d
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Dir2d::gp_Dir2d(const gp_Vec2d& theV)
{
const gp_XY& aXY = theV.XY();
coord.SetY(anY / aD);
}
-// =======================================================================
-// function : gp_Dir2d
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Dir2d::gp_Dir2d(const gp_XY& theXY)
{
Standard_Real aX = theXY.X();
coord.SetY(anY / aD);
}
-// =======================================================================
-// function : gp_Dir2d
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Dir2d::gp_Dir2d(const Standard_Real theXv, const Standard_Real theYv)
{
Standard_Real aD = sqrt(theXv * theXv + theYv * theYv);
coord.SetY(theYv / aD);
}
-// =======================================================================
-// function : SetCoord
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir2d::SetCoord(const Standard_Integer theIndex, const Standard_Real theXi)
{
Standard_Real aX = coord.X();
coord.SetY(anY / aD);
}
-// =======================================================================
-// function : SetCoord
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir2d::SetCoord(const Standard_Real theXv, const Standard_Real theYv)
{
Standard_Real aD = sqrt(theXv * theXv + theYv * theYv);
coord.SetY(theYv / aD);
}
-// =======================================================================
-// function : SetX
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir2d::SetX(const Standard_Real theX)
{
Standard_Real anY = coord.Y();
coord.SetY(anY / aD);
}
-// =======================================================================
-// function : SetY
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir2d::SetY(const Standard_Real theY)
{
Standard_Real aX = coord.X();
coord.SetY(theY / aD);
}
-// =======================================================================
-// function : SetXY
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir2d::SetXY(const gp_XY& theXY)
{
Standard_Real aX = theXY.X();
coord.SetY(anY / aD);
}
-// =======================================================================
-// function : IsEqual
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Boolean gp_Dir2d::IsEqual(const gp_Dir2d& theOther,
const Standard_Real theAngularTolerance) const
{
return anAng <= theAngularTolerance;
}
-// =======================================================================
-// function : IsNormal
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Boolean gp_Dir2d::IsNormal(const gp_Dir2d& theOther,
const Standard_Real theAngularTolerance) const
{
return anAng <= theAngularTolerance;
}
-// =======================================================================
-// function : IsOpposite
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Boolean gp_Dir2d::IsOpposite(const gp_Dir2d& theOther,
const Standard_Real theAngularTolerance) const
{
return M_PI - anAng <= theAngularTolerance;
}
-// =======================================================================
-// function : IsParallel
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Boolean gp_Dir2d::IsParallel(const gp_Dir2d& theOther,
const Standard_Real theAngularTolerance) const
{
return anAng <= theAngularTolerance || M_PI - anAng <= theAngularTolerance;
}
-// =======================================================================
-// function : Rotate
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Dir2d::Rotate(const Standard_Real theAng)
{
gp_Trsf2d aT;
Standard_Real minorRadius;
};
-// =======================================================================
-// function : Directrix1
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Ax1 gp_Elips::Directrix1() const
{
Standard_Real anE = Eccentricity();
return gp_Ax1(gp_Pnt(anOrig), pos.YDirection());
}
-// =======================================================================
-// function : Directrix2
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Ax1 gp_Elips::Directrix2() const
{
Standard_Real anE = Eccentricity();
return gp_Ax1(gp_Pnt(anOrig), pos.YDirection());
}
-// =======================================================================
-// function : Eccentricity
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Elips::Eccentricity() const
{
if (majorRadius == 0.0)
}
}
-// =======================================================================
-// function : Focus1
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Pnt gp_Elips::Focus1() const
{
Standard_Real aC = sqrt(majorRadius * majorRadius - minorRadius * minorRadius);
return gp_Pnt(aPP.X() + aC * aDD.X(), aPP.Y() + aC * aDD.Y(), aPP.Z() + aC * aDD.Z());
}
-// =======================================================================
-// function : Focus2
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Pnt gp_Elips::Focus2() const
{
Standard_Real aC = sqrt(majorRadius * majorRadius - minorRadius * minorRadius);
return gp_Pnt(aPP.X() - aC * aDD.X(), aPP.Y() - aC * aDD.Y(), aPP.Z() - aC * aDD.Z());
}
-// =======================================================================
-// function : Parameter
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Elips::Parameter() const
{
if (majorRadius == 0.0)
}
}
-// =======================================================================
-// function : Scale
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Elips::Scale(const gp_Pnt& theP, const Standard_Real theS)
// Modified by skv - Fri Apr 8 10:28:10 2005 OCC8559 Begin
// { pos.Scale(P, S); }
// Modified by skv - Fri Apr 8 10:28:10 2005 OCC8559 End
-// =======================================================================
-// function : Scaled
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Elips gp_Elips::Scaled(const gp_Pnt& theP, const Standard_Real theS) const
{
gp_Elips anE = *this;
return anE;
}
-// =======================================================================
-// function : Transform
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Elips::Transform(const gp_Trsf& theT)
{
majorRadius *= theT.ScaleFactor();
pos.Transform(theT);
}
-// =======================================================================
-// function : Transformed
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Elips gp_Elips::Transformed(const gp_Trsf& theT) const
{
gp_Elips anE = *this;
Standard_Real minorRadius;
};
-// =======================================================================
-// function : Directrix1
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Ax2d gp_Elips2d::Directrix1() const
{
Standard_Real anE = Eccentricity();
return gp_Ax2d(gp_Pnt2d(anOrig), gp_Dir2d(pos.YDirection()));
}
-// =======================================================================
-// function : Directrix2
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Ax2d gp_Elips2d::Directrix2() const
{
Standard_Real anE = Eccentricity();
return gp_Ax2d(gp_Pnt2d(anOrig), gp_Dir2d(pos.YDirection()));
}
-// =======================================================================
-// function : Eccentricity
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Elips2d::Eccentricity() const
{
if (majorRadius == 0.0)
}
}
-// =======================================================================
-// function : Focus1
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Pnt2d gp_Elips2d::Focus1() const
{
Standard_Real aC = sqrt(majorRadius * majorRadius - minorRadius * minorRadius);
return gp_Pnt2d(aPP.X() + aC * aDD.X(), aPP.Y() + aC * aDD.Y());
}
-// =======================================================================
-// function : Focus2
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Pnt2d gp_Elips2d::Focus2() const
{
Standard_Real aC = sqrt(majorRadius * majorRadius - minorRadius * minorRadius);
return gp_Pnt2d(aPP.X() - aC * aDD.X(), aPP.Y() - aC * aDD.Y());
}
-// =======================================================================
-// function : Scale
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Elips2d::Scale(const gp_Pnt2d& theP, const Standard_Real theS)
{
majorRadius *= theS;
pos.Scale(theP, theS);
}
-// =======================================================================
-// function : Scaled
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Elips2d gp_Elips2d::Scaled(const gp_Pnt2d& theP, const Standard_Real theS) const
{
gp_Elips2d anE = *this;
return anE;
}
-// =======================================================================
-// function : Parameter
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Elips2d::Parameter() const
{
if (majorRadius == 0.0)
}
}
-// =======================================================================
-// function : Reversed
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Elips2d gp_Elips2d::Reversed() const
{
gp_Elips2d anE = *this;
return anE;
}
-// =======================================================================
-// function : Transform
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline void gp_Elips2d::Transform(const gp_Trsf2d& theT)
{
Standard_Real aTSca = theT.ScaleFactor();
pos.Transform(theT);
}
-// =======================================================================
-// function : Transformed
-// purpose :
-// =======================================================================
+//=================================================================================================
+
inline gp_Elips2d gp_Elips2d::Transformed(const gp_Trsf2d& theT) const
{
gp_Elips2d anE = *this;
Standard_Real scale;
};
-//=======================================================================
-// function : SetAffinity
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_GTrsf::SetAffinity(const gp_Ax1& theA1, const Standard_Real theRatio)
{
shape = gp_Other;
loc.Add(theA1.Location().XYZ());
}
-//=======================================================================
-// function : SetAffinity
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_GTrsf::SetAffinity(const gp_Ax2& theA2, const Standard_Real theRatio)
{
shape = gp_Other;
matrix.SetDiagonal(matrix.Value(1, 1) + 1., matrix.Value(2, 2) + 1., matrix.Value(3, 3) + 1.);
}
-//=======================================================================
-// function : SetValue
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_GTrsf::SetValue(const Standard_Integer theRow,
const Standard_Integer theCol,
const Standard_Real theValue)
}
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_GTrsf::Value(const Standard_Integer theRow,
const Standard_Integer theCol) const
{
return scale * matrix.Value(theRow, theCol);
}
-//=======================================================================
-// function : Transforms
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_GTrsf::Transforms(gp_XYZ& theCoord) const
{
theCoord.Multiply(matrix);
theCoord.Add(loc);
}
-//=======================================================================
-// function : Transforms
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_GTrsf::Transforms(Standard_Real& theX,
Standard_Real& theY,
Standard_Real& theZ) const
aTriplet.Coord(theX, theY, theZ);
}
-//=======================================================================
-// function : Trsf
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Trsf gp_GTrsf::Trsf() const
{
if (Form() == gp_Other)
#include <gp_Trsf2d.hxx>
-//=======================================================================
-// function : SetTrsf2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_GTrsf2d::SetTrsf2d(const gp_Trsf2d& theT)
{
shape = theT.shape;
scale = theT.scale;
}
-//=======================================================================
-// function : gp_GTrsf2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_GTrsf2d::gp_GTrsf2d(const gp_Trsf2d& theT)
{
shape = theT.shape;
scale = theT.scale;
}
-//=======================================================================
-// function : SetValue
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_GTrsf2d::SetValue(const Standard_Integer theRow,
const Standard_Integer theCol,
const Standard_Real theValue)
shape = gp_Other;
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_GTrsf2d::Value(const Standard_Integer theRow,
const Standard_Integer theCol) const
{
return scale * matrix.Value(theRow, theCol);
}
-//=======================================================================
-// function : Transforms
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_GTrsf2d::Transforms(gp_XY& theCoord) const
{
theCoord.Multiply(matrix);
theCoord.Add(loc);
}
-//=======================================================================
-// function : Transforms
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_GTrsf2d::Transforms(Standard_Real& theX, Standard_Real& theY) const
{
gp_XY aDoublet(theX, theY);
Standard_Real minorRadius;
};
-//=======================================================================
-// function : Asymptote1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Ax1 gp_Hypr::Asymptote1() const
{
Standard_ConstructionError_Raise_if(majorRadius <= gp::Resolution(),
return gp_Ax1(pos.Location(), gp_Dir(aV));
}
-//=======================================================================
-// function : Asymptote2
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Ax1 gp_Hypr::Asymptote2() const
{
Standard_ConstructionError_Raise_if(majorRadius <= gp::Resolution(),
return gp_Ax1(pos.Location(), gp_Dir(aV));
}
-//=======================================================================
-// function : Focus1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Pnt gp_Hypr::Focus1() const
{
Standard_Real aC = sqrt(majorRadius * majorRadius + minorRadius * minorRadius);
return gp_Pnt(aPP.X() + aC * aDD.X(), aPP.Y() + aC * aDD.Y(), aPP.Z() + aC * aDD.Z());
}
-//=======================================================================
-// function : Focus2
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Pnt gp_Hypr::Focus2() const
{
Standard_Real aC = sqrt(majorRadius * majorRadius + minorRadius * minorRadius);
return gp_Pnt(aPP.X() - aC * aDD.X(), aPP.Y() - aC * aDD.Y(), aPP.Z() - aC * aDD.Z());
}
-//=======================================================================
-// function : Scale
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Hypr::Scale(const gp_Pnt& theP, const Standard_Real theS)
{
majorRadius *= theS;
pos.Scale(theP, theS);
}
-//=======================================================================
-// function : Scaled
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Hypr gp_Hypr::Scaled(const gp_Pnt& theP, const Standard_Real theS) const
{
gp_Hypr aH = *this;
return aH;
}
-//=======================================================================
-// function : Transform
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Hypr::Transform(const gp_Trsf& theT)
{
majorRadius *= theT.ScaleFactor();
pos.Transform(theT);
}
-//=======================================================================
-// function : Transformed
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Hypr gp_Hypr::Transformed(const gp_Trsf& theT) const
{
gp_Hypr aH = *this;
return aH;
}
-//=======================================================================
-// function : Directrix1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Ax1 gp_Hypr::Directrix1() const
{
Standard_Real anE = Eccentricity();
return gp_Ax1(gp_Pnt(anOrig), pos.YDirection());
}
-//=======================================================================
-// function : Directrix2
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Ax1 gp_Hypr::Directrix2() const
{
Standard_Real anE = Eccentricity();
Standard_Real minorRadius;
};
-//=======================================================================
-// function : Asymptote1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Ax2d gp_Hypr2d::Asymptote1() const
{
Standard_ConstructionError_Raise_if(majorRadius <= gp::Resolution(),
return gp_Ax2d(pos.Location(), aVdir);
}
-//=======================================================================
-// function : Asymptote2
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Ax2d gp_Hypr2d::Asymptote2() const
{
Standard_ConstructionError_Raise_if(majorRadius <= gp::Resolution(),
return gp_Ax2d(pos.Location(), aVdir);
}
-//=======================================================================
-// function : Directrix1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Ax2d gp_Hypr2d::Directrix1() const
{
Standard_Real anE = Eccentricity();
return gp_Ax2d(gp_Pnt2d(anOrig), gp_Dir2d(pos.YDirection()));
}
-//=======================================================================
-// function : Directrix2
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Ax2d gp_Hypr2d::Directrix2() const
{
Standard_Real anE = Eccentricity();
return gp_Ax2d(gp_Pnt2d(anOrig), gp_Dir2d(pos.YDirection()));
}
-//=======================================================================
-// function : Reversed
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Hypr2d gp_Hypr2d::Reversed() const
{
gp_Hypr2d aH = *this;
return aH;
}
-//=======================================================================
-// function : Scale
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Hypr2d::Scale(const gp_Pnt2d& theP, const Standard_Real theS)
{
majorRadius *= theS;
pos.Scale(theP, theS);
}
-//=======================================================================
-// function : Scaled
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Hypr2d gp_Hypr2d::Scaled(const gp_Pnt2d& theP, const Standard_Real theS) const
{
gp_Hypr2d aH = *this;
return aH;
}
-//=======================================================================
-// function : Transform
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Hypr2d::Transform(const gp_Trsf2d& theT)
{
majorRadius *= theT.ScaleFactor();
pos.Transform(theT);
}
-//=======================================================================
-// function : Transformed
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Hypr2d gp_Hypr2d::Transformed(const gp_Trsf2d& theT) const
{
gp_Hypr2d aH = *this;
gp_Ax1 pos;
};
-//=======================================================================
-// function : Distance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Lin::Distance(const gp_Pnt& theP) const
{
gp_XYZ aCoord = theP.XYZ();
return aCoord.Modulus();
}
-//=======================================================================
-// function : SquareDistance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Lin::SquareDistance(const gp_Pnt& theP) const
{
const gp_Pnt& aLoc = pos.Location();
return aV.SquareMagnitude();
}
-//=======================================================================
-// function : Normal
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Lin gp_Lin::Normal(const gp_Pnt& theP) const
{
const gp_Pnt& aLoc = pos.Location();
gp_Ax2d pos;
};
-//=======================================================================
-// function : Distance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Lin2d::Distance(const gp_Pnt2d& theP) const
{
gp_XY aCoord = theP.XY();
return aVal;
}
-//=======================================================================
-// function : Distance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Lin2d::Distance(const gp_Lin2d& theOther) const
{
Standard_Real aD = 0.0;
return aD;
}
-//=======================================================================
-// function : SquareDistance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Lin2d::SquareDistance(const gp_Pnt2d& theP) const
{
gp_XY aCoord = theP.XY();
return aD * aD;
}
-//=======================================================================
-// function : SquareDistance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Lin2d::SquareDistance(const gp_Lin2d& theOther) const
{
Standard_Real aD = 0.0;
Standard_Real myMat[3][3];
};
-//=======================================================================
-// function : gp_Mat
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Mat::gp_Mat(const Standard_Real theA11,
const Standard_Real theA12,
const Standard_Real theA13,
myMat[2][2] = theA33;
}
-//=======================================================================
-// function : Add
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat::Add(const gp_Mat& theOther)
{
myMat[0][0] += theOther.myMat[0][0];
myMat[2][2] += theOther.myMat[2][2];
}
-//=======================================================================
-// function : Added
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Mat gp_Mat::Added(const gp_Mat& theOther) const
{
gp_Mat aNewMat(*this);
return aNewMat;
}
-//=======================================================================
-// function : Divide
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat::Divide(const Standard_Real theScalar)
{
Standard_Real aVal = theScalar;
myMat[2][2] *= anUnSurScalar;
}
-//=======================================================================
-// function : Divided
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Mat gp_Mat::Divided(const Standard_Real theScalar) const
{
gp_Mat aNewMat(*this);
return aNewMat;
}
-//=======================================================================
-// function : Multiply
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat::Multiply(const gp_Mat& theOther)
{
const Standard_Real aT00 = myMat[0][0] * theOther.myMat[0][0] + myMat[0][1] * theOther.myMat[1][0]
myMat[2][2] = aT22;
}
-//=======================================================================
-// function : PreMultiply
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat::PreMultiply(const gp_Mat& theOther)
{
const Standard_Real aT00 = theOther.myMat[0][0] * myMat[0][0] + theOther.myMat[0][1] * myMat[1][0]
myMat[2][2] = aT22;
}
-//=======================================================================
-// function : Multiplied
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Mat gp_Mat::Multiplied(const Standard_Real theScalar) const
{
gp_Mat aNewMat(*this);
return aNewMat;
}
-//=======================================================================
-// function : Multiply
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat::Multiply(const Standard_Real theScalar)
{
myMat[0][0] *= theScalar;
myMat[2][2] *= theScalar;
}
-//=======================================================================
-// function : Subtract
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat::Subtract(const gp_Mat& theOther)
{
myMat[0][0] -= theOther.myMat[0][0];
myMat[2][2] -= theOther.myMat[2][2];
}
-//=======================================================================
-// function : Subtracted
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Mat gp_Mat::Subtracted(const gp_Mat& theOther) const
{
gp_Mat aNewMat(*this);
return aNewMat;
}
-//=======================================================================
-// function : Transpose
-// purpose :
-//=======================================================================
+//=================================================================================================
+
// On macOS 10.13.6 with XCode 9.4.1 the compiler has a bug leading to
// generation of invalid code when method gp_Mat::Transpose() is called
// for a matrix which is when applied to vector; it looks like vector
Standard_Real myMat[2][2];
};
-//=======================================================================
-// function : SetRotation
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat2d::SetRotation(const Standard_Real theAng)
{
Standard_Real aSinA = sin(theAng);
myMat[1][0] = aSinA;
}
-//=======================================================================
-// function : Add
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat2d::Add(const gp_Mat2d& theOther)
{
myMat[0][0] += theOther.myMat[0][0];
myMat[1][1] += theOther.myMat[1][1];
}
-//=======================================================================
-// function : Added
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Mat2d gp_Mat2d::Added(const gp_Mat2d& theOther) const
{
gp_Mat2d aNewMat2d;
return aNewMat2d;
}
-//=======================================================================
-// function : Divide
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat2d::Divide(const Standard_Real theScalar)
{
myMat[0][0] /= theScalar;
myMat[1][1] /= theScalar;
}
-//=======================================================================
-// function : Divided
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Mat2d gp_Mat2d::Divided(const Standard_Real theScalar) const
{
gp_Mat2d aNewMat2d;
return aNewMat2d;
}
-//=======================================================================
-// function : Multiply
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat2d::Multiply(const gp_Mat2d& theOther)
{
const Standard_Real aT00 =
myMat[1][0] = aT10;
}
-//=======================================================================
-// function : PreMultiply
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat2d::PreMultiply(const gp_Mat2d& theOther)
{
const Standard_Real aT00 =
myMat[0][1] = aT01;
}
-//=======================================================================
-// function : Multiplied
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Mat2d gp_Mat2d::Multiplied(const Standard_Real theScalar) const
{
gp_Mat2d aNewMat2d;
return aNewMat2d;
}
-//=======================================================================
-// function : Multiply
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat2d::Multiply(const Standard_Real theScalar)
{
myMat[0][0] *= theScalar;
myMat[1][1] *= theScalar;
}
-//=======================================================================
-// function : Subtract
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat2d::Subtract(const gp_Mat2d& theOther)
{
myMat[0][0] -= theOther.myMat[0][0];
myMat[1][1] -= theOther.myMat[1][1];
}
-//=======================================================================
-// function : Subtracted
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Mat2d gp_Mat2d::Subtracted(const gp_Mat2d& theOther) const
{
gp_Mat2d aNewMat2d;
return aNewMat2d;
}
-//=======================================================================
-// function : Transpose
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Mat2d::Transpose()
{
const Standard_Real aTemp = myMat[0][1];
myMat[1][0] = aTemp;
}
-//=======================================================================
-// function : Transposed
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Mat2d gp_Mat2d::Transposed() const
{
gp_Mat2d aNewMat2d;
Standard_Real focalLength;
};
-//=======================================================================
-// function : gp_Parab
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Parab::gp_Parab(const gp_Ax1& theD, const gp_Pnt& theF)
{
gp_Lin aDroite(theD);
anAx.Direction());
}
-//=======================================================================
-// function : Directrix
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Ax1 gp_Parab::Directrix() const
{
const gp_Pnt& aPP = pos.Location();
return gp_Ax1(aP, pos.YDirection());
}
-//=======================================================================
-// function : Focus
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Pnt gp_Parab::Focus() const
{
const gp_Pnt& aPP = pos.Location();
aPP.Z() + focalLength * aDD.Z());
}
-//=======================================================================
-// function : Scale
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Parab::Scale(const gp_Pnt& theP, const Standard_Real theS)
{
focalLength *= theS;
pos.Scale(theP, theS);
}
-//=======================================================================
-// function : Scaled
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Parab gp_Parab::Scaled(const gp_Pnt& theP, const Standard_Real theS) const
{
gp_Parab aPrb = *this;
return aPrb;
}
-//=======================================================================
-// function : Transform
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Parab::Transform(const gp_Trsf& theT)
{
focalLength *= theT.ScaleFactor();
pos.Transform(theT);
}
-//=======================================================================
-// function : Transformed
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Parab gp_Parab::Transformed(const gp_Trsf& theT) const
{
gp_Parab aPrb = *this;
Standard_Real focalLength;
};
-//=======================================================================
-// function : Directrix
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Ax2d gp_Parab2d::Directrix() const
{
gp_Pnt2d aP(pos.Location().X() - focalLength * pos.XDirection().X(),
return gp_Ax2d(aP, aV);
}
-//=======================================================================
-// function : Reversed
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Parab2d gp_Parab2d::Reversed() const
{
gp_Parab2d aP = *this;
return aP;
}
-//=======================================================================
-// function : Scale
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Parab2d::Scale(const gp_Pnt2d& theP, const Standard_Real theS)
{
focalLength *= theS;
pos.Scale(theP, theS);
}
-//=======================================================================
-// function : Scaled
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Parab2d gp_Parab2d::Scaled(const gp_Pnt2d& theP, const Standard_Real theS) const
{
gp_Parab2d aPrb = *this;
return aPrb;
}
-//=======================================================================
-// function : Transform
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Parab2d::Transform(const gp_Trsf2d& theT)
{
focalLength *= theT.ScaleFactor();
pos.Transform(theT);
}
-//=======================================================================
-// function : Transformed
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Parab2d gp_Parab2d::Transformed(const gp_Trsf2d& theT) const
{
gp_Parab2d aPrb = *this;
#include <gp_Lin.hxx>
-//=======================================================================
-// function : Coefficients
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Pln::Coefficients(Standard_Real& theA,
Standard_Real& theB,
Standard_Real& theC,
theD = -(theA * aP.X() + theB * aP.Y() + theC * aP.Z());
}
-//=======================================================================
-// function : Distance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Pln::Distance(const gp_Pnt& theP) const
{
const gp_Pnt& aLoc = pos.Location();
return aD;
}
-//=======================================================================
-// function : Distance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Pln::Distance(const gp_Lin& theL) const
{
Standard_Real aD = 0.0;
return aD;
}
-//=======================================================================
-// function : Distance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Pln::Distance(const gp_Pln& theOther) const
{
Standard_Real aD = 0.0;
#include <gp_Vec.hxx>
#include <gp_XYZ.hxx>
-//=======================================================================
-// function : Distance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Pnt::Distance(const gp_Pnt& theOther) const
{
return sqrt(SquareDistance(theOther));
}
-//=======================================================================
-// function : SquareDistance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Pnt::SquareDistance(const gp_Pnt& theOther) const
{
const gp_XYZ& aXYZ = theOther.coord;
return aDx * aDx + aDy * aDy + aDz * aDz;
}
-//=======================================================================
-// function : Rotate
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Pnt::Rotate(const gp_Ax1& theA1, const Standard_Real theAng)
{
gp_Trsf aT;
aT.Transforms(coord);
}
-//=======================================================================
-// function : Scale
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Pnt::Scale(const gp_Pnt& theP, const Standard_Real theS)
{
gp_XYZ aXYZ = theP.coord;
coord.Add(aXYZ);
}
-//=======================================================================
-// function : Translate
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Pnt::Translate(const gp_Vec& theV)
{
coord.Add(theV.XYZ());
}
-//=======================================================================
-// function : Translated
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Pnt gp_Pnt::Translated(const gp_Vec& theV) const
{
gp_Pnt aP = *this;
#include <gp_Vec2d.hxx>
#include <gp_Trsf2d.hxx>
-//=======================================================================
-// function : Distance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Pnt2d::Distance(const gp_Pnt2d& theOther) const
{
const gp_XY& aXY = theOther.coord;
return sqrt(aX * aX + aY * aY);
}
-//=======================================================================
-// function : SquareDistance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Pnt2d::SquareDistance(const gp_Pnt2d& theOther) const
{
const gp_XY& aXY = theOther.coord;
return (aX * aX + aY * aY);
}
-//=======================================================================
-// function : Rotate
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Pnt2d::Rotate(const gp_Pnt2d& theP, const Standard_Real theAng)
{
gp_Trsf2d aT;
aT.Transforms(coord);
}
-//=======================================================================
-// function : Scale
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Pnt2d::Scale(const gp_Pnt2d& theP, const Standard_Real theS)
{
gp_XY aXY = theP.coord;
coord.Add(aXY);
}
-//=======================================================================
-// function : Translate
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Pnt2d::Translate(const gp_Vec2d& theV)
{
coord.Add(theV.XY());
}
-//=======================================================================
-// function : Translated
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Pnt2d gp_Pnt2d::Translated(const gp_Vec2d& theV) const
{
gp_Pnt2d aP = *this;
Standard_Real w;
};
-//=======================================================================
-// function : Set
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Quaternion::Set(Standard_Real theX,
Standard_Real theY,
Standard_Real theZ,
this->w = theW;
}
-//=======================================================================
-// function : Set
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Quaternion::Set(const gp_Quaternion& theQuaternion)
{
x = theQuaternion.x;
w = theQuaternion.w;
}
-//=======================================================================
-// function : Scale
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Quaternion::Scale(const Standard_Real theScale)
{
x *= theScale;
w *= theScale;
}
-//=======================================================================
-// function : Multiplied
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Quaternion gp_Quaternion::Multiplied(const gp_Quaternion& theQ) const
{
return gp_Quaternion(w * theQ.x + x * theQ.w + y * theQ.z - z * theQ.y,
// 16 multiplications 12 addidtions 0 variables
}
-//=======================================================================
-// function : Add
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Quaternion::Add(const gp_Quaternion& theQ)
{
x += theQ.x;
w += theQ.w;
}
-//=======================================================================
-// function : Subtract
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Quaternion::Subtract(const gp_Quaternion& theQ)
{
x -= theQ.x;
Standard_Real radius;
};
-//=======================================================================
-// function : Scale
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Sphere::Scale(const gp_Pnt& theP, const Standard_Real theS)
{
pos.Scale(theP, theS);
}
}
-//=======================================================================
-// function : Scaled
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Sphere gp_Sphere::Scaled(const gp_Pnt& theP, const Standard_Real theS) const
{
gp_Sphere aC = *this;
return aC;
}
-//=======================================================================
-// function : Transform
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Sphere::Transform(const gp_Trsf& theT)
{
pos.Transform(theT);
}
}
-//=======================================================================
-// function : Transformed
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Sphere gp_Sphere::Transformed(const gp_Trsf& theT) const
{
gp_Sphere aC = *this;
Standard_Real minorRadius;
};
-//=======================================================================
-// function : Scale
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Torus::Scale(const gp_Pnt& theP, const Standard_Real theS)
{
pos.Scale(theP, theS);
minorRadius *= s;
}
-//=======================================================================
-// function : Scaled
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Torus gp_Torus::Scaled(const gp_Pnt& theP, const Standard_Real theS) const
{
gp_Torus aC = *this;
return aC;
}
-//=======================================================================
-// function : Transform
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Torus::Transform(const gp_Trsf& theT)
{
pos.Transform(theT);
majorRadius *= aT;
}
-//=======================================================================
-// function : Transformed
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Torus gp_Torus::Transformed(const gp_Trsf& theT) const
{
gp_Torus aC = *this;
#include <Standard_OutOfRange.hxx>
#include <Standard_Dump.hxx>
-//=======================================================================
-// function : gp_Trsf
-// purpose : Constructor from 2d
-//=======================================================================
+//=================================================================================================
+
gp_Trsf::gp_Trsf(const gp_Trsf2d& T)
: scale(T.ScaleFactor()),
shape(T.Form()),
#include <gp_Vec.hxx>
#include <gp_Pnt.hxx>
-//=======================================================================
-// function : gp_Trsf
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Trsf::gp_Trsf()
: scale(1.0),
shape(gp_Identity),
{
}
-//=======================================================================
-// function : SetMirror
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Trsf::SetMirror(const gp_Pnt& theP)
{
shape = gp_PntMirror;
loc.Multiply(2.0);
}
-//=======================================================================
-// function : SetTranslation
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Trsf::SetTranslation(const gp_Vec& theV)
{
shape = gp_Translation;
loc = theV.XYZ();
}
-//=======================================================================
-// function : SetTranslation
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Trsf::SetTranslation(const gp_Pnt& theP1, const gp_Pnt& theP2)
{
shape = gp_Translation;
loc = (theP2.XYZ()).Subtracted(theP1.XYZ());
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Trsf::Value(const Standard_Integer theRow,
const Standard_Integer theCol) const
{
}
}
-//=======================================================================
-// function : Transforms
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Trsf::Transforms(Standard_Real& theX, Standard_Real& theY, Standard_Real& theZ) const
{
gp_XYZ aTriplet(theX, theY, theZ);
theZ = aTriplet.Z();
}
-//=======================================================================
-// function : Transforms
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Trsf::Transforms(gp_XYZ& theCoord) const
{
theCoord.Multiply(matrix);
#include <gp_Trsf.hxx>
#include <gp_Pnt2d.hxx>
-//=======================================================================
-// function : gp_Trsf2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Trsf2d::gp_Trsf2d()
{
shape = gp_Identity;
loc.SetCoord(0.0, 0.0);
}
-//=======================================================================
-// function : gp_Trsf2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Trsf2d::gp_Trsf2d(const gp_Trsf& theT)
: scale(theT.ScaleFactor()),
shape(theT.Form()),
matrix(2, 2) = M(2, 2);
}
-//=======================================================================
-// function : SetRotation
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Trsf2d::SetRotation(const gp_Pnt2d& theP, const Standard_Real theAng)
{
shape = gp_Rotation;
loc.Add(theP.XY());
}
-//=======================================================================
-// function : SetMirror
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Trsf2d::SetMirror(const gp_Pnt2d& theP)
{
shape = gp_PntMirror;
loc.Multiply(2.0);
}
-//=======================================================================
-// function : SetScale
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Trsf2d::SetScale(const gp_Pnt2d& theP, const Standard_Real theS)
{
shape = gp_Scale;
loc.Multiply(1.0 - theS);
}
-//=======================================================================
-// function : SetTranslation
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Trsf2d::SetTranslation(const gp_Vec2d& theV)
{
shape = gp_Translation;
loc = theV.XY();
}
-//=======================================================================
-// function : SetTranslation
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Trsf2d::SetTranslation(const gp_Pnt2d& theP1, const gp_Pnt2d& theP2)
{
shape = gp_Translation;
loc = (theP2.XY()).Subtracted(theP1.XY());
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Trsf2d::Value(const Standard_Integer theRow,
const Standard_Integer theCol) const
{
}
}
-//=======================================================================
-// function : Transforms
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Trsf2d::Transforms(Standard_Real& theX, Standard_Real& theY) const
{
gp_XY aDoublet(theX, theY);
aDoublet.Coord(theX, theY);
}
-//=======================================================================
-// function : Transforms
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Trsf2d::Transforms(gp_XY& theCoord) const
{
theCoord.Multiply(matrix);
#include <gp_Pnt.hxx>
#include <gp_Trsf.hxx>
-//=======================================================================
-// function : gp_Vec
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Vec::gp_Vec(const gp_Dir& theV)
{
coord = theV.XYZ();
}
-//=======================================================================
-// function : gp_Vec
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Vec::gp_Vec(const gp_Pnt& theP1, const gp_Pnt& theP2)
{
coord = theP2.XYZ().Subtracted(theP1.XYZ());
}
-//=======================================================================
-// function : IsNormal
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean gp_Vec::IsNormal(const gp_Vec& theOther,
const Standard_Real theAngularTolerance) const
{
return anAng <= theAngularTolerance;
}
-//=======================================================================
-// function : Angle
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Vec::Angle(const gp_Vec& theOther) const
{
gp_VectorWithNullMagnitude_Raise_if(coord.Modulus() <= gp::Resolution()
return (gp_Dir(coord)).Angle(theOther);
}
-//=======================================================================
-// function : AngleWithRef
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_Vec::AngleWithRef(const gp_Vec& theOther, const gp_Vec& theVRef) const
{
gp_VectorWithNullMagnitude_Raise_if(coord.Modulus() <= gp::Resolution()
return (gp_Dir(coord)).AngleWithRef(theOther, theVRef);
}
-//=======================================================================
-// function : Normalized
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Vec gp_Vec::Normalized() const
{
const Standard_Real aD = coord.Modulus();
return aV;
}
-//=======================================================================
-// function : Rotate
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Vec::Rotate(const gp_Ax1& theA1, const Standard_Real theAng)
{
gp_Trsf aT;
#include <gp_Trsf2d.hxx>
#include <gp_Pnt2d.hxx>
-//=======================================================================
-// function : gp_Vec2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Vec2d::gp_Vec2d(const gp_Dir2d& theV)
{
coord = theV.XY();
}
-//=======================================================================
-// function : gp_Vec2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Vec2d::gp_Vec2d(const gp_Pnt2d& theP1, const gp_Pnt2d& theP2)
{
coord = theP2.XY().Subtracted(theP1.XY());
}
-//=======================================================================
-// function : IsOpposite
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean gp_Vec2d::IsOpposite(const gp_Vec2d& theOther,
const Standard_Real theAngularTolerance) const
{
return M_PI - anAng <= theAngularTolerance;
}
-//=======================================================================
-// function : IsParallel
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean gp_Vec2d::IsParallel(const gp_Vec2d& theOther,
const Standard_Real theAngularTolerance) const
{
return anAng <= theAngularTolerance || M_PI - anAng <= theAngularTolerance;
}
-//=======================================================================
-// function : Normalized
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Vec2d gp_Vec2d::Normalized() const
{
Standard_Real aD = coord.Modulus();
return aV;
}
-//=======================================================================
-// function : Rotate
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_Vec2d::Rotate(const Standard_Real theAng)
{
gp_Trsf2d aT;
Standard_Real y;
};
-//=======================================================================
-// function : Multiply
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_XY::Multiply(const gp_Mat2d& theMatrix)
{
const Standard_Real aXresult = theMatrix.myMat[0][0] * x + theMatrix.myMat[0][1] * y;
x = aXresult;
}
-//=======================================================================
-// function : Normalize
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_XY::Normalize()
{
Standard_Real aD = Modulus();
Standard_Real z;
};
-//=======================================================================
-// function : Cross
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_XYZ::Cross(const gp_XYZ& theRight)
{
const Standard_Real aXresult = y * theRight.z - z * theRight.y;
y = aYresult;
}
-//=======================================================================
-// function : CrossMagnitude
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_XYZ::CrossMagnitude(const gp_XYZ& theRight) const
{
return sqrt(CrossSquareMagnitude(theRight));
}
-//=======================================================================
-// function : CrossSquareMagnitude
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_XYZ::CrossSquareMagnitude(const gp_XYZ& theRight) const
{
const Standard_Real aXresult = y * theRight.z - z * theRight.y;
return aXresult * aXresult + aYresult * aYresult + aZresult * aZresult;
}
-//=======================================================================
-// function : CrossCross
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_XYZ::CrossCross(const gp_XYZ& theCoord1, const gp_XYZ& theCoord2)
{
// First compute theCoord1 * theCoord2
y = aYresult;
}
-//=======================================================================
-// function : DotCross
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real gp_XYZ::DotCross(const gp_XYZ& theCoord1, const gp_XYZ& theCoord2) const
{
const Standard_Real aXresult = theCoord1.y * theCoord2.z - theCoord1.z * theCoord2.y;
return (x * aXresult + y * anYresult + z * aZresult);
}
-//=======================================================================
-// function : Multiply
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_XYZ::Multiply(const gp_Mat& theMatrix)
{
// Cache original coordinates to avoid aliasing issues
+ theMatrix.myMat[2][2] * aOrigZ;
}
-//=======================================================================
-// function : Normalize
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void gp_XYZ::Normalize()
{
Standard_Real aD = Modulus();
return myErrorReached;
}
-//=======================================================================
-// function : AbsolutError
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real math_KronrodSingleIntegration::AbsolutError() const
{
#include <Message_Algorithm.hxx>
#include <TCollection_HExtendedString.hxx>
-//=======================================================================
-// function : SetStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Message_Algorithm::SetStatus(const Message_Status& theStat,
const Standard_CString theStr,
SetStatus(theStat, new TCollection_HExtendedString(theStr), noRepetitions);
}
-//=======================================================================
-// function : SetStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Message_Algorithm::SetStatus(const Message_Status& theStat,
const TCollection_AsciiString& theStr,
SetStatus(theStat, new TCollection_HExtendedString(theStr), noRepetitions);
}
-//=======================================================================
-// function : SetStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Message_Algorithm::SetStatus(const Message_Status& theStat,
const Handle(TCollection_HAsciiString)& theStr,
SetStatus(theStat, new TCollection_HExtendedString(theStr), noRepetitions);
}
-//=======================================================================
-// function : SetStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Message_Algorithm::SetStatus(const Message_Status& theStat,
const TCollection_ExtendedString& theStr,
SetStatus(theStat, new TCollection_HExtendedString(theStr), noRepetitions);
}
-//=======================================================================
-// function : GetStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Message_ExecStatus& Message_Algorithm::GetStatus() const
{
return myStatus;
}
-//=======================================================================
-// function : ChangeStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Message_ExecStatus& Message_Algorithm::ChangeStatus()
{
return myStatus;
}
-//=======================================================================
-// function : GetMessenger
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Message_Messenger) Message_Algorithm::GetMessenger() const
{
return Arg(theString->String());
}
-//=======================================================================
-// function : Original
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TCollection_ExtendedString& Message_Msg::Original() const
{
return myOriginal;
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TCollection_ExtendedString& Message_Msg::Value() const
{
return myMessageBody;
}
-//=======================================================================
-// function : IsEdited
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Message_Msg::IsEdited() const
{
#include <Message_ProgressScope.hxx>
-//=======================================================================
-// function : Increment
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void Message_ProgressIndicator::Increment(const Standard_Real theStep,
const Message_ProgressScope& theScope)
{
#include <Message_ProgressIndicator.hxx>
-//=======================================================================
-// function : IsActive
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean Message_ProgressRange::IsActive() const
{
return !myWasUsed && myParentScope && myParentScope->myProgress;
}
-//=======================================================================
-// function : UserBreak
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean Message_ProgressRange::UserBreak() const
{
return myParentScope && myParentScope->myProgress && myParentScope->myProgress->UserBreak();
}
-//=======================================================================
-// function : Close
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void Message_ProgressRange::Close()
{
if (!IsActive())
#include <Message_ProgressRange.hxx>
-//=======================================================================
-// function : Message_ProgressScope
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Message_ProgressScope::Message_ProgressScope(Message_ProgressIndicator* theProgress)
: myProgress(theProgress),
myParent(0),
{
}
-//=======================================================================
-// function : Message_ProgressScope
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Message_ProgressScope::Message_ProgressScope(const Message_ProgressRange& theRange,
const TCollection_AsciiString& theName,
Standard_Real theMax,
theRange.myWasUsed = true; // Disarm the range
}
-//=======================================================================
-// function : Message_ProgressScope
-// purpose :
-//=======================================================================
+//=================================================================================================
+
template <size_t N>
Message_ProgressScope::Message_ProgressScope(const Message_ProgressRange& theRange,
const char (&theName)[N],
theRange.myWasUsed = true; // Disarm the range
}
-//=======================================================================
-// function : Message_ProgressScope
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Message_ProgressScope::Message_ProgressScope(const Message_ProgressRange& theRange,
const NullString*,
Standard_Real theMax,
theRange.myWasUsed = true; // Disarm the range
}
-//=======================================================================
-// function : Close
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void Message_ProgressScope::Close()
{
if (!myIsActive)
myIsActive = false;
}
-//=======================================================================
-// function : UserBreak
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean Message_ProgressScope::UserBreak() const
{
return myProgress && myProgress->UserBreak();
}
-//=======================================================================
-// function : Next
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Message_ProgressRange Message_ProgressScope::Next(Standard_Real theStep)
{
if (myIsActive && theStep > 0.)
return Message_ProgressRange();
}
-//=======================================================================
-// function : Show
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Message_ProgressScope::Show()
{
}
}
-//=======================================================================
-// function : localToGlobal
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real Message_ProgressScope::localToGlobal(const Standard_Real theVal) const
{
if (theVal <= 0.)
return myPortion * x / (1. + x); // hyperbola
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Message_ProgressScope::Value() const
{
IMPLEMENT_STANDARD_RTTIEXT(NCollection_BaseAllocator, Standard_Transient)
-//=======================================================================
-// function : Allocate
-// purpose : Standard allocation
-//=======================================================================
+//=================================================================================================
+
void* NCollection_BaseAllocator::Allocate(const size_t theSize)
{
return Standard::Allocate(theSize);
Standard_Boolean myIsFullRandom;
};
-//=======================================================================
-// function : Fill
-// purpose :
-//=======================================================================
+//=================================================================================================
template <class TheObjType, class TheBndType>
Standard_Integer NCollection_UBTreeFiller<TheObjType, TheBndType>::Fill()
return nbAdd;
}
-//=======================================================================
-// function : CheckTree
-// purpose :
-//=======================================================================
+//=================================================================================================
template <class TheObjType, class TheBndType>
Standard_Integer NCollection_UBTreeFiller<TheObjType, TheBndType>::CheckTree(
return aNumber;
}
-//=======================================================================
-// function : checkNode
-// purpose :
-//=======================================================================
+//=================================================================================================
template <class TheObjType, class TheBndType>
Standard_Real NCollection_UBTreeFiller<TheObjType, TheBndType>::checkNode(
template <typename Type>
const Standard_Utf32Char NCollection_UtfIterator<Type>::UTF32_MAX_LEGAL = 0x0010FFFFUL;
-// =======================================================================
-// function : readUTF16
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline void NCollection_UtfIterator<Type>::readUTF16()
{
myCharUtf32 = aChar;
}
-// =======================================================================
-// function : AdvanceBytesUtf8
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline Standard_Integer NCollection_UtfIterator<Type>::AdvanceBytesUtf8() const
{
}
}
-// =======================================================================
-// function : GetUtf8
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline Standard_Utf8Char* NCollection_UtfIterator<Type>::GetUtf8(Standard_Utf8Char* theBuffer) const
{
return (Standard_Utf8Char*)GetUtf8((Standard_Utf8UChar*)theBuffer);
}
-// =======================================================================
-// function : GetUtf8
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline Standard_Utf8UChar* NCollection_UtfIterator<Type>::GetUtf8(
Standard_Utf8UChar* theBuffer) const
}
}
-// =======================================================================
-// function : AdvanceBytesUtf16
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline Standard_Integer NCollection_UtfIterator<Type>::AdvanceBytesUtf16() const
{
return AdvanceCodeUnitsUtf16() * sizeof(Standard_Utf16Char);
}
-// =======================================================================
-// function : AdvanceCodeUnitsUtf16
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline Standard_Integer NCollection_UtfIterator<Type>::AdvanceCodeUnitsUtf16() const
{
}
}
-// =======================================================================
-// function : GetUtf16
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline Standard_Utf16Char* NCollection_UtfIterator<Type>::GetUtf16(
Standard_Utf16Char* theBuffer) const
}
}
-// =======================================================================
-// function : GetUtf32
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline Standard_Utf32Char* NCollection_UtfIterator<Type>::GetUtf32(
Standard_Utf32Char* theBuffer) const
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-// =======================================================================
-// function : GetChar
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
Standard_Utf32Char NCollection_UtfString<Type>::GetChar(const Standard_Integer theCharIndex) const
{
return 0;
}
-// =======================================================================
-// function : GetCharBuffer
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
const Type* NCollection_UtfString<Type>::GetCharBuffer(const Standard_Integer theCharIndex) const
{
return NULL;
}
-// =======================================================================
-// function : Clear
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline void NCollection_UtfString<Type>::Clear()
{
myString = strAlloc(mySize);
}
-// =======================================================================
-// function : NCollection_UtfString
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline NCollection_UtfString<Type>::NCollection_UtfString()
: myString(strAlloc(0)),
//
}
-// =======================================================================
-// function : NCollection_UtfString
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline NCollection_UtfString<Type>::NCollection_UtfString(const NCollection_UtfString& theCopy)
: myString(strAlloc(theCopy.mySize)),
strCopy((Standard_Byte*)myString, (const Standard_Byte*)theCopy.myString, mySize);
}
-// =======================================================================
-// function : NCollection_UtfString
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline NCollection_UtfString<Type>::NCollection_UtfString(NCollection_UtfString&& theOther) noexcept
: myString(theOther.myString),
theOther.myLength = 0;
}
-// =======================================================================
-// function : NCollection_UtfString
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline NCollection_UtfString<Type>::NCollection_UtfString(const char* theCopyUtf8,
const Standard_Integer theLength)
FromUnicode(theCopyUtf8, theLength);
}
-// =======================================================================
-// function : NCollection_UtfString
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline NCollection_UtfString<Type>::NCollection_UtfString(const Standard_Utf16Char* theCopyUtf16,
const Standard_Integer theLength)
FromUnicode(theCopyUtf16, theLength);
}
-// =======================================================================
-// function : NCollection_UtfString
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline NCollection_UtfString<Type>::NCollection_UtfString(const Standard_Utf32Char* theCopyUtf32,
const Standard_Integer theLength)
#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) \
|| (defined(_MSC_VER) && _MSC_VER >= 1900)
-// =======================================================================
-// function : NCollection_UtfString
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline NCollection_UtfString<Type>::NCollection_UtfString(const Standard_WideChar* theCopyUtfWide,
const Standard_Integer theLength)
strFree(myString);
}
-// =======================================================================
-// function : Assign
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline const NCollection_UtfString<Type>& NCollection_UtfString<Type>::Assign(
const NCollection_UtfString<Type>& theOther)
return (*this);
}
-// =======================================================================
-// function : Swap
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline void NCollection_UtfString<Type>::Swap(NCollection_UtfString<Type>& theOther)
{
};
#endif
-// =======================================================================
-// function : FromLocale
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline void NCollection_UtfString<Type>::FromLocale(const char* theString,
const Standard_Integer theLength)
#endif
}
-// =======================================================================
-// function : ToLocale
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline bool NCollection_UtfString<Type>::ToLocale(char* theBuffer,
const Standard_Integer theSizeBytes) const
return (*this);
}
-// =======================================================================
-// function : IsEqual
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline bool NCollection_UtfString<Type>::IsEqual(const NCollection_UtfString& theCompare) const
{
return (*this);
}
-// =======================================================================
-// function : SubString
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline NCollection_UtfString<Type> NCollection_UtfString<Type>::SubString(
const Standard_Integer theStart,
return NCollection_UtfString<Type>();
}
-// =======================================================================
-// function : ToUtf8
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline const NCollection_UtfString<Standard_Utf8Char> NCollection_UtfString<Type>::ToUtf8() const
{
return aCopy;
}
-// =======================================================================
-// function : ToUtf16
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline const NCollection_UtfString<Standard_Utf16Char> NCollection_UtfString<Type>::ToUtf16() const
{
return aCopy;
}
-// =======================================================================
-// function : ToUtf32
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline const NCollection_UtfString<Standard_Utf32Char> NCollection_UtfString<Type>::ToUtf32() const
{
return aCopy;
}
-// =======================================================================
-// function : ToUtfWide
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <typename Type>
inline const NCollection_UtfString<Standard_WideChar> NCollection_UtfString<Type>::ToUtfWide() const
{
}
} // namespace MurmurHashUtils
-//=======================================================================
-// function : MurmurHash64A
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline uint64_t MurmurHash64A(const void* theKey, int theLen, uint64_t theSeed) noexcept
{
static constexpr uint64_t aMul = (((uint64_t)0xc6a4a793UL) << 32UL) + (uint64_t)0x5bd1e995UL;
return aHash;
}
-//=======================================================================
-// function : MurmurHash2A
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline uint32_t MurmurHash2A(const void* theKey, int theLen, uint32_t theSeed) noexcept
{
constexpr uint32_t aMul = 0x5bd1e995;
namespace FNVHash
{
-//=======================================================================
-// function : FNVHash1A
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline uint32_t FNVHash1A(const void* theKey, int theLen, uint32_t theSeed) noexcept
{
const char* cptr = static_cast<const char*>(theKey);
return theSeed;
}
-//=======================================================================
-// function : FNVHash64A
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline uint64_t FNVHash64A(const void* theKey, int theLen, uint64_t theSeed) noexcept
{
const char* cptr = static_cast<const char*>(theKey);
return TCollection_AsciiString(*this, TCollection_AsciiString(other));
}
-//============================================================================
-// function : HashCode
-// purpose :
-//============================================================================
+//=================================================================================================
+
inline size_t TCollection_AsciiString::HashCode() const
{
if (mylength < 4)
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Mass
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Units_Dimensions::Mass() const
{
return themass;
}
-//=======================================================================
-// function : Length
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Units_Dimensions::Length() const
{
return thelength;
}
-//=======================================================================
-// function : Time
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Units_Dimensions::Time() const
{
return thetime;
}
-//=======================================================================
-// function : ElectricCurrent
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Units_Dimensions::ElectricCurrent() const
{
return theelectriccurrent;
}
-//=======================================================================
-// function : ThermodynamicTemperature
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Units_Dimensions::ThermodynamicTemperature() const
{
return thethermodynamictemperature;
}
-//=======================================================================
-// function : AmountOfSubstance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Units_Dimensions::AmountOfSubstance() const
{
return theamountofsubstance;
}
-//=======================================================================
-// function : LuminousIntensity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Units_Dimensions::LuminousIntensity() const
{
return theluminousintensity;
}
-//=======================================================================
-// function : PlaneAngle
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Units_Dimensions::PlaneAngle() const
{
return theplaneangle;
}
-//=======================================================================
-// function : SolidAngle
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Units_Dimensions::SolidAngle() const
{
#include <Units_TokensSequence.hxx>
#include <Units_Token.hxx>
-//=======================================================================
-// function : Sequence
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Units_TokensSequence) Units_Lexicon::Sequence() const
{
return thesequenceoftokens;
}
-//=======================================================================
-// function : Dump
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Units_Lexicon::Dump() const
{
#include <Units_Dimensions.hxx>
#include <TCollection_HAsciiString.hxx>
-//=======================================================================
-// function : Units_Quantity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Units_Quantity::Units_Quantity(const Standard_CString aname,
const Handle(Units_Dimensions)& adimensions,
theunitssequence = aunitssequence;
}
-//=======================================================================
-// function : Name
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TCollection_AsciiString Units_Quantity::Name() const
{
return thename->String();
}
-//=======================================================================
-// function : Dimensions
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Units_Dimensions) Units_Quantity::Dimensions() const
{
return thedimensions;
}
-//=======================================================================
-// function : Sequence
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Units_UnitsSequence) Units_Quantity::Sequence() const
{
#include <Units_TokensSequence.hxx>
#include <Units_Token.hxx>
-//=======================================================================
-// function : Sequence
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Units_TokensSequence) Units_Sentence::Sequence() const
{
return thesequenceoftokens;
}
-//=======================================================================
-// function : Sequence
-
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Units_Sentence::Sequence(const Handle(Units_TokensSequence)& asequenceoftokens)
{
thesequenceoftokens = asequenceoftokens;
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Units_Sentence::IsDone() const
{
return thesequenceoftokens->Length() > 0;
}
-//=======================================================================
-// function : Dump
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Units_Sentence::Dump() const
{
#include <TCollection_AsciiString.hxx>
#include <Units_Dimensions.hxx>
-//=======================================================================
-// function : Word
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TCollection_AsciiString Units_Token::Word() const
{
return theword;
}
-//=======================================================================
-// function : Mean
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TCollection_AsciiString Units_Token::Mean() const
{
return themean;
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Units_Token::Value() const
{
return thevalue;
}
-//=======================================================================
-// function : Dimensions
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Units_Dimensions) Units_Token::Dimensions() const
{
return thedimensions;
}
-//=======================================================================
-// function : Word
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Units_Token::Word(const Standard_CString aword)
{
theword = aword;
}
-//=======================================================================
-// function : Mean
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Units_Token::Mean(const Standard_CString amean)
{
themean = amean;
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Units_Token::Value(const Standard_Real avalue)
{
thevalue = avalue;
}
-//=======================================================================
-// function : IsNotEqual
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Units_Token::IsNotEqual(const Standard_CString astring) const
{
return Standard_True;
}
-//=======================================================================
-// function : IsNotEqual
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Units_Token::IsNotEqual(const Handle(Units_Token)& atoken) const
{
return Standard_True;
}
-//=======================================================================
-// function : IsLessOrEqual
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Units_Token::IsLessOrEqual(const Standard_CString astring) const
{
return Standard_False;
}
-//=======================================================================
-// function : IsGreater
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Units_Token::IsGreater(const Standard_CString astring) const
{
: Standard_False;
}
-//=======================================================================
-// function : IsGreater
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Units_Token::IsGreater(const Handle(Units_Token)& atoken) const
{
: Standard_False;
}
-//=======================================================================
-// function : IsGreaterOrEqual
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Units_Token::IsGreaterOrEqual(const Handle(Units_Token)& atoken) const
{
#include <TCollection_HAsciiString.hxx>
#include <TCollection_AsciiString.hxx>
-//=======================================================================
-// function : Name
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TCollection_AsciiString Units_Unit::Name() const
{
return thename->String();
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Units_Unit::Value() const
{
return thevalue;
}
-//=======================================================================
-// function : Quantity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Units_Quantity) Units_Unit::Quantity() const
{
return thequantity;
}
-//=======================================================================
-// function : SymbolsSequence
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TColStd_HSequenceOfHAsciiString) Units_Unit::SymbolsSequence() const
{
return thesymbolssequence;
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Units_Unit::Value(const Standard_Real avalue)
{
thevalue = avalue;
}
-//=======================================================================
-// function : Quantity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Units_Unit::Quantity(const Handle(Units_Quantity)& aquantity)
{
#include <Units_Quantity.hxx>
#include <Units_Explorer.hxx>
-//=======================================================================
-// function : Sequence
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Units_QuantitiesSequence) Units_UnitsDictionary::Sequence() const
{
return thequantitiessequence;
}
-//=======================================================================
-// function : Dump
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Units_UnitsDictionary::Dump(const Standard_Integer alevel) const
{
}
}
-//=======================================================================
-// function : Dump
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Units_UnitsDictionary::Dump(const Handle(Units_Dimensions)& adimensions) const
{
#include <Units_Lexicon.hxx>
-//=======================================================================
-// function : Dump
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Units_UnitsLexicon::Dump() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : BOPAlgo_MakerVolume
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPAlgo_MakerVolume::BOPAlgo_MakerVolume()
: BOPAlgo_Builder(),
myIntersect(Standard_True),
{
}
-//=======================================================================
-// function : BOPAlgo_MakerVolume
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPAlgo_MakerVolume::BOPAlgo_MakerVolume(
const Handle(NCollection_BaseAllocator)& theAllocator)
: BOPAlgo_Builder(theAllocator),
Clear();
}
-//=======================================================================
-// function : Clear
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPAlgo_MakerVolume::Clear()
{
BOPAlgo_Builder::Clear();
myAvoidInternalShapes = Standard_False;
}
-//=======================================================================
-// function : SetIntersect
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPAlgo_MakerVolume::SetIntersect(const Standard_Boolean bIntersect)
{
myIntersect = bIntersect;
}
-//=======================================================================
-// function : IsIntersect
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPAlgo_MakerVolume::IsIntersect() const
{
return myIntersect;
}
-//=======================================================================
-// function : Box
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const TopoDS_Solid& BOPAlgo_MakerVolume::Box() const
{
return mySBox;
}
-//=======================================================================
-// function : Faces
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const TopTools_ListOfShape& BOPAlgo_MakerVolume::Faces() const
{
return myFaces;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPAlgo_WireEdgeSet::BOPAlgo_WireEdgeSet() {}
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPAlgo_WireEdgeSet::BOPAlgo_WireEdgeSet(
const Handle(NCollection_BaseAllocator)& theAllocator)
: myStartShapes(theAllocator),
//=======================================================================
inline BOPAlgo_WireEdgeSet::~BOPAlgo_WireEdgeSet() {}
-//=======================================================================
-// function : Clear
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPAlgo_WireEdgeSet::Clear()
{
myStartShapes.Clear();
myShapes.Clear();
}
-//=======================================================================
-// function : SetFace
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPAlgo_WireEdgeSet::SetFace(const TopoDS_Face& aF)
{
myFace = aF;
}
-//=======================================================================
-// function : Face
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const TopoDS_Face& BOPAlgo_WireEdgeSet::Face() const
{
return myFace;
}
-//=======================================================================
-// function : AddStartElement
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPAlgo_WireEdgeSet::AddStartElement(const TopoDS_Shape& aE)
{
myStartShapes.Append(aE);
}
-//=======================================================================
-// function : StartElements
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const TopTools_ListOfShape& BOPAlgo_WireEdgeSet::StartElements() const
{
return myStartShapes;
}
-//=======================================================================
-// function : AddShape
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPAlgo_WireEdgeSet::AddShape(const TopoDS_Shape& aW)
{
myShapes.Append(aW);
}
-//=======================================================================
-// function : Shapes
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const TopTools_ListOfShape& BOPAlgo_WireEdgeSet::Shapes() const
{
return myShapes;
#include <TopoDS_Edge.hxx>
-//=======================================================================
-// function : BOPAlgo_EdgeInfo
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPAlgo_EdgeInfo
{
public:
typedef NCollection_IndexedDataMap<TopoDS_Shape, BOPAlgo_ListOfEdgeInfo, TopTools_ShapeMapHasher>
BOPAlgo_IndexedDataMapOfShapeListOfEdgeInfo;
-//=======================================================================
-// function : MakeWire
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPAlgo_WireSplitter::MakeWire(TopTools_ListOfShape& aLE, TopoDS_Wire& aWire)
{
BRep_Builder aBB;
* and some satellite information
*
*/
-//=======================================================================
-// class : BOPDS_CoupleOfPaveBlocks
-// purpose :
-//=======================================================================
+
+//=================================================================================================
+
class BOPDS_CoupleOfPaveBlocks
{
public:
#include <BOPDS_PaveBlock.hxx>
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_Curve::BOPDS_Curve()
: myAllocator(NCollection_BaseAllocator::CommonBaseAllocator()),
myPaveBlocks(myAllocator),
{
}
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_Curve::BOPDS_Curve(const Handle(NCollection_BaseAllocator)& theAllocator)
: myAllocator(theAllocator),
myPaveBlocks(myAllocator),
{
}
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_Curve::~BOPDS_Curve() {}
-//=======================================================================
-// function : SetCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_Curve::SetCurve(const IntTools_Curve& theCurve)
{
myCurve = theCurve;
}
-//=======================================================================
-// function : Curve
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const IntTools_Curve& BOPDS_Curve::Curve() const
{
return myCurve;
}
-//=======================================================================
-// function : SetPaveBlocks
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_Curve::SetPaveBlocks(const BOPDS_ListOfPaveBlock& theLPB)
{
BOPDS_ListIteratorOfListOfPaveBlock aIt;
}
}
-//=======================================================================
-// function : PaveBlocks
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const BOPDS_ListOfPaveBlock& BOPDS_Curve::PaveBlocks() const
{
return myPaveBlocks;
}
-//=======================================================================
-// function : ChangePaveBlocks
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_ListOfPaveBlock& BOPDS_Curve::ChangePaveBlocks()
{
return myPaveBlocks;
}
-//=======================================================================
-// function : InitPaveBlock1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_Curve::InitPaveBlock1()
{
if (!myPaveBlocks.Extent())
}
}
-//=======================================================================
-// function : ChangePaveBlock1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Handle(BOPDS_PaveBlock)& BOPDS_Curve::ChangePaveBlock1()
{
Handle(BOPDS_PaveBlock)* pPB = (Handle(BOPDS_PaveBlock)*)&myPaveBlocks.First();
return *pPB;
}
-//=======================================================================
-// function : TechnoVertices
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const TColStd_ListOfInteger& BOPDS_Curve::TechnoVertices() const
{
return myTechnoVertices;
}
-//=======================================================================
-// function : ChangeTechnoVertices
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline TColStd_ListOfInteger& BOPDS_Curve::ChangeTechnoVertices()
{
return myTechnoVertices;
}
-//=======================================================================
-// function : SetBox
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_Curve::SetBox(const Bnd_Box& theBox)
{
myBox = theBox;
}
-//=======================================================================
-// function : Box
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const Bnd_Box& BOPDS_Curve::Box() const
{
return myBox;
}
-//=======================================================================
-// function : ChangeBox
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Bnd_Box& BOPDS_Curve::ChangeBox()
{
return myBox;
}
-//=======================================================================
-// function : HasEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_Curve::HasEdge() const
{
Standard_Boolean bFlag;
#include <BOPDS_Pair.hxx>
-//=======================================================================
-// function : InterfVV
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_VectorOfInterfVV& BOPDS_DS::InterfVV()
{
return myInterfVV;
}
-//=======================================================================
-// function : InterfVE
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_VectorOfInterfVE& BOPDS_DS::InterfVE()
{
return myInterfVE;
}
-//=======================================================================
-// function : InterfVF
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_VectorOfInterfVF& BOPDS_DS::InterfVF()
{
return myInterfVF;
-} //=======================================================================
+} //=================================================================================================
-// function : InterfEE
-// purpose :
-//=======================================================================
inline BOPDS_VectorOfInterfEE& BOPDS_DS::InterfEE()
{
return myInterfEE;
}
-//=======================================================================
-// function : InterfEF
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_VectorOfInterfEF& BOPDS_DS::InterfEF()
{
return myInterfEF;
}
-//=======================================================================
-// function : InterfFF
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_VectorOfInterfFF& BOPDS_DS::InterfFF()
{
return myInterfFF;
}
-//=======================================================================
-// function : InterfVZ
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_VectorOfInterfVZ& BOPDS_DS::InterfVZ()
{
return myInterfVZ;
}
-//=======================================================================
-// function : InterfEZ
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_VectorOfInterfEZ& BOPDS_DS::InterfEZ()
{
return myInterfEZ;
}
-//=======================================================================
-// function : InterfFZ
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_VectorOfInterfFZ& BOPDS_DS::InterfFZ()
{
return myInterfFZ;
}
-//=======================================================================
-// function : InterfZZ
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_VectorOfInterfZZ& BOPDS_DS::InterfZZ()
{
return myInterfZZ;
}
-//=======================================================================
-// function : NbInterfTypes
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer BOPDS_DS::NbInterfTypes()
{
return 10;
}
-//=======================================================================
-// function : AddInterf
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_DS::AddInterf(const Standard_Integer theI1,
const Standard_Integer theI2)
{
return Standard_False;
}
-//=======================================================================
-// function : HasInterf
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_DS::HasInterf(const Standard_Integer theI) const
{
return myInterfered.Contains(theI);
}
-//=======================================================================
-// function : HasInterf
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_DS::HasInterf(const Standard_Integer theI1,
const Standard_Integer theI2) const
{
return myInterfTB.Contains(aPK);
}
-//=======================================================================
-// function : Interferences
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const BOPDS_MapOfPair& BOPDS_DS::Interferences() const
{
return myInterfTB;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_FaceInfo::BOPDS_FaceInfo()
: myAllocator(NCollection_BaseAllocator::CommonBaseAllocator()),
myIndex(-1),
{
}
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_FaceInfo::BOPDS_FaceInfo(const Handle(NCollection_BaseAllocator)& theAllocator)
: myAllocator(theAllocator),
myIndex(-1),
Clear();
}
-//=======================================================================
-// function : Clear
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_FaceInfo::Clear()
{
myPaveBlocksIn.Clear();
myVerticesOn.Clear();
}
-//=======================================================================
-// function : SetIndex
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_FaceInfo::SetIndex(const Standard_Integer theI)
{
myIndex = theI;
}
-//=======================================================================
-// function : Index
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer BOPDS_FaceInfo::Index() const
{
return myIndex;
}
-//=======================================================================
-// function : PaveBlockIn
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const BOPDS_IndexedMapOfPaveBlock& BOPDS_FaceInfo::PaveBlocksIn() const
{
return myPaveBlocksIn;
}
-//=======================================================================
-// function : ChangePaveBlocksIn
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_IndexedMapOfPaveBlock& BOPDS_FaceInfo::ChangePaveBlocksIn()
{
return myPaveBlocksIn;
}
-//=======================================================================
-// function : VerticesIn
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const TColStd_MapOfInteger& BOPDS_FaceInfo::VerticesIn() const
{
return myVerticesIn;
}
-//=======================================================================
-// function : ChangeVerticesIn
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline TColStd_MapOfInteger& BOPDS_FaceInfo::ChangeVerticesIn()
{
return myVerticesIn;
}
// On
-//=======================================================================
-// function : PaveBlocksOn
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const BOPDS_IndexedMapOfPaveBlock& BOPDS_FaceInfo::PaveBlocksOn() const
{
return myPaveBlocksOn;
}
-//=======================================================================
-// function : ChangePaveBlocksOn
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_IndexedMapOfPaveBlock& BOPDS_FaceInfo::ChangePaveBlocksOn()
{
return myPaveBlocksOn;
}
-//=======================================================================
-// function : VerticesOn
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const TColStd_MapOfInteger& BOPDS_FaceInfo::VerticesOn() const
{
return myVerticesOn;
}
-//=======================================================================
-// function : ChangeVerticesOn
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline TColStd_MapOfInteger& BOPDS_FaceInfo::ChangeVerticesOn()
{
return myVerticesOn;
}
// Sc
-//=======================================================================
-// function : PaveBlocksSc
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const BOPDS_IndexedMapOfPaveBlock& BOPDS_FaceInfo::PaveBlocksSc() const
{
return myPaveBlocksSc;
}
-//=======================================================================
-// function : ChangePaveBlocksSc
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_IndexedMapOfPaveBlock& BOPDS_FaceInfo::ChangePaveBlocksSc()
{
return myPaveBlocksSc;
}
-//=======================================================================
-// function : VerticesSc
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const TColStd_MapOfInteger& BOPDS_FaceInfo::VerticesSc() const
{
return myVerticesSc;
}
-//=======================================================================
-// function : ChangeVerticesSc
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline TColStd_MapOfInteger& BOPDS_FaceInfo::ChangeVerticesSc()
{
return myVerticesSc;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_IndexRange::BOPDS_IndexRange()
: myFirst(0),
myLast(0)
{
}
-//=======================================================================
-// function : SetFirst
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_IndexRange::SetFirst(const Standard_Integer aFirst)
{
myFirst = aFirst;
}
-//=======================================================================
-// function : First
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer BOPDS_IndexRange::First() const
{
return myFirst;
}
-//=======================================================================
-// function : SetLast
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_IndexRange::SetLast(const Standard_Integer aLast)
{
myLast = aLast;
}
-//=======================================================================
-// function :Last
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer BOPDS_IndexRange::Last() const
{
return myLast;
}
-//=======================================================================
-// function : SetIndices
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_IndexRange::SetIndices(const Standard_Integer theI1, const Standard_Integer theI2)
{
myFirst = theI1;
myLast = theI2;
}
-//=======================================================================
-// function : Indices
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_IndexRange::Indices(Standard_Integer& theI1, Standard_Integer& theI2) const
{
theI1 = myFirst;
theI2 = myLast;
}
-//=======================================================================
-// function : Contains
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_IndexRange::Contains(const Standard_Integer aIndex) const
{
return aIndex >= myFirst && aIndex <= myLast;
* The class BOPDS_Interf is root class
*
*/
-//=======================================================================
-// function : BOPDS_Interf
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPDS_Interf
{
public:
* The class BOPDS_InterfVV stores the information about
* the interference of the type vertex/vertex.
*/
-//=======================================================================
-// function : BOPDS_InterfVV
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPDS_InterfVV : public BOPDS_Interf
{
public:
* The class BOPDS_InterfVE stores the information about
* the interference of the type vertex/edge.
*/
-//=======================================================================
-// function : BOPDS_InterfVE
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPDS_InterfVE : public BOPDS_Interf
{
public:
* The class BOPDS_InterfVF stores the information about
* the interference of the type vertex/face
*/
-//=======================================================================
-// function : BOPDS_InterfVF
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPDS_InterfVF : public BOPDS_Interf
{
public:
* The class BOPDS_InterfEE stores the information about
* the interference of the type edge/edge.
*/
-//=======================================================================
-// function : BOPDS_InterfEE
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPDS_InterfEE : public BOPDS_Interf
{
public:
* The class BOPDS_InterfEF stores the information about
* the interference of the type edge/face.
*/
-//=======================================================================
-// function : BOPDS_InterfEF
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPDS_InterfEF : public BOPDS_Interf
{
public:
*/
;
-//=======================================================================
-// function : BOPDS_InterfFF
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPDS_InterfFF : public BOPDS_Interf
{
public:
* The class BOPDS_InterfVZ stores the information about
* the interference of the type vertex/solid.
*/
-//=======================================================================
-// function : BOPDS_InterfVZ
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPDS_InterfVZ : public BOPDS_Interf
{
public:
* The class BOPDS_InterfEZ stores the information about
* the interference of the type edge/solid.
*/
-//=======================================================================
-// function : BOPDS_InterfEZ
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPDS_InterfEZ : public BOPDS_Interf
{
public:
* The class BOPDS_InterfFZ stores the information about
* the interference of the type face/solid.
*/
-//=======================================================================
-// function : BOPDS_InterfFZ
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPDS_InterfFZ : public BOPDS_Interf
{
public:
* The class BOPDS_InterfZZ stores the information about
* the interference of the type solid/solid.
*/
-//=======================================================================
-// function : BOPDS_InterfZZ
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPDS_InterfZZ : public BOPDS_Interf
{
public:
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_Pave::BOPDS_Pave()
{
myIndex = -1;
myParameter = 99.;
}
-//=======================================================================
-// function : SetIndex
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_Pave::SetIndex(const Standard_Integer theIndex)
{
myIndex = theIndex;
}
-//=======================================================================
-// function : Index
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer BOPDS_Pave::Index() const
{
return myIndex;
}
-//=======================================================================
-// function : SetParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_Pave::SetParameter(const Standard_Real theParameter)
{
myParameter = theParameter;
}
-//=======================================================================
-// function : Parameter
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real BOPDS_Pave::Parameter() const
{
return myParameter;
}
-//=======================================================================
-// function : Contents
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_Pave::Contents(Standard_Integer& theIndex, Standard_Real& theParameter) const
{
theIndex = myIndex;
theParameter = myParameter;
}
-//=======================================================================
-// function : IsLess
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_Pave::IsLess(const BOPDS_Pave& theOther) const
{
return myParameter < theOther.myParameter;
}
-//=======================================================================
-// function : IsEqual
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_Pave::IsEqual(const BOPDS_Pave& theOther) const
{
Standard_Boolean bFlag;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_Point::BOPDS_Point()
{
myPnt.SetCoord(99., 99., 99.);
//=======================================================================
inline BOPDS_Point::~BOPDS_Point() {}
-//=======================================================================
-// function : SetIndex
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_Point::SetIndex(const Standard_Integer theIndex)
{
myIndex = theIndex;
}
-//=======================================================================
-// function : Index
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer BOPDS_Point::Index() const
{
return myIndex;
}
-//=======================================================================
-// function : SetPnt
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_Point::SetPnt(const gp_Pnt& thePnt)
{
myPnt = thePnt;
}
-//=======================================================================
-// function : Pnt
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const gp_Pnt& BOPDS_Point::Pnt() const
{
return myPnt;
}
-//=======================================================================
-// function : SetPnt2D1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_Point::SetPnt2D1(const gp_Pnt2d& thePnt)
{
myPnt2D1 = thePnt;
}
-//=======================================================================
-// function : Pnt2D1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const gp_Pnt2d& BOPDS_Point::Pnt2D1() const
{
return myPnt2D1;
}
-//=======================================================================
-// function : SetPnt2D2
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_Point::SetPnt2D2(const gp_Pnt2d& thePnt)
{
myPnt2D2 = thePnt;
}
-//=======================================================================
-// function : Pnt2D2
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const gp_Pnt2d& BOPDS_Point::Pnt2D2() const
{
return myPnt2D2;
#include <BOPDS_Tools.hxx>
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_ShapeInfo::BOPDS_ShapeInfo()
:
{
}
-//=======================================================================
-// function :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline BOPDS_ShapeInfo::BOPDS_ShapeInfo(const Handle(NCollection_BaseAllocator)& theAllocator)
: myType(TopAbs_SHAPE),
mySubShapes(theAllocator),
//=======================================================================
inline BOPDS_ShapeInfo::~BOPDS_ShapeInfo() {}
-//=======================================================================
-// function : SetShape
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_ShapeInfo::SetShape(const TopoDS_Shape& theS)
{
myShape = theS;
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const TopoDS_Shape& BOPDS_ShapeInfo::Shape() const
{
return myShape;
}
-//=======================================================================
-// function : SetShapeType
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_ShapeInfo::SetShapeType(const TopAbs_ShapeEnum theType)
{
myType = theType;
}
-//=======================================================================
-// function : ShapeType
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline TopAbs_ShapeEnum BOPDS_ShapeInfo::ShapeType() const
{
return myType;
}
-//=======================================================================
-// function : SetBox
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_ShapeInfo::SetBox(const Bnd_Box& theBox)
{
myBox = theBox;
}
-//=======================================================================
-// function : Box
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const Bnd_Box& BOPDS_ShapeInfo::Box() const
{
return myBox;
}
-//=======================================================================
-// function : ChangeBox
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Bnd_Box& BOPDS_ShapeInfo::ChangeBox()
{
return myBox;
}
-//=======================================================================
-// function : SubShapes
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const TColStd_ListOfInteger& BOPDS_ShapeInfo::SubShapes() const
{
return mySubShapes;
}
-//=======================================================================
-// function : ChangeSubShapes
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline TColStd_ListOfInteger& BOPDS_ShapeInfo::ChangeSubShapes()
{
return mySubShapes;
}
-//=======================================================================
-// function : HasSubShape
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_ShapeInfo::HasSubShape(const Standard_Integer theI) const
{
return mySubShapes.Contains(theI);
}
-//=======================================================================
-// function : HasReference
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_ShapeInfo::HasReference() const
{
return (myReference >= 0);
}
-//=======================================================================
-// function : SetReference
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_ShapeInfo::SetReference(const Standard_Integer theI)
{
myReference = theI;
}
-//=======================================================================
-// function : Reference
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer BOPDS_ShapeInfo::Reference() const
{
return myReference;
}
-//=======================================================================
-// function : HasBRep
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_ShapeInfo::HasBRep() const
{
return (BOPDS_Tools::HasBRep(myType));
}
-//=======================================================================
-// function : IsInterfering
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_ShapeInfo::IsInterfering() const
{
return (HasBRep() || myType == TopAbs_SOLID);
}
-//=======================================================================
-// function : HasFlag
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_ShapeInfo::HasFlag() const
{
return (myFlag >= 0);
}
-//=======================================================================
-// function : HasFlag
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_ShapeInfo::HasFlag(Standard_Integer& theFlag) const
{
theFlag = myFlag;
return (myFlag >= 0);
}
-//=======================================================================
-// function : SetFlag
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BOPDS_ShapeInfo::SetFlag(const Standard_Integer theFlag)
{
myFlag = theFlag;
}
-//=======================================================================
-// function : Flag
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer BOPDS_ShapeInfo::Flag() const
{
return myFlag;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function: HasBRep
-// purpose:
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_Tools::HasBRep(const TopAbs_ShapeEnum aTi)
{
return (aTi == TopAbs_VERTEX || aTi == TopAbs_EDGE || aTi == TopAbs_FACE);
}
-//=======================================================================
-// function: IsInterfering
-// purpose:
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BOPDS_Tools::IsInterfering(const TopAbs_ShapeEnum aTi)
{
return (BOPDS_Tools::HasBRep(aTi) || aTi == TopAbs_SOLID);
}
-//=======================================================================
-// function : TypeToInteger
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer BOPDS_Tools::TypeToInteger(const TopAbs_ShapeEnum aType1,
const TopAbs_ShapeEnum aType2)
{
return iRet;
}
-//=======================================================================
-// function : TypeToInteger
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer BOPDS_Tools::TypeToInteger(const TopAbs_ShapeEnum aType1)
{
Standard_Integer iRet = 9;
#include <NCollection_BaseAllocator.hxx>
#include <TopTools_ListOfShape.hxx>
-//=======================================================================
-// class : ConnexityBlock
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPTools_ConnexityBlock
{
public:
#include <TopoDS_Shape.hxx>
-//=======================================================================
-// class :
-// purpose :
-//=======================================================================
+//=================================================================================================
+
class BOPTools_CoupleOfShape
{
public:
#include <Precision.hxx>
#include <BRep_Tool.hxx>
-//=======================================================================
-// function : IntTools_EdgeEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline IntTools_EdgeEdge::IntTools_EdgeEdge()
: myTol1(0.),
myTol2(0.),
{
}
-//=======================================================================
-// function : IntTools_EdgeEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline IntTools_EdgeEdge::IntTools_EdgeEdge(const TopoDS_Edge& theEdge1,
const TopoDS_Edge& theEdge2)
: myEdge1(theEdge1),
{
}
-//=======================================================================
-// function : IntTools_EdgeEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline IntTools_EdgeEdge::IntTools_EdgeEdge(const TopoDS_Edge& theEdge1,
const Standard_Real aT11,
const Standard_Real aT12,
{
}
-//=======================================================================
-// function : IntTools_EdgeEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline IntTools_EdgeEdge::~IntTools_EdgeEdge() {}
-//=======================================================================
-// function : SetEdge1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void IntTools_EdgeEdge::SetEdge1(const TopoDS_Edge& theEdge)
{
myEdge1 = theEdge;
}
-//=======================================================================
-// function : SetRange1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void IntTools_EdgeEdge::SetRange1(const IntTools_Range& theRange)
{
myRange1 = theRange;
}
-//=======================================================================
-// function : SetRange1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void IntTools_EdgeEdge::SetRange1(const Standard_Real aT1, const Standard_Real aT2)
{
myRange1.SetFirst(aT1);
myRange1.SetLast(aT2);
}
-//=======================================================================
-// function : SetEdge1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void IntTools_EdgeEdge::SetEdge1(const TopoDS_Edge& theEdge,
const Standard_Real aT1,
const Standard_Real aT2)
SetRange1(aT1, aT2);
}
-//=======================================================================
-// function : SetEdge2
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void IntTools_EdgeEdge::SetEdge2(const TopoDS_Edge& theEdge)
{
myEdge2 = theEdge;
}
-//=======================================================================
-// function : SetRange1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void IntTools_EdgeEdge::SetRange2(const IntTools_Range& theRange)
{
myRange2 = theRange;
}
-//=======================================================================
-// function : SetRange1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void IntTools_EdgeEdge::SetRange2(const Standard_Real aT1, const Standard_Real aT2)
{
myRange2.SetFirst(aT1);
myRange2.SetLast(aT2);
}
-//=======================================================================
-// function : SetEdge1
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void IntTools_EdgeEdge::SetEdge2(const TopoDS_Edge& theEdge,
const Standard_Real aT1,
const Standard_Real aT2)
SetRange2(aT1, aT2);
}
-//=======================================================================
-// function : SetFuzzyValue
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void IntTools_EdgeEdge::SetFuzzyValue(const Standard_Real theFuzz)
{
myFuzzyValue = Max(theFuzz, Precision::Confusion());
}
-//=======================================================================
-// function : FuzzyValue
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real IntTools_EdgeEdge::FuzzyValue() const
{
return myFuzzyValue;
}
-//=======================================================================
-// function : CommonParts
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const IntTools_SequenceOfCommonPrts& IntTools_EdgeEdge::CommonParts() const
{
return myCommonParts;
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean IntTools_EdgeEdge::IsDone() const
{
return (myErrorStatus == 0);
}
-//=======================================================================
-// function : CheckData
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void IntTools_EdgeEdge::CheckData()
{
if (myEdge1.IsNull() || myEdge2.IsNull())
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Shell
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shell& BRepFill_Generator::Shell() const
{
angmax = Angmax;
}
-//=======================================================================
-// function : Simulate
-// purpose : Calculate N Sections
-//=======================================================================
+//=================================================================================================
+
void BRepFill_PipeShell::Simulate(const Standard_Integer N, TopTools_ListOfShape& List)
{
// Preparation
#include <TopoDS.hxx>
#include <TopTools_HArray1OfShape.hxx>
-//=======================================================================
-// function : Edge
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const TopoDS_Edge& BRepFill_ShapeLaw::Edge(const Standard_Integer Index) const
{
return TopoDS::Edge(myEdges->Value(Index));
#include <IntPatch_Line.hxx>
-//=======================================================================
-// function : TopOpeBRep_LineInter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopOpeBRep_LineInter::TopOpeBRep_LineInter()
: myOK(Standard_True),
{
}
-//=======================================================================
-// function : SetFaces
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopOpeBRep_LineInter::SetFaces(const TopoDS_Face& F1, const TopoDS_Face& F2)
{
myF2 = F2;
}
-//=======================================================================
-// function : TypeLineCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopOpeBRep_TypeLineCurve TopOpeBRep_LineInter::TypeLineCurve() const
{
return myTypeLineCurve;
}
-//=======================================================================
-// function : NbVPoint
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer TopOpeBRep_LineInter::NbVPoint() const
{
return myNbVPoint;
}
-//=======================================================================
-// function : INL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRep_LineInter::INL() const
{
return myINL;
}
-//=======================================================================
-// function : IsVClosed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRep_LineInter::IsVClosed() const
{
return myIsVClosed;
}
-//=======================================================================
-// function : HasVPonR
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRep_LineInter::HasVPonR() const
{
return myHasVPonR;
}
-//=======================================================================
-// function : TransitionOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline IntSurf_TypeTrans TopOpeBRep_LineInter::TransitionOnS1() const
{
return myIL->TransitionOnS1();
}
-//=======================================================================
-// function : TransitionOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline IntSurf_TypeTrans TopOpeBRep_LineInter::TransitionOnS2() const
{
return myIL->TransitionOnS2();
}
-//=======================================================================
-// function : SituationS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline IntSurf_Situation TopOpeBRep_LineInter::SituationS1() const
{
return myIL->SituationS1();
}
-//=======================================================================
-// function : SituationS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline IntSurf_Situation TopOpeBRep_LineInter::SituationS2() const
{
return myIL->SituationS2();
}
-//=======================================================================
-// function : LineW
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(IntPatch_WLine)& TopOpeBRep_LineInter::LineW() const
{
return myILW;
}
-//=======================================================================
-// function : LineG
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(IntPatch_GLine)& TopOpeBRep_LineInter::LineG() const
{
return myILG;
}
-//=======================================================================
-// function : LineR
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(IntPatch_RLine)& TopOpeBRep_LineInter::LineR() const
{
return myILR;
}
-//=======================================================================
-// function : Index
-// purpose : trace
-//=======================================================================
+//=================================================================================================
inline void TopOpeBRep_LineInter::Index(const Standard_Integer I)
{
myIndex = I;
}
-//=======================================================================
-// function : Index
-// purpose : trace
-//=======================================================================
+//=================================================================================================
inline Standard_Integer TopOpeBRep_LineInter::Index() const
{
return myIndex;
}
-//=======================================================================
-// function : OK
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRep_LineInter::OK() const
{
#include <TopOpeBRep_define.hxx>
-//=======================================================================
-// function : SetPint
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetPint(const IntRes2d_IntersectionPoint& P)
{
mypint = P;
myhaspint = Standard_True;
}
-//=======================================================================
-// function : HasPint
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean TopOpeBRep_Point2d::HasPint() const
{
return myhaspint;
}
-//=======================================================================
-// function : Pint
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const IntRes2d_IntersectionPoint& TopOpeBRep_Point2d::Pint() const
{
if (!HasPint())
return mypint;
}
-//=======================================================================
-// function : SetIsVertex
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetIsVertex(const Standard_Integer Index, const Standard_Boolean B)
{
if (Index == 1)
throw Standard_Failure("TopOpeBRep_Point2d::SetIsVertex");
}
-//=======================================================================
-// function : IsVertex
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean TopOpeBRep_Point2d::IsVertex(const Standard_Integer Index) const
{
if (Index == 1)
throw Standard_Failure("TopOpeBRep_Point2d::IsVertex");
}
-//=======================================================================
-// function : SetVertex
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetVertex(const Standard_Integer Index, const TopoDS_Vertex& V)
{
if (Index == 1)
throw Standard_Failure("TopOpeBRep_Point2d::SetVertex");
}
-//=======================================================================
-// function : SetTransition
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetTransition(const Standard_Integer Index,
const TopOpeBRepDS_Transition& T)
{
throw Standard_Failure("TopOpeBRep_Point2d::SetTransition");
}
-//=======================================================================
-// function : SetParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetParameter(const Standard_Integer Index, const Standard_Real P)
{
if (Index == 1)
throw Standard_Failure("TopOpeBRep_Point2d::SetParameter");
}
-//=======================================================================
-// function : Parameter
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real TopOpeBRep_Point2d::Parameter(const Standard_Integer Index) const
{
if (Index == 1)
throw Standard_Failure("TopOpeBRep_Point2d::Parameter");
}
-//=======================================================================
-// function : SetIsPointOfSegment
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetIsPointOfSegment(const Standard_Boolean B)
{
myispointofsegment = B;
}
-//=======================================================================
-// function : IsPointOfSegment
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean TopOpeBRep_Point2d::IsPointOfSegment() const
{
return myispointofsegment;
}
-//=======================================================================
-// function : SetSegmentAncestors
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetSegmentAncestors(const Standard_Integer IP1,
const Standard_Integer IP2)
{
mystatus = TopOpeBRep_P2DNEW;
}
-//=======================================================================
-// function : SegmentAncestors
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean TopOpeBRep_Point2d::SegmentAncestors(Standard_Integer& IP1,
Standard_Integer& IP2) const
{
return myhasancestors;
}
-//=======================================================================
-// function : SetStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetStatus(const TopOpeBRep_P2Dstatus I)
{
mystatus = I;
}
-//=======================================================================
-// function : Status
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline TopOpeBRep_P2Dstatus TopOpeBRep_Point2d::Status() const
{
return mystatus;
}
-//=======================================================================
-// function : SetIndex
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetIndex(const Standard_Integer I)
{
myindex = I;
}
-//=======================================================================
-// function : Index
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer TopOpeBRep_Point2d::Index() const
{
return myindex;
}
-//=======================================================================
-// function : SetValue
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetValue(const gp_Pnt& P)
{
mypnt = P;
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const gp_Pnt& TopOpeBRep_Point2d::Value() const
{
return mypnt;
}
-//=======================================================================
-// function : SetValue2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetValue2d(const gp_Pnt2d& P)
{
mypnt2d = P;
}
-//=======================================================================
-// function : Value2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline const gp_Pnt2d& TopOpeBRep_Point2d::Value2d() const
{
return mypnt2d;
}
-//=======================================================================
-// function : SetKeep
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetKeep(const Standard_Boolean B)
{
mykeep = B;
}
-//=======================================================================
-// function : Keep
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean TopOpeBRep_Point2d::Keep() const
{
return mykeep;
}
-//=======================================================================
-// function : SetEdgesConfig
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetEdgesConfig(const TopOpeBRepDS_Config B)
{
myedgesconfig = B;
}
-//=======================================================================
-// function : EdgesConfig
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline TopOpeBRepDS_Config TopOpeBRep_Point2d::EdgesConfig() const
{
return myedgesconfig;
}
-//=======================================================================
-// function : SetTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetTolerance(const Standard_Real t)
{
mytolerance = t;
}
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real TopOpeBRep_Point2d::Tolerance() const
{
return mytolerance;
}
-//=======================================================================
-// function : SetHctxff2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetHctxff2d(const Handle(TopOpeBRep_Hctxff2d)& h)
{
myctxff2d = h;
}
-//=======================================================================
-// function : Hctxff2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Handle(TopOpeBRep_Hctxff2d) TopOpeBRep_Point2d::Hctxff2d() const
{
return myctxff2d;
}
-//=======================================================================
-// function : SetHctxee2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void TopOpeBRep_Point2d::SetHctxee2d(const Handle(TopOpeBRep_Hctxee2d)& h)
{
myctxee2d = h;
}
-//=======================================================================
-// function : Hctxee2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Handle(TopOpeBRep_Hctxee2d) TopOpeBRep_Point2d::Hctxee2d() const
{
return myctxee2d;
#include <IntPatch_Point.hxx>
-//=======================================================================
-// function : TopOpeBRep_VPointInter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopOpeBRep_VPointInter::TopOpeBRep_VPointInter()
: myPPOI(NULL),
{
}
-//=======================================================================
-// function : SetShapes
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopOpeBRep_VPointInter::SetShapes(const Standard_Integer I1, const Standard_Integer I2)
{
myS2 = I2;
}
-//=======================================================================
-// function : GetShapes
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopOpeBRep_VPointInter::GetShapes(Standard_Integer& I1, Standard_Integer& I2) const
{
I2 = myS2;
}
-//=======================================================================
-// function : TransitionOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline IntSurf_Transition TopOpeBRep_VPointInter::TransitionOnS1() const
{
return myPPOI->TransitionOnS1();
}
-//=======================================================================
-// function : TransitionOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline IntSurf_Transition TopOpeBRep_VPointInter::TransitionOnS2() const
{
return myPPOI->TransitionOnS2();
}
-//=======================================================================
-// function : TransitionLineArc1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline IntSurf_Transition TopOpeBRep_VPointInter::TransitionLineArc1() const
{
return myPPOI->TransitionLineArc1();
}
-//=======================================================================
-// function : TransitionLineArc2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline IntSurf_Transition TopOpeBRep_VPointInter::TransitionLineArc2() const
{
return myPPOI->TransitionLineArc2();
}
-//=======================================================================
-// function : IsOnDomS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRep_VPointInter::IsOnDomS1() const
{
return myPPOI->IsOnDomS1();
}
-//=======================================================================
-// function : IsOnDomS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRep_VPointInter::IsOnDomS2() const
{
return myPPOI->IsOnDomS2();
}
-//=======================================================================
-// function : ParametersOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopOpeBRep_VPointInter::ParametersOnS1(Standard_Real& u, Standard_Real& v) const
{
myPPOI->ParametersOnS1(u, v);
}
-//=======================================================================
-// function : ParametersOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopOpeBRep_VPointInter::ParametersOnS2(Standard_Real& u, Standard_Real& v) const
{
myPPOI->ParametersOnS2(u, v);
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const gp_Pnt& TopOpeBRep_VPointInter::Value() const
{
return myPPOI->Value();
}
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real TopOpeBRep_VPointInter::Tolerance() const
{
return myPPOI->Tolerance();
}
-//=======================================================================
-// function : ParameterOnLine
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real TopOpeBRep_VPointInter::ParameterOnLine() const
{
return myPPOI->ParameterOnLine();
}
-//=======================================================================
-// function : ParameterOnArc1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real TopOpeBRep_VPointInter::ParameterOnArc1() const
{
return myPPOI->ParameterOnArc1();
}
-//=======================================================================
-// function : ParameterOnArc2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real TopOpeBRep_VPointInter::ParameterOnArc2() const
{
return myPPOI->ParameterOnArc2();
}
-//=======================================================================
-// function : IsVertexOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRep_VPointInter::IsVertexOnS1() const
{
return myPPOI->IsVertexOnS1();
}
-//=======================================================================
-// function : IsVertexOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRep_VPointInter::IsVertexOnS2() const
{
return myPPOI->IsVertexOnS2();
}
-//=======================================================================
-// function : IsMultiple
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRep_VPointInter::IsMultiple() const
{
return myPPOI->IsMultiple();
}
-//=======================================================================
-// function : IsInternal
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRep_VPointInter::IsInternal() const
{
return Standard_False;
}
-//=======================================================================
-// function : ShapeIndex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer TopOpeBRep_VPointInter::ShapeIndex() const
{
return myShapeIndex;
}
-//=======================================================================
-// function : ShapeIndex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopOpeBRep_VPointInter::ShapeIndex(const Standard_Integer I)
{
myShapeIndex = I;
}
-//=======================================================================
-// function : Keep
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRep_VPointInter::Keep() const
{
return myKeep;
}
-//=======================================================================
-// function : ChangeKeep
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopOpeBRep_VPointInter::ChangeKeep(const Standard_Boolean keep)
{
myKeep = keep;
}
-//=======================================================================
-// function : Index
-// purpose : trace
-//=======================================================================
+//=================================================================================================
inline void TopOpeBRep_VPointInter::Index(const Standard_Integer I)
{
myIndex = I;
}
-//=======================================================================
-// function : Index
-// purpose : trace
-//=======================================================================
+//=================================================================================================
inline Standard_Integer TopOpeBRep_VPointInter::Index() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Initialize
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopOpeBRepBuild_BlockIterator::Initialize()
{
myValue = myLower;
}
-//=======================================================================
-// function : More
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRepBuild_BlockIterator::More() const
{
return b;
}
-//=======================================================================
-// function : Next
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopOpeBRepBuild_BlockIterator::Next()
{
myValue++;
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer TopOpeBRepBuild_BlockIterator::Value() const
{
return myValue;
}
-//=======================================================================
-// function : Extent
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer TopOpeBRepBuild_BlockIterator::Extent() const
{
#include <StdFail_NotDone.hxx>
-//=======================================================================
-// function : TopOpeBRepBuild_FuseFace
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopOpeBRepBuild_FuseFace::TopOpeBRepBuild_FuseFace()
: myInternal(Standard_False),
{
}
-//=======================================================================
-// function : TopOpeBRepBuild_FuseFace
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopOpeBRepBuild_FuseFace::TopOpeBRepBuild_FuseFace(const TopTools_ListOfShape& LIF,
const TopTools_ListOfShape& LRF,
Init(LIF, LRF, CXM);
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRepBuild_FuseFace::IsDone() const
{
return myDone;
}
-//=======================================================================
-// function : IsModified
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopOpeBRepBuild_FuseFace::IsModified() const
{
return myModified;
}
-//=======================================================================
-// function : ListOfFusionnedFaces
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& TopOpeBRepBuild_FuseFace::LFuseFace() const
{
return myLFF;
}
-//=======================================================================
-// function : ListOfInternalEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& TopOpeBRepBuild_FuseFace::LInternEdge() const
{
return myLIE;
}
-//=======================================================================
-// function : ListOfExternalEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& TopOpeBRepBuild_FuseFace::LExternEdge() const
{
return myLEE;
}
-//=======================================================================
-// function : ListOfModifiedEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& TopOpeBRepBuild_FuseFace::LModifEdge() const
{
return myLME;
}
-//=======================================================================
-// function : ListOfInternalVertex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& TopOpeBRepBuild_FuseFace::LInternVertex() const
{
return myLIV;
}
-//=======================================================================
-// function : ListOfExternalVertex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& TopOpeBRepBuild_FuseFace::LExternVertex() const
{
return myLEV;
}
-//=======================================================================
-// function : ListOfModifiedVertex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& TopOpeBRepBuild_FuseFace::LModifVertex() const
{
return Standard_True;
}
-//=======================================================================
-// variable : Standard_EXPORT TopOpeBRepDS_PDataStructure GLOBAL_DS2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_EXPORT TopOpeBRepDS_PDataStructure GLOBAL_DS2d = NULL;
//=================================================================================================
if (isfafa)
newO = Standard_False; // xpu110598
- // if (fus) : faces are SDSO : we keep original edge's orientation
- // if (com) : faces are SDSO : we keep original edge's orientation
- // if (cut && TBToFill==OUT) : myFaceToFill is the reference face,
- // we keep original edge's orientation
+ // if (fus) : faces are SDSO : we keep original edge's orientation
+ // if (com) : faces are SDSO : we keep original edge's orientation
+ // if (cut && TBToFill==OUT) : myFaceToFill is the reference face,
+ // we keep original edge's orientation
#ifdef OCCT_DEBUG
Standard_Integer iEOR;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : BRepFeatForm
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_Form::BRepFeat_Form()
: myFuse(Standard_False),
{
}
-//=======================================================================
-// function : BasisShapeValid
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_Form::BasisShapeValid()
{
mySbOK = Standard_True;
}
-//=======================================================================
-// function : PerfSelectionValid
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_Form::PerfSelectionValid()
{
myPSOK = Standard_True;
}
-//=======================================================================
-// function : GeneratedShapeValid
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_Form::GeneratedShapeValid()
{
myGSOK = Standard_True;
}
-//=======================================================================
-// function : ShapeFromValid
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_Form::ShapeFromValid()
{
mySFOK = Standard_True;
}
-//=======================================================================
-// function : ShapeUntilValid
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_Form::ShapeUntilValid()
{
mySUOK = Standard_True;
}
-//=======================================================================
-// function : GluedFacesValid
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_Form::GluedFacesValid()
{
myGFOK = Standard_True;
}
-//=======================================================================
-// function : SketchFaceValid
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_Form::SketchFaceValid()
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : BRepFeat_Gluer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_Gluer::BRepFeat_Gluer() {}
-//=======================================================================
-// function : BRepFeat_Gluer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_Gluer::BRepFeat_Gluer(const TopoDS_Shape& Snew, const TopoDS_Shape& Sbase)
: myGluer(Sbase, Snew) // Attention a l`inversion
{
}
-//=======================================================================
-// function : Init
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_Gluer::Init(const TopoDS_Shape& Snew, const TopoDS_Shape& Sbase)
{
myGluer.Init(Sbase, Snew);
}
-//=======================================================================
-// function : Bind
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_Gluer::Bind(const TopoDS_Face& Fnew, const TopoDS_Face& Fbase)
{
myGluer.Bind(Fnew, Fbase);
}
-//=======================================================================
-// function : Bind
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_Gluer::Bind(const TopoDS_Edge& Enew, const TopoDS_Edge& Ebase)
{
myGluer.Bind(Enew, Ebase);
}
-//=======================================================================
-// function : OpeType
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_Operation BRepFeat_Gluer::OpeType() const
{
return myGluer.OpeType();
}
-//=======================================================================
-// function : BasisShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& BRepFeat_Gluer::BasisShape() const
{
return myGluer.BasisShape();
}
-//=======================================================================
-// function : GluedShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& BRepFeat_Gluer::GluedShape() const
{
// Modified by jag, Tue May 30 09:47:02 1995
-//=======================================================================
-// function : BRepFeat_MakeCylindricalHole
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_MakeCylindricalHole::BRepFeat_MakeCylindricalHole()
: myAxDef(Standard_False),
{
}
-//=======================================================================
-// function : Init
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_MakeCylindricalHole::Init(const gp_Ax1& Axis)
{
myAxDef = Standard_True;
}
-//=======================================================================
-// function : Init
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_MakeCylindricalHole::Init(const TopoDS_Shape& S, const gp_Ax1& Axis)
{
myAxDef = Standard_True;
}
-//=======================================================================
-// function : Status
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_Status BRepFeat_MakeCylindricalHole::Status() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : BRepFeat_MakeLinearForm
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_MakeLinearForm::BRepFeat_MakeLinearForm()
: myBnd(0.0),
{
}
-//=======================================================================
-// function : BRepFeat_MakePrism
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_MakeLinearForm::BRepFeat_MakeLinearForm(const TopoDS_Shape& Sbase,
const TopoDS_Wire& W,
#endif
}
-//=======================================================================
-// function : Add
-// purpose : add faces of gluing
-//=======================================================================
+//=================================================================================================
void BRepFeat_MakePipe::Add(const TopoDS_Edge& E, const TopoDS_Face& F)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : BRepFeat_MakePipe
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_MakePipe::BRepFeat_MakePipe() {}
-//=======================================================================
-// function : BRepFeat_MakePipe
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_MakePipe::BRepFeat_MakePipe(const TopoDS_Shape& Sbase,
const TopoDS_Shape& Pbase,
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : BRepFeat_MakePrism
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_MakePrism::BRepFeat_MakePrism()
: myStatusError(BRepFeat_OK)
{
}
-//=======================================================================
-// function : BRepFeat_MakePrism
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_MakePrism::BRepFeat_MakePrism(const TopoDS_Shape& Sbase,
const TopoDS_Shape& Pbase,
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : BRepFeat_MakeRevol
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_MakeRevol::BRepFeat_MakeRevol()
: myStatusError(BRepFeat_OK)
{
}
-//=======================================================================
-// function : BRepFeat_MakeRevol
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_MakeRevol::BRepFeat_MakeRevol(const TopoDS_Shape& Sbase,
const TopoDS_Shape& Pbase,
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : BRepFeat_MakeLinearForm
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_MakeRevolutionForm::BRepFeat_MakeRevolutionForm()
: myHeight1(0.0),
{
}
-//=======================================================================
-// function : BRepFeat_MakePrism
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_MakeRevolutionForm::BRepFeat_MakeRevolutionForm(const TopoDS_Shape& Sbase,
const TopoDS_Wire& W,
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : BRepFeatForm
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_RibSlot::BRepFeat_RibSlot()
: myFuse(Standard_False),
#include <LocOpe_WiresOnShape.hxx>
-//=======================================================================
-// function : BRepFeat_SplitShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_SplitShape::BRepFeat_SplitShape() {}
-//=======================================================================
-// function : BRepFeat_SplitShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepFeat_SplitShape::BRepFeat_SplitShape(const TopoDS_Shape& S)
: mySShape(S)
myWOnShape = new LocOpe_WiresOnShape(S);
}
-//=======================================================================
-// function : Add
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BRepFeat_SplitShape::Add(const TopTools_SequenceOfShape& theEdges)
{
return myWOnShape->Add(theEdges);
}
-//=======================================================================
-// function : Init
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_SplitShape::Init(const TopoDS_Shape& S)
{
}
}
-//=======================================================================
-// function : SetCheckInterior
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_SplitShape::SetCheckInterior(const Standard_Boolean ToCheckInterior)
{
myWOnShape->SetCheckInterior(ToCheckInterior);
}
-//=======================================================================
-// function : Add
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_SplitShape::Add(const TopoDS_Wire& W, const TopoDS_Face& F)
{
myWOnShape->Bind(W, F);
}
-//=======================================================================
-// function : Add
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_SplitShape::Add(const TopoDS_Edge& E, const TopoDS_Face& F)
{
myWOnShape->Bind(E, F);
}
-//=======================================================================
-// function : Add
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_SplitShape::Add(const TopoDS_Compound& Comp, const TopoDS_Face& F)
{
myWOnShape->Bind(Comp, F);
}
-//=======================================================================
-// function : Add
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepFeat_SplitShape::Add(const TopoDS_Edge& E, const TopoDS_Edge& EOn)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : LocOpe_BuildShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_BuildShape::LocOpe_BuildShape() {}
-//=======================================================================
-// function : LocOpe_BuildShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_BuildShape::LocOpe_BuildShape(const TopTools_ListOfShape& L)
{
Perform(L);
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_BuildShape::Shape() const
{
#include <StdFail_NotDone.hxx>
-//=======================================================================
-// function : LocOpe_CSIntersector
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_CSIntersector::LocOpe_CSIntersector()
: myDone(Standard_False),
{
}
-//=======================================================================
-// function : LocOpe_CSIntersector
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_CSIntersector::LocOpe_CSIntersector(const TopoDS_Shape& S)
: myDone(Standard_False),
{
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean LocOpe_CSIntersector::IsDone() const
{
#include <StdFail_NotDone.hxx>
-//=======================================================================
-// function : LocOpe_CurveShapeIntersector
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_CurveShapeIntersector::LocOpe_CurveShapeIntersector()
: myDone(Standard_False)
{
}
-//=======================================================================
-// function : LocOpe_CurveShapeIntersector
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_CurveShapeIntersector::LocOpe_CurveShapeIntersector(const gp_Ax1& Axis,
const TopoDS_Shape& S)
Init(Axis, S);
}
-//=======================================================================
-// function : LocOpe_CurveShapeIntersector
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_CurveShapeIntersector::LocOpe_CurveShapeIntersector(const gp_Circ& C,
const TopoDS_Shape& S)
Init(C, S);
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean LocOpe_CurveShapeIntersector::IsDone() const
{
return myDone;
}
-//=======================================================================
-// function : NbPoints
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer LocOpe_CurveShapeIntersector::NbPoints() const
{
return myPoints.Length();
}
-//=======================================================================
-// function : Point
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const LocOpe_PntFace& LocOpe_CurveShapeIntersector::Point(const Standard_Integer I) const
{
#include <TopoDS.hxx>
-//=======================================================================
-// function : LocOpe_FindEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_FindEdges::LocOpe_FindEdges() {}
-//=======================================================================
-// function : LocOpe_FindEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_FindEdges::LocOpe_FindEdges(const TopoDS_Shape& FFrom, const TopoDS_Shape& FTo)
{
Set(FFrom, FTo);
}
-//=======================================================================
-// function : InitIterator
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void LocOpe_FindEdges::InitIterator()
{
myItTo.Initialize(myLTo);
}
-//=======================================================================
-// function : More
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean LocOpe_FindEdges::More() const
{
return myItFrom.More();
}
-//=======================================================================
-// function : EdgeFrom
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Edge& LocOpe_FindEdges::EdgeFrom() const
{
return TopoDS::Edge(myItFrom.Value());
}
-//=======================================================================
-// function : EdgeTo
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Edge& LocOpe_FindEdges::EdgeTo() const
{
return TopoDS::Edge(myItTo.Value());
}
-//=======================================================================
-// function : Next
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void LocOpe_FindEdges::Next()
{
#include <TopoDS.hxx>
-//=======================================================================
-// function : LocOpe_FindEdgesInFace
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_FindEdgesInFace::LocOpe_FindEdgesInFace() {}
-//=======================================================================
-// function : LocOpe_FindEdgesInFace
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_FindEdgesInFace::LocOpe_FindEdgesInFace(const TopoDS_Shape& S, const TopoDS_Face& F)
{
Set(S, F);
}
-//=======================================================================
-// function : Init
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void LocOpe_FindEdgesInFace::Init()
{
myIt.Initialize(myList);
}
-//=======================================================================
-// function : More
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean LocOpe_FindEdgesInFace::More() const
{
return myIt.More();
}
-//=======================================================================
-// function : Edge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Edge& LocOpe_FindEdgesInFace::Edge() const
{
return TopoDS::Edge(myIt.Value());
}
-//=======================================================================
-// function : Next
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void LocOpe_FindEdgesInFace::Next()
{
#include <StdFail_NotDone.hxx>
-//=======================================================================
-// function : LocOpe_Generator
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_Generator::LocOpe_Generator()
: myDone(Standard_False)
{
}
-//=======================================================================
-// function : LocOpe_Generator
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_Generator::LocOpe_Generator(const TopoDS_Shape& S)
: myShape(S),
{
}
-//=======================================================================
-// function : Init
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void LocOpe_Generator::Init(const TopoDS_Shape& S)
{
myDone = Standard_False;
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean LocOpe_Generator::IsDone() const
{
return myDone;
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_Generator::Shape() const
{
return myShape;
}
-//=======================================================================
-// function : ResultingShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_Generator::ResultingShape() const
{
#include <StdFail_NotDone.hxx>
-//=======================================================================
-// function : LocOpe_Gluer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_Gluer::LocOpe_Gluer()
: myDone(Standard_False),
{
}
-//=======================================================================
-// function : LocOpe_Gluer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_Gluer::LocOpe_Gluer(const TopoDS_Shape& Sbase, const TopoDS_Shape& Snew)
: myDone(Standard_False),
{
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean LocOpe_Gluer::IsDone() const
{
return myDone;
}
-//=======================================================================
-// function : ResultingShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_Gluer::ResultingShape() const
{
return myRes;
}
-//=======================================================================
-// function : BasisShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_Gluer::BasisShape() const
{
return mySb;
}
-//=======================================================================
-// function : GluedShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_Gluer::GluedShape() const
{
return mySn;
}
-//=======================================================================
-// function : OpeType
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_Operation LocOpe_Gluer::OpeType() const
{
return myOpe;
}
-//=======================================================================
-// function : Edges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& LocOpe_Gluer::Edges() const
{
return myEdges;
}
-//=======================================================================
-// function : TgtEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& LocOpe_Gluer::TgtEdges() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : LocOpe_LinearForm
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_LinearForm::LocOpe_LinearForm()
: myDone(Standard_False),
{
}
-//=======================================================================
-// function : LocOpe_LinearForm
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_LinearForm::LocOpe_LinearForm(const TopoDS_Shape& Base,
const gp_Vec& V,
Perform(Base, V, Pnt1, Pnt2);
}
-//=======================================================================
-// function : LocOpe_LinearForm
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_LinearForm::LocOpe_LinearForm(const TopoDS_Shape& Base,
const gp_Vec& V,
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Spine
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_Pipe::Spine() const
{
return myPipe.Spine();
}
-//=======================================================================
-// function : Profile
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_Pipe::Profile() const
{
return myPipe.Profile();
}
-//=======================================================================
-// function : FirstShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_Pipe::FirstShape() const
{
return myPipe.FirstShape();
}
-//=======================================================================
-// function : LastShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_Pipe::LastShape() const
{
#include <StdFail_NotDone.hxx>
-//=======================================================================
-// function : LocOpe_SplitShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_SplitShape::LocOpe_SplitShape()
: myDone(Standard_False)
{
}
-//=======================================================================
-// function : LocOpe_SplitShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_SplitShape::LocOpe_SplitShape(const TopoDS_Shape& S)
{
Init(S);
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_SplitShape::Shape() const
{
#include <StdFail_NotDone.hxx>
-//=======================================================================
-// function : LocOpe_Spliter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_Spliter::LocOpe_Spliter()
: myDone(Standard_False)
{
}
-//=======================================================================
-// function : LocOpe_Spliter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline LocOpe_Spliter::LocOpe_Spliter(const TopoDS_Shape& S)
: myShape(S),
{
}
-//=======================================================================
-// function : Init
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void LocOpe_Spliter::Init(const TopoDS_Shape& S)
{
myDone = Standard_False;
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean LocOpe_Spliter::IsDone() const
{
return myDone;
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_Spliter::Shape() const
{
return myShape;
}
-//=======================================================================
-// function : ResultingShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& LocOpe_Spliter::ResultingShape() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetCheckInterior
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void LocOpe_WiresOnShape::SetCheckInterior(const Standard_Boolean ToCheckInterior)
{
myCheckInterior = ToCheckInterior;
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean LocOpe_WiresOnShape::IsDone() const
{
return myDone;
}
-//=======================================================================
-// function : IsFaceWithSection
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean LocOpe_WiresOnShape::IsFaceWithSection(const TopoDS_Shape& aFace) const
{
return Standard_False;
}
-//=======================================================================
-// function : Recadre2
-// purpose : Contact lost on Rst2
-//=======================================================================
+//=================================================================================================
Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre2(Blend_RstRstFunction& Func,
Blend_SurfCurvFuncInv& Finv,
#include <StdFail_NotDone.hxx>
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBlend_RstRstLineBuilder::IsDone() const
{
return done;
}
-//=======================================================================
-// function : Line
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(BRepBlend_Line)& BRepBlend_RstRstLineBuilder::Line() const
{
return line;
}
-//=======================================================================
-// function : Decroch1Start
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBlend_RstRstLineBuilder::Decroch1Start() const
{
return Standard_False;
}
-//=======================================================================
-// function : Decroch1End
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBlend_RstRstLineBuilder::Decroch1End() const
{
return Standard_False;
}
-//=======================================================================
-// function : Decroch2Start
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBlend_RstRstLineBuilder::Decroch2Start() const
{
return Standard_False;
}
-//=======================================================================
-// function : Decroch2End
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBlend_RstRstLineBuilder::Decroch2End() const
{
#include <StdFail_NotDone.hxx>
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBlend_SurfRstLineBuilder::IsDone() const
{
return done;
}
-//=======================================================================
-// function : Line
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(BRepBlend_Line)& BRepBlend_SurfRstLineBuilder::Line() const
{
return line;
}
-//=======================================================================
-// function : DecrochStart
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBlend_SurfRstLineBuilder::DecrochStart() const
{
return decrochdeb;
}
-//=======================================================================
-// function : DecrochEnd
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBlend_SurfRstLineBuilder::DecrochEnd() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : IsModified
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepFilletAPI_MakeFillet2d::IsModified(const TopoDS_Edge& E) const
{
return myMakeChFi2d.IsModified(E);
}
-//=======================================================================
-// function : FilletEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_SequenceOfShape& BRepFilletAPI_MakeFillet2d::FilletEdges() const
{
return myMakeChFi2d.FilletEdges();
}
-//=======================================================================
-// function : NbFillet
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer BRepFilletAPI_MakeFillet2d::NbFillet() const
{
return myMakeChFi2d.NbFillet();
}
-//=======================================================================
-// function : ChamferEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_SequenceOfShape& BRepFilletAPI_MakeFillet2d::ChamferEdges() const
{
return myMakeChFi2d.ChamferEdges();
}
-//=======================================================================
-// function : NbChamfer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer BRepFilletAPI_MakeFillet2d::NbChamfer() const
{
return myMakeChFi2d.NbChamfer();
}
-//=======================================================================
-// function : HasDescendant
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepFilletAPI_MakeFillet2d::HasDescendant(const TopoDS_Edge& E) const
{
return myMakeChFi2d.HasDescendant(E);
}
-//=======================================================================
-// function : DescendantEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Edge& BRepFilletAPI_MakeFillet2d::DescendantEdge(const TopoDS_Edge& E) const
{
return myMakeChFi2d.DescendantEdge(E);
}
-//=======================================================================
-// function : Status
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFi2d_ConstructionError BRepFilletAPI_MakeFillet2d::Status() const
{
#include <TopoDS_Wire.hxx>
#include <TopoDS_Face.hxx>
-//=======================================================================
-// function : Result
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Face ChFi2d_Builder::Result() const
{
return aFace;
}
-//=======================================================================
-// function : IsModified
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ChFi2d_Builder::IsModified(const TopoDS_Edge& E) const
{
return history.IsBound(E);
}
-//=======================================================================
-// function : FilletEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_SequenceOfShape& ChFi2d_Builder::FilletEdges() const
{
return fillets;
}
-//=======================================================================
-// function : ChamferEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_SequenceOfShape& ChFi2d_Builder::ChamferEdges() const
{
return chamfers;
}
-//=======================================================================
-// function : NbFillet
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFi2d_Builder::NbFillet() const
{
return fillets.Length();
}
-//=======================================================================
-// function : NbChamfer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFi2d_Builder::NbChamfer() const
{
return chamfers.Length();
}
-//=======================================================================
-// function : HasDescendant
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ChFi2d_Builder::HasDescendant(const TopoDS_Edge& E) const
{
return history.IsBound(E);
}
-//=======================================================================
-// function : DescendantEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Edge& ChFi2d_Builder::DescendantEdge(const TopoDS_Edge& E) const
{
return TopoDS::Edge(history.Find(E));
} // DescendantEdge
-//=======================================================================
-// function : Status
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFi2d_ConstructionError ChFi2d_Builder::Status() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetInterference
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_FaceInterference::SetInterference(const Standard_Integer LineIndex,
const TopAbs_Orientation Trans,
pCurveOnSurf = PCurv2;
}
-//=======================================================================
-// function : SetLineIndex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_FaceInterference::SetLineIndex(const Standard_Integer I)
{
lineindex = I;
}
-//=======================================================================
-// function : SetFirstParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_FaceInterference::SetFirstParameter(const Standard_Real U1)
{
firstParam = U1;
}
-//=======================================================================
-// function : SetLastParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_FaceInterference::SetLastParameter(const Standard_Real U1)
{
lastParam = U1;
}
-//=======================================================================
-// function : LineIndex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_FaceInterference::LineIndex() const
{
return lineindex;
}
-//=======================================================================
-// function : Transition
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation ChFiDS_FaceInterference::Transition() const
{
return LineTransition;
}
-//=======================================================================
-// function : PCurveOnFace
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Geom2d_Curve)& ChFiDS_FaceInterference::PCurveOnFace() const
{
return pCurveOnFace;
}
-//=======================================================================
-// function : PCurveOnSurf
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Geom2d_Curve)& ChFiDS_FaceInterference::PCurveOnSurf() const
{
return pCurveOnSurf;
}
-//=======================================================================
-// function : ChangePCurveOnFace
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Geom2d_Curve)& ChFiDS_FaceInterference::ChangePCurveOnFace()
{
return pCurveOnFace;
}
-//=======================================================================
-// function : ChangePCurveOnSurf
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Geom2d_Curve)& ChFiDS_FaceInterference::ChangePCurveOnSurf()
{
return pCurveOnSurf;
}
-//=======================================================================
-// function : FirstParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ChFiDS_FaceInterference::FirstParameter() const
{
return firstParam;
}
-//=======================================================================
-// function : LastParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ChFiDS_FaceInterference::LastParameter() const
{
#include <TopoDS.hxx>
-//=======================================================================
-// function : SetTypeOfConcavity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Spine::SetTypeOfConcavity(const ChFiDS_TypeOfConcavity theType)
{
myTypeOfConcavity = theType;
}
-//=======================================================================
-// function : SetFirstStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Spine::SetFirstStatus(const ChFiDS_State S)
{
firstState = S;
}
-//=======================================================================
-// function : SetLastStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Spine::SetLastStatus(const ChFiDS_State S)
{
lastState = S;
}
-//=======================================================================
-// function : GetTypeOfConcavity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFiDS_TypeOfConcavity ChFiDS_Spine::GetTypeOfConcavity() const
{
return myTypeOfConcavity;
}
-//=======================================================================
-// function : FirstStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFiDS_State ChFiDS_Spine::FirstStatus() const
{
return firstState;
}
-//=======================================================================
-// function : LastStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFiDS_State ChFiDS_Spine::LastStatus() const
{
return lastState;
}
-//=======================================================================
-// function : SetStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Spine::SetStatus(const ChFiDS_State S, const Standard_Boolean IsFirst)
{
lastState = S;
}
-//=======================================================================
-// function : Status
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFiDS_State ChFiDS_Spine::Status(const Standard_Boolean IsFirst) const
{
return lastState;
}
-//=======================================================================
-// function : SetTangencyExtremity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Spine::SetTangencyExtremity(const Standard_Boolean IsTangency,
const Standard_Boolean IsFirst)
lastistgt = IsTangency;
}
-//=======================================================================
-// function : IsTangencyExtremity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ChFiDS_Spine::IsTangencyExtremity(const Standard_Boolean IsFirst) const
{
return lastistgt;
}
-//=======================================================================
-// function : NbEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_Spine::NbEdges() const
{
return spine.Length();
}
-//=======================================================================
-// function : Edges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Edge& ChFiDS_Spine::Edges(const Standard_Integer I) const
{
return TopoDS::Edge(spine.Value(I));
}
-//=======================================================================
-// function : OffsetEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Edge& ChFiDS_Spine::OffsetEdges(const Standard_Integer I) const
{
return TopoDS::Edge(offsetspine.Value(I));
}
-//=======================================================================
-// function : SetEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Spine::SetEdges(const TopoDS_Edge& E)
{
spine.Append(E);
}
-//=======================================================================
-// function : SetOffsetEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Spine::SetOffsetEdges(const TopoDS_Edge& E)
{
offsetspine.Append(E);
}
-//=======================================================================
-// function : PutInFirst
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Spine::PutInFirst(const TopoDS_Edge& E)
{
spine.InsertBefore(1, E);
}
-//=======================================================================
-// function : PutInFirstOffset
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Spine::PutInFirstOffset(const TopoDS_Edge& E)
{
offsetspine.InsertBefore(1, E);
}
-//=======================================================================
-// function : CurrentIndexOfElementarySpine
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer ChFiDS_Spine::CurrentIndexOfElementarySpine() const
{
return indexofcurve;
}
-//=======================================================================
-// function : Mode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFiDS_ChamfMode ChFiDS_Spine::Mode() const
{
return myMode;
}
-//=======================================================================
-// function : GetTolesp
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real ChFiDS_Spine::GetTolesp() const
{
return tolesp;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetOfSurfData
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(ChFiDS_HData)& ChFiDS_Stripe::SetOfSurfData() const
{
return myHdata;
}
-//=======================================================================
-// function : Spine
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(ChFiDS_Spine)& ChFiDS_Stripe::Spine() const
{
return mySpine;
}
-//=======================================================================
-// function : OrientationOnFace1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation ChFiDS_Stripe::OrientationOnFace1() const
{
return myOr1;
}
-//=======================================================================
-// function : OrientationOnFace2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation ChFiDS_Stripe::OrientationOnFace2() const
{
return myOr2;
}
-//=======================================================================
-// function : Choix
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_Stripe::Choix() const
{
return myChoix;
}
-//=======================================================================
-// function : ChangeSetOfSurfData
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ChFiDS_HData)& ChFiDS_Stripe::ChangeSetOfSurfData()
{
return myHdata;
}
-//=======================================================================
-// function : ChangeSpine
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ChFiDS_Spine)& ChFiDS_Stripe::ChangeSpine()
{
return mySpine;
}
-//=======================================================================
-// function : OrientationOnFace1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::OrientationOnFace1(const TopAbs_Orientation Or1)
{
myOr1 = Or1;
}
-//=======================================================================
-// function : OrientationOnFace2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::OrientationOnFace2(const TopAbs_Orientation Or2)
{
myOr2 = Or2;
}
-//=======================================================================
-// function : Choix
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::Choix(const Standard_Integer C)
{
myChoix = C;
}
-//=======================================================================
-// function : FirstParameters
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::FirstParameters(Standard_Real& Pdeb, Standard_Real& Pfin) const
{
Pfin = parfin1;
}
-//=======================================================================
-// function : lastParameters
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::LastParameters(Standard_Real& Pdeb, Standard_Real& Pfin) const
{
Pfin = parfin2;
}
-//=======================================================================
-// function : ChangeFirstParameters
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::ChangeFirstParameters(const Standard_Real Pdeb, const Standard_Real Pfin)
{
parfin1 = Pfin;
}
-//=======================================================================
-// function : ChangeLastParameters
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::ChangeLastParameters(const Standard_Real Pdeb, const Standard_Real Pfin)
{
parfin2 = Pfin;
}
-//=======================================================================
-// function : FirstCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_Stripe::FirstCurve() const
{
return indexOfcurve1;
}
-//=======================================================================
-// function : LastCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_Stripe::LastCurve() const
{
return indexOfcurve2;
}
-//=======================================================================
-// function : ChangeFirstCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::ChangeFirstCurve(const Standard_Integer Index)
{
indexOfcurve1 = Index;
}
-//=======================================================================
-// function : ChangeLastCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::ChangeLastCurve(const Standard_Integer Index)
{
indexOfcurve2 = Index;
}
-//=======================================================================
-// function : FirstPCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Geom2d_Curve)& ChFiDS_Stripe::FirstPCurve() const
{
return pcrv1;
}
-//=======================================================================
-// function : LastPCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Geom2d_Curve)& ChFiDS_Stripe::LastPCurve() const
{
return pcrv2;
}
-//=======================================================================
-// function : ChangeFirstPCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Geom2d_Curve)& ChFiDS_Stripe::ChangeFirstPCurve()
{
return pcrv1;
}
-//=======================================================================
-// function : ChangeLastPCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Geom2d_Curve)& ChFiDS_Stripe::ChangeLastPCurve()
{
return pcrv2;
}
-//=======================================================================
-// function : IndexFirstPointOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_Stripe::IndexFirstPointOnS1() const
{
return indexfirstPOnS1;
}
-//=======================================================================
-// function : IndexLastPointOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_Stripe::IndexLastPointOnS1() const
{
return indexlastPOnS1;
}
-//=======================================================================
-// function : IndexFirstPointOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_Stripe::IndexFirstPointOnS2() const
{
return indexfirstPOnS2;
}
-//=======================================================================
-// function : IndexLastPointOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_Stripe::IndexLastPointOnS2() const
{
return indexlastPOnS2;
}
-//=======================================================================
-// function : ChangeIndexFirstPointOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::ChangeIndexFirstPointOnS1(const Standard_Integer Index)
{
indexfirstPOnS1 = Index;
}
-//=======================================================================
-// function : ChangeIndexLastPointOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::ChangeIndexLastPointOnS1(const Standard_Integer Index)
{
indexlastPOnS1 = Index;
}
-//=======================================================================
-// function : ChangeIndexFirstPointOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::ChangeIndexFirstPointOnS2(const Standard_Integer Index)
{
indexfirstPOnS2 = Index;
}
-//=======================================================================
-// function : ChangeIndexLastPointOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::ChangeIndexLastPointOnS2(const Standard_Integer Index)
{
indexlastPOnS2 = Index;
}
-//=======================================================================
-// function : FirstPCurveOrientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation ChFiDS_Stripe::FirstPCurveOrientation() const
{
return orcurv1;
}
-//=======================================================================
-// function : LastPCurveOrientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation ChFiDS_Stripe::LastPCurveOrientation() const
{
return orcurv2;
}
-//=======================================================================
-// function : FirstPCurveOrientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::FirstPCurveOrientation(const TopAbs_Orientation O)
{
orcurv1 = O;
}
-//=======================================================================
-// function : LastPCurveOrientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_Stripe::LastPCurveOrientation(const TopAbs_Orientation O)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Extent
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_StripeMap::Extent() const
{
return mymap.Extent();
}
-//=======================================================================
-// function : FindKey
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Vertex& ChFiDS_StripeMap::FindKey(const Standard_Integer I) const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : IndexOfS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_SurfData::IndexOfS1() const
{
return indexOfS1;
}
-//=======================================================================
-// function : IsOnCurve1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ChFiDS_SurfData::IsOnCurve1() const
{
return isoncurv1;
}
-//=======================================================================
-// function : IndexOfC1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_SurfData::IndexOfC1() const
{
return indexOfC1;
}
-//=======================================================================
-// function : SetIndexOfC1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_SurfData::SetIndexOfC1(const Standard_Integer theIndex)
{
isoncurv1 = (theIndex != 0);
}
-//=======================================================================
-// function : IndexOfS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_SurfData::IndexOfS2() const
{
return indexOfS2;
}
-//=======================================================================
-// function : IsOnCurve2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ChFiDS_SurfData::IsOnCurve2() const
{
return isoncurv2;
}
-//=======================================================================
-// function : IndexOfC2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_SurfData::IndexOfC2() const
{
return indexOfC2;
}
-//=======================================================================
-// function : SetIndexOfC2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_SurfData::SetIndexOfC2(const Standard_Integer theIndex)
{
isoncurv2 = (theIndex != 0);
}
-//=======================================================================
-// function : Surf
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_SurfData::Surf() const
{
return indexOfConge;
}
-//=======================================================================
-// function : Orientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation ChFiDS_SurfData::Orientation() const
{
return orientation;
}
-//=======================================================================
-// function : InterferenceOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const ChFiDS_FaceInterference& ChFiDS_SurfData::InterferenceOnS1() const
{
return intf1;
}
-//=======================================================================
-// function : InterferenceOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const ChFiDS_FaceInterference& ChFiDS_SurfData::InterferenceOnS2() const
{
return intf2;
}
-//=======================================================================
-// function : VertexFirstOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const ChFiDS_CommonPoint& ChFiDS_SurfData::VertexFirstOnS1() const
{
return pfirstOnS1;
}
-//=======================================================================
-// function : VertexLastOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const ChFiDS_CommonPoint& ChFiDS_SurfData::VertexLastOnS1() const
{
return plastOnS1;
}
-//=======================================================================
-// function : VertexFirstOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const ChFiDS_CommonPoint& ChFiDS_SurfData::VertexFirstOnS2() const
{
return pfirstOnS2;
}
-//=======================================================================
-// function : VertexLastOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const ChFiDS_CommonPoint& ChFiDS_SurfData::VertexLastOnS2() const
{
return plastOnS2;
}
-//=======================================================================
-// function : ChangeIndexOfS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_SurfData::ChangeIndexOfS1(const Standard_Integer Index)
{
indexOfS1 = Index;
}
-//=======================================================================
-// function : ChangeIndexOfS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_SurfData::ChangeIndexOfS2(const Standard_Integer Index)
{
indexOfS2 = Index;
}
-//=======================================================================
-// function : ChangeSurf
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ChFiDS_SurfData::ChangeSurf(const Standard_Integer Index)
{
indexOfConge = Index;
}
-//=======================================================================
-// function : ChangeOrientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation& ChFiDS_SurfData::ChangeOrientation()
{
return orientation;
}
-//=======================================================================
-// function : ChangeInterferenceOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFiDS_FaceInterference& ChFiDS_SurfData::ChangeInterferenceOnS1()
{
return intf1;
}
-//=======================================================================
-// function : ChangeInterferenceOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFiDS_FaceInterference& ChFiDS_SurfData::ChangeInterferenceOnS2()
{
return intf2;
}
-//=======================================================================
-// function : ChangeVertexFirstOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFiDS_CommonPoint& ChFiDS_SurfData::ChangeVertexFirstOnS1()
{
return pfirstOnS1;
}
-//=======================================================================
-// function : ChangeVertexLastOnS1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFiDS_CommonPoint& ChFiDS_SurfData::ChangeVertexLastOnS1()
{
return plastOnS1;
}
-//=======================================================================
-// function : ChangeVertexFirstOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFiDS_CommonPoint& ChFiDS_SurfData::ChangeVertexFirstOnS2()
{
return pfirstOnS2;
}
-//=======================================================================
-// function : ChangeVertexLastOnS2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFiDS_CommonPoint& ChFiDS_SurfData::ChangeVertexLastOnS2()
{
return plastOnS2;
}
-//=======================================================================
-// function : IsOnCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ChFiDS_SurfData::IsOnCurve(const Standard_Integer OnS) const
{
return isoncurv2;
}
-//=======================================================================
-// function : IndexOfC
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ChFiDS_SurfData::IndexOfC(const Standard_Integer OnS) const
{
return indexOfC2;
}
-//=======================================================================
-// function : Twist
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ChFiDS_SurfData::TwistOnS1() const
{
// --- keep pipe parametrized like path
-//=======================================================================
-//function : AppBlend_AppSurf
-//purpose :
-//=======================================================================
+//=================================================================================================
+
AppBlend_AppSurf::AppBlend_AppSurf ()
: done(Standard_False),
}
-//=======================================================================
-//function : AppBlend_AppSurf
-//purpose :
-//=======================================================================
+//=================================================================================================
+
AppBlend_AppSurf::AppBlend_AppSurf (const Standard_Integer Degmin,
const Standard_Integer Degmax,
critweights[2]=0.4;
}
-//=======================================================================
-//function : Init
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void AppBlend_AppSurf::Init (const Standard_Integer Degmin,
const Standard_Integer Degmax,
W2 = critweights[1];
W3 = critweights[2] ;
}
-//=======================================================================
-//function : SetCriteriumWeight
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void AppBlend_AppSurf::SetCriteriumWeight(const Standard_Real W1, const Standard_Real W2, const Standard_Real W3)
{
critweights[1] = W2;
critweights[2] = W3;
}
-//=======================================================================
-//function : SetContinuity
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void AppBlend_AppSurf::SetContinuity (const GeomAbs_Shape TheCont)
{
continuity = TheCont;
}
-//=======================================================================
-//function : Continuity
-//purpose :
-//=======================================================================
+//=================================================================================================
+
GeomAbs_Shape AppBlend_AppSurf::Continuity () const
{
return continuity;
}
-//=======================================================================
-//function : SetParType
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void AppBlend_AppSurf::SetParType (const Approx_ParametrizationType ParType)
{
paramtype = ParType;
}
-//=======================================================================
-//function : ParType
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Approx_ParametrizationType AppBlend_AppSurf::ParType () const
{
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void AppBlend_AppSurf::Perform(const Handle(TheLine)& Lin,
TheSectionGenerator& F,
InternalPerform(Lin, F, SpApprox, Standard_False);
}
-//=======================================================================
-//function : PerformSmoothing
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void AppBlend_AppSurf::PerformSmoothing(const Handle(TheLine)& Lin,
TheSectionGenerator& F)
InternalPerform(Lin, F, Standard_True, Standard_True);
}
-//=======================================================================
-//function : InternalPerform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void AppBlend_AppSurf::InternalPerform(const Handle(TheLine)& Lin,
TheSectionGenerator& F,
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void AppBlend_AppSurf::Perform(const Handle(TheLine)& Lin,
TheSectionGenerator& F,
}
-//=======================================================================
-//function : SurfShape
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void AppBlend_AppSurf::SurfShape (Standard_Integer& UDegree,
Standard_Integer& VDegree,
TVMults = tabVMults->Array1();
}
-//=======================================================================
-//function : Curves2dShape
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void AppBlend_AppSurf::Curves2dShape(Standard_Integer& Degree,
Standard_Integer& NbPoles,
NbKnots = tabVKnots->Length();
}
-//=======================================================================
-//function : Curve2d
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void AppBlend_AppSurf::Curve2d(const Standard_Integer Index,
TColgp_Array1OfPnt2d& TPoles,
TMults = tabVMults->Array1();
}
-//=======================================================================
-//function : TolCurveOnSurf
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Real AppBlend_AppSurf::TolCurveOnSurf(const Standard_Integer) const
{
#include <DrawTrSurf.hxx>
#endif
-//=======================================================================
-//function : Constructor
-//purpose :
-//=======================================================================
+//=================================================================================================
+
ApproxInt_MultiLine::ApproxInt_MultiLine()
{
PtrOnmySvSurfaces = NULL;
V2o = 0.;
}
-//=======================================================================
-//function : Constructor
-//purpose :
-//=======================================================================
+//=================================================================================================
+
ApproxInt_MultiLine::
ApproxInt_MultiLine(const Handle_TheLine& line,
const Standard_Address svsurf,
#endif
}
-//=======================================================================
-//function : Constructor
-//purpose :
-//=======================================================================
+//=================================================================================================
+
ApproxInt_MultiLine::
ApproxInt_MultiLine(const Handle_TheLine& line,
const Standard_Integer NbP3d,
TabPnt(1).SetCoord(aP.X()+Xo, aP.Y()+Yo, aP.Z()+Zo);
}
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void ApproxInt_MultiLine::Value(const Standard_Integer Index,
TColgp_Array1OfPnt2d& TabPnt2d) const
{
}
}
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void ApproxInt_MultiLine::Value(const Standard_Integer Index,
TColgp_Array1OfPnt& TabPnt,
TColgp_Array1OfPnt2d& TabPnt2d) const
Value(Index, TabPnt2d);
}
-//=======================================================================
-//function : Tangency
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean ApproxInt_MultiLine::Tangency( const Standard_Integer Index,
TColgp_Array1OfVec& TabVec) const
{
return ret;
}
-//=======================================================================
-//function : Tangency
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean ApproxInt_MultiLine::Tangency( const Standard_Integer Index,
TColgp_Array1OfVec2d& TabVec2d) const
{
return ret;
}
-//=======================================================================
-//function : Tangency
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean ApproxInt_MultiLine::Tangency( const Standard_Integer Index,
TColgp_Array1OfVec& TabVec,
TColgp_Array1OfVec2d& TabVec2d) const
return (Tangency(Index, TabVec) && Tangency(Index, TabVec2d));
}
-//=======================================================================
-//function : MakeMLBetween
-//purpose :
-//=======================================================================
+//=================================================================================================
+
ApproxInt_MultiLine
ApproxInt_MultiLine::MakeMLBetween( const Standard_Integer Low,
const Standard_Integer High,
}
}
-//=======================================================================
-//function : MakeMLOneMorePoint
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean
ApproxInt_MultiLine::MakeMLOneMorePoint(const Standard_Integer theLow,
const Standard_Integer theHigh,
return Standard_True;
}
-//=======================================================================
-//function : Dump
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void ApproxInt_MultiLine::Dump() const
{
TColgp_Array1OfPnt anArr1(1, 1);
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Extrema
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Extrema_ExtCC2d& Geom2dAPI_ExtremaCurveCurve::Extrema() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Intersector
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Geom2dInt_GInter& Geom2dAPI_InterCurveCurve::Intersector() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Extrema
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Extrema_ExtPC2d& Geom2dAPI_ProjectPointOnCurve::Extrema() const
{
}
}
-//=======================================================================
-// Function : KeepPoints
-// Purpose : Sets the above flag.
-//=======================================================================
+//=================================================================================================
void Geom2dHatch_Hatcher::KeepPoints(const Standard_Boolean Keep)
{
}
}
-//=======================================================================
-// Function : KeepSegments
-// Purpose : Sets the above flag.
-//=======================================================================
+//=================================================================================================
void Geom2dHatch_Hatcher::KeepSegments(const Standard_Boolean Keep)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// Function : Geom2dHatch_Intersector
-// Purpose : Constructor.
-//=======================================================================
+//=================================================================================================
inline Geom2dHatch_Intersector::Geom2dHatch_Intersector(const Standard_Real Confusion,
const Standard_Real Tangency)
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Extrema
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Extrema_ExtCC& GeomAPI_ExtremaCurveCurve::Extrema() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Extrema
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Extrema_ExtCS& GeomAPI_ExtremaCurveSurface::Extrema() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Extrema
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Extrema_ExtSS& GeomAPI_ExtremaSurfaceSurface::Extrema() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : GeomAPI_IntSS
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAPI_IntSS::GeomAPI_IntSS() {}
-//=======================================================================
-// function : GeomAPI_IntSS
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAPI_IntSS::GeomAPI_IntSS(const Handle(Geom_Surface)& S1,
const Handle(Geom_Surface)& S2,
{
}
-//=======================================================================
-// function : Perform
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void GeomAPI_IntSS::Perform(const Handle(Geom_Surface)& S1,
const Handle(Geom_Surface)& S2,
myIntersec.Perform(S1, S2, Tol, Standard_True);
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean GeomAPI_IntSS::IsDone() const
{
return myIntersec.IsDone();
}
-//=======================================================================
-// function : NbLines
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer GeomAPI_IntSS::NbLines() const
{
return myIntersec.NbLines();
}
-//=======================================================================
-// function : Line
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Geom_Curve)& GeomAPI_IntSS::Line(const Standard_Integer I) const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Extrema
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Extrema_ExtPC& GeomAPI_ProjectPointOnCurve::Extrema() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Extrema
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Extrema_ExtPS& GeomAPI_ProjectPointOnSurf::Extrema() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Surface
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Geom_BSplineSurface)& GeomFill_BSplineCurves::Surface() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Surface
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Geom_BezierSurface)& GeomFill_BezierCurves::Surface() const
{
}
#endif
-//==================================================================
-// Function: InGoodPeriod
-// Purpose : Recadre un paramtere
-//==================================================================
+//=================================================================================================
+
static void InGoodPeriod(const Standard_Real Prec,
const Standard_Real Period,
Standard_Real& Current)
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : NbPoints
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer GeomFill_Line::NbPoints() const
{
return myNbPoints;
}
-//=======================================================================
-// function : Point
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer GeomFill_Line::Point(const Standard_Integer Index) const
{
}
#endif
-//==================================================================
-// Function: InGoodPeriod
-// Purpose : Recadre un paramtere
-//==================================================================
+//=================================================================================================
+
static void InGoodPeriod(const Standard_Real Prec,
const Standard_Real Period,
Standard_Real& Current)
rotation = Standard_False;
}
-//==================================================================
-// Function: EraseRotation
-// Purpose : Supprime la Rotation
-//==================================================================
+//=================================================================================================
+
void GeomFill_LocationGuide::EraseRotation()
{
rotation = Standard_False;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : const
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Geom_Surface)& GeomFill_Pipe::Surface() const
{
return mySurface;
}
-//=======================================================================
-// function : ExchangeUV
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean GeomFill_Pipe::ExchangeUV() const
{
return myExchUV;
}
-//=======================================================================
-// function : GenerateParticularCase
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void GeomFill_Pipe::GenerateParticularCase(const Standard_Boolean B)
{
myKPart = B;
}
-//=======================================================================
-// function : GenerateParticularCase
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean GeomFill_Pipe::GenerateParticularCase() const
{
return myKPart;
}
-//=======================================================================
-// function : ErrorOnSurf
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real GeomFill_Pipe::ErrorOnSurf() const
{
return myError;
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean GeomFill_Pipe::IsDone() const
{
return myStatus == GeomFill_PipeOk;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : IsPeriodic
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean GeomFill_Profiler::IsPeriodic() const
{
return myIsPeriodic;
}
-//=======================================================================
-// function : Curve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Geom_Curve)& GeomFill_Profiler::Curve(const Standard_Integer Index) const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : NbSections
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer GeomFill_SweepSectionGenerator::NbSections() const
{
#include <GeomAdaptor_Surface.hxx>
#include <Extrema_ExtPS.hxx>
-//=======================================================================
-// function : Perform
-// purpose : General intersection
-//=======================================================================
+//=================================================================================================
+
void GeomInt_IntSS::Perform(const Handle(Geom_Surface)& S1,
const Handle(Geom_Surface)& S2,
const Standard_Real Tol,
#include <IntPatch_Point.hxx>
#include <Geom_Surface.hxx>
-//=======================================================================
-// function : GeomInt_IntSS
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline GeomInt_IntSS::GeomInt_IntSS()
: myNbrestr(0),
myTolReached2d(0.0),
{
}
-//=======================================================================
-// function : GeomInt_IntSS
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline GeomInt_IntSS::GeomInt_IntSS(const Handle(Geom_Surface)& S1,
const Handle(Geom_Surface)& S2,
const Standard_Real Tol,
InternalPerform(Tol, Approx, ApproxS1, ApproxS2, Standard_True, U1, V1, U2, V2);
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean GeomInt_IntSS::IsDone() const
{
return myIntersector.IsDone();
}
-//=======================================================================
-// function : TolReached2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real GeomInt_IntSS::TolReached2d() const
{
return myTolReached2d;
}
-//=======================================================================
-// function : TolReached3d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Real GeomInt_IntSS::TolReached3d() const
{
return myTolReached3d;
}
-//=======================================================================
-// function : NbLines
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer GeomInt_IntSS::NbLines() const
{
return sline.Length() - myNbrestr;
}
-//=======================================================================
-// function : NbBoundaries
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer GeomInt_IntSS::NbBoundaries() const
{
StdFail_NotDone_Raise_if(!myIntersector.IsDone(), "GeomInt_IntSS::NbBoundaries() - no result");
return myNbrestr;
}
-//=======================================================================
-// function : NbPoints
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer GeomInt_IntSS::NbPoints() const
{
return myIntersector.NbPnts();
}
-//=======================================================================
-// function : Point
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Pnt GeomInt_IntSS::Point(const Standard_Integer Index) const
{
return myIntersector.Point(Index).Value();
#include <StdFail_NotDone.hxx>
-//=======================================================================
-// function : GeomInt_LineConstructor
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomInt_LineConstructor::GeomInt_LineConstructor()
: done(Standard_False)
{
}
-//=======================================================================
-// function : Load
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void GeomInt_LineConstructor::Load(const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_TopolTool)& D2,
myHS2 = S2;
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean GeomInt_LineConstructor::IsDone() const
{
return done;
}
-//=======================================================================
-// function : NbParts
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer GeomInt_LineConstructor::NbParts() const
{
return (seqp.Length() / 2);
}
-//=======================================================================
-// function : Part
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline void GeomInt_LineConstructor::Part(const Standard_Integer I,
Standard_Real& WFirst,
Standard_Real& WLast) const
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Hatch_Hatcher::Tolerance(const Standard_Real Tol)
{
myToler = Tol;
}
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Hatch_Hatcher::Tolerance() const
{
}
}
-//=======================================================================
-// Function : Dump
-// Purpose : Dump of the domain.
-//=======================================================================
+//=================================================================================================
void HatchGen_Domain::Dump(const Standard_Integer Index) const
{
}
}
-//=======================================================================
-//function : SetMinNbSamples
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurve_IntCurveCurveGen::SetMinNbSamples(const Standard_Integer theMinNbSamples)
{
intcurvcurv.SetMinNbSamples(theMinNbSamples);
}
-//=======================================================================
-//function : GetMinNbSamples
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer IntCurve_IntCurveCurveGen::GetMinNbSamples() const
{
return intcurvcurv.GetMinNbSamples();
}
-//=======================================================================
-//function : GetMinNbPoints
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer IntCurve_IntPolyPolyGen::GetMinNbSamples() const
{
return myMinPntNb;
}
-//=======================================================================
-//function : SetMinNbPoints
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurve_IntPolyPolyGen::SetMinNbSamples(const Standard_Integer theMinNbSamples)
{
myMinPntNb = theMinNbSamples;
Standard_Real& theVmax,
Standard_Boolean& theNoIntersection);
-//=======================================================================
-//function : IntCurveSurface_Inter
-//purpose :
-//=======================================================================
+//=================================================================================================
+
IntCurveSurface_Inter::IntCurveSurface_Inter()
{
}
-//=======================================================================
-//function : DoSurface
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::DoSurface(const TheSurface& surface,
const Standard_Real u0,
const Standard_Real u1,
gap = Max(Ures,Vres);
}
-//=======================================================================
-//function : DoNewBounds
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::DoNewBounds(
const TheSurface& surface,
const Standard_Real u0,
Perform(curve,surface,U0,V0,U1,V1);
}
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::Perform(const TheCurve& curve,
const TheSurface& surface,
const Standard_Real U1,const Standard_Real V1,
}
}
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::Perform(const TheCurve& curve,
const IntCurveSurface_ThePolygon& polygon,
const TheSurface& surface) {
IntCurveSurface_ThePolyhedron polyhedron(surface,nbsu,nbsv,u1,v1,u2,v2);
Perform(curve,polygon,surface,polyhedron);
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::Perform(const TheCurve& curve,
const TheSurface& surface,
const IntCurveSurface_ThePolyhedron& polyhedron) {
IntCurveSurface_ThePolygon polygon(curve,TheCurveTool::NbSamples(curve,u1,u2));
Perform(curve,polygon,surface,polyhedron);
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::Perform(const TheCurve& curve,
const IntCurveSurface_ThePolygon& polygon,
const TheSurface& surface,
InternalPerform(curve,polygon,surface,polyhedron,u1,v1,u2,v2);
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::Perform(const TheCurve& curve,
const IntCurveSurface_ThePolygon& polygon,
const TheSurface& surface,
}
}
-//=======================================================================
-//function : InternalPerform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::InternalPerform(const TheCurve& curve,
const IntCurveSurface_ThePolygon& polygon,
const TheSurface& surface,
delete [] TabU;
}
}
-//=======================================================================
-//function : InternalPerformCurveQuadric
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::InternalPerformCurveQuadric(const TheCurve& curve,
const TheSurface& surface) {
IntCurveSurface_TheQuadCurvExactInter QuadCurv(surface,curve);
}
}
-//=======================================================================
-//function : InternalPerform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::InternalPerform(const TheCurve& curve,
const IntCurveSurface_ThePolygon& polygon,
const TheSurface& surface,
}
} //-- Fin : la Surface est une quadrique
}
-//=======================================================================
-//function : PerformConicSurf
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::PerformConicSurf(const gp_Lin& Line,
const TheCurve& curve,
const TheSurface& surface,
}
}
}
-//=======================================================================
-//function : PerformConicSurf
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::PerformConicSurf(const gp_Circ& Circle,
const TheCurve& curve,
const TheSurface& surface,
}
}
}
-//=======================================================================
-//function : PerformConicSurf
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::PerformConicSurf(const gp_Elips& Ellipse,
const TheCurve& curve,
const TheSurface& surface,
}
}
}
-//=======================================================================
-//function : PerformConicSurf
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::PerformConicSurf(const gp_Parab& Parab,
const TheCurve& curve,
const TheSurface& surface,
}
}
}
-//=======================================================================
-//function : PerformConicSurf
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::PerformConicSurf(const gp_Hypr& Hypr,
const TheCurve& curve,
const TheSurface& surface,
}
}
}
-//=======================================================================
-//function : AppendIntAna
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::AppendIntAna(const TheCurve& curve,
const TheSurface& surface,
const IntAna_IntConicQuad& intana_ConicQuad) {
//-- std::cout<<" IntAna Conic Quad Not Done "<<std::endl;
}
}
-//=======================================================================
-//function : AppendPoint
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::AppendPoint(const TheCurve& curve,
const Standard_Real lw,
const TheSurface& surface,
}
-//=======================================================================
-//function : AppendSegment
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Inter::AppendSegment(const TheCurve& ,
const Standard_Real ,
const Standard_Real ,
U = u1;
V = v1;
}
-//=======================================================================
-//function : IntCurveSurface_ComputeTransitions
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_ComputeTransitions(const TheCurve& curve,
const Standard_Real w,
IntCurveSurface_TransitionOnCurve& TransOnCurve,
TransOnCurve = IntCurveSurface_Tangent;
}
}
-//=======================================================================
-//function : IntCurveSurface_ComputeParamsOnQuadric
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_ComputeParamsOnQuadric(const TheSurface& surface,
const gp_Pnt& P,
Standard_Real& u,
return;
}
-//=======================================================================
-//function : EstLimForInfOffs
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void EstLimForInfOffs(const gp_Lin& Line,
const TheSurface& surface,
const Standard_Integer nbsu,
V2new = Min(V2new, 1.e10);
}
}
-//=======================================================================
-//function : EstLimForInfSurf
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void EstLimForInfSurf(Standard_Real& U1new,
Standard_Real& U2new,
Standard_Real& V1new,
Init(C);
}
-//=======================================================================
-//function : IntCurveSurface_Polygon
-//purpose :
-//=======================================================================
+//=================================================================================================
+
IntCurveSurface_Polygon::IntCurveSurface_Polygon(const TheCurve& C,
const TColStd_Array1OfReal& Upars):
ClosedPolygon = Standard_False;
}
-//=======================================================================
-//function : Init
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Polygon::Init(const TheCurve& C,
const TColStd_Array1OfReal& Upars) {
#define LONGUEUR_MINI_EDGE_TRIANGLE 1e-15
-//=======================================================================
-//function : IntCurveSurface_Polyhedron
-//purpose :
-//=======================================================================
+//=================================================================================================
+
IntCurveSurface_Polyhedron::IntCurveSurface_Polyhedron (const ThePSurface& Surface,
const Standard_Integer nbdU,
const Standard_Integer nbdV,
Init(Surface,u1,v1,u2,v2);
}
-//=======================================================================
-//function : IntCurveSurface_Polyhedron
-//purpose :
-//=======================================================================
+//=================================================================================================
+
IntCurveSurface_Polyhedron::IntCurveSurface_Polyhedron (const ThePSurface& Surface,
const TColStd_Array1OfReal& Upars,
const TColStd_Array1OfReal& Vpars)
C_MyPnts=C_MyU=C_MyV=C_MyIsOnBounds=NULL;
}
-//=======================================================================
-//function : Init
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Polyhedron::Init(const ThePSurface& Surface,
const Standard_Real U0,
const Standard_Real V0,
Dump();
#endif
}
-//=======================================================================
-//function : Init
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Polyhedron::Init(const ThePSurface& Surface,
const TColStd_Array1OfReal& Upars,
const TColStd_Array1OfReal& Vpars) {
Dump();
#endif
}
-//=======================================================================
-//function : DeflectionOnTriangle
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Real IntCurveSurface_Polyhedron::DeflectionOnTriangle (const ThePSurface& Surface,
const Standard_Integer Triang) const
{
gp_Vec P1P(P1,P);
return(Abs(P1P.Dot(NormalVector)));
}
-//=======================================================================
-//function : Parameters
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Polyhedron::Parameters( const Standard_Integer Index
,Standard_Real &U
,Standard_Real &V) const
Standard_Real *CMyV = (Standard_Real *)C_MyV;
V = CMyV[Index];
}
-//=======================================================================
-//function : DeflectionOverEstimation
-//purpose : Set
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Polyhedron::DeflectionOverEstimation(const Standard_Real flec)
{
if(flec<0.0001) {
TheBnd.Enlarge(flec);
}
}
-//=======================================================================
-//function : DeflectionOverEstimation
-//purpose : Get
-//=======================================================================
+//=================================================================================================
+
Standard_Real IntCurveSurface_Polyhedron::DeflectionOverEstimation() const
{
return TheDeflection;
}
-//=======================================================================
-//function : Bounding
-//purpose :
-//=======================================================================
+//=================================================================================================
+
const Bnd_Box& IntCurveSurface_Polyhedron::Bounding() const
{
return TheBnd;
}
-//=======================================================================
-//function : FillBounding
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Polyhedron::FillBounding()
{
TheComponentsBnd=new Bnd_HArray1OfBox(1, NbTriangles());
TheComponentsBnd->SetValue(iTri,Boite);
}
}
-//=======================================================================
-//function : ComponentsBounding
-//purpose :
-//=======================================================================
+//=================================================================================================
+
const Handle(Bnd_HArray1OfBox)&
IntCurveSurface_Polyhedron::ComponentsBounding() const
{
return TheComponentsBnd;
}
-//=======================================================================
-//function : NbTriangles
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer IntCurveSurface_Polyhedron::NbTriangles () const
{
return nbdeltaU*nbdeltaV*2;
}
-//=======================================================================
-//function : NbPoints
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer IntCurveSurface_Polyhedron::NbPoints () const
{
return (nbdeltaU+1)*(nbdeltaV+1);
}
-//=======================================================================
-//function : TriConnex
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer IntCurveSurface_Polyhedron::TriConnex
(const Standard_Integer Triang,
const Standard_Integer Pivot,
}
-//=======================================================================
-//function : PlaneEquation
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Polyhedron::PlaneEquation (const Standard_Integer Triang,
gp_XYZ& NormalVector,
Standard_Real& PolarDistance) const
PolarDistance = NormalVector * Point(i1).XYZ();
}
}
-//=======================================================================
-//function : Contain
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean IntCurveSurface_Polyhedron::Contain (const Standard_Integer Triang,
const gp_Pnt& ThePnt) const
{
else
return Standard_False;
}
-//=======================================================================
-//function : Dump
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Polyhedron::Dump() const
{
}
-//=======================================================================
-//function : Size
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Polyhedron::Size (Standard_Integer& nbdu,
Standard_Integer& nbdv) const
{
nbdu=nbdeltaU;
nbdv=nbdeltaV;
}
-//=======================================================================
-//function : Triangle
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntCurveSurface_Polyhedron::Triangle (const Standard_Integer Index,
Standard_Integer& P1,
Standard_Integer& P2,
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Error
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real IntPatch_Polygo::Error() const
{
return myError;
}
-//=======================================================================
-// function : DeflectionOverEstimation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real IntPatch_Polygo::DeflectionOverEstimation() const
{
return myError;
}
-//=======================================================================
-// function : NbSegments
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer IntPatch_Polygo::NbSegments() const
{
return NbPoints() - 1;
}
-//=======================================================================
-// function : BeginOfSeg
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void IntPatch_Polygo::Segment(const Standard_Integer theIndex,
gp_Pnt2d& theBegin,
};
-//=======================================================================
-//function : FindVertex
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void FindVertex (const TheArc& A,
const Handle(TheTopolTool)& Domain,
TheFunction& Func,
}
}
-//=======================================================================
-//function : ComputeBoundsfromInfinite
-//purpose :
-//=======================================================================
+//=================================================================================================
+
// - PROVISIONAL - TEMPORARY - NOT GOOD - NYI - TO DO
// - Temporary - temporary - not good - nyi - to do
void ComputeBoundsfromInfinite(TheFunction& Func,
}
}
-//=======================================================================
-//function : PointProcess
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void PointProcess (const gp_Pnt& Pt,
const Standard_Real Para,
const TheArc& A,
}
}
-//=======================================================================
-//function : IsRegularity
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean IsRegularity(const TheArc& /*A*/,
const Handle(TheTopolTool)& aDomain)
{
return (BRep_Tool::HasContinuity(*anE));
}
-//=======================================================================
-//function : TreatLC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer TreatLC (const TheArc& A,
const Handle(TheTopolTool)& aDomain,
const IntSurf_Quadric& aQuadric,
}
-//=======================================================================
-//function : IntStart_SearchOnBoundaries::IntStart_SearchOnBoundaries
-//purpose :
-//=======================================================================
+//=================================================================================================
+
IntStart_SearchOnBoundaries::IntStart_SearchOnBoundaries ()
: done(Standard_False),
all(Standard_False)
{
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void IntStart_SearchOnBoundaries::Perform (TheFunction& Func,
const Handle(TheTopolTool)& Domain,
const Standard_Real TolBoundary,
return myTZones(Index);
}
-//=======================================================================
-// function : GetTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Intf_Interference::GetTolerance() const
{
}
-//=======================================================================
-//function : Intf_InterferencePolygonPolyhedron
-//purpose : Empty constructor
-//=======================================================================
+//=================================================================================================
+
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron()
: Intf_Interference (Standard_False),
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Intf_InterferencePolygonPolyhedron::Perform
(const Polygon3d& thePolyg, const Polyhedron& thePolyh)
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Intf_InterferencePolygonPolyhedron::Perform
(const gp_Lin& theLin, const Polyhedron& thePolyh)
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Intf_InterferencePolygonPolyhedron::Perform
(const Polygon3d& thePolyg, const Polyhedron& thePolyh,
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Intf_InterferencePolygonPolyhedron::Perform
(const gp_Lin& theLin, const Polyhedron& thePolyh,
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Bounding
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Bnd_Box2d& Intf_Polygon2d::Bounding() const
{
#include <Intf_SeqOfSectionPoint.hxx>
-//=======================================================================
-// function : NumberOfPoint
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer Intf_SectionLine::NumberOfPoints() const
{
return Result.Length();
}
-//=======================================================================
-// function : ParamOnFirst
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Intf_TangentZone::ParamOnFirst(Standard_Real& paraMin, Standard_Real& paraMax) const
{
paraMax = ParamOnFirstMax;
}
-//=======================================================================
-// function : ParamOnSecond
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Intf_TangentZone::ParamOnSecond(Standard_Real& paraMin, Standard_Real& paraMax) const
{
#include <IntRes2d_IntersectionPoint.hxx>
#include <gp_Vec2d.hxx>
-//=======================================================================
-//function : TopClass_Classifier2d
-//purpose :
-//=======================================================================
+//=================================================================================================
+
TopClass_Classifier2d::TopClass_Classifier2d() :
myIsSet(Standard_False),
{
}
-//=======================================================================
-//function : Reset
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void TopClass_Classifier2d::Reset(const gp_Lin2d& L,
const Standard_Real P,
// Modified by skv - Wed Jul 12 15:20:58 2006 OCC12627 End
}
-//=======================================================================
-//function : Compare
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void TopClass_Classifier2d::Compare(const TheEdge& E,
const TopAbs_Orientation Or)
// Modified by skv - Wed Jul 12 15:20:58 2006 OCC12627
-//=======================================================================
-// function : Parameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real TopClass_Classifier2d::Parameter() const
{
return myParam;
}
-//=======================================================================
-// function : Intersector
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TheIntersector& TopClass_Classifier2d::Intersector()
{
return myIntersector;
}
-//=======================================================================
-// function : ClosestIntersection
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer TopClass_Classifier2d::ClosestIntersection() const
{
return myClosest;
}
-//=======================================================================
-// function : State
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_State TopClass_Classifier2d::State() const
{
// Modified by skv - Wed Jul 12 15:20:58 2006 OCC12627 Begin
-//=======================================================================
-// function : IsHeadOrEnd
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopClass_Classifier2d::IsHeadOrEnd() const
{
#include <IntRes2d_IntersectionSegment.hxx>
#include <IntRes2d_IntersectionPoint.hxx>
-//=======================================================================
-//function : TopClass_FaceClassifier
-//purpose :
-//=======================================================================
+//=================================================================================================
+
TopClass_FaceClassifier::TopClass_FaceClassifier() :
myEdgeParameter(0.0),
{
}
-//=======================================================================
-//function : TopClass_FaceClassifier
-//purpose :
-//=======================================================================
+//=================================================================================================
+
TopClass_FaceClassifier::TopClass_FaceClassifier(TheFaceExplorer& FExp,
const gp_Pnt2d& P,
Perform(FExp,P,Tol);
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void TopClass_FaceClassifier::Perform(TheFaceExplorer& Fexp,
const gp_Pnt2d& P,
}
}
-//=======================================================================
-//function : State
-//purpose :
-//=======================================================================
+//=================================================================================================
+
TopAbs_State TopClass_FaceClassifier::State() const
{
else return myClassifier.State();
}
-//=======================================================================
-//function : Edge
-//purpose :
-//=======================================================================
+//=================================================================================================
+
const TheEdge& TopClass_FaceClassifier::Edge() const
{
}
-//=======================================================================
-//function : EdgeParameter
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Real TopClass_FaceClassifier::EdgeParameter() const
{
#include TheFaceExplorer_hxx
-//=======================================================================
-// function : Rejected
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopClass_FaceClassifier::Rejected() const
{
return rejected;
}
-//=======================================================================
-// function : Nowires
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean TopClass_FaceClassifier::NoWires() const
{
return nowires;
}
-//=======================================================================
-// function : Position
-// purpose :
-//=======================================================================
+//=================================================================================================
inline IntRes2d_Position TopClass_FaceClassifier::Position() const
{
#include <HLRAlgo_EdgeStatus.hxx>
-//=======================================================================
-// function : MoreHidden
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRAlgo_EdgeIterator::MoreHidden() const
{
return iHid <= myNbHid + 1;
}
-//=======================================================================
-// function : Hidden
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_EdgeIterator::Hidden(Standard_Real& Start,
Standard_ShortReal& TolStart,
TolEnd = myHidTolEnd;
}
-//=======================================================================
-// function : InitVisible
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_EdgeIterator::InitVisible(HLRAlgo_EdgeStatus& status)
{
myNbVis = ((HLRAlgo_EdgeStatus*)EVis)->NbVisiblePart();
}
-//=======================================================================
-// function : MoreVisible
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRAlgo_EdgeIterator::MoreVisible() const
{
return iVis <= myNbVis;
}
-//=======================================================================
-// function : NextVisible
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_EdgeIterator::NextVisible()
{
iVis++;
}
-//=======================================================================
-// function : Visible
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_EdgeIterator::Visible(Standard_Real& Start,
Standard_ShortReal& TolStart,
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Orientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_Intersection::Orientation(const TopAbs_Orientation Ori)
{
myOrien = Ori;
}
-//=======================================================================
-// function : Orientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation HLRAlgo_Intersection::Orientation() const
{
return myOrien;
}
-//=======================================================================
-// function : Level
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_Intersection::Level(const Standard_Integer Lev)
{
myLevel = Lev;
}
-//=======================================================================
-// function : Level
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRAlgo_Intersection::Level() const
{
return myLevel;
}
-//=======================================================================
-// function : SegIndex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_Intersection::SegIndex(const Standard_Integer SegInd)
{
mySegIndex = SegInd;
}
-//=======================================================================
-// function : SegIndex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRAlgo_Intersection::SegIndex() const
{
return mySegIndex;
}
-//=======================================================================
-// function : Index
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_Intersection::Index(const Standard_Integer Ind)
{
myIndex = Ind;
}
-//=======================================================================
-// function : Index
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRAlgo_Intersection::Index() const
{
return myIndex;
}
-//=======================================================================
-// function : Parameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_Intersection::Parameter(const Standard_Real P)
{
myParam = P;
}
-//=======================================================================
-// function : Parameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRAlgo_Intersection::Parameter() const
{
return myParam;
}
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_Intersection::Tolerance(const Standard_ShortReal T)
{
myToler = T;
}
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_ShortReal HLRAlgo_Intersection::Tolerance() const
{
return myToler;
}
-//=======================================================================
-// function : State
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_Intersection::State(const TopAbs_State St)
{
myState = St;
}
-//=======================================================================
-// function : State
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_State HLRAlgo_Intersection::State() const
{
#include <HLRAlgo_HArray1OfTData.hxx>
#include <HLRAlgo_HArray1OfPHDat.hxx>
-//=======================================================================
-// function : FaceIndex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_PolyData::FaceIndex(const Standard_Integer I)
{
myFaceIndices.Index = I;
}
-//=======================================================================
-// function : FaceIndex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRAlgo_PolyData::FaceIndex() const
{
return myFaceIndices.Index;
}
-//=======================================================================
-// function : Nodes
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TColgp_Array1OfXYZ& HLRAlgo_PolyData::Nodes() const
{
return myHNodes->ChangeArray1();
}
-//=======================================================================
-// function : TData
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRAlgo_Array1OfTData& HLRAlgo_PolyData::TData() const
{
return myHTData->ChangeArray1();
}
-//=======================================================================
-// function : PHDat
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRAlgo_Array1OfPHDat& HLRAlgo_PolyData::PHDat() const
{
return myHPHDat->ChangeArray1();
}
-//=======================================================================
-// function : Hiding
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRAlgo_PolyData::Hiding() const
{
#include <HLRAlgo_HArray1OfPISeg.hxx>
#include <HLRAlgo_HArray1OfPINod.hxx>
-//=======================================================================
-// function : DecTData
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_PolyInternalData::DecTData()
{
myNbTData--;
}
-//=======================================================================
-// function : DecPISeg
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_PolyInternalData::DecPISeg()
{
myNbPISeg--;
}
-//=======================================================================
-// function : DecPINod
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_PolyInternalData::DecPINod()
{
myNbPINod--;
}
-//=======================================================================
-// function : NbTData
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRAlgo_PolyInternalData::NbTData() const
{
return myNbTData;
}
-//=======================================================================
-// function : NbPISeg
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRAlgo_PolyInternalData::NbPISeg() const
{
return myNbPISeg;
}
-//=======================================================================
-// function : NbPINod
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRAlgo_PolyInternalData::NbPINod() const
{
return myNbPINod;
}
-//=======================================================================
-// function : Planar
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRAlgo_PolyInternalData::Planar() const
{
return myPlanar;
}
-//=======================================================================
-// function : Planar
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_PolyInternalData::Planar(const Standard_Boolean B)
{
myPlanar = B;
}
-//=======================================================================
-// function : IntOutL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRAlgo_PolyInternalData::IntOutL() const
{
return myIntOutL;
}
-//=======================================================================
-// function : IntOutL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_PolyInternalData::IntOutL(const Standard_Boolean B)
{
myIntOutL = B;
}
-//=======================================================================
-// function : TData
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRAlgo_Array1OfTData& HLRAlgo_PolyInternalData::TData() const
{
return myTData->ChangeArray1();
}
-//=======================================================================
-// function : PINod
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRAlgo_Array1OfPINod& HLRAlgo_PolyInternalData::PINod() const
{
return myPINod->ChangeArray1();
}
-//=======================================================================
-// function : PISeg
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRAlgo_Array1OfPISeg& HLRAlgo_PolyInternalData::PISeg() const
{
#include <gp_Vec.hxx>
#include <gp_Pnt.hxx>
-//=======================================================================
-// function : Directions
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_Projector::Directions(gp_Vec2d& D1, gp_Vec2d& D2, gp_Vec2d& D3) const
{
D3 = myD3;
}
-//=======================================================================
-// function : Perspective
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRAlgo_Projector::Perspective() const
{
}
/*
-//=======================================================================
-//function : Transformation
-//purpose :
-//=======================================================================
+//=================================================================================================
+
inline const gp_Trsf & HLRAlgo_Projector::Transformation() const
{ return myTrsf; }
*/
-//=======================================================================
-// function : InvertedTransformation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const gp_Trsf& HLRAlgo_Projector::InvertedTransformation() const
{
return myInvTrsf;
}
-//=======================================================================
-// function : FullTransformation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const gp_Trsf& HLRAlgo_Projector::FullTransformation() const
{
return myScaledTrsf;
}
-//=======================================================================
-// function : Focus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRAlgo_Projector::Focus() const
{
return myFocus;
}
-//=======================================================================
-// function : Transform
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_Projector::Transform(gp_Vec& D) const
{
D.Transform(myTrsf);
}
-//=======================================================================
-// function : Transform
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRAlgo_Projector::Transform(gp_Pnt& Pnt) const
{
#include <gp_Hypr.hxx>
#include <BRepAdaptor_Curve.hxx>
-//=======================================================================
-// function : FirstParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_BCurveTool::FirstParameter(const BRepAdaptor_Curve& C)
{
return (C.FirstParameter());
}
-//=======================================================================
-// function : LastParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_BCurveTool::LastParameter(const BRepAdaptor_Curve& C)
{
return (C.LastParameter());
}
-//=======================================================================
-// function : Continuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_Shape HLRBRep_BCurveTool::Continuity(const BRepAdaptor_Curve& C)
{
return (C.Continuity());
}
-//=======================================================================
-// function : NbIntervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_BCurveTool::NbIntervals(const BRepAdaptor_Curve& C,
const GeomAbs_Shape Sh)
return (C.NbIntervals(Sh));
}
-//=======================================================================
-// function : Intervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_BCurveTool::Intervals(const BRepAdaptor_Curve& C,
TColStd_Array1OfReal& Tab,
C.Intervals(Tab, Sh);
}
-//=======================================================================
-// function : IsClosed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_BCurveTool::IsClosed(const BRepAdaptor_Curve& C)
{
return (C.IsClosed());
}
-//=======================================================================
-// function : IsPeriodic
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_BCurveTool::IsPeriodic(const BRepAdaptor_Curve& C)
{
return (C.IsPeriodic());
}
-//=======================================================================
-// function : Period
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_BCurveTool::Period(const BRepAdaptor_Curve& C)
{
return (C.Period());
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Pnt HLRBRep_BCurveTool::Value(const BRepAdaptor_Curve& C, const Standard_Real U)
{
return (C.Value(U));
}
-//=======================================================================
-// function : D0
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_BCurveTool::D0(const BRepAdaptor_Curve& C, const Standard_Real U, gp_Pnt& P)
{
C.D0(U, P);
}
-//=======================================================================
-// function : D1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_BCurveTool::D1(const BRepAdaptor_Curve& C,
const Standard_Real U,
C.D2(U, P, T, N);
}
-//=======================================================================
-// function : D3
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_BCurveTool::D3(const BRepAdaptor_Curve& C,
const Standard_Real U,
C.D3(U, P, V1, V2, V3);
}
-//=======================================================================
-// function : DN
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Vec HLRBRep_BCurveTool::DN(const BRepAdaptor_Curve& C,
const Standard_Real U,
return (C.DN(U, N));
}
-//=======================================================================
-// function : Resolution
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_BCurveTool::Resolution(const BRepAdaptor_Curve& C,
const Standard_Real R3d)
return (C.Resolution(R3d));
}
-//=======================================================================
-// function : GetType
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_CurveType HLRBRep_BCurveTool::GetType(const BRepAdaptor_Curve& C)
{
return (C.GetType());
}
-//=======================================================================
-// function : Line
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Lin HLRBRep_BCurveTool::Line(const BRepAdaptor_Curve& C)
{
return (C.Line());
}
-//=======================================================================
-// function : Circle
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Circ HLRBRep_BCurveTool::Circle(const BRepAdaptor_Curve& C)
{
return (C.Circle());
}
-//=======================================================================
-// function : Ellipse
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Elips HLRBRep_BCurveTool::Ellipse(const BRepAdaptor_Curve& C)
{
return (C.Ellipse());
}
-//=======================================================================
-// function : Parabola
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Parab HLRBRep_BCurveTool::Parabola(const BRepAdaptor_Curve& C)
{
return (C.Parabola());
}
-//=======================================================================
-// function : Hyperbola
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Hypr HLRBRep_BCurveTool::Hyperbola(const BRepAdaptor_Curve& C)
{
return (C.Hyperbola());
}
-//=======================================================================
-// function : Degree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_BCurveTool::Degree(const BRepAdaptor_Curve& C)
{
return (C.Degree());
}
-//=======================================================================
-// function : IsRational
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_BCurveTool::IsRational(const BRepAdaptor_Curve& C)
{
return (C.IsRational());
}
-//=======================================================================
-// function : NbPoles
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_BCurveTool::NbPoles(const BRepAdaptor_Curve& C)
{
return (C.NbPoles());
}
-//=======================================================================
-// function : NbKnots
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_BCurveTool::NbKnots(const BRepAdaptor_Curve& C)
{
#include <Adaptor3d_Curve.hxx>
#include <BRepAdaptor_Surface.hxx>
-//=======================================================================
-// function : FirstUParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_BSurfaceTool::FirstUParameter(const BRepAdaptor_Surface& Surf)
{
return Surf.FirstUParameter();
}
-//=======================================================================
-// function : FirstVParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_BSurfaceTool::FirstVParameter(const BRepAdaptor_Surface& Surf)
{
return Surf.FirstVParameter();
}
-//=======================================================================
-// function : LastUParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_BSurfaceTool::LastUParameter(const BRepAdaptor_Surface& Surf)
{
return Surf.LastUParameter();
}
-//=======================================================================
-// function : LastVParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_BSurfaceTool::LastVParameter(const BRepAdaptor_Surface& Surf)
{
return Surf.LastVParameter();
}
-//=======================================================================
-// function : NbUIntervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_BSurfaceTool::NbUIntervals(const BRepAdaptor_Surface& Surf,
const GeomAbs_Shape S)
return Surf.NbUIntervals(S);
}
-//=======================================================================
-// function : NbVIntervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_BSurfaceTool::NbVIntervals(const BRepAdaptor_Surface& Surf,
const GeomAbs_Shape S)
return Surf.NbVIntervals(S);
}
-//=======================================================================
-// function : UIntervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_BSurfaceTool::UIntervals(const BRepAdaptor_Surface& Surf,
TColStd_Array1OfReal& Tab,
Surf.UIntervals(Tab, S);
}
-//=======================================================================
-// function : VIntervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_BSurfaceTool::VIntervals(const BRepAdaptor_Surface& Surf,
TColStd_Array1OfReal& Tab,
Surf.VIntervals(Tab, S);
}
-//=======================================================================
-// function : UTrim
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Adaptor3d_Surface) HLRBRep_BSurfaceTool::UTrim(const BRepAdaptor_Surface& Surf,
const Standard_Real F,
return Surf.UTrim(F, L, Tol);
}
-//=======================================================================
-// function : VTrim
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Adaptor3d_Surface) HLRBRep_BSurfaceTool::VTrim(const BRepAdaptor_Surface& Surf,
const Standard_Real F,
return Surf.VTrim(F, L, Tol);
}
-//=======================================================================
-// function : IsUClosed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_BSurfaceTool::IsUClosed(const BRepAdaptor_Surface& S)
{
return S.IsUClosed();
}
-//=======================================================================
-// function : IsVClosed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_BSurfaceTool::IsVClosed(const BRepAdaptor_Surface& S)
{
return S.IsVClosed();
}
-//=======================================================================
-// function : IsUPeriodic
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_BSurfaceTool::IsUPeriodic(const BRepAdaptor_Surface& S)
{
return S.IsUPeriodic();
}
-//=======================================================================
-// function : UPeriod
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_BSurfaceTool::UPeriod(const BRepAdaptor_Surface& S)
{
return S.UPeriod();
}
-//=======================================================================
-// function : IsVPeriodic
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_BSurfaceTool::IsVPeriodic(const BRepAdaptor_Surface& S)
{
return S.IsVPeriodic();
}
-//=======================================================================
-// function : VPeriod
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_BSurfaceTool::VPeriod(const BRepAdaptor_Surface& S)
{
return S.VPeriod();
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Pnt HLRBRep_BSurfaceTool::Value(const BRepAdaptor_Surface& S,
const Standard_Real U,
return S.Value(U, V);
}
-//=======================================================================
-// function : D0
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_BSurfaceTool::D0(const BRepAdaptor_Surface& S,
const Standard_Real U,
S.D0(U, V, P);
}
-//=======================================================================
-// function : D1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_BSurfaceTool::D1(const BRepAdaptor_Surface& S,
const Standard_Real U,
S.D1(U, V, P, D1U, D1V);
}
-//=======================================================================
-// function : D2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_BSurfaceTool::D2(const BRepAdaptor_Surface& S,
const Standard_Real U,
S.D2(U, V, P, D1U, D1V, D2U, D2V, D2UV);
}
-//=======================================================================
-// function : D3
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_BSurfaceTool::D3(const BRepAdaptor_Surface& S,
const Standard_Real U,
S.D3(U, V, P, D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV);
}
-//=======================================================================
-// function : DN
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Vec HLRBRep_BSurfaceTool::DN(const BRepAdaptor_Surface& S,
const Standard_Real U,
return S.DN(U, V, Nu, Nv);
}
-//=======================================================================
-// function : UResolution
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_BSurfaceTool::UResolution(const BRepAdaptor_Surface& S,
const Standard_Real R3d)
return S.UResolution(R3d);
}
-//=======================================================================
-// function : VResolution
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_BSurfaceTool::VResolution(const BRepAdaptor_Surface& S,
const Standard_Real R3d)
return S.VResolution(R3d);
}
-//=======================================================================
-// function : GetType
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_SurfaceType HLRBRep_BSurfaceTool::GetType(const BRepAdaptor_Surface& S)
{
return S.GetType();
}
-//=======================================================================
-// function : Plane
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Pln HLRBRep_BSurfaceTool::Plane(const BRepAdaptor_Surface& S)
{
return S.Plane();
}
-//=======================================================================
-// function : Cylinder
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Cylinder HLRBRep_BSurfaceTool::Cylinder(const BRepAdaptor_Surface& S)
{
return S.Cylinder();
}
-//=======================================================================
-// function : Cone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Cone HLRBRep_BSurfaceTool::Cone(const BRepAdaptor_Surface& S)
{
return S.Cone();
}
-//=======================================================================
-// function : Sphere
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Sphere HLRBRep_BSurfaceTool::Sphere(const BRepAdaptor_Surface& S)
{
return S.Sphere();
}
-//=======================================================================
-// function : Torus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Torus HLRBRep_BSurfaceTool::Torus(const BRepAdaptor_Surface& S)
{
return S.Torus();
}
-//=======================================================================
-// function : Bezier
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Geom_BezierSurface) HLRBRep_BSurfaceTool::Bezier(const BRepAdaptor_Surface& S)
{
return (S.Bezier());
}
-//=======================================================================
-// function : BSpline
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Geom_BSplineSurface) HLRBRep_BSurfaceTool::BSpline(const BRepAdaptor_Surface& S)
{
return (S.BSpline());
}
-//=======================================================================
-// function : AxeOfRevolution
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Ax1 HLRBRep_BSurfaceTool::AxeOfRevolution(const BRepAdaptor_Surface& S)
{
return (S.AxeOfRevolution());
}
-//=======================================================================
-// function : Direction
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Dir HLRBRep_BSurfaceTool::Direction(const BRepAdaptor_Surface& S)
{
return (S.Direction());
}
-//=======================================================================
-// function : BasisCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Adaptor3d_Curve) HLRBRep_BSurfaceTool::BasisCurve(const BRepAdaptor_Surface& S)
{
return (S.BasisCurve());
}
-//=======================================================================
-// function : UContinuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_Shape HLRBRep_BSurfaceTool::UContinuity(const BRepAdaptor_Surface& S)
{
return (S.UContinuity());
}
-//=======================================================================
-// function : VContinuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_Shape HLRBRep_BSurfaceTool::VContinuity(const BRepAdaptor_Surface& S)
{
return (S.VContinuity());
}
-//=======================================================================
-// function : UDegree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_BSurfaceTool::UDegree(const BRepAdaptor_Surface& S)
{
return (S.UDegree());
}
-//=======================================================================
-// function : NbUPoles
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_BSurfaceTool::NbUPoles(const BRepAdaptor_Surface& S)
{
return (S.NbUPoles());
}
-//=======================================================================
-// function : NbUKnots
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_BSurfaceTool::NbUKnots(const BRepAdaptor_Surface& S)
{
return (S.NbUKnots());
}
-//=======================================================================
-// function : IsURational
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_BSurfaceTool::IsURational(const BRepAdaptor_Surface& S)
{
return (S.IsURational());
}
-//=======================================================================
-// function : VDegree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_BSurfaceTool::VDegree(const BRepAdaptor_Surface& S)
{
return (S.VDegree());
}
-//=======================================================================
-// function : NbVPoles
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_BSurfaceTool::NbVPoles(const BRepAdaptor_Surface& S)
{
return (S.NbVPoles());
}
-//=======================================================================
-// function : NbVKnots
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_BSurfaceTool::NbVKnots(const BRepAdaptor_Surface& S)
{
return (S.NbVKnots());
}
-//=======================================================================
-// function : IsVRational
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_BSurfaceTool::IsVRational(const BRepAdaptor_Surface& S)
{
#include <HLRBRep_Curve.hxx>
#include <GeomAbs_Shape.hxx>
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_CLPropsATool::Value(const HLRBRep_Curve* A, const Standard_Real U, gp_Pnt2d& P)
{
P = A->Value(U);
}
-//=======================================================================
-// function : D1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_CLPropsATool::D1(const HLRBRep_Curve* A,
const Standard_Real U,
A->D1(U, P, V1);
}
-//=======================================================================
-// function : D2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_CLPropsATool::D2(const HLRBRep_Curve* A,
const Standard_Real U,
A->D2(U, P, V1, V2);
}
-//=======================================================================
-// function : D3
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_CLPropsATool::D3(const HLRBRep_Curve* A,
const Standard_Real U,
A->D3(U, P, V1, V2, V3);
}
-//=======================================================================
-// function : Continuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_CLPropsATool::Continuity(const HLRBRep_Curve*)
{
return GeomAbs_C2;
}
-//=======================================================================
-// function : FirstParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_CLPropsATool::FirstParameter(const HLRBRep_Curve* A)
{
return A->FirstParameter();
}
-//=======================================================================
-// function : LastParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_CLPropsATool::LastParameter(const HLRBRep_Curve* A)
{
#include <gp_Parab2d.hxx>
#include <HLRBRep_BCurveTool.hxx>
-//=======================================================================
-// function : Curve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepAdaptor_Curve& HLRBRep_Curve::Curve()
{
return myCurve;
}
-//=======================================================================
-// function : GetCurve
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const BRepAdaptor_Curve& HLRBRep_Curve::GetCurve() const
{
return myCurve;
}
-//=======================================================================
-// function : Value3D
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Pnt HLRBRep_Curve::Value3D(const Standard_Real U) const
{
return P;
}
-//=======================================================================
-// function : D0
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_Curve::D0(const Standard_Real U, gp_Pnt& P) const
{
HLRBRep_BCurveTool::D0(myCurve, U, P);
}
-//=======================================================================
-// function : D1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_Curve::D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V) const
{
HLRBRep_BCurveTool::D1(myCurve, U, P, V);
}
-//=======================================================================
-// function : FirstParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_Curve::FirstParameter() const
{
return Parameter2d(HLRBRep_BCurveTool::FirstParameter(myCurve));
}
-//=======================================================================
-// function : LastParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_Curve::LastParameter() const
{
return Parameter2d(HLRBRep_BCurveTool::LastParameter(myCurve));
}
-//=======================================================================
-// function : Continuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_Shape HLRBRep_Curve::Continuity() const
{
return HLRBRep_BCurveTool::Continuity(myCurve);
}
-//=======================================================================
-// function : NbIntervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Curve::NbIntervals(const GeomAbs_Shape S) const
{
return HLRBRep_BCurveTool::NbIntervals(myCurve, S);
}
-//=======================================================================
-// function : Intervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_Curve::Intervals(TColStd_Array1OfReal& Tab, const GeomAbs_Shape Sh) const
{
HLRBRep_BCurveTool::Intervals(myCurve, Tab, Sh);
}
-//=======================================================================
-// function : IsClosed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_Curve::IsClosed() const
{
return HLRBRep_BCurveTool::IsClosed(myCurve);
}
-//=======================================================================
-// function : IsPeriodic
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_Curve::IsPeriodic() const
{
return HLRBRep_BCurveTool::IsPeriodic(myCurve);
}
-//=======================================================================
-// function : Period
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_Curve::Period() const
{
return HLRBRep_BCurveTool::Period(myCurve);
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Pnt2d HLRBRep_Curve::Value(const Standard_Real U) const
{
return P;
}
-//=======================================================================
-// function : Resolution
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_Curve::Resolution(const Standard_Real R3d) const
{
return HLRBRep_BCurveTool::Resolution(myCurve, R3d);
}
-//=======================================================================
-// function : GetType
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_CurveType HLRBRep_Curve::GetType() const
{
return myType;
}
-//=======================================================================
-// function : Degree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Curve::Degree() const
{
return HLRBRep_BCurveTool::Degree(myCurve);
}
-//=======================================================================
-// function : NbPoles
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Curve::NbPoles() const
{
return HLRBRep_BCurveTool::NbPoles(myCurve);
}
-//=======================================================================
-// function : NbKnots
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Curve::NbKnots() const
{
return HLRBRep_BCurveTool::NbKnots(myCurve);
}
-//=======================================================================
-// function : IsRational
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_Curve::IsRational() const
{
#define IS_C2_COMPOSITE 0
-//=======================================================================
-// function : FirstParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_CurveTool::FirstParameter(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->FirstParameter());
}
-//=======================================================================
-// function : LastParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_CurveTool::LastParameter(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->LastParameter());
}
-//=======================================================================
-// function : Continuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_Shape HLRBRep_CurveTool::Continuity(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->Continuity());
}
-//=======================================================================
-// function : NbIntervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_CurveTool::NbIntervals(const Standard_Address C)
{
#endif
}
-//=======================================================================
-// function : Intervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_CurveTool::Intervals(const Standard_Address C, TColStd_Array1OfReal& Tab)
{
#endif
}
-//=======================================================================
-// function : GetInterval
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_CurveTool::GetInterval(const Standard_Address /*C*/,
const Standard_Integer i,
b = Tab.Value(i + 1);
}
-//=======================================================================
-// function : IsClosed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_CurveTool::IsClosed(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->IsClosed());
}
-//=======================================================================
-// function : IsPeriodic
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_CurveTool::IsPeriodic(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->IsPeriodic());
}
-//=======================================================================
-// function : Period
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_CurveTool::Period(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->Period());
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Pnt2d HLRBRep_CurveTool::Value(const Standard_Address C, const Standard_Real U)
{
return (((HLRBRep_Curve*)C)->Value(U));
}
-//=======================================================================
-// function : D0
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_CurveTool::D0(const Standard_Address C, const Standard_Real U, gp_Pnt2d& P)
{
((HLRBRep_Curve*)C)->D0(U, P);
}
-//=======================================================================
-// function : D1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_CurveTool::D1(const Standard_Address C,
const Standard_Real U,
((HLRBRep_Curve*)C)->D1(U, P, T);
}
-//=======================================================================
-// function : D2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_CurveTool::D2(const Standard_Address C,
const Standard_Real U,
((HLRBRep_Curve*)C)->D2(U, P, T, N);
}
-//=======================================================================
-// function : D3
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_CurveTool::D3(const Standard_Address C,
const Standard_Real U,
((HLRBRep_Curve*)C)->D3(U, P, V1, V2, V3);
}
-//=======================================================================
-// function : DN
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Vec2d HLRBRep_CurveTool::DN(const Standard_Address C,
const Standard_Real U,
return (((HLRBRep_Curve*)C)->DN(U, N));
}
-//=======================================================================
-// function : Resolution
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_CurveTool::Resolution(const Standard_Address C,
const Standard_Real R3d)
return (((HLRBRep_Curve*)C)->Resolution(R3d));
}
-//=======================================================================
-// function : GetType
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_CurveType HLRBRep_CurveTool::GetType(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->GetType());
}
-//=======================================================================
-// function : TheType
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_CurveType HLRBRep_CurveTool::TheType(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->GetType());
}
-//=======================================================================
-// function : Line
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Lin2d HLRBRep_CurveTool::Line(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->Line());
}
-//=======================================================================
-// function : Circle
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Circ2d HLRBRep_CurveTool::Circle(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->Circle());
}
-//=======================================================================
-// function : Ellipse
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Elips2d HLRBRep_CurveTool::Ellipse(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->Ellipse());
}
-//=======================================================================
-// function : Parabola
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Parab2d HLRBRep_CurveTool::Parabola(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->Parabola());
}
-//=======================================================================
-// function : Hyperbola
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Hypr2d HLRBRep_CurveTool::Hyperbola(const Standard_Address C)
{
return (((HLRBRep_Curve*)C)->Hyperbola());
}
-//=======================================================================
-// function : Bezier
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Geom2d_BezierCurve) HLRBRep_CurveTool::Bezier(const Standard_Address /*C*/)
{
return (0);
}
-//=======================================================================
-// function : BSpline
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Geom2d_BSplineCurve) HLRBRep_CurveTool::BSpline(const Standard_Address /*C*/)
{
return (0);
}
-//=======================================================================
-// function : EpsX
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_CurveTool::EpsX(const Standard_Address /*C*/)
{
return (1e-10);
}
-//=======================================================================
-// function : Degree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_CurveTool::Degree(const Standard_Address C)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : EDataArray
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRBRep_Array1OfEData& HLRBRep_Data::EDataArray()
{
return myEData;
}
-//=======================================================================
-// function : FDataArray
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRBRep_Array1OfFData& HLRBRep_Data::FDataArray()
{
return myFData;
}
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_Data::Tolerance(const Standard_ShortReal tol)
{
myToler = tol;
}
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_ShortReal HLRBRep_Data::Tolerance() const
{
return myToler;
}
-//=======================================================================
-// function : Projector
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRAlgo_Projector& HLRBRep_Data::Projector()
{
return myProj;
}
-//=======================================================================
-// function : NbVertices
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Data::NbVertices() const
{
return myNbVertices;
}
-//=======================================================================
-// function : NbEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Data::NbEdges() const
{
return myNbEdges;
}
-//=======================================================================
-// function : NbFaces
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Data::NbFaces() const
{
return myNbFaces;
}
-//=======================================================================
-// function : EdgeMap
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopTools_IndexedMapOfShape& HLRBRep_Data::EdgeMap()
{
return myEMap;
}
-//=======================================================================
-// function : FaceMap
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopTools_IndexedMapOfShape& HLRBRep_Data::FaceMap()
{
return myFMap;
}
-//=======================================================================
-// function : SimpleHidingFace
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_Data::SimpleHidingFace() const
{
return iFaceSimp;
}
-//=======================================================================
-// function : HidingTheFace
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_Data::HidingTheFace() const
{
return iFaceTest;
}
-//=======================================================================
-// function : MoreInterference
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_Data::MoreInterference() const
{
return (iInterf <= myNbPoints + 2 * myNbSegments);
}
-//=======================================================================
-// function : Interference
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRAlgo_Interference& HLRBRep_Data::Interference()
{
return myIntf;
}
-//=======================================================================
-// function :EdgeOfTheHidingFace
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_Data::EdgeOfTheHidingFace(const Standard_Integer,
const HLRBRep_EdgeData& ED) const
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Selected
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::Selected() const
{
return (myFlags & EMaskSelected) != 0;
}
-//=======================================================================
-// function : Selected
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::Selected(const Standard_Boolean B)
{
myFlags &= ~EMaskSelected;
}
-//=======================================================================
-// function : Rg1Line
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::Rg1Line() const
{
return (myFlags & EMaskRg1Line) != 0;
}
-//=======================================================================
-// function : Rg1Line
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::Rg1Line(const Standard_Boolean B)
{
myFlags &= ~EMaskRg1Line;
}
-//=======================================================================
-// function : RgNLine
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::RgNLine() const
{
return (myFlags & EMaskRgNLine) != 0;
}
-//=======================================================================
-// function : RgNLine
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::RgNLine(const Standard_Boolean B)
{
myFlags &= ~EMaskRgNLine;
}
-//=======================================================================
-// function : Vertical
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::Vertical() const
{
return (myFlags & EMaskVertical) != 0;
}
-//=======================================================================
-// function : Vertical
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::Vertical(const Standard_Boolean B)
{
myFlags &= ~EMaskVertical;
}
-//=======================================================================
-// function : Simple
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::Simple() const
{
return (myFlags & EMaskSimple) != 0;
}
-//=======================================================================
-// function : Simple
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::Simple(const Standard_Boolean B)
{
myFlags &= ~EMaskSimple;
}
-//=======================================================================
-// function : OutLVSta
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::OutLVSta() const
{
return (myFlags & EMaskOutLVSta) != 0;
}
-//=======================================================================
-// function : OutLVSta
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::OutLVSta(const Standard_Boolean B)
{
myFlags &= ~EMaskOutLVSta;
}
-//=======================================================================
-// function : OutLVEnd
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::OutLVEnd() const
{
return (myFlags & EMaskOutLVEnd) != 0;
}
-//=======================================================================
-// function : OutLVEnd
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::OutLVEnd(const Standard_Boolean B)
{
myFlags &= ~EMaskOutLVEnd;
}
-//=======================================================================
-// function : CutAtSta
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::CutAtSta() const
{
return (myFlags & EMaskCutAtSta) != 0;
}
-//=======================================================================
-// function : CutAtSta
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::CutAtSta(const Standard_Boolean B)
{
myFlags &= ~EMaskCutAtSta;
}
-//=======================================================================
-// function : CutAtEnd
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::CutAtEnd() const
{
return (myFlags & EMaskCutAtEnd) != 0;
}
-//=======================================================================
-// function : CutAtEnd
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::CutAtEnd(const Standard_Boolean B)
{
myFlags &= ~EMaskCutAtEnd;
}
-//=======================================================================
-// function : VerAtSta
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::VerAtSta() const
{
return (myFlags & EMaskVerAtSta) != 0;
}
-//=======================================================================
-// function : VerAtSta
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::VerAtSta(const Standard_Boolean B)
{
myFlags &= ~EMaskVerAtSta;
}
-//=======================================================================
-// function : VerAtEnd
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::VerAtEnd() const
{
return (myFlags & EMaskVerAtEnd) != 0;
}
-//=======================================================================
-// function : VerAtEnd
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::VerAtEnd(const Standard_Boolean B)
{
myFlags &= ~EMaskVerAtEnd;
}
-//=======================================================================
-// function : AutoIntersectionDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::AutoIntersectionDone() const
{
return (myFlags & EMaskIntDone) != 0;
}
-//=======================================================================
-// function : AutoIntersectionDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::AutoIntersectionDone(const Standard_Boolean B)
{
myFlags &= ~EMaskIntDone;
}
-//=======================================================================
-// function : Used
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeData::Used() const
{
return (myFlags & EMaskUsed) != 0;
}
-//=======================================================================
-// function : Used
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::Used(const Standard_Boolean B)
{
myFlags &= ~EMaskUsed;
}
-//=======================================================================
-// function : HideCount
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_EdgeData::HideCount() const
{
return myHideCount;
}
-//=======================================================================
-// function : HideCount
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::HideCount(const Standard_Integer I)
{
myHideCount = I;
}
-//=======================================================================
-// function : VSta
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_EdgeData::VSta() const
{
return myVSta;
}
-//=======================================================================
-// function : VSta
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::VSta(const Standard_Integer I)
{
myVSta = I;
}
-//=======================================================================
-// function : VEnd
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_EdgeData::VEnd() const
{
return myVEnd;
}
-//=======================================================================
-// function : VEnd
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeData::VEnd(const Standard_Integer I)
{
myVEnd = I;
}
-//=======================================================================
-// function : Status
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRAlgo_EdgeStatus& HLRBRep_EdgeData::Status()
{
return myStatus;
}
-//=======================================================================
-// function : ChangeGeometry
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRBRep_Curve& HLRBRep_EdgeData::ChangeGeometry()
{
return myGeometry;
}
-//=======================================================================
-// function : Geometry
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const HLRBRep_Curve& HLRBRep_EdgeData::Geometry() const
{
return myGeometry;
}
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_ShortReal HLRBRep_EdgeData::Tolerance() const
{
#include <HLRAlgo_Interference.hxx>
-//=======================================================================
-// function : InitVertices
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeInterferenceTool::InitVertices()
{
cur = 0;
}
-//=======================================================================
-// function : MoreVertices
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeInterferenceTool::MoreVertices() const
{
return cur < 2;
}
-//=======================================================================
-// function : NextVertex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_EdgeInterferenceTool::NextVertex()
{
cur++;
}
-//=======================================================================
-// function : CurrentVertex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const HLRAlgo_Intersection& HLRBRep_EdgeInterferenceTool::CurrentVertex() const
{
return inter[cur];
}
-//=======================================================================
-// function : CurrentOrientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation HLRBRep_EdgeInterferenceTool::CurrentOrientation() const
{
return TopAbs_REVERSED;
}
-//=======================================================================
-// function : CurrentParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_EdgeInterferenceTool::CurrentParameter() const
{
return inter[cur].Parameter();
}
-//=======================================================================
-// function : IsPeriodic
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_EdgeInterferenceTool::IsPeriodic() const
{
return Standard_False;
}
-//=======================================================================
-// function : ParameterOfInterference
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_EdgeInterferenceTool::ParameterOfInterference(
const HLRAlgo_Interference& I) const
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Selected
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::Selected() const
{
return (myFlags & (Standard_Integer)FMaskSelected) != 0;
}
-//=======================================================================
-// function : Selected
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Selected(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskSelected);
}
-//=======================================================================
-// function : Back
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::Back() const
{
return (myFlags & (Standard_Integer)FMaskBack) != 0;
}
-//=======================================================================
-// function : Back
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Back(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskBack);
}
-//=======================================================================
-// function : Side
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::Side() const
{
return (myFlags & (Standard_Integer)FMaskSide) != 0;
}
-//=======================================================================
-// function : Side
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Side(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskSide);
}
-//=======================================================================
-// function : Closed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::Closed() const
{
return (myFlags & (Standard_Integer)FMaskClosed) != 0;
}
-//=======================================================================
-// function : Closed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Closed(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskClosed);
}
-//=======================================================================
-// function : Hiding
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::Hiding() const
{
return (myFlags & (Standard_Integer)FMaskHiding) != 0;
}
-//=======================================================================
-// function : Hiding
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Hiding(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskHiding);
}
-//=======================================================================
-// function : Simple
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::Simple() const
{
return (myFlags & (Standard_Integer)FMaskSimple) != 0;
}
-//=======================================================================
-// function : Simple
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Simple(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskSimple);
}
-//=======================================================================
-// function : Cut
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::Cut() const
{
return (myFlags & (Standard_Integer)FMaskCut) != 0;
}
-//=======================================================================
-// function : Cut
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Cut(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskCut);
}
-//=======================================================================
-// function : WithOutL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::WithOutL() const
{
return (myFlags & (Standard_Integer)FMaskWithOutL) != 0;
}
-//=======================================================================
-// function : WithOutL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::WithOutL(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskWithOutL);
}
-//=======================================================================
-// function : Plane
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::Plane() const
{
return (myFlags & (Standard_Integer)FMaskPlane) != 0;
}
-//=======================================================================
-// function : Plane
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Plane(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskPlane);
}
-//=======================================================================
-// function : Cylinder
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::Cylinder() const
{
return (myFlags & (Standard_Integer)FMaskCylinder) != 0;
}
-//=======================================================================
-// function : Cylinder
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Cylinder(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskCylinder);
}
-//=======================================================================
-// function : Cone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::Cone() const
{
return (myFlags & (Standard_Integer)FMaskCone) != 0;
}
-//=======================================================================
-// function : Cone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Cone(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskCone);
}
-//=======================================================================
-// function : Sphere
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::Sphere() const
{
return (myFlags & (Standard_Integer)FMaskSphere) != 0;
}
-//=======================================================================
-// function : Sphere
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Sphere(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskSphere);
}
-//=======================================================================
-// function : Torus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceData::Torus() const
{
return (myFlags & (Standard_Integer)FMaskTorus) != 0;
}
-//=======================================================================
-// function : Torus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Torus(const Standard_Boolean B)
{
myFlags &= ~((Standard_Integer)FMaskTorus);
}
-//=======================================================================
-// function : Size
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_FaceData::Size() const
{
return mySize;
}
-//=======================================================================
-// function : Size
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Size(const Standard_Real S)
{
mySize = S;
}
-//=======================================================================
-// function : Orientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation HLRBRep_FaceData::Orientation() const
{
return ((TopAbs_Orientation)(myFlags & (Standard_Integer)EMaskOrient));
}
-//=======================================================================
-// function : Orientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceData::Orientation(const TopAbs_Orientation O)
{
myFlags |= ((Standard_Integer)O & (Standard_Integer)EMaskOrient);
}
-//=======================================================================
-// function : Wires
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(HLRAlgo_WiresBlock)& HLRBRep_FaceData::Wires()
{
return myWires;
}
-//=======================================================================
-// function : Geometry
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRBRep_Surface& HLRBRep_FaceData::Geometry()
{
return myGeometry;
}
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_ShortReal HLRBRep_FaceData::Tolerance() const
{
#include <HLRAlgo_WiresBlock.hxx>
#include <HLRAlgo_EdgesBlock.hxx>
-//=======================================================================
-// function : MoreEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceIterator::MoreEdge() const
{
return iWire <= nbWires;
}
-//=======================================================================
-// function : BeginningOfWire
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceIterator::BeginningOfWire() const
{
return iEdge == 1;
}
-//=======================================================================
-// function : EndOfWire
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceIterator::EndOfWire() const
{
return iEdge == nbEdges;
}
-//=======================================================================
-// function : SkipWire
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_FaceIterator::SkipWire()
{
NextEdge();
}
-//=======================================================================
-// function : Wire
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(HLRAlgo_EdgesBlock) HLRBRep_FaceIterator::Wire() const
{
return myWires->Wire(iWire);
}
-//=======================================================================
-// function : Edge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_FaceIterator::Edge() const
{
return myEdges->Edge(iEdge);
}
-//=======================================================================
-// function : Orientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation HLRBRep_FaceIterator::Orientation() const
{
return myEdges->Orientation(iEdge);
}
-//=======================================================================
-// function : OutLine
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceIterator::OutLine() const
{
return myEdges->OutLine(iEdge);
}
-//=======================================================================
-// function : Internal
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceIterator::Internal() const
{
return myEdges->Internal(iEdge);
}
-//=======================================================================
-// function : Double
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceIterator::Double() const
{
return myEdges->Double(iEdge);
}
-//=======================================================================
-// function : IsoLine
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_FaceIterator::IsoLine() const
{
#include <TopoDS_Shape.hxx>
-//=======================================================================
-// function : VCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::VCompound()
{
return InternalCompound(5, Standard_True, TopoDS_Shape());
}
-//=======================================================================
-// function : VCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::VCompound(const TopoDS_Shape& S)
{
return InternalCompound(5, Standard_True, S);
}
-//=======================================================================
-// function : Rg1LineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::Rg1LineVCompound()
{
return InternalCompound(3, Standard_True, TopoDS_Shape());
}
-//=======================================================================
-// function : Rg1LineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::Rg1LineVCompound(const TopoDS_Shape& S)
{
return InternalCompound(3, Standard_True, S);
}
-//=======================================================================
-// function : RgNLineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::RgNLineVCompound()
{
return InternalCompound(4, Standard_True, TopoDS_Shape());
}
-//=======================================================================
-// function : RgNLineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::RgNLineVCompound(const TopoDS_Shape& S)
{
return InternalCompound(4, Standard_True, S);
}
-//=======================================================================
-// function : OutLineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::OutLineVCompound()
{
return InternalCompound(2, Standard_True, TopoDS_Shape());
}
-//=======================================================================
-// function : OutLineVCompound3d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::OutLineVCompound3d()
{
return InternalCompound(2, Standard_True, TopoDS_Shape(), Standard_True);
}
-//=======================================================================
-// function : OutLineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::OutLineVCompound(const TopoDS_Shape& S)
{
return InternalCompound(2, Standard_True, S);
}
-//=======================================================================
-// function : IsoLineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::IsoLineVCompound()
{
return InternalCompound(1, Standard_True, TopoDS_Shape());
}
-//=======================================================================
-// function : IsoLineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::IsoLineVCompound(const TopoDS_Shape& S)
{
return InternalCompound(1, Standard_True, S);
}
-//=======================================================================
-// function : HCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::HCompound()
{
return InternalCompound(5, Standard_False, TopoDS_Shape());
}
-//=======================================================================
-// function : HCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::HCompound(const TopoDS_Shape& S)
{
return InternalCompound(5, Standard_False, S);
}
-//=======================================================================
-// function : Rg1LineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::Rg1LineHCompound()
{
return InternalCompound(3, Standard_False, TopoDS_Shape());
}
-//=======================================================================
-// function : Rg1LineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::Rg1LineHCompound(const TopoDS_Shape& S)
{
return InternalCompound(3, Standard_False, S);
}
-//=======================================================================
-// function : RgNLineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::RgNLineHCompound()
{
return InternalCompound(4, Standard_False, TopoDS_Shape());
}
-//=======================================================================
-// function : RgNLineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::RgNLineHCompound(const TopoDS_Shape& S)
{
return InternalCompound(4, Standard_False, S);
}
-//=======================================================================
-// function : OutLineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::OutLineHCompound()
{
return InternalCompound(2, Standard_False, TopoDS_Shape());
}
-//=======================================================================
-// function : OutLineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::OutLineHCompound(const TopoDS_Shape& S)
{
return InternalCompound(2, Standard_False, S);
}
-//=======================================================================
-// function : IsoLineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::IsoLineHCompound()
{
return InternalCompound(1, Standard_False, TopoDS_Shape());
}
-//=======================================================================
-// function : IsoLineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::IsoLineHCompound(const TopoDS_Shape& S)
{
return InternalCompound(1, Standard_False, S);
}
-//=======================================================================
-// function : CompoundOfEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::CompoundOfEdges(const HLRBRep_TypeOfResultingEdge type,
const Standard_Boolean visible,
return InternalCompound(type, visible, TopoDS_Shape(), In3d);
}
-//=======================================================================
-// function : CompoundOfEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_HLRToShape::CompoundOfEdges(const TopoDS_Shape& S,
const HLRBRep_TypeOfResultingEdge type,
#include <TopoDS_Shape.hxx>
-//=======================================================================
-// function : Show
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_PolyHLRToShape::Show()
{
myHideMode = Standard_False;
}
-//=======================================================================
-// function : Hide
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_PolyHLRToShape::Hide()
{
myHideMode = Standard_True;
}
-//=======================================================================
-// function : VCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::VCompound()
{
return InternalCompound(4, Standard_True, TopoDS_Shape());
}
-//=======================================================================
-// function : VCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::VCompound(const TopoDS_Shape& S)
{
return InternalCompound(4, Standard_True, S);
}
-//=======================================================================
-// function : Rg1LineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::Rg1LineVCompound()
{
return InternalCompound(2, Standard_True, TopoDS_Shape());
}
-//=======================================================================
-// function : Rg1LineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::Rg1LineVCompound(const TopoDS_Shape& S)
{
return InternalCompound(2, Standard_True, S);
}
-//=======================================================================
-// function : RgNLineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::RgNLineVCompound()
{
return InternalCompound(3, Standard_True, TopoDS_Shape());
}
-//=======================================================================
-// function : RgNLineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::RgNLineVCompound(const TopoDS_Shape& S)
{
return InternalCompound(3, Standard_True, S);
}
-//=======================================================================
-// function : OutLineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::OutLineVCompound()
{
return InternalCompound(1, Standard_True, TopoDS_Shape());
}
-//=======================================================================
-// function : OutLineVCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::OutLineVCompound(const TopoDS_Shape& S)
{
return InternalCompound(1, Standard_True, S);
}
-//=======================================================================
-// function : HCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::HCompound()
{
return InternalCompound(4, Standard_False, TopoDS_Shape());
}
-//=======================================================================
-// function : HCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::HCompound(const TopoDS_Shape& S)
{
return InternalCompound(4, Standard_False, S);
}
-//=======================================================================
-// function : Rg1LineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::Rg1LineHCompound()
{
return InternalCompound(2, Standard_False, TopoDS_Shape());
}
-//=======================================================================
-// function : Rg1LineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::Rg1LineHCompound(const TopoDS_Shape& S)
{
return InternalCompound(2, Standard_False, S);
}
-//=======================================================================
-// function : RgNLineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::RgNLineHCompound()
{
return InternalCompound(3, Standard_False, TopoDS_Shape());
}
-//=======================================================================
-// function : RgNLineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::RgNLineHCompound(const TopoDS_Shape& S)
{
return InternalCompound(3, Standard_False, S);
}
-//=======================================================================
-// function : OutLineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::OutLineHCompound()
{
return InternalCompound(1, Standard_False, TopoDS_Shape());
}
-//=======================================================================
-// function : OutLineHCompound
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape HLRBRep_PolyHLRToShape::OutLineHCompound(const TopoDS_Shape& S)
{
#include <GeomAbs_Shape.hxx>
#include <gp_Pnt.hxx>
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_SLPropsATool::Value(const Standard_Address A,
const Standard_Real U,
P = ((HLRBRep_Surface*)A)->Value(U, V);
}
-//=======================================================================
-// function : D1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_SLPropsATool::D1(const Standard_Address A,
const Standard_Real U,
((HLRBRep_Surface*)A)->D1(U, V, P, D1U, D1V);
}
-//=======================================================================
-// function : D2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_SLPropsATool::D2(const Standard_Address A,
const Standard_Real U,
((HLRBRep_Surface*)A)->D2(U, V, P, D1U, D1V, D2U, D2V, DUV);
}
-//=======================================================================
-// function : DN
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Vec HLRBRep_SLPropsATool::DN(const Standard_Address A,
const Standard_Real U,
return ((HLRBRep_Surface*)A)->DN(U, V, Nu, Nv);
}
-//=======================================================================
-// function : Continuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_SLPropsATool::Continuity(const Standard_Address)
{
return 2;
} // et boum ! cky le 27 - 04 - 1993
-//=======================================================================
-// function : Bounds
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_SLPropsATool::Bounds(const Standard_Address,
Standard_Real& U1,
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : HLRBRep_ShapeBounds
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRBRep_ShapeBounds::HLRBRep_ShapeBounds()
: myNbIso(0),
{
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_ShapeBounds::Shape(const Handle(HLRTopoBRep_OutLiner)& S)
{
myShape = S;
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(HLRTopoBRep_OutLiner)& HLRBRep_ShapeBounds::Shape() const
{
return myShape;
}
-//=======================================================================
-// function : ShapeData
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_ShapeBounds::ShapeData(const Handle(Standard_Transient)& SD)
{
myShapeData = SD;
}
-//=======================================================================
-// function : ShapeData
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Standard_Transient)& HLRBRep_ShapeBounds::ShapeData() const
{
return myShapeData;
}
-//=======================================================================
-// function : NbOfIso
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_ShapeBounds::NbOfIso(const Standard_Integer nbIso)
{
myNbIso = nbIso;
}
-//=======================================================================
-// function : NbOfIso
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_ShapeBounds::NbOfIso() const
{
#include <BRepAdaptor_Surface.hxx>
#include <HLRBRep_BSurfaceTool.hxx>
-//=======================================================================
-// function : Surface
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRepAdaptor_Surface& HLRBRep_Surface::Surface()
{
return mySurf;
}
-//=======================================================================
-// function : FirstUParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_Surface::FirstUParameter() const
{
return HLRBRep_BSurfaceTool::FirstUParameter(mySurf);
}
-//=======================================================================
-// function : LastUParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_Surface::LastUParameter() const
{
return HLRBRep_BSurfaceTool::LastUParameter(mySurf);
}
-//=======================================================================
-// function : FirstVParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_Surface::FirstVParameter() const
{
return HLRBRep_BSurfaceTool::FirstVParameter(mySurf);
}
-//=======================================================================
-// function : LastVParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_Surface::LastVParameter() const
{
return HLRBRep_BSurfaceTool::LastVParameter(mySurf);
}
-//=======================================================================
-// function : UContinuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_Shape HLRBRep_Surface::UContinuity() const
{
return HLRBRep_BSurfaceTool::UContinuity(mySurf);
}
-//=======================================================================
-// function : VContinuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_Shape HLRBRep_Surface::VContinuity() const
{
return HLRBRep_BSurfaceTool::VContinuity(mySurf);
}
-//=======================================================================
-// function : NbUIntervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Surface::NbUIntervals(const GeomAbs_Shape S)
{
return HLRBRep_BSurfaceTool::NbUIntervals(mySurf, S);
}
-//=======================================================================
-// function : NbVIntervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Surface::NbVIntervals(const GeomAbs_Shape S)
{
return HLRBRep_BSurfaceTool::NbVIntervals(mySurf, S);
}
-//=======================================================================
-// function : IsUClosed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_Surface::IsUClosed() const
{
return HLRBRep_BSurfaceTool::IsUClosed(mySurf);
}
-//=======================================================================
-// function : IsVClosed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_Surface::IsVClosed() const
{
return HLRBRep_BSurfaceTool::IsVClosed(mySurf);
}
-//=======================================================================
-// function : IsUPeriodic
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_Surface::IsUPeriodic() const
{
return HLRBRep_BSurfaceTool::IsUPeriodic(mySurf);
}
-//=======================================================================
-// function : UPeriod
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_Surface::UPeriod() const
{
return HLRBRep_BSurfaceTool::UPeriod(mySurf);
}
-//=======================================================================
-// function : IsVPeriodic
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRBRep_Surface::IsVPeriodic() const
{
return HLRBRep_BSurfaceTool::IsVPeriodic(mySurf);
}
-//=======================================================================
-// function : VPeriod
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRBRep_Surface::VPeriod() const
{
return HLRBRep_BSurfaceTool::VPeriod(mySurf);
}
-//=======================================================================
-// function : D0
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_Surface::D0(const Standard_Real U, const Standard_Real V, gp_Pnt& P) const
{
HLRBRep_BSurfaceTool::D0(mySurf, U, V, P);
}
-//=======================================================================
-// function : D1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_Surface::D1(const Standard_Real U,
const Standard_Real V,
HLRBRep_BSurfaceTool::D1(mySurf, U, V, P, D1U, D1V);
}
-//=======================================================================
-// function : D2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_Surface::D2(const Standard_Real U,
const Standard_Real V,
HLRBRep_BSurfaceTool::D2(mySurf, U, V, P, D1U, D1V, D2U, D2V, D2UV);
}
-//=======================================================================
-// function : D3
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRBRep_Surface::D3(const Standard_Real U,
const Standard_Real V,
HLRBRep_BSurfaceTool::D3(mySurf, U, V, P, D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV);
}
-//=======================================================================
-// function : DN
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Vec HLRBRep_Surface::DN(const Standard_Real U,
const Standard_Real V,
return HLRBRep_BSurfaceTool::DN(mySurf, U, V, Nu, Nv);
}
-//=======================================================================
-// function : GetType
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_SurfaceType HLRBRep_Surface::GetType() const
{
return myType;
}
-//=======================================================================
-// function : Cylinder
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Cylinder HLRBRep_Surface::Cylinder() const
{
return HLRBRep_BSurfaceTool::Cylinder(mySurf);
}
-//=======================================================================
-// function : Cone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Cone HLRBRep_Surface::Cone() const
{
return HLRBRep_BSurfaceTool::Cone(mySurf);
}
-//=======================================================================
-// function : Sphere
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Sphere HLRBRep_Surface::Sphere() const
{
return HLRBRep_BSurfaceTool::Sphere(mySurf);
}
-//=======================================================================
-// function : Torus
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Torus HLRBRep_Surface::Torus() const
{
return HLRBRep_BSurfaceTool::Torus(mySurf);
}
-//=======================================================================
-// function : UDegree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Surface::UDegree() const
{
return HLRBRep_BSurfaceTool::UDegree(mySurf);
}
-//=======================================================================
-// function : NbUPoles
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Surface::NbUPoles() const
{
return HLRBRep_BSurfaceTool::NbUPoles(mySurf);
}
-//=======================================================================
-// function : VDegree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Surface::VDegree() const
{
return HLRBRep_BSurfaceTool::VDegree(mySurf);
}
-//=======================================================================
-// function : NbVPoles
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Surface::NbVPoles() const
{
return HLRBRep_BSurfaceTool::NbVPoles(mySurf);
}
-//=======================================================================
-// function : NbUKnots
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Surface::NbUKnots() const
{
return HLRBRep_BSurfaceTool::NbUKnots(mySurf);
}
-//=======================================================================
-// function : NbVKnots
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer HLRBRep_Surface::NbVKnots() const
{
return HLRBRep_BSurfaceTool::NbVKnots(mySurf);
}
-//=======================================================================
-// function : Axis
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Ax1 HLRBRep_Surface::Axis() const
{
#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
-//=======================================================================
-// function : EdgeSplE
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& HLRTopoBRep_Data::EdgeSplE(const TopoDS_Edge& E) const
{
return mySplE(E);
}
-//=======================================================================
-// function : FaceIntL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& HLRTopoBRep_Data::FaceIntL(const TopoDS_Face& F) const
{
return myData(F).FaceIntL();
}
-//=======================================================================
-// function : FaceOutL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& HLRTopoBRep_Data::FaceOutL(const TopoDS_Face& F) const
{
return myData(F).FaceOutL();
}
-//=======================================================================
-// function : FaceIsoL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& HLRTopoBRep_Data::FaceIsoL(const TopoDS_Face& F) const
{
return myData(F).FaceIsoL();
}
-//=======================================================================
-// function : IsOutV
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRTopoBRep_Data::IsOutV(const TopoDS_Vertex& V) const
{
return myOutV.Contains(V);
}
-//=======================================================================
-// function : IsIntV
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRTopoBRep_Data::IsIntV(const TopoDS_Vertex& V) const
{
return myIntV.Contains(V);
}
-//=======================================================================
-// function : AddOutV
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTopoBRep_Data::AddOutV(const TopoDS_Vertex& V)
{
myOutV.Add(V);
}
-//=======================================================================
-// function : AddIntV
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTopoBRep_Data::AddIntV(const TopoDS_Vertex& V)
{
myIntV.Add(V);
}
-//=======================================================================
-// function : MoreEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRTopoBRep_Data::MoreEdge() const
{
return myEIterator.More();
}
-//=======================================================================
-// function : Edge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Edge& HLRTopoBRep_Data::Edge() const
{
return TopoDS::Edge(myEIterator.Key());
}
-//=======================================================================
-// function : MoreVertex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean HLRTopoBRep_Data::MoreVertex() const
{
return myVIterator.More();
}
-//=======================================================================
-// function : NextVertex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTopoBRep_Data::NextVertex()
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : FaceIntL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& HLRTopoBRep_FaceData::FaceIntL() const
{
return myIntL;
}
-//=======================================================================
-// function : FaceOutL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& HLRTopoBRep_FaceData::FaceOutL() const
{
return myOutL;
}
-//=======================================================================
-// function : FaceIsoL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_ListOfShape& HLRTopoBRep_FaceData::FaceIsoL() const
{
return myIsoL;
}
-//=======================================================================
-// function : AddIntL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopTools_ListOfShape& HLRTopoBRep_FaceData::AddIntL()
{
return myIntL;
}
-//=======================================================================
-// function : AddOutL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopTools_ListOfShape& HLRTopoBRep_FaceData::AddOutL()
{
return myOutL;
}
-//=======================================================================
-// function : AddIsoL
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopTools_ListOfShape& HLRTopoBRep_FaceData::AddIsoL()
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : OriginalShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTopoBRep_OutLiner::OriginalShape(const TopoDS_Shape& OriS)
{
myOriginalShape = OriS;
}
-//=======================================================================
-// function : OriginalShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape& HLRTopoBRep_OutLiner::OriginalShape()
{
return myOriginalShape;
}
-//=======================================================================
-// function : OutLinedShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void HLRTopoBRep_OutLiner::OutLinedShape(const TopoDS_Shape& OutS)
{
myOutLinedShape = OutS;
}
-//=======================================================================
-// function : OutLinedShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape& HLRTopoBRep_OutLiner::OutLinedShape()
{
return myOutLinedShape;
}
-//=======================================================================
-// function : DataStructure
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRTopoBRep_Data& HLRTopoBRep_OutLiner::DataStructure()
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : HLRTopoBRep_VData
-// purpose :
-//=======================================================================
+//=================================================================================================
inline HLRTopoBRep_VData::HLRTopoBRep_VData()
: myParameter(0.0)
{
}
-//=======================================================================
-// function : Parameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real HLRTopoBRep_VData::Parameter() const
{
return myParameter;
}
-//=======================================================================
-// function : Vertex
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& HLRTopoBRep_VData::Vertex() const
{
// ***--------* IsJustAfter
// ***---* IsAfter
-//=======================================================================
-// function : Start
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Intrv_Interval::Start() const
{
return myStart;
}
-//=======================================================================
-// function : End
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Intrv_Interval::End() const
{
return myEnd;
}
-//=======================================================================
-// function : TolStart
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_ShortReal Intrv_Interval::TolStart() const
{
return myTolStart;
}
-//=======================================================================
-// function : TolEnd
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_ShortReal Intrv_Interval::TolEnd() const
{
return myTolEnd;
}
-//=======================================================================
-// function : Bounds
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Intrv_Interval::Bounds(Standard_Real& Start,
Standard_ShortReal& TolStart,
TolEnd = myTolEnd;
}
-//=======================================================================
-// function : SetStart
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Intrv_Interval::SetStart(const Standard_Real Start, const Standard_ShortReal TolStart)
{
}
}
-//=======================================================================
-// function : SetEnd
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Intrv_Interval::SetEnd(const Standard_Real End, const Standard_ShortReal TolEnd)
{
}
}
-//=======================================================================
-// function : AreFused
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean AreFused(const Standard_Real c1,
const Standard_ShortReal t1,
return t1 + t2 >= Abs(c1 - c2);
}
-//=======================================================================
-// function : IsProbablyEmpty
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Intrv_Interval::IsProbablyEmpty() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-//function : TopBas_Interference
-//purpose :
-//=======================================================================
+//=================================================================================================
+
TopBas_Interference::TopBas_Interference()
{
}
-//=======================================================================
-//function : TopBas_Interference
-//purpose :
-//=======================================================================
+//=================================================================================================
+
TopBas_Interference::TopBas_Interference(const TheSubShape& Inters,
const TheShape& Bound,
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Intersection
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopBas_Interference::Intersection(const TheSubShape& I)
{
myIntersection = I;
}
-//=======================================================================
-// function : Boundary
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopBas_Interference::Boundary(const TheShape& B)
{
myBoundary = B;
}
-//=======================================================================
-// function : Orientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopBas_Interference::Orientation(const TopAbs_Orientation Or)
{
myOrientation = Or;
}
-//=======================================================================
-// function : Transition
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopBas_Interference::Transition(const TopAbs_Orientation Or)
{
myTransition = Or;
}
-//=======================================================================
-// function : BoundaryTransition
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopBas_Interference::BoundaryTransition(const TopAbs_Orientation Or)
{
myBTransition = Or;
}
-//=======================================================================
-// function : Intersection
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TheSubShape& TopBas_Interference::Intersection() const
{
return myIntersection;
}
-//=======================================================================
-// function : ChangeIntersection
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TheSubShape& TopBas_Interference::ChangeIntersection()
{
return myIntersection;
}
-//=======================================================================
-// function : Boundary
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TheShape& TopBas_Interference::Boundary() const
{
return myBoundary;
}
-//=======================================================================
-// function : ChangeBoundary
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TheShape& TopBas_Interference::ChangeBoundary()
{
return myBoundary;
}
-//=======================================================================
-// function : Orientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation TopBas_Interference::Orientation() const
{
return myOrientation;
}
-//=======================================================================
-// function : Transition
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation TopBas_Interference::Transition() const
{
return myTransition;
}
-//=======================================================================
-// function : BoundaryTransition
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation TopBas_Interference::BoundaryTransition() const
{
}
}
-//=======================================================================
-// function : ErrorStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer HelixBRep_BuilderHelix::ErrorStatus() const
{
return myErrorStatus;
}
-//=======================================================================
-// function : WarningStatus
-// purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer HelixBRep_BuilderHelix::WarningStatus() const
{
return myWarningStatus;
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
+
const TopoDS_Shape& HelixBRep_BuilderHelix::Shape() const
{
return myShape;
compute(theVertexIndices);
}
-//=======================================================================
-// function : superMesh
-// purpose : Build the super mesh
-//=======================================================================
+//=================================================================================================
+
void BRepMesh_Delaun::superMesh(const Bnd_Box2d& theBox)
{
Standard_Real aMinX, aMinY, aMaxX, aMaxY;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : First
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepOffset_Interval::First(const Standard_Real U)
{
f = U;
}
-//=======================================================================
-// function : Last
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepOffset_Interval::Last(const Standard_Real U)
{
l = U;
}
-//=======================================================================
-// function : Type
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepOffset_Interval::Type(const ChFiDS_TypeOfConcavity T)
{
type = T;
}
-//=======================================================================
-// function : First
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real BRepOffset_Interval::First() const
{
return f;
}
-//=======================================================================
-// function : Last
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real BRepOffset_Interval::Last() const
{
return l;
}
-//=======================================================================
-// function : Type
-// purpose :
-//=======================================================================
+//=================================================================================================
inline ChFiDS_TypeOfConcavity BRepOffset_Interval::Type() const
{
myBuilder.MakeEdge(E, new Geom_Line(L), Precision::Confusion());
}
-//=======================================================================
-// function : MakeEdge
-// purpose : Make a Circular Edge
-//=======================================================================
+//=================================================================================================
void BRepPrim_Builder::MakeEdge(TopoDS_Edge& E, const gp_Circ& C) const
{
myBuilder.Add(W, EE);
}
-//=======================================================================
-// function : AddFaceWire
-// purpose : Add a Wire to a Face
-//=======================================================================
+//=================================================================================================
void BRepPrim_Builder::AddFaceWire(TopoDS_Face& F, const TopoDS_Wire& W) const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Builder
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const BRep_Builder& BRepPrim_Builder::Builder() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Builder
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const BRep_Builder& BRepSweep_Builder::Builder() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : More
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepSweep_Iterator::More() const
{
return myIterator.More();
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& BRepSweep_Iterator::Value() const
{
return myIterator.Value();
}
-//=======================================================================
-// function : Orientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation BRepSweep_Iterator::Orientation() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Index
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer Sweep_NumShape::Index() const
{
return myIndex;
}
-//=======================================================================
-// function : Type
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_ShapeEnum Sweep_NumShape::Type() const
{
return myType;
}
-//=======================================================================
-// function : Closed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Sweep_NumShape::Closed() const
{
return myClosed;
}
-//=======================================================================
-// function : BegInfinite
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Sweep_NumShape::BegInfinite() const
{
return myBegInf;
}
-//=======================================================================
-// function : EndInfinite
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Sweep_NumShape::EndInfinite() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : More
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Sweep_NumShapeIterator::More() const
{
return myMore;
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Sweep_NumShape& Sweep_NumShapeIterator::Value() const
{
return myCurrentNumShape;
}
-//=======================================================================
-// function : Orientation
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_Orientation Sweep_NumShapeIterator::Orientation() const
{
#include <ShapeAlgo_AlgoContainer.hxx>
-//=======================================================================
-// function : SetToolContainer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeAlgo_AlgoContainer::SetToolContainer(const Handle(ShapeAlgo_ToolContainer)& TC)
{
myTC = TC;
}
-//=======================================================================
-// function : ToolContainer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeAlgo_ToolContainer) ShapeAlgo_AlgoContainer::ToolContainer() const
{
#include <TopoDS.hxx>
#include <TopTools_HSequenceOfShape.hxx>
-//=======================================================================
-// function : SetFreeBound
-// purpose : Sets contour
-//=======================================================================
+//=================================================================================================
inline void ShapeAnalysis_FreeBoundData::SetFreeBound(const TopoDS_Wire& freebound)
{
// purpose : Adds notch on free bound with its maximum width
//=======================================================================
-//=======================================================================
-// function : FreeBound
-// purpose : Returns contour
-//=======================================================================
+//=================================================================================================
inline TopoDS_Wire ShapeAnalysis_FreeBoundData::FreeBound() const
{
// 25.12.98 pdn renaming methods GetWires and GetEdges to GetClosedWires and GetOpenWires
// respectively
-//=======================================================================
-// function : GetClosedWires
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Compound& ShapeAnalysis_FreeBounds::GetClosedWires() const
{
return myWires;
}
-//=======================================================================
-// function : GetOpenWires
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Compound& ShapeAnalysis_FreeBounds::GetOpenWires() const
{
#include <ShapeAnalysis_HSequenceOfFreeBounds.hxx>
-//=======================================================================
-// function : Shape
-// purpose : Returns shape
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape ShapeAnalysis_FreeBoundsProperties::Shape() const
{
return !(myShape.IsNull());
}
-//=======================================================================
-// function : Tolerance
-// purpose : Returns tolerance
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeAnalysis_FreeBoundsProperties::Tolerance() const
{
return du * du + dv * dv > max3d * max3d;
}
-//=======================================================================
-// static : ComputeIso
-// purpose :
-//=======================================================================
+//=================================================================================================
static Handle(Geom_Curve) ComputeIso(const Handle(Geom_Surface)& surf,
const Standard_Boolean utype,
#include <Geom_Surface.hxx>
#include <GeomAdaptor_Surface.hxx>
-//=======================================================================
-// function : Surface
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(Geom_Surface)& ShapeAnalysis_Surface::Surface() const
{
return mySurf;
}
-//=======================================================================
-// function : TrueAdaptor3d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(GeomAdaptor_Surface)& ShapeAnalysis_Surface::TrueAdaptor3d() const
{
return myAdSur;
}
-//=======================================================================
-// function : Gap
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeAnalysis_Surface::Gap() const
{
return myGap;
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Pnt ShapeAnalysis_Surface::Value(const Standard_Real u, const Standard_Real v)
{
return myAdSur->Value(u, v);
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Pnt ShapeAnalysis_Surface::Value(const gp_Pnt2d& p2d)
{
return myAdSur->Value(p2d.X(), p2d.Y());
}
-//=======================================================================
-// function : Bounds
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeAnalysis_Surface::Bounds(Standard_Real& ufirst,
Standard_Real& ulast,
vlast = myVL;
}
-//=======================================================================
-// function : UCloseVal
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeAnalysis_Surface::UCloseVal() const
{
return myUCloseVal;
}
-//=======================================================================
-// function : VCloseVal
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeAnalysis_Surface::VCloseVal() const
{
#include <ShapeExtend.hxx>
#include <ShapeExtend_WireData.hxx>
-//=======================================================================
-// function : IsLoaded
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::IsLoaded() const
{
return !myWire.IsNull() && myWire->NbEdges() > 0;
}
-//=======================================================================
-// function : IsReady
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::IsReady() const
{
return IsLoaded() && !myFace.IsNull();
}
-//=======================================================================
-// function : Precision
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeAnalysis_Wire::Precision() const
{
return myPrecision;
}
-//=======================================================================
-// function : WireData
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(ShapeExtend_WireData)& ShapeAnalysis_Wire::WireData() const
{
return myWire;
}
-//=======================================================================
-// function : NbEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer ShapeAnalysis_Wire::NbEdges() const
{
return myWire.IsNull() ? 0 : myWire->NbEdges();
}
-//=======================================================================
-// function : Face
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Face& ShapeAnalysis_Wire::Face() const
{
return myFace;
}
-//=======================================================================
-// function : Surface
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(ShapeAnalysis_Surface)& ShapeAnalysis_Wire::Surface() const
{
return mySurf;
}
-//=======================================================================
-// function : StatusOrder
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::StatusOrder(const ShapeExtend_Status Status) const
{
return ShapeExtend::DecodeStatus(myStatusOrder, Status);
}
-//=======================================================================
-// function : StatusConnected
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::StatusConnected(const ShapeExtend_Status Status) const
{
return ShapeExtend::DecodeStatus(myStatusConnected, Status);
}
-//=======================================================================
-// function : StatusEdgeCurves
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::StatusEdgeCurves(const ShapeExtend_Status Status) const
{
return ShapeExtend::DecodeStatus(myStatusEdgeCurves, Status);
}
-//=======================================================================
-// function : StatusDegenerated
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::StatusDegenerated(const ShapeExtend_Status Status) const
{
return ShapeExtend::DecodeStatus(myStatusDegenerated, Status);
}
-//=======================================================================
-// function : StatusClosed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::StatusClosed(const ShapeExtend_Status Status) const
{
return ShapeExtend::DecodeStatus(myStatusClosed, Status);
}
-//=======================================================================
-// function : StatusSmall
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::StatusSmall(const ShapeExtend_Status Status) const
{
return ShapeExtend::DecodeStatus(myStatusSmall, Status);
}
-//=======================================================================
-// function : StatusSelfIntersection
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::StatusSelfIntersection(
const ShapeExtend_Status Status) const
return ShapeExtend::DecodeStatus(myStatusSelfIntersection, Status);
}
-//=======================================================================
-// function : StatusLacking
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::StatusLacking(const ShapeExtend_Status Status) const
{
return ShapeExtend::DecodeStatus(myStatusLacking, Status);
}
-//=======================================================================
-// function : StatusGaps3d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::StatusGaps3d(const ShapeExtend_Status Status) const
{
return ShapeExtend::DecodeStatus(myStatusGaps3d, Status);
}
-//=======================================================================
-// function : StatusGaps2d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::StatusGaps2d(const ShapeExtend_Status Status) const
{
return ShapeExtend::DecodeStatus(myStatusGaps2d, Status);
}
-//=======================================================================
-// function : StatusCurveGaps
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::StatusCurveGaps(const ShapeExtend_Status Status) const
{
return ShapeExtend::DecodeStatus(myStatusCurveGaps, Status);
}
-//=======================================================================
-// function : StatusLoop
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::StatusLoop(const ShapeExtend_Status Status) const
{
return ShapeExtend::DecodeStatus(myStatusLoop, Status);
}
-//=======================================================================
-// function : Status
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeAnalysis_Wire::LastCheckStatus(const ShapeExtend_Status Status) const
{
return ShapeExtend::DecodeStatus(myStatus, Status);
}
-//=======================================================================
-// function : MinDistance3d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeAnalysis_Wire::MinDistance3d() const
{
return myMin3d;
}
-//=======================================================================
-// function : MinDistance2d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeAnalysis_Wire::MinDistance2d() const
{
return myMin2d;
}
-//=======================================================================
-// function : MaxDistance3d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeAnalysis_Wire::MaxDistance3d() const
{
return myMax3d;
}
-//=======================================================================
-// function : MaxDistance2d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeAnalysis_Wire::MaxDistance2d() const
{
return bspl;
}
-//=======================================================================
-// function : FixKnots
-// purpose : Fix coincided knots
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean ShapeConstruct_Curve::FixKnots(Handle(TColStd_HArray1OfReal)& knots)
{
Standard_Boolean Fixed = Standard_False;
return Fixed;
}
-//=======================================================================
-// function : FixKnots
-// purpose : Fix coincided knots
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean ShapeConstruct_Curve::FixKnots(TColStd_Array1OfReal& knots)
{
Standard_Boolean Fixed = Standard_False;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetTol3d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeCustom_BSplineRestriction::SetTol3d(const Standard_Real Tol3d)
{
myTol3d = Tol3d;
}
-//=======================================================================
-// function : SetTol2d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeCustom_BSplineRestriction::SetTol2d(const Standard_Real Tol2d)
{
myTol2d = Tol2d;
}
-//=======================================================================
-// function : ModifyApproxSurfaceFlag
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_BSplineRestriction::ModifyApproxSurfaceFlag()
{
return myApproxSurfaceFlag;
}
-//=======================================================================
-// function : ModifyApproxCurve3dFlag
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_BSplineRestriction::ModifyApproxCurve3dFlag()
{
return myApproxCurve3dFlag;
}
-//=======================================================================
-// function : ModifyApproxCurve2dFlag
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_BSplineRestriction::ModifyApproxCurve2dFlag()
{
return myApproxCurve2dFlag;
}
-//=======================================================================
-// function : SetContinuity3d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeCustom_BSplineRestriction::SetContinuity3d(const GeomAbs_Shape Continuity3d)
{
myContinuity3d = Continuity3d;
}
-//=======================================================================
-// function : SetContinuity2d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeCustom_BSplineRestriction::SetContinuity2d(const GeomAbs_Shape Continuity2d)
{
myContinuity2d = Continuity2d;
}
-//=======================================================================
-// function : SetMaxDegree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeCustom_BSplineRestriction::SetMaxDegree(const Standard_Integer MaxDegree)
{
myMaxDegree = MaxDegree;
}
-//=======================================================================
-// function : SetMaxNbSegments
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeCustom_BSplineRestriction::SetMaxNbSegments(const Standard_Integer MaxNbSegments)
{
myNbMaxSeg = MaxNbSegments;
}
-//=======================================================================
-// function : Curve3dError
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeCustom_BSplineRestriction::Curve3dError() const
{
return myCurve3dError;
}
-//=======================================================================
-// function : Curve2dError
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeCustom_BSplineRestriction::Curve2dError() const
{
return myCurve2dError;
}
-//=======================================================================
-// function : SurfaceError
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeCustom_BSplineRestriction::SurfaceError() const
{
return mySurfaceError;
}
-//=======================================================================
-// function : SetPriority
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeCustom_BSplineRestriction::SetPriority(const Standard_Boolean Degree)
{
myDeg = Degree;
}
-//=======================================================================
-// function : SetConvRational
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeCustom_BSplineRestriction::SetConvRational(const Standard_Boolean Rational)
{
myRational = Rational;
}
-//=======================================================================
-// function : GetRestrictionParameters
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeCustom_RestrictionParameters) ShapeCustom_BSplineRestriction::
GetRestrictionParameters() const
return myParameters;
}
-//=======================================================================
-// function : SetRestrictionParameters
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeCustom_BSplineRestriction::SetRestrictionParameters(
const Handle(ShapeCustom_RestrictionParameters)& aModes)
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : GMaxDegree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeCustom_RestrictionParameters::GMaxDegree()
{
return myGMaxDegree;
}
-//=======================================================================
-// function : GMaxSeg
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeCustom_RestrictionParameters::GMaxSeg()
{
return myGMaxSeg;
}
-//=======================================================================
-// function : ConvertPlane
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertPlane()
{
return myConvPlane;
}
-//=======================================================================
-// function : ConvertBezierSurf
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertBezierSurf()
{
return myConvBezierSurf;
}
-//=======================================================================
-// function : ConvertRevolutionSurf
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertRevolutionSurf()
{
return myConvRevolSurf;
}
-//=======================================================================
-// function : ConvertExtrusionSurf
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertExtrusionSurf()
{
return myConvExtrSurf;
}
-//=======================================================================
-// function : ConvertOffsetSurf
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertOffsetSurf()
{
return myConvOffsetSurf;
}
-//=======================================================================
-// function : SegmentSurfaceMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_RestrictionParameters::SegmentSurfaceMode()
{
return mySegmentSurfaceMode;
}
-//=======================================================================
-// function : ConvertCurve3d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertCurve3d()
{
return myConvCurve3d;
}
-//=======================================================================
-// function : ConvertOffsetCurv3d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertOffsetCurv3d()
{
return myConvOffsetCurv3d;
}
-//=======================================================================
-// function : ConvertCurve2d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertCurve2d()
{
return myConvCurve2d;
}
-//=======================================================================
-// function : ConvertOffsetCurv2d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertOffsetCurv2d()
{
return myConvOffsetCurv2d;
}
-//=======================================================================
-// function : ConvertConicalSurface
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertConicalSurf()
{
return myConvConicalSurf;
}
-//=======================================================================
-// function : ConvertSphericalSurf
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertSphericalSurf()
{
return myConvSphericalSurf;
}
-//=======================================================================
-// function : ConvertToroidalSurf
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertToroidalSurf()
{
return myConvCylindricalSurf;
}
-//=======================================================================
-// function : ConvertCylindricalSurf
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean& ShapeCustom_RestrictionParameters::ConvertCylindricalSurf()
{
return myConvToroidalSurf;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : ReversedParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeExtend_ComplexCurve::ReversedParameter(const Standard_Real U) const
{
return (1 - U);
}
-//=======================================================================
-// function : FirstParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeExtend_ComplexCurve::FirstParameter() const
{
return 0;
}
-//=======================================================================
-// function : LastParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeExtend_ComplexCurve::LastParameter() const
{
return 1;
}
-//=======================================================================
-// function : IsClosed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeExtend_ComplexCurve::IsClosed() const
{
return myClosed;
}
-//=======================================================================
-// function : IsPeriodic
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeExtend_ComplexCurve::IsPeriodic() const
{
return Standard_False;
}
-//=======================================================================
-// function : Continuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_Shape ShapeExtend_ComplexCurve::Continuity() const
{
return GeomAbs_C0;
}
-//=======================================================================
-// function : IsCN
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeExtend_ComplexCurve::IsCN(const Standard_Integer N) const
{
#include <ShapeExtend_MsgRegistrator.hxx>
-//=======================================================================
-// function : MapTransient
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const ShapeExtend_DataMapOfTransientListOfMsg& ShapeExtend_MsgRegistrator::MapTransient()
const
return myMapTransient;
}
-//=======================================================================
-// function : MapShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const ShapeExtend_DataMapOfShapeListOfMsg& ShapeExtend_MsgRegistrator::MapShape() const
{
#include <ShapeExtend.hxx>
-//=======================================================================
-// function : FixWireMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Face::FixWireMode()
{
return myFixWireMode;
}
-//=======================================================================
-// function : FixOrientationMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Face::FixOrientationMode()
{
return myFixOrientationMode;
}
-//=======================================================================
-// function : FixAddNaturalBoundMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Face::FixAddNaturalBoundMode()
{
return myFixAddNaturalBoundMode;
}
-//=======================================================================
-// function : FixMissingSeamMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Face::FixMissingSeamMode()
{
return myFixMissingSeamMode;
}
-//=======================================================================
-// function : FixSmallAreaWireMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Face::FixSmallAreaWireMode()
{
return myFixSmallAreaWireMode;
}
-//=======================================================================
-// function : RemoveSmallAreaFaceMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Face::RemoveSmallAreaFaceMode()
{
return myRemoveSmallAreaFaceMode;
}
-//=======================================================================
-// function : FixIntersectingWiresMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Face::FixIntersectingWiresMode()
{
return myFixIntersectingWiresMode;
}
-//=======================================================================
-// function : FixLoopWiresMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Face::FixLoopWiresMode()
{
return myFixLoopWiresMode;
}
-//=======================================================================
-// function : FixSplitFaceMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Face::FixSplitFaceMode()
{
return myFixSplitFaceMode;
}
-//=======================================================================
-// function : AutoCorrectPrecisionMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Face::AutoCorrectPrecisionMode()
{
return myAutoCorrectPrecisionMode;
}
-//=======================================================================
-// function : FixPeriodicDegeneratedMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Face::FixPeriodicDegeneratedMode()
{
return myFixPeriodicDegenerated;
}
-//=======================================================================
-// function : Face
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Face ShapeFix_Face::Face() const
{
return myFace;
}
-//=======================================================================
-// function : Result
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape ShapeFix_Face::Result() const
{
return myResult;
}
-//=======================================================================
-// function : Status
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Face::Status(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatus, status);
}
-//=======================================================================
-// function : FixWireTool
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeFix_Wire) ShapeFix_Face::FixWireTool()
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : GetClosedWires
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Compound& ShapeFix_FreeBounds::GetClosedWires() const
{
return myWires;
}
-//=======================================================================
-// function : GetOpenWires
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Compound& ShapeFix_FreeBounds::GetOpenWires() const
{
return myEdges;
}
-//=======================================================================
-// function : GetShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& ShapeFix_FreeBounds::GetShape() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Context
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeBuild_ReShape) ShapeFix_IntersectionTool::Context() const
{
#include <Precision.hxx>
-//=======================================================================
-// function : Context
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeBuild_ReShape) ShapeFix_Root::Context() const
{
return myContext;
}
-//=======================================================================
-// function : MsgRegistrator
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeExtend_BasicMsgRegistrator) ShapeFix_Root::MsgRegistrator() const
{
return myMsgReg;
}
-//=======================================================================
-// function : Precision
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeFix_Root::Precision() const
{
return myPrecision;
}
-//=======================================================================
-// function : MinTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeFix_Root::MinTolerance() const
{
return myMinTol;
}
-//=======================================================================
-// function : MaxTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeFix_Root::MaxTolerance() const
{
return myMaxTol;
}
-//=======================================================================
-// function : LimitTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeFix_Root::LimitTolerance(const Standard_Real toler) const
{
return Min(myMaxTol, toler);
}
-//=======================================================================
-// function : SendMsg
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeFix_Root::SendMsg(const Message_Msg& message, const Message_Gravity gravity) const
{
SendMsg(myShape, message, gravity);
}
-//=======================================================================
-// function : SendWarning
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeFix_Root::SendWarning(const TopoDS_Shape& shape, const Message_Msg& message) const
{
SendMsg(shape, message, Message_Warning);
}
-//=======================================================================
-// function : SendWarning
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeFix_Root::SendWarning(const Message_Msg& message) const
{
SendWarning(myShape, message);
}
-//=======================================================================
-// function : SendFail
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeFix_Root::SendFail(const TopoDS_Shape& shape, const Message_Msg& message) const
{
SendMsg(shape, message, Message_Fail);
}
-//=======================================================================
-// function : SendFail
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeFix_Root::SendFail(const Message_Msg& message) const
{
#include <ShapeFix_Face.hxx>
#include <ShapeFix_Wire.hxx>
-//=======================================================================
-// function : FixSolidTool
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeFix_Solid) ShapeFix_Shape::FixSolidTool() const
{
return myFixSolid;
}
-//=======================================================================
-// function : FixShellTool
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeFix_Shell) ShapeFix_Shape::FixShellTool() const
{
return myFixSolid->FixShellTool();
}
-//=======================================================================
-// function : FixFaceTool
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeFix_Face) ShapeFix_Shape::FixFaceTool() const
{
return myFixSolid->FixShellTool()->FixFaceTool();
}
-//=======================================================================
-// function : FixWireTool
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeFix_Wire) ShapeFix_Shape::FixWireTool() const
{
return myFixSolid->FixShellTool()->FixFaceTool()->FixWireTool();
}
-//=======================================================================
-// function : FixEdgeTool
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeFix_Edge) ShapeFix_Shape::FixEdgeTool() const
{
return myFixSolid->FixShellTool()->FixFaceTool()->FixWireTool()->FixEdgeTool();
}
-//=======================================================================
-// function : FixSolidMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Shape::FixSolidMode()
{
return myFixSolidMode;
}
-//=======================================================================
-// function : FixFreeShellMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Shape::FixFreeShellMode()
{
return myFixShellMode;
}
-//=======================================================================
-// function : FixFreeFaceMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Shape::FixFreeFaceMode()
{
return myFixFaceMode;
}
-//=======================================================================
-// function : FixFreeWireMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Shape::FixFreeWireMode()
{
return myFixWireMode;
}
-//=======================================================================
-// function : FixSameParameterMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Shape::FixSameParameterMode()
{
return myFixSameParameterMode;
}
-//=======================================================================
-// function : FixVertexPositionMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Shape::FixVertexPositionMode()
{
return myFixVertexPositionMode;
}
-//=======================================================================
-// function : FixVertexTolMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Shape::FixVertexTolMode()
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : FixFaceTool
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeFix_Face) ShapeFix_Shell::FixFaceTool()
{
return myFixFace;
}
-//=======================================================================
-// function : FixFaceMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Shell::FixFaceMode()
{
return myFixFaceMode;
}
-//=======================================================================
-// function : FixOrientationMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Shell::FixOrientationMode()
{
#include <ShapeExtend_WireData.hxx>
#include <ShapeAnalysis_Wire.hxx>
-//=======================================================================
-// function : SetFace
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeFix_Wire::SetFace(const TopoDS_Face& face)
{
myAnalyzer->SetFace(face);
}
-//=======================================================================
-// function : SetSurface
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeFix_Wire::SetSurface(const Handle(Geom_Surface)& surf)
{
myAnalyzer->SetSurface(theSurfaceAnalysis);
}
-//=======================================================================
-// function : SetSurface
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeFix_Wire::SetSurface(const Handle(Geom_Surface)& surf, const TopLoc_Location& loc)
{
myAnalyzer->SetSurface(surf, loc);
}
-//=======================================================================
-// function : IsLoaded
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::IsLoaded() const
{
return myAnalyzer->IsLoaded();
}
-//=======================================================================
-// function : IsReady
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::IsReady() const
{
return myAnalyzer->IsReady();
}
-//=======================================================================
-// function : Wire
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Wire ShapeFix_Wire::Wire() const
{
return myAnalyzer->WireData()->Wire();
}
-//=======================================================================
-// function : WireAPIMake
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Wire ShapeFix_Wire::WireAPIMake() const
{
return myAnalyzer->WireData()->WireAPIMake();
}
-//=======================================================================
-// function : Analyzer
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeAnalysis_Wire) ShapeFix_Wire::Analyzer() const
{
return myAnalyzer;
}
-//=======================================================================
-// function : WireData
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const Handle(ShapeExtend_WireData)& ShapeFix_Wire::WireData() const
{
return myAnalyzer->WireData();
}
-//=======================================================================
-// function : Face
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Face& ShapeFix_Wire::Face() const
{
return myAnalyzer->Face();
}
-//=======================================================================
-// function : ModifyTopologyMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeFix_Wire::ModifyTopologyMode()
{
return myTopoMode;
}
-//=======================================================================
-// function : ModifyGeometryMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeFix_Wire::ModifyGeometryMode()
{
return myGeomMode;
}
-//=======================================================================
-// function : ModifyRemoveLoopMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::ModifyRemoveLoopMode()
{
return myRemoveLoopMode;
}
-//=======================================================================
-// function : ClosedWireMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeFix_Wire::ClosedWireMode()
{
return myClosedMode;
}
-//=======================================================================
-// function : PreferencePCurveMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeFix_Wire::PreferencePCurveMode()
{
return myPreference2d;
}
-//=======================================================================
-// function : FixGapsByRangesMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeFix_Wire::FixGapsByRangesMode()
{
//=======================================================================
// function : Fix..Mode for high-level fixes
-//=======================================================================
-// function : FixReorderMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixReorderMode()
{
return myFixReorderMode;
}
-//=======================================================================
-// function : FixSmallMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixSmallMode()
{
return myFixSmallMode;
}
-//=======================================================================
-// function : FixConnectedMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixConnectedMode()
{
return myFixConnectedMode;
}
-//=======================================================================
-// function : FixEdgeCurvesMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixEdgeCurvesMode()
{
return myFixEdgeCurvesMode;
}
-//=======================================================================
-// function : FixDegeneratedMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixDegeneratedMode()
{
//=======================================================================
// function : Fix..Mode for low-level fixes
-//=======================================================================
-// function : FixReversed2dMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixReversed2dMode()
{
return myFixReversed2dMode;
}
-//=======================================================================
-// function : FixRemovePCurveMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixRemovePCurveMode()
{
return myFixRemovePCurveMode;
}
-//=======================================================================
-// function : FixRemoveCurve3dMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixRemoveCurve3dMode()
{
return myFixRemoveCurve3dMode;
}
-//=======================================================================
-// function : FixAddPCurveMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixAddPCurveMode()
{
return myFixAddPCurveMode;
}
-//=======================================================================
-// function : FixAddCurve3dMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixAddCurve3dMode()
{
return myFixAddCurve3dMode;
}
-//=======================================================================
-// function : FixSeamMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixSeamMode()
{
return myFixSeamMode;
}
-//=======================================================================
-// function : FixShiftedMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixShiftedMode()
{
return myFixShiftedMode;
}
-//=======================================================================
-// function : FixSameParameterMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixSameParameterMode()
{
return myFixSameParameterMode;
}
-//=======================================================================
-// function : FixVertexToleranceMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixVertexToleranceMode()
{
return myFixVertexToleranceMode;
}
-//=======================================================================
-// function : FixLackingMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixLackingMode()
{
return myFixLackingMode;
}
-//=======================================================================
-// function : FixSelfIntersectionMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixSelfIntersectionMode()
{
return myFixSelfIntersectionMode;
}
-//=======================================================================
-// function : FixGaps3dMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixGaps3dMode()
{
return myFixGaps3dMode;
}
-//=======================================================================
-// function : FixGaps2dMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixGaps2dMode()
{
return myFixGaps2dMode;
}
-//=======================================================================
-// function : FixNotchedEdgesMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixNotchedEdgesMode()
{
return myFixNotchedEdgesMode;
}
-//=======================================================================
-// function : FixSelfIntersectingEdgeMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixSelfIntersectingEdgeMode()
{
return myFixSelfIntersectingEdgeMode;
}
-//=======================================================================
-// function : FixIntersectingEdgesMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixIntersectingEdgesMode()
{
return myFixIntersectingEdgesMode;
}
-//=======================================================================
-// function : FixNonAdjacentIntersectingEdgesMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer& ShapeFix_Wire::FixNonAdjacentIntersectingEdgesMode()
{
return myFixNonAdjacentIntersectingEdgesMode;
}
-//=======================================================================
-// function : FixTailMode
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Integer& ShapeFix_Wire::FixTailMode()
{
return myFixTailMode;
//=======================================================================
// function : Status.. for high-level methods
-//=======================================================================
-// function : StatusReorder
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::StatusReorder(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusReorder, status);
}
-//=======================================================================
-// function : StatusSmall
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::StatusSmall(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusSmall, status);
}
-//=======================================================================
-// function : StatusConnected
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::StatusConnected(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusConnected, status);
}
-//=======================================================================
-// function : StatusEdgeCurves
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::StatusEdgeCurves(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusEdgeCurves, status);
}
-//=======================================================================
-// function : StatusDegenerated
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::StatusDegenerated(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusDegenerated, status);
}
-//=======================================================================
-// function : StatusLacking
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::StatusLacking(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusLacking, status);
}
-//=======================================================================
-// function : StatusSelfIntersection
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::StatusSelfIntersection(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusSelfIntersection, status);
}
-//=======================================================================
-// function : StatusGaps3d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::StatusGaps3d(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusGaps3d, status);
}
-//=======================================================================
-// function : StatusGaps2d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::StatusGaps2d(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusGaps2d, status);
}
-//=======================================================================
-// function : StatusClosed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::StatusClosed(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusClosed, status);
}
-//=======================================================================
-// function : StatusNotches
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::StatusNotches(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusNotches, status);
}
-//=======================================================================
-// function : StatusFixTails
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean ShapeFix_Wire::StatusFixTails(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusFixTails, status);
return ShapeExtend::DecodeStatus(myLastFixStatus, status);
}
-//=======================================================================
-// function : FixEdgeTool
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeFix_Edge) ShapeFix_Wire::FixEdgeTool() const
{
return myFixEdge;
}
-//=======================================================================
-// function : StatusRemovedSegment
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wire::StatusRemovedSegment() const
{
#include <ShapeExtend.hxx>
-//=======================================================================
-// function : StatusWireGaps
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wireframe::StatusWireGaps(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusWireGaps, status);
}
-//=======================================================================
-// function : StatusSmallEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeFix_Wireframe::StatusSmallEdges(const ShapeExtend_Status status) const
{
return ShapeExtend::DecodeStatus(myStatusSmallEdges, status);
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape ShapeFix_Wireframe::Shape()
{
return myShape;
}
-//=======================================================================
-// function : ModeDropSmallEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeFix_Wireframe::ModeDropSmallEdges()
{
return myModeDrop;
}
-//=======================================================================
-// function : SetLimitAngle
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeFix_Wireframe::SetLimitAngle(const Standard_Real theLimitAngle)
{
myLimitAngle = theLimitAngle;
}
-//=======================================================================
-// function : LimitAngle
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeFix_Wireframe::LimitAngle() const
{
return Standard_True;
}
-//=======================================================================
-// function : splitcontinuity
-// purpose : Split by Continuity
-//=======================================================================
+//=================================================================================================
static Standard_Boolean splitcontinuity(const Handle(ShapeProcess_Context)& context,
const Message_ProgressRange&)
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetLineMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ConvertCurve3dToBezier::SetLineMode(const Standard_Boolean mode)
{
myLineMode = mode;
}
-//=======================================================================
-// function : GetLineMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ConvertCurve3dToBezier::GetLineMode() const
{
return myLineMode;
}
-//=======================================================================
-// function : SetCircleMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ConvertCurve3dToBezier::SetCircleMode(const Standard_Boolean mode)
{
myCircleMode = mode;
}
-//=======================================================================
-// function : GetCircleMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ConvertCurve3dToBezier::GetCircleMode() const
{
return myCircleMode;
}
-//=======================================================================
-// function : SetConicMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ConvertCurve3dToBezier::SetConicMode(const Standard_Boolean mode)
{
myConicMode = mode;
}
-//=======================================================================
-// function : GetConicMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ConvertCurve3dToBezier::GetConicMode() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetPlaneMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ConvertSurfaceToBezierBasis::SetPlaneMode(const Standard_Boolean mode)
{
myPlaneMode = mode;
}
-//=======================================================================
-// function : GetPlaneMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ConvertSurfaceToBezierBasis::GetPlaneMode() const
{
return myPlaneMode;
}
-//=======================================================================
-// function : SetRevolutionMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ConvertSurfaceToBezierBasis::SetRevolutionMode(const Standard_Boolean mode)
{
myRevolutionMode = mode;
}
-//=======================================================================
-// function : GetRevolutionMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ConvertSurfaceToBezierBasis::GetRevolutionMode() const
{
return myRevolutionMode;
}
-//=======================================================================
-// function : SetExtrusionMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ConvertSurfaceToBezierBasis::SetExtrusionMode(const Standard_Boolean mode)
{
myExtrusionMode = mode;
}
-//=======================================================================
-// function : GetExtrusionMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ConvertSurfaceToBezierBasis::GetExtrusionMode() const
{
return myExtrusionMode;
}
-//=======================================================================
-// function : SetBSplineMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ConvertSurfaceToBezierBasis::SetBSplineMode(const Standard_Boolean mode)
{
myBSplineMode = mode;
}
-//=======================================================================
-// function : GetBSplineMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ConvertSurfaceToBezierBasis::GetBSplineMode() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetFace
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_EdgeDivide::SetFace(const TopoDS_Face& F)
{
myFace = F;
}
-//=======================================================================
-// function : HasCurve2d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_EdgeDivide::HasCurve2d() const
{
return myHasCurve2d;
}
-//=======================================================================
-// function : HasCurve3d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_EdgeDivide::HasCurve3d() const
{
return myHasCurve3d;
}
-//=======================================================================
-// function : Knots2d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TColStd_HSequenceOfReal) ShapeUpgrade_EdgeDivide::Knots2d() const
{
return myKnots2d;
}
-//=======================================================================
-// function : Knots3d
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TColStd_HSequenceOfReal) ShapeUpgrade_EdgeDivide::Knots3d() const
{
#include <ShapeExtend.hxx>
-//=======================================================================
-// function : MinArea
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real& ShapeUpgrade_RemoveInternalWires::MinArea()
{
return myMinArea;
}
-//=======================================================================
-// function : RemoveFaceMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean& ShapeUpgrade_RemoveInternalWires::RemoveFaceMode()
{
return myRemoveFacesMode;
}
-//=======================================================================
-// function : RemovedFaces
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_SequenceOfShape& ShapeUpgrade_RemoveInternalWires::RemovedFaces() const
{
return myRemovedFaces;
}
-//=======================================================================
-// function : RemovedWires
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopTools_SequenceOfShape& ShapeUpgrade_RemoveInternalWires::RemovedWires() const
{
return myRemoveWires;
}
-//=======================================================================
-// function : GetResult
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape ShapeUpgrade_RemoveInternalWires::GetResult() const
{
return myResult;
}
-//=======================================================================
-// function : Status
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_RemoveInternalWires::Status(
const ShapeExtend_Status theStatus) const
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : GetResult
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape ShapeUpgrade_RemoveLocations::GetResult() const
{
return myShape;
}
-//=======================================================================
-// function : SetRemoveLevel
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_RemoveLocations::SetRemoveLevel(const TopAbs_ShapeEnum theLevel)
{
myLevelRemoving = theLevel;
}
-//=======================================================================
-// function : RemoveLevel
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopAbs_ShapeEnum ShapeUpgrade_RemoveLocations::RemoveLevel() const
{
return myLevelRemoving;
}
-//=======================================================================
-// function : ModifiedShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape ShapeUpgrade_RemoveLocations::ModifiedShape(
const TopoDS_Shape& theInitShape) const
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Set2dConversion
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ShapeConvertToBezier::Set2dConversion(const Standard_Boolean mode)
{
my2dMode = mode;
}
-//=======================================================================
-// function : Get2dConversion
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ShapeConvertToBezier::Get2dConversion() const
{
return my2dMode;
}
-//=======================================================================
-// function : Set3dConversion
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ShapeConvertToBezier::Set3dConversion(const Standard_Boolean mode)
{
my3dMode = mode;
}
-//=======================================================================
-// function : Get3dConversion
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ShapeConvertToBezier::Get3dConversion() const
{
return my3dMode;
}
-//=======================================================================
-// function : SetSurfaceConversion
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ShapeConvertToBezier::SetSurfaceConversion(const Standard_Boolean mode)
{
mySurfaceMode = mode;
}
-//=======================================================================
-// function : GetSurfaceConversion
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ShapeConvertToBezier::GetSurfaceConversion() const
{
return mySurfaceMode;
}
-//=======================================================================
-// function : Set3dLineConversion
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ShapeConvertToBezier::Set3dLineConversion(const Standard_Boolean mode)
{
my3dLineMode = mode;
}
-//=======================================================================
-// function : Get3dLineConversion
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ShapeConvertToBezier::Get3dLineConversion() const
{
return my3dLineMode;
}
-//=======================================================================
-// function : Set3dCircleConversion
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ShapeConvertToBezier::Set3dCircleConversion(const Standard_Boolean mode)
{
my3dCircleMode = mode;
}
-//=======================================================================
-// function : Get3dCircleConversion
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ShapeConvertToBezier::Get3dCircleConversion() const
{
return my3dCircleMode;
}
-//=======================================================================
-// function : Set3dConicConversion
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ShapeConvertToBezier::Set3dConicConversion(const Standard_Boolean mode)
{
my3dConicMode = mode;
}
-//=======================================================================
-// function : Get3dConicConversion
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ShapeConvertToBezier::Get3dConicConversion() const
{
return my3dConicMode;
}
-//=======================================================================
-// function : SetPlaneMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ShapeConvertToBezier::SetPlaneMode(const Standard_Boolean mode)
{
myPlaneMode = mode;
}
-//=======================================================================
-// function : GetPlaneMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ShapeConvertToBezier::GetPlaneMode() const
{
return myPlaneMode;
}
-//=======================================================================
-// function : SetRevolutionMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ShapeConvertToBezier::SetRevolutionMode(const Standard_Boolean mode)
{
myRevolutionMode = mode;
}
-//=======================================================================
-// function : GetRevolutionMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ShapeConvertToBezier::GetRevolutionMode() const
{
return myRevolutionMode;
}
-//=======================================================================
-// function : SetExtrusionMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ShapeConvertToBezier::SetExtrusionMode(const Standard_Boolean mode)
{
myExtrusionMode = mode;
}
-//=======================================================================
-// function : GetExtrusionMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ShapeConvertToBezier::GetExtrusionMode() const
{
return myExtrusionMode;
}
-//=======================================================================
-// function : SetBSplineMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_ShapeConvertToBezier::SetBSplineMode(const Standard_Boolean mode)
{
myBSplineMode = mode;
}
-//=======================================================================
-// function : GetBSplineMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean ShapeUpgrade_ShapeConvertToBezier::GetBSplineMode() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetContext
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_Tool::SetContext(const Handle(ShapeBuild_ReShape)& context)
{
myContext = context;
}
-//=======================================================================
-// function : Context
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(ShapeBuild_ReShape) ShapeUpgrade_Tool::Context() const
{
return myContext;
}
-//=======================================================================
-// function : SetPrecision
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_Tool::SetPrecision(const Standard_Real preci)
{
myMinTol = myPrecision;
}
-//=======================================================================
-// function : Precision
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeUpgrade_Tool::Precision() const
{
return myPrecision;
}
-//=======================================================================
-// function : SetMinTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_Tool::SetMinTolerance(const Standard_Real mintol)
{
myMinTol = mintol;
}
-//=======================================================================
-// function : MinTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeUpgrade_Tool::MinTolerance() const
{
return myMinTol;
}
-//=======================================================================
-// function : SetMaxTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void ShapeUpgrade_Tool::SetMaxTolerance(const Standard_Real maxtol)
{
myMaxTol = maxtol;
}
-//=======================================================================
-// function : MaxTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeUpgrade_Tool::MaxTolerance() const
{
return myMaxTol;
}
-//=======================================================================
-// function : LimitTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real ShapeUpgrade_Tool::LimitTolerance(const Standard_Real toler) const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetMaxTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepBuilderAPI_Sewing::SetMaxTolerance(const Standard_Real theMaxToler)
{
myMaxTolerance = theMaxToler;
}
-//=======================================================================
-// function : MaxTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real BRepBuilderAPI_Sewing::MaxTolerance() const
{
return myMaxTolerance;
}
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real BRepBuilderAPI_Sewing::Tolerance() const
{
return myTolerance;
}
-//=======================================================================
-// function : SetTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepBuilderAPI_Sewing::SetTolerance(const Standard_Real theToler)
{
myTolerance = theToler;
}
-//=======================================================================
-// function : SetMinTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepBuilderAPI_Sewing::SetMinTolerance(const Standard_Real theMinToler)
{
myMinTolerance = theMinToler;
}
-//=======================================================================
-// function : MinTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real BRepBuilderAPI_Sewing::MinTolerance() const
{
return myMinTolerance;
}
-//=======================================================================
-// function : SetFaceMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepBuilderAPI_Sewing::SetFaceMode(const Standard_Boolean theFaceMode)
{
myFaceMode = theFaceMode;
}
-//=======================================================================
-// function : FaceMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBuilderAPI_Sewing::FaceMode() const
{
return myFaceMode;
}
-//=======================================================================
-// function : SetFloatingEdgesMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepBuilderAPI_Sewing::SetFloatingEdgesMode(const Standard_Boolean theFloatingEdgesMode)
{
myFloatingEdgesMode = theFloatingEdgesMode;
}
-//=======================================================================
-// function : FloatingEdgesMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBuilderAPI_Sewing::FloatingEdgesMode() const
{
}
/*
-//=======================================================================
-//function : SetCuttingFloatingEdgesMode
-//purpose :
-//=======================================================================
+//=================================================================================================
+
inline void BRepBuilderAPI_Sewing::SetCuttingFloatingEdgesMode(const Standard_Boolean
theCuttingFloatingEdgesMode)
myCuttingFloatingEdgesMode = theCuttingFloatingEdgesMode;
}
-//=======================================================================
-//function : CuttingFloatingEdgesMode
-//purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BRepBuilderAPI_Sewing::CuttingFloatingEdgesMode() const
{
}
*/
-//=======================================================================
-// function : SameParameterMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBuilderAPI_Sewing::SameParameterMode() const
{
return mySameParameterMode;
}
-//=======================================================================
-// function : SetSameParameterMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepBuilderAPI_Sewing::SetSameParameterMode(const Standard_Boolean SameParameterMode)
{
mySameParameterMode = SameParameterMode;
}
-//=======================================================================
-// function : SetLocalTolerancesMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepBuilderAPI_Sewing::SetLocalTolerancesMode(
const Standard_Boolean theLocalTolerancesMode)
myLocalToleranceMode = theLocalTolerancesMode;
}
-//=======================================================================
-// function : LocalTolerancesMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBuilderAPI_Sewing::LocalTolerancesMode() const
{
return myLocalToleranceMode;
}
-//=======================================================================
-// function : SetNonManifoldMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepBuilderAPI_Sewing::SetNonManifoldMode(const Standard_Boolean theNonManifoldMode)
{
myNonmanifold = theNonManifoldMode;
}
-//=======================================================================
-// function : NonManifoldMode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepBuilderAPI_Sewing::NonManifoldMode() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Edge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Edge& BRepClass_Edge::Edge()
{
return myEdge;
}
-//=======================================================================
-// function : Edge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Edge& BRepClass_Edge::Edge() const
{
return myEdge;
}
-//=======================================================================
-// function : Face
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Face& BRepClass_Edge::Face()
{
return myFace;
}
-//=======================================================================
-// function : Face
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Face& BRepClass_Edge::Face() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : MoreWires
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepClass_FaceExplorer::MoreWires() const
{
return myWExplorer.More();
}
-//=======================================================================
-// function : NextWire
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepClass_FaceExplorer::NextWire()
{
myWExplorer.Next();
}
-//=======================================================================
-// function : MoreEdges
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean BRepClass_FaceExplorer::MoreEdges() const
{
return myEExplorer.More();
}
-//=======================================================================
-// function : NextEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepClass_FaceExplorer::NextEdge()
{
}
} // namespace
-//=======================================================================
-// struct : IndexBand
-// purpose :
-//=======================================================================
+//=================================================================================================
+
struct IndexBand
{
IndexBand()
Standard_Integer Last;
};
-//=======================================================================
-// struct : ThreadSolution
-// purpose :
-//=======================================================================
+//=================================================================================================
+
struct ThreadSolution
{
ThreadSolution(Standard_Integer theTaskNum)
NCollection_Array1<Standard_Real> Dist;
};
-//=======================================================================
-// struct : VertexFunctor
-// purpose :
-//=======================================================================
+//=================================================================================================
+
struct VertexFunctor
{
VertexFunctor(NCollection_Array1<IndexBand>* theBandArray, const Message_ProgressRange& theRange)
return Standard_True;
}
-//=======================================================================
-// struct : DistanceFunctor
-// purpose :
-//=======================================================================
+//=================================================================================================
+
struct DistanceFunctor
{
DistanceFunctor(NCollection_Array1<NCollection_Array1<BRepExtrema_CheckPair>>* theArrayOfArrays,
Standard_Real StartDist;
};
-//=======================================================================
-// struct : DistancePairFunctor
-// purpose :
-//=======================================================================
+//=================================================================================================
+
struct DistancePairFunctor
{
DistancePairFunctor(NCollection_Array1<IndexBand>* theBandArray,
Decomposition(Shape2, myMapV2, myMapE2, myMapF2);
}
-//=======================================================================
-// struct : TreatmentFunctor
-// purpose :
-//=======================================================================
+//=================================================================================================
+
struct TreatmentFunctor
{
TreatmentFunctor(NCollection_Array1<NCollection_Array1<TopoDS_Shape>>* theArrayOfArrays,
#include <TopoDS.hxx>
#include <TopoDS_Face.hxx>
-//=======================================================================
-// function : BRepGProp_Domain
-// purpose : Empty constructor.
-//=======================================================================
+//=================================================================================================
inline BRepGProp_Domain::BRepGProp_Domain() {}
}
//
-//=======================================================================
-// function : GetFace
-// purpose : Returns TopoDS Face.
-//=======================================================================
+
+//=================================================================================================
inline const TopoDS_Face& BRepGProp_Face::GetFace() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetNbKronrodPoints
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepGProp_TFunction::SetNbKronrodPoints(const Standard_Integer theNbPoints)
{
myNbPntOuter = (theNbPoints % 2 == 0) ? theNbPoints + 1 : theNbPoints;
}
-//=======================================================================
-// function : SetValueType
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepGProp_TFunction::SetValueType(const GProp_ValueType theType)
{
myUFunction.SetValueType(myValueType);
}
-//=======================================================================
-// function : SetTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRepGProp_TFunction::SetTolerance(const Standard_Real theTolerance)
{
myTolerance = theTolerance;
}
-//=======================================================================
-// function : TolReached
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real BRepGProp_TFunction::ErrorReached() const
{
return myErrReached;
}
-//=======================================================================
-// function : ErrorReached
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real BRepGProp_TFunction::AbsolutError() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-//function : MAT_TList
-//purpose :
-//=======================================================================
+//=================================================================================================
+
MAT_TList::MAT_TList()
{
thenumberofitems = 0;
}
-//=======================================================================
-//function : First
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::First()
{
thecurrentindex = 1;
}
-//=======================================================================
-//function : Last
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::Last()
{
thecurrentindex = thenumberofitems;
}
-//=======================================================================
-//function : Init
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::Init(const Item& anitem)
{
}
}
-//=======================================================================
-//function : Next
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::Next()
{
}
}
-//=======================================================================
-//function : Previous
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::Previous()
{
}
}
-//=======================================================================
-//function : More
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean MAT_TList::More() const
{
return (!thecurrentnode.IsNull());
}
-//=======================================================================
-//function : Current
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Item MAT_TList::Current() const
{
return thecurrentnode->GetItem();
}
-//=======================================================================
-//function : Current
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::Current(const Item& anitem) const
{
thecurrentnode->SetItem(anitem);
}
-//=======================================================================
-//function : FirstItem
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Item MAT_TList::FirstItem() const
{
return thefirstnode->GetItem();
}
-//=======================================================================
-//function : LastItem
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Item MAT_TList::LastItem() const
{
return thelastnode->GetItem();
}
-//=======================================================================
-//function : PreviousItem
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Item MAT_TList::PreviousItem() const
{
return thecurrentnode->Previous()->GetItem();
}
-//=======================================================================
-//function : NextItem
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Item MAT_TList::NextItem() const
{
return thecurrentnode->Next()->GetItem();
}
-//=======================================================================
-//function : Brackets
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Item MAT_TList::Brackets (const Standard_Integer anindex)
{
return thecurrentnode->GetItem();
}
-//=======================================================================
-//function : Unlink
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::Unlink()
{
thecurrentindex--;
}
-//=======================================================================
-//function : LinkBefore
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::LinkBefore(const Item& anitem)
{
node->Next(thecurrentnode);
}
-//=======================================================================
-//function : LinkAfter
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::LinkAfter(const Item& anitem)
{
node->Previous(thecurrentnode);
}
-//=======================================================================
-//function : FrontAdd
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::FrontAdd(const Item& anitem)
{
thefirstnode = node;
}
-//=======================================================================
-//function : BackAdd
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::BackAdd(const Item& anitem)
{
thelastnode = node;
}
-//=======================================================================
-//function : Permute
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::Permute()
{
thecurrentindex++;
}
-//=======================================================================
-//function : Loop
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::Loop() const
{
thefirstnode->Previous(thelastnode);
}
-//=======================================================================
-//function : Dump
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TList::Dump(const Standard_Integer ashift,
const Standard_Integer alevel)
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Number
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer MAT_TList::Number() const
{
return thenumberofitems;
}
-//=======================================================================
-// function : Index
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer MAT_TList::Index() const
{
return thecurrentindex;
}
-//=======================================================================
-// function : IsEmpty
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean MAT_TList::IsEmpty() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-//function : Dummy
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void MAT_TListNode::Dummy()const {}
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : MAT_TListNode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline MAT_TListNode::MAT_TListNode() {}
-//=======================================================================
-// function : MAT_TListNode
-// purpose :
-//=======================================================================
+//=================================================================================================
inline MAT_TListNode::MAT_TListNode(const Item& anitem)
{
theitem = anitem;
}
-//=======================================================================
-// function : GetItem
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Item MAT_TListNode::GetItem() const
{
return theitem;
}
-//=======================================================================
-// function : Next
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(MAT_TListNode) MAT_TListNode::Next() const
{
return thenext;
}
-//=======================================================================
-// function : Previous
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(MAT_TListNode) MAT_TListNode::Previous() const
{
return theprevious;
}
-//=======================================================================
-// function : SetItem
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void MAT_TListNode::SetItem(const Item& anitem)
{
theitem = anitem;
}
-//=======================================================================
-// function : Next
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void MAT_TListNode::Next(const Handle(MAT_TListNode)& atlistnode)
{
thenext = atlistnode;
}
-//=======================================================================
-// function : Previous
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void MAT_TListNode::Previous(const Handle(MAT_TListNode)& atlistnode)
{
F.TShape()->Modified(Standard_True);
}
-//=======================================================================
-// function : MakeEdge
-// purpose : make undefined edge
-//=======================================================================
+//=================================================================================================
void BRep_Builder::MakeEdge(TopoDS_Edge& E) const
{
#include <BRep_TVertex.hxx>
#include <BRep_Tool.hxx>
-//=======================================================================
-// function : MakeFace
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::MakeFace(TopoDS_Face& F) const
{
MakeShape(F, TF);
}
-//=======================================================================
-// function : MakeEdge
-// purpose : make edge from curve
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::MakeEdge(TopoDS_Edge& E,
const Handle(Geom_Curve)& C,
UpdateEdge(E, C, TopLoc_Location(), Tol);
}
-//=======================================================================
-// function : MakeEdge
-// purpose : make edge from curve
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::MakeEdge(TopoDS_Edge& E, const Handle(Poly_Polygon3D)& P) const
{
UpdateEdge(E, P, T, L);
}
-//=======================================================================
-// function : MakeEdge
-// purpose : make edge from curve
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::MakeEdge(TopoDS_Edge& E,
const Handle(Geom_Curve)& C,
UpdateEdge(E, C, L, Tol);
}
-//=======================================================================
-// function : UpdateEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const Handle(Geom_Curve)& C,
UpdateEdge(E, C, TopLoc_Location(), Tol);
}
-//=======================================================================
-// function : UpdateEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const Handle(Geom2d_Curve)& C,
UpdateEdge(E, C, BRep_Tool::Surface(F, l), l, Tol);
}
-//=======================================================================
-// function : UpdateEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const Handle(Geom2d_Curve)& C1,
UpdateEdge(E, C1, C2, BRep_Tool::Surface(F, l), l, Tol);
}
-//=======================================================================
-// function : UpdateEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::UpdateEdge(const TopoDS_Edge& E, const Handle(Poly_Polygon3D)& P) const
{
UpdateEdge(E, P, TopLoc_Location());
}
-//=======================================================================
-// function : UpdateEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const Handle(Poly_PolygonOnTriangulation)& P,
UpdateEdge(E, P, T, TopLoc_Location());
}
-//=======================================================================
-// function : UpdateEdge
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::UpdateEdge(const TopoDS_Edge& E,
const Handle(Poly_PolygonOnTriangulation)& P1,
UpdateEdge(E, P1, P2, T, TopLoc_Location());
}
-//=======================================================================
-// function : Range
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::Range(const TopoDS_Edge& E,
const TopoDS_Face& F,
Range(E, BRep_Tool::Surface(F, l), l, First, Last);
}
-//=======================================================================
-// function : MakeVertex
-// purpose : undefined vertex
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::MakeVertex(TopoDS_Vertex& V) const
{
MakeShape(V, TV);
}
-//=======================================================================
-// function : MakeVertex
-// purpose : vertex from 3d point
-//=======================================================================
+//=================================================================================================
inline void BRep_Builder::MakeVertex(TopoDS_Vertex& V,
const gp_Pnt& P,
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetUVPoints2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_CurveOnClosedSurface::SetUVPoints2(const gp_Pnt2d& P1, const gp_Pnt2d& P2)
{
myUV22 = P2;
}
-//=======================================================================
-// function : UVPoints2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_CurveOnClosedSurface::UVPoints2(gp_Pnt2d& P1, gp_Pnt2d& P2) const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetUVPoints
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_CurveOnSurface::SetUVPoints(const gp_Pnt2d& P1, const gp_Pnt2d& P2)
{
myUV2 = P2;
}
-//=======================================================================
-// function : UVPoints
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_CurveOnSurface::UVPoints(gp_Pnt2d& P1, gp_Pnt2d& P2) const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Location
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopLoc_Location& BRep_CurveRepresentation::Location() const
{
return myLocation;
}
-//=======================================================================
-// function : Location
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_CurveRepresentation::Location(const TopLoc_Location& L)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : SetRange
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_GCurve::SetRange(const Standard_Real First, const Standard_Real Last)
{
Update();
}
-//=======================================================================
-// function : Range
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_GCurve::Range(Standard_Real& First, Standard_Real& Last) const
{
Last = myLast;
}
-//=======================================================================
-// function : First
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real BRep_GCurve::First() const
{
return myFirst;
}
-//=======================================================================
-// function : Last
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real BRep_GCurve::Last() const
{
return myLast;
}
-//=======================================================================
-// function : First
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_GCurve::First(const Standard_Real F)
{
Update();
}
-//=======================================================================
-// function : Last
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_GCurve::Last(const Standard_Real L)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Location
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopLoc_Location& BRep_PointRepresentation::Location() const
{
return myLocation;
}
-//=======================================================================
-// function : Location
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_PointRepresentation::Location(const TopLoc_Location& L)
{
myLocation = L;
}
-//=======================================================================
-// function : Parameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real BRep_PointRepresentation::Parameter() const
{
return myParameter;
}
-//=======================================================================
-// function : Parameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_PointRepresentation::Parameter(const Standard_Real P)
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real BRep_TEdge::Tolerance() const
{
return myTolerance;
}
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_TEdge::Tolerance(const Standard_Real T)
{
myTolerance = T;
}
-//=======================================================================
-// function : UpdateTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_TEdge::UpdateTolerance(const Standard_Real T)
{
myTolerance = T;
}
-//=======================================================================
-// function : Curves
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const BRep_ListOfCurveRepresentation& BRep_TEdge::Curves() const
{
return myCurves;
}
-//=======================================================================
-// function : ChangeCurves
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRep_ListOfCurveRepresentation& BRep_TEdge::ChangeCurves()
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real BRep_TVertex::Tolerance() const
{
return myTolerance;
}
-//=======================================================================
-// function : Tolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_TVertex::Tolerance(const Standard_Real T)
{
myTolerance = T;
}
-//=======================================================================
-// function : UpdateTolerance
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_TVertex::UpdateTolerance(const Standard_Real T)
{
myTolerance = T;
}
-//=======================================================================
-// function : Pnt
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const gp_Pnt& BRep_TVertex::Pnt() const
{
return myPnt;
}
-//=======================================================================
-// function : Pnt
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void BRep_TVertex::Pnt(const gp_Pnt& P)
{
myPnt = P;
}
-//=======================================================================
-// function : Points
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const BRep_ListOfPointRepresentation& BRep_TVertex::Points() const
{
return myPoints;
}
-//=======================================================================
-// function : ChangePoints
-// purpose :
-//=======================================================================
+//=================================================================================================
inline BRep_ListOfPointRepresentation& BRep_TVertex::ChangePoints()
{
return Standard_True;
}
-//==============================================================================
-// data : myEmptyList
-// purpose :
-//==============================================================================
+//=================================================================================================
+
const TopTools_ListOfShape BRepTools_History::myEmptyList;
//=================================================================================================
return myEmptyList;
}
-//==============================================================================
-// data : myMsgUnsupportedType
-// purpose :
-//==============================================================================
+//=================================================================================================
+
const char* BRepTools_History::myMsgUnsupportedType = "Error: unsupported shape type.";
-//==============================================================================
-// data : myMsgGeneratedAndRemoved
-// purpose :
-//==============================================================================
+//=================================================================================================
+
const char* BRepTools_History::myMsgGeneratedAndRemoved =
"Error: a shape is generated and removed simultaneously.";
-//==============================================================================
-// data : myMsgModifiedAndRemoved
-// purpose :
-//==============================================================================
+//=================================================================================================
+
const char* BRepTools_History::myMsgModifiedAndRemoved =
"Error: a shape is modified and removed simultaneously.";
-//==============================================================================
-// data : myMsgGeneratedAndModified
-// purpose :
-//==============================================================================
+//=================================================================================================
+
const char* BRepTools_History::myMsgGeneratedAndModified =
"Error: a shape is generated and modified "
"from the same shape simultaneously.";
#include <Standard_NoSuchObject.hxx>
-//=======================================================================
-// function : ModifiedShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& BRepTools_Modifier::ModifiedShape(const TopoDS_Shape& S) const
{
return myMap(S);
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Standard_Boolean BRepTools_Modifier::IsDone() const
{
return myDone;
#include <TopoDS_CompSolid.hxx>
#include <TopoDS_Compound.hxx>
-//=======================================================================
-// function : MakeWire
-// purpose : Make an empty wire
-//=======================================================================
+//=================================================================================================
inline void TopoDS_Builder::MakeWire(TopoDS_Wire& W) const
{
MakeShape(W, TW);
}
-//=======================================================================
-// function : MakeShell
-// purpose : Make an empty Shell
-//=======================================================================
+//=================================================================================================
inline void TopoDS_Builder::MakeShell(TopoDS_Shell& S) const
{
MakeShape(S, TS);
}
-//=======================================================================
-// function : MakeSolid
-// purpose : Make an empty Solid
-//=======================================================================
+//=================================================================================================
inline void TopoDS_Builder::MakeSolid(TopoDS_Solid& S) const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : TopoDS_HShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_HShape::TopoDS_HShape() {}
-//=======================================================================
-// function : TopoDS_HShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_HShape::TopoDS_HShape(const TopoDS_Shape& aShape)
: myShape(aShape)
{
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void TopoDS_HShape::Shape(const TopoDS_Shape& aShape)
{
myShape = aShape;
}
-//=======================================================================
-// function : Shape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline const TopoDS_Shape& TopoDS_HShape::Shape() const
{
return myShape;
}
-//=======================================================================
-// function : ChangeShape
-// purpose :
-//=======================================================================
+//=================================================================================================
inline TopoDS_Shape& TopoDS_HShape::ChangeShape()
{
}
}
-//=======================================================================
-// function :Locate1Coord
-// purpose : along BSpline curve
-//=======================================================================
+//=================================================================================================
static void Locate1Coord(const Standard_Integer Index,
const gp_Pnt2d& UV,
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray1OfInteger.hxx>
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean AdvApprox_ApproxAFunction::HasResult() const
{
return myHasResult;
}
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean AdvApprox_ApproxAFunction::IsDone() const
{
return myDone;
}
-//=======================================================================
-// function : Poles1d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Handle(TColStd_HArray2OfReal) AdvApprox_ApproxAFunction::Poles1d() const
{
return my1DPoles;
}
-//=======================================================================
-// function : Poles2d
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Handle(TColgp_HArray2OfPnt2d) AdvApprox_ApproxAFunction::Poles2d() const
{
return my2DPoles;
}
-//=======================================================================
-// function : Poles
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline Handle(TColgp_HArray2OfPnt) AdvApprox_ApproxAFunction::Poles() const
{
return my3DPoles;
}
-//=======================================================================
-// function : Degree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer AdvApprox_ApproxAFunction::Degree() const
{
return myDegree;
}
-//=======================================================================
-// function : NbKnots
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer AdvApprox_ApproxAFunction::NbKnots() const
{
return myKnots->Length();
}
-//=======================================================================
-// function : Knots
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TColStd_HArray1OfReal) AdvApprox_ApproxAFunction::Knots() const
return myKnots;
}
-//=======================================================================
-// function : Multiplicities
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(TColStd_HArray1OfInteger) AdvApprox_ApproxAFunction::Multiplicities() const
return myMults;
}
-//=======================================================================
-// function : NumSubSpaces
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer AdvApprox_ApproxAFunction::NumSubSpaces(
const Standard_Integer Dimension) const
-//=======================================================================
-//function : FirstTangencyVector
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::FirstTangencyVector(const MultiLine& Line,
const Standard_Integer index,
math_Vector& V)
}
-//=======================================================================
-//function : LastTangencyVector
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::LastTangencyVector(const MultiLine& Line,
const Standard_Integer index,
math_Vector& V)
-//=======================================================================
-//function : SearchFirstLambda
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Real Approx_BSplComputeLine::
SearchFirstLambda(const MultiLine& Line,
const math_Vector& aPar,
}
-//=======================================================================
-//function : SearchLastLambda
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Real Approx_BSplComputeLine::
SearchLastLambda(const MultiLine& Line,
const math_Vector& aPar,
-//=======================================================================
-//function : Approx_BSplComputeLine
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Approx_BSplComputeLine::Approx_BSplComputeLine
(const MultiLine& Line,
const math_Vector& Parameters,
}
-//=======================================================================
-//function : Approx_BSplComputeLine
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Approx_BSplComputeLine::Approx_BSplComputeLine
(const math_Vector& Parameters,
const Standard_Integer degreemin,
tolreached = Standard_False;
}
-//=======================================================================
-//function : Approx_BSplComputeLine
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Approx_BSplComputeLine::Approx_BSplComputeLine
(const Standard_Integer degreemin,
const Standard_Integer degreemax,
}
-//=======================================================================
-//function : Approx_BSplComputeLine
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Approx_BSplComputeLine::Approx_BSplComputeLine
(const MultiLine& Line,
const Standard_Integer degreemin,
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::Perform(const MultiLine& Line)
{
-//=======================================================================
-//function : Parameters
-//purpose :
-//=======================================================================
+//=================================================================================================
+
const TColStd_Array1OfReal& Approx_BSplComputeLine::Parameters() const
{
return myParameters->Array1();
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
+//=================================================================================================
+
const AppParCurves_MultiBSpCurve& Approx_BSplComputeLine::Value() const
{
return TheMultiBSpCurve;
}
-//=======================================================================
-//function : ChangeValue
-//purpose :
-//=======================================================================
+//=================================================================================================
+
AppParCurves_MultiBSpCurve& Approx_BSplComputeLine::ChangeValue()
{
return TheMultiBSpCurve;
}
-//=======================================================================
-//function : Parameters
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::Parameters(const MultiLine& Line,
const Standard_Integer firstP,
}
-//=======================================================================
-//function : Compute
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Approx_BSplComputeLine::Compute(const MultiLine& Line,
const Standard_Integer fpt,
const Standard_Integer lpt,
-//=======================================================================
-//function : SetParameters
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::SetParameters(const math_Vector& ThePar)
{
myfirstParam = new TColStd_HArray1OfReal(ThePar.Lower(),
}
-//=======================================================================
-//function : SetKnots
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::SetKnots(const TColStd_Array1OfReal& Knots)
{
myhasknots = Standard_True;
}
-//=======================================================================
-//function : SetKnotsAndMultiplicities
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::SetKnotsAndMultiplicities
(const TColStd_Array1OfReal& Knots,
const TColStd_Array1OfInteger& Mults)
}
}
-//=======================================================================
-//function : Init
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::Init(const Standard_Integer degreemin,
const Standard_Integer degreemax,
const Standard_Real Tolerance3d,
-//=======================================================================
-//function : SetDegrees
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::SetDegrees(const Standard_Integer degreemin,
const Standard_Integer degreemax)
{
}
-//=======================================================================
-//function : SetTolerances
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::SetTolerances(const Standard_Real Tolerance3d,
const Standard_Real Tolerance2d)
{
}
-//=======================================================================
-//function : SetConstraints
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::SetConstraints(const AppParCurves_Constraint FirstC,
const AppParCurves_Constraint LastC)
{
mylastC = LastC;
}
-//=======================================================================
-//function : SetPeriodic
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::SetPeriodic(const Standard_Boolean thePeriodic)
{
myPeriodic = thePeriodic;
}
-//=======================================================================
-//function : IsAllApproximated
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Approx_BSplComputeLine::IsAllApproximated() const
{
return alldone;
}
-//=======================================================================
-//function : IsToleranceReached
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Approx_BSplComputeLine::IsToleranceReached() const
{
return tolreached;
}
-//=======================================================================
-//function : Error
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::Error(Standard_Real& tol3d,
Standard_Real& tol2d) const
{
-//=======================================================================
-//function : SetContinuity
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::SetContinuity(const Standard_Integer C)
{
mycont = C;
-//=======================================================================
-//function : FindRealConstraints
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::FindRealConstraints(const MultiLine& Line)
{
realfirstC = myfirstC;
-//=======================================================================
-//function : Interpol
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::Interpol(const MultiLine& Line)
{
Standard_Integer i, Thefirstpt, Thelastpt, deg = 3;
}
-//=======================================================================
-//function : TangencyVector
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_BSplComputeLine::TangencyVector(
const MultiLine& Line,
const AppParCurves_MultiCurve& C,
myMaxSegments = theMaxSegments;
}
-//=======================================================================
-//function : SetInvOrder
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_ComputeCLine::SetInvOrder(const Standard_Boolean theInvOrder)
{
myInvOrder = theInvOrder;
}
-//=======================================================================
-//function : SetHangChecking
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Approx_ComputeCLine::SetHangChecking(const Standard_Boolean theHangChecking)
{
myHangChecking = theHangChecking;
#include <StdFail_NotDone.hxx>
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean CPnts_AbscissaPoint::IsDone() const
{
return myDone;
}
-//=======================================================================
-// function : Parameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real CPnts_AbscissaPoint::Parameter() const
{
return myParam;
}
-//=======================================================================
-// function : SetParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void CPnts_AbscissaPoint::SetParameter(const Standard_Real P)
{
#include <StdFail_NotDone.hxx>
#include <Standard_OutOfRange.hxx>
-//=======================================================================
-// function : IsAllDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean CPnts_UniformDeflection::IsAllDone() const
{
return myDone;
}
-//=======================================================================
-// function : Next
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void CPnts_UniformDeflection::Next()
{
myIPoint++;
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real CPnts_UniformDeflection::Value() const
{
return myParams[myIPoint + 1];
}
-//=======================================================================
-// function : Point
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Pnt CPnts_UniformDeflection::Point() const
{
#include <Geom2d_BSplineCurve.hxx>
#include <Adaptor2d_Curve2d.hxx>
-//=======================================================================
-// function : FirstParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Extrema_Curve2dTool::FirstParameter(const Adaptor2d_Curve2d& C)
{
return C.FirstParameter();
}
-//=======================================================================
-// function : LastParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Extrema_Curve2dTool::LastParameter(const Adaptor2d_Curve2d& C)
{
return C.LastParameter();
}
-//=======================================================================
-// function : Continuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_Shape Extrema_Curve2dTool::Continuity(const Adaptor2d_Curve2d& C)
{
return C.Continuity();
}
-//=======================================================================
-// function : NbIntervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer Extrema_Curve2dTool::NbIntervals(const Adaptor2d_Curve2d& C,
const GeomAbs_Shape S)
return C.NbIntervals(S);
}
-//=======================================================================
-// function : Intervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Extrema_Curve2dTool::Intervals(const Adaptor2d_Curve2d& C,
TColStd_Array1OfReal& T,
C.Intervals(T, S);
}
-//=======================================================================
-// function : IsClosed
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Extrema_Curve2dTool::IsClosed(const Adaptor2d_Curve2d& C)
{
return C.IsClosed();
}
-//=======================================================================
-// function : IsPeriodic
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Extrema_Curve2dTool::IsPeriodic(const Adaptor2d_Curve2d& C)
{
return C.IsPeriodic();
}
-//=======================================================================
-// function : Period
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Extrema_Curve2dTool::Period(const Adaptor2d_Curve2d& C)
{
return C.Period();
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Pnt2d Extrema_Curve2dTool::Value(const Adaptor2d_Curve2d& C, const Standard_Real U)
{
return C.Value(U);
}
-//=======================================================================
-// function : D0
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Extrema_Curve2dTool::D0(const Adaptor2d_Curve2d& C, const Standard_Real U, gp_Pnt2d& P)
{
C.D0(U, P);
}
-//=======================================================================
-// function : D1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Extrema_Curve2dTool::D1(const Adaptor2d_Curve2d& C,
const Standard_Real U,
C.D1(U, P, V);
}
-//=======================================================================
-// function : D2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Extrema_Curve2dTool::D2(const Adaptor2d_Curve2d& C,
const Standard_Real U,
C.D2(U, P, V1, V2);
}
-//=======================================================================
-// function : D3
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Extrema_Curve2dTool::D3(const Adaptor2d_Curve2d& C,
const Standard_Real U,
C.D3(U, P, V1, V2, V3);
}
-//=======================================================================
-// function : DN
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Vec2d Extrema_Curve2dTool::DN(const Adaptor2d_Curve2d& C,
const Standard_Real U,
return C.DN(U, N);
}
-//=======================================================================
-// function : Resolution
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Extrema_Curve2dTool::Resolution(const Adaptor2d_Curve2d& C,
const Standard_Real R3d)
return C.Resolution(R3d);
}
-//=======================================================================
-// function : GetType
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_CurveType Extrema_Curve2dTool::GetType(const Adaptor2d_Curve2d& C)
{
return C.GetType();
}
-//=======================================================================
-// function : Line
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Lin2d Extrema_Curve2dTool::Line(const Adaptor2d_Curve2d& C)
{
return C.Line();
}
-//=======================================================================
-// function : Circle
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Circ2d Extrema_Curve2dTool::Circle(const Adaptor2d_Curve2d& C)
{
return C.Circle();
}
-//=======================================================================
-// function : Ellipse
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Elips2d Extrema_Curve2dTool::Ellipse(const Adaptor2d_Curve2d& C)
{
return C.Ellipse();
}
-//=======================================================================
-// function : Hyperbola
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Hypr2d Extrema_Curve2dTool::Hyperbola(const Adaptor2d_Curve2d& C)
{
return C.Hyperbola();
}
-//=======================================================================
-// function : Parabola
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Parab2d Extrema_Curve2dTool::Parabola(const Adaptor2d_Curve2d& C)
{
return C.Parabola();
}
-//=======================================================================
-// function : NbPoles
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer Extrema_Curve2dTool::NbPoles(const Adaptor2d_Curve2d& C)
{
return C.NbPoles();
}
-//=======================================================================
-// function : Degree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer Extrema_Curve2dTool::Degree(const Adaptor2d_Curve2d& C)
{
return C.Degree();
}
-//=======================================================================
-// function : IsRational
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Extrema_Curve2dTool::IsRational(const Adaptor2d_Curve2d& C)
{
return C.Degree() != 0;
}
-//=======================================================================
-// function : NbKnots
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer Extrema_Curve2dTool::NbKnots(const Adaptor2d_Curve2d& C)
{
return C.NbKnots();
}
-//=======================================================================
-// function : Bezier
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Geom2d_BezierCurve) Extrema_Curve2dTool::Bezier(const Adaptor2d_Curve2d& C)
{
return C.Bezier();
}
-//=======================================================================
-// function : BSpline
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Geom2d_BSplineCurve) Extrema_Curve2dTool::BSpline(const Adaptor2d_Curve2d& C)
{
#include <Geom_BSplineCurve.hxx>
#include <Adaptor3d_Curve.hxx>
-//=======================================================================
-// function : FirstParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Extrema_CurveTool::FirstParameter(const Adaptor3d_Curve& C)
{
return C.FirstParameter();
}
-//=======================================================================
-// function : LastParameter
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Extrema_CurveTool::LastParameter(const Adaptor3d_Curve& C)
{
return C.LastParameter();
}
-//=======================================================================
-// function : Value
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Pnt Extrema_CurveTool::Value(const Adaptor3d_Curve& C, const Standard_Real U)
{
return C.Value(U);
}
-//=======================================================================
-// function : D0
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Extrema_CurveTool::D0(const Adaptor3d_Curve& C, const Standard_Real U, gp_Pnt& P)
{
C.D0(U, P);
}
-//=======================================================================
-// function : D1
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Extrema_CurveTool::D1(const Adaptor3d_Curve& C,
const Standard_Real U,
C.D1(U, P, V);
}
-//=======================================================================
-// function : D2
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Extrema_CurveTool::D2(const Adaptor3d_Curve& C,
const Standard_Real U,
C.D2(U, P, V1, V2);
}
-//=======================================================================
-// function : D3
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Extrema_CurveTool::D3(const Adaptor3d_Curve& C,
const Standard_Real U,
C.D3(U, P, V1, V2, V3);
}
-//=======================================================================
-// function : DN
-// purpose :
-//=======================================================================
+//=================================================================================================
+
inline gp_Vec Extrema_CurveTool::DN(const Adaptor3d_Curve& C,
const Standard_Real U,
const Standard_Integer N)
return C.DN(U, N);
}
-//=======================================================================
-// function : Continuity
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_Shape Extrema_CurveTool::Continuity(const Adaptor3d_Curve& C)
{
return C.Continuity();
}
-//=======================================================================
-// function : NbIntervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer Extrema_CurveTool::NbIntervals(Adaptor3d_Curve& C, const GeomAbs_Shape S)
{
return C.NbIntervals(S);
}
-//=======================================================================
-// function : Intervals
-// purpose :
-//=======================================================================
+//=================================================================================================
inline void Extrema_CurveTool::Intervals(Adaptor3d_Curve& C,
TColStd_Array1OfReal& T,
C.Intervals(T, S);
}
-//=======================================================================
-// function : Period
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Extrema_CurveTool::Period(const Adaptor3d_Curve& C)
{
return C.Period();
}
-//=======================================================================
-// function : GetType
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomAbs_CurveType Extrema_CurveTool::GetType(const Adaptor3d_Curve& C)
{
return C.GetType();
}
-//=======================================================================
-// function : Line
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Lin Extrema_CurveTool::Line(const Adaptor3d_Curve& C)
{
return C.Line();
}
-//=======================================================================
-// function : Circle
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Circ Extrema_CurveTool::Circle(const Adaptor3d_Curve& C)
{
return C.Circle();
}
-//=======================================================================
-// function : Ellipse
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Elips Extrema_CurveTool::Ellipse(const Adaptor3d_Curve& C)
{
return C.Ellipse();
}
-//=======================================================================
-// function : Hyperbola
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Hypr Extrema_CurveTool::Hyperbola(const Adaptor3d_Curve& C)
{
return C.Hyperbola();
}
-//=======================================================================
-// function : Parabola
-// purpose :
-//=======================================================================
+//=================================================================================================
inline gp_Parab Extrema_CurveTool::Parabola(const Adaptor3d_Curve& C)
{
return C.Parabola();
}
-//=======================================================================
-// function : NbPoles
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer Extrema_CurveTool::NbPoles(const Adaptor3d_Curve& C)
{
return C.NbPoles();
}
-//=======================================================================
-// function : Degree
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer Extrema_CurveTool::Degree(const Adaptor3d_Curve& C)
{
return C.Degree();
}
-//=======================================================================
-// function : IsRational
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean Extrema_CurveTool::IsRational(const Adaptor3d_Curve& C)
{
return C.IsRational();
}
-//=======================================================================
-// function : NbKnots
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Integer Extrema_CurveTool::NbKnots(const Adaptor3d_Curve& C)
{
return C.NbKnots();
}
-//=======================================================================
-// function : Bezier
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Geom_BezierCurve) Extrema_CurveTool::Bezier(const Adaptor3d_Curve& C)
{
return C.Bezier();
}
-//=======================================================================
-// function : BSpline
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Handle(Geom_BSplineCurve) Extrema_CurveTool::BSpline(const Adaptor3d_Curve& C)
{
return C.BSpline();
}
-//=======================================================================
-// function : Resolution
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Real Extrema_CurveTool::Resolution(const Adaptor3d_Curve& C,
const Standard_Real R3d)
#include <NCollection_Array1.hxx>
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GExtPC::Perform(const ThePoint& P)
{
mySqDist.Clear();
}
-//=======================================================================
-//function : Initialize
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GExtPC::Initialize(const TheCurve& C,
const Standard_Real Uinf,
}
-//=======================================================================
-//function : IntervalPerform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GExtPC::IntervalPerform(const ThePoint& P)
{
}
-//=======================================================================
-//function : AddSol
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GExtPC::AddSol(const Standard_Real theU, const ThePoint& theP,
const Standard_Real theSqDist,
}
-//=======================================================================
-//function : Extrema_GExtPC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GExtPC::Extrema_GExtPC()
{
type = GeomAbs_OtherCurve;
}
-//=======================================================================
-//function : Extrema_GExtPC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GExtPC::Extrema_GExtPC(const ThePoint& P,
const TheCurve& C,
Perform(P);
}
-//=======================================================================
-//function : Extrema_GExtPC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GExtPC::Extrema_GExtPC(const ThePoint& P,
const TheCurve& C,
}
-//=======================================================================
-//function : IsDone
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Extrema_GExtPC::IsDone() const
{
}
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Real Extrema_GExtPC::SquareDistance(const Standard_Integer N) const
{
}
-//=======================================================================
-//function : NbExt
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer Extrema_GExtPC::NbExt() const
{
}
-//=======================================================================
-//function : IsMin
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Extrema_GExtPC::IsMin(const Standard_Integer N) const
{
-//=======================================================================
-//function : Point
-//purpose :
-//=======================================================================
+//=================================================================================================
+
const ThePOnC & Extrema_GExtPC::Point(const Standard_Integer N) const
{
}
-//=======================================================================
-//function : TrimmedDistances
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GExtPC::TrimmedSquareDistances(Standard_Real& dist1,
Standard_Real& dist2,
#include <TColStd_Array1OfReal.hxx>
-//=======================================================================
-//function : Extrema_GLocateExtPC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GLocateExtPC::Extrema_GLocateExtPC()
: myC(NULL),
}
-//=======================================================================
-//function : Extrema_GLocateExtPC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GLocateExtPC::Extrema_GLocateExtPC (const ThePoint& P,
const TheCurve& C,
Perform(P, U0);
}
-//=======================================================================
-//function : Extrema_GLocateExtPC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GLocateExtPC::Extrema_GLocateExtPC (const ThePoint& P,
const TheCurve& C,
-//=======================================================================
-//function : Initialize
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GLocateExtPC::Initialize(const TheCurve& C,
const Standard_Real Umin,
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GLocateExtPC::Perform(const ThePoint& P,
const Standard_Real U0)
-//=======================================================================
-//function : IsDone
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Extrema_GLocateExtPC::IsDone () const
{
}
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Real Extrema_GLocateExtPC::SquareDistance () const
{
}
-//=======================================================================
-//function : IsMin
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Extrema_GLocateExtPC::IsMin () const
{
}
-//=======================================================================
-//function : Point
-//purpose :
-//=======================================================================
+//=================================================================================================
+
const ThePOnC & Extrema_GLocateExtPC::Point () const
{
return aDist;
}
-//=======================================================================
-//function : Extrema_GenExtCC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GenExtCC::Extrema_GenExtCC()
: myIsFindSingleSolution(Standard_False),
myParallel(Standard_False),
myC[0] = myC[1] = 0;
}
-//=======================================================================
-//function : Extrema_GenExtCC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GenExtCC::Extrema_GenExtCC(const Curve1& C1,
const Curve2& C2)
: myIsFindSingleSolution(Standard_False),
myUppBorder(2) = C2.LastParameter();
}
-//=======================================================================
-//function : Extrema_GenExtCC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GenExtCC::Extrema_GenExtCC(const Curve1& C1,
const Curve2& C2,
const Standard_Real Uinf,
myUppBorder(2) = Vsup;
}
-//=======================================================================
-//function : SetParams
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GenExtCC::SetParams(const Curve1& C1,
const Curve2& C2,
const Standard_Real Uinf,
myUppBorder(2) = Vsup;
}
-//=======================================================================
-//function : SetTolerance
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GenExtCC::SetTolerance(Standard_Real theTol)
{
myCurveMinTol = theTol;
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GenExtCC::Perform()
{
myDone = Standard_False;
}
}
-//=======================================================================
-//function : IsDone
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Extrema_GenExtCC::IsDone() const
{
return myDone;
}
-//=======================================================================
-//function : IsParallel
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Extrema_GenExtCC::IsParallel() const
{
if (!IsDone()) throw StdFail_NotDone();
return myParallel;
}
-//=======================================================================
-//function : NbExt
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer Extrema_GenExtCC::NbExt() const
{
if (!IsDone()) throw StdFail_NotDone();
return myPoints1.Length();
}
-//=======================================================================
-//function : SquareDistance
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Real Extrema_GenExtCC::SquareDistance(const Standard_Integer N) const
{
if (N < 1 || N > NbExt())
return Tool1::Value(*((Curve1*)myC[0]), myPoints1(N)).SquareDistance(Tool2::Value(*((Curve2*)myC[1]), myPoints2(N)));
}
-//=======================================================================
-//function : Points
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GenExtCC::Points(const Standard_Integer N,
POnC& P1,
POnC& P2) const
P2.SetValues(myPoints2(N), Tool2::Value(*((Curve2*)myC[1]), myPoints2(N)));
}
-//=======================================================================
-//function : SetSingleSolutionFlag
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GenExtCC::SetSingleSolutionFlag(const Standard_Boolean theFlag)
{
myIsFindSingleSolution = theFlag;
}
-//=======================================================================
-//function : GetSingleSolutionFlag
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Extrema_GenExtCC::GetSingleSolutionFlag() const
{
return myIsFindSingleSolution;
#include <Standard_NotImplemented.hxx>
-//=======================================================================
-//function : Extrema_GenExtPC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GenExtPC::Extrema_GenExtPC ()
: myDone(Standard_False),
-//=======================================================================
-//function : Extrema_GenExtPC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GenExtPC::Extrema_GenExtPC (const Pnt& P,
const Curve& C,
}
-//=======================================================================
-//function : Extrema_GenExtPC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GenExtPC::Extrema_GenExtPC (const Pnt& P,
const Curve& C,
}
-//=======================================================================
-//function : Initialize
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GenExtPC::Initialize(const Curve& C,
const Standard_Integer NbU,
myusup = Tool::LastParameter(C);
}
-//=======================================================================
-//function : Initialize
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GenExtPC::Initialize(const Curve& C,
const Standard_Integer NbU,
}
-//=======================================================================
-//function : Initialize
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GenExtPC::Initialize(const Standard_Integer NbU,
const Standard_Real Umin,
myusup = Usup;
}
-//=======================================================================
-//function : Initialize
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GenExtPC::Initialize(const Curve& C)
{
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GenExtPC::Perform(const Pnt& P)
/*-----------------------------------------------------------------------------
-//=======================================================================
-//function : IsDone
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Extrema_GenExtPC::IsDone () const {
}
-//=======================================================================
-//function : NbExt
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Integer Extrema_GenExtPC::NbExt () const {
}
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Real Extrema_GenExtPC::SquareDistance (const Standard_Integer N) const
{
}
-//=======================================================================
-//function : IsMin
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Extrema_GenExtPC::IsMin (const Standard_Integer N) const {
}
-//=======================================================================
-//function : Point
-//purpose :
-//=======================================================================
+//=================================================================================================
+
const POnC & Extrema_GenExtPC::Point (const Standard_Integer N) const
{
#include <Standard_DomainError.hxx>
#include <math_FunctionRoot.hxx>
-//=======================================================================
-//function : Extrema_GenLocateExtPC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GenLocateExtPC::Extrema_GenLocateExtPC()
: myDone(Standard_False),
}
-//=======================================================================
-//function : Extrema_GenLocateExtPC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GenLocateExtPC::Extrema_GenLocateExtPC (const Pnt& P,
const Curve& C,
}
-//=======================================================================
-//function : Extrema_GenLocateExtPC
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Extrema_GenLocateExtPC::Extrema_GenLocateExtPC (const Pnt& P,
const Curve& C,
}
-//=======================================================================
-//function : Initialize
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GenLocateExtPC::Initialize(const Curve& C,
const Standard_Real Umin,
}
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
+//=================================================================================================
+
void Extrema_GenLocateExtPC::Perform(const Pnt& P,
const Standard_Real U0)
}
}
-//=======================================================================
-//function : IsDone
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Extrema_GenLocateExtPC::IsDone () const
{
}
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Real Extrema_GenLocateExtPC::SquareDistance() const
{
}
-//=======================================================================
-//function : IsMin
-//purpose :
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean Extrema_GenLocateExtPC::IsMin () const
{
}
-//=======================================================================
-//function : Point
-//purpose :
-//=======================================================================
+//=================================================================================================
+
const POnC & Extrema_GenLocateExtPC::Point () const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean GeomLib_Interpolate::IsDone() const
{
return myIsDone;
}
-//=======================================================================
-// function : Error
-// purpose :
-//=======================================================================
+//=================================================================================================
inline GeomLib_InterpolationErrors GeomLib_Interpolate::Error() const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-//=======================================================================
-// function : IsDone
-// purpose :
-//=======================================================================
+//=================================================================================================
inline Standard_Boolean GeomLib_MakeCurvefromApprox::IsDone() const
{
return (gp_Parab(gp_Ax2(pt1, dir1, dir2), param1));
}
-//=======================================================================
-// function : Hyperbola
-// purpose : Returns a Hyperbola
-//=======================================================================
+//=================================================================================================
+
gp_Hypr IntAna_QuadQuadGeo::Hyperbola(const Standard_Integer n) const
{
if (!done)
//
//
-//=======================================================================
-// classn : ProjLib_Function
-// purpose :
-//=======================================================================
+
+//=================================================================================================
+
class ProjLib_Function : public AppCont_Function
{
Handle(Adaptor3d_Curve) myCurve;
TraverseSensitives(-1);
}
-//============================================================================
-// Method: Pick
-// Purpose: Picking by rectangle
-//============================================================================
+//=================================================================================================
+
void IVtkOCC_ViewerSelector::Pick(const Standard_Integer theXMin,
const Standard_Integer theYMin,
const Standard_Integer theXMax,
IMPLEMENT_STANDARD_RTTIEXT(MeshVS_SensitiveFace, Select3D_SensitiveFace)
-//=======================================================================
-// name : MeshVS_SensitiveFace::MeshVS_SensitiveFace
-// Purpose :
-//=======================================================================
+//=================================================================================================
+
MeshVS_SensitiveFace::MeshVS_SensitiveFace(const Handle(SelectMgr_EntityOwner)& theOwnerId,
const TColgp_Array1OfPnt& thePnts,
const Select3D_TypeOfSensitivity theSensitivity)
IMPLEMENT_STANDARD_RTTIEXT(MeshVS_SensitiveMesh, Select3D_SensitiveEntity)
-//=======================================================================
-// name : MeshVS_SensitiveMesh::MeshVS_SensitiveMesh
-// Purpose :
-//=======================================================================
+//=================================================================================================
+
MeshVS_SensitiveMesh::MeshVS_SensitiveMesh(const Handle(SelectMgr_EntityOwner)& theOwnerId,
const Standard_Integer theMode)
: Select3D_SensitiveEntity(theOwnerId)
return myMode;
}
-//=======================================================================
-// name : GetConnected
-// Purpose :
-//=======================================================================
+//=================================================================================================
+
Handle(Select3D_SensitiveEntity) MeshVS_SensitiveMesh::GetConnected()
{
Handle(MeshVS_SensitiveMesh) aMeshEnt = new MeshVS_SensitiveMesh(myOwnerId);
IMPLEMENT_STANDARD_RTTIEXT(MeshVS_SensitiveSegment, Select3D_SensitiveSegment)
-//=======================================================================
-// name : MeshVS_SensitiveSegment::MeshVS_SensitiveSegment
-// Purpose :
-//=======================================================================
+//=================================================================================================
+
MeshVS_SensitiveSegment::MeshVS_SensitiveSegment(const Handle(SelectMgr_EntityOwner)& theOwnerId,
const gp_Pnt& theFirstPnt,
const gp_Pnt& theLastPnt)
return h;
}
-//=======================================================================
-// name : SetSimplePrsMode
-// Purpose :
-//=======================================================================
+//=================================================================================================
+
void MeshVS_VectorPrsBuilder::SetSimplePrsMode(const Standard_Boolean IsSimpleArrow)
{
myIsSimplePrs = IsSimpleArrow;
}
-//=======================================================================
-// name : SetSimplePrsParams
-// Purpose :
-//=======================================================================
+//=================================================================================================
+
void MeshVS_VectorPrsBuilder::SetSimplePrsParams(const Standard_Real theLineWidthParam,
const Standard_Real theStartParam,
const Standard_Real theEndParam)
Handle(NCollection_Buffer) myData; //!< buffer data
};
-// =======================================================================
-// function : Create
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class BaseBufferT>
bool OpenGl_BufferCompatT<BaseBufferT>::Create(const Handle(OpenGl_Context)&)
{
return BaseBufferT::myBufferId != OpenGl_Buffer::NO_BUFFER;
}
-// =======================================================================
-// function : Release
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class BaseBufferT>
void OpenGl_BufferCompatT<BaseBufferT>::Release(OpenGl_Context*)
{
myData.Nullify();
}
-// =======================================================================
-// function : initLink
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class BaseBufferT>
bool OpenGl_BufferCompatT<BaseBufferT>::initLink(const Handle(NCollection_Buffer)& theData,
const unsigned int theComponentsNb,
return true;
}
-// =======================================================================
-// function : init
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class BaseBufferT>
bool OpenGl_BufferCompatT<BaseBufferT>::init(const Handle(OpenGl_Context)& theCtx,
const unsigned int theComponentsNb,
return true;
}
-// =======================================================================
-// function : subData
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class BaseBufferT>
bool OpenGl_BufferCompatT<BaseBufferT>::subData(const Handle(OpenGl_Context)&,
const Standard_Integer theElemFrom,
return true;
}
-// =======================================================================
-// function : getSubData
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class BaseBufferT>
bool OpenGl_BufferCompatT<BaseBufferT>::getSubData(const Handle(OpenGl_Context)&,
const Standard_Integer theElemFrom,
#include <Standard_ProgramError.hxx>
-// =======================================================================
-// function : IsCurrent
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Standard_Boolean OpenGl_Context::IsCurrent() const
{
#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
#endif
}
-// =======================================================================
-// function : MakeCurrent
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Standard_Boolean OpenGl_Context::MakeCurrent()
{
if (myGContext == NULL)
#endif
}
-// =======================================================================
-// function : SwapBuffers
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void OpenGl_Context::SwapBuffers()
{
if (myGContext == NULL)
#endif
}
-// =======================================================================
-// function : Init
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Standard_Boolean OpenGl_Context::Init (const Standard_Boolean theIsCoreProfile)
{
if (myIsInitialized)
}
};
-// =======================================================================
-// function : Create
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class theCompType, int theNbComps>
inline OpenGl_TextureFormat OpenGl_TextureFormat::Create()
{
#include <OpenGL/CGLRenderers.h>
#endif
-// =======================================================================
-// function : OpenGl_Window
-// purpose :
-// =======================================================================
+//=================================================================================================
+
OpenGl_Window::OpenGl_Window()
: myOwnGContext (false),
mySwapInterval (0)
//
}
-// =======================================================================
-// function : Init
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void OpenGl_Window::Init (const Handle(OpenGl_GraphicDriver)& theDriver,
const Handle(Aspect_Window)& thePlatformWindow,
const Handle(Aspect_Window)& theSizeWindow,
#endif
}
-// =======================================================================
-// function : Resize
-// purpose : call_subr_resize
-// =======================================================================
+//=================================================================================================
+
void OpenGl_Window::Resize()
{
// If the size is not changed - do nothing
init();
}
-// =======================================================================
-// function : init
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void OpenGl_Window::init()
{
if (!Activate())
}
}
-// =======================================================================
-// function : SetSwapInterval
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void OpenGl_Window::SetSwapInterval (Standard_Boolean theToForceNoSync)
{
const Standard_Integer aSwapInterval = theToForceNoSync ? 0 : myGlContext->caps->swapInterval;
#ifndef HAVE_OBJC_ARC
-// =======================================================================
-// function : Cocoa_LocalPool
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Cocoa_LocalPool::Cocoa_LocalPool()
: myPoolObj ([[NSAutoreleasePool alloc] init])
{
@end
#endif
-// =======================================================================
-// function : Cocoa_Window
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Cocoa_Window::Cocoa_Window (const Standard_CString theTitle,
const Standard_Integer thePxLeft,
const Standard_Integer thePxTop,
#endif
}
-// =======================================================================
-// function : Cocoa_Window
-// purpose :
-// =======================================================================
+//=================================================================================================
+
#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
Cocoa_Window::Cocoa_Window (UIView* theViewNS)
: Aspect_Window(),
}
}
-// =======================================================================
-// function : SetHView
-// purpose :
-// =======================================================================
+//=================================================================================================
+
#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
void Cocoa_Window::SetHView (UIView* theView)
{
#endif
}
-// =======================================================================
-// function : IsMapped
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Standard_Boolean Cocoa_Window::IsMapped() const
{
if (IsVirtual())
#endif
}
-// =======================================================================
-// function : Map
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void Cocoa_Window::Map() const
{
if (IsVirtual())
}
}
-// =======================================================================
-// function : Unmap
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void Cocoa_Window::Unmap() const
{
if (myHView != NULL)
}
}
-// =======================================================================
-// function : DoResize
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Aspect_TypeOfResize Cocoa_Window::DoResize()
{
if (myHView == NULL)
return aMode;
}
-// =======================================================================
-// function : DoMapping
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Standard_Boolean Cocoa_Window::DoMapping() const
{
return Standard_True;
}
-// =======================================================================
-// function : Ratio
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Standard_Real Cocoa_Window::Ratio() const
{
if (myHView == NULL)
return Standard_Real (aBounds.size.width / aBounds.size.height);
}
-// =======================================================================
-// function : Position
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void Cocoa_Window::Position (Standard_Integer& X1, Standard_Integer& Y1,
Standard_Integer& X2, Standard_Integer& Y2) const
{
#endif
}
-// =======================================================================
-// function : Size
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void Cocoa_Window::Size (Standard_Integer& theWidth,
Standard_Integer& theHeight) const
{
theHeight = (Standard_Integer )aBounds.size.height;
}
-// =======================================================================
-// function : SetTitle
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void Cocoa_Window::SetTitle (const TCollection_AsciiString& theTitle)
{
if (myHView == NULL)
#endif
}
-// =======================================================================
-// function : InvalidateContent
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void Cocoa_Window::InvalidateContent (const Handle(Aspect_DisplayConnection)& )
{
if (myHView == NULL)
}
}
-// =======================================================================
-// function : VirtualKeyFromNative
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Aspect_VKey Cocoa_Window::VirtualKeyFromNative (Standard_Integer theKey)
{
switch (theKey)
}
} // namespace Graphic3d_TransformUtils
-// =======================================================================
-// function : Convert
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <class T>
void Graphic3d_TransformUtils::Convert(const gp_Trsf& theTransformation,
typename MatrixType<T>::Mat4& theOut)
}
}
-//=======================================================================
-// class : Disk
-// function : Init
-// purpose :
-//=======================================================================
+//=================================================================================================
+
void AIS_Manipulator::Disk::Init(const Standard_ShortReal theInnerRadius,
const Standard_ShortReal theOuterRadius,
const gp_Ax1& thePosition,
myTriangulation = aTool.CreatePolyTriangulation(aTrsf);
}
-//=======================================================================
-// class : Sphere
-// function : Init
-// purpose :
-//=======================================================================
+//=================================================================================================
+
void AIS_Manipulator::Sphere::Init(const Standard_ShortReal theRadius,
const gp_Pnt& thePosition,
const ManipulatorSkin theSkinMode,
myTriangulation = aTool.CreatePolyTriangulation(aTrsf);
}
-//=======================================================================
-// class : Cube
-// function : Init
-// purpose :
-//=======================================================================
+//=================================================================================================
+
void AIS_Manipulator::Cube::Init(const gp_Ax1& thePosition,
const Standard_ShortReal theSize,
const ManipulatorSkin theSkinMode)
myArray->AddVertex(theP3, theNormal);
}
-//=======================================================================
-// class : Sector
-// function : Init
-// purpose :
-//=======================================================================
+//=================================================================================================
+
void AIS_Manipulator::Sector::Init(const Standard_ShortReal theRadius,
const gp_Ax1& thePosition,
const gp_Dir& theXDirection,
ArrowPrs);
}
-//=======================================================================
-// function : Add
-// purpose : // for offset curve
-//=======================================================================
+//=================================================================================================
void DsgPrs_EllipseRadiusPresentation::Add(const Handle(Prs3d_Presentation)& aPresentation,
const Handle(Prs3d_Drawer)& aDrawer,
return Standard_False;
}
-//=======================================================================
-// function : Constructor
-// purpose : vertex Fix Relation
-//=======================================================================
+//=================================================================================================
PrsDim_FixRelation::PrsDim_FixRelation(const TopoDS_Shape& aShape,
const Handle(Geom_Plane)& aPlane,
myArrowSize = 5.;
}
-//=======================================================================
-// function : Constructor
-// purpose : vertex Fix Relation
-//=======================================================================
+//=================================================================================================
PrsDim_FixRelation::PrsDim_FixRelation(const TopoDS_Shape& aShape,
const Handle(Geom_Plane)& aPlane,
return Standard_True;
}
-// =======================================================================
-// function : hasSphereOverlap
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <int N>
Standard_Boolean SelectMgr_Frustum<N>::hasSphereOverlap(const gp_Pnt& thePnt,
const Standard_Real theRadius,
return IsBoundaryIntersectSphere(aCenterProj, theRadius, aNorm, aBoundaries, isBoundaryInside);
}
-// =======================================================================
-// function : IsDotInside
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <int N>
Standard_Boolean SelectMgr_Frustum<N>::isDotInside(const gp_Pnt& thePnt,
const TColgp_Array1OfPnt& theVertices) const
return false;
}
-// =======================================================================
-// function : isSegmentsIntersect
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <int N>
Standard_Boolean SelectMgr_Frustum<N>::isSegmentsIntersect(const gp_Pnt& thePnt1Seg1,
const gp_Pnt& thePnt2Seg1,
return false;
}
-// =======================================================================
-// function : isIntersectCircle
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <int N>
Standard_Boolean SelectMgr_Frustum<N>::isIntersectCircle(
const Standard_Real theRadius,
return false;
}
-// =======================================================================
-// function : isInsideCylinderEndFace
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <int N>
Standard_Boolean SelectMgr_Frustum<N>::isInsideCylinderEndFace(
const Standard_Real theBottomRad,
return true;
}
-// =======================================================================
-// function : hasCylinderOverlap
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <int N>
Standard_Boolean SelectMgr_Frustum<N>::hasCylinderOverlap(const Standard_Real theBottomRad,
const Standard_Real theTopRad,
return isCylInsideRec;
}
-// =======================================================================
-// function : hasCircleOverlap
-// purpose :
-// =======================================================================
+//=================================================================================================
+
template <int N>
Standard_Boolean SelectMgr_Frustum<N>::hasCircleOverlap(const Standard_Real theRadius,
const gp_Trsf& theTrsf,
return theIsFilled ? !isInside || (isCenterInside && isInside) : isInside && isCenterInside;
}
-//=======================================================================
-// function : DumpJson
-// purpose :
-//=======================================================================
+//=================================================================================================
+
template <int N>
void SelectMgr_Frustum<N>::DumpJson(Standard_OStream& theOStream, Standard_Integer theDepth) const
{
projects / occt.git / commitdiff