Provide ShallowCopy() functions for adapters & evaluators of curves, 2d curves and surfaces. This will allow using copies of the same adapter in multi-thread calculations.
{
}
+//=======================================================================
+//function : ShallowCopy()
+//purpose :
+//=======================================================================
+
+Handle(Adaptor2d_Curve2d) Adaptor2d_Curve2d::ShallowCopy() const
+{
+ throw Standard_NotImplemented("Adaptor2d_Curve2d::ShallowCopy");
+}
+
//=======================================================================
//function : FirstParameter
//purpose :
{
DEFINE_STANDARD_RTTIEXT(Adaptor2d_Curve2d, Standard_Transient)
public:
+
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor2d_Curve2d) ShallowCopy() const;
Standard_EXPORT virtual Standard_Real FirstParameter() const;
{
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+ Handle(Adaptor2d_Curve2d) Adaptor2d_Line2d::ShallowCopy() const
+ {
+ Handle(Adaptor2d_Line2d) aCopy = new Adaptor2d_Line2d();
+
+ aCopy->myUfirst = myUfirst;
+ aCopy->myUlast = myUlast;
+ aCopy->myAx2d = myAx2d;
+
+ return aCopy;
+ }
+
//=======================================================================
//function : Load
//purpose :
Standard_EXPORT Adaptor2d_Line2d();
Standard_EXPORT Adaptor2d_Line2d(const gp_Pnt2d& P, const gp_Dir2d& D, const Standard_Real UFirst, const Standard_Real ULast);
-
+
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor2d_Curve2d) ShallowCopy() const Standard_OVERRIDE;
+
Standard_EXPORT void Load (const gp_Lin2d& L);
Standard_EXPORT void Load (const gp_Lin2d& L, const Standard_Real UFirst, const Standard_Real ULast);
{
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor2d_Curve2d) Adaptor2d_OffsetCurve::ShallowCopy() const
+{
+ Handle(Adaptor2d_OffsetCurve) aCopy = new Adaptor2d_OffsetCurve();
+
+ if (!myCurve.IsNull())
+ {
+ aCopy->myCurve = myCurve->ShallowCopy();
+ }
+ aCopy->myOffset = myOffset;
+ aCopy->myFirst = myFirst;
+ aCopy->myLast = myLast;
+
+ return aCopy;
+}
//=======================================================================
//function : Load
//purpose :
//! WFirst,WLast define the bounds of the Offset curve.
Standard_EXPORT Adaptor2d_OffsetCurve(const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Offset, const Standard_Real WFirst, const Standard_Real WLast);
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor2d_Curve2d) ShallowCopy() const Standard_OVERRIDE;
+
//! Changes the curve. The Offset is reset to 0.
Standard_EXPORT void Load (const Handle(Adaptor2d_Curve2d)& S);
{
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Curve) Adaptor3d_Curve::ShallowCopy() const
+{
+ throw Standard_NotImplemented("Adaptor3d_Curve::ShallowCopy");
+}
+
//=======================================================================
//function : FirstParameter
//purpose :
DEFINE_STANDARD_RTTIEXT(Adaptor3d_Curve, Standard_Transient)
public:
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Curve) ShallowCopy() const;
+
Standard_EXPORT virtual Standard_Real FirstParameter() const;
Standard_EXPORT virtual Standard_Real LastParameter() const;
Load(C);
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Curve) Adaptor3d_CurveOnSurface::ShallowCopy() const
+{
+ Handle(Adaptor3d_CurveOnSurface) aCopy = new Adaptor3d_CurveOnSurface();
+
+ if (!mySurface.IsNull())
+ {
+ aCopy->mySurface = mySurface->ShallowCopy();
+ }
+ if (!myCurve.IsNull())
+ {
+ aCopy->myCurve = myCurve->ShallowCopy();
+ }
+ aCopy->myType = myType;
+ aCopy->myCirc = myCirc;
+ aCopy->myLin = myLin;
+ if (!myFirstSurf.IsNull())
+ {
+ aCopy->myFirstSurf = myFirstSurf->ShallowCopy();
+ }
+ if (!myLastSurf.IsNull())
+ {
+ aCopy->myLastSurf = myLastSurf->ShallowCopy();
+ }
+ aCopy->myIntervals = myIntervals;
+ aCopy->myIntCont = myIntCont;
+
+ return aCopy;
+}
+
//=======================================================================
//function : Load
//purpose :
//! the surface <S>.
Standard_EXPORT Adaptor3d_CurveOnSurface(const Handle(Adaptor2d_Curve2d)& C, const Handle(Adaptor3d_Surface)& S);
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Curve) ShallowCopy() const Standard_OVERRIDE;
+
//! Changes the surface.
Standard_EXPORT void Load (const Handle(Adaptor3d_Surface)& S);
Load(theIso, theParam, theWFirst, theWLast);
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Curve) Adaptor3d_IsoCurve::ShallowCopy() const
+{
+ Handle(Adaptor3d_IsoCurve) aCopy = new Adaptor3d_IsoCurve();
+
+ if (!mySurface.IsNull())
+ {
+ aCopy->mySurface = mySurface->ShallowCopy();
+ }
+ aCopy->myIso = myIso;
+ aCopy->myFirst = myFirst;
+ aCopy->myLast = myLast;
+ aCopy->myParameter = myParameter;
+
+ return aCopy;
+}
+
//=======================================================================
//function : Load
//purpose :
//! iso. WFirst,WLast define the bounds of the iso.
Standard_EXPORT Adaptor3d_IsoCurve(const Handle(Adaptor3d_Surface)& S, const GeomAbs_IsoType Iso, const Standard_Real Param, const Standard_Real WFirst, const Standard_Real WLast);
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Curve) ShallowCopy() const Standard_OVERRIDE;
+
//! Changes the surface. The iso is reset to
//! NoneIso.
Standard_EXPORT void Load (const Handle(Adaptor3d_Surface)& S);
{
}
+//=======================================================================
+//function : ShallowCopy()
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Surface) Adaptor3d_Surface::ShallowCopy() const
+{
+ throw Standard_NotImplemented("Adaptor3d_Surface::ShallowCopy");
+}
//=======================================================================
//function : FirstUParameter
//purpose :
DEFINE_STANDARD_RTTIEXT(Adaptor3d_Surface, Standard_Transient)
public:
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Surface) ShallowCopy() const;
+
Standard_EXPORT virtual Standard_Real FirstUParameter() const;
Standard_EXPORT virtual Standard_Real LastUParameter() const;
Initialize(theWire, theIsAC, theFirst, theLast, theTolerance);
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Curve) BRepAdaptor_CompCurve::ShallowCopy() const
+{
+ Handle(BRepAdaptor_CompCurve) aCopy = new BRepAdaptor_CompCurve();
+
+ aCopy->myWire = myWire;
+ aCopy->TFirst = TFirst;
+ aCopy->TLast = TLast;
+ aCopy->PTol = PTol;
+ aCopy->myCurves = new (BRepAdaptor_HArray1OfCurve) (1, myCurves->Size());
+ for (Standard_Integer anI = 1; anI <= myCurves->Size(); ++anI)
+ {
+ const Handle(Adaptor3d_Curve) aCurve = myCurves->Value(anI).ShallowCopy();
+ const BRepAdaptor_Curve& aBrepCurve = *(Handle(BRepAdaptor_Curve)::DownCast(aCurve));
+ aCopy->myCurves->SetValue(anI, aBrepCurve);
+ }
+ aCopy->myKnots = myKnots;
+ aCopy->CurIndex = CurIndex;
+ aCopy->Forward = Forward;
+ aCopy->IsbyAC = IsbyAC;
+
+ return aCopy;
+}
+
void BRepAdaptor_CompCurve::Initialize(const TopoDS_Wire& W,
const Standard_Boolean AC)
{
//! <W>.
Standard_EXPORT BRepAdaptor_CompCurve(const TopoDS_Wire& W, const Standard_Boolean KnotByCurvilinearAbcissa, const Standard_Real First, const Standard_Real Last, const Standard_Real Tol);
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Curve) ShallowCopy() const Standard_OVERRIDE;
+
//! Sets the wire <W>.
Standard_EXPORT void Initialize (const TopoDS_Wire& W, const Standard_Boolean KnotByCurvilinearAbcissa);
Initialize(E,F);
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Curve) BRepAdaptor_Curve::ShallowCopy() const
+{
+ Handle(BRepAdaptor_Curve) aCopy = new BRepAdaptor_Curve();
+
+ aCopy->myTrsf = myTrsf;
+
+ const Handle(Adaptor3d_Curve) aCurve = myCurve.ShallowCopy();
+ const GeomAdaptor_Curve& aGeomCurve = *(Handle(GeomAdaptor_Curve)::DownCast(aCurve));
+ aCopy->myCurve = aGeomCurve;
+
+ if (!myConSurf.IsNull())
+ {
+ aCopy->myConSurf = Handle(Adaptor3d_CurveOnSurface)::DownCast(myConSurf->ShallowCopy());
+ }
+ aCopy->myEdge = myEdge;
+
+ return aCopy;
+}
+
//=======================================================================
//function : Reset
//purpose :
//! the face.
Standard_EXPORT BRepAdaptor_Curve(const TopoDS_Edge& E, const TopoDS_Face& F);
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Curve) ShallowCopy() const Standard_OVERRIDE;
+
//! Reset currently loaded curve (undone Load()).
Standard_EXPORT void Reset();
Initialize(E,F);
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor2d_Curve2d) BRepAdaptor_Curve2d::ShallowCopy() const
+{
+ Handle(BRepAdaptor_Curve2d) aCopy = new BRepAdaptor_Curve2d();
+
+ aCopy->myCurve = myCurve;
+ aCopy->myTypeCurve = myTypeCurve;
+ aCopy->myFirst = myFirst;
+ aCopy->myLast = myLast;
+ aCopy->myBSplineCurve = myBSplineCurve;
+ if (!myNestedEvaluator.IsNull())
+ {
+ aCopy->myNestedEvaluator = myNestedEvaluator->ShallowCopy();
+ }
+
+ return aCopy;
+}
//=======================================================================
//function : Initialize
//! Creates with the pcurve of <E> on <F>.
Standard_EXPORT BRepAdaptor_Curve2d(const TopoDS_Edge& E, const TopoDS_Face& F);
+
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor2d_Curve2d) ShallowCopy() const Standard_OVERRIDE;
//! Initialize with the pcurve of <E> on <F>.
Standard_EXPORT void Initialize (const TopoDS_Edge& E, const TopoDS_Face& F);
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Surface) BRepAdaptor_Surface::ShallowCopy() const
+{
+ Handle(BRepAdaptor_Surface) aCopy = new BRepAdaptor_Surface();
+
+ const Handle(Adaptor3d_Surface) aSurface = mySurf.ShallowCopy();
+ const GeomAdaptor_Surface& aGeomSurface = *(Handle(GeomAdaptor_Surface)::DownCast(aSurface));
+ aCopy->mySurf = aGeomSurface;
+
+ aCopy->myTrsf = myTrsf;
+ aCopy->myFace = myFace;
+
+ return aCopy;
+}
//=======================================================================
//function : Initialize
//purpose :
//! the parameter range in the UV space of the
//! restriction.
Standard_EXPORT BRepAdaptor_Surface(const TopoDS_Face& F, const Standard_Boolean R = Standard_True);
+
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Surface) ShallowCopy() const Standard_OVERRIDE;
//! Sets the surface to the geometry of <F>.
Standard_EXPORT void Initialize (const TopoDS_Face& F, const Standard_Boolean Restriction = Standard_True);
Init(theEonF, theEdge);
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+Handle(Adaptor3d_Curve) BiTgte_CurveOnEdge::ShallowCopy() const
+{
+ Handle(BiTgte_CurveOnEdge) aCopy = new BiTgte_CurveOnEdge();
+
+ aCopy->myEdge = myEdge;
+ aCopy->myEonF = myEonF;
+ aCopy->myCurv = myCurv;
+ aCopy->myConF = myConF;
+ aCopy->myType = myType;
+ aCopy->myCirc = myCirc;
+
+ return aCopy;
+}
//=======================================================================
//function : Init
//purpose :
Standard_EXPORT BiTgte_CurveOnEdge();
Standard_EXPORT BiTgte_CurveOnEdge(const TopoDS_Edge& EonF, const TopoDS_Edge& Edge);
+
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Curve) ShallowCopy() const Standard_OVERRIDE;
Standard_EXPORT void Init (const TopoDS_Edge& EonF, const TopoDS_Edge& Edge);
{
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+Handle(Adaptor3d_Curve) ChFiDS_ElSpine::ShallowCopy() const
+{
+ Handle(ChFiDS_ElSpine) aCopy = new ChFiDS_ElSpine();
+
+ const Handle(Adaptor3d_Curve) aCurve = curve.ShallowCopy();
+ const GeomAdaptor_Curve& aGeomCurve = *(Handle(GeomAdaptor_Curve)::DownCast(aCurve));
+ aCopy->curve = aGeomCurve;
+
+ aCopy->ptfirst = ptfirst;
+ aCopy->ptlast = ptlast;
+ aCopy->tgfirst = tgfirst;
+ aCopy->tglast = tglast;
+ aCopy->VerticesWithTangents = VerticesWithTangents;
+ aCopy->previous = previous;
+ aCopy->next = next;
+ aCopy->pfirst = pfirst;
+ aCopy->plast = plast;
+ aCopy->period = period;
+ aCopy->periodic = periodic;
+ aCopy->pfirstsav = pfirstsav;
+ aCopy->plastsav = plastsav;
+
+ return aCopy;
+}
//=======================================================================
//function : FirstParameter
gp_Lin ChFiDS_ElSpine::Line() const
{
- return curve.Line();
+ return curve.Line();
}
//=======================================================================
gp_Hypr ChFiDS_ElSpine::Hyperbola() const
{
- return curve.Hyperbola();
+ return curve.Hyperbola();
}
//=======================================================================
public:
Standard_EXPORT ChFiDS_ElSpine();
+
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Curve) ShallowCopy() const Standard_OVERRIDE;
Standard_EXPORT virtual Standard_Real FirstParameter() const Standard_OVERRIDE;
IMPLEMENT_STANDARD_RTTIEXT(Geom2dAdaptor_Curve, Adaptor2d_Curve2d)
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor2d_Curve2d) Geom2dAdaptor_Curve::ShallowCopy() const
+{
+ Handle(Geom2dAdaptor_Curve) aCopy = new Geom2dAdaptor_Curve();
+
+ aCopy->myCurve = myCurve;
+ aCopy->myTypeCurve = myTypeCurve;
+ aCopy->myFirst = myFirst;
+ aCopy->myLast = myLast;
+ aCopy->myBSplineCurve = myBSplineCurve;
+ if(!myNestedEvaluator.IsNull())
+ {
+ aCopy->myNestedEvaluator = myNestedEvaluator->ShallowCopy();
+ }
+
+ return aCopy;
+}
+
//=======================================================================
//function : LocalContinuity
//purpose : Computes the Continuity of a BSplineCurve
//! Standard_ConstructionError is raised if Ufirst>Ulast
Standard_EXPORT Geom2dAdaptor_Curve(const Handle(Geom2d_Curve)& C, const Standard_Real UFirst, const Standard_Real ULast);
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor2d_Curve2d) ShallowCopy() const Standard_OVERRIDE;
+
//! Reset currently loaded curve (undone Load()).
Standard_EXPORT void Reset();
//! \param theParameter the value on the knot axis which identifies the caching span
void RebuildCache (const Standard_Real theParameter) const;
-private:
+protected:
Handle(Geom2d_Curve) myCurve;
GeomAbs_CurveType myTypeCurve;
virtual gp_Vec2d DN(const Standard_Real theU,
const Standard_Integer theDerU) const = 0;
+ virtual Handle(Geom2dEvaluator_Curve) ShallowCopy() const = 0;
+
DEFINE_STANDARD_RTTI_INLINE(Geom2dEvaluator_Curve,Standard_Transient)
};
return aDN;
}
+Handle(Geom2dEvaluator_Curve) Geom2dEvaluator_OffsetCurve::ShallowCopy() const
+{
+ Handle(Geom2dEvaluator_OffsetCurve) aCopy;
+ if (!myBaseAdaptor.IsNull())
+ {
+ aCopy = new Geom2dEvaluator_OffsetCurve(Handle(Geom2dAdaptor_Curve)::DownCast(myBaseAdaptor->ShallowCopy()),
+ myOffset);
+ }
+ else
+ {
+ aCopy = new Geom2dEvaluator_OffsetCurve(myBaseCurve, myOffset);
+ }
+
+ return aCopy;
+}
+
void Geom2dEvaluator_OffsetCurve::BaseD0(const Standard_Real theU,
gp_Pnt2d& theValue) const
Standard_EXPORT gp_Vec2d DN(const Standard_Real theU,
const Standard_Integer theDeriv) const Standard_OVERRIDE;
+ Standard_EXPORT Handle(Geom2dEvaluator_Curve) ShallowCopy() const Standard_OVERRIDE;
+
DEFINE_STANDARD_RTTIEXT(Geom2dEvaluator_OffsetCurve,Geom2dEvaluator_Curve)
private:
IMPLEMENT_STANDARD_RTTIEXT(GeomAdaptor_Curve, Adaptor3d_Curve)
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Curve) GeomAdaptor_Curve::ShallowCopy() const
+{
+ Handle(GeomAdaptor_Curve) aCopy = new GeomAdaptor_Curve();
+
+ aCopy->myCurve = myCurve;
+ aCopy->myTypeCurve = myTypeCurve;
+ aCopy->myFirst = myFirst;
+ aCopy->myLast = myLast;
+ aCopy->myBSplineCurve = myBSplineCurve;
+ if (!myNestedEvaluator.IsNull())
+ {
+ aCopy->myNestedEvaluator = myNestedEvaluator->ShallowCopy();
+ }
+
+ return aCopy;
+}
+
//=======================================================================
//function : LocalContinuity
//purpose : Computes the Continuity of a BSplineCurve
Load (theCurve, theUFirst, theULast);
}
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Curve) ShallowCopy() const Standard_OVERRIDE;
+
//! Reset currently loaded curve (undone Load()).
Standard_EXPORT void Reset();
return GeomAbs_CN;
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Surface) GeomAdaptor_Surface::ShallowCopy() const
+{
+ Handle(GeomAdaptor_Surface) aCopy = new GeomAdaptor_Surface();
+
+ aCopy->mySurface = mySurface;
+ aCopy->myUFirst = myUFirst;
+ aCopy->myULast = myULast;
+ aCopy->myVFirst = myVFirst;
+ aCopy->myVLast = myVLast;
+ aCopy->myTolU = myTolU;
+ aCopy->myTolV = myTolV;
+ aCopy->myBSplineSurface = myBSplineSurface;
+
+ aCopy->mySurfaceType = mySurfaceType;
+ if (!myNestedEvaluator.IsNull())
+ {
+ aCopy->myNestedEvaluator = myNestedEvaluator->ShallowCopy();
+ }
+
+ return aCopy;
+}
+
//=======================================================================
//function : Load
//purpose :
Load (theSurf, theUFirst, theULast, theVFirst, theVLast, theTolU, theTolV);
}
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Surface) ShallowCopy() const Standard_OVERRIDE;
+
void Load (const Handle(Geom_Surface)& theSurf)
{
if (theSurf.IsNull()) { throw Standard_NullObject("GeomAdaptor_Surface::Load"); }
//! \param theV second parameter to identify the span for caching
Standard_EXPORT void RebuildCache (const Standard_Real theU, const Standard_Real theV) const;
-private:
+ protected:
Handle(Geom_Surface) mySurface;
Standard_Real myUFirst;
Handle(Geom_BSplineSurface) myBSplineSurface; ///< B-spline representation to prevent downcasts
mutable Handle(BSplSLib_Cache) mySurfaceCache; ///< Cached data for B-spline or Bezier surface
-protected:
GeomAbs_SurfaceType mySurfaceType;
Handle(GeomEvaluator_Surface) myNestedEvaluator; ///< Calculates values of nested complex surfaces (offset surface, surface of extrusion or revolution)
};
Load(V);
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Surface) GeomAdaptor_SurfaceOfLinearExtrusion::ShallowCopy() const
+{
+ Handle(GeomAdaptor_SurfaceOfLinearExtrusion) aCopy = new GeomAdaptor_SurfaceOfLinearExtrusion();
+
+ if (!myBasisCurve.IsNull())
+ {
+ aCopy->myBasisCurve = myBasisCurve->ShallowCopy();
+ }
+ aCopy->myDirection = myDirection;
+ aCopy->myHaveDir = myHaveDir;
+
+ aCopy->mySurface = mySurface;
+ aCopy->myUFirst = myUFirst;
+ aCopy->myULast = myULast;
+ aCopy->myVFirst = myVFirst;
+ aCopy->myVLast = myVLast;
+ aCopy->myTolU = myTolU;
+ aCopy->myTolV = myTolV;
+ aCopy->myBSplineSurface = myBSplineSurface;
+
+ aCopy->mySurfaceType = mySurfaceType;
+ if (!myNestedEvaluator.IsNull())
+ {
+ aCopy->myNestedEvaluator = myNestedEvaluator->ShallowCopy();
+ }
+
+ return aCopy;
+}
//=======================================================================
//function : Load
//purpose :
//! Thew Curve and the Direction are loaded.
Standard_EXPORT GeomAdaptor_SurfaceOfLinearExtrusion(const Handle(Adaptor3d_Curve)& C, const gp_Dir& V);
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Surface) ShallowCopy() const Standard_OVERRIDE;
+
//! Changes the Curve
Standard_EXPORT void Load (const Handle(Adaptor3d_Curve)& C);
Load(V);
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Surface) GeomAdaptor_SurfaceOfRevolution::ShallowCopy() const
+{
+ Handle(GeomAdaptor_SurfaceOfRevolution) aCopy = new GeomAdaptor_SurfaceOfRevolution();
+
+ if (!myBasisCurve.IsNull())
+ {
+ aCopy->myBasisCurve = myBasisCurve->ShallowCopy();
+ }
+ aCopy->myAxis = myAxis;
+ aCopy->myHaveAxis = myHaveAxis;
+ aCopy->myAxeRev = myAxeRev;
+
+ aCopy->mySurface = mySurface;
+ aCopy->myUFirst = myUFirst;
+ aCopy->myULast = myULast;
+ aCopy->myVFirst = myVFirst;
+ aCopy->myVLast = myVLast;
+ aCopy->myTolU = myTolU;
+ aCopy->myTolV = myTolV;
+ aCopy->myBSplineSurface = myBSplineSurface;
+
+ aCopy->mySurfaceType = mySurfaceType;
+ if (!myNestedEvaluator.IsNull())
+ {
+ aCopy->myNestedEvaluator = myNestedEvaluator->ShallowCopy();
+ }
+
+ return aCopy;
+}
+
//=======================================================================
//function : Load
//purpose :
//! The Curve and the Direction are loaded.
Standard_EXPORT GeomAdaptor_SurfaceOfRevolution(const Handle(Adaptor3d_Curve)& C, const gp_Ax1& V);
+
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Surface) ShallowCopy() const Standard_OVERRIDE;
//! Changes the Curve
Standard_EXPORT void Load (const Handle(Adaptor3d_Curve)& C);
virtual gp_Vec DN(const Standard_Real theU,
const Standard_Integer theDerU) const = 0;
+ virtual Handle(GeomEvaluator_Curve) ShallowCopy() const = 0;
+
DEFINE_STANDARD_RTTI_INLINE(GeomEvaluator_Curve,Standard_Transient)
};
return aDN;
}
+Handle(GeomEvaluator_Curve) GeomEvaluator_OffsetCurve::ShallowCopy() const
+{
+ Handle(GeomEvaluator_OffsetCurve) aCopy;
+ if (!myBaseAdaptor.IsNull())
+ {
+ aCopy = new GeomEvaluator_OffsetCurve(Handle(GeomAdaptor_Curve)::DownCast(myBaseAdaptor->ShallowCopy()),
+ myOffset, myOffsetDir);
+ }
+ else
+ {
+ aCopy = new GeomEvaluator_OffsetCurve(myBaseCurve, myOffset, myOffsetDir);
+ }
+ return aCopy;
+}
+
void GeomEvaluator_OffsetCurve::BaseD0(const Standard_Real theU,
gp_Pnt& theValue) const
Standard_EXPORT gp_Vec DN(const Standard_Real theU,
const Standard_Integer theDeriv) const Standard_OVERRIDE;
+ Standard_EXPORT virtual Handle(GeomEvaluator_Curve) ShallowCopy() const Standard_OVERRIDE;
+
DEFINE_STANDARD_RTTIEXT(GeomEvaluator_OffsetCurve,GeomEvaluator_Curve)
private:
}
}
+Handle(GeomEvaluator_Surface) GeomEvaluator_OffsetSurface::ShallowCopy() const
+{
+ Handle(GeomEvaluator_OffsetSurface) aCopy;
+ if (!myBaseAdaptor.IsNull())
+ {
+ aCopy = new GeomEvaluator_OffsetSurface(Handle(GeomAdaptor_Surface)::DownCast(myBaseAdaptor->ShallowCopy()),
+ myOffset, myOscSurf);
+ }
+ else
+ {
+ aCopy = new GeomEvaluator_OffsetSurface(myBaseSurf, myOffset, myOscSurf);
+ }
+
+ return aCopy;
+}
+
void GeomEvaluator_OffsetSurface::BaseD0(const Standard_Real theU, const Standard_Real theV,
gp_Pnt& theValue) const
const Standard_Integer theDerU,
const Standard_Integer theDerV) const Standard_OVERRIDE;
+ Standard_EXPORT Handle(GeomEvaluator_Surface) ShallowCopy() const Standard_OVERRIDE;
+
DEFINE_STANDARD_RTTIEXT(GeomEvaluator_OffsetSurface,GeomEvaluator_Surface)
private:
virtual gp_Vec DN(const Standard_Real theU, const Standard_Real theV,
const Standard_Integer theDerU, const Standard_Integer theDerV) const = 0;
+ virtual Handle(GeomEvaluator_Surface) ShallowCopy() const = 0;
+
DEFINE_STANDARD_RTTI_INLINE(GeomEvaluator_Surface,Standard_Transient)
};
return aResult;
}
+Handle(GeomEvaluator_Surface) GeomEvaluator_SurfaceOfExtrusion::ShallowCopy() const
+{
+ Handle(GeomEvaluator_SurfaceOfExtrusion) aCopy;
+ if (!myBaseAdaptor.IsNull())
+ {
+ aCopy = new GeomEvaluator_SurfaceOfExtrusion(myBaseAdaptor->ShallowCopy(), myDirection);
+ }
+ else
+ {
+ aCopy = new GeomEvaluator_SurfaceOfExtrusion(myBaseCurve, myDirection);
+ }
+
+ return aCopy;
+}
+
const Standard_Integer theDerU,
const Standard_Integer theDerV) const Standard_OVERRIDE;
+ Standard_EXPORT Handle(GeomEvaluator_Surface) ShallowCopy() const Standard_OVERRIDE;
+
DEFINE_STANDARD_RTTIEXT(GeomEvaluator_SurfaceOfExtrusion,GeomEvaluator_Surface)
private:
return aResult;
}
+Handle(GeomEvaluator_Surface) GeomEvaluator_SurfaceOfRevolution::ShallowCopy() const
+{
+ Handle(GeomEvaluator_SurfaceOfRevolution) aCopy;
+ if (!myBaseAdaptor.IsNull())
+ {
+ aCopy = new GeomEvaluator_SurfaceOfRevolution(myBaseAdaptor->ShallowCopy(),
+ myRotAxis.Direction(), myRotAxis.Location());
+ }
+ else
+ {
+ aCopy = new GeomEvaluator_SurfaceOfRevolution(myBaseCurve,
+ myRotAxis.Direction(), myRotAxis.Location());
+ }
+
+ return aCopy;
+}
+
const Standard_Integer theDerU,
const Standard_Integer theDerV) const Standard_OVERRIDE;
+ Standard_EXPORT Handle(GeomEvaluator_Surface) ShallowCopy() const Standard_OVERRIDE;
+
DEFINE_STANDARD_RTTIEXT(GeomEvaluator_SurfaceOfRevolution,GeomEvaluator_Surface)
private:
{
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Curve) GeomFill_SnglrFunc::ShallowCopy() const
+{
+ Handle(GeomFill_SnglrFunc) aCopy = new GeomFill_SnglrFunc(myHCurve->ShallowCopy());
+ aCopy->ratio = ratio;
+ return aCopy;
+}
+
void GeomFill_SnglrFunc::SetRatio(const Standard_Real Ratio)
{
ratio = Ratio;
Standard_EXPORT GeomFill_SnglrFunc(const Handle(Adaptor3d_Curve)& HC);
+
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Curve) ShallowCopy() const Standard_OVERRIDE;
Standard_EXPORT void SetRatio (const Standard_Real Ratio);
Init();
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor2d_Curve2d) ProjLib_CompProjectedCurve::ShallowCopy() const
+{
+ Handle(ProjLib_CompProjectedCurve) aCopy = new ProjLib_CompProjectedCurve();
+
+ if (!mySurface.IsNull())
+ {
+ aCopy->mySurface = mySurface->ShallowCopy();
+ }
+ if (!myCurve.IsNull())
+ {
+ aCopy->myCurve = myCurve->ShallowCopy();
+ }
+ aCopy->myNbCurves = myNbCurves;
+ aCopy->mySequence = mySequence;
+ aCopy->myTolU = myTolU;
+ aCopy->myTolV = myTolV;
+ aCopy->myMaxDist = myMaxDist;
+ aCopy->myUIso = myUIso;
+ aCopy->myVIso = myVIso;
+ aCopy->mySnglPnts = mySnglPnts;
+ aCopy->myMaxDistance = myMaxDistance;
+
+ return aCopy;
+}
+
//=======================================================================
//function : Init
//purpose :
break;
}
}
- if (!found) throw Standard_DomainError("ProjLib_CompProjectedCurve::D0");
+ if (!found)
+ {
+ throw Standard_DomainError("ProjLib_CompProjectedCurve::D0");
+ }
Standard_Real U0, V0;
//! if MaxDist < 0 then algorithm works as above.
Standard_EXPORT ProjLib_CompProjectedCurve(const Handle(Adaptor3d_Surface)& S, const Handle(Adaptor3d_Curve)& C, const Standard_Real TolU, const Standard_Real TolV, const Standard_Real MaxDist);
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor2d_Curve2d) ShallowCopy() const Standard_OVERRIDE;
+
//! computes a set of projected point and determine the
//! continuous parts of the projected curves. The points
//! corresponding to a projection on the bounds of the surface are
// }
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_Curve) ProjLib_ProjectOnPlane::ShallowCopy() const
+{
+ Handle(ProjLib_ProjectOnPlane) aCopy = new ProjLib_ProjectOnPlane();
+
+ if (!myCurve.IsNull())
+ {
+ aCopy->myCurve = myCurve->ShallowCopy();
+ }
+ aCopy->myPlane = myPlane;
+ aCopy->myDirection = myDirection;
+ aCopy->myKeepParam = myKeepParam;
+ aCopy->myFirstPar = myFirstPar;
+ aCopy->myLastPar = myLastPar;
+ aCopy->myTolerance = myTolerance;
+ aCopy->myType = myType;
+ if (!myResult.IsNull())
+ {
+ aCopy->myResult = Handle(GeomAdaptor_Curve)::DownCast(myResult->ShallowCopy());
+ }
+ aCopy->myIsApprox = myIsApprox;
+
+ return aCopy;
+}
+
//=======================================================================
//function : Project
//purpose : Returns the projection of a point <Point> on a plane
//! raises if the direction <D> is parallel to the
//! plane <Pl>.
Standard_EXPORT ProjLib_ProjectOnPlane(const gp_Ax3& Pl, const gp_Dir& D);
+
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor3d_Curve) ShallowCopy() const Standard_OVERRIDE;
//! Sets the Curve and perform the projection.
//! if <KeepParametrization> is true, the parametrization
Perform(C);
}
+//=======================================================================
+//function : ShallowCopy
+//purpose :
+//=======================================================================
+
+Handle(Adaptor2d_Curve2d) ProjLib_ProjectedCurve::ShallowCopy() const
+{
+ Handle(ProjLib_ProjectedCurve) aCopy = new ProjLib_ProjectedCurve();
+
+ aCopy->myTolerance = myTolerance;
+ if (!mySurface.IsNull())
+ {
+ aCopy->mySurface = mySurface->ShallowCopy();
+ }
+ if (!myCurve.IsNull())
+ {
+ aCopy->myCurve = myCurve->ShallowCopy();
+ }
+ aCopy->myResult = myResult;
+ aCopy->myDegMin = myDegMin;
+ aCopy->myDegMax = myDegMax;
+ aCopy->myMaxSegments = myMaxSegments;
+ aCopy->myMaxDist = myMaxDist;
+ aCopy->myBndPnt = myBndPnt;
+
+ return aCopy;
+}
//=======================================================================
//function : Load
//! If projecting uses approximation, 3d tolerance is Tol, default parameters are used,
Standard_EXPORT ProjLib_ProjectedCurve(const Handle(Adaptor3d_Surface)& S, const Handle(Adaptor3d_Curve)& C, const Standard_Real Tol);
+ //! Shallow copy of adaptor
+ Standard_EXPORT virtual Handle(Adaptor2d_Curve2d) ShallowCopy() const Standard_OVERRIDE;
+
//! Changes the tolerance used to project
//! the curve on the surface
Standard_EXPORT void Load (const Standard_Real Tolerance);
projects / occt.git / commitdiff