IMPLEMENT_STANDARD_RTTIEXT(Adaptor3d_HVertex,Standard_Transient)
Adaptor3d_HVertex::Adaptor3d_HVertex ()
-{}
+: myTol(0.0)
+{
+}
Adaptor3d_HVertex::Adaptor3d_HVertex (const gp_Pnt2d& P,
}
-Adaptor3d_TopolTool::Adaptor3d_TopolTool () : myNbSamplesU(-1),nbRestr(0),idRestr(0)
-
+Adaptor3d_TopolTool::Adaptor3d_TopolTool ()
+: myNbSamplesU(-1),
+ myNbSamplesV(-1),
+ nbRestr(0),
+ idRestr(0),
+ Uinf(0.0),
+ Usup(0.0),
+ Vinf(0.0),
+ Vsup(0.0),
+ nbVtx(0),
+ idVtx(0)
{
}
AdvApp2Var_Context::
AdvApp2Var_Context()
+: myFav(0),
+ myOrdU(0),
+ myOrdV(0),
+ myLimU(0),
+ myLimV(0),
+ myNb1DSS(0),
+ myNb2DSS(0),
+ myNb3DSS(0),
+ myNbURoot(0),
+ myNbVRoot(0),
+ myJDegU(0),
+ myJDegV(0)
{
}
//purpose :
//=======================================================================
-AppBlend_AppSurf::AppBlend_AppSurf ():done(Standard_False) {}
+AppBlend_AppSurf::AppBlend_AppSurf ()
+: done(Standard_False),
+ dmin(0),
+ dmax(0),
+ tol3d(0.0),
+ tol2d(0.0),
+ nbit(0),
+ udeg(0),
+ vdeg(0),
+ knownp(Standard_False),
+ tol3dreached(0.0),
+ tol2dreached(0.0),
+ paramtype(Approx_ChordLength),
+ continuity(GeomAbs_C2)
+{
+ critweights[0]=0.4;
+ critweights[1]=0.2;
+ critweights[2]=0.4;
+}
//=======================================================================
const Standard_Real Tol3d,
const Standard_Real Tol2d,
const Standard_Integer NbIt,
- const Standard_Boolean KnownParameters):
- done(Standard_False),dmin(Degmin),dmax(Degmax),
- tol3d(Tol3d),tol2d(Tol2d),nbit(NbIt),knownp(KnownParameters)
+ const Standard_Boolean KnownParameters)
+: done(Standard_False),
+ dmin(Degmin),
+ dmax(Degmax),
+ tol3d(Tol3d),
+ tol2d(Tol2d),
+ nbit(NbIt),
+ udeg(0),
+ vdeg(0),
+ knownp(KnownParameters),
+ tol3dreached(0.0),
+ tol2dreached(0.0),
+ paramtype(Approx_ChordLength),
+ continuity(GeomAbs_C2)
{
- continuity = GeomAbs_C2;
- paramtype = Approx_ChordLength;
critweights[0]=0.4;
critweights[1]=0.2;
critweights[2]=0.4;
const Standard_Integer FirstPoint,
const Standard_Integer LastPoint):
mySSP(SSP),
+ myQuadraticWeight(0.0),
+ myQualityWeight(0.0),
myPntWeight(FirstPoint, LastPoint),
- myE(0)
+ myLength(0.0),
+ myE(0),
+ IF(0),
+ IL(0)
{
+ memset (myEstimation, 0, sizeof (myEstimation));
+ memset (myPercent, 0, sizeof (myPercent));
myPntWeight.Init(1.);
}
#include <AppParCurves_ConstraintCouple.hxx>
AppParCurves_ConstraintCouple::
- AppParCurves_ConstraintCouple() {}
+ AppParCurves_ConstraintCouple()
+: myIndex(-1),
+ myConstraint(AppParCurves_NoConstraint)
+{
+}
AppParCurves_ConstraintCouple::
const Standard_Real Tol3d,
const Standard_Real Tol2d,
const Standard_Integer NbIterations):
- ParError(FirstPoint, LastPoint,0.0) {
+ ParError(FirstPoint, LastPoint,0.0),
+ AvError(0.0),
+ MError3d(0.0),
+ MError2d(0.0)
+{
// Standard_Boolean grad = Standard_True;
Standard_Integer j, k, i2, l;
//purpose :
//=======================================================================
-AppParCurves_MultiBSpCurve::AppParCurves_MultiBSpCurve() {}
+AppParCurves_MultiBSpCurve::AppParCurves_MultiBSpCurve()
+: myDegree(0)
+{
+}
//=======================================================================
AppParCurves_MultiBSpCurve::AppParCurves_MultiBSpCurve
(const Standard_Integer NbPol):
- AppParCurves_MultiCurve(NbPol)
+ AppParCurves_MultiCurve(NbPol),
+ myDegree(0)
{
}
#define tabPoint Handle(TColgp_HArray1OfPnt)::DownCast (ttabPoint)
#define tabPoint2d Handle(TColgp_HArray1OfPnt2d)::DownCast (ttabPoint2d)
-AppParCurves_MultiPoint::AppParCurves_MultiPoint() {}
+AppParCurves_MultiPoint::AppParCurves_MultiPoint()
+: nbP(0),
+ nbP2d(0)
+{
+}
AppParCurves_MultiPoint::AppParCurves_MultiPoint (const Standard_Integer NbPoles,
myInvOrder = Standard_True;
myHangChecking = Standard_True;
alldone = Standard_False;
+ tolreached = Standard_False;
+ currenttol3d = 0.0;
+ currenttol2d = 0.0;
Perform(Line);
}
myMaxSegments = MAXSEGM;
myInvOrder = Standard_True;
myHangChecking = Standard_True;
+ tolreached = Standard_False;
+ currenttol3d = 0.0;
+ currenttol2d = 0.0;
}
//=======================================================================
const GeomAbs_Shape Order,
const Standard_Integer MaxDegree,
const Standard_Integer MaxSegments)
+: myMaxError2d1(0.0),
+ myMaxError2d2(0.0)
{
#ifdef OCCT_DEBUG_CHRONO
t_total = t_init = t_approx = t_uparam = 0;
//--------------------------------------------------------------------------------
ApproxInt_ImpPrmSvSurfaces::ApproxInt_ImpPrmSvSurfaces( const TheISurface& ISurf
,const ThePSurface& PSurf):
+ MyIsTangent(Standard_False),
MyHasBeenComputed(Standard_False),
+ MyIsTangentbis(Standard_False),
MyHasBeenComputedbis(Standard_False),
MyImplicitFirst(Standard_True),
MyZerImpFunc(PSurf,ISurf)
//--------------------------------------------------------------------------------
ApproxInt_ImpPrmSvSurfaces::ApproxInt_ImpPrmSvSurfaces( const ThePSurface& PSurf
,const TheISurface& ISurf):
+ MyIsTangent(Standard_False),
MyHasBeenComputed(Standard_False),
+ MyIsTangentbis(Standard_False),
MyHasBeenComputedbis(Standard_False),
MyImplicitFirst(Standard_False),
MyZerImpFunc(PSurf,ISurf)
//--------------------------------------------------------------------------------
ApproxInt_PrmPrmSvSurfaces::ApproxInt_PrmPrmSvSurfaces( const ThePSurface& Surf1
,const ThePSurface& Surf2):
+ MyIsTangent(Standard_False),
MyHasBeenComputed(Standard_False),
+ MyIsTangentbis(Standard_False),
MyHasBeenComputedbis(Standard_False),
MyIntersectionOn2S(Surf1,Surf2,TOLTANGENCY)
{
//=======================================================================
BRepBlend_CurvPointRadInv::BRepBlend_CurvPointRadInv
(const Handle(Adaptor3d_HCurve)& C1,
- const Handle(Adaptor3d_HCurve)& C2) : curv1(C1), curv2(C2)
+ const Handle(Adaptor3d_HCurve)& C2)
+: curv1(C1),
+ curv2(C2),
+ choix(0)
{
}
const Standard_Real Tol) :
pt(P),
tang(gp_Vec(0,0,0)),
- param(Param),u(W),tol(Tol),isvtx(Standard_False),
+ param(Param),u(W),v(0.0),
+ tol(Tol),isvtx(Standard_False),
hastang(Standard_False)
{}
#include <IntSurf_Transition.hxx>
#include <Standard_DomainError.hxx>
-BRepBlend_PointOnRst::BRepBlend_PointOnRst () {}
+BRepBlend_PointOnRst::BRepBlend_PointOnRst ()
+: prm(0.0)
+{
+}
BRepBlend_PointOnRst::BRepBlend_PointOnRst(const Handle(Adaptor2d_HCurve2d)& A,
surf1(Surf1), surf2(Surf2), rst1(Rst1), rst2(Rst2),
cons1(Rst1, Surf1), cons2(Rst2, Surf2),
guide(CGuide), tguide(CGuide),
- istangent(Standard_True), maxang(RealFirst()), minang(RealLast()),
- distmin(RealLast()),
- mySShape(BlendFunc_Rational)
-{}
+ prmrst1(0.0), prmrst2(0.0),
+ istangent(Standard_True), ray(0.0),
+ choix(0), normtg(0.0), theD(0.0),
+ maxang(RealFirst()), minang(RealLast()),
+ distmin(RealLast()), mySShape(BlendFunc_Rational)
+{
+}
//=======================================================================
//function : NbVariables
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor2d_HCurve2d)& Rst2,
const Handle(Adaptor3d_TopolTool)& Domain2):
- sol(1,2), surf1(Surf1), domain1(Domain1),
- surf2(Surf2), domain2(Domain2), rst1(Rst1), rst2(Rst2)
+ done(Standard_False), sol(1, 2), surf1(Surf1),
+ domain1(Domain1), surf2(Surf2),
+ domain2(Domain2), rst1(Rst1), rst2(Rst2),
+ tolesp(0.0), tolgui(0.0), pasmax(0.0),
+ fleche(0.0), param(0.0), rebrou(Standard_False),
+ iscomplete(Standard_False), comptra(Standard_False), sens(0.0),
+ decrochdeb(Blend_NoDecroch), decrochfin(Blend_NoDecroch)
{
}
BRepBlend_SurfCurvConstRadInv::BRepBlend_SurfCurvConstRadInv
(const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_HCurve)& C,
- const Handle(Adaptor3d_HCurve)& Cg) : surf(S),curv(C),guide(Cg)
+ const Handle(Adaptor3d_HCurve)& Cg)
+: surf(S),
+ curv(C),
+ guide(Cg),
+ ray(0.0),
+ choix(0)
{
}
//=======================================================================
BRepBlend_SurfPointConstRadInv::BRepBlend_SurfPointConstRadInv
(const Handle(Adaptor3d_HSurface)& S,
- const Handle(Adaptor3d_HCurve)& C) : surf(S), curv(C)
+ const Handle(Adaptor3d_HCurve)& C)
+: surf(S),
+ curv(C),
+ ray(0.0),
+ choix(0)
{
}
const Handle(Adaptor3d_HCurve)& CGuide):
surf(Surf), surfrst(SurfRst), rst(Rst), cons(Rst,SurfRst),
guide(CGuide), tguide(CGuide),
- istangent(Standard_True), theD(0.), maxang(RealFirst()), minang(RealLast()),
- distmin(RealLast()),
- mySShape(BlendFunc_Rational)
-{}
+ prmrst(0.0), istangent(Standard_True),
+ ray(0.0), choix(0), normtg(0.0),
+ theD(0.), maxang(RealFirst()), minang(RealLast()),
+ distmin(RealLast()), mySShape(BlendFunc_Rational)
+{
+}
//=======================================================================
//function : NbVariables
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor2d_HCurve2d)& Rst,
const Handle(Adaptor3d_TopolTool)& Domain2):
- sol(1,3),surf1(Surf1), domain1(Domain1),
- surf2(Surf2), rst(Rst), domain2(Domain2)
+ done(Standard_False), sol(1, 3), surf1(Surf1),
+ domain1(Domain1), surf2(Surf2), rst(Rst),
+ domain2(Domain2), tolesp(0.0), tolgui(0.0),
+ pasmax(0.0), fleche(0.0), param(0.0),
+ rebrou(Standard_False), iscomplete(Standard_False),
+ comptra(Standard_False), sens(0.0),
+ decrochdeb(Standard_False), decrochfin(Standard_False)
{
}
BRepBuilderAPI_FastSewing::NodeInspector::
NodeInspector(const NCollection_Vector<FS_Vertex>& theVec,
const gp_Pnt& thePnt,
- const Standard_Real theTol):
-myVecOfVertexes(theVec), myPoint(thePnt), myResID(-1)
+ const Standard_Real theTol)
+: myVecOfVertexes(theVec),
+ myPoint(thePnt),
+ myResID(-1),
+ myIsFindingEnable(Standard_False)
{
mySQToler = theTol*theTol;
}
//=======================================================================
BRepCheck_Face::BRepCheck_Face (const TopoDS_Face& F)
+: myIntres(BRepCheck_NoError),
+ myImbres(BRepCheck_NoError),
+ myOrires(BRepCheck_NoError)
{
Init(F);
myIntdone = Standard_False;
//=======================================================================
BRepCheck_Shell::BRepCheck_Shell(const TopoDS_Shell& S)
+: myNbori(0),
+ myCdone(Standard_False),
+ myCstat(BRepCheck_NoError),
+ myOdone(Standard_False),
+ myOstat(BRepCheck_NoError)
{
Init(S);
}
//purpose :
//=======================================================================
BRepCheck_Wire::BRepCheck_Wire(const TopoDS_Wire& W)
+: myCdone(Standard_False),
+ myCstat(BRepCheck_NoError),
+ myGctrl(Standard_False)
{
Init(W);
}
//============================================================================
BRepClass3d_Intersector3d::BRepClass3d_Intersector3d()
- : done(Standard_False),hasapoint(Standard_False)
+: U(0.0),
+ V(0.0),
+ W(0.0),
+ done(Standard_False),
+ hasapoint(Standard_False),
+ state(TopAbs_UNKNOWN)
{
}
//============================================================================
//function : BRepClass3d_SClassifier
//purpose :
//=======================================================================
-BRepClass3d_SClassifier::BRepClass3d_SClassifier()
+BRepClass3d_SClassifier::BRepClass3d_SClassifier()
+: myState(0)
{
}
}
BRepClass3d_SolidClassifier::BRepClass3d_SolidClassifier(const TopoDS_Shape& S)
-: aSolidLoaded(Standard_True),explorer(S)
+: aSolidLoaded(Standard_True),
+ explorer(S),
+ isaholeinspace(Standard_False)
{
#if LBRCOMPT
STAT.NbConstrShape++;
//purpose :
//=======================================================================
-BRepClass3d_SolidExplorer::BRepClass3d_SolidExplorer()
+BRepClass3d_SolidExplorer::BRepClass3d_SolidExplorer()
+: myReject(Standard_True),
+ myFirstFace(0),
+ myParamOnEdge(0.0)
{
}
Standard_Real Distance; //!< Distance between sub-shapes
//! Uninitialized constructor for collection.
- BRepExtrema_CheckPair() {}
+ BRepExtrema_CheckPair()
+ : Index1(0),
+ Index2(0),
+ Distance(0.0)
+ {
+ }
//! Creates new pair of sub-shapes.
BRepExtrema_CheckPair (Standard_Integer theIndex1,
Init (Sbase, Pbase, Skface, Angle, Fuse, Modify);
}
- BRepFeat_MakeDPrism()
+ BRepFeat_MakeDPrism()
+ : myAngle(RealLast()),
+ myStatusError(BRepFeat_OK)
{
}
//purpose :
//=======================================================================
-inline BRepFeat_MakeLinearForm::BRepFeat_MakeLinearForm () {}
+inline BRepFeat_MakeLinearForm::BRepFeat_MakeLinearForm ()
+: myBnd(0.0),
+ myTol(0.0)
+{
+}
//=======================================================================
//purpose :
//=======================================================================
-inline BRepFeat_MakePrism::BRepFeat_MakePrism () {}
+inline BRepFeat_MakePrism::BRepFeat_MakePrism ()
+: myStatusError(BRepFeat_OK)
+{
+}
//=======================================================================
//purpose :
//=======================================================================
-inline BRepFeat_MakeRevol::BRepFeat_MakeRevol () {}
+inline BRepFeat_MakeRevol::BRepFeat_MakeRevol ()
+: myStatusError(BRepFeat_OK)
+{
+}
//=======================================================================
//purpose :
//=======================================================================
-inline BRepFeat_MakeRevolutionForm::BRepFeat_MakeRevolutionForm () {}
+inline BRepFeat_MakeRevolutionForm::BRepFeat_MakeRevolutionForm ()
+: myHeight1(0.0),
+ myHeight2(0.0),
+ mySliding(Standard_False),
+ myBnd(0.0),
+ myTol(0.0),
+ myAngle1(RealLast()),
+ myAngle2(RealLast())
+{
+}
//=======================================================================
//purpose :
//=======================================================================
-inline BRepFeat_RibSlot::BRepFeat_RibSlot ()
-{}
+inline BRepFeat_RibSlot::BRepFeat_RibSlot ()
+: myFuse(Standard_False),
+ mySliding(Standard_False),
+ myStatusError(BRepFeat_OK)
+{
+}
//purpose : Constructor
//=======================================================================
BRepGProp_Sinert::BRepGProp_Sinert()
+: myEpsilon(0.0)
{
}
//purpose : Constructor
//=======================================================================
BRepGProp_Vinert::BRepGProp_Vinert()
+: myEpsilon(0.0)
{
}
//function : BRepLib_FindSurface
//purpose :
//=======================================================================
-BRepLib_FindSurface::BRepLib_FindSurface()
+BRepLib_FindSurface::BRepLib_FindSurface()
+: myTolerance(0.0),
+ myTolReached(0.0),
+ isExisted(Standard_False)
{
}
//=======================================================================
//=======================================================================
BRepLib_MakeEdge::BRepLib_MakeEdge()
-{}
+: myError(BRepLib_PointProjectionFailed)
+{
+}
//=======================================================================
//function : BRepLib_MakeEdge
{
public:
BRepLib_BndBoxVertexSelector(const TopTools_IndexedMapOfShape& theMapOfShape)
- : BRepLib_BndBoxVertexSelector::Selector(), myMapOfShape (theMapOfShape)
- {}
+ : BRepLib_BndBoxVertexSelector::Selector(),
+ myMapOfShape (theMapOfShape),
+ myTolP(0.0),
+ myVInd(0)
+ {
+ }
Standard_Boolean Reject (const Bnd_Box& theBox) const
{
//purpose : Constructeur vide.
//=============================================================================
BRepMAT2d_BisectingLocus::BRepMAT2d_BisectingLocus()
+: isDone(Standard_False),
+ nbContours(0)
{
}
//purpose :
//=======================================================================
BRepMAT2d_LinkTopoBilo::BRepMAT2d_LinkTopoBilo()
+: current(0),
+ isEmpty(Standard_True)
{
}
myCircles (new NCollection_IncAllocator(
IMeshData::MEMORY_BLOCK_SIZE_HUGE))
{
+ memset (mySupVert, 0, sizeof (mySupVert));
if (isFillCircles)
{
InitCirclesTool (theCellsCountU, theCellsCountV);
: myCircles (theVertices.Length(), new NCollection_IncAllocator(
IMeshData::MEMORY_BLOCK_SIZE_HUGE))
{
+ memset (mySupVert, 0, sizeof (mySupVert));
if ( theVertices.Length() > 2 )
{
myMeshData = new BRepMesh_DataStructureOfDelaun(
myCircles ( theVertices.Length(), new NCollection_IncAllocator(
IMeshData::MEMORY_BLOCK_SIZE_HUGE))
{
+ memset (mySupVert, 0, sizeof (mySupVert));
if ( theVertices.Length() > 2 )
{
Init( theVertices );
myCircles ( theVertexIndices.Length(), new NCollection_IncAllocator(
IMeshData::MEMORY_BLOCK_SIZE_HUGE))
{
+ memset (mySupVert, 0, sizeof (mySupVert));
perform(theVertexIndices);
}
myCircles (theVertexIndices.Length (), new NCollection_IncAllocator(
IMeshData::MEMORY_BLOCK_SIZE_HUGE))
{
+ memset (mySupVert, 0, sizeof (mySupVert));
perform (theVertexIndices, theCellsCountU, theCellsCountV);
}
//! Constructor.
BRepMesh_DelaunayDeflectionControlMeshAlgo()
: myMaxSqDeflection(-1.),
- myIsAllDegenerated(Standard_False)
+ myIsAllDegenerated(Standard_False),
+ myCircles(NULL)
{
}
//! Contains geometrical data related to node of triangle.
struct TriangleNodeInfo
{
+ TriangleNodeInfo()
+ : isFrontierLink(Standard_False)
+ {
+ }
+
gp_XY Point2d;
gp_XYZ Point;
Standard_Boolean isFrontierLink;
//! Constructor. Initializes empty provider.
BRepMesh_EdgeParameterProvider()
+ : myIsSameParam(Standard_False),
+ myFirstParam(0.0),
+ myOldFirstParam(0.0),
+ myScale(0.0),
+ myCurParam(0.0),
+ myFoundParam(0.0)
{
}
BndBox2dTreeSelector(const Standard_Real theTolerance)
: myMaxLoopSize(M_PI * theTolerance * theTolerance),
mySelfSegmentIndex(-1),
+ mySegment(0),
myIndices(256, new NCollection_IncAllocator(IMeshData::MEMORY_BLOCK_SIZE_HUGE))
{
}
gp_Pnt2d* Point2; // / using indices.
Segment()
- : Point1(NULL)
- , Point2(NULL)
+ : EdgePtr(NULL),
+ Point1(NULL),
+ Point2(NULL)
{
}
myParamsForbiddenToRemove(theParamsForbiddenToRemove),
myControlParamsForbiddenToRemove(theControlParamsForbiddenToRemove),
myAllocator(new NCollection_IncAllocator(IMeshData::MEMORY_BLOCK_SIZE_HUGE)),
- myControlParamsToRemove(new IMeshData::MapOfReal(1, myAllocator))
+ myControlParamsToRemove(new IMeshData::MapOfReal(1, myAllocator)),
+ myCurrParam(0.0),
+ myCurrControlParam(0.0),
+ myPrevControlParam(0.0)
{
}
//! Constructor.
BRepMesh_NURBSRangeSplitter()
+ : mySurfaceType(GeomAbs_OtherSurface)
{
}
//=======================================================================
BRepTools_ReShape::BRepTools_ReShape()
+: myStatus(-1)
{
myConsiderLocation = Standard_False;
}
//function : BRepTools_WireExplorer
//purpose :
//=======================================================================
-BRepTools_WireExplorer::BRepTools_WireExplorer()
+BRepTools_WireExplorer::BRepTools_WireExplorer()
+: myReverse(Standard_False),
+ myTolU(0.0),
+ myTolV(0.0)
{
}
BRepTopAdaptor_FClass2d::BRepTopAdaptor_FClass2d(const TopoDS_Face& aFace,const Standard_Real TolUV)
-: Toluv(TolUV), Face(aFace) {
+: Toluv(TolUV),
+ Face(aFace),
+ U1(0.0),
+ V1(0.0),
+ U2(0.0),
+ V2(0.0)
+{
#if LBRCOMPT
STAT.NbConstrShape++;
//function : BRepTopAdaptor_TopolTool
//purpose :
//=======================================================================
- BRepTopAdaptor_TopolTool::BRepTopAdaptor_TopolTool () : myFClass2d(NULL)
+ BRepTopAdaptor_TopolTool::BRepTopAdaptor_TopolTool ()
+ : myFClass2d(NULL),
+ myU0(0.0),
+ myV0(0.0),
+ myDU(0.0),
+ myDV(0.0)
{
myNbSamplesU=-1;
}
//! Constructor
BVH_Distance()
: BVH_Traverse <NumType, Dimension, BVHSetType, NumType>(),
- myDistance (std::numeric_limits<NumType>::max())
+ myDistance (std::numeric_limits<NumType>::max()),
+ myIsDone(Standard_False)
{
}
template<class T, int N>
BVH_DistanceField<T, N>::BVH_DistanceField (const Standard_Integer theMaximumSize,
const Standard_Boolean theComputeSign)
-: myMaximumSize (theMaximumSize),
+: myDimensionX(0),
+ myDimensionY(0),
+ myDimensionZ(0),
+ myMaximumSize (theMaximumSize),
myComputeSign (theComputeSign),
myIsParallel (Standard_False)
{
//! Constructor
BVH_PairDistance()
: BVH_PairTraverse <NumType, Dimension, BVHSetType, NumType>(),
- myDistance (std::numeric_limits<NumType>::max())
+ myDistance (std::numeric_limits<NumType>::max()),
+ myIsDone(Standard_False)
{
}
//purpose :
//=============================================================================
Bisector_BisecCC::Bisector_BisecCC()
+: sign1(0.0),
+ sign2(0.0),
+ currentInterval(0),
+ shiftParameter(0.0),
+ distMax(0.0),
+ isEmpty(Standard_True),
+ isConvex1(Standard_False),
+ isConvex2(Standard_False),
+ extensionStart(Standard_False),
+ extensionEnd(Standard_False)
{
- shiftParameter = 0;
- isEmpty = Standard_False;
}
//=============================================================================
// purpose :
//=============================================================================
Bisector_BisecPC::Bisector_BisecPC()
+: sign(0.0),
+ bisInterval(0),
+ currentInterval(0),
+ shiftParameter(0.0),
+ distMax(0.0),
+ isEmpty(Standard_True),
+ isConvex(Standard_False),
+ extensionStart(Standard_False),
+ extensionEnd(Standard_False)
{
}
// purpose :
//=============================================================================
Bisector_PointOnBis::Bisector_PointOnBis()
+: param1(0.0),
+ param2(0.0),
+ paramBis(0.0),
+ distance(0.0),
+ infinite(Standard_False)
{
}
const Handle(Adaptor3d_HCurve)& C,
const Handle(Adaptor3d_HCurve)& CG) :
- surf(S),curv(C),guide(CG),istangent(Standard_True),
- maxang(RealFirst()), minang(RealLast()),mySShape(BlendFunc_Rational)
-{}
+ surf(S),curv(C),guide(CG), prmc(0.0),
+ istangent(Standard_True), ray(0.0),
+ choix(0), normtg(0.0), theD(0.0),
+ maxang(RealFirst()), minang(RealLast()),
+ mySShape(BlendFunc_Rational)
+{
+}
//=======================================================================
const Handle(Adaptor3d_HCurve)& C) :
surf1(S1),surf2(S2),
curv(C), tcurv(C),
+ param(0),
+ dist1(RealLast()),
+ angle(RealLast()),
+ tgang(RealLast()),
FX(1, 4),
DX(1, 4, 1, 4),
istangent(Standard_True),
+ choix(0),
distmin(RealLast())
{
}
BlendFunc_ChAsymInv::BlendFunc_ChAsymInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C) :
- surf1(S1),surf2(S2),curv(C),
+ surf1(S1),surf2(S2),
+ dist1(RealLast()),
+ angle(RealLast()),
+ tgang(RealLast()),
+ curv(C), choix(0),
+ first(Standard_False),
FX(1, 4),
DX(1, 4, 1, 4)
{
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C)
:
- surf1(S1),surf2(S2),
- curv(C), tcurv(C),
- istangent(Standard_True),
- xval(1,4),
- E(1,4), DEDX(1,4,1,4), DEDT(1,4),
- D2EDX2(4,4,4),
- D2EDXDT(1,4,1,4), D2EDT2(1,4),
- maxang(RealFirst()), minang(RealLast()),
- distmin(RealLast()),
- mySShape(BlendFunc_Rational)
+ surf1(S1),surf2(S2),
+ curv(C), tcurv(C),
+ istangent(Standard_True), param(0.0),
+ ray1(0.0), ray2(0.0),
+ choix(0), xval(1, 4),
+ E(1,4), DEDX(1,4,1,4), DEDT(1,4),
+ D2EDX2(4,4,4),
+ D2EDXDT(1,4,1,4), D2EDT2(1,4),
+ maxang(RealFirst()), minang(RealLast()),
+ distmin(RealLast()),
+ mySShape(BlendFunc_Rational)
{
// Initialisaton of cash control variables.
tval = -9.876e100;
BlendFunc_ConstRadInv::BlendFunc_ConstRadInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
- const Handle(Adaptor3d_HCurve)& C):
- surf1(S1),surf2(S2),curv(C)
-{}
+ const Handle(Adaptor3d_HCurve)& C)
+: surf1(S1),
+ surf2(S2),
+ curv(C),
+ ray1(0.0),
+ ray2(0.0),
+ choix(0),
+ first(Standard_False)
+{
+}
void BlendFunc_ConstRadInv::Set(const Standard_Real R,
const Standard_Integer Choix)
BlendFunc_ConstThroat::BlendFunc_ConstThroat(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C)
- : BlendFunc_GenChamfer(S1,S2,C)
+: BlendFunc_GenChamfer(S1,S2,C),
+ istangent(Standard_False),
+ param(0.0),
+ Throat(0.0),
+ normtg(0.0),
+ theD(0.0)
{
}
BlendFunc_ConstThroatInv::BlendFunc_ConstThroatInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C)
- : BlendFunc_GenChamfInv(S1,S2,C)
+: BlendFunc_GenChamfInv(S1,S2,C),
+ Throat(0.0),
+ param(0.0),
+ sign1(0.0),
+ sign2(0.0),
+ normtg(0.0),
+ theD(0.0)
{
}
//purpose :
//=======================================================================
BlendFunc_Corde::BlendFunc_Corde(const Handle(Adaptor3d_HSurface)& S,
- const Handle(Adaptor3d_HCurve)& CG) :
- surf(S),guide(CG)
+ const Handle(Adaptor3d_HCurve)& CG)
+: surf(S),
+ guide(CG),
+ dis(0.0),
+ normtg(0.0),
+ theD(0.0),
+ istangent(Standard_False)
{
}
//=======================================================================
BlendFunc_GenChamfInv::BlendFunc_GenChamfInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
- const Handle(Adaptor3d_HCurve)& C) :
- surf1(S1),surf2(S2),curv(C)
+ const Handle(Adaptor3d_HCurve)& C)
+: surf1(S1),
+ surf2(S2),
+ curv(C),
+ choix(0),
+ first(Standard_False)
{
}
BlendFunc_GenChamfer::BlendFunc_GenChamfer(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& CG)
- : surf1(S1),surf2(S2),curv(CG),
- distmin(RealLast())
+: surf1(S1),
+ surf2(S2),
+ curv(CG),
+ choix(0),
+ tol(0.0),
+ distmin(RealLast())
{
}
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C) :
- surf1(S1),surf2(S2),curv(C),
- istangent(Standard_True),
- distmin(RealLast())
-{}
+ surf1(S1),surf2(S2),curv(C),
+ istangent(Standard_True),
+ normtg(0.0), theD(0.0),
+ distmin(RealLast())
+{
+}
Standard_Integer BlendFunc_Ruled::NbEquations () const
{
BlendFunc_RuledInv::BlendFunc_RuledInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
- const Handle(Adaptor3d_HCurve)& C) :
- surf1(S1),surf2(S2),curv(C)
-{}
+ const Handle(Adaptor3d_HCurve)& C)
+: surf1(S1),
+ surf2(S2),
+ curv(C),
+ first(Standard_False)
+{
+}
void BlendFunc_RuledInv::Set(const Standard_Boolean OnFirst,
const Handle(Adaptor2d_HCurve2d)& C)
-CDF_Store::CDF_Store() {}
+CDF_Store::CDF_Store()
+: myHasSubComponents(Standard_False),
+ myIsMainDocument(Standard_False),
+ myStatus(PCDM_SS_No_Obj)
+{
+}
CDF_Store::CDF_Store(const Handle(CDM_Document)& aDocument):myHasSubComponents(Standard_False) {
myMainDocument = aDocument;
}
CDM_MetaData::CDM_MetaData(const TCollection_ExtendedString& aFolder, const TCollection_ExtendedString& aName, const TCollection_ExtendedString& aPath,const TCollection_ExtendedString& aFileName,const Standard_Boolean ReadOnly):
myIsRetrieved(Standard_False),
+myDocument(NULL),
myFolder(aFolder),
myName(aName),
myHasVersion(Standard_False),
CDM_MetaData::CDM_MetaData(const TCollection_ExtendedString& aFolder, const TCollection_ExtendedString& aName, const TCollection_ExtendedString& aPath,const TCollection_ExtendedString& aVersion,const TCollection_ExtendedString& aFileName,const Standard_Boolean ReadOnly):
myIsRetrieved(Standard_False),
+myDocument(NULL),
myFolder(aFolder),
myName(aName),
myVersion(aVersion),
myToDocument(aToDocument),
myFromDocument(aFromDocument.operator->()),
myReferenceIdentifier(aReferenceIdentifier),
-myDocumentVersion(aToDocumentVersion)
+myDocumentVersion(aToDocumentVersion),
+myUseStorageConfiguration(Standard_False)
{}
CDM_Reference::CDM_Reference(const Handle(CDM_Document)& aFromDocument, const Handle(CDM_MetaData)& aToDocument, const Standard_Integer aReferenceIdentifier, const Handle(CDM_Application)& anApplication, const Standard_Integer aToDocumentVersion, const Standard_Boolean UseStorageConfiguration):
//purpose :
//=======================================================================
-CPnts_AbscissaPoint::CPnts_AbscissaPoint() : myDone(Standard_False)
+CPnts_AbscissaPoint::CPnts_AbscissaPoint()
+: myDone(Standard_False),
+ myL(0.0),
+ myParam(0.0),
+ myUMin(0.0),
+ myUMax(0.0)
{
}
//purpose :
//=======================================================================
-CPnts_UniformDeflection::CPnts_UniformDeflection ()
-{
- myDone = Standard_False;
+CPnts_UniformDeflection::CPnts_UniformDeflection ()
+: myDone(Standard_False),
+ my3d(Standard_False),
+ myFinish(Standard_False),
+ myTolCur(0.0),
+ myControl(Standard_False),
+ myIPoint(0),
+ myNbPoints(0),
+ myDwmax(0.0),
+ myDeflection(0.0),
+ myFirstParam(0.0),
+ myLastParam(0.0),
+ myDu(0.0)
+{
+ memset (myParams, 0, sizeof (myParams));
}
//=======================================================================
Contap_ArcFunction::Contap_ArcFunction ():
myMean(1.),
myType(Contap_ContourStd),
-myDir(0.,0.,1.)
-{}
+myDir(0.,0.,1.),
+myCosAng(0.0)
+{
+}
void Contap_ArcFunction::Set(const Handle(Adaptor3d_HSurface)& S)
static const Standard_Real Tolpetit = 1.e-8;
-Contap_ContAna::Contap_ContAna (): done(Standard_False) {}
+Contap_ContAna::Contap_ContAna ()
+: done(Standard_False),
+ nbSol(0),
+ typL(GeomAbs_OtherCurve),
+ prm(0.0)
+{
+}
void Contap_ContAna::Perform (const gp_Sphere& S,
const gp_Dir& D)
#include <Standard_DomainError.hxx>
Contap_Point::Contap_Point ():
- onarc(Standard_False),isvtx(Standard_False),ismult(Standard_False),
- myInternal(Standard_False)
-{}
+uparam(0.0), vparam(0.0), paraline(0.0),
+onarc(Standard_False), prmarc(0.0), isvtx(Standard_False),
+ismult(Standard_False), myInternal(Standard_False)
+{
+}
Contap_Point::Contap_Point (const gp_Pnt& Pt,
const Standard_Real U,
const Standard_Real V):
-pt(Pt),uparam(U),vparam(V),onarc(Standard_False),isvtx(Standard_False),
-ismult(Standard_False),myInternal(Standard_False)
-{}
+pt(Pt),uparam(U),vparam(V),
+paraline(0.0), onarc(Standard_False),
+prmarc(0.0), isvtx(Standard_False),
+ismult(Standard_False), myInternal(Standard_False)
+{
+}
\ No newline at end of file
myMean(1.),
myType(Contap_ContourStd),
myDir(0.,0.,1.),
+ myAng(0.0),
myCosAng(0.), // PI/2 - Angle de depouille
tol(1.e-6),
+ valf(0.0),
+ Usol(0.0),
+ Vsol(0.0),
+ Fpu(0.0),
+ Fpv(0.0),
+ tangent(Standard_False),
computed(Standard_False),
derived(Standard_False)
-{}
+{
+}
void Contap_SurfFunction::Set(const Handle(Adaptor3d_HSurface)& S)
{
//=======================================================================
DBRep_HideData::DBRep_HideData()
-{}
+: myView(-1),
+ myFocal(0.0),
+ myAngle(0.0)
+{
+}
//=======================================================================
//function : Set
//purpose :
//=======================================================================
Draw_Drawable3D::Draw_Drawable3D() :
+ myXmin(0.0),
+ myXmax(0.0),
+ myYmin(0.0),
+ myYmax(0.0),
isVisible(Standard_False),
isProtected(Standard_False),
myName(NULL)
isAllocated(Standard_False),
myInterp(p),
myDoLog(Standard_False),
- myDoEcho(Standard_False)
+ myDoEcho(Standard_False),
+ myFDLog(-1)
{
}
Draw_Marker2D::Draw_Marker2D(const gp_Pnt2d& P, const Draw_MarkerShape T,
const Draw_Color& C, const Standard_Real /*RSize*/) :
- myPos(P), myCol(C), myTyp(T)
+ myPos(P), myCol(C), myTyp(T), mySiz(0)
{
}
//=======================================================================
Draw_Marker3D::Draw_Marker3D(const gp_Pnt& P, const Draw_MarkerShape T,
const Draw_Color& C, const Standard_Integer S) :
- myPos(P), myCol(C), myTyp(T), mySiz(S), myIsRSiz(Standard_False)
+ myPos(P), myCol(C), myTyp(T), mySiz(S), myRSiz(0.0), myIsRSiz(Standard_False)
{
}
Draw_Marker3D::Draw_Marker3D(const gp_Pnt& P, const Draw_MarkerShape T,
const Draw_Color& C, const Standard_Real RSize) :
- myPos(P), myCol(C), myTyp(T), myRSiz(RSize), myIsRSiz(Standard_True)
+ myPos(P), myCol(C), myTyp(T), mySiz(0), myRSiz(RSize), myIsRSiz(Standard_True)
{
}
myFrameX1 (0),
myFrameY1 (0)
{
+ memset (myType, 0, sizeof (myType));
}
//=======================================================================
myFrameX1 (0),
myFrameY1 (0)
{
+ memset (myType, 0, sizeof (myType));
}
//=======================================================================
myFrameX1 (0),
myFrameY1 (0)
{
+ memset (myType, 0, sizeof (myType));
}
#endif
myFrameX1 (0),
myFrameY1 (0)
{
+ memset (myType, 0, sizeof (myType));
}
//=======================================================================
next(firstWindow),
previous(NULL),
myMemHbm(NULL),
- myUseBuffer(Standard_False)
+ myUseBuffer(Standard_False),
+ myCurrPen(0),
+ myCurrMode(0)
{
if (firstWindow) firstWindow->previous = this;
firstWindow = this;
friend class DrawWindow;
public :
//constructeur
- Segment () {}
+ Segment ()
+ : x1(0),
+ y1(0),
+ x2(0),
+ y2(0)
+ {
+ }
//destructeur
~Segment () {}
//=======================================================================
DrawDim_Dimension::DrawDim_Dimension()
: is_valued(Standard_False),
+ myValue(0.0),
myTextColor(Draw_blanc)
{
}
Extrema_ExtCC::Extrema_ExtCC (const Standard_Real TolC1,
const Standard_Real TolC2)
: myIsFindSingleSolution(Standard_False),
- myDone (Standard_False)
+ myDone (Standard_False),
+ myIsPar(Standard_False)
{
myC[0] = 0; myC[1] = 0;
myInf[0] = myInf[1] = -Precision::Infinite();
#include <StdFail_NotDone.hxx>
Extrema_ExtCC2d::Extrema_ExtCC2d()
-: myIsFindSingleSolution(Standard_False)
+: myIsFindSingleSolution(Standard_False),
+ myDone(Standard_False),
+ myIsPar(Standard_False),
+ mynbext(0),
+ inverse(Standard_False),
+ myv1(0.0),
+ myv2(0.0),
+ mytolc1(0.0),
+ mytolc2(0.0),
+ mydist11(0.0),
+ mydist12(0.0),
+ mydist21(0.0),
+ mydist22(0.0)
{
}
#include <TColStd_Array1OfReal.hxx>
#include <Extrema_ExtPS.hxx>
-Extrema_ExtCS::Extrema_ExtCS()
+Extrema_ExtCS::Extrema_ExtCS()
+: myS(NULL),
+ myDone(Standard_False),
+ myIsPar(Standard_False),
+ myuinf(0.0),
+ myusup(0.0),
+ myvinf(0.0),
+ myvsup(0.0),
+ mytolC(0.0),
+ mytolS(0.0),
+ myucinf(0.0),
+ myucsup(0.0),
+ myStype(GeomAbs_OtherSurface)
{
- myDone = Standard_False;
}
Extrema_ExtCS::Extrema_ExtCS(const Adaptor3d_Curve& C,
const Standard_Real Cte,
const Standard_Real Binf,
const Standard_Real Bsup)
+: NbRoots(0),
+ infinite_roots(Standard_False)
{
Standard_Integer i, nbessai;
Standard_Real cc ,sc, c, s, cte;
myDone = Standard_False;
myIsPar = Standard_False;
myNbExt = 0;
-
- for (Standard_Integer i = 0; i < 6; i++)
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
{
- mySqDist[i] = RealLast();
+ mySqDist[anIdx] = RealLast();
}
}
//=======================================================================
myDone = Standard_False;
myNbExt = 0;
myIsPar = Standard_False;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
const gp_Dir &aD1 = theC1.Position().Direction(),
&aD2 = theC2.Position().Direction();
myIsPar = Standard_False;
myDone = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
if (PlanarLineCircleExtrema(C1, C2))
{
myIsPar = Standard_False;
myDone = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
// Calculate T1 the reference of the ellipse ...
gp_Dir D = C1.Direction();
myIsPar = Standard_False;
myDone = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
// Calculate T1 in the reference of the hyperbola...
gp_Dir D = C1.Direction();
myIsPar = Standard_False;
myDone = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
// Calculate T1 in the reference of the parabola...
gp_Dir D = C1.Direction();
myIsPar = Standard_False;
myDone = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
//
aTolA=Precision::Angular();
aTolD=Precision::Confusion();
myDone = Standard_False;
myIsPar = Standard_False;
myNbExt = 0;
-
- for (Standard_Integer i = 0; i < 8; i++)
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
{
- mySqDist[i] = RealLast();
+ mySqDist[anIdx] = RealLast();
}
}
myDone = Standard_False;
myIsPar = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
gp_Vec2d D1(C1.Direction());
gp_Vec2d D2(C2.Direction());
myIsPar = Standard_False;
myDone = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
// Calculate T1 in the reference of the circle ...
gp_Dir2d D = C1.Direction();
myIsPar = Standard_False;
myDone = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
// Calculate T1 in the reference of the ellipse ...
gp_Dir2d D = C1.Direction();
myIsPar = Standard_False;
myDone = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
// Calculate T1 in the reference of the parabole ...
gp_Dir2d D = C1.Direction();
myIsPar = Standard_False;
myDone = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
// Calculate T1 in the reference of the parabole ...
gp_Dir2d D = C1.Direction();
myDone = Standard_False;
myNbExt = 0;
myDone = Standard_True;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
gp_Pnt2d O1 = C1.Location();
gp_Pnt2d O2 = C2.Location();
myIsPar = Standard_False;
myDone = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
Standard_Integer i, j;
myIsPar = Standard_False;
myDone = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
Standard_Integer i, j;
myIsPar = Standard_False;
myDone = Standard_False;
myNbExt = 0;
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
Standard_Integer i, j;
myDone(Standard_False),
myNbExt(0)
{
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
}
//=============================================================================
myDone(Standard_False),
myNbExt(0)
{
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
Initialize (theS,
theUmin,
theUsup,
myDone(Standard_False),
myNbExt(0)
{
+ for (size_t anIdx = 0; anIdx < sizeof (mySqDist) / sizeof (mySqDist[0]); anIdx++)
+ {
+ mySqDist[anIdx] = RealLast();
+ }
Initialize (theS,
theS->FirstUParameter(),
theS->LastUParameter(),
//=======================================================================
Extrema_ExtPS::Extrema_ExtPS()
+: myS(NULL),
+ myDone(Standard_False),
+ myuinf(0.0),
+ myusup(0.0),
+ myvinf(0.0),
+ myvsup(0.0),
+ mytolu(0.0),
+ mytolv(0.0),
+ d11(0.0),
+ d12(0.0),
+ d21(0.0),
+ d22(0.0),
+ mytype(GeomAbs_OtherSurface)
{
- myDone = Standard_False;
}
#include <Standard_OutOfRange.hxx>
#include <StdFail_NotDone.hxx>
-Extrema_ExtSS::Extrema_ExtSS()
+Extrema_ExtSS::Extrema_ExtSS()
+: myS2(NULL),
+ myDone(Standard_False),
+ myIsPar(Standard_False),
+ myuinf1(0.0),
+ myusup1(0.0),
+ myvinf1(0.0),
+ myvsup1(0.0),
+ myuinf2(0.0),
+ myusup2(0.0),
+ myvinf2(0.0),
+ myvsup2(0.0),
+ mytolS1(0.0),
+ mytolS2(0.0),
+ myStype(GeomAbs_OtherSurface)
{
- myDone = Standard_False;
}
Extrema_ExtSS::Extrema_ExtSS(const Adaptor3d_Surface& S1,
//purpose :
//=======================================================================
Extrema_FuncExtCS::Extrema_FuncExtCS()
+ : myC(NULL),
+ myS(NULL),
+ myt(0.0),
+ myU(0.0),
+ myV(0.0)
{
myCinit = Standard_False;
mySinit = Standard_False;
//purpose :
//=======================================================================
Extrema_FuncExtSS::Extrema_FuncExtSS ()
+: myS1(NULL),
+ myS2(NULL),
+ myU1(0.0),
+ myV1(0.0),
+ myU2(0.0),
+ myV2(0.0)
{
myS1init = Standard_False;
myS2init = Standard_False;
Extrema_FuncExtSS::Extrema_FuncExtSS (const Adaptor3d_Surface& S1,
const Adaptor3d_Surface& S2)
+: myU1(0.0),
+ myV1(0.0),
+ myU2(0.0),
+ myV2(0.0)
{
myS1 = (Adaptor3d_SurfacePtr)&S1;
myS2 = (Adaptor3d_SurfacePtr)&S2;
#include <Standard_TypeMismatch.hxx>
Extrema_FuncPSNorm::Extrema_FuncPSNorm ()
+: myS(NULL),
+ myU(0.0),
+ myV(0.0)
{
myPinit = Standard_False;
mySinit = Standard_False;
//=============================================================================
Extrema_FuncPSNorm::Extrema_FuncPSNorm (const gp_Pnt& P,
const Adaptor3d_Surface& S)
+: myU(0.0),
+ myV(0.0)
{
myP = P;
myS = (Adaptor3d_SurfacePtr)&S;
//purpose :
//=======================================================================
-Extrema_GLocateExtPC::Extrema_GLocateExtPC() { }
+Extrema_GLocateExtPC::Extrema_GLocateExtPC()
+: myC(NULL),
+ mydist2(0.0),
+ myismin(Standard_False),
+ myDone(Standard_False),
+ myumin(0.0),
+ myusup(0.0),
+ mytol(0.0),
+ type(GeomAbs_OtherCurve),
+ numberext(0)
+{
+}
//=======================================================================
//purpose :
//=======================================================================
Extrema_GenExtCS::Extrema_GenExtCS()
+: myDone(Standard_False),
+ mytmin(0.0),
+ mytsup(0.0),
+ myumin(0.0),
+ myusup(0.0),
+ myvmin(0.0),
+ myvsup(0.0),
+ mytsample(0),
+ myusample(0),
+ myvsample(0),
+ mytol1(0.0),
+ mytol2(0.0),
+ myS(NULL)
{
- myDone = Standard_False;
- myInit = Standard_False;
}
//=======================================================================
Standard_Boolean myDone;
- Standard_Boolean myInit;
Standard_Real mytmin;
Standard_Real mytsup;
Standard_Real myumin;
//purpose :
//=======================================================================
-Extrema_GenExtPC::Extrema_GenExtPC () {
- myDone = Standard_False;
- myInit = Standard_False;
+Extrema_GenExtPC::Extrema_GenExtPC ()
+: myDone(Standard_False),
+ myInit(Standard_False),
+ mynbsample(0),
+ myumin(0.0),
+ myusup(0.0),
+ mytolu(0.0),
+ mytolF(0.0)
+{
}
- update table TbSel.
-----------------------------------------------------------------------------*/
-Extrema_GenExtPS::Extrema_GenExtPS()
+Extrema_GenExtPS::Extrema_GenExtPS()
+: myumin(0.0),
+ myusup(0.0),
+ myvmin(0.0),
+ myvsup(0.0),
+ myusample(0),
+ myvsample(0),
+ mytolu(0.0),
+ mytolv(0.0),
+ myS(NULL)
{
myDone = Standard_False;
myInit = Standard_False;
//purpose :
//=======================================================================
Extrema_GenExtSS::Extrema_GenExtSS()
+: myu1min(0.0),
+ myu1sup(0.0),
+ myv1min(0.0),
+ myv1sup(0.0),
+ myu2min(0.0),
+ myu2sup(0.0),
+ myv2min(0.0),
+ myv2sup(0.0),
+ myusample(0),
+ myvsample(0),
+ mytol1(0.0),
+ mytol2(0.0),
+ myS2(NULL)
{
myDone = Standard_False;
myInit = Standard_False;
-----------------------------------------------------------------------------*/
{
myDone = Standard_False;
+ mySqDist = RealLast();
Standard_Real Uinf = Tool1::FirstParameter(C1);
Standard_Real Usup = Tool1::LastParameter(C1);
//purpose :
//=======================================================================
Extrema_GenLocateExtCS::Extrema_GenLocateExtCS()
+: myDone(Standard_False),
+ mySqDist(RealLast())
{
}
//purpose :
//=======================================================================
-Extrema_GenLocateExtPC::Extrema_GenLocateExtPC()
-{
- myDone = Standard_False;
+Extrema_GenLocateExtPC::Extrema_GenLocateExtPC()
+: myDone(Standard_False),
+ mytolU(0.0),
+ myumin(0.0),
+ myusup(0.0)
+{
}
//purpose :
//=======================================================================
Extrema_GenLocateExtSS::Extrema_GenLocateExtSS()
+: myDone(Standard_False),
+ mySqDist(RealLast())
{
}
Extrema_GlobOptFuncCCC0::Extrema_GlobOptFuncCCC0(const Adaptor3d_Curve& C1,
const Adaptor3d_Curve& C2)
: myC1_3d(&C1),
- myC2_3d(&C2)
+ myC2_3d(&C2),
+ myC1_2d(NULL),
+ myC2_2d(NULL)
{
myType = 1;
}
//=======================================================================
Extrema_GlobOptFuncCCC0::Extrema_GlobOptFuncCCC0(const Adaptor2d_Curve2d& C1,
const Adaptor2d_Curve2d& C2)
-: myC1_2d(&C1),
+: myC1_3d(NULL),
+ myC2_3d(NULL),
+ myC1_2d(&C1),
myC2_2d(&C2)
{
myType = 2;
Extrema_GlobOptFuncCCC1::Extrema_GlobOptFuncCCC1(const Adaptor3d_Curve& C1,
const Adaptor3d_Curve& C2)
: myC1_3d(&C1),
- myC2_3d(&C2)
+ myC2_3d(&C2),
+ myC1_2d(NULL),
+ myC2_2d(NULL)
{
myType = 1;
}
//=======================================================================
Extrema_GlobOptFuncCCC1::Extrema_GlobOptFuncCCC1(const Adaptor2d_Curve2d& C1,
const Adaptor2d_Curve2d& C2)
-: myC1_2d(&C1),
+: myC1_3d(NULL),
+ myC2_3d(NULL),
+ myC1_2d(&C1),
myC2_2d(&C2)
{
myType = 2;
Extrema_GlobOptFuncCCC2::Extrema_GlobOptFuncCCC2(const Adaptor3d_Curve& C1,
const Adaptor3d_Curve& C2)
: myC1_3d(&C1),
- myC2_3d(&C2)
+ myC2_3d(&C2),
+ myC1_2d(NULL),
+ myC2_2d(NULL)
{
myType = 1;
}
//=======================================================================
Extrema_GlobOptFuncCCC2::Extrema_GlobOptFuncCCC2(const Adaptor2d_Curve2d& C1,
const Adaptor2d_Curve2d& C2)
-: myC1_2d(&C1),
+: myC1_3d(NULL),
+ myC2_3d(NULL),
+ myC1_2d(&C1),
myC2_2d(&C2)
{
myType = 2;
const Adaptor3d_Curve& C2,
const Standard_Real U0,
const Standard_Real V0)
+: mySqDist(RealLast())
{
Standard_Real TolU = C1.Resolution(Precision::Confusion());
Standard_Real TolV = C2.Resolution(Precision::Confusion());
const Adaptor2d_Curve2d& C2,
const Standard_Real U0,
const Standard_Real V0)
+: mySqDist(RealLast())
{
Standard_Real TolU = Extrema_Curve2dTool::Resolution(C1, Precision::Confusion());
Standard_Real TolV = Extrema_Curve2dTool::Resolution(C2, Precision::Confusion());
IMPLEMENT_STANDARD_RTTIEXT(FEmTool_ElementaryCriterion,Standard_Transient)
-void FEmTool_ElementaryCriterion::Set(const Handle(TColStd_HArray2OfReal)& Coeff)
+FEmTool_ElementaryCriterion::FEmTool_ElementaryCriterion()
+: myFirst(0.0),
+ myLast(0.0)
+{
+}
+
+void FEmTool_ElementaryCriterion::Set(const Handle(TColStd_HArray2OfReal)& Coeff)
{
myCoeff = Coeff;
}
{
public:
-
+ //! Empty constructor
+ Standard_EXPORT FEmTool_ElementaryCriterion();
//! Set the coefficient of the Element (the Curve)
Standard_EXPORT void Set (const Handle(TColStd_HArray2OfReal)& Coeff);
OriginalSliding(LengthSliding),
MyBattenLaw(Law),
MyTension(BSplOrder, FlatKnots, Poles, 1, LengthSliding, Law, FreeSliding),
- MySagging(BSplOrder, FlatKnots, Poles, 1, Law, FreeSliding)
+ MySagging(BSplOrder, FlatKnots, Poles, 1, Law, FreeSliding),
+ MyStatus(FairCurve_OK)
{
}
MyPhysicalRatio(PhysicalRatio),
MyTension(BSplOrder, FlatKnots, Poles, 1, LengthSliding, Law, FreeSliding, Standard_True),
MySagging(BSplOrder, FlatKnots, Poles, 1, Law, FreeSliding),
- MyJerk( BSplOrder, FlatKnots, Poles, 1, Law, FreeSliding)
+ MyJerk( BSplOrder, FlatKnots, Poles, 1, Law, FreeSliding),
+ MyStatus(FairCurve_OK)
{
Standard_DomainError_Raise_if(PhysicalRatio < 0 || PhysicalRatio > 1,
"FairCurve_EnergyOfMVC: PhysicalRatio error" );
//=======================================================================
GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection ()
-:myDone(Standard_False),myCont(GeomAbs_C1)
+: myDone(Standard_False),
+ myDeflection(0.0),
+ myCont(GeomAbs_C1)
{
}
//purpose :
//=======================================================================
-GCPnts_TangentialDeflection::GCPnts_TangentialDeflection () { }
+GCPnts_TangentialDeflection::GCPnts_TangentialDeflection ()
+: angularDeflection(0.0),
+ curvatureDeflection(0.0),
+ uTol(0.0),
+ minNbPnts(0),
+ myMinLen(0.0),
+ lastu(0.0),
+ firstu(0.0)
+{
+}
//=======================================================================
//function : AddPoint
//=======================================================================
GCPnts_UniformDeflection::GCPnts_UniformDeflection ()
-:myDone(Standard_False)
+: myDone(Standard_False),
+ myDeflection(0.0)
{
}
GProp_PEquation::GProp_PEquation(const TColgp_Array1OfPnt& Pnts,
const Standard_Real Tol)
+: type(GProp_None)
{
GProp_PGProps Pmat(Pnts);
g = Pmat.CentreOfMass();
//purpose :
//=======================================================================
Geom_OsculatingSurface::Geom_OsculatingSurface()
- : myAlong(1,4)
+: myTol(0.0),
+ myAlong(1,4)
{
myAlong.Init(Standard_False);
}
//purpose :
//=======================================================================
Geom2dAPI_ProjectPointOnCurve::Geom2dAPI_ProjectPointOnCurve()
+: myIndex(-1)
{
myIsDone = Standard_False;
}
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real ParamOn ):
+ WellDone(Standard_False),
cirsol(1,8) ,
qualifier1(1,8),
qualifier2(1,8),
par2sol(1,8) ,
pararg1(1,8) ,
pararg2(1,8) ,
- parcen3(1,8)
+ parcen3(1,8)
{
Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
Geom2dAdaptor_Curve C2 = Qualified2.Qualified();
const Standard_Real Tolerance ,
const Standard_Real Param1 ,
const Standard_Real ParamOn ):
+ WellDone(Standard_False),
cirsol(1,8) ,
qualifier1(1,8),
qualifier2(1,8),
par2sol(1,8) ,
pararg1(1,8) ,
pararg2(1,8) ,
- parcen3(1,8)
+ parcen3(1,8)
{
Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
GeomAbs_CurveType Type1 = C1.GetType();
const Handle(Geom2d_Point)& Point2 ,
const Geom2dAdaptor_Curve& OnCurve ,
const Standard_Real Tolerance ):
+ WellDone(Standard_False),
cirsol(1,8) ,
qualifier1(1,8),
qualifier2(1,8),
par2sol(1,8) ,
pararg1(1,8) ,
pararg2(1,8) ,
- parcen3(1,8)
-
+ parcen3(1,8)
{
GeomAbs_CurveType Type3 = OnCurve.GetType();
Handle(Geom2d_Curve) Con = OnCurve.Curve();
WellDone = Standard_False;
Standard_Real Tol = Abs(Tolang);
- WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
parcen3 = 0.;
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
parcen3 = 0.;
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
throw GccEnt_BadQualifier();
parcen3 = 0.;
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
parcen3 = 0.;
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
parcen3 = 0.;
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
parcen3 = 0.;
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
parcen3 = 0.;
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
throw GccEnt_BadQualifier();
WellDone = Standard_False;
Standard_Real Tol = Abs(Tolerance);
- WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
parcen3 = 0.;
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
parcen3 = 0.;
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
parcen3 = 0.;
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
throw GccEnt_BadQualifier();
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
+ qualifier3 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
+ qualifier3 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
+ qualifier3 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
+ qualifier3 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
+ qualifier3 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() ||
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
+ qualifier3 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
+ qualifier3 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
throw GccEnt_BadQualifier();
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
+ qualifier3 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
+ qualifier3 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() ||
Standard_Real Tol = Abs(Tolerance);
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
+ qualifier3 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
par1sol = 0.;
pararg1 = 0.;
-
+ par2sol = 0.0;
+ pararg2 = 0.0;
//Standard_Real Tol = Abs(Tolang);
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (Qualified1.IsEnclosed()) { throw GccEnt_BadQualifier(); }
gp_Circ2d C1 = Qualified1.Qualified();
Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
const Standard_Real Tolang ) {
par1sol = 0.;
pararg1 = 0.;
+ par2sol = 0.0;
+ pararg2 = 0.0;
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
!(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
par1sol = 0.;
pararg1 = 0.;
+ par2sol = 0.0;
+ pararg2 = 0.0;
WellDone = Standard_False;
+ qualifier1 = GccEnt_noqualifier;
+ qualifier2 = GccEnt_noqualifier;
if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
throw GccEnt_BadQualifier();
const gp_Lin2d& TheLine ,
const Standard_Real TolAng ,
const Standard_Real Angle ):
+ Paral2(Standard_False),
linsol(1,2) ,
qualifier1(1,2),
pnttg1sol(1,2) ,
par1sol(1,2) ,
par2sol(1,2) ,
pararg1(1,2) ,
- pararg2(1,2)
+ pararg2(1,2)
{
Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
Handle(Geom2d_Curve) CC1 = C1.Curve();
const Standard_Real TolAng ,
const Standard_Real Param1 ,
const Standard_Real Angle ):
+ Paral2(Standard_False),
linsol(1,2) ,
qualifier1(1,2),
pnttg1sol(1,2) ,
par1sol(1,2) ,
par2sol(1,2) ,
pararg1(1,2) ,
- pararg2(1,2)
+ pararg2(1,2)
{
Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
Handle(Geom2d_Curve) CC1 = C1.Curve();
const Standard_Real Param1 ,
const Standard_Real TolAng ,
const Standard_Real Angle )
+: par2sol(0.0),
+ pararg2(0.0)
{
par1sol = 0.;
static const Standard_Real Probing_Step = 0.2111;
Geom2dHatch_Elements::Geom2dHatch_Elements(const Geom2dHatch_Elements& )
+: NumWire(0),
+ NumEdge(0),
+ myCurEdge(0),
+ myCurEdgePar(0.0)
{
#ifdef OCCT_DEBUG
std::cout<<" Magic Constructor in Geom2dHatch_Elements:: "<<std::endl;
// Purpose : Constructor.
//=======================================================================
-Geom2dHatch_Hatching::Geom2dHatch_Hatching () {
+Geom2dHatch_Hatching::Geom2dHatch_Hatching ()
+: myTrimDone(Standard_False),
+ myTrimFailed(Standard_False),
+ myIsDone(Standard_False),
+ myStatus(HatchGen_NoProblem)
+{
}
//=======================================================================
//purpose :
//=======================================================================
Geom2dLProp_CurAndInf2d::Geom2dLProp_CurAndInf2d()
+: isDone(Standard_False)
{
}
//purpose :
//=======================================================================
Geom2dLProp_NumericCurInf2d::Geom2dLProp_NumericCurInf2d()
+: isDone(Standard_False)
{
}
//=======================================================================
//purpose :
//=======================================================================
GeomAPI_ExtremaCurveCurve::GeomAPI_ExtremaCurveCurve()
+: myIsDone(Standard_False),
+ myIndex(0),
+ myTotalExt(Standard_False),
+ myIsInfinite(Standard_False),
+ myTotalDist(0.0)
{
- myIsDone = Standard_False;
- myTotalExt = Standard_False;
+ memset (myTotalPars, 0, sizeof (myTotalPars));
}
//purpose :
//=======================================================================
GeomAPI_ExtremaCurveSurface::GeomAPI_ExtremaCurveSurface()
+: myIsDone(Standard_False),
+ myIndex(0)
{
- myIsDone = Standard_False;
}
//purpose :
//=======================================================================
GeomAPI_ExtremaSurfaceSurface::GeomAPI_ExtremaSurfaceSurface()
+: myIsDone(Standard_False),
+ myIndex(0)
{
- myIsDone = Standard_False;
}
//purpose :
//=======================================================================
GeomAPI_ProjectPointOnCurve::GeomAPI_ProjectPointOnCurve()
+: myIsDone(Standard_False),
+ myIndex(0)
{
- myIsDone = Standard_False;
}
//=======================================================================
//function : GeomAPI_ProjectPointOnCurve
//purpose :
//=======================================================================
GeomAPI_ProjectPointOnSurf::GeomAPI_ProjectPointOnSurf()
-: myIsDone (Standard_False) { }
+: myIsDone (Standard_False),
+ myIndex(0)
+{
+}
//=======================================================================
GeomFill_ConstrainedFilling::GeomFill_ConstrainedFilling
(const Standard_Integer MaxDeg,
- const Standard_Integer MaxSeg) :
- degmax(MaxDeg),segmax(MaxSeg),appdone(Standard_False)
+ const Standard_Integer MaxSeg)
+: degmax(MaxDeg),
+ segmax(MaxSeg),
+ appdone(Standard_False),
+ nbd3(0)
{
dom[0] = dom[1] = dom[2] = dom[3] = 1.;
+ memset (ctr, 0, sizeof (ctr));
+ memset (degree, 0, sizeof (degree));
+ memset (ibound, 0, sizeof (ibound));
+ memset (mig, 0, sizeof (mig));
}
//=======================================================================
GeomFill_CornerState::GeomFill_CornerState() :
gap(RealLast()),
+ tgtang(0.0),
isconstrained(0),
+ norang(0.0),
scal(1.),
coonscnd(1)
{
//purpose :
//=======================================================================
GeomFill_Filling::GeomFill_Filling()
+: IsRational(Standard_False)
{
}
//=======================================================================
GeomFill_Frenet::GeomFill_Frenet()
+: isSngl(Standard_False)
{
}
(const Handle(GeomFill_SectionLaw)& S,
const Handle(Adaptor3d_HCurve)& C,
const Standard_Real Param)
-: TheGuide(C), TheLaw(S), TheUonS(Param)
+: TheGuide(C),
+ TheLaw(S),
+ isconst(Standard_False),
+ First(0.0),
+ Last(0.0),
+ TheUonS(Param)
{
Standard_Real Tol = Precision::Confusion();
if (TheLaw->IsConstant(Tol)) {
//===============================================================
GeomFill_SectionPlacement::
GeomFill_SectionPlacement(const Handle(GeomFill_LocationLaw)& L,
- const Handle(Geom_Geometry)& Section) :
- myLaw(L), /* myAdpSection(Section), mySection(Section), */
- Dist(RealLast()), AngleMax(0.)
+ const Handle(Geom_Geometry)& Section) :
+ myLaw(L), /* myAdpSection(Section), mySection(Section), */
+ SecParam(0.0), PathParam(0.0),
+ Dist(RealLast()), AngleMax(0.)
{
done = Standard_False;
//=======================================================================
GeomFill_SweepSectionGenerator::GeomFill_SweepSectionGenerator()
+: myRadius(0.0),
+ myIsDone(Standard_False),
+ myNbSections(0),
+ myType(-1),
+ myPolynomial(Standard_False)
{
- myIsDone = Standard_False;
}
const Standard_Integer NumPoints,
const TColgp_Array1OfPnt& PointsArray,
const TColStd_Array1OfReal& ParametersArray)
-
+: myIsDone(Standard_False)
{
Standard_Integer ii,
num_knots,
#include <gp_Vec.hxx>
GeomPlate_Aij::GeomPlate_Aij()
+: Ind1(0),
+ Ind2(0)
{
}
//---------------------------------------------------------
// Constructeur vide
//---------------------------------------------------------
-GeomPlate_CurveConstraint :: GeomPlate_CurveConstraint () :
-myLProp(2,1.e-4)
+GeomPlate_CurveConstraint :: GeomPlate_CurveConstraint ()
+: myNbPoints(0),
+ myOrder(0),
+ myTang(0),
+ myConstG0(Standard_False),
+ myConstG1(Standard_False),
+ myConstG2(Standard_False),
+ myLProp(2, 1.e-4),
+ myTolDist(0.0),
+ myTolAng(0.0),
+ myTolCurv(0.0),
+ myTolU(0.0),
+ myTolV(0.0)
{
}
myOrder(Order),
myLProp(2,TolDist),
myPoint(Pt),
+myU(0.0),
+myV(0.0),
myTolDist(TolDist),
+myTolAng(0.0),
+myTolCurv(0.0),
hasPnt2dOnSurf(Standard_False)
{ if ((myOrder>1)||(myOrder<-1))
throw Standard_Failure("GeomPlate_PointConstraint : the constraint must 0 or -1 with a point");
//function : GeomPlate_Surface
//purpose :
//=======================================================================
-GeomPlate_Surface::GeomPlate_Surface(const Handle(Geom_Surface)& Surfinit,const Plate_Plate& Surfinter) : mySurfinter(Surfinter),mySurfinit(Surfinit)
+GeomPlate_Surface::GeomPlate_Surface(const Handle(Geom_Surface)& Surfinit,const Plate_Plate& Surfinter)
+: mySurfinter(Surfinter),
+ mySurfinit(Surfinit),
+ myUmin(0.0),
+ myUmax(0.0),
+ myVmin(0.0),
+ myVmax(0.0)
{
}
ToEnableAlphaToCoverage (Standard_True),
// ray tracing parameters
IsGlobalIlluminationEnabled (Standard_False),
+ SamplesPerPixel(0),
RaytracingDepth (THE_DEFAULT_DEPTH),
IsShadowEnabled (Standard_True),
IsReflectionEnabled (Standard_False),
public:
struct IndicesT
{
+ IndicesT()
+ : ShapeIndex(-1),
+ FaceConex1(0),
+ Face1Pt1(0),
+ Face1Pt2(0),
+ FaceConex2(0),
+ Face2Pt1(0),
+ Face2Pt2(0),
+ MinSeg(0),
+ MaxSeg(0),
+ SegFlags(0)
+ {
+ }
Standard_Integer ShapeIndex;
Standard_Integer FaceConex1;
Standard_Integer Face1Pt1;
//purpose :
//=======================================================================
HLRAlgo_EdgeIterator::HLRAlgo_EdgeIterator ()
-{}
+: myNbVis(0),
+ myNbHid(0),
+ EVis(NULL),
+ EHid(NULL),
+ iVis(0),
+ iHid(0),
+ myHidStart(0.0),
+ myHidEnd(0.0),
+ myHidTolStart(0.0),
+ myHidTolEnd(0.0)
+{
+}
//=======================================================================
//function : InitHidden
//purpose :
//=======================================================================
HLRAlgo_Intersection::HLRAlgo_Intersection()
-{}
+: mySegIndex(0),
+ myIndex(0),
+ myLevel(0),
+ myParam(0.0),
+ myToler(0.0)
+{
+}
//=======================================================================
//function : HLRAlgo_Intersection
//=======================================================================
HLRAlgo_PolyAlgo::HLRAlgo_PolyAlgo ()
+: myNbrShell(0),
+ myCurShell(0),
+ myFound(Standard_False)
{
myTriangle.TolParam = 0.00000001;
myTriangle.TolAng = 0.0001;
public:
struct FaceIndices
{
+ //! The default constructor.
+ FaceIndices()
+ : Index(0),
+ Min(0),
+ Max(0)
+ {
+ }
+
Standard_Integer Index, Min, Max;
};
//! The default constructor.
Box()
+ : XMin(0.0),
+ YMin(0.0),
+ ZMin(0.0),
+ XMax(0.0),
+ YMax(0.0),
+ ZMax(0.0)
{
}
struct PlaneT
{
+ PlaneT() : D(0.0) {}
gp_XYZ Normal;
Standard_Real D;
};
struct NodeData
{
+ NodeData()
+ : PCu1(0.0),
+ PCu2(0.0),
+ Scal(0.0)
+ {
+ }
gp_XYZ Point, Normal;
gp_XY UV;
Standard_Real PCu1, PCu2, Scal;
//=======================================================================
inline HLRBRep_ShapeBounds::HLRBRep_ShapeBounds ()
-{}
+: myNbIso(0),
+ myVertStart(0),
+ myVertEnd(0),
+ myEdgeStart(0),
+ myEdgeEnd(0),
+ myFaceStart(0),
+ myFaceEnd(0)
+{
+}
//=======================================================================
//function : Shape
//purpose :
//=======================================================================
HLRBRep_Surface::HLRBRep_Surface ()
+: myType(GeomAbs_OtherSurface),
+ myProj(NULL)
{
}
const Standard_Integer ViewId,
const Standard_Boolean Debug) :
myAlgo(Alg),
+ myDispRg1(Standard_False),
+ myDispRgN(Standard_False),
myDispHid(Standard_False),
myViewId(ViewId),
myDebug(Debug),
//=======================================================================
inline HLRTopoBRep_VData::HLRTopoBRep_VData()
-{}
+: myParameter(0.0)
+{
+}
//=======================================================================
//function : Parameter
//purpose :
//=======================================================================
Hatch_Line::Hatch_Line()
+: myForm(Hatch_ANYLINE)
{
}
//purpose :
//=======================================================================
Hatch_Parameter::Hatch_Parameter()
+: myPar1(0.0),
+ myStart(Standard_False),
+ myIndex(0),
+ myPar2(0.0)
{
}
//=======================================================================
HatchGen_PointOnElement::HatchGen_PointOnElement (const IntRes2d_IntersectionPoint& Point)
+: myType(HatchGen_UNDETERMINED)
{
const IntRes2d_Transition& TrsH = Point.TransitionOfFirst() ;
const IntRes2d_Transition& TrsE = Point.TransitionOfSecond() ;
//purpose :
//=======================================================================
IntAna_Curve::IntAna_Curve()
+: Z0Cte(0.0),
+ Z0Sin(0.0),
+ Z0Cos(0.0),
+ Z0SinSin(0.0),
+ Z0CosCos(0.0),
+ Z0CosSin(0.0),
+ Z1Cte(0.0),
+ Z1Sin(0.0),
+ Z1Cos(0.0),
+ Z1SinSin(0.0),
+ Z1CosCos(0.0),
+ Z1CosSin(0.0),
+ Z2Cte(0.0),
+ Z2Sin(0.0),
+ Z2Cos(0.0),
+ Z2SinSin(0.0),
+ Z2CosCos(0.0),
+ Z2CosSin(0.0),
+ TwoCurves(Standard_False),
+ TakeZPositive(Standard_False),
+ Tolerance(0.0),
+ DomainInf(0.0),
+ DomainSup(0.0),
+ RestrictedInf(Standard_False),
+ RestrictedSup(Standard_False),
+ firstbounded(Standard_False),
+ lastbounded(Standard_False),
+ typequadric(GeomAbs_OtherSurface),
+ RCyl(0.0),
+ Angle(0.0),
+ myFirstParameter(0.0),
+ myLastParameter(0.0)
{
- typequadric=GeomAbs_OtherSurface;
- firstbounded=Standard_False;
- lastbounded=Standard_False;
}
//=======================================================================
//function : SetConeQuadValues
#include <Standard_DomainError.hxx>
#include <StdFail_NotDone.hxx>
-IntAna_Int3Pln::IntAna_Int3Pln () : done(Standard_False) {}
+IntAna_Int3Pln::IntAna_Int3Pln()
+: done(Standard_False),
+ empt(Standard_True)
+{
+}
IntAna_Int3Pln::IntAna_Int3Pln (const gp_Pln& P1, const gp_Pln& P2,
//==
CREATE(void) {
done=Standard_False;
+ parallel = Standard_False;
+ inquadric = Standard_False;
+ nbpts = 0;
+ memset (paramonc, 0, sizeof (paramonc));
}
//=============================================================================
//== L i n e - Q u a d r i c
#include <StdFail_NotDone.hxx>
#include <TColStd_Array1OfReal.hxx>
-IntAna_IntLinTorus::IntAna_IntLinTorus () : done(Standard_False)
-{}
+IntAna_IntLinTorus::IntAna_IntLinTorus ()
+: done(Standard_False),
+ nbpt(0)
+{
+ memset (theFi, 0, sizeof (theFi));
+ memset (theParam, 0, sizeof (theParam));
+ memset (theTheta, 0, sizeof (theTheta));
+}
IntAna_IntLinTorus::IntAna_IntLinTorus (const gp_Lin& L, const gp_Torus& T) {
Perform(L,T);
const Standard_Real S,
const Standard_Real Cte,
const Standard_Real Binf,
- const Standard_Real Bsup)
+ const Standard_Real Bsup)
+: infinite_roots(Standard_False)
{
Standard_Integer i, j, SvNbRoots;
Standard_Boolean Triee;
myNbMaxCurves=12;
myEpsilon=0.00000001;
myEpsilonCoeffPolyNull=0.00000001;
+ memset (nextcurve, 0, sizeof (nextcurve));
+ memset (previouscurve, 0, sizeof (previouscurve));
}
//=======================================================================
//function : IntAna_IntQuadQuad::IntAna_IntQuadQuad
#include <Standard_OutOfRange.hxx>
#include <StdFail_NotDone.hxx>
-IntAna2d_AnaIntersection::IntAna2d_AnaIntersection () {
-
- done = Standard_False;
+IntAna2d_AnaIntersection::IntAna2d_AnaIntersection ()
+: done(Standard_False),
+ para(Standard_False),
+ iden(Standard_False),
+ empt(Standard_True),
+ nbp(0)
+{
}
IntAna2d_AnaIntersection::IntAna2d_AnaIntersection (const gp_Lin2d& L1,
IntAna2d_IntPoint::IntAna2d_IntPoint (const Standard_Real X, const Standard_Real Y,
const Standard_Real U1):
- myu1(U1),myp(X,Y),myimplicit(Standard_True)
+ myu1(U1),myu2(RealLast()),myp(X,Y),myimplicit(Standard_True)
{
}
myimplicit = Standard_True;
myp.SetCoord(X,Y);
myu1 = U1;
-
+ myu2 = RealLast();
}
return;
}
Standard_Integer i,j,nbp;
- for(i=0;i<16;i++) val[i]=RealLast();
+ for (size_t anIdx = 0; anIdx < sizeof (val) / sizeof (val[0]); anIdx++)
+ {
+ val[anIdx] = RealLast();
+ sol[anIdx] = RealLast();
+ }
Standard_Real tol = Epsilon(100.0);
math_DirectPolynomialRoots MATH_A43210(A4,A3,A2,A1,A0);
const Standard_Real A1,
const Standard_Real A0) {
//-- std::cout<<" IntAna2d : A2..A0 "<<A2<<" "<<A1<<" "<<A0<<" "<<std::endl;
+ for (size_t anIdx = 0; anIdx < sizeof (val) / sizeof (val[0]); anIdx++)
+ {
+ val[anIdx] = RealLast();
+ sol[anIdx] = RealLast();
+ }
nbsol=0;
if((Abs(A2)+Abs(A1)+Abs(A0))<Epsilon(10000.0)) {
same = Standard_True;
#define Parab_2p prm2
//======================================================================
-IntCurve_IConicTool::IntCurve_IConicTool(void) {
+IntCurve_IConicTool::IntCurve_IConicTool(void)
+: prm1(0.0),
+ prm2(0.0),
+ prm3(0.0),
+ type(GeomAbs_OtherCurve)
+{
//###### PLACER LE TYPE NON DEFINI ######
}
}
//======================================================================
//======================================================================
-IntCurve_IConicTool::IntCurve_IConicTool(const gp_Lin2d& Line) {
+IntCurve_IConicTool::IntCurve_IConicTool(const gp_Lin2d& Line)
+: prm1(0.0),
+ prm2(0.0),
+ prm3(0.0)
+{
Line.Coefficients(Line_a,Line_b,Line_c);
Axis = gp_Ax22d(Line.Position(),Standard_True);
type = GeomAbs_Line;
}
//======================================================================
-IntCurve_IConicTool::IntCurve_IConicTool(const gp_Elips2d& Elips) {
+IntCurve_IConicTool::IntCurve_IConicTool(const gp_Elips2d& Elips)
+: prm1(0.0),
+ prm2(0.0),
+ prm3(0.0)
+{
Elips_a = Elips.MajorRadius();
Elips_b = Elips.MinorRadius();
Elips_c = sqrt(Elips_a*Elips_a-Elips_b*Elips_b);
type = GeomAbs_Ellipse;
}
//======================================================================
-IntCurve_IConicTool::IntCurve_IConicTool(const gp_Circ2d& C) {
+IntCurve_IConicTool::IntCurve_IConicTool(const gp_Circ2d& C)
+: prm1(0.0),
+ prm2(0.0),
+ prm3(0.0)
+{
Circle_r=C.Radius();
Axis=C.Axis();
Circle_x0=Axis.Location().X();
type = GeomAbs_Circle;
}
//======================================================================
-IntCurve_IConicTool::IntCurve_IConicTool(const gp_Parab2d& P) {
+IntCurve_IConicTool::IntCurve_IConicTool(const gp_Parab2d& P)
+: prm1(0.0),
+ prm2(0.0),
+ prm3(0.0)
+{
Parab_f=P.Focal();
Parab_2p=4.0*Parab_f;
Axis=P.Axis();
type = GeomAbs_Parabola;
}
//======================================================================
-IntCurve_IConicTool::IntCurve_IConicTool(const gp_Hypr2d& H) {
+IntCurve_IConicTool::IntCurve_IConicTool(const gp_Hypr2d& H)
+: prm1(0.0),
+ prm2(0.0),
+ prm3(0.0)
+{
Hypr_a = H.MajorRadius();
Hypr_b = H.MinorRadius();
Axis = H.Axis();
IsNull=Standard_False;
}
-Interval::Interval(const IntRes2d_Domain& Domain) {
+Interval::Interval(const IntRes2d_Domain& Domain)
+: Binf(0.0),
+ Bsup(0.0)
+{
IsNull=Standard_False;
if(Domain.HasFirstPoint()) {
HasFirstBound=Standard_True;
IntCurve_PConic::IntCurve_PConic(const gp_Circ2d& C) :
axe(C.Axis()) ,
- prm1(C.Radius()) , TheEpsX(0.00000001) , TheAccuracy(20) ,
+ prm1(C.Radius()), prm2(0.0), TheEpsX(0.00000001) , TheAccuracy(20) ,
type(GeomAbs_Circle) {
}
IntCurve_PConic::IntCurve_PConic(const gp_Parab2d& P) :
axe(P.Axis()) ,
- prm1(P.Focal()) , TheEpsX(0.00000001) , TheAccuracy(20) ,
+ prm1(P.Focal()), prm2(0.0), TheEpsX(0.00000001) , TheAccuracy(20) ,
type(GeomAbs_Parabola) {
}
IntCurve_PConic::IntCurve_PConic(const gp_Lin2d& L) :
- axe(gp_Ax22d(L.Position())) , TheEpsX(0.00000001) ,
+ axe(gp_Ax22d(L.Position())) ,
+ prm1(0.0), prm2(0.0), TheEpsX(0.00000001) ,
TheAccuracy(20) , type(GeomAbs_Line) {
}
#include <IntCurveSurface_IntersectionPoint.hxx>
//================================================================================
-IntCurveSurface_IntersectionPoint::IntCurveSurface_IntersectionPoint() { }
+IntCurveSurface_IntersectionPoint::IntCurveSurface_IntersectionPoint()
+: myUSurf(0.0),
+ myVSurf(0.0),
+ myUCurv(0.0)
+{
+}
//================================================================================
IntCurveSurface_IntersectionPoint::IntCurveSurface_IntersectionPoint(const gp_Pnt& P,
const Standard_Real USurf,
const Standard_Real TolTangency ) :
done(Standard_True),
empty(Standard_True),
+tangent(Standard_False),
myZerParFunc(surf1,surf2),
tol(TolTangency*TolTangency)
{
done(Standard_True),
empty(Standard_True),
myFunction(F),
+ w(0.0),
+ u(0.0),
+ v(0.0),
tol(TolTangency*TolTangency)
{
if(tol<1e-13) { tol=1e-13; }
IntImp_ZerImpFunc::IntImp_ZerImpFunc() :
+ surf(NULL),
+ func(NULL),
+ u(0.0),
+ v(0.0),
+ tol(0.0),
+ valf(0.0),
computed(Standard_False),
+ tangent(Standard_False),
+ tgdu(0.0),
+ tgdv(0.0),
derived(Standard_False)
{
}
IntImp_ZerImpFunc::IntImp_ZerImpFunc(const ThePSurface& PS ,
const TheISurface& IS) :
+ u(0.0),
+ v(0.0),
+ tol(0.0),
+ valf(0.0),
computed(Standard_False),
+ tangent(Standard_False),
+ tgdu(0.0),
+ tgdv(0.0),
derived(Standard_False)
{
surf = (Standard_Address)(&PS);
}
IntImp_ZerImpFunc::IntImp_ZerImpFunc(const TheISurface& IS) :
+ surf(NULL),
+ u(0.0),
+ v(0.0),
+ tol(0.0),
+ valf(0.0),
computed(Standard_False),
+ tangent(Standard_False),
+ tgdu(0.0),
+ tgdv(0.0),
derived(Standard_False)
{
func = (Standard_Address)(&IS);
IntImp_ZerParFunc::IntImp_ZerParFunc(const ThePSurface& S1 ,
- const ThePSurface& S2) {
+ const ThePSurface& S2)
+: compute(Standard_False),
+ tangent(Standard_False),
+ paramConst(0.0)
+{
surf1 = (Standard_Address)(&S1);
surf2 = (Standard_Address)(&S2);
ures2 = ThePSurfaceTool::UResolution(SURF2,Precision::Confusion());
vres2 = ThePSurfaceTool::VResolution(SURF2,Precision::Confusion());
-
+ memset (f, 0, sizeof (f));
compute = Standard_False;
tangent = Standard_False;
}
const IntSurf_TypeTrans Trans1,
const IntSurf_TypeTrans Trans2) :
IntPatch_Line(Tang,Trans1,Trans2),
- fipt(Standard_False),lapt(Standard_False)
-
+ fipt(Standard_False),
+ lapt(Standard_False),
+ indf(0),
+ indl(0)
{
typ = IntPatch_Analytic;
curv = C;
const IntSurf_Situation Situ1,
const IntSurf_Situation Situ2) :
IntPatch_Line(Tang,Situ1,Situ2),
- fipt(Standard_False),lapt(Standard_False)
-
+ fipt(Standard_False),
+ lapt(Standard_False),
+ indf(0),
+ indl(0)
{
typ = IntPatch_Analytic;
curv = C;
IntPatch_ALine::IntPatch_ALine (const IntAna_Curve& C,
const Standard_Boolean Tang) :
IntPatch_Line(Tang),
- fipt(Standard_False),lapt(Standard_False)
-
+ fipt(Standard_False),
+ lapt(Standard_False),
+ indf(0),
+ indl(0)
{
typ = IntPatch_Analytic;
curv = C;
//purpose :
//=======================================================================
IntPatch_ImpImpIntersection::IntPatch_ImpImpIntersection ():
-myDone(IntStatus_Fail)
+myDone(IntStatus_Fail),
+empt(Standard_True),
+tgte(Standard_False),
+oppo(Standard_False)
{
}
//=======================================================================
//=======================================================================
IntPatch_InterferencePolyhedron::IntPatch_InterferencePolyhedron ()
-: Intf_Interference(Standard_False)
-{}
+: Intf_Interference(Standard_False),
+ Incidence(0)
+{
+ memset (OI, 0, sizeof (OI));
+ memset (TI, 0, sizeof (TI));
+ memset (dpOeT, 0, sizeof (dpOeT));
+ memset (dpOpT, 0, sizeof (dpOpT));
+ memset (deOpT, 0, sizeof (deOpT));
+}
//=======================================================================
//function : IntPatch_InterferencePolyhedron
IntPatch_InterferencePolyhedron::IntPatch_InterferencePolyhedron
(const IntPatch_Polyhedron& FirstPol, const IntPatch_Polyhedron& SeconPol)
-: Intf_Interference(Standard_False)
+: Intf_Interference(Standard_False),
+ Incidence(0)
{
+ memset (OI, 0, sizeof (OI));
+ memset (TI, 0, sizeof (TI));
+ memset (dpOeT, 0, sizeof (dpOeT));
+ memset (dpOpT, 0, sizeof (dpOpT));
+ memset (deOpT, 0, sizeof (deOpT));
if (!IntPatch_PolyhedronTool::Bounding(FirstPol).IsOut
(IntPatch_PolyhedronTool::Bounding(SeconPol))) {
Tolerance=IntPatch_PolyhedronTool::DeflectionOverEstimation(FirstPol)+
IntPatch_InterferencePolyhedron::IntPatch_InterferencePolyhedron
(const IntPatch_Polyhedron& Objet)
-: Intf_Interference(Standard_True)
+: Intf_Interference(Standard_True),
+ Incidence(0)
{
+ memset (OI, 0, sizeof (OI));
+ memset (TI, 0, sizeof (TI));
+ memset (dpOeT, 0, sizeof (dpOeT));
+ memset (dpOpT, 0, sizeof (dpOpT));
+ memset (deOpT, 0, sizeof (deOpT));
Tolerance=IntPatch_PolyhedronTool::DeflectionOverEstimation(Objet)*2;
if (Tolerance==0.)
Tolerance=Epsilon(1000.);
//======================================================================
IntPatch_Intersection::IntPatch_Intersection ()
: done(Standard_False),
- //empt, tgte, oppo,
+ empt(Standard_True),
+ tgte(Standard_False),
+ oppo(Standard_False),
myTolArc(0.0), myTolTang(0.0),
myUVMaxStep(0.0), myFleche(0.0),
- myIsStartPnt(Standard_False)
- //myU1Start, myV1Start, myU2Start, myV2Start
+ myIsStartPnt(Standard_False),
+ myU1Start(0.0),
+ myV1Start(0.0),
+ myU2Start(0.0),
+ myV2Start(0.0)
{
}
const Standard_Real TolArc,
const Standard_Real TolTang)
: done(Standard_False),
- //empt, tgte, oppo,
+ empt(Standard_True),
+ tgte(Standard_False),
+ oppo(Standard_False),
myTolArc(TolArc), myTolTang(TolTang),
myUVMaxStep(0.0), myFleche(0.0),
- myIsStartPnt(Standard_False)
- //myU1Start, myV1Start, myU2Start, myV2Start
+ myIsStartPnt(Standard_False),
+ myU1Start(0.0),
+ myV1Start(0.0),
+ myU2Start(0.0),
+ myV2Start(0.0)
{
if(myTolArc<1e-8) myTolArc=1e-8;
if(myTolTang<1e-8) myTolTang=1e-8;
const Standard_Real TolArc,
const Standard_Real TolTang)
: done(Standard_False),
- //empt, tgte, oppo,
+ empt(Standard_True),
+ tgte(Standard_False),
+ oppo(Standard_False),
myTolArc(TolArc), myTolTang(TolTang),
myUVMaxStep(0.0), myFleche(0.0),
- myIsStartPnt(Standard_False)
- //myU1Start, myV1Start, myU2Start, myV2Start
+ myIsStartPnt(Standard_False),
+ myU1Start(0.0),
+ myV1Start(0.0),
+ myU2Start(0.0),
+ myV2Start(0.0)
{
Perform(S1,D1,TolArc,TolTang);
}
//=======================================================================
IntPatch_PolyLine::IntPatch_PolyLine ()
- : IntPatch_Polygo(INITDEFLE)
-{}
+ : IntPatch_Polygo(INITDEFLE),
+ onfirst(Standard_False)
+{
+}
//=======================================================================
//function : IntPatch_PolyLine
//=======================================================================
IntPatch_PolyLine::IntPatch_PolyLine (const Standard_Real InitDefle)
- : IntPatch_Polygo(InitDefle)
-{}
+ : IntPatch_Polygo(InitDefle),
+ onfirst(Standard_False)
+{
+}
//=======================================================================
//function : SetWLine
// function :
// purpose :
//==================================================================================
-IntPatch_PrmPrmIntersection::IntPatch_PrmPrmIntersection(): done(Standard_False)
+IntPatch_PrmPrmIntersection::IntPatch_PrmPrmIntersection()
+: done(Standard_False),
+ empt(Standard_True)
{
}
IntPatch_RLine::IntPatch_RLine (const Standard_Boolean Tang,
const IntSurf_TypeTrans Trans1,
const IntSurf_TypeTrans Trans2) :
- IntPatch_PointLine(Tang,Trans1,Trans2), fipt(Standard_False),lapt(Standard_False)
-
+ IntPatch_PointLine(Tang,Trans1,Trans2),
+ ParamInf1(0.0),
+ ParamSup1(0.0),
+ ParamInf2(0.0),
+ ParamSup2(0.0),
+ fipt(Standard_False),
+ lapt(Standard_False),
+ indf(0),
+ indl(0)
{
typ = IntPatch_Restriction;
onS2=Standard_False;
IntPatch_RLine::IntPatch_RLine (const Standard_Boolean Tang,
const IntSurf_Situation Situ1,
const IntSurf_Situation Situ2) :
- IntPatch_PointLine(Tang,Situ1,Situ2), fipt(Standard_False),lapt(Standard_False)
+ IntPatch_PointLine(Tang,Situ1,Situ2),
+ ParamInf1(0.0),
+ ParamSup1(0.0),
+ ParamInf2(0.0),
+ ParamSup2(0.0),
+ fipt(Standard_False),
+ lapt(Standard_False),
+ indf(0),
+ indl(0)
{
typ = IntPatch_Restriction;
onS2=Standard_False;
IntPatch_RLine::IntPatch_RLine (const Standard_Boolean Tang) :
- IntPatch_PointLine(Tang), fipt(Standard_False),lapt(Standard_False)
-
+ IntPatch_PointLine(Tang),
+ ParamInf1(0.0),
+ ParamSup1(0.0),
+ ParamInf2(0.0),
+ ParamSup2(0.0),
+ fipt(Standard_False),
+ lapt(Standard_False),
+ indf(0),
+ indl(0)
{
typ = IntPatch_Restriction;
onS2=Standard_False;
#include <IntRes2d_IntersectionSegment.hxx>
#include <Standard_DomainError.hxx>
-IntRes2d_IntersectionSegment::IntRes2d_IntersectionSegment ():
-
- ptfirst(),ptlast() { }
+IntRes2d_IntersectionSegment::IntRes2d_IntersectionSegment ()
+: oppos(Standard_False),
+ first(Standard_False),
+ last(Standard_False)
+{
+}
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-IntStart_PathPoint::IntStart_PathPoint () {
+IntStart_PathPoint::IntStart_PathPoint ()
+: tol(0.0),
+ isnew(Standard_True),
+ param(0.0)
+{
}
IntStart_PathPoint::IntStart_PathPoint (const gp_Pnt& P,
//purpose :
//=======================================================================
IntStart_SearchOnBoundaries::IntStart_SearchOnBoundaries ()
-: done(Standard_False)
+: done(Standard_False),
+ all(Standard_False)
{
}
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-IntStart_Segment::IntStart_Segment () {}
+IntStart_Segment::IntStart_Segment ()
+: hasfp(Standard_False),
+ haslp(Standard_False)
+{
+}
void IntStart_Segment::SetLimitPoint (const ThePathPoint& V,
#include <gp_Vec2d.hxx>
#include <IntSurf_InteriorPoint.hxx>
-IntSurf_InteriorPoint::IntSurf_InteriorPoint () {}
+IntSurf_InteriorPoint::IntSurf_InteriorPoint ()
+: paramu(0.0),
+ paramv(0.0)
+{
+}
IntSurf_InteriorPoint::IntSurf_InteriorPoint (const gp_Pnt& P,
// ============================================================
IntSurf_Quadric::IntSurf_Quadric ():typ(GeomAbs_OtherSurface),
- prm1(0.), prm2(0.), prm3(0.), prm4(0.)
-{}
+ prm1(0.), prm2(0.), prm3(0.), prm4(0.), ax3direc(Standard_False)
+{
+}
// ============================================================
IntSurf_Quadric::IntSurf_Quadric (const gp_Pln& P):
ax3(P.Position()),typ(GeomAbs_Plane)
pas(Increment),
tolerance(1,2),
epsilon(Epsilon*Epsilon),
+ reversed(Standard_False),
wd1 (IntWalk_VectorOfWalkingData::allocator_type (new NCollection_IncAllocator)),
wd2 (wd1.get_allocator()),
nbMultiplicities (wd1.get_allocator()),
+ Um(0.0),
+ UM(0.0),
+ Vm(0.0),
+ VM(0.0),
ToFillHoles(theToFillHoles)
{
}
done(Standard_True),
close(Standard_False),
+tgfirst(Standard_False),
+tglast(Standard_False),
+myTangentIdx(0),
fleche(Deflection),
+pasMax(0.0),
tolconf(Epsilon),
myTolTang(TolTangency),
sensCheminement(1),
+previoustg(Standard_False),
myIntersectionOn2S(Caro1,Caro2,TolTangency),
STATIC_BLOCAGE_SUR_PAS_TROP_GRAND(0),
STATIC_PRECEDENT_INFLEXION(0)
//purpose : Initialize for a deferred interference.
//=======================================================================
Intf_Interference::Intf_Interference (const Standard_Boolean Self)
- : SelfIntf(Self)
-{}
+ : SelfIntf(Self),
+ Tolerance(0.0)
+{
+}
//=======================================================================
//=======================================================================
Intf_Tool::Intf_Tool()
: nbSeg(0)
-{}
+{
+ memset (beginOnCurve, 0, sizeof (beginOnCurve));
+ memset (bord, 0, sizeof (bord));
+ memset (xint, 0, sizeof (xint));
+ memset (yint, 0, sizeof (yint));
+ memset (zint, 0, sizeof (zint));
+ memset (parint, 0, sizeof (parint));
+}
//=======================================================================
//function : Lin2dBox
public:
// ---------- PUBLIC METHODS ----------
- LDOM_BasicAttribute () : LDOM_BasicNode (LDOM_Node::UNKNOWN) {}
+ LDOM_BasicAttribute () : LDOM_BasicNode (LDOM_Node::UNKNOWN), myName(NULL) {}
// Empty constructor
LDOM_BasicAttribute& operator = (const LDOM_NullPtr * aNull);
//=======================================================================
Law_BSpFunc::Law_BSpFunc()
+: first(0.0),
+ last(0.0)
{
}
//purpose :
//=======================================================================
Law_Constant::Law_Constant()
+: radius(0.0),
+ first(0.0),
+ last(0.0)
{
}
IMPLEMENT_STANDARD_RTTIEXT(Law_Linear,Law_Function)
-Law_Linear::Law_Linear () {}
+Law_Linear::Law_Linear ()
+: valdeb(0.0),
+ valfin(0.0),
+ pdeb(0.0),
+ pfin(0.0)
+{
+}
void Law_Linear::Set (const Standard_Real Pdeb,
//=======================================================================
inline LocOpe_Generator::LocOpe_Generator()
+: myDone(Standard_False)
{
}
//purpose :
//=======================================================================
-inline LocOpe_LinearForm::LocOpe_LinearForm () {}
+inline LocOpe_LinearForm::LocOpe_LinearForm ()
+: myDone(Standard_False),
+ myIsTrans(Standard_False)
+{
+}
//=======================================================================
//! Empty constructor. Useful only for the list.
- LocOpe_PntFace() {}
+ LocOpe_PntFace()
+ : myPar(0.0),
+ myUPar(0.0),
+ myVPar(0.0)
+ {
+ }
LocOpe_PntFace (const gp_Pnt& P, const TopoDS_Face& F, const TopAbs_Orientation Or, const Standard_Real Param, const Standard_Real UPar, const Standard_Real VPar)
: myPnt (P), myFace (F), myOri (Or), myPar (Param), myUPar (UPar), myVPar (VPar)
//function : LocOpe_Prism
//purpose :
//=======================================================================
-LocOpe_Prism::LocOpe_Prism(): myDone(Standard_False)
-{}
+LocOpe_Prism::LocOpe_Prism()
+: myIsTrans(Standard_False),
+ myDone(Standard_False)
+{
+}
//=======================================================================
//function : LocOpe_Prism
//purpose :
//=======================================================================
-LocOpe_Revol::LocOpe_Revol() : myDone(Standard_False)
-
-{}
-
+LocOpe_Revol::LocOpe_Revol()
+: myAngle(0.0),
+ myAngTra(0.0),
+ myIsTrans(Standard_False),
+ myDone(Standard_False)
+{
+}
//=======================================================================
//function : Perform
//function : LocOpe_Revol
//purpose :
//=======================================================================
-LocOpe_RevolutionForm::LocOpe_RevolutionForm() : myDone(Standard_False)
-
-{}
+LocOpe_RevolutionForm::LocOpe_RevolutionForm()
+: myAngle(0.0),
+ myAngTra(0.0),
+ myDone(Standard_False),
+ myIsTrans(Standard_False)
+{
+}
//=======================================================================
//=======================================================================
inline LocOpe_Spliter::LocOpe_Spliter()
+: myDone(Standard_False)
{
}
//purpose :
//=======================================================================
-LocOpe_WiresOnShape::LocOpe_WiresOnShape(const TopoDS_Shape& S):
- myShape(S),myCheckInterior(Standard_True),myDone(Standard_False)
-{}
+LocOpe_WiresOnShape::LocOpe_WiresOnShape(const TopoDS_Shape& S)
+: myShape(S),
+ myCheckInterior(Standard_True),
+ myDone(Standard_False),
+ myIndex(-1)
+{
+}
//=======================================================================
//function : Init
const Standard_Real EpsG2,
const Standard_Real Percent,
const Standard_Real Maxlen )
+: myContC0(0.0),
+ myContC1(0.0),
+ myContC2(0.0),
+ myContG1(0.0),
+ myContG2(0.0),
+ myCourbC1(0.0),
+ myCourbC2(0.0),
+ myG2Variation(0.0),
+ myLambda1(0.0),
+ myLambda2(0.0)
{ myTypeCont = Order;
myepsnul= Epsnul;
myMaxLon=Maxlen;
const Standard_Real EpsG1,
const Standard_Real Percent,
const Standard_Real Maxlen)
+: myContC0(0.0),
+ myContC1U(0.0),
+ myContC1V(0.0),
+ myContC2U(0.0),
+ myContC2V(0.0),
+ myContG1(0.0),
+ myLambda1U(0.0),
+ myLambda2U(0.0),
+ myLambda1V(0.0),
+ myLambda2V(0.0),
+ myETA1(0.0),
+ myETA2(0.0),
+ myETA(0.0),
+ myZETA1(0.0),
+ myZETA2(0.0),
+ myZETA(0.0),
+ myAlpha(0.0),
+ myGap(0.0)
{ myepsnul=EpsNul;
myepsC0= EpsC0;
myepsC1= EpsC1;
const Standard_Real EpsG1,
const Standard_Real Percent,
const Standard_Real Maxlen )
+: myContC0(0.0),
+ myContC1U(0.0),
+ myContC1V(0.0),
+ myContC2U(0.0),
+ myContC2V(0.0),
+ myContG1(0.0),
+ myLambda1U(0.0),
+ myLambda2U(0.0),
+ myLambda1V(0.0),
+ myLambda2V(0.0),
+ myETA1(0.0),
+ myETA2(0.0),
+ myETA(0.0),
+ myZETA1(0.0),
+ myZETA2(0.0),
+ myZETA(0.0),
+ myAlpha(0.0),
+ myGap(0.0)
{ myTypeCont = Ordre;
myepsnul=EpsNul;
myepsC0= EpsC0;
const Standard_Real EpsG1,
const Standard_Real Percent,
const Standard_Real Maxlen )
+: myContC0(0.0),
+ myContC1U(0.0),
+ myContC1V(0.0),
+ myContC2U(0.0),
+ myContC2V(0.0),
+ myContG1(0.0),
+ myLambda1U(0.0),
+ myLambda2U(0.0),
+ myLambda1V(0.0),
+ myLambda2V(0.0),
+ myETA1(0.0),
+ myETA2(0.0),
+ myETA(0.0),
+ myZETA1(0.0),
+ myZETA2(0.0),
+ myZETA(0.0),
+ myAlpha(0.0),
+ myGap(0.0)
{ Standard_Real pard1, parf1, pard2, parf2, u1, v1, u2, v2;
myTypeCont = Ordre;
MAT_BasicElt::MAT_BasicElt(const Standard_Integer anInteger)
: startLeftArc (0),
endLeftArc (0),
- index(anInteger)
+ index(anInteger),
+ geomIndex(0)
{
}
IMPLEMENT_STANDARD_RTTIEXT(MAT_Edge,Standard_Transient)
MAT_Edge::MAT_Edge()
+: theedgenumber(0),
+ thedistance(0.0),
+ theintersectionpoint(0)
{
}
// =====================================================================
// Constructeur vide.
// =====================================================================
-MAT_Graph::MAT_Graph() {}
+MAT_Graph::MAT_Graph()
+: numberOfArcs(0),
+ numberOfNodes(0),
+ numberOfBasicElts(0),
+ numberOfInfiniteNodes(0)
+{
+}
// =====================================================================
// function : Perform
MAT_Node::MAT_Node(const Standard_Integer GeomIndex,
const Handle(MAT_Arc)& LinkedArc,
const Standard_Real Distance)
- : geomIndex(GeomIndex),
+ : nodeIndex(0),
+ geomIndex(GeomIndex),
distance(Distance)
{
aLinkedArc = LinkedArc.get();
// purpose :
//========================================================================
MAT_Zone::MAT_Zone ()
-{}
+: limited(Standard_True)
+{
+}
//========================================================================
// function:
//=============================================================================
MAT2d_Circuit::MAT2d_Circuit(const GeomAbs_JoinType aJoinType,
const Standard_Boolean IsOpenResult)
+: direction(0.0)
{
myJoinType = aJoinType;
myIsOpenResult = IsOpenResult;
//purpose :
//=============================================================================
MAT2d_Connexion::MAT2d_Connexion()
+: lineA(0),
+ lineB(0),
+ itemA(0),
+ itemB(0),
+ distance(0.0),
+ parameterOnA(0.0),
+ parameterOnB(0.0)
{
}
// purpose :
//========================================================================
MAT2d_Mat2d::MAT2d_Mat2d(const Standard_Boolean IsOpenResult)
+: semiInfinite(Standard_False),
+ isDone(Standard_False)
{
myIsOpenResult = IsOpenResult;
thenumberofbisectors = 0;
//purpose :
//============================================================================
MAT2d_MiniPath::MAT2d_MiniPath()
+: theDirection(1.0),
+ indStart(0)
{
}
IMPLEMENT_STANDARD_RTTIEXT(MoniTool_Element,Standard_Transient)
+MoniTool_Element::MoniTool_Element()
+: thecode(-1)
+{
+}
+
void MoniTool_Element::SetHashCode (const Standard_Integer code)
{ thecode = code; }
public:
+ //! Empty constructor
+ Standard_EXPORT MoniTool_Element();
+
//! Returns the HashCode which has been stored by SetHashCode
//! (remark that HashCode could be deferred then be defined by
//! sub-classes, the result is the same)
}
MoniTool_Stat::MoniTool_Stat (const MoniTool_Stat& )
-{ }
+ : thelev(0)
+{
+}
MoniTool_Stat& MoniTool_Stat::Current ()
{
projects / occt.git / commitdiff