Extrema_GenExtPS now prefers resizing of Array2 tables instead of managing tables by extra handles.
Removed unsafe casts to Adaptor3d_SurfacePtr/Adaptor3d_CurvePtr in Extrema classes.
Removed unsafe casts to curve adaptors in Extrema_ExtCC, Extrema_ExtCC2d classes.
Extrema_GenExtPS, Extrema_GenExtSS, Extrema_ExtCS -
copies by value are now disallowed;
several unexpected places copying the object have been fixed.
IntTools_Context - maps of void* have been replaced by typed maps.
+++ /dev/null
-// Created on: 1992-10-08
-// Created by: Isabelle GRIGNON
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Adaptor3d_CurveOnSurfacePtr_HeaderFile
-#define _Adaptor3d_CurveOnSurfacePtr_HeaderFile
-
-class Adaptor3d_CurveOnSurface;
-typedef Adaptor3d_CurveOnSurface* Adaptor3d_CurveOnSurfacePtr;
-
-#endif // _Adaptor3d_CurveOnSurfacePtr_HeaderFile
+++ /dev/null
-// Created on: 1992-10-08
-// Created by: Isabelle GRIGNON
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Adaptor3d_CurvePtr_HeaderFile
-#define _Adaptor3d_CurvePtr_HeaderFile
-
-class Adaptor3d_Curve;
-typedef Adaptor3d_Curve* Adaptor3d_CurvePtr;
-
-#endif // _Adaptor3d_CurvePtr_HeaderFile
+++ /dev/null
-// Created on: 1992-10-08
-// Created by: Isabelle GRIGNON
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Adaptor3d_SurfacePtr_HeaderFile
-#define _Adaptor3d_SurfacePtr_HeaderFile
-
-class Adaptor3d_Surface;
-typedef Adaptor3d_Surface* Adaptor3d_SurfacePtr;
-
-#endif // _Adaptor3d_SurfacePtr_HeaderFile
Adaptor3d_Curve.hxx
Adaptor3d_CurveOnSurface.cxx
Adaptor3d_CurveOnSurface.hxx
-Adaptor3d_CurveOnSurfacePtr.hxx
-Adaptor3d_CurvePtr.hxx
Adaptor3d_HSurfaceTool.cxx
Adaptor3d_HSurfaceTool.hxx
Adaptor3d_HVertex.cxx
Adaptor3d_IsoCurve.hxx
Adaptor3d_Surface.cxx
Adaptor3d_Surface.hxx
-Adaptor3d_SurfacePtr.hxx
Adaptor3d_TopolTool.cxx
Adaptor3d_TopolTool.hxx
//
// compute max tolerance for common blocks on faces
if (aLFI.Extent()) {
- Standard_Integer nF;
- GeomAPI_ProjectPointOnSurf aProjPS;
- TColStd_ListIteratorOfListOfInteger aItLI;
- //
- aItLI.Initialize(aLFI);
- for (; aItLI.More(); aItLI.Next()) {
- nF = aItLI.Value();
+ for (TColStd_ListIteratorOfListOfInteger aItLI (aLFI); aItLI.More(); aItLI.Next())
+ {
+ const Standard_Integer nF = aItLI.Value();
const TopoDS_Face& aF = *(TopoDS_Face*)&theDS->Shape(nF);
aTol = BRep_Tool::Tolerance(aF);
//
- aProjPS = aCtx->ProjPS(aF);
+ GeomAPI_ProjectPointOnSurf& aProjPS = aCtx->ProjPS(aF);
//
aT = aT1;
for (Standard_Integer i=1; i <= aNbPnt; i++) {
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
+#include <BRepFill_Filling.hxx>
-#include <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <BRep_Builder.hxx>
#include <BRep_CurveRepresentation.hxx>
#include <BRepFill_CurveConstraint.hxx>
#include <BRepFill_EdgeFaceAndOrder.hxx>
#include <BRepFill_FaceAndOrder.hxx>
-#include <BRepFill_Filling.hxx>
#include <BRepLib.hxx>
#include <BRepLib_MakeVertex.hxx>
#include <BRepLib_MakeEdge.hxx>
Constr->SetCurve2dOnSurf( Curve2d );
}
}
- myBuilder.Add( Constr );
+ myBuilder->Add( Constr );
}
}
//======================================================================
void BRepFill_Filling::Build()
{
- GeomPlate_BuildPlateSurface thebuild( myDegree, myNbPtsOnCur, myNbIter,
- myTol2d, myTol3d, myTolAng, myTolCurv, myAnisotropie );
-
- myBuilder = thebuild;
+ myBuilder.reset (new GeomPlate_BuildPlateSurface (myDegree, myNbPtsOnCur, myNbIter,
+ myTol2d, myTol3d, myTolAng, myTolCurv, myAnisotropie));
TopoDS_Edge CurEdge;
TopoDS_Face CurFace;
Standard_Integer i, j;
{
Handle( BRepAdaptor_Surface ) HSurfInit = new BRepAdaptor_Surface();
HSurfInit->Initialize( myInitFace );
- myBuilder.LoadInitSurface( BRep_Tool::Surface( HSurfInit->Face() ) );
+ myBuilder->LoadInitSurface( BRep_Tool::Surface( HSurfInit->Face() ) );
}
//Adding constraints to myBuilder
AddConstraints( myBoundary );
- myBuilder.SetNbBounds( myBoundary.Length() );
+ myBuilder->SetNbBounds( myBoundary.Length() );
AddConstraints( myConstraints );
for (i = 1; i <= myPoints.Length(); i++)
- myBuilder.Add( myPoints(i) );
+ {
+ myBuilder->Add (myPoints (i));
+ }
- myBuilder.Perform();
- if (myBuilder.IsDone())
+ myBuilder->Perform();
+ if (myBuilder->IsDone())
+ {
myIsDone = Standard_True;
+ }
else
- {
- myIsDone = Standard_False;
- return;
- }
+ {
+ myIsDone = Standard_False;
+ return;
+ }
- Handle( GeomPlate_Surface ) GPlate = myBuilder.Surface();
- Handle( Geom_BSplineSurface ) Surface;
+ Handle(GeomPlate_Surface) GPlate = myBuilder->Surface();
+ Handle(Geom_BSplineSurface) Surface;
// Approximation
- Standard_Real dmax = 1.1 * myBuilder.G0Error(); //???????????
+ Standard_Real dmax = 1.1 * myBuilder->G0Error(); //???????????
//Standard_Real dmax = myTol3d;
if (! myIsInitFaceGiven)
{
TColgp_SequenceOfXY S2d;
TColgp_SequenceOfXYZ S3d;
- myBuilder.Disc2dContour(4,S2d);
- myBuilder.Disc3dContour(4,0,S3d);
- seuil = Max( myTol3d, 10*myBuilder.G0Error() ); //????????
+ myBuilder->Disc2dContour (4, S2d);
+ myBuilder->Disc3dContour (4, 0, S3d);
+ seuil = Max (myTol3d, 10 * myBuilder->G0Error()); //????????
GeomPlate_PlateG0Criterion Criterion( S2d, S3d, seuil );
GeomPlate_MakeApprox Approx( GPlate, Criterion, myTol3d, myMaxSegments, myMaxDeg );
Surface = Approx.Surface();
//Build the final wire and final face
TopTools_ListOfShape FinalEdges;
- Handle(TColGeom2d_HArray1OfCurve) CurvesOnPlate = myBuilder.Curves2d();
+ Handle(TColGeom2d_HArray1OfCurve) CurvesOnPlate = myBuilder->Curves2d();
BRep_Builder BB;
for (i = 1; i <= myBoundary.Length(); i++)
{
//==========================================================================
Standard_Real BRepFill_Filling::G0Error() const
{
- return myBuilder.G0Error();
+ return myBuilder->G0Error();
}
//=======================================================================
//======================================================================
Standard_Real BRepFill_Filling::G1Error() const
{
- return myBuilder.G1Error();
+ return myBuilder->G1Error();
}
//=======================================================================
//======================================================================
Standard_Real BRepFill_Filling::G2Error() const
{
- return myBuilder.G2Error();
+ return myBuilder->G2Error();
}
//==========================================================================
//==========================================================================
Standard_Real BRepFill_Filling::G0Error( const Standard_Integer Index )
{
- return myBuilder.G0Error( Index );
+ return myBuilder->G0Error (Index);
}
//==========================================================================
//==========================================================================
Standard_Real BRepFill_Filling::G1Error( const Standard_Integer Index )
{
- return myBuilder.G1Error( Index );
+ return myBuilder->G1Error (Index);
}
//==========================================================================
//==========================================================================
Standard_Real BRepFill_Filling::G2Error( const Standard_Integer Index )
{
- return myBuilder.G2Error( Index );
+ return myBuilder->G2Error (Index);
}
#ifndef _BRepFill_Filling_HeaderFile
#define _BRepFill_Filling_HeaderFile
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <GeomPlate_BuildPlateSurface.hxx>
#include <BRepFill_SequenceOfEdgeFaceAndOrder.hxx>
#include <BRepFill_SequenceOfFaceAndOrder.hxx>
+#include <GeomAbs_Shape.hxx>
+#include <GeomPlate_BuildPlateSurface.hxx>
#include <GeomPlate_SequenceOfPointConstraint.hxx>
+#include <TopoDS_Face.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <TopTools_ListOfShape.hxx>
-#include <TopoDS_Face.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Integer.hxx>
-#include <Standard_Boolean.hxx>
-#include <GeomAbs_Shape.hxx>
#include <TopTools_SequenceOfShape.hxx>
-class StdFail_NotDone;
-class Standard_OutOfRange;
-class Standard_ConstructionError;
-class TopoDS_Face;
+
+#include <memory>
+
class TopoDS_Edge;
class gp_Pnt;
-class TopoDS_Shape;
-
//! N-Side Filling
//! This algorithm avoids to build a face from:
//! Limitations:
//! * If some constraints are not compatible
//! The algorithm does not take them into account.
-//! So the constraints will not be satisfyed in an area containing
-//! the incompatibilitries.
+//! So the constraints will not be satisfied in an area containing
+//! the incompatibilities.
//! * The constraints defining the bound of the face have to be
//! entered in order to have a continuous wire.
//!
Standard_EXPORT Standard_Real G2Error (const Standard_Integer Index);
-
-
-
-protected:
-
-
-
-
-
private:
-
//! Adds constraints to builder
Standard_EXPORT void AddConstraints (const BRepFill_SequenceOfEdgeFaceAndOrder& SeqOfConstraints);
//! Can properly operate only with convex contour
Standard_EXPORT void FindExtremitiesOfHoles (const TopTools_ListOfShape& WireList, TopTools_SequenceOfShape& VerSeq) const;
+private:
- GeomPlate_BuildPlateSurface myBuilder;
+ opencascade::std::shared_ptr<GeomPlate_BuildPlateSurface> myBuilder;
BRepFill_SequenceOfEdgeFaceAndOrder myBoundary;
BRepFill_SequenceOfEdgeFaceAndOrder myConstraints;
BRepFill_SequenceOfFaceAndOrder myFreeConstraints;
Standard_Boolean myIsInitFaceGiven;
Standard_Boolean myIsDone;
-
};
-
-
-
-
-
-
#endif // _BRepFill_Filling_HeaderFile
BRepGProp_TFunction::BRepGProp_TFunction(const BRepGProp_Face &theSurface,
const gp_Pnt &theVertex,
const Standard_Boolean IsByPoint,
- const Standard_Address theCoeffs,
+ const Standard_Real* theCoeffs,
const Standard_Real theUMin,
const Standard_Real theTolerance):
mySurface(theSurface),
//! correspondingly) of the shift if the inertia is computed
//! with respect to the point different then the location.
//! If IsByPoint is equal to Standard_False, the number of the
- //! coefficients is 4 and they represent the compbination of
+ //! coefficients is 4 and they represent the combination of
//! plane parameters and shift values.
- Standard_EXPORT BRepGProp_TFunction(const BRepGProp_Face& theSurface, const gp_Pnt& theVertex, const Standard_Boolean IsByPoint, const Standard_Address theCoeffs, const Standard_Real theUMin, const Standard_Real theTolerance);
+ Standard_EXPORT BRepGProp_TFunction (const BRepGProp_Face& theSurface,
+ const gp_Pnt& theVertex,
+ const Standard_Boolean IsByPoint,
+ const Standard_Real* theCoeffs,
+ const Standard_Real theUMin,
+ const Standard_Real theTolerance);
Standard_EXPORT void Init();
BRepGProp_UFunction::BRepGProp_UFunction(const BRepGProp_Face &theSurface,
const gp_Pnt &theVertex,
const Standard_Boolean IsByPoint,
- const Standard_Address theCoeffs)
+ const Standard_Real* theCoeffs)
: mySurface(theSurface),
myVertex(theVertex),
myCoeffs(theCoeffs),
return thePMP0.Dot(aNorm.XYZ());
// Volume and additional coefficients computation for ByPlane mode.
- Standard_Real *aCoeff = (Standard_Real *)myCoeffs;
+ const Standard_Real* aCoeff = myCoeffs;
theS = aNorm.X()*aCoeff[0] + aNorm.Y()*aCoeff[1] + aNorm.Z()*aCoeff[2];
theD1 = thePMP0.X()*aCoeff[0] + thePMP0.Y()*aCoeff[1]
}
// Center of mass computation for ByPlane mode.
- Standard_Real *aCoeff = (Standard_Real *)myCoeffs;
+ const Standard_Real* aCoeff = myCoeffs;
switch (myValueType) {
case GProp_CenterMassX: F *= (aPmP0.X() - 0.5*aCoeff[0]*aD1); break;
Standard_Real aD1;
Standard_Real aParam1;
Standard_Real aParam2;
- Standard_Real *aCoeffs = (Standard_Real *)myCoeffs;
+ const Standard_Real* aCoeffs = myCoeffs;
F = VolumeValue(X, aPmP0, aS, aD1);
//! If IsByPoint is equal to Standard_False, the number of the
//! coefficients is 4 and they represent the combination of
//! plane parameters and shift values.
- Standard_EXPORT BRepGProp_UFunction(const BRepGProp_Face& theSurface, const gp_Pnt& theVertex, const Standard_Boolean IsByPoint, const Standard_Address theCoeffs);
+ Standard_EXPORT BRepGProp_UFunction(const BRepGProp_Face& theSurface, const gp_Pnt& theVertex, const Standard_Boolean IsByPoint, const Standard_Real* theCoeffs);
//! Setting the type of the value to be returned.
void SetValueType (const GProp_ValueType theType);
//! Returns a value of the function.
Standard_EXPORT virtual Standard_Boolean Value (const Standard_Real X, Standard_Real& F) Standard_OVERRIDE;
-
-
-
-protected:
-
-
-
-
-
private:
-
//! Private method. Returns the value for volume computation.
//! Other returned values are:
//! - thePMP0 - PSurf(X,Y) minus Location.
BRepGProp_Face mySurface;
gp_Pnt myVertex;
- Standard_Address myCoeffs;
+ const Standard_Real* myCoeffs;
Standard_Real myVParam;
GProp_ValueType myValueType;
Standard_Boolean myIsByPoint;
{
Standard_Real aShift[] = { 0., 0., 0. };
- return PrivatePerform(theSurface, NULL, Standard_True, &aShift, theTolerance,
+ return PrivatePerform(theSurface, NULL, Standard_True, aShift, theTolerance,
theCGFlag, theIFlag);
}
aXYZ.Coord(aShift[0], aShift[1], aShift[2]);
- return PrivatePerform(theSurface, NULL, Standard_True, &aShift, theTolerance,
+ return PrivatePerform(theSurface, NULL, Standard_True, aShift, theTolerance,
theCGFlag, theIFlag);
}
Standard_Real aShift[] = { 0., 0., 0. };
return PrivatePerform(theSurface, &theDomain,
- Standard_True, &aShift, theTolerance,
+ Standard_True, aShift, theTolerance,
theCGFlag, theIFlag);
}
aXYZ.Coord(aShift[0], aShift[1], aShift[2]);
return PrivatePerform(theSurface, &theDomain,
- Standard_True, &aShift, theTolerance,
+ Standard_True, aShift, theTolerance,
theCGFlag, theIFlag);
}
aCoeff[3] = aCoeff[3] - aCoeff[0]*aXLoc - aCoeff[1]*aYLoc - aCoeff[2]*aZLoc;
return PrivatePerform(theSurface, NULL,
- Standard_False, &aCoeff, theTolerance,
+ Standard_False, aCoeff, theTolerance,
theCGFlag, theIFlag);
}
aCoeff[3] = aCoeff[3] - aCoeff[0]*aXLoc - aCoeff[1]*aYLoc - aCoeff[2]*aZLoc;
return PrivatePerform(theSurface, &theDomain,
- Standard_False, &aCoeff, theTolerance,
+ Standard_False, aCoeff, theTolerance,
theCGFlag, theIFlag);
}
(BRepGProp_Face &theSurface,
const Standard_Address thePtrDomain,
const Standard_Boolean IsByPoint,
- const Standard_Address theCoeffs,
+ const Standard_Real* theCoeffs,
const Standard_Real theTolerance,
const Standard_Boolean theCGFlag,
const Standard_Boolean theIFlag)
{
const Standard_Real aTTol = 1.e-9;
- Standard_Real *aCoeffs = (Standard_Real *)theCoeffs;
+ const Standard_Real* aCoeffs = theCoeffs;
// Compute the number of 2d bounding curves of the face.
BRepGProp_Domain *aPDomain = NULL;
// Get the spans on the curve.
Handle(TColStd_HArray1OfReal) aTKnots;
- BRepGProp_TFunction aTFunc(theSurface, loc, IsByPoint, theCoeffs,
- aUMin, aCrvTol);
+ BRepGProp_TFunction aTFunc (theSurface, loc, IsByPoint, theCoeffs, aUMin, aCrvTol);
theSurface.GetTKnots(aTMin, aTMax, aTKnots);
//! Returns the absolut reached computation error.
Standard_Real GetAbsolutError() const;
-
-
-
-protected:
-
-
-
-
-
private:
-
//! Main method for computation of the global properties that
//! is invoked by each Perform method.
- Standard_EXPORT Standard_Real PrivatePerform (BRepGProp_Face& theSurface, const Standard_Address thePtrDomain, const Standard_Boolean IsByPoint, const Standard_Address theCoeffs, const Standard_Real theTolerance, const Standard_Boolean theCGFlag, const Standard_Boolean theIFlag);
+ Standard_EXPORT Standard_Real PrivatePerform (BRepGProp_Face& theSurface,
+ const Standard_Address thePtrDomain,
+ const Standard_Boolean IsByPoint,
+ const Standard_Real* theCoeffs,
+ const Standard_Real theTolerance,
+ const Standard_Boolean theCGFlag,
+ const Standard_Boolean theIFlag);
Standard_Real myErrorReached;
Perform();
}
+//=======================================================================
+//function : Initialize
+//purpose :
+//=======================================================================
+void Extrema_ExtCC::Initialize (const Adaptor3d_Curve& C1,
+ const Adaptor3d_Curve& C2,
+ const Standard_Real TolC1,
+ const Standard_Real TolC2)
+{
+ // myECC will be re-initialized by Perform()
+ myDone = Standard_False;
+ SetCurve (1, C1, C1.FirstParameter(), C1.LastParameter());
+ SetCurve (2, C2, C2.FirstParameter(), C2.LastParameter());
+ SetTolerance (1, TolC1);
+ SetTolerance (2, TolC2);
+ mydist11 = mydist12 = mydist21 = mydist22 = RealFirst();
+}
+
+//=======================================================================
+//function : Initialize
+//purpose :
+//=======================================================================
+void Extrema_ExtCC::Initialize (const Adaptor3d_Curve& C1,
+ const Adaptor3d_Curve& C2,
+ const Standard_Real U1,
+ const Standard_Real U2,
+ const Standard_Real V1,
+ const Standard_Real V2,
+ const Standard_Real TolC1,
+ const Standard_Real TolC2)
+{
+ // myECC will be re-initialized by Perform()
+ myDone = Standard_False;
+ SetCurve (1, C1, U1, U2);
+ SetCurve (2, C2, V1, V2);
+ SetTolerance (1, TolC1);
+ SetTolerance (2, TolC2);
+ mydist11 = mydist12 = mydist21 = mydist22 = RealFirst();
+}
+
//=======================================================================
//function : SetCurve
-//purpose :
+//purpose :
//=======================================================================
void Extrema_ExtCC::SetCurve (const Standard_Integer theRank, const Adaptor3d_Curve& C)
{
Standard_OutOfRange_Raise_if (theRank < 1 || theRank > 2, "Extrema_ExtCC::SetCurve()")
Standard_Integer anInd = theRank - 1;
- myC[anInd] = (Standard_Address)&C;
+ myC[anInd] = &C;
}
//=======================================================================
void Extrema_ExtCC::Perform()
{
Standard_NullObject_Raise_if (!myC[0] || !myC[1], "Extrema_ExtCC::Perform()")
- myECC.SetParams(*((Adaptor3d_Curve*)myC[0]),
- *((Adaptor3d_Curve*)myC[1]), myInf[0], mySup[0], myInf[1], mySup[1]);
+ myECC.SetParams(*myC[0], *myC[1], myInf[0], mySup[0], myInf[1], mySup[1]);
myECC.SetTolerance(Min(myTol[0], myTol[1]));
myECC.SetSingleSolutionFlag(GetSingleSolutionFlag());
myDone = Standard_False;
mySqDist.Clear();
myIsPar = Standard_False;
- GeomAbs_CurveType type1 = (*((Adaptor3d_Curve*)myC[0])).GetType();
- GeomAbs_CurveType type2 = (*((Adaptor3d_Curve*)myC[1])).GetType();
+ GeomAbs_CurveType type1 = myC[0]->GetType();
+ GeomAbs_CurveType type2 = myC[1]->GetType();
Standard_Real U11, U12, U21, U22, Tol = Min(myTol[0], myTol[1]);
U11 = myInf[0];
U21 = myInf[1];
U22 = mySup[1];
- if (!Precision::IsInfinite(U11)) P1f = Extrema_CurveTool::Value(*((Adaptor3d_Curve*)myC[0]), U11);
- if (!Precision::IsInfinite(U12)) P1l = Extrema_CurveTool::Value(*((Adaptor3d_Curve*)myC[0]), U12);
- if (!Precision::IsInfinite(U21)) P2f = Extrema_CurveTool::Value(*((Adaptor3d_Curve*)myC[1]), U21);
- if (!Precision::IsInfinite(U22)) P2l = Extrema_CurveTool::Value(*((Adaptor3d_Curve*)myC[1]), U22);
+ if (!Precision::IsInfinite(U11)) P1f = Extrema_CurveTool::Value(*myC[0], U11);
+ if (!Precision::IsInfinite(U12)) P1l = Extrema_CurveTool::Value(*myC[0], U12);
+ if (!Precision::IsInfinite(U21)) P2f = Extrema_CurveTool::Value(*myC[1], U21);
+ if (!Precision::IsInfinite(U22)) P2l = Extrema_CurveTool::Value(*myC[1], U22);
if (Precision::IsInfinite(U11) || Precision::IsInfinite(U21)) mydist11 = RealLast();
}
switch (aType2) {
case GeomAbs_Line: {
- Extrema_ExtElC Xtrem((*((Adaptor3d_Curve*)myC[anInd1])).Line(), (*((Adaptor3d_Curve*)myC[anInd2])).Line(), Tol);
+ Extrema_ExtElC Xtrem (myC[anInd1]->Line(), myC[anInd2]->Line(), Tol);
PrepareResults(Xtrem, isInverse, U11, U12, U21, U22);
break;
}
case GeomAbs_Circle: {
- Extrema_ExtElC Xtrem((*((Adaptor3d_Curve*)myC[anInd1])).Line(), (*((Adaptor3d_Curve*)myC[anInd2])).Circle(), Tol);
+ Extrema_ExtElC Xtrem (myC[anInd1]->Line(), myC[anInd2]->Circle(), Tol);
PrepareResults(Xtrem, isInverse, U11, U12, U21, U22);
break;
}
case GeomAbs_Ellipse: {
- Extrema_ExtElC Xtrem((*((Adaptor3d_Curve*)myC[anInd1])).Line(), (*((Adaptor3d_Curve*)myC[anInd2])).Ellipse());
+ Extrema_ExtElC Xtrem (myC[anInd1]->Line(), myC[anInd2]->Ellipse());
PrepareResults(Xtrem, isInverse, U11, U12, U21, U22);
break;
}
case GeomAbs_Hyperbola: {
- Extrema_ExtElC Xtrem((*((Adaptor3d_Curve*)myC[anInd1])).Line(), (*((Adaptor3d_Curve*)myC[anInd2])).Hyperbola());
+ Extrema_ExtElC Xtrem (myC[anInd1]->Line(), myC[anInd2]->Hyperbola());
PrepareResults(Xtrem, isInverse, U11, U12, U21, U22);
break;
}
case GeomAbs_Parabola: {
- Extrema_ExtElC Xtrem((*((Adaptor3d_Curve*)myC[anInd1])).Line(), (*((Adaptor3d_Curve*)myC[anInd2])).Parabola());
+ Extrema_ExtElC Xtrem (myC[anInd1]->Line(), myC[anInd2]->Parabola());
PrepareResults(Xtrem, isInverse, U11, U12, U21, U22);
break;
}
} else if (type1 == GeomAbs_Circle && type2 == GeomAbs_Circle) {
//analytical case - two circles
Standard_Boolean bIsDone;
- Extrema_ExtElC CCXtrem ((*((Adaptor3d_Curve*)myC[0])).Circle(), (*((Adaptor3d_Curve*)myC[1])).Circle());
+ Extrema_ExtElC CCXtrem (myC[0]->Circle(), myC[1]->Circle());
bIsDone = CCXtrem.IsDone();
if(bIsDone) {
PrepareResults(CCXtrem, Standard_False, U11, U12, U21, U22);
if (!myIsPar)
return;
- const GeomAbs_CurveType aType1 = Extrema_CurveTool::GetType(*((Adaptor3d_Curve*) myC[0]));
- const GeomAbs_CurveType aType2 = Extrema_CurveTool::GetType(*((Adaptor3d_Curve*) myC[1]));
-
+ const GeomAbs_CurveType aType1 = Extrema_CurveTool::GetType (*myC[0]);
+ const GeomAbs_CurveType aType2 = Extrema_CurveTool::GetType (*myC[1]);
if (((aType1 != GeomAbs_Line) && (aType1 != GeomAbs_Circle)) ||
((aType2 != GeomAbs_Line) && (aType2 != GeomAbs_Circle)))
{
//The projection of the circle's location to the trimmed line must exist.
const Standard_Boolean isReversed = (aType1 != GeomAbs_Circle);
const gp_Pnt aPonC = !isReversed ?
- Extrema_CurveTool::Value(*((Adaptor3d_Curve*) myC[0]), theUt11) :
- Extrema_CurveTool::Value(*((Adaptor3d_Curve*) myC[1]), theUt21);
+ Extrema_CurveTool::Value (*myC[0], theUt11) :
+ Extrema_CurveTool::Value (*myC[1], theUt21);
- const gp_Lin aL = !isReversed ? ((Adaptor3d_Curve*) myC[1])->Line() :
- ((Adaptor3d_Curve*) myC[0])->Line();
+ const gp_Lin aL = myC[!isReversed ? 1 : 0]->Line();
const Extrema_ExtPElC ExtPLin(aPonC, aL, Precision::Confusion(),
!isReversed ? theUt21 : theUt11,
!isReversed ? theUt22 : theUt12);
myIsPar = Standard_False;
- const gp_Lin aLin1 = ((Adaptor3d_Curve*) myC[0])->Line();
- const gp_Lin aLin2 = ((Adaptor3d_Curve*) myC[1])->Line();
+ const gp_Lin aLin1 = myC[0]->Line();
+ const gp_Lin aLin2 = myC[1]->Line();
const Standard_Boolean isOpposite(aLin1.Direction().Dot(aLin2.Direction()) < 0.0);
Bnd_Range aRange2(theUt21, theUt22);
// the range [V1-PI, V2-PI]. All ranges must be adjusted to correspond
// periodic range before checking of intersection.
- const gp_Circ aWorkCirc = ((Adaptor3d_Curve*) myC[1])->Circle();
+ const gp_Circ aWorkCirc = myC[1]->Circle();
const Standard_Real aPeriod = M_PI + M_PI;
gp_Vec aVTg1;
gp_Pnt aP11;
- const gp_Pnt aP12 = Extrema_CurveTool::Value(*((Adaptor3d_Curve*) myC[0]), theUt12);
- Extrema_CurveTool::D1(*((Adaptor3d_Curve*) myC[0]), theUt11, aP11, aVTg1);
+ const gp_Pnt aP12 = Extrema_CurveTool::Value (*myC[0], theUt12);
+ Extrema_CurveTool::D1 (*myC[0], theUt11, aP11, aVTg1);
const Bnd_Range aRange(theUt21, theUt22);
Bnd_Range aProjRng1;
Standard_Real aPar1 = ElCLib::InPeriod(ElCLib::Parameter(aWorkCirc, aP11),
theUt21, theUt21 + aPeriod);
- const gp_Vec aVTg2 = Extrema_CurveTool::DN(*((Adaptor3d_Curve*) myC[1]), aPar1, 1);
+ const gp_Vec aVTg2 = Extrema_CurveTool::DN (*myC[1], aPar1, 1);
// Check if circles have same/opposite directions
const Standard_Boolean isOpposite(aVTg1.Dot(aVTg2) < 0.0);
aRng.GetIntermediatePoint(0.5, aPar);
const gp_Pnt aPCirc2 = ElCLib::Value(aPar, aWorkCirc);
Extrema_ExtPElC ExtPCir(aPCirc2,
- Extrema_CurveTool::Circle(*((Adaptor3d_Curve*) myC[0])),
+ Extrema_CurveTool::Circle (*myC[0]),
Precision::Confusion(), theUt11, theUt12);
Standard_Real aMinSqD = ExtPCir.SquareDistance(1);
const Extrema_POnCurv aP2(aPar, aPCirc2);
Extrema_ExtPElC ExtPCir(aPCirc2,
- Extrema_CurveTool::Circle(*((Adaptor3d_Curve*) myC[0])),
+ Extrema_CurveTool::Circle (*myC[0]),
Precision::Confusion(), theUt11, theUt12);
Standard_Boolean isFound = !myIsPar;
U = P2.Parameter();
}
- if (Extrema_CurveTool::IsPeriodic(*((Adaptor3d_Curve*)myC[0]))) {
- U = ElCLib::InPeriod(U, Ut11, Ut11+Extrema_CurveTool::Period(*((Adaptor3d_Curve*)myC[0])));
+ if (Extrema_CurveTool::IsPeriodic (*myC[0]))
+ {
+ U = ElCLib::InPeriod(U, Ut11, Ut11+Extrema_CurveTool::Period (*myC[0]));
}
- if (Extrema_CurveTool::IsPeriodic(*((Adaptor3d_Curve*)myC[1]))) {
- U2 = ElCLib::InPeriod(U2, Ut21, Ut21+Extrema_CurveTool::Period(*((Adaptor3d_Curve*)myC[1])));
+ if (Extrema_CurveTool::IsPeriodic (*myC[1]))
+ {
+ U2 = ElCLib::InPeriod(U2, Ut21, Ut21+Extrema_CurveTool::Period (*myC[1]));
}
if ((U >= Ut11 - RealEpsilon()) &&
U2 = P2.Parameter();
// Check points to be into param space.
- if (Extrema_CurveTool::IsPeriodic(*((Adaptor3d_Curve*) myC[0])))
+ if (Extrema_CurveTool::IsPeriodic (*myC[0]))
{
- U = ElCLib::InPeriod(U, Ut11, Ut11 + Extrema_CurveTool::Period(*((Adaptor3d_Curve*) myC[0])));
+ U = ElCLib::InPeriod(U, Ut11, Ut11 + Extrema_CurveTool::Period (*myC[0]));
}
- if (Extrema_CurveTool::IsPeriodic(*((Adaptor3d_Curve*) myC[1])))
+ if (Extrema_CurveTool::IsPeriodic (*myC[1]))
{
- U2 = ElCLib::InPeriod(U2, Ut21, Ut21 + Extrema_CurveTool::Period(*((Adaptor3d_Curve*) myC[1])));
+ U2 = ElCLib::InPeriod(U2, Ut21, Ut21 + Extrema_CurveTool::Period (*myC[1]));
}
if ((U >= Ut11 - RealEpsilon()) &&
//! It calculates all the distances.
Standard_EXPORT Extrema_ExtCC(const Adaptor3d_Curve& C1, const Adaptor3d_Curve& C2, const Standard_Real U1, const Standard_Real U2, const Standard_Real V1, const Standard_Real V2, const Standard_Real TolC1 = 1.0e-10, const Standard_Real TolC2 = 1.0e-10);
+
+ //! Initializes but does not perform algorithm.
+ Standard_EXPORT void Initialize (const Adaptor3d_Curve& C1,
+ const Adaptor3d_Curve& C2,
+ const Standard_Real TolC1 = 1.0e-10,
+ const Standard_Real TolC2 = 1.0e-10);
+
+ //! Initializes but does not perform algorithm.
+ Standard_EXPORT void Initialize (const Adaptor3d_Curve& C1,
+ const Adaptor3d_Curve& C2,
+ const Standard_Real U1,
+ const Standard_Real U2,
+ const Standard_Real V1,
+ const Standard_Real V2,
+ const Standard_Real TolC1 = 1.0e-10,
+ const Standard_Real TolC2 = 1.0e-10);
Standard_EXPORT void SetCurve (const Standard_Integer theRank, const Adaptor3d_Curve& C);
private:
+ // disallow copies
+ Extrema_ExtCC (Extrema_ExtCC& );
+ Extrema_ExtCC& operator= (Extrema_ExtCC& );
+
+private:
Standard_Boolean myIsFindSingleSolution; // Default value is false.
Extrema_ECC myECC;
Standard_Boolean myIsPar;
Extrema_SequenceOfPOnCurv mypoints;
TColStd_SequenceOfReal mySqDist;
- Standard_Address myC[2];
+ const Adaptor3d_Curve* myC[2];
Standard_Real myInf[2];
Standard_Real mySup[2];
Standard_Real myTol[2];
Standard_Real mydist21;
Standard_Real mydist22;
-
};
-
-
-
-
-
-
#endif // _Extrema_ExtCC_HeaderFile
const Standard_Real TolC1,
const Standard_Real TolC2)
{
- myC = (Standard_Address)&C2;
+ myC = &C2;
myv1 = V1;
myv2 = V2;
mytolc1 = TolC1;
{
mypoints.Clear();
mySqDist.Clear();
- GeomAbs_CurveType type1 = Extrema_Curve2dTool::GetType(C1), type2 = Extrema_Curve2dTool::GetType(*((Adaptor2d_Curve2d*)myC));
+ GeomAbs_CurveType type1 = Extrema_Curve2dTool::GetType(C1), type2 = Extrema_Curve2dTool::GetType (*myC);
Standard_Real U11, U12, U21, U22, Tol = Min(mytolc1, mytolc2);
// Extrema_POnCurv2d P1, P2;
mynbext = 0;
U22 = myv2;
P1f = Extrema_Curve2dTool::Value(C1, U11);
P1l = Extrema_Curve2dTool::Value(C1, U12);
- P2f = Extrema_Curve2dTool::Value(*((Adaptor2d_Curve2d*)myC), U21);
- P2l = Extrema_Curve2dTool::Value(*((Adaptor2d_Curve2d*)myC), U22);
+ P2f = Extrema_Curve2dTool::Value(*myC, U21);
+ P2l = Extrema_Curve2dTool::Value(*myC, U22);
switch(type1) {
switch(type2) {
case GeomAbs_Line: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Circle(C1), Tol);
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*myC), Extrema_Curve2dTool::Circle(C1), Tol);
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
case GeomAbs_Circle: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Circle(*myC));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 2*M_PI);
}
break;
case GeomAbs_Ellipse: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Ellipse(*((Adaptor2d_Curve2d*)myC)));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Ellipse(*myC));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 2*M_PI );
}
break;
case GeomAbs_Parabola: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Parabola(*((Adaptor2d_Curve2d*)myC)));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Parabola(*myC));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
case GeomAbs_Hyperbola: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Hyperbola(*((Adaptor2d_Curve2d*)myC)));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Hyperbola(*myC));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0. );
}
break;
default: {
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period2 = 0.;
- if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
+ if (Extrema_Curve2dTool::IsPeriodic(*myC)) Period2 = Extrema_Curve2dTool::Period(*myC);
Results(aParamSolver, U11, U12, U21, U22, 2*M_PI,Period2);
}
break;
switch(type2) {
case GeomAbs_Line: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Ellipse(C1));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*myC), Extrema_Curve2dTool::Ellipse(C1));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
case GeomAbs_Circle: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Ellipse(C1));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*myC), Extrema_Curve2dTool::Ellipse(C1));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 2*M_PI);
}
break;
case GeomAbs_Ellipse:
{
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22,2*M_PI, 2*M_PI);
}
break;
case GeomAbs_Parabola: {
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1), Extrema_Curve2dTool::Parabola(*((Adaptor2d_Curve2d*)myC)));
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1), Extrema_Curve2dTool::Parabola(*myC));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
case GeomAbs_Hyperbola: {
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1), Extrema_Curve2dTool::Hyperbola(*((Adaptor2d_Curve2d*)myC)));
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1), Extrema_Curve2dTool::Hyperbola(*myC));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
default: {
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period2 = 0.;
- if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
+ if (Extrema_Curve2dTool::IsPeriodic(*myC)) Period2 = Extrema_Curve2dTool::Period(*myC);
Results(aParamSolver, U11, U12, U21, U22, 2*M_PI,Period2);
}
break;
switch(type2) {
case GeomAbs_Line: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Parabola(C1));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*myC), Extrema_Curve2dTool::Parabola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Circle: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Parabola(C1));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*myC), Extrema_Curve2dTool::Parabola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
}
break;
case GeomAbs_Ellipse: {
//inverse = Standard_True;
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Parabola(C1));
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(*myC), Extrema_Curve2dTool::Parabola(C1));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 2*M_PI);
}
break;
case GeomAbs_Parabola: {
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Parabola(C1), Extrema_Curve2dTool::Parabola(*((Adaptor2d_Curve2d*)myC)));
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Parabola(C1), Extrema_Curve2dTool::Parabola(*myC));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
break;
case GeomAbs_Hyperbola: {
//inverse = Standard_True;
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Parabola(C1));
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(*myC), Extrema_Curve2dTool::Parabola(C1));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
}
break;
default: {
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period2 = 0.;
- if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
+ if (Extrema_Curve2dTool::IsPeriodic(*myC)) Period2 = Extrema_Curve2dTool::Period(*myC);
Results(aParamSolver, U11, U12, U21, U22, 0., Period2);
}
break;
switch(type2) {
case GeomAbs_Line: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Hyperbola(C1));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*myC), Extrema_Curve2dTool::Hyperbola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Circle: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Hyperbola(C1));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*myC), Extrema_Curve2dTool::Hyperbola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
}
break;
case GeomAbs_Ellipse: {
//inverse = Standard_True;
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Hyperbola(C1));
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(*myC), Extrema_Curve2dTool::Hyperbola(C1));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 2*M_PI );
}
break;
case GeomAbs_Parabola: {
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(C1), Extrema_Curve2dTool::Parabola(*((Adaptor2d_Curve2d*)myC)));
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(C1), Extrema_Curve2dTool::Parabola(*myC));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Hyperbola: {
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(C1), Extrema_Curve2dTool::Hyperbola(*((Adaptor2d_Curve2d*)myC)));
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(C1), Extrema_Curve2dTool::Hyperbola(*myC));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
}
break;
default: {
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period2 = 0.;
- if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
+ if (Extrema_Curve2dTool::IsPeriodic(*myC)) Period2 = Extrema_Curve2dTool::Period(*myC);
Results(aParamSolver, U11, U12, U21, U22, 0., Period2);
}
break;
switch(type2) {
case GeomAbs_Line: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Tol);
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Line(*myC), Tol);
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Circle: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)), Tol);
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Circle(*myC), Tol);
Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
}
break;
case GeomAbs_Ellipse: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Ellipse(*((Adaptor2d_Curve2d*)myC)));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Ellipse(*myC));
Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
}
break;
case GeomAbs_Parabola: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Parabola(*((Adaptor2d_Curve2d*)myC)));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Parabola(*myC));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Hyperbola: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Hyperbola(*((Adaptor2d_Curve2d*)myC)));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Hyperbola(*myC));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
default: {
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period2 = 0.;
- if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
+ if (Extrema_Curve2dTool::IsPeriodic(*myC)) Period2 = Extrema_Curve2dTool::Period(*myC);
Results(aParamSolver, U11, U12, U21, U22, 0., Period2);
}
break;
// La premiere courbe est une BezierCurve ou une BSplineCurve:
//
default: {
- Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
+ Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period1 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(C1)) Period1 = Extrema_Curve2dTool::Period(C1);
Standard_Real Period2 = 0.;
- if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
+ if (Extrema_Curve2dTool::IsPeriodic(*myC)) Period2 = Extrema_Curve2dTool::Period(*myC);
Results(aParamSolver, U11, U12, U21, U22, Period1, Period2);
}
break;
TColStd_SequenceOfReal mySqDist;
Standard_Integer mynbext;
Standard_Boolean inverse;
- Standard_Address myC;
+ const Adaptor2d_Curve2d* myC;
Standard_Real myv1;
Standard_Real myv2;
Standard_Real mytolc1;
const Standard_Real TolS)
{
- Initialize(S, S.FirstUParameter(), S.LastUParameter(),
- S.FirstVParameter(), S.LastVParameter(),
- TolC, TolS);
+ Initialize (S, TolC, TolS);
Perform(C, C.FirstParameter(), C.LastParameter());
}
Perform(C, UCinf, UCsup);
}
+void Extrema_ExtCS::Initialize (const Adaptor3d_Surface& S, const Standard_Real TolC, const Standard_Real TolS)
+{
+ Initialize (S, S.FirstUParameter(), S.LastUParameter(),
+ S.FirstVParameter(), S.LastVParameter(),
+ TolC, TolS);
+}
void Extrema_ExtCS::Initialize(const Adaptor3d_Surface& S,
const Standard_Real Uinf,
const Standard_Real TolC,
const Standard_Real TolS)
{
- myS = (Adaptor3d_SurfacePtr)&S;
+ myS = &S;
myIsPar = Standard_False;
myuinf = Uinf;
myusup = Usup;
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
-#include <Adaptor3d_SurfacePtr.hxx>
-#include <Standard_Boolean.hxx>
#include <Extrema_ExtElCS.hxx>
#include <Extrema_SequenceOfPOnSurf.hxx>
#include <Extrema_SequenceOfPOnCurv.hxx>
-#include <Standard_Real.hxx>
#include <TColStd_SequenceOfReal.hxx>
#include <GeomAbs_SurfaceType.hxx>
-#include <Standard_Integer.hxx>
-class StdFail_NotDone;
-class Standard_OutOfRange;
-class Standard_TypeMismatch;
+
class Adaptor3d_Curve;
class Adaptor3d_Surface;
class Extrema_POnCurv;
//! UCinf and UCmax are the start and end parameters
//! of the curve.
Standard_EXPORT Extrema_ExtCS(const Adaptor3d_Curve& C, const Adaptor3d_Surface& S, const Standard_Real UCinf, const Standard_Real UCsup, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup, const Standard_Real TolC, const Standard_Real TolS);
-
+
+ //! Initializes the fields of the algorithm.
+ Standard_EXPORT void Initialize (const Adaptor3d_Surface& S, const Standard_Real TolC, const Standard_Real TolS);
+
//! Initializes the fields of the algorithm.
Standard_EXPORT void Initialize (const Adaptor3d_Surface& S, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup, const Standard_Real TolC, const Standard_Real TolS);
//! Returns the point of the Nth resulting distance.
Standard_EXPORT void Points (const Standard_Integer N, Extrema_POnCurv& P1, Extrema_POnSurf& P2) const;
+private:
-
-
-protected:
-
-
-
-
+ Standard_EXPORT Standard_Boolean AddSolution (const Adaptor3d_Curve& Curve, const Standard_Real T, const Standard_Real U, const Standard_Real V, const gp_Pnt& PointOnCurve, const gp_Pnt& PointOnSurf, const Standard_Real SquareDist);
private:
-
- Standard_EXPORT Standard_Boolean AddSolution (const Adaptor3d_Curve& Curve, const Standard_Real T, const Standard_Real U, const Standard_Real V, const gp_Pnt& PointOnCurve, const gp_Pnt& PointOnSurf, const Standard_Real SquareDist);
-
- Standard_EXPORT Adaptor3d_SurfacePtr Bidon() const;
+ // disallow copies
+ Extrema_ExtCS (Extrema_ExtCS& );
+ Extrema_ExtCS& operator= (Extrema_ExtCS& );
+private:
- Adaptor3d_SurfacePtr myS;
+ const Adaptor3d_Surface* myS;
Standard_Boolean myDone;
Standard_Boolean myIsPar;
Extrema_ExtElCS myExtElCS;
TColStd_SequenceOfReal mySqDist;
GeomAbs_SurfaceType myStype;
-
};
-
-
-
-
-
-
#endif // _Extrema_ExtCS_HeaderFile
//=======================================================================
static Standard_Boolean IsExtremum (const Standard_Real U, const Standard_Real V,
- const gp_Pnt& P, const Adaptor3d_SurfacePtr& S,
+ const gp_Pnt& P, const Adaptor3d_Surface* S,
gp_Pnt& E, Standard_Real& Dist2,
const Standard_Boolean IsVSup,
const Standard_Boolean IsMin)
const Standard_Real theTolU,
const Standard_Real theTolV)
{
- myS = (Adaptor3d_SurfacePtr)&theS;
+ myS = &theS;
myuinf = theUinf;
myusup = theUsup;
myvinf = theVinf;
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
-#include <Adaptor3d_SurfacePtr.hxx>
-#include <Standard_Boolean.hxx>
#include <Extrema_ExtPElS.hxx>
#include <Extrema_GenExtPS.hxx>
#include <Extrema_SequenceOfPOnSurf.hxx>
Standard_EXPORT void SetAlgo (const Extrema_ExtAlgo A);
-
-
-
-protected:
-
-
-
-
-
private:
-
-
- Standard_EXPORT Adaptor3d_SurfacePtr Bidon() const;
Standard_EXPORT void TreatSolution (const Extrema_POnSurf& PS, const Standard_Real Val);
+private:
- Adaptor3d_SurfacePtr myS;
+ const Adaptor3d_Surface* myS;
Standard_Boolean myDone;
Extrema_ExtPElS myExtPElS;
Extrema_GenExtPS myExtPS;
Handle(Extrema_ExtPExtS) myExtPExtS;
Handle(Extrema_ExtPRevS) myExtPRevS;
-
};
-
-
-
-
-
-
#endif // _Extrema_ExtPS_HeaderFile
const Standard_Real Vsup2,
const Standard_Real TolS2)
{
- myS2 = (Adaptor3d_SurfacePtr)&S2;
+ myS2 = &S2;
myIsPar = Standard_False;
myuinf2 = Uinf2;
myusup2 = Usup2;
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
-#include <Adaptor3d_SurfacePtr.hxx>
-#include <Standard_Boolean.hxx>
#include <Extrema_ExtElSS.hxx>
#include <Extrema_SequenceOfPOnSurf.hxx>
#include <Standard_Real.hxx>
//! Returns the point of the Nth resulting distance.
Standard_EXPORT void Points (const Standard_Integer N, Extrema_POnSurf& P1, Extrema_POnSurf& P2) const;
-
-
-
-protected:
-
-
-
-
-
private:
-
- Standard_EXPORT Adaptor3d_SurfacePtr Bidon() const;
-
-
- Adaptor3d_SurfacePtr myS2;
+ const Adaptor3d_Surface* myS2;
Standard_Boolean myDone;
Standard_Boolean myIsPar;
Extrema_ExtElSS myExtElSS;
TColStd_SequenceOfReal mySqDist;
GeomAbs_SurfaceType myStype;
-
};
-
-
-
-
-
-
#endif // _Extrema_ExtSS_HeaderFile
void Extrema_FuncExtCS::Initialize(const Adaptor3d_Curve& C,
const Adaptor3d_Surface& S)
{
- myC = (Adaptor3d_CurvePtr)&C;
- myS = (Adaptor3d_SurfacePtr)&S;
+ myC = &C;
+ myS = &S;
myCinit = Standard_True;
mySinit = Standard_True;
myPoint1.Clear();
if (!myCinit || !mySinit) throw Standard_TypeMismatch();
return myPoint2.Value(N);
}
-
-//=======================================================================
-//function : Bidon1
-//purpose :
-//=======================================================================
-
-Adaptor3d_SurfacePtr Extrema_FuncExtCS::Bidon1() const
-{
- return (Adaptor3d_SurfacePtr)0L;
-}
-
-//=======================================================================
-//function : Bidon2
-//purpose :
-//=======================================================================
-
-Adaptor3d_CurvePtr Extrema_FuncExtCS::Bidon2() const
-{
- return (Adaptor3d_CurvePtr)0L;
-}
-
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
-#include <Adaptor3d_CurvePtr.hxx>
-#include <Adaptor3d_SurfacePtr.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Real.hxx>
#include <TColStd_SequenceOfReal.hxx>
//! Return the Nth extremum on S.
Standard_EXPORT const Extrema_POnSurf& PointOnSurface (const Standard_Integer N) const;
-
-
-
-protected:
-
-
-
-
-
private:
-
- Standard_EXPORT Adaptor3d_SurfacePtr Bidon1() const;
-
- Standard_EXPORT Adaptor3d_CurvePtr Bidon2() const;
-
-
- Adaptor3d_CurvePtr myC;
- Adaptor3d_SurfacePtr myS;
+ const Adaptor3d_Curve* myC;
+ const Adaptor3d_Surface* myS;
gp_Pnt myP1;
gp_Pnt myP2;
Standard_Real myt;
Standard_Boolean myCinit;
Standard_Boolean mySinit;
-
};
-
-
-
-
-
-
#endif // _Extrema_FuncExtCS_HeaderFile
myU2(0.0),
myV2(0.0)
{
- myS1 = (Adaptor3d_SurfacePtr)&S1;
- myS2 = (Adaptor3d_SurfacePtr)&S2;
+ myS1 = &S1;
+ myS2 = &S2;
myS1init = Standard_True;
myS2init = Standard_True;
}
void Extrema_FuncExtSS::Initialize(const Adaptor3d_Surface& S1,
const Adaptor3d_Surface& S2)
{
- myS1 = (Adaptor3d_SurfacePtr)&S1;
- myS2 = (Adaptor3d_SurfacePtr)&S2;
+ myS1 = &S1;
+ myS2 = &S2;
myS1init = Standard_True;
myS2init = Standard_True;
myPoint1.Clear();
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
-#include <Adaptor3d_SurfacePtr.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Real.hxx>
#include <TColStd_SequenceOfReal.hxx>
//! Renvoie le Nieme extremum sur S2.
Standard_EXPORT const Extrema_POnSurf& PointOnS2 (const Standard_Integer N) const;
-
-
-
-protected:
-
-
-
-
-
private:
-
- Standard_EXPORT Adaptor3d_SurfacePtr Bidon() const;
-
-
- Adaptor3d_SurfacePtr myS1;
- Adaptor3d_SurfacePtr myS2;
+ const Adaptor3d_Surface* myS1;
+ const Adaptor3d_Surface* myS2;
gp_Pnt myP1;
gp_Pnt myP2;
Standard_Real myU1;
Standard_Boolean myS1init;
Standard_Boolean myS2init;
-
};
-
-
-
-
-
-
#endif // _Extrema_FuncExtSS_HeaderFile
myV(0.0)
{
myP = P;
- myS = (Adaptor3d_SurfacePtr)&S;
+ myS = &S;
myPinit = Standard_True;
mySinit = Standard_True;
}
//=============================================================================
void Extrema_FuncPSNorm::Initialize(const Adaptor3d_Surface& S)
{
- myS = (Adaptor3d_SurfacePtr)&S;
+ myS = &S;
mySinit = Standard_True;
myPoint.Clear();
mySqDist.Clear();
#include <Standard_DefineAlloc.hxx>
#include <gp_Pnt.hxx>
-#include <Adaptor3d_SurfacePtr.hxx>
-#include <Standard_Real.hxx>
#include <TColStd_SequenceOfReal.hxx>
#include <Extrema_SequenceOfPOnSurf.hxx>
#include <Standard_Boolean.hxx>
#include <math_FunctionSetWithDerivatives.hxx>
#include <Standard_Integer.hxx>
#include <math_Vector.hxx>
-class Standard_OutOfRange;
-class gp_Pnt;
+
class Adaptor3d_Surface;
class math_Matrix;
class Extrema_POnSurf;
private:
gp_Pnt myP;
- Adaptor3d_SurfacePtr myS;
+ const Adaptor3d_Surface* myS;
Standard_Real myU;
Standard_Real myV;
gp_Pnt myPs;
const Standard_Real Vsup,
const Standard_Real Tol2)
{
- myS = (Adaptor3d_SurfacePtr)&S;
+ myS = &S;
myusample = NbU;
myvsample = NbV;
myumin = Umin;
return myF.PointOnSurface(N);
}
-
-//=======================================================================
-//function : BidonSurface
-//purpose :
-//=======================================================================
-Adaptor3d_SurfacePtr Extrema_GenExtCS::BidonSurface() const
-{
- return (Adaptor3d_SurfacePtr)0L;
-}
-
-//=======================================================================
-//function : BidonCurve
-//purpose :
-//=======================================================================
-Adaptor3d_CurvePtr Extrema_GenExtCS::BidonCurve() const
-{
- return (Adaptor3d_CurvePtr)0L;
-}
-
#ifndef _Extrema_GenExtCS_HeaderFile
#define _Extrema_GenExtCS_HeaderFile
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Integer.hxx>
#include <Extrema_FuncExtCS.hxx>
-#include <Adaptor3d_SurfacePtr.hxx>
#include <TColgp_HArray2OfPnt.hxx>
-#include <Adaptor3d_CurvePtr.hxx>
-class StdFail_NotDone;
-class Standard_OutOfRange;
-class Standard_TypeMismatch;
class Adaptor3d_Curve;
class Adaptor3d_Surface;
class Extrema_POnCurv;
//! Returns the point of the Nth resulting distance.
Standard_EXPORT const Extrema_POnSurf& PointOnSurface (const Standard_Integer N) const;
-
-
-
-protected:
-
-
-
-
-
private:
-
- Standard_EXPORT Adaptor3d_CurvePtr BidonCurve() const;
-
- Standard_EXPORT Adaptor3d_SurfacePtr BidonSurface() const;
-
Standard_EXPORT void GlobMinGenCS(const Adaptor3d_Curve& theC,
const Standard_Integer theNbParticles,
const math_Vector& theTUVinf,
const math_Vector& theTUVsup,
math_Vector& theTUV);
+private:
+
+ // disallow copies
+ Extrema_GenExtCS (const Extrema_GenExtCS& );
+ Extrema_GenExtCS& operator= (const Extrema_GenExtCS& );
+
+private:
Standard_Boolean myDone;
Standard_Real mytmin;
Standard_Real mytol1;
Standard_Real mytol2;
Extrema_FuncExtCS myF;
- Adaptor3d_SurfacePtr myS;
+ const Adaptor3d_Surface* myS;
Handle(TColgp_HArray2OfPnt) mySurfPnts;
-
};
-
-
-
-
-
-
#endif // _Extrema_GenExtCS_HeaderFile
const Standard_Real TolU,
const Standard_Real TolV)
{
- myS = (Adaptor3d_SurfacePtr)&S;
+ myS = &S;
myusample = NbU;
myvsample = NbV;
mytolu = TolU;
}
//If flag was changed and extrema not reinitialized Extrema would fail
- myPoints = new Extrema_HArray2OfPOnSurfParams
- (0, myusample + 1, 0, myvsample + 1);
+ myPoints.Resize (0, myusample + 1, 0, myvsample + 1, false);
// Calculation of distances
for ( NoU = 1 ; NoU <= myusample; NoU++ ) {
aParam.SetElementType(Extrema_Node);
aParam.SetIndices(NoU, NoV);
- myPoints->SetValue(NoU, NoV, aParam);
+ myPoints.SetValue(NoU, NoV, aParam);
}
}
- myFacePntParams =
- new Extrema_HArray2OfPOnSurfParams(0, myusample, 0, myvsample);
-
- myUEdgePntParams =
- new Extrema_HArray2OfPOnSurfParams(1, myusample - 1, 1, myvsample);
- myVEdgePntParams =
- new Extrema_HArray2OfPOnSurfParams(1, myusample, 1, myvsample - 1);
+ myFacePntParams .Resize (0, myusample, 0, myvsample, false);
+ myUEdgePntParams.Resize (1, myusample - 1, 1, myvsample, false);
+ myVEdgePntParams.Resize (1, myusample, 1, myvsample - 1, false);
// Fill boundary with negative square distance.
// It is used for computation of Maximum.
for (NoV = 0; NoV <= myvsample + 1; NoV++) {
- myPoints->ChangeValue(0, NoV).SetSqrDistance(-1.);
- myPoints->ChangeValue(myusample + 1, NoV).SetSqrDistance(-1.);
+ myPoints.ChangeValue(0, NoV).SetSqrDistance(-1.);
+ myPoints.ChangeValue(myusample + 1, NoV).SetSqrDistance(-1.);
}
for (NoU = 1; NoU <= myusample; NoU++) {
- myPoints->ChangeValue(NoU, 0).SetSqrDistance(-1.);
- myPoints->ChangeValue(NoU, myvsample + 1).SetSqrDistance(-1.);
+ myPoints.ChangeValue(NoU, 0).SetSqrDistance(-1.);
+ myPoints.ChangeValue(NoU, myvsample + 1).SetSqrDistance(-1.);
}
myInit = Standard_True;
// Step 1. Compute distances to nodes.
for ( NoU = 1 ; NoU <= myusample; NoU++ ) {
for ( NoV = 1 ; NoV <= myvsample; NoV++) {
- Extrema_POnSurfParams &aParam = myPoints->ChangeValue(NoU, NoV);
+ Extrema_POnSurfParams &aParam = myPoints.ChangeValue(NoU, NoV);
aParam.SetSqrDistance(thePoint.SquareDistance(aParam.Value()));
}
{
for ( NoV = 1 ; NoV <= myvsample; NoV++)
{
- const Extrema_POnSurfParams &aParam0 = myPoints->Value(NoU, NoV);
+ const Extrema_POnSurfParams &aParam0 = myPoints.Value(NoU, NoV);
if (NoU < myusample)
{
// Compute parameters to UEdge.
- const Extrema_POnSurfParams &aParam1 = myPoints->Value(NoU + 1, NoV);
+ const Extrema_POnSurfParams &aParam1 = myPoints.Value(NoU + 1, NoV);
const Extrema_POnSurfParams &anEdgeParam = ComputeEdgeParameters(Standard_True, aParam0, aParam1, thePoint, aDiffTol);
- myUEdgePntParams->SetValue(NoU, NoV, anEdgeParam);
+ myUEdgePntParams.SetValue(NoU, NoV, anEdgeParam);
}
if (NoV < myvsample)
{
// Compute parameters to VEdge.
- const Extrema_POnSurfParams &aParam1 = myPoints->Value(NoU, NoV + 1);
+ const Extrema_POnSurfParams &aParam1 = myPoints.Value(NoU, NoV + 1);
const Extrema_POnSurfParams &anEdgeParam = ComputeEdgeParameters(Standard_False, aParam0, aParam1, thePoint, aDiffTol);
- myVEdgePntParams->SetValue(NoU, NoV, anEdgeParam);
+ myVEdgePntParams.SetValue(NoU, NoV, anEdgeParam);
}
}
}
for ( NoU = 1 ; NoU < myusample; NoU++ ) {
for ( NoV = 1 ; NoV < myvsample; NoV++) {
- const Extrema_POnSurfParams &aUE0 = myUEdgePntParams->Value(NoU, NoV);
- const Extrema_POnSurfParams &aUE1 = myUEdgePntParams->Value(NoU, NoV+1);
- const Extrema_POnSurfParams &aVE0 = myVEdgePntParams->Value(NoU, NoV);
- const Extrema_POnSurfParams &aVE1 = myVEdgePntParams->Value(NoU+1, NoV);
+ const Extrema_POnSurfParams &aUE0 = myUEdgePntParams.Value(NoU, NoV);
+ const Extrema_POnSurfParams &aUE1 = myUEdgePntParams.Value(NoU, NoV+1);
+ const Extrema_POnSurfParams &aVE0 = myVEdgePntParams.Value(NoU, NoV);
+ const Extrema_POnSurfParams &aVE1 = myVEdgePntParams.Value(NoU+1, NoV);
aSqrDist01 = aUE0.Value().SquareDistance(aUE1.Value());
aDiffDist = Abs(aUE0.GetSqrDistance() - aUE1.GetSqrDistance());
const Extrema_POnSurfParams &aEMin =
aUEMin.GetSqrDistance() < aVEMin.GetSqrDistance() ? aUEMin : aVEMin;
- myFacePntParams->SetValue(NoU, NoV, aEMin);
+ myFacePntParams.SetValue(NoU, NoV, aEMin);
} else {
// Find closest point inside the face.
Standard_Real aU[2];
aParam.SetElementType(Extrema_Face);
aParam.SetSqrDistance(thePoint.SquareDistance(aParam.Value()));
aParam.SetIndices(NoU, NoV);
- myFacePntParams->SetValue(NoU, NoV, aParam);
+ myFacePntParams.SetValue(NoU, NoV, aParam);
}
}
}
// Fill boundary with RealLast square distance.
for (NoV = 0; NoV <= myvsample; NoV++) {
- myFacePntParams->ChangeValue(0, NoV).SetSqrDistance(RealLast());
- myFacePntParams->ChangeValue(myusample, NoV).SetSqrDistance(RealLast());
+ myFacePntParams.ChangeValue(0, NoV).SetSqrDistance(RealLast());
+ myFacePntParams.ChangeValue(myusample, NoV).SetSqrDistance(RealLast());
}
for (NoU = 1; NoU < myusample; NoU++) {
- myFacePntParams->ChangeValue(NoU, 0).SetSqrDistance(RealLast());
- myFacePntParams->ChangeValue(NoU, myvsample).SetSqrDistance(RealLast());
+ myFacePntParams.ChangeValue(NoU, 0).SetSqrDistance(RealLast());
+ myFacePntParams.ChangeValue(NoU, myvsample).SetSqrDistance(RealLast());
}
}
}
for (NoU = 1; NoU < myusample; NoU++) {
for (NoV = 1; NoV < myvsample; NoV++) {
const Extrema_POnSurfParams &aParam =
- myFacePntParams->Value(NoU, NoV);
+ myFacePntParams.Value(NoU, NoV);
isMin = Standard_False;
anElemType = aParam.GetElementType();
(anElemType == Extrema_Node && (iU == 1 || iU == myusample))) {
// Check the down face.
const Extrema_POnSurfParams &aDownParam =
- myFacePntParams->Value(NoU, NoV - 1);
+ myFacePntParams.Value(NoU, NoV - 1);
if (aDownParam.GetElementType() == anElemType) {
aDownParam.GetIndices(iU2, iV2);
(anElemType == Extrema_Node && (iV == 1 || iV == myvsample))) {
// Check the right face.
const Extrema_POnSurfParams &aRightParam =
- myFacePntParams->Value(NoU - 1, NoV);
+ myFacePntParams.Value(NoU - 1, NoV);
if (aRightParam.GetElementType() == anElemType) {
aRightParam.GetIndices(iU2, iV2);
isMin = Standard_True;
const Extrema_POnSurfParams *anOtherParam[3] =
- { &myFacePntParams->Value(NoU, NoV - 1), // Down
- &myFacePntParams->Value(NoU - 1, NoV - 1), // Lower-left
- &myFacePntParams->Value(NoU - 1, NoV) }; // Left
+ { &myFacePntParams.Value(NoU, NoV - 1), // Down
+ &myFacePntParams.Value(NoU - 1, NoV - 1), // Lower-left
+ &myFacePntParams.Value(NoU - 1, NoV) }; // Left
for (i = 0; i < 3 && isMin; i++) {
if (anOtherParam[i]->GetElementType() == Extrema_Node) {
{
for (NoV = 1; NoV <= myvsample; NoV++)
{
- const Extrema_POnSurfParams &aParamMain = myPoints->Value(NoU, NoV);
- const Extrema_POnSurfParams &aParam1 = myPoints->Value(NoU - 1, NoV - 1);
- const Extrema_POnSurfParams &aParam2 = myPoints->Value(NoU - 1, NoV);
- const Extrema_POnSurfParams &aParam3 = myPoints->Value(NoU - 1, NoV + 1);
- const Extrema_POnSurfParams &aParam4 = myPoints->Value(NoU, NoV - 1);
- const Extrema_POnSurfParams &aParam5 = myPoints->Value(NoU, NoV + 1);
- const Extrema_POnSurfParams &aParam6 = myPoints->Value(NoU + 1, NoV - 1);
- const Extrema_POnSurfParams &aParam7 = myPoints->Value(NoU + 1, NoV);
- const Extrema_POnSurfParams &aParam8 = myPoints->Value(NoU + 1, NoV + 1);
+ const Extrema_POnSurfParams &aParamMain = myPoints.Value(NoU, NoV);
+ const Extrema_POnSurfParams &aParam1 = myPoints.Value(NoU - 1, NoV - 1);
+ const Extrema_POnSurfParams &aParam2 = myPoints.Value(NoU - 1, NoV);
+ const Extrema_POnSurfParams &aParam3 = myPoints.Value(NoU - 1, NoV + 1);
+ const Extrema_POnSurfParams &aParam4 = myPoints.Value(NoU, NoV - 1);
+ const Extrema_POnSurfParams &aParam5 = myPoints.Value(NoU, NoV + 1);
+ const Extrema_POnSurfParams &aParam6 = myPoints.Value(NoU + 1, NoV - 1);
+ const Extrema_POnSurfParams &aParam7 = myPoints.Value(NoU + 1, NoV);
+ const Extrema_POnSurfParams &aParam8 = myPoints.Value(NoU + 1, NoV + 1);
Dist = aParamMain.GetSqrDistance();
(aParam8.GetSqrDistance() <= Dist))
{
// Find maximum.
- FindSolution(P, myPoints->Value(NoU, NoV));
+ FindSolution(P, myPoints.Value(NoU, NoV));
}
}
}
#ifndef _Extrema_GenExtPS_HeaderFile
#define _Extrema_GenExtPS_HeaderFile
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Integer.hxx>
-#include <Extrema_HArray2OfPOnSurfParams.hxx>
-#include <Extrema_HUBTreeOfSphere.hxx>
#include <Bnd_HArray1OfSphere.hxx>
+#include <Extrema_Array2OfPOnSurfParams.hxx>
+#include <Extrema_POnSurfParams.hxx>
+#include <Extrema_HUBTreeOfSphere.hxx>
#include <Extrema_FuncPSNorm.hxx>
-#include <Adaptor3d_SurfacePtr.hxx>
#include <Extrema_ExtFlag.hxx>
#include <Extrema_ExtAlgo.hxx>
#include <TColStd_HArray1OfReal.hxx>
-#include <Extrema_POnSurfParams.hxx>
-class StdFail_NotDone;
-class Standard_OutOfRange;
-class Standard_TypeMismatch;
-class gp_Pnt;
-class Adaptor3d_Surface;
-class Extrema_POnSurf;
-class Extrema_POnSurfParams;
+class Adaptor3d_Surface;
//! It calculates all the extremum distances
//! between a point and a surface.
DEFINE_STANDARD_ALLOC
-
Standard_EXPORT Extrema_GenExtPS();
//! It calculates all the distances.
//! Returns the point of the Nth resulting distance.
Standard_EXPORT const Extrema_POnSurf& Point (const Standard_Integer N) const;
-
-
-
-protected:
-
-
-
-
-
private:
-
-
- Standard_EXPORT Adaptor3d_SurfacePtr Bidon() const;
Standard_EXPORT void BuildTree();
//! Compute new edge parameters.
Standard_EXPORT const Extrema_POnSurfParams& ComputeEdgeParameters (const Standard_Boolean IsUEdge, const Extrema_POnSurfParams& theParam0, const Extrema_POnSurfParams& theParam1, const gp_Pnt& thePoints, const Standard_Real theDiffTol);
+private:
+
+ // disallow copies
+ Extrema_GenExtPS (const Extrema_GenExtPS& );
+ Extrema_GenExtPS& operator= (const Extrema_GenExtPS& );
+
+private:
Standard_Boolean myDone;
Standard_Boolean myInit;
Standard_Integer myvsample;
Standard_Real mytolu;
Standard_Real mytolv;
- Handle(Extrema_HArray2OfPOnSurfParams) myPoints;
+
+ Extrema_Array2OfPOnSurfParams myPoints;
Extrema_HUBTreeOfSphere mySphereUBTree;
Handle(Bnd_HArray1OfSphere) mySphereArray;
Extrema_FuncPSNorm myF;
- Adaptor3d_SurfacePtr myS;
+ const Adaptor3d_Surface* myS;
Extrema_ExtFlag myFlag;
Extrema_ExtAlgo myAlgo;
Handle(TColStd_HArray1OfReal) myUParams;
Handle(TColStd_HArray1OfReal) myVParams;
- Handle(Extrema_HArray2OfPOnSurfParams) myFacePntParams;
- Handle(Extrema_HArray2OfPOnSurfParams) myUEdgePntParams;
- Handle(Extrema_HArray2OfPOnSurfParams) myVEdgePntParams;
+ Extrema_Array2OfPOnSurfParams myFacePntParams;
+ Extrema_Array2OfPOnSurfParams myUEdgePntParams;
+ Extrema_Array2OfPOnSurfParams myVEdgePntParams;
Extrema_POnSurfParams myGridParam;
-
};
-
-
-
-
-
-
#endif // _Extrema_GenExtPS_HeaderFile
const Standard_Real V2sup,
const Standard_Real Tol2)
{
- myS2 = (Adaptor3d_SurfacePtr)&S2;
+ myS2 = &S2;
mypoints1 = new TColgp_HArray2OfPnt(0,NbU+1,0,NbV+1);
mypoints2 = new TColgp_HArray2OfPnt(0,NbU+1,0,NbV+1);
myusample = NbU;
return myF.PointOnS2(N);
}
-
-//=======================================================================
-//function : Bidon
-//purpose :
-//=======================================================================
-
-Adaptor3d_SurfacePtr Extrema_GenExtSS::Bidon() const
-{
- return (Adaptor3d_SurfacePtr)0L;
-}
-
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
-#include <Standard_Boolean.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Integer.hxx>
#include <TColgp_HArray2OfPnt.hxx>
#include <Extrema_FuncExtSS.hxx>
-#include <Adaptor3d_SurfacePtr.hxx>
-class StdFail_NotDone;
-class Standard_OutOfRange;
-class Standard_TypeMismatch;
+
class Adaptor3d_Surface;
class Extrema_POnSurf;
-
//! It calculates all the extremum distances
//! between two surfaces.
//! These distances can be minimum or maximum.
//! Returns the point of the Nth resulting distance.
Standard_EXPORT const Extrema_POnSurf& PointOnS2 (const Standard_Integer N) const;
-
-
-
-protected:
-
-
-
-
-
private:
-
- Standard_EXPORT Adaptor3d_SurfacePtr Bidon() const;
+ // disallow copies
+ Extrema_GenExtSS (const Extrema_GenExtSS& );
+ Extrema_GenExtSS& operator= (const Extrema_GenExtSS& );
+private:
Standard_Boolean myDone;
Standard_Boolean myInit;
Standard_Real mytol1;
Standard_Real mytol2;
Extrema_FuncExtSS myF;
- Adaptor3d_SurfacePtr myS2;
-
+ const Adaptor3d_Surface* myS2;
};
-
-
-
-
-
-
#endif // _Extrema_GenExtSS_HeaderFile
+++ /dev/null
-// Created on: 1991-02-26
-// Created by: Isabelle GRIGNON
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef Extrema_HArray2OfPOnSurfParams_HeaderFile
-#define Extrema_HArray2OfPOnSurfParams_HeaderFile
-
-#include <Extrema_POnSurfParams.hxx>
-#include <Extrema_Array2OfPOnSurfParams.hxx>
-#include <NCollection_DefineHArray2.hxx>
-
-DEFINE_HARRAY2(Extrema_HArray2OfPOnSurfParams, Extrema_Array2OfPOnSurfParams)
-
-
-#endif
Extrema_HArray2OfPOnCurv.hxx
Extrema_HArray2OfPOnCurv2d.hxx
Extrema_HArray2OfPOnSurf.hxx
-Extrema_HArray2OfPOnSurfParams.hxx
Extrema_HUBTreeOfSphere.hxx
Extrema_LocateExtCC.cxx
Extrema_LocateExtCC.hxx
Standard_Real Tol = Precision::PConfusion();
myC1.Load(C1);
myC2.Load(C2);
- Extrema_ExtCC theExtCC(myC1, myC2, Tol,Tol);
- myExtCC = theExtCC;
+ myExtCC.Initialize (myC1, myC2, Tol,Tol);
+ myExtCC.Perform();
myIsDone = myExtCC.IsDone() && ( myExtCC.NbExt() > 0);
if ( myIsDone) {
Standard_Real Tol = Precision::PConfusion();
myC1.Load(C1);
myC2.Load(C2);
- Extrema_ExtCC theExtCC(myC1,myC2,U1min,U1max,U2min,U2max,Tol,Tol);
- myExtCC = theExtCC;
+
+ myExtCC.Initialize (myC1,myC2,U1min,U1max,U2min,U2max,Tol,Tol);
+ myExtCC.Perform();
myIsDone = myExtCC.IsDone() && ( myExtCC.NbExt() > 0 );
GeomAdaptor_Surface TheSurface (Surface);
Standard_Real Tol = Precision::PConfusion();
- Extrema_ExtCS theExtCS(TheCurve,TheSurface,Tol,Tol);
- myExtCS = theExtCS;
-
+ myExtCS.Initialize (TheSurface, Tol, Tol);
+ myExtCS.Perform (TheCurve, TheCurve.FirstParameter(), TheCurve.LastParameter());
myIsDone = myExtCS.IsDone() && (myExtCS.IsParallel() || myExtCS.NbExt() > 0);
if ( myIsDone) {
GeomAdaptor_Surface TheSurface (Surface, Umin, Umax, Vmin, Vmax);
Standard_Real Tol = Precision::PConfusion();
- Extrema_ExtCS theExtCS(TheCurve,TheSurface,
- Wmin,Wmax,Umin,Umax,Vmin,Vmax,Tol,Tol);
- myExtCS = theExtCS;
-
+ myExtCS.Initialize (TheSurface,
+ Umin,Umax,Vmin,Vmax,Tol,Tol);
+ myExtCS.Perform (TheCurve, Wmin, Wmax);
myIsDone = myExtCS.IsDone() && (myExtCS.IsParallel() || myExtCS.NbExt() > 0);
if ( myIsDone) {
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
-#include <Adaptor3d_CurveOnSurfacePtr.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <CSLib.hxx>
gp_Vec2d D2d;
gp_Pnt S;
gp_Vec dS_du, dS_dv;
- Handle(Adaptor2d_Curve2d) myCurve2d = Adaptor3d_CurveOnSurfacePtr(myTrimmed.get())->GetCurve();
- Handle(Adaptor3d_Surface) mySupport = Adaptor3d_CurveOnSurfacePtr(myTrimmed.get())->GetSurface();
+ Handle(Adaptor2d_Curve2d) myCurve2d = static_cast<Adaptor3d_CurveOnSurface*>(myTrimmed.get())->GetCurve();
+ Handle(Adaptor3d_Surface) mySupport = static_cast<Adaptor3d_CurveOnSurface*>(myTrimmed.get())->GetSurface();
Standard_Integer OrderU, OrderV;
myCurve2d->D1(Param, C2d, D2d);
gp_Vec2d D2d, D2_2d;
gp_Pnt S;
gp_Vec dS_du, dS_dv, d2S_du, d2S_dv, d2S_duv, F, DF;
- Handle(Adaptor2d_Curve2d) myCurve2d = Adaptor3d_CurveOnSurfacePtr(myTrimmed.get())->GetCurve();
- Handle(Adaptor3d_Surface) mySupport = Adaptor3d_CurveOnSurfacePtr(myTrimmed.get())->GetSurface();
+ Handle(Adaptor2d_Curve2d) myCurve2d = static_cast<Adaptor3d_CurveOnSurface*>(myTrimmed.get())->GetCurve();
+ Handle(Adaptor3d_Surface) mySupport = static_cast<Adaptor3d_CurveOnSurface*>(myTrimmed.get())->GetSurface();
// Standard_Integer Order;
myCurve2d->D2(Param, C2d, D2d, D2_2d);
mySupport->D2(C2d.X(), C2d.Y(), S, dS_du, dS_dv,
gp_Pnt S;
gp_Vec dS_du, dS_dv, d2S_du, d2S_dv, d2S_duv,
d3S_du, d3S_dv, d3S_duuv, d3S_duvv, F, DF, D2F;
- Handle(Adaptor2d_Curve2d) myCurve2d = Adaptor3d_CurveOnSurfacePtr(myTrimmed.get())->GetCurve();
- Handle(Adaptor3d_Surface) mySupport = Adaptor3d_CurveOnSurfacePtr(myTrimmed.get())->GetSurface();
+ Handle(Adaptor2d_Curve2d) myCurve2d = static_cast<Adaptor3d_CurveOnSurface*>(myTrimmed.get())->GetCurve();
+ Handle(Adaptor3d_Surface) mySupport = static_cast<Adaptor3d_CurveOnSurface*>(myTrimmed.get())->GetSurface();
// Standard_Integer Order;
myCurve2d->D3(Param, C2d, D2d, D2_2d, D3_2d);
mySupport->D3(C2d.X(), C2d.Y(), S, dS_du, dS_dv,
//function : ParametersOfNearestPointOnSurface
//purpose :
//=======================================================================
-static Standard_Boolean ParametersOfNearestPointOnSurface(const Extrema_ExtPS theExtr,
+static Standard_Boolean ParametersOfNearestPointOnSurface(const Extrema_ExtPS& theExtr,
Standard_Real& theU,
Standard_Real& theV)
{
#endif
- Standard_Address myC1 = ((HLRBRep_EdgeData*) A1)->Curve();
+ HLRBRep_Curve* myC1 = ((HLRBRep_EdgeData*) A1)->Curve();
myTypePerform = 1;
d = b - a;
if (da1 != 0) a = a + d * da1;
if (db1 != 0) b = b - d * db1;
- ((HLRBRep_Curve*)myC1)->D0(a,pa);
- ((HLRBRep_Curve*)myC1)->D0(b,pb);
- a = ((HLRBRep_Curve*)myC1)->Parameter2d(a);
- b = ((HLRBRep_Curve*)myC1)->Parameter2d(b);
+ myC1->D0(a,pa);
+ myC1->D0(b,pb);
+ a = myC1->Parameter2d(a);
+ b = myC1->Parameter2d(b);
IntRes2d_Domain D1(pa,a,(Standard_Real)ta,pb,b,(Standard_Real)tb);
//modified by jgv, 18.04.2016 for OCC27341
// return;
// }
- Standard_Address myC1 = ((HLRBRep_EdgeData*) A1)->Curve();
- Standard_Address myC2 = ((HLRBRep_EdgeData*) A2)->Curve();
+ HLRBRep_Curve* myC1 = ((HLRBRep_EdgeData*) A1)->Curve();
+ HLRBRep_Curve* myC2 = ((HLRBRep_EdgeData*) A2)->Curve();
myTypePerform = 1;
if (da1 != 0) {
//-- a = a + d * da1;
- ((HLRBRep_Curve*)myC1)->D1(a1,pa1,va1);
+ myC1->D1(a1,pa1,va1);
Standard_Real qwe=va1.Magnitude();
if(qwe>1e-12) {
dd=pdist*decalagea1/qwe;
if (db1 != 0) {
//-- b = b - d * db1;
- ((HLRBRep_Curve*)myC1)->D1(b1,pb1,vb1);
+ myC1->D1(b1,pb1,vb1);
Standard_Real qwe=vb1.Magnitude();
if(qwe>1e-12) {
dd=pdist*decalageb1/qwe;
- ((HLRBRep_Curve*)myC1)->D0(a1,pa1);
- ((HLRBRep_Curve*)myC1)->D0(b1,pb1);
+ myC1->D0(a1,pa1);
+ myC1->D0(b1,pb1);
- a1 = ((HLRBRep_Curve*)myC1)->Parameter2d(a1);
- b1 = ((HLRBRep_Curve*)myC1)->Parameter2d(b1);
+ a1 = myC1->Parameter2d(a1);
+ b1 = myC1->Parameter2d(b1);
if(EnBout) {
ta=tb=-1.;
- ((HLRBRep_Curve*)myC2)->D0(a2,pa2);
- ((HLRBRep_Curve*)myC2)->D0(b2,pb2);
+ myC2->D0(a2,pa2);
+ myC2->D0(b2,pb2);
- a2 = ((HLRBRep_Curve*)myC2)->Parameter2d(a2);
- b2 = ((HLRBRep_Curve*)myC2)->Parameter2d(b2);
+ a2 = myC2->Parameter2d(a2);
+ b2 = myC2->Parameter2d(b2);
if(EnBout) {
ta=tb=-1.;
#ifdef PERF
NbIntersSimulate++;
#endif
- Standard_Address myC1 = ((HLRBRep_EdgeData*) A1)->Curve();
- Standard_Address myC2 = ((HLRBRep_EdgeData*) A2)->Curve();
+ HLRBRep_Curve* myC1 = ((HLRBRep_EdgeData*) A1)->Curve();
+ HLRBRep_Curve* myC2 = ((HLRBRep_EdgeData*) A2)->Curve();
- Standard_Real u3= ((HLRBRep_Curve*)myC1)->Parameter3d(u);
- Standard_Real v3= ((HLRBRep_Curve*)myC2)->Parameter3d(v);
+ Standard_Real u3= myC1->Parameter3d(u);
+ Standard_Real v3= myC2->Parameter3d(v);
gp_Pnt2d P13,P23;
gp_Vec2d T13,T23;
- ((HLRBRep_Curve*)myC1)->D1(u3,P13,T13);
- ((HLRBRep_Curve*)myC2)->D1(v3,P23,T23);
+ myC1->D1(u3,P13,T13);
+ myC2->D1(v3,P23,T23);
IntRes2d_Transition Tr1,Tr2;
IntRes2d_Position Pos1,Pos2;
}
GeomAdaptor_Curve aGACurve(aCurve, anarg1, anarg2);
- Extrema_ExtCS theExtCS;
- theExtCS.Initialize(aGASurface, myUMinParameter, myUMaxParameter,
- myVMinParameter, myVMaxParameter, Tol, Tol);
+ Extrema_ExtCS anExtCS;
+ anExtCS.Initialize(aGASurface, myUMinParameter, myUMaxParameter,
+ myVMinParameter, myVMaxParameter, Tol, Tol);
Standard_Real first = aCurve->FirstParameter(), last = aCurve->LastParameter();
if (aCurve->IsPeriodic() ||
(anarg1 >= first - Precision::PConfusion() && anarg2 <= last + Precision::PConfusion()))
{
- //Extrema_ExtCS theExtCS(aGACurve, aGASurface, Tol, Tol);
- theExtCS.Perform(aGACurve, anarg1, anarg2);
+ //Extrema_ExtCS anExtCS (aGACurve, aGASurface, Tol, Tol);
+ anExtCS.Perform (aGACurve, anarg1, anarg2);
}
-
- myExtrema = theExtCS;
- if(myExtrema.IsDone() && (myExtrema.NbExt() || myExtrema.IsParallel())) {
+ if (anExtCS.IsDone() && (anExtCS.NbExt() || anExtCS.IsParallel()))
+ {
Standard_Integer anOldNbRanges = myRangeManager.Length();
-
- if (myExtrema.IsParallel()) {
-
- if (myMinSqDistance > myExtrema.SquareDistance (1))
- myMinSqDistance = myExtrema.SquareDistance (1);
- if(myExtrema.SquareDistance(1) < myCriteria * myCriteria) {
+ if (anExtCS.IsParallel())
+ {
+ const Standard_Real aSqDist = anExtCS.SquareDistance (1);
+ myMinSqDistance = Min (myMinSqDistance, aSqDist);
+ if (aSqDist < myCriteria * myCriteria)
+ {
Standard_Real U1, V1, U2, V2;
Standard_Real adistance1 = Distance(anarg1, U1, V1);
Standard_Real adistance2 = Distance(anarg2, U2, V2);
else {
Standard_Boolean solutionfound = Standard_False;
- for(Standard_Integer j = 1 ; j <= myExtrema.NbExt(); j++) {
-
- if(myExtrema.SquareDistance(j) < myCriteria * myCriteria) {
+ for(Standard_Integer j = 1 ; j <= anExtCS.NbExt(); j++)
+ {
+ if (anExtCS.SquareDistance(j) < myCriteria * myCriteria)
+ {
Extrema_POnCurv p1;
Extrema_POnSurf p2;
- myExtrema.Points(j, p1, p2);
+ anExtCS.Points (j, p1, p2);
Standard_Real U, V;
p2.Parameter(U, V);
}
}
- if (myMinSqDistance > myExtrema.SquareDistance (j))
- myMinSqDistance = myExtrema.SquareDistance (j);
- } //end for
+ myMinSqDistance = Min (myMinSqDistance, anExtCS.SquareDistance (j));
+ }
if(!solutionfound) {
myRangeManager.SetFlag(i, 1);
if(adifference > 0) {
i+=adifference;
}
- } // end if(myExtrema.IsDone() && (myExtrema.NbExt() || myExtrema.IsParallel()))
+ }
}
}
Standard_Real myFaceTolerance;
Standard_Real myCurveResolution;
Standard_Real myCriteria;
- Extrema_ExtCS myExtrema;
GeomAPI_ProjectPointOnSurf myProjector;
IntTools_MarkedRangeSet myRangeManager;
Handle(IntTools_Context) myContext;
//=======================================================================
IntTools_Context::~IntTools_Context()
{
- Standard_Address anAdr;
- DataMapOfShapeAddress::Iterator aIt;
- DataMapOfTransientAddress::Iterator aIt1;
- //
- IntTools_FClass2d* pFClass2d;
- //
- aIt.Initialize(myFClass2dMap);
- for (; aIt.More(); aIt.Next()) {
- anAdr=aIt.Value();
- pFClass2d=(IntTools_FClass2d*)anAdr;
+ for (NCollection_DataMap<TopoDS_Shape, IntTools_FClass2d*, TopTools_ShapeMapHasher>::Iterator anIt (myFClass2dMap);
+ anIt.More(); anIt.Next())
+ {
+ IntTools_FClass2d* pFClass2d = anIt.Value();;
(*pFClass2d).~IntTools_FClass2d();
- myAllocator->Free(anAdr);
+ myAllocator->Free (pFClass2d);
}
myFClass2dMap.Clear();
- //
+
clearCachedPOnSProjectors();
- //
- GeomAPI_ProjectPointOnCurve* pProjPC;
- aIt.Initialize(myProjPCMap);
- for (; aIt.More(); aIt.Next()) {
- anAdr=aIt.Value();
- pProjPC=(GeomAPI_ProjectPointOnCurve*)anAdr;
+ for (NCollection_DataMap<TopoDS_Shape, GeomAPI_ProjectPointOnCurve*, TopTools_ShapeMapHasher>::Iterator anIt (myProjPCMap);
+ anIt.More(); anIt.Next())
+ {
+ GeomAPI_ProjectPointOnCurve* pProjPC = anIt.Value();
(*pProjPC).~GeomAPI_ProjectPointOnCurve();
- myAllocator->Free(anAdr);
+ myAllocator->Free (pProjPC);
}
myProjPCMap.Clear();
- //
- //
- BRepClass3d_SolidClassifier* pSC;
- aIt.Initialize(mySClassMap);
- for (; aIt.More(); aIt.Next()) {
- anAdr=aIt.Value();
- pSC=(BRepClass3d_SolidClassifier*)anAdr;
+
+ for (NCollection_DataMap<TopoDS_Shape, BRepClass3d_SolidClassifier*, TopTools_ShapeMapHasher>::Iterator anIt (mySClassMap);
+ anIt.More(); anIt.Next())
+ {
+ BRepClass3d_SolidClassifier* pSC = anIt.Value();
(*pSC).~BRepClass3d_SolidClassifier();
- myAllocator->Free(anAdr);
+ myAllocator->Free (pSC);
}
mySClassMap.Clear();
- //
- GeomAPI_ProjectPointOnCurve* pProjPT;
- aIt1.Initialize(myProjPTMap);
- for (; aIt1.More(); aIt1.Next()) {
- anAdr=aIt1.Value();
- pProjPT=(GeomAPI_ProjectPointOnCurve*)anAdr;
+
+ for (NCollection_DataMap<Handle(Geom_Curve), GeomAPI_ProjectPointOnCurve*, TColStd_MapTransientHasher>::Iterator anIt (myProjPTMap);
+ anIt.More(); anIt.Next())
+ {
+ GeomAPI_ProjectPointOnCurve* pProjPT = anIt.Value();
(*pProjPT).~GeomAPI_ProjectPointOnCurve();
- myAllocator->Free(anAdr);
+ myAllocator->Free (pProjPT);
}
myProjPTMap.Clear();
- //
- Geom2dHatch_Hatcher* pHatcher;
- aIt.Initialize(myHatcherMap);
- for (; aIt.More(); aIt.Next()) {
- anAdr=aIt.Value();
- pHatcher=(Geom2dHatch_Hatcher*)anAdr;
+
+ for (NCollection_DataMap<TopoDS_Shape, Geom2dHatch_Hatcher*, TopTools_ShapeMapHasher>::Iterator anIt (myHatcherMap);
+ anIt.More(); anIt.Next())
+ {
+ Geom2dHatch_Hatcher* pHatcher = anIt.Value();
(*pHatcher).~Geom2dHatch_Hatcher();
- myAllocator->Free(anAdr);
+ myAllocator->Free (pHatcher);
}
myHatcherMap.Clear();
- //
- IntTools_SurfaceRangeLocalizeData* pSData = NULL;
- aIt.Initialize(myProjSDataMap);
- for (; aIt.More(); aIt.Next()) {
- anAdr=aIt.Value();
- pSData = (IntTools_SurfaceRangeLocalizeData*)anAdr;
+
+ for (NCollection_DataMap<TopoDS_Shape, IntTools_SurfaceRangeLocalizeData*, TopTools_ShapeMapHasher>::Iterator anIt (myProjSDataMap);
+ anIt.More(); anIt.Next())
+ {
+ IntTools_SurfaceRangeLocalizeData* pSData = anIt.Value();
(*pSData).~IntTools_SurfaceRangeLocalizeData();
- myAllocator->Free(anAdr);
+ myAllocator->Free (pSData);
}
myProjSDataMap.Clear();
- //
- Bnd_Box* pBox;
- aIt.Initialize(myBndBoxDataMap);
- for (; aIt.More(); aIt.Next()) {
- anAdr=aIt.Value();
- pBox=(Bnd_Box*)anAdr;
+
+ for (NCollection_DataMap<TopoDS_Shape, Bnd_Box*, TopTools_ShapeMapHasher>::Iterator anIt (myBndBoxDataMap);
+ anIt.More(); anIt.Next())
+ {
+ Bnd_Box* pBox = anIt.Value();
(*pBox).~Bnd_Box();
- myAllocator->Free(anAdr);
+ myAllocator->Free (pBox);
}
myBndBoxDataMap.Clear();
- //
- BRepAdaptor_Surface* pSurfAdaptor;
- aIt.Initialize(mySurfAdaptorMap);
- for (; aIt.More(); aIt.Next()) {
- anAdr=aIt.Value();
- pSurfAdaptor=(BRepAdaptor_Surface*)anAdr;
+
+ for (NCollection_DataMap<TopoDS_Shape, BRepAdaptor_Surface*, TopTools_ShapeMapHasher>::Iterator anIt (mySurfAdaptorMap);
+ anIt.More(); anIt.Next())
+ {
+ BRepAdaptor_Surface* pSurfAdaptor = anIt.Value();
(*pSurfAdaptor).~BRepAdaptor_Surface();
- myAllocator->Free(anAdr);
+ myAllocator->Free (pSurfAdaptor);
}
mySurfAdaptorMap.Clear();
- //
- Bnd_OBB* pOBB;
- aIt.Initialize(myOBBMap);
- for (; aIt.More(); aIt.Next()) {
- anAdr=aIt.Value();
- pOBB=(Bnd_OBB*)anAdr;
+
+ for (NCollection_DataMap<TopoDS_Shape, Bnd_OBB*, TopTools_ShapeMapHasher>::Iterator anIt (myOBBMap);
+ anIt.More(); anIt.Next())
+ {
+ Bnd_OBB* pOBB = anIt.Value();
(*pOBB).~Bnd_OBB();
- myAllocator->Free(anAdr);
+ myAllocator->Free (pOBB);
}
myOBBMap.Clear();
}
+
//=======================================================================
//function : BndBox
//purpose :
//=======================================================================
Bnd_Box& IntTools_Context::BndBox(const TopoDS_Shape& aS)
{
- Standard_Address anAdr;
- Bnd_Box* pBox;
- //
- if (!myBndBoxDataMap.IsBound(aS)) {
+ Bnd_Box* pBox = NULL;
+ if (!myBndBoxDataMap.Find (aS, pBox))
+ {
//
pBox=(Bnd_Box*)myAllocator->Allocate(sizeof(Bnd_Box));
new (pBox) Bnd_Box();
Bnd_Box &aBox=*pBox;
BRepBndLib::Add(aS, aBox);
//
- anAdr=(Standard_Address)pBox;
- myBndBoxDataMap.Bind(aS, anAdr);
- }
- else {
- anAdr=myBndBoxDataMap.Find(aS);
- pBox=(Bnd_Box*)anAdr;
+ myBndBoxDataMap.Bind (aS, pBox);
}
return *pBox;
}
+
//=======================================================================
//function : IsInfiniteFace
//purpose :
//=======================================================================
IntTools_FClass2d& IntTools_Context::FClass2d(const TopoDS_Face& aF)
{
- Standard_Address anAdr;
- IntTools_FClass2d* pFClass2d;
- //
- if (!myFClass2dMap.IsBound(aF)) {
+ IntTools_FClass2d* pFClass2d = NULL;
+ if (!myFClass2dMap.Find (aF, pFClass2d))
+ {
Standard_Real aTolF;
TopoDS_Face aFF;
//
pFClass2d=(IntTools_FClass2d*)myAllocator->Allocate(sizeof(IntTools_FClass2d));
new (pFClass2d) IntTools_FClass2d(aFF, aTolF);
//
- anAdr=(Standard_Address)pFClass2d;
- myFClass2dMap.Bind(aFF, anAdr);
- }
- else {
- anAdr=myFClass2dMap.Find(aF);
- pFClass2d=(IntTools_FClass2d*)anAdr;
+ myFClass2dMap.Bind(aFF, pFClass2d);
}
return *pFClass2d;
}
+
//=======================================================================
//function : ProjPS
//purpose :
//=======================================================================
GeomAPI_ProjectPointOnSurf& IntTools_Context::ProjPS(const TopoDS_Face& aF)
{
- Standard_Address anAdr;
- GeomAPI_ProjectPointOnSurf* pProjPS;
-
- if (!myProjPSMap.IsBound(aF)) {
+ GeomAPI_ProjectPointOnSurf* pProjPS = NULL;
+ if (!myProjPSMap.Find (aF, pProjPS))
+ {
Standard_Real Umin, Usup, Vmin, Vsup;
UVBounds(aF, Umin, Usup, Vmin, Vsup);
const Handle(Geom_Surface)& aS=BRep_Tool::Surface(aF);
pProjPS=(GeomAPI_ProjectPointOnSurf*)myAllocator->Allocate(sizeof(GeomAPI_ProjectPointOnSurf));
new (pProjPS) GeomAPI_ProjectPointOnSurf();
pProjPS->Init(aS ,Umin, Usup, Vmin, Vsup, myPOnSTolerance);
- pProjPS->SetExtremaFlag(Extrema_ExtFlag_MIN);
+ pProjPS->SetExtremaFlag(Extrema_ExtFlag_MIN); ///
//
- anAdr=(Standard_Address)pProjPS;
- myProjPSMap.Bind(aF, anAdr);
- }
-
- else {
- anAdr=myProjPSMap.Find(aF);
- pProjPS=(GeomAPI_ProjectPointOnSurf*)anAdr;
+ myProjPSMap.Bind(aF, pProjPS);
}
return *pProjPS;
}
//=======================================================================
GeomAPI_ProjectPointOnCurve& IntTools_Context::ProjPC(const TopoDS_Edge& aE)
{
- Standard_Address anAdr;
- GeomAPI_ProjectPointOnCurve* pProjPC;
-
- if (!myProjPCMap.IsBound(aE)) {
+ GeomAPI_ProjectPointOnCurve* pProjPC = NULL;
+ if (!myProjPCMap.Find (aE, pProjPC))
+ {
Standard_Real f, l;
//
Handle(Geom_Curve)aC3D=BRep_Tool::Curve (aE, f, l);
new (pProjPC) GeomAPI_ProjectPointOnCurve();
pProjPC->Init(aC3D, f, l);
//
- anAdr=(Standard_Address)pProjPC;
- myProjPCMap.Bind(aE, anAdr);
- }
-
- else {
- anAdr=myProjPCMap.Find(aE);
- pProjPC=(GeomAPI_ProjectPointOnCurve*)anAdr;
+ myProjPCMap.Bind(aE, pProjPC);
}
return *pProjPC;
}
(const Handle(Geom_Curve)& aC3D)
{
- Standard_Address anAdr;
- GeomAPI_ProjectPointOnCurve* pProjPT;
-
- if (!myProjPTMap.IsBound(aC3D)) {
+ GeomAPI_ProjectPointOnCurve* pProjPT = NULL;
+ if (!myProjPTMap.Find (aC3D, pProjPT))
+ {
Standard_Real f, l;
f=aC3D->FirstParameter();
l=aC3D->LastParameter();
new (pProjPT) GeomAPI_ProjectPointOnCurve();
pProjPT->Init(aC3D, f, l);
//
- anAdr=(Standard_Address)pProjPT;
- myProjPTMap.Bind(aC3D, anAdr);
- }
-
- else {
- anAdr=myProjPTMap.Find(aC3D);
- pProjPT=(GeomAPI_ProjectPointOnCurve*)anAdr;
+ myProjPTMap.Bind (aC3D, pProjPT);
}
return *pProjPT;
}
+
//=======================================================================
//function : SolidClassifier
//purpose :
BRepClass3d_SolidClassifier& IntTools_Context::SolidClassifier
(const TopoDS_Solid& aSolid)
{
- Standard_Address anAdr;
- BRepClass3d_SolidClassifier* pSC;
-
- if (!mySClassMap.IsBound(aSolid)) {
- //
+ BRepClass3d_SolidClassifier* pSC = NULL;
+ if (!mySClassMap.Find (aSolid, pSC))
+ {
pSC=(BRepClass3d_SolidClassifier*)myAllocator->Allocate(sizeof(BRepClass3d_SolidClassifier));
new (pSC) BRepClass3d_SolidClassifier(aSolid);
//
- anAdr=(Standard_Address)pSC;
- mySClassMap.Bind(aSolid, anAdr);
- }
-
- else {
- anAdr=mySClassMap.Find(aSolid);
- pSC =(BRepClass3d_SolidClassifier*)anAdr;
+ mySClassMap.Bind (aSolid, pSC);
}
return *pSC;
}
BRepAdaptor_Surface& IntTools_Context::SurfaceAdaptor
(const TopoDS_Face& theFace)
{
- Standard_Address anAdr;
- BRepAdaptor_Surface* pBAS;
-
- if (!mySurfAdaptorMap.IsBound(theFace)) {
+ BRepAdaptor_Surface* pBAS = NULL;
+ if (!mySurfAdaptorMap.Find (theFace, pBAS))
+ {
//
pBAS=(BRepAdaptor_Surface*)myAllocator->Allocate(sizeof(BRepAdaptor_Surface));
new (pBAS) BRepAdaptor_Surface(theFace, Standard_True);
//
- anAdr=(Standard_Address)pBAS;
- mySurfAdaptorMap.Bind(theFace, anAdr);
- }
-
- else {
- anAdr=mySurfAdaptorMap.Find(theFace);
- pBAS =(BRepAdaptor_Surface*)anAdr;
+ mySurfAdaptorMap.Bind (theFace, pBAS);
}
return *pBAS;
}
//=======================================================================
Geom2dHatch_Hatcher& IntTools_Context::Hatcher(const TopoDS_Face& aF)
{
- Standard_Address anAdr;
- Geom2dHatch_Hatcher* pHatcher;
- //
- if (!myHatcherMap.IsBound(aF)) {
+ Geom2dHatch_Hatcher* pHatcher = NULL;
+ if (!myHatcherMap.Find (aF, pHatcher))
+ {
Standard_Real aTolArcIntr, aTolTangfIntr, aTolHatch2D, aTolHatch3D;
Standard_Real aU1, aU2, aEpsT;
TopAbs_Orientation aOrE;
pHatcher->AddElement(aGAC, aOrE);
}// for (; aExp.More() ; aExp.Next()) {
//
- anAdr=(Standard_Address)pHatcher;
- myHatcherMap.Bind(aFF, anAdr);
- }//if (!myHatcherMap.IsBound(aF)) {
- //
- else {
- anAdr=myHatcherMap.Find(aF);
- pHatcher=(Geom2dHatch_Hatcher*)anAdr;
+ myHatcherMap.Bind (aFF, pHatcher);
}
-
return *pHatcher;
}
Bnd_OBB& IntTools_Context::OBB(const TopoDS_Shape& aS,
const Standard_Real theGap)
{
- Standard_Address anAdr;
- Bnd_OBB* pBox;
- //
- if (!myOBBMap.IsBound(aS))
+ Bnd_OBB* pBox = NULL;
+ if (!myOBBMap.Find (aS, pBox))
{
pBox = (Bnd_OBB*)myAllocator->Allocate(sizeof(Bnd_OBB));
new (pBox) Bnd_OBB();
BRepBndLib::AddOBB(aS, aBox);
aBox.Enlarge(theGap);
//
- anAdr = (Standard_Address)pBox;
- myOBBMap.Bind(aS, anAdr);
- }
- else
- {
- anAdr = myOBBMap.Find(aS);
- pBox = (Bnd_OBB*)anAdr;
+ myOBBMap.Bind(aS, pBox);
}
return *pBox;
}
IntTools_SurfaceRangeLocalizeData& IntTools_Context::SurfaceData
(const TopoDS_Face& aF)
{
- Standard_Address anAdr;
- IntTools_SurfaceRangeLocalizeData* pSData;
- //
- if (!myProjSDataMap.IsBound(aF)) {
+ IntTools_SurfaceRangeLocalizeData* pSData = NULL;
+ if (!myProjSDataMap.Find (aF, pSData))
+ {
pSData=(IntTools_SurfaceRangeLocalizeData*)
myAllocator->Allocate(sizeof(IntTools_SurfaceRangeLocalizeData));
new (pSData) IntTools_SurfaceRangeLocalizeData
10. * Precision::PConfusion(),
10. * Precision::PConfusion());
//
- anAdr=(Standard_Address)pSData;
- myProjSDataMap.Bind(aF, anAdr);
- }
-
- else {
- anAdr=myProjSDataMap.Find(aF);
- pSData=(IntTools_SurfaceRangeLocalizeData*)anAdr;
+ myProjSDataMap.Bind (aF, pSData);
}
return *pSData;
-
}
//=======================================================================
//=======================================================================
void IntTools_Context::clearCachedPOnSProjectors()
{
- GeomAPI_ProjectPointOnSurf* pProjPS;
- DataMapOfShapeAddress::Iterator aIt(myProjPSMap);
- for (; aIt.More(); aIt.Next()) {
- Standard_Address anAdr=aIt.Value();
- pProjPS=(GeomAPI_ProjectPointOnSurf*)anAdr;
+ for (NCollection_DataMap<TopoDS_Shape, GeomAPI_ProjectPointOnSurf*, TopTools_ShapeMapHasher>::Iterator aIt(myProjPSMap);
+ aIt.More(); aIt.Next())
+ {
+ GeomAPI_ProjectPointOnSurf* pProjPS = aIt.Value();
(*pProjPS).~GeomAPI_ProjectPointOnSurf();
- myAllocator->Free(anAdr);
+ myAllocator->Free (pProjPS);
}
myProjPSMap.Clear();
}
UMax = aBAS.LastUParameter ();
VMin = aBAS.FirstVParameter();
VMax = aBAS.LastVParameter ();
-}
\ No newline at end of file
+}
protected:
- typedef NCollection_DataMap<TopoDS_Shape,
- Standard_Address,
- TopTools_ShapeMapHasher> DataMapOfShapeAddress;
- typedef NCollection_DataMap<Handle(Standard_Transient),
- Standard_Address,
- TColStd_MapTransientHasher> DataMapOfTransientAddress;
-
Handle(NCollection_BaseAllocator) myAllocator;
- DataMapOfShapeAddress myFClass2dMap;
- DataMapOfShapeAddress myProjPSMap;
- DataMapOfShapeAddress myProjPCMap;
- DataMapOfShapeAddress mySClassMap;
- DataMapOfTransientAddress myProjPTMap;
- DataMapOfShapeAddress myHatcherMap;
- DataMapOfShapeAddress myProjSDataMap;
- DataMapOfShapeAddress myBndBoxDataMap;
- DataMapOfShapeAddress mySurfAdaptorMap;
- DataMapOfShapeAddress myOBBMap; // Map of oriented bounding boxes
+ NCollection_DataMap<TopoDS_Shape, IntTools_FClass2d*, TopTools_ShapeMapHasher> myFClass2dMap;
+ NCollection_DataMap<TopoDS_Shape, GeomAPI_ProjectPointOnSurf*, TopTools_ShapeMapHasher> myProjPSMap;
+ NCollection_DataMap<TopoDS_Shape, GeomAPI_ProjectPointOnCurve*, TopTools_ShapeMapHasher> myProjPCMap;
+ NCollection_DataMap<TopoDS_Shape, BRepClass3d_SolidClassifier*, TopTools_ShapeMapHasher> mySClassMap;
+ NCollection_DataMap<Handle(Geom_Curve), GeomAPI_ProjectPointOnCurve*, TColStd_MapTransientHasher> myProjPTMap;
+ NCollection_DataMap<TopoDS_Shape, Geom2dHatch_Hatcher*, TopTools_ShapeMapHasher> myHatcherMap;
+ NCollection_DataMap<TopoDS_Shape, IntTools_SurfaceRangeLocalizeData*, TopTools_ShapeMapHasher> myProjSDataMap;
+ NCollection_DataMap<TopoDS_Shape, Bnd_Box*, TopTools_ShapeMapHasher> myBndBoxDataMap;
+ NCollection_DataMap<TopoDS_Shape, BRepAdaptor_Surface*, TopTools_ShapeMapHasher> mySurfAdaptorMap;
+ NCollection_DataMap<TopoDS_Shape, Bnd_OBB*, TopTools_ShapeMapHasher> myOBBMap; // Map of oriented bounding boxes
Standard_Integer myCreateFlag;
Standard_Real myPOnSTolerance;
-
private:
myPerMinParam(0.0),
myPerMaxParam(0.0),
myPeriodicDir(0),
- myExtCC(NULL),
+ myExtCCCurve1(NULL),
+ myExtCCLast2DParam(0.0),
myExtPS(NULL)
{ }
- // Assignment operator is forbidden.
- void operator=(const SplitDS &theSplitDS);
-
const Handle(Adaptor3d_Curve) myCurve;
const Handle(Adaptor3d_Surface) mySurface;
NCollection_Vector<Standard_Real> &mySplits;
Standard_Real myPerMaxParam;
Standard_Integer myPeriodicDir;
- Extrema_ExtCC *myExtCC;
+ Adaptor3d_CurveOnSurface* myExtCCCurve1;
+ Standard_Real myExtCCLast2DParam;
+
Extrema_ExtPS *myExtPS;
+
+private:
+
+ // Assignment operator is forbidden.
+ void operator=(const SplitDS &theSplitDS);
+
};
//! Compute split points in the parameter space of the curve.
Handle(Geom2d_Curve) aC2GC = new Geom2d_Line(aStartPnt, aDir);
Handle(Geom2dAdaptor_Curve) aC = new Geom2dAdaptor_Curve(aC2GC, 0, aLast2DParam);
Adaptor3d_CurveOnSurface aCOnS(aC, theSplitDS.mySurface);
-
- Extrema_ExtCC anExtCC;
- anExtCC.SetCurve(1, aCOnS);
- anExtCC.SetCurve(2, *theSplitDS.myCurve);
- anExtCC.SetSingleSolutionFlag(Standard_True); // Search only one solution since multiple invocations are needed.
- anExtCC.SetRange(1, 0, aLast2DParam);
- theSplitDS.myExtCC = &anExtCC;
+ theSplitDS.myExtCCCurve1 = &aCOnS;
+ theSplitDS.myExtCCLast2DParam = aLast2DParam;
FindSplitPoint(theSplitDS,
theSplitDS.myCurve->FirstParameter(), // Initial curve range.
const Standard_Real theMaxParam)
{
// Make extrema copy to avoid dependencies between different levels of the recursion.
- Extrema_ExtCC anExtCC(*theSplitDS.myExtCC);
+ Extrema_ExtCC anExtCC;
+ anExtCC.SetCurve(1, *theSplitDS.myExtCCCurve1);
+ anExtCC.SetCurve(2, *theSplitDS.myCurve);
+ anExtCC.SetSingleSolutionFlag (Standard_True); // Search only one solution since multiple invocations are needed.
+ anExtCC.SetRange(1, 0, theSplitDS.myExtCCLast2DParam);
anExtCC.SetRange(2, theMinParam, theMaxParam);
anExtCC.Perform();
#include <ProjLib_PrjFunc.hxx>
#include <Standard_ConstructionError.hxx>
-ProjLib_PrjFunc::ProjLib_PrjFunc(const Adaptor3d_CurvePtr & C,const Standard_Real FixVal,const Adaptor3d_SurfacePtr & S, const Standard_Integer Fix) : myCurve(C), mySurface(S), myt(0), myU(0), myV(0), myFix(Fix)
+ProjLib_PrjFunc::ProjLib_PrjFunc (const Adaptor3d_Curve* C, const Standard_Real FixVal, const Adaptor3d_Surface* S, const Standard_Integer Fix)
+: myCurve(C), mySurface(S), myt(0), myU(0), myV(0), myFix(Fix)
{
myNorm=Min(1.,Min(mySurface->UResolution(1.),mySurface->VResolution(1.)));
// myNorm=1.;
// pout NT, meme si on n'y passe pas.
return gp_Pnt2d(0.,0.);
}
-
-
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
-#include <Adaptor3d_CurvePtr.hxx>
-#include <Adaptor3d_SurfacePtr.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Integer.hxx>
#include <math_FunctionSetWithDerivatives.hxx>
-#include <Standard_Boolean.hxx>
#include <math_Vector.hxx>
-class Standard_ConstructionError;
+
class math_Matrix;
class gp_Pnt2d;
-
-
class ProjLib_PrjFunc : public math_FunctionSetWithDerivatives
{
public:
DEFINE_STANDARD_ALLOC
- Standard_EXPORT ProjLib_PrjFunc(const Adaptor3d_CurvePtr& C, const Standard_Real FixVal, const Adaptor3d_SurfacePtr& S, const Standard_Integer Fix);
+ Standard_EXPORT ProjLib_PrjFunc(const Adaptor3d_Curve* C, const Standard_Real FixVal, const Adaptor3d_Surface* S, const Standard_Integer Fix);
//! returns the number of variables of the function.
Standard_EXPORT Standard_Integer NbVariables() const;
//! returns point on surface
Standard_EXPORT gp_Pnt2d Solution() const;
-
-
-
-protected:
-
-
-
-
-
private:
-
-
- Adaptor3d_CurvePtr myCurve;
- Adaptor3d_SurfacePtr mySurface;
+ const Adaptor3d_Curve* myCurve;
+ const Adaptor3d_Surface* mySurface;
Standard_Real myt;
Standard_Real myU;
Standard_Real myV;
Standard_Integer myFix;
Standard_Real myNorm;
-
};
-
-
-
-
-
-
#endif // _ProjLib_PrjFunc_HeaderFile
{
if (myFix > 3 || myFix < 1) throw Standard_ConstructionError();
mySolution = gp_Pnt2d(0.,0.);
- myCurve = (Adaptor3d_CurvePtr)&C;
- mySurface = (Adaptor3d_SurfacePtr)&S;
+ myCurve = &C;
+ mySurface = &S;
}
// void ProjLib_PrjResolve::Perform(const Standard_Real t, const Standard_Real U, const Standard_Real V, const gp_Pnt2d& Tol2d, const gp_Pnt2d& Inf, const gp_Pnt2d& Sup, const Standard_Real FuncTol, const Standard_Boolean StrictInside)
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
-#include <Adaptor3d_CurvePtr.hxx>
-#include <Adaptor3d_SurfacePtr.hxx>
-#include <Standard_Boolean.hxx>
#include <gp_Pnt2d.hxx>
-#include <Standard_Integer.hxx>
-#include <Standard_Real.hxx>
-class Standard_DomainError;
-class Standard_ConstructionError;
-class StdFail_NotDone;
+
class Adaptor3d_Curve;
class Adaptor3d_Surface;
-class gp_Pnt2d;
-
class ProjLib_PrjResolve
//! Returns the point of the extremum distance.
Standard_EXPORT gp_Pnt2d Solution() const;
-
-
-
-protected:
-
-
-
-
-
private:
-
-
- Adaptor3d_CurvePtr myCurve;
- Adaptor3d_SurfacePtr mySurface;
+ const Adaptor3d_Curve* myCurve;
+ const Adaptor3d_Surface* mySurface;
Standard_Boolean myDone;
gp_Pnt2d mySolution;
Standard_Integer myFix;
-
};
-
-
-
-
-
-
#endif // _ProjLib_PrjResolve_HeaderFile
projects / occt.git / commitdiff