--- File: BRepExtrema.cdl
--- Created: Fri Dec 3 15:48:19 1993
--- Author: Christophe MARION
--- <cma@sdsun1>
----Copyright: Matra Datavision 1993
+-- File: BRepExtrema.cdl
+-- Created: Fri Dec 3 15:48:19 1993
+-- Author: Christophe MARION
+---Copyright: Matra Datavision 1993
package BRepExtrema
----------------------------------------------------------
-- Extrema between two Shapes with triangulation.
----------------------------------------------------------
- class Poly;
+ imported Poly;
----------------------------------------------------------
-- Extrema between a Point and an Edge.
----------------------------------------------------------
- class ExtPC;
+ imported ExtPC;
----------------------------------------------------------
-- Extrema between two Edges.
----------------------------------------------------------
- class ExtCC;
+ imported ExtCC;
----------------------------------------------------------
-- Extrema between a Point and a Face.
----------------------------------------------------------
- class ExtPF;
+ imported ExtPF;
----------------------------------------------------------
-- Extrema between an Edge and a Face.
----------------------------------------------------------
- class ExtCF;
+ imported ExtCF;
----------------------------------------------------------
-- Extrema between two Faces.
----------------------------------------------------------
- class ExtFF;
+ imported ExtFF;
----------------------------------------------------------
-- IsInFace => The solution is inside a Face.
----------------------------------------------------------
- enumeration SupportType is IsVertex, IsOnEdge, IsInFace end SupportType;
-
+ imported SupportType;
----------------------------------------------------------
-- between two shapes and the corresponding couples of solution points.
----------------------------------------------------------
- class DistShapeShape;
-
-
+ imported DistShapeShape;
----------------------------------------------------------
-- This class is used to store a solution on a Shape.
-- (used only by class DistShapeShape)
----------------------------------------------------------
- class SolutionElem;
-
+ imported SolutionElem;
----------------------------------------------------------
-- This sequence is used to store all the solution on each Shape.
----------------------------------------------------------
- class SeqOfSolution instantiates Sequence from TCollection
- ( SolutionElem from BRepExtrema);
-
-
-
-
-
- ----------------------------------------------------------
- -- This class is used to compute minimum distance between two elementary
- -- Shapes ( Vertex, Edge, Face ) (used only by class DistShapeShape)
- ----------------------------------------------------------
- private class DistanceSS from BRepExtrema;
-
-
-
-
-
+ imported SeqOfSolution;
+ imported DistanceSS;
end BRepExtrema;
-// File: BRepExtrema_DistShapeShape.cxx
-// Created: Mon Apr 22 17:03:37 1996
-// Modified : Mps(10-04-97) portage WNT
-// Author: Maria PUMBORIOS
-// Author: Herve LOUESSARD
-// <mps@sgi64>
-
-#include <BRepExtrema_DistShapeShape.ixx>
+// File: BRepExtrema_DistShapeShape.cxx
+// Created: Mon Apr 22 17:03:37 1996
+// Modified: Mps(10-04-97) portage WNT
+// Author: Maria PUMBORIOS
+// Author: Herve LOUESSARD
+
+#include <BRepExtrema_DistShapeShape.hxx>
+
#include <Standard_OStream.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <BRepBndLib.hxx>
#include <Bnd_Box.hxx>
#include <TopExp.hxx>
-#include <TCollection.hxx>
-#include <Standard_Real.hxx>
#include <BRepExtrema_DistanceSS.hxx>
#include <TopoDS.hxx>
#include <TopAbs.hxx>
#include <TopoDS_Face.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <Precision.hxx>
-#include <BRepExtrema_SeqOfSolution.hxx>
-#include <BRepExtrema_SolutionElem.hxx>
#include <Bnd_SeqOfBox.hxx>
#include <BRepExtrema_UnCompatibleShape.hxx>
#include <BRep_Tool.hxx>
#include <BRepClass3d_SolidClassifier.hxx>
+#include <StdFail_NotDone.hxx>
static void Decomposition(const TopoDS_Shape& S,
TopTools_IndexedMapOfShape& MapV,
TopTools_IndexedMapOfShape& MapE,
TopTools_IndexedMapOfShape& MapF)
{
- MapV.Clear();
- MapE.Clear();
- MapF.Clear();
- TopExp::MapShapes(S,TopAbs_VERTEX,MapV);
- TopExp::MapShapes(S,TopAbs_EDGE,MapE);
- TopExp::MapShapes(S,TopAbs_FACE,MapF);
+ MapV.Clear();
+ MapE.Clear();
+ MapF.Clear();
+ TopExp::MapShapes(S,TopAbs_VERTEX,MapV);
+ TopExp::MapShapes(S,TopAbs_EDGE,MapE);
+ TopExp::MapShapes(S,TopAbs_FACE,MapF);
}
static void BoxCalculation(const TopTools_IndexedMapOfShape& Map,
Bnd_SeqOfBox& SBox)
{
- Standard_Integer i = 0;
- for(i = 1; i <= Map.Extent(); i++) {
- Bnd_Box box;
- BRepBndLib::Add( Map(i), box);
- SBox.Append(box);
- }
+ for (Standard_Integer i = 1; i <= Map.Extent(); i++)
+ {
+ Bnd_Box box;
+ BRepBndLib::Add(Map(i), box);
+ SBox.Append(box);
+ }
}
-static Standard_Real DistanceInitiale(const TopoDS_Vertex V1,
+inline Standard_Real DistanceInitiale(const TopoDS_Vertex V1,
const TopoDS_Vertex V2)
{
- gp_Pnt P1,P2;
- P1= BRep_Tool::Pnt(V1);
- P2= BRep_Tool::Pnt(V2);
- return(P1.Distance(P2));
+ return (BRep_Tool::Pnt(V1).Distance(BRep_Tool::Pnt(V2)));
}
//=======================================================================
const Bnd_SeqOfBox& LBox1,
const Bnd_SeqOfBox& LBox2)
{
- Standard_Integer i = 0, j = 0;
- Bnd_Box box1, box2;
- TopoDS_Shape S1, S2;
- BRepExtrema_SeqOfSolution seq1, seq2;
-
- Standard_Integer n1 = Map1.Extent();
- Standard_Integer n2 = Map2.Extent();
- for(i = 1; i <= n1; i++) {
- box1= LBox1.Value(i);
- S1= TopoDS_Shape (Map1(i));
- for(j = 1; j <= n2; j++) {
- box2= LBox2.Value(j);
- S2 = TopoDS_Shape (Map2(j));
+ Standard_Integer i, j;
+ BRepExtrema_SeqOfSolution seq1, seq2;
+
+ const Standard_Integer n1 = Map1.Extent();
+ const Standard_Integer n2 = Map2.Extent();
+ for (i = 1; i <= n1; i++)
+ {
+ const Bnd_Box &box1 = LBox1.Value(i);
+ const TopoDS_Shape &S1 = Map1(i);
+ for (j = 1; j <= n2; j++)
+ {
+ const Bnd_Box &box2= LBox2.Value(j);
+ const TopoDS_Shape &S2 = Map2(j);
+
BRepExtrema_DistanceSS dist(S1,S2,box1,box2,myDistRef,myEps);
- if(dist.IsDone())
- if(dist.DistValue() < (myDistRef-myEps)) {
- ListeDeSolutionShape1.Clear();
- ListeDeSolutionShape2.Clear();
+ if (dist.IsDone())
+ if(dist.DistValue() < (myDistRef-myEps))
+ {
+ mySolutionsShape1.Clear();
+ mySolutionsShape2.Clear();
seq1= dist.Seq1Value();
seq2= dist.Seq2Value();
- ListeDeSolutionShape1.Append(seq1);
- ListeDeSolutionShape2.Append(seq2);
+ mySolutionsShape1.Append(seq1);
+ mySolutionsShape2.Append(seq2);
myDistRef=dist.DistValue();
}
- else if(fabs (dist.DistValue()-myDistRef)< myEps ) {
+ else if(fabs(dist.DistValue()-myDistRef) < myEps)
+ {
seq1= dist.Seq1Value();
seq2= dist.Seq2Value();
- ListeDeSolutionShape1.Append(seq1);
- ListeDeSolutionShape2.Append(seq2);
- // Modified by Sergey KHROMOV - Tue Mar 6 12:15:39 2001 Begin
+ mySolutionsShape1.Append(seq1);
+ mySolutionsShape2.Append(seq2);
if (myDistRef > dist.DistValue())
myDistRef=dist.DistValue();
- // Modified by Sergey KHROMOV - Tue Mar 6 12:15:37 2001 End
}
}
}
//=======================================================================
BRepExtrema_DistShapeShape::BRepExtrema_DistShapeShape()
+: myDistRef(0.),
+ myDistValue(0.),
+ myIsDone(Standard_False),
+ myInnerSol(Standard_False),
+ myEps(Precision::Confusion()),
+ myFlag(Extrema_ExtFlag_MINMAX),
+ myAlgo(Extrema_ExtAlgo_Grad)
{
- myEps = Precision::Confusion();
}
//=======================================================================
//purpose :
//=======================================================================
BRepExtrema_DistShapeShape::BRepExtrema_DistShapeShape(const TopoDS_Shape& Shape1,
- const TopoDS_Shape& Shape2)
+ const TopoDS_Shape& Shape2,
+ const Extrema_ExtFlag F,
+ const Extrema_ExtAlgo A)
+: myDistRef(0.),
+ myDistValue(0.),
+ myIsDone(Standard_False),
+ myInnerSol(Standard_False),
+ myEps(Precision::Confusion()),
+ myFlag(F),
+ myAlgo(A)
{
- myEps = Precision::Confusion();
LoadS1(Shape1);
LoadS2(Shape2);
Perform();
//=======================================================================
BRepExtrema_DistShapeShape::BRepExtrema_DistShapeShape(const TopoDS_Shape& Shape1,
- const TopoDS_Shape& Shape2,
- const Standard_Real theDeflection)
+ const TopoDS_Shape& Shape2,
+ const Standard_Real theDeflection,
+ const Extrema_ExtFlag F,
+ const Extrema_ExtAlgo A)
+: myDistRef(0.),
+ myDistValue(0.),
+ myIsDone(Standard_False),
+ myInnerSol(Standard_False),
+ myEps(theDeflection),
+ myFlag(F),
+ myAlgo(A)
{
- myEps = theDeflection;
LoadS1(Shape1);
LoadS2(Shape2);
Perform();
}
-//=======================================================================
-//function : SetDeflection
-//purpose :
-//=======================================================================
-
-void BRepExtrema_DistShapeShape::SetDeflection(const Standard_Real theDeflection)
-{
- myEps = theDeflection;
-}
-
//=======================================================================
//function : LoadS1
//purpose :
{
myIsDone=Standard_False;
myInnerSol=Standard_False;
- ListeDeSolutionShape1.Clear();
- ListeDeSolutionShape2.Clear();
-
- if( myShape1.IsNull() || myShape2.IsNull() )
+ mySolutionsShape1.Clear();
+ mySolutionsShape2.Clear();
+
+ if ( myShape1.IsNull() || myShape2.IsNull() )
return Standard_False;
+ TopoDS_Vertex V;
Bnd_SeqOfBox BV1, BV2, BE1, BE2, BF1, BF2;
- Standard_Real tol = 0.001;
- gp_Pnt P;
- Standard_Integer nbv1,nbv2;
-
- // traitement des solides
- TopAbs_ShapeEnum Type1 = myShape1.ShapeType();
- TopAbs_ShapeEnum Type2 = myShape2.ShapeType();
- if((Type1==TopAbs_SOLID) || (Type1 == TopAbs_COMPSOLID)) {
+ const Standard_Real tol = 0.001;
+
+ // Treatment of solids
+ const TopAbs_ShapeEnum Type1 = myShape1.ShapeType();
+ if ((Type1==TopAbs_SOLID) || (Type1 == TopAbs_COMPSOLID))
+ {
BRepClass3d_SolidClassifier Classi(myShape1);
- nbv2=myMapV2.Extent();
- nbv1=0;
- while ( (nbv1<nbv2) && (! myInnerSol))
+ const Standard_Integer nbv2 = myMapV2.Extent();
+ Standard_Integer nbv1 = 0;
+ do
{
nbv1++;
- TopoDS_Vertex V2 = TopoDS::Vertex(myMapV2(nbv1));
- P=BRep_Tool::Pnt(V2);
+ V = TopoDS::Vertex(myMapV2(nbv1));
+ const gp_Pnt &P = BRep_Tool::Pnt(V);
Classi.Perform(P,tol);
- if(Classi.State()==TopAbs_IN) {
+ if (Classi.State()==TopAbs_IN)
+ {
myInnerSol = Standard_True;
- myNbSolution = 1;
- myDistRef = 0;
+ myDistRef = 0.;
myIsDone = Standard_True;
- BRepExtrema_SolutionElem Sol(0,P,BRepExtrema_IsVertex,V2);
- ListeDeSolutionShape1.Append(Sol);
- ListeDeSolutionShape2.Append(Sol);
+ BRepExtrema_SolutionElem Sol(0,P,BRepExtrema_IsVertex,V);
+ mySolutionsShape1.Append(Sol);
+ mySolutionsShape2.Append(Sol);
}
}
+ while ( (nbv1<nbv2) && (!myInnerSol) );
}
- if(((Type2==TopAbs_SOLID)||(Type2==TopAbs_COMPSOLID))&&(!myInnerSol)) {
+ const TopAbs_ShapeEnum Type2 = myShape2.ShapeType();
+ if (((Type2==TopAbs_SOLID) || (Type2==TopAbs_COMPSOLID)) && (!myInnerSol))
+ {
BRepClass3d_SolidClassifier Classi(myShape2);
- nbv1= myMapV1.Extent();
- nbv2=0;
- while ((nbv2<nbv1) && (! myInnerSol))
+ const Standard_Integer nbv1 = myMapV1.Extent();
+ Standard_Integer nbv2 = 0;
+ do
{
nbv2++;
- TopoDS_Vertex V1=TopoDS::Vertex(myMapV1(nbv2));
- P=BRep_Tool::Pnt(V1);
+ V = TopoDS::Vertex(myMapV1(nbv2));
+ const gp_Pnt &P = BRep_Tool::Pnt(V);
Classi.Perform(P,tol);
if (Classi.State()==TopAbs_IN) {
myInnerSol = Standard_True;
- myNbSolution = 1;
myDistRef = 0;
myIsDone = Standard_True;
- BRepExtrema_SolutionElem Sol (0,P,BRepExtrema_IsVertex,V1);
- ListeDeSolutionShape1.Append(Sol);
- ListeDeSolutionShape2.Append(Sol);
+ BRepExtrema_SolutionElem Sol (0,P,BRepExtrema_IsVertex,V);
+ mySolutionsShape1.Append(Sol);
+ mySolutionsShape2.Append(Sol);
}
}
+ while ( (nbv2<nbv1) && (!myInnerSol) );
}
- if (!myInnerSol) {
- BoxCalculation( myMapV1,BV1);
- BoxCalculation( myMapE1,BE1);
- BoxCalculation( myMapF1,BF1);
- BoxCalculation( myMapV2,BV2);
- BoxCalculation( myMapE2,BE2);
- BoxCalculation( myMapF2,BF2);
+ if (!myInnerSol)
+ {
+ BoxCalculation(myMapV1,BV1);
+ BoxCalculation(myMapE1,BE1);
+ BoxCalculation(myMapF1,BF1);
+ BoxCalculation(myMapV2,BV2);
+ BoxCalculation(myMapE2,BE2);
+ BoxCalculation(myMapF2,BF2);
- if (myMapV1.Extent()!=0 && myMapV2.Extent()!=0) {
+ if (myMapV1.Extent() && myMapV2.Extent())
+ {
TopoDS_Vertex V1 = TopoDS::Vertex(myMapV1(1));
TopoDS_Vertex V2 = TopoDS::Vertex(myMapV2(1));
- myDistRef = DistanceInitiale(V1, V2);
+ myDistRef = DistanceInitiale(V1, V2);
}
else
- myDistRef= 1.e30;
-
- DistanceMapMap( myMapV1, myMapV2, BV1, BV2);
- DistanceMapMap( myMapV1, myMapE2, BV1, BE2);
- DistanceMapMap( myMapE1, myMapV2, BE1, BV2);
- DistanceMapMap( myMapV1, myMapF2, BV1, BF2);
- DistanceMapMap( myMapF1, myMapV2, BF1, BV2);
- DistanceMapMap( myMapE1, myMapE2, BE1, BE2);
- DistanceMapMap( myMapE1, myMapF2, BE1, BF2);
- DistanceMapMap( myMapF1, myMapE2, BF1, BE2);
-
+ myDistRef= 1.e30; //szv:!!!
+
+ DistanceMapMap(myMapV1, myMapV2, BV1, BV2);
+ DistanceMapMap(myMapV1, myMapE2, BV1, BE2);
+ DistanceMapMap(myMapE1, myMapV2, BE1, BV2);
+ DistanceMapMap(myMapV1, myMapF2, BV1, BF2);
+ DistanceMapMap(myMapF1, myMapV2, BF1, BV2);
+ DistanceMapMap(myMapE1, myMapE2, BE1, BE2);
+ DistanceMapMap(myMapE1, myMapF2, BE1, BF2);
+ DistanceMapMap(myMapF1, myMapE2, BF1, BE2);
+
if( (fabs(myDistRef)) > myEps )
DistanceMapMap(myMapF1,myMapF2,BF1,BF2);
// Modified by Sergey KHROMOV - Tue Mar 6 11:55:03 2001 Begin
- Standard_Integer i = 0;
- for(i = 1; i <= ListeDeSolutionShape1.Length(); i++)
- if (ListeDeSolutionShape1.Value(i).Dist() > myDistRef + myEps) {
- ListeDeSolutionShape1.Remove(i);
- ListeDeSolutionShape2.Remove(i);
+ Standard_Integer i = 1;
+ for (; i <= mySolutionsShape1.Length(); i++)
+ if (mySolutionsShape1.Value(i).Dist() > myDistRef + myEps)
+ {
+ mySolutionsShape1.Remove(i);
+ mySolutionsShape2.Remove(i);
}
// Modified by Sergey KHROMOV - Tue Mar 6 11:55:04 2001 End
- myNbSolution = ListeDeSolutionShape1.Length();
- if( myNbSolution > 0 )
- myIsDone = Standard_True;
- else
- myIsDone = Standard_False;
+ myIsDone = ( mySolutionsShape1.Length() > 0 );
}
return myIsDone;
}
-//=======================================================================
-//function :
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepExtrema_DistShapeShape:: InnerSolution () const
-{
- return (myInnerSol);
-}
-
-//=======================================================================
-//function : IsDone
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepExtrema_DistShapeShape::IsDone() const
-{
- return (myIsDone);
-}
-
-//=======================================================================
-//function : NbSolution
-//purpose :
-//=======================================================================
-
-Standard_Integer BRepExtrema_DistShapeShape::NbSolution() const
-{
- if (myIsDone == Standard_False) {
- StdFail_NotDone::Raise
- ("BRepExtrema_DistShapeShape::NbSolution: There's no solution ");
- }
- return (myNbSolution);
-}
-
//=======================================================================
//function : Value
//purpose :
Standard_Real BRepExtrema_DistShapeShape::Value() const
{
- if (myIsDone == Standard_False) {
- StdFail_NotDone::Raise
- ("BRepExtrema_DistShapeShape::Value: There's no solution ");
- }
- return (myDistRef);
-}
+ if (!myIsDone)
+ StdFail_NotDone::Raise("BRepExtrema_DistShapeShape::Value: There's no solution ");
-//=======================================================================
-//function : PointOnShape1
-//purpose :
-//=======================================================================
-
-gp_Pnt BRepExtrema_DistShapeShape::PointOnShape1(const Standard_Integer N) const
-{
- if (myIsDone == Standard_False)
- { StdFail_NotDone::Raise
- ("BRepExtrema_DistShapeShape::PointOnShape1: There's no solution ");
- }
- if ((N<1)||(N>myNbSolution))
- { Standard_OutOfRange::Raise
- ("BRepExtrema_DistShapeShape::PointOnShape1: Nth solution doesn't exist ");
- }
- return ((ListeDeSolutionShape1.Value(N)).Point());
-}
-
-//=======================================================================
-//function : PointOnShape2
-//purpose :
-//=======================================================================
-
-gp_Pnt BRepExtrema_DistShapeShape::PointOnShape2(const Standard_Integer N) const
-{
- if (myIsDone == Standard_False)
- { StdFail_NotDone::Raise
- ("BRepExtrema_DistShapeShape::PointOnShape2: There's no solution ");
- }
- if ((N<1)||(N>myNbSolution))
- { Standard_OutOfRange::Raise
- ("BRepExtrema_DistShapeShape::PointOnShape2: Nth solution doesn't exist ");
- }
- return ((ListeDeSolutionShape2.Value(N)).Point());
-}
-
-//=======================================================================
-//function : SupportTypeShape1
-//purpose :
-//=======================================================================
-
-BRepExtrema_SupportType BRepExtrema_DistShapeShape::SupportTypeShape1(const Standard_Integer N) const
-{
- if (myIsDone == Standard_False)
- { StdFail_NotDone::Raise
- ("BRepExtrema_DistShapeShape::SupportTypeShape1: There's no solution ");
- }
- if ((N<1)||(N>myNbSolution))
- { Standard_OutOfRange::Raise
- ("BRepExtrema_DistShapeShape::SupportTypeShape1: Nth solution doesn't exist ");
- }
- return ((ListeDeSolutionShape1.Value(N)).SupportKind());
-}
-
-//=======================================================================
-//function : SupportTypeShape2
-//purpose :
-//=======================================================================
-
-BRepExtrema_SupportType BRepExtrema_DistShapeShape::SupportTypeShape2(const Standard_Integer N) const
-{
- if (myIsDone == Standard_False)
- { StdFail_NotDone::Raise
- ("BRepExtrema_DistShapeShape::SupportTypeShape2: There's no solution ");
- }
- if ((N<1)||(N>myNbSolution))
- { Standard_OutOfRange::Raise
- ("BRepExtrema_DistShapeShape::SupportTypeShape2: Nth solution doesn't exist ");
- }
- return ((ListeDeSolutionShape2.Value(N)).SupportKind());
+ return myDistRef;
}
//=======================================================================
//purpose :
//=======================================================================
-TopoDS_Shape BRepExtrema_DistShapeShape::SupportOnShape1(const Standard_Integer N) const
+TopoDS_Shape BRepExtrema_DistShapeShape::SupportOnShape1(const Standard_Integer N) const
{
- BRepExtrema_SupportType Type;
- TopoDS_Shape a_shape;
-
- if (myIsDone == Standard_False)
- { StdFail_NotDone::Raise
- ("BRepExtrema_DistShapeShape::SupportOnShape1: There's no solution ");
- }
- if ((N<1)||(N>myNbSolution))
- { Standard_OutOfRange::Raise
- ("BRepExtrema_DistShapeShape::SupportOnShape1: Nth solution doesn't exist ");
- }
- Type = ((ListeDeSolutionShape1.Value(N)).SupportKind());
- switch ( Type)
- { case BRepExtrema_IsVertex : a_shape=ListeDeSolutionShape1.Value(N).Vertex();
- break;
- case BRepExtrema_IsOnEdge : a_shape=ListeDeSolutionShape1.Value(N).Edge();
- break;
- case BRepExtrema_IsInFace : a_shape=ListeDeSolutionShape1.Value(N).Face();
- break;
- default :{}
- }
- return a_shape ;
+ if (!myIsDone)
+ StdFail_NotDone::Raise("BRepExtrema_DistShapeShape::SupportOnShape1: There's no solution ");
+
+ const BRepExtrema_SolutionElem &sol = mySolutionsShape1.Value(N);
+ switch (sol.SupportKind())
+ {
+ case BRepExtrema_IsVertex : return sol.Vertex();
+ case BRepExtrema_IsOnEdge : return sol.Edge();
+ case BRepExtrema_IsInFace : return sol.Face();
+ }
+ return TopoDS_Shape();
}
//=======================================================================
TopoDS_Shape BRepExtrema_DistShapeShape::SupportOnShape2(const Standard_Integer N) const
{
- BRepExtrema_SupportType Type;
- TopoDS_Shape a_shape ;
-
- if (myIsDone == Standard_False)
- { StdFail_NotDone::Raise
- ("BRepExtrema_DistShapeShape::SupportOnShape2: There's no solution ");
- }
- if ((N<1)||(N>myNbSolution))
- { Standard_OutOfRange::Raise
- ("BRepExtrema_DistShapeShape::SupportOnShape2: Nth solution doesn't exist ");
- }
- Type = ((ListeDeSolutionShape2.Value(N)).SupportKind());
- switch ( Type)
- { case BRepExtrema_IsVertex : a_shape=ListeDeSolutionShape2.Value(N).Vertex();
- break;
- case BRepExtrema_IsOnEdge : a_shape=ListeDeSolutionShape2.Value(N).Edge();
- break;
- case BRepExtrema_IsInFace : a_shape=ListeDeSolutionShape2.Value(N).Face();
- break;
- default :{}
- }
- return a_shape ;
+ if (!myIsDone)
+ StdFail_NotDone::Raise("BRepExtrema_DistShapeShape::SupportOnShape2: There's no solution ");
+
+ const BRepExtrema_SolutionElem &sol = mySolutionsShape2.Value(N);
+ switch (sol.SupportKind())
+ {
+ case BRepExtrema_IsVertex : return sol.Vertex();
+ case BRepExtrema_IsOnEdge : return sol.Edge();
+ case BRepExtrema_IsInFace : return sol.Face();
+ }
+ return TopoDS_Shape();
}
//=======================================================================
void BRepExtrema_DistShapeShape::ParOnEdgeS1(const Standard_Integer N, Standard_Real& t) const
{
- BRepExtrema_SupportType Type;
-
- if (myIsDone == Standard_False)
- { StdFail_NotDone::Raise
- ("BRepExtrema_DistShapeShape::ParOnEdgeS1: There's no solution ");
- }
- if ((N<1)||(N>myNbSolution))
- { Standard_OutOfRange::Raise
- ("BRepExtrema_DistShapeShape::ParOnEdgeS1: Nth solution doesn't exist ");
- }
-
- Type = ((ListeDeSolutionShape1.Value(N)).SupportKind());
- if (Type != BRepExtrema_IsOnEdge)
- { BRepExtrema_UnCompatibleShape::Raise
- ("BRepExtrema_DistShapeShape::ParOnEdgeS1:ParOnEdgeS1 is impossible without EDGE ");
- }
-
- (ListeDeSolutionShape1.Value(N)).EdgeParameter(t);
+ if (!myIsDone)
+ StdFail_NotDone::Raise("BRepExtrema_DistShapeShape::ParOnEdgeS1: There's no solution");
+
+ const BRepExtrema_SolutionElem &sol = mySolutionsShape1.Value(N);
+ if (sol.SupportKind() != BRepExtrema_IsOnEdge)
+ BRepExtrema_UnCompatibleShape::Raise
+ ("BRepExtrema_DistShapeShape::ParOnEdgeS1: ParOnEdgeS1 is impossible without EDGE");
+
+ sol.EdgeParameter(t);
}
//=======================================================================
void BRepExtrema_DistShapeShape::ParOnEdgeS2(const Standard_Integer N, Standard_Real& t) const
{
- BRepExtrema_SupportType Type;
-
- if (myIsDone == Standard_False)
- { StdFail_NotDone::Raise
- ("BRepExtrema_DistShapeShape::ParOnEdgeS2: There's no solution ");
- }
- if ((N<1)||(N>myNbSolution))
- { Standard_OutOfRange::Raise
- ("BRepExtrema_DistShapeShape::ParOnEdgeS2: Nth solution doesn't exist ");
- }
-
- Type = ((ListeDeSolutionShape2.Value(N)).SupportKind());
- if (Type != BRepExtrema_IsOnEdge)
- { BRepExtrema_UnCompatibleShape::Raise
- ("BRepExtrema_DistShapeShape::ParOnEdgeS2:ParOnEdgeS2 is impossible without EDGE ");
- }
+ if (!myIsDone)
+ StdFail_NotDone::Raise("BRepExtrema_DistShapeShape::ParOnEdgeS2: There's no solution");
+
+ const BRepExtrema_SolutionElem &sol = mySolutionsShape2.Value(N);
+ if (sol.SupportKind() != BRepExtrema_IsOnEdge)
+ BRepExtrema_UnCompatibleShape::Raise
+ ("BRepExtrema_DistShapeShape::ParOnEdgeS2: ParOnEdgeS2 is impossible without EDGE");
- (ListeDeSolutionShape2.Value(N)).EdgeParameter(t);
+ sol.EdgeParameter(t);
}
//=======================================================================
void BRepExtrema_DistShapeShape::ParOnFaceS1(const Standard_Integer N, Standard_Real& u, Standard_Real& v) const
{
- BRepExtrema_SupportType Type;
-
- if (myIsDone == Standard_False)
- { StdFail_NotDone::Raise
- ("BRepExtrema_DistShapeShape::ParOnFaceS1: There's no solution ");
- }
- if ((N<1)||(N>myNbSolution))
- { Standard_OutOfRange::Raise
- ("BRepExtrema_DistShapeShape::ParOnFaceS1: Nth solution doesn't exist ");
- }
-
- Type = ((ListeDeSolutionShape1.Value(N)).SupportKind());
- if (Type != BRepExtrema_IsInFace)
- { BRepExtrema_UnCompatibleShape::Raise
- ("BRepExtrema_DistShapeShape::ParOnFaceS1:ParOnFaceS1 is impossible without FACE ");
- }
+ if (!myIsDone)
+ StdFail_NotDone::Raise("BRepExtrema_DistShapeShape::ParOnFaceS1: There's no solution");
+
+ const BRepExtrema_SolutionElem &sol = mySolutionsShape1.Value(N);
+ if (sol.SupportKind() != BRepExtrema_IsInFace)
+ BRepExtrema_UnCompatibleShape::Raise
+ ("BRepExtrema_DistShapeShape::ParOnFaceS1: ParOnFaceS1 is impossible without FACE");
- (ListeDeSolutionShape1.Value(N)).FaceParameter(u, v);
+ sol.FaceParameter(u, v);
}
+//=======================================================================
+//function : ParOnFaceS2
+//purpose :
+//=======================================================================
+
void BRepExtrema_DistShapeShape::ParOnFaceS2(const Standard_Integer N, Standard_Real& u, Standard_Real& v) const
{
- BRepExtrema_SupportType Type;
-
- if (myIsDone == Standard_False)
- { StdFail_NotDone::Raise
- ("BRepExtrema_DistShapeShape::ParOnFaceS2: There's no solution ");
- }
- if ((N<1)||(N>myNbSolution))
- { Standard_OutOfRange::Raise
- ("BRepExtrema_DistShapeShape::ParOnFaceS2: Nth solution doesn't exist ");
- }
- Type = ((ListeDeSolutionShape2.Value(N)).SupportKind());
- if (Type != BRepExtrema_IsInFace)
- { BRepExtrema_UnCompatibleShape::Raise
- ("BRepExtrema_DistShapeShape::ParOnFaceS2:ParOnFaceS2 is impossible without FACE ");
- }
-
- (ListeDeSolutionShape2.Value(N)).FaceParameter(u, v);
+ if (!myIsDone)
+ StdFail_NotDone::Raise("BRepExtrema_DistShapeShape::ParOnFaceS2: There's no solution");
+ const BRepExtrema_SolutionElem &sol = mySolutionsShape2.Value(N);
+ if (sol.SupportKind() != BRepExtrema_IsInFace)
+ BRepExtrema_UnCompatibleShape::Raise
+ ("BRepExtrema_DistShapeShape::ParOnFaceS2:ParOnFaceS2 is impossible without FACE ");
+
+ sol.FaceParameter(u, v);
}
//=======================================================================
{
Standard_Integer i;
Standard_Real r1,r2;
- BRepExtrema_SupportType Type1, Type2;
o<< "the distance value is : " << Value()<<endl;
o<< "the number of solutions is :"<<NbSolution()<<endl;
o<<endl;
- for (i=1;i<=NbSolution();i++) {
- o<<"solution number "<<i<<": "<< endl;
+ for (i=1;i<=NbSolution();i++)
+ {
+ o<<"solution number "<<i<<": "<< endl;
o<<"the type of the solution on the first shape is " <<Standard_Integer( SupportTypeShape1(i)) <<endl;
o<<"the type of the solution on the second shape is "<<Standard_Integer( SupportTypeShape2(i))<< endl;
o<< "the coordinates of the point on the first shape are: "<<endl;
o<< "the coordinates of the point on the second shape are: "<<endl;
o<<"X="<< PointOnShape2(i).X()<< " Y="<<PointOnShape2(i).Y()<<" Z="<< PointOnShape2(i).Z()<<endl;
- Type1=SupportTypeShape1(i);
- Type2=SupportTypeShape2(i);
- if (Type1 == BRepExtrema_IsOnEdge)
- {
- ParOnEdgeS1(i,r1);
- o << "parameter on the first edge : t= " << r1 << endl;
- }
- if (Type1 == BRepExtrema_IsInFace)
- {
- ParOnFaceS1(i,r1,r2);
- o << "parameters on the first face : u= " << r1 << " v=" << r2 << endl;
- }
- if (Type2 == BRepExtrema_IsOnEdge)
- {
- ParOnEdgeS2(i,r1);
- o << "parameter on the second edge : t=" << r1 << endl;
- }
- if (Type2 == BRepExtrema_IsInFace)
- {
- ParOnFaceS2(i,r1,r2);
- o << "parameters on the second face : u= " << r1 << " v=" << r2 << endl;
- }
-
+ switch (SupportTypeShape1(i))
+ {
+ case BRepExtrema_IsOnEdge:
+ ParOnEdgeS1(i,r1);
+ o << "parameter on the first edge : t= " << r1 << endl;
+ break;
+ case BRepExtrema_IsInFace:
+ ParOnFaceS1(i,r1,r2);
+ o << "parameters on the first face : u= " << r1 << " v=" << r2 << endl;
+ break;
+ }
+ switch (SupportTypeShape2(i))
+ {
+ case BRepExtrema_IsOnEdge:
+ ParOnEdgeS2(i,r1);
+ o << "parameter on the second edge : t=" << r1 << endl;
+ break;
+ case BRepExtrema_IsInFace:
+ ParOnFaceS2(i,r1,r2);
+ o << "parameters on the second face : u= " << r1 << " v=" << r2 << endl;
+ break;
+ }
o<<endl;
}
}
--- /dev/null
+// File generated by CPPExt (Value)
+//
+// Copyright (C) 1991 - 2000 by
+// Matra Datavision SA. All rights reserved.
+//
+// Copyright (C) 2001 - 2004 by
+// Open CASCADE SA. All rights reserved.
+//
+// This file is part of the Open CASCADE Technology software.
+//
+// This software may be distributed and/or modified under the terms and
+// conditions of the Open CASCADE Public License as defined by Open CASCADE SA
+// and appearing in the file LICENSE included in the packaging of this file.
+//
+// This software is distributed on an "AS IS" basis, without warranty of any
+// kind, and Open CASCADE SA hereby disclaims all such warranties,
+// including without limitation, any warranties of merchantability, fitness
+// for a particular purpose or non-infringement. Please see the License for
+// the specific terms and conditions governing rights and limitations under the
+// License.
+
+#ifndef _BRepExtrema_DistShapeShape_HeaderFile
+#define _BRepExtrema_DistShapeShape_HeaderFile
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#endif
+
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+#ifndef _BRepExtrema_SeqOfSolution_HeaderFile
+#include <BRepExtrema_SeqOfSolution.hxx>
+#endif
+#ifndef _BRepExtrema_SolutionElem_HeaderFile
+#include <BRepExtrema_SolutionElem.hxx>
+#endif
+#ifndef _TopoDS_Shape_HeaderFile
+#include <TopoDS_Shape.hxx>
+#endif
+#ifndef _TopTools_IndexedMapOfShape_HeaderFile
+#include <TopTools_IndexedMapOfShape.hxx>
+#endif
+#ifndef _Extrema_ExtFlag_HeaderFile
+#include <Extrema_ExtFlag.hxx>
+#endif
+#ifndef _Extrema_ExtAlgo_HeaderFile
+#include <Extrema_ExtAlgo.hxx>
+#endif
+#ifndef _BRepExtrema_SupportType_HeaderFile
+#include <BRepExtrema_SupportType.hxx>
+#endif
+#ifndef _Standard_OStream_HeaderFile
+#include <Standard_OStream.hxx>
+#endif
+#ifndef _gp_Pnt_HeaderFile
+#include <gp_Pnt.hxx>
+#endif
+class TopoDS_Shape;
+class TopTools_IndexedMapOfShape;
+class Bnd_SeqOfBox;
+
+
+//! This class provides tools to compute minimum distance <br>
+//! between two Shapes (Compound,CompSolid, Solid, Shell, Face, Wire, Edge, Vertex). <br>
+class BRepExtrema_DistShapeShape
+{
+ public:
+
+ void* operator new(size_t,void* anAddress)
+ {
+ return anAddress;
+ }
+ void* operator new(size_t size)
+ {
+ return Standard::Allocate(size);
+ }
+ void operator delete(void *anAddress)
+ {
+ if (anAddress) Standard::Free((Standard_Address&)anAddress);
+ }
+
+ //! create empty tool <br>
+ Standard_EXPORT BRepExtrema_DistShapeShape();
+ //! computation of the minimum distance (value and pair of points) using default deflection <br>
+ //! Default value is Precision::Confusion(). <br>
+ Standard_EXPORT BRepExtrema_DistShapeShape(const TopoDS_Shape& Shape1,const TopoDS_Shape& Shape2,const Extrema_ExtFlag F = Extrema_ExtFlag_MINMAX,const Extrema_ExtAlgo A = Extrema_ExtAlgo_Grad);
+ //! create tool and load both shapes into it <br>
+ Standard_EXPORT BRepExtrema_DistShapeShape(const TopoDS_Shape& Shape1,const TopoDS_Shape& Shape2,const Standard_Real theDeflection,const Extrema_ExtFlag F = Extrema_ExtFlag_MINMAX,const Extrema_ExtAlgo A = Extrema_ExtAlgo_Grad);
+
+ Standard_EXPORT void SetDeflection(const Standard_Real theDeflection)
+ {
+ myEps = theDeflection;
+ }
+ //! load first shape into extrema <br>
+ Standard_EXPORT void LoadS1(const TopoDS_Shape& Shape1);
+ //! load second shape into extrema <br>
+ Standard_EXPORT void LoadS2(const TopoDS_Shape& Shape1);
+ //! computation of the minimum distance (value and <br>
+ //! couple of points). Parameter theDeflection is used <br>
+ //! to specify a maximum deviation of extreme distances <br>
+ //! from the minimum one. <br>
+ //! Returns IsDone status. <br>
+ Standard_EXPORT Standard_Boolean Perform();
+ //! True if the minimum distance is found. <br>
+ Standard_EXPORT Standard_Boolean IsDone() const
+ {
+ return myIsDone;
+ }
+ //! Returns the number of solutions satisfying the minimum distance. <br>
+ Standard_EXPORT Standard_Integer NbSolution() const
+ {
+ return mySolutionsShape1.Length();
+ }
+ //! Returns the value of the minimum distance. <br>
+ Standard_EXPORT Standard_Real Value() const;
+ //! True if one of the shapes is a solid and the other shape <br>
+ //! is completely or partially inside the solid. <br>
+ Standard_EXPORT Standard_Boolean InnerSolution() const
+ {
+ return myInnerSol;
+ }
+ //! Returns the Point corresponding to the <N>th solution on the first Shape <br>
+ Standard_EXPORT const gp_Pnt & PointOnShape1(const Standard_Integer N) const
+ {
+ return mySolutionsShape1.Value(N).Point();
+ }
+ //! Returns the Point corresponding to the <N>th solution on the second Shape <br>
+ Standard_EXPORT const gp_Pnt & PointOnShape2(const Standard_Integer N) const
+ {
+ return mySolutionsShape2.Value(N).Point();
+ }
+ //! gives the type of the support where the Nth solution on the first shape is situated: <br>
+ //! IsVertex => the Nth solution on the first shape is a Vertex <br>
+ //! IsOnEdge => the Nth soluion on the first shape is on a Edge <br>
+ //! IsInFace => the Nth solution on the first shape is inside a face <br>
+ //! the corresponding support is obtained by the method SupportOnShape1 <br>
+ Standard_EXPORT BRepExtrema_SupportType SupportTypeShape1(const Standard_Integer N) const
+ {
+ return mySolutionsShape1.Value(N).SupportKind();
+ }
+ //! gives the type of the support where the Nth solution on the second shape is situated: <br>
+ //! IsVertex => the Nth solution on the second shape is a Vertex <br>
+ //! IsOnEdge => the Nth soluion on the secondt shape is on a Edge <br>
+ //! IsInFace => the Nth solution on the second shape is inside a face <br>
+ //! the corresponding support is obtained by the method SupportOnShape2 <br>
+ Standard_EXPORT BRepExtrema_SupportType SupportTypeShape2(const Standard_Integer N) const
+ {
+ return mySolutionsShape2.Value(N).SupportKind();
+ }
+ //! gives the support where the Nth solution on the first shape is situated. <br>
+ //! This support can be a Vertex, an Edge or a Face. <br>
+ Standard_EXPORT TopoDS_Shape SupportOnShape1(const Standard_Integer N) const;
+ //! gives the support where the Nth solution on the second shape is situated. <br>
+ //! This support can be a Vertex, an Edge or a Face. <br>
+ Standard_EXPORT TopoDS_Shape SupportOnShape2(const Standard_Integer N) const;
+ //! gives the corresponding parameter t if the Nth solution <br>
+ //! is situated on an Egde of the first shape <br>
+ Standard_EXPORT void ParOnEdgeS1(const Standard_Integer N,Standard_Real& t) const;
+ //! gives the corresponding parameter t if the Nth solution <br>
+ //! is situated on an Egde of the first shape <br>
+ Standard_EXPORT void ParOnEdgeS2(const Standard_Integer N,Standard_Real& t) const;
+ //! gives the corresponding parameters (U,V) if the Nth solution <br>
+ //! is situated on an face of the first shape <br>
+ Standard_EXPORT void ParOnFaceS1(const Standard_Integer N,Standard_Real& u,Standard_Real& v) const;
+ //! gives the corresponding parameters (U,V) if the Nth solution <br>
+ //! is situated on an Face of the second shape <br>
+ Standard_EXPORT void ParOnFaceS2(const Standard_Integer N,Standard_Real& u,Standard_Real& v) const;
+ //! Prints on the stream o information on the current state of the object. <br>
+ Standard_EXPORT void Dump(Standard_OStream& o) const;
+
+ Standard_EXPORT void SetFlag(const Extrema_ExtFlag F)
+ {
+ myFlag = F;
+ }
+
+ Standard_EXPORT void SetAlgo(const Extrema_ExtAlgo A)
+ {
+ myAlgo = A;
+ }
+
+private:
+
+ //! computes the minimum distance between two maps of shapes (Face,Edge,Vertex) <br>
+ Standard_EXPORT void DistanceMapMap(const TopTools_IndexedMapOfShape& Map1,const TopTools_IndexedMapOfShape& Map2,const Bnd_SeqOfBox& LBox1,const Bnd_SeqOfBox& LBox2);
+
+ Standard_Real myDistRef;
+ Standard_Real myDistValue;
+ Standard_Boolean myIsDone;
+ BRepExtrema_SeqOfSolution mySolutionsShape1;
+ BRepExtrema_SeqOfSolution mySolutionsShape2;
+ Standard_Boolean myInnerSol;
+ Standard_Real myEps;
+ TopoDS_Shape myShape1;
+ TopoDS_Shape myShape2;
+ TopTools_IndexedMapOfShape myMapV1;
+ TopTools_IndexedMapOfShape myMapV2;
+ TopTools_IndexedMapOfShape myMapE1;
+ TopTools_IndexedMapOfShape myMapE2;
+ TopTools_IndexedMapOfShape myMapF1;
+ TopTools_IndexedMapOfShape myMapF2;
+ Extrema_ExtFlag myFlag;
+ Extrema_ExtAlgo myAlgo;
+};
+
+#endif
-// File: BRepExtrema_DistanceSS.cxx
-// Created: Mon Apr 22 17:03:37 1996
+// File: BRepExtrema_DistanceSS.cxx
+// Created: Mon Apr 22 17:03:37 1996
// Author: Maria PUMBORIOS
-// Author: Herve LOUESSARD
-// <mps@sgi64>
+// Author: Herve LOUESSARD
+// Modified: Sergey ZERCHANINOV
+
+#include <BRepExtrema_DistanceSS.hxx>
-#include <BRepExtrema_DistanceSS.ixx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopExp.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <BRep_Tool.hxx>
#include <BRepExtrema_SupportType.hxx>
-#include <Precision.hxx>
#include <Standard_Real.hxx>
#include <BRepExtrema_SolutionElem.hxx>
#include <BRepExtrema_SeqOfSolution.hxx>
#include <Bnd_Box.hxx>
#include <BRepExtrema_ExtPC.hxx>
#include <BRepExtrema_ExtPF.hxx>
+#include <Extrema_ExtFlag.hxx>
#include <BRepExtrema_ExtCC.hxx>
#include <BRepExtrema_ExtCF.hxx>
#include <BRepExtrema_ExtFF.hxx>
#include <TColgp_Array1OfPnt.hxx>
-
-/*********************************************************************************/
/*********************************************************************************/
//------------------------------------------------------------------------------
// function: TRI_SOLUTION
//------------------------------------------------------------------------------
-void TRI_SOLUTION (const BRepExtrema_SeqOfSolution& SeqSol,
- const gp_Pnt& Pt, Standard_Boolean& inserer )
+static Standard_Boolean TRI_SOLUTION (const BRepExtrema_SeqOfSolution& SeqSol, const gp_Pnt& Pt)
{
- inserer = Standard_True;
- Standard_Integer Nbsol= SeqSol.Length();
- Standard_Integer i;
- Standard_Real dst;
- for (i=1;i<=Nbsol;i++)
- {gp_Pnt P1=SeqSol.Value(i).Point();
- dst=P1.Distance(Pt);
- if (dst<=Precision::Confusion()) inserer=Standard_False;}
+ const Standard_Integer Nbsol = SeqSol.Length();
+ for (Standard_Integer i = 1; i <= Nbsol; i++)
+ {
+ const Standard_Real dst = SeqSol.Value(i).Point().Distance(Pt);
+ if (dst <= Precision::Confusion()) return Standard_False;
+ }
+ return Standard_True;
}
//------------------------------------------------------------------------------
// function: MIN_SOLUTION
//------------------------------------------------------------------------------
-void MIN_SOLUTION (const BRepExtrema_SeqOfSolution& SeqSol1,
- const BRepExtrema_SeqOfSolution& SeqSol2,
- const Standard_Real& DstRef,
- const Standard_Real& Eps,
- BRepExtrema_SeqOfSolution& seqSol1,
- BRepExtrema_SeqOfSolution& seqSol2)
+static void MIN_SOLUTION (const BRepExtrema_SeqOfSolution& SeqSol1,
+ const BRepExtrema_SeqOfSolution& SeqSol2,
+ const Standard_Real DstRef,
+ const Standard_Real Eps,
+ BRepExtrema_SeqOfSolution& seqSol1,
+ BRepExtrema_SeqOfSolution& seqSol2)
{
- Standard_Real dst1;
- Standard_Integer nbSol = SeqSol1.Length();
-
- for (Standard_Integer i = 1; i<=nbSol; i++)
- {
- dst1 = SeqSol1.Value(i).Dist();
-
- if (fabs(dst1 - DstRef) < Eps)
+ const Standard_Integer nbSol = SeqSol1.Length();
+ for (Standard_Integer i = 1; i <= nbSol; i++)
+ {
+ const Standard_Real dst1 = SeqSol1.Value(i).Dist();
+ if (fabs(dst1 - DstRef) < Eps)
{
- seqSol1.Append(SeqSol1.Value(i));
- seqSol2.Append(SeqSol2.Value(i));
+ seqSol1.Append(SeqSol1.Value(i));
+ seqSol2.Append(SeqSol2.Value(i));
}
- }
+ }
}
-
//------------------------------------------------------------------------------
// function: TRIM_INFINIT_EDGE
//------------------------------------------------------------------------------
-void TRIM_INFINIT_EDGE(const TopoDS_Edge& S1,
- const TopoDS_Edge& S2,
- TopoDS_Edge& aResEdge,
- Standard_Boolean& bIsTrim1,
- Standard_Boolean& bIsTrim2)
+static void TRIM_INFINIT_EDGE(const TopoDS_Edge& S1, const TopoDS_Edge& S2, TopoDS_Edge& aResEdge,
+ Standard_Boolean& bIsTrim1, Standard_Boolean& bIsTrim2)
{
- if ( BRep_Tool::Degenerated(S1) ||
- BRep_Tool::Degenerated(S2) )
+ if ( BRep_Tool::Degenerated(S1) || BRep_Tool::Degenerated(S2) )
return;
aResEdge = S2;
Standard_Real aFirst1, aLast1, aFirst2, aLast2;
- Handle(Geom_Curve) pCurv;
Handle(Geom_Curve) pCurv1 = BRep_Tool::Curve(S1, aFirst1, aLast1);
Handle(Geom_Curve) pCurv2 = BRep_Tool::Curve(S2, aFirst2, aLast2);
- Standard_Real Umin, Umax;
- Standard_Boolean bUmin, bUmax;
- bUmin = bUmax = Standard_False;
-
if (Precision::IsInfinite(aFirst1) &&
Precision::IsInfinite(aLast1) &&
Precision::IsInfinite(aFirst2) &&
Precision::IsInfinite(aLast2))
return;
-
- if ( !pCurv1.IsNull() && (Precision::IsInfinite(aFirst1) ||
- Precision::IsInfinite(aLast1)) )
+ Standard_Real Umin, Umax;
+ Standard_Boolean bUmin, bUmax;
+ bUmin = bUmax = Standard_False;
+
+ Handle(Geom_Curve) pCurv;
+ if ( !pCurv1.IsNull() && (Precision::IsInfinite(aFirst1) || Precision::IsInfinite(aLast1)) )
+ {
+ pCurv = pCurv1;
+ bIsTrim1 = Standard_True;
+ if (!Precision::IsInfinite(aFirst1))
{
- pCurv = pCurv1;
- bIsTrim1 = Standard_True;
- if (!Precision::IsInfinite(aFirst1))
- {
- bUmin = Standard_True;
- Umin = aFirst1;
- }
- else if (!Precision::IsInfinite(aLast1))
- {
- bUmax = Standard_True;
- Umax = aLast1;
- }
+ bUmin = Standard_True;
+ Umin = aFirst1;
}
- else if ( !pCurv2.IsNull() && (Precision::IsInfinite(aFirst2) ||
- Precision::IsInfinite(aLast2)) )
+ else if (!Precision::IsInfinite(aLast1))
{
- pCurv = pCurv2;
- bIsTrim2 = Standard_True;
- if (!Precision::IsInfinite(aFirst2))
- {
- bUmin = Standard_True;
- Umin = aFirst2;
- }
- else if (!Precision::IsInfinite(aLast2))
- {
- bUmax = Standard_True;
- Umax = aLast2;
- }
+ bUmax = Standard_True;
+ Umax = aLast1;
}
- if (bIsTrim1 || bIsTrim2)
+ }
+ else if ( !pCurv2.IsNull() && (Precision::IsInfinite(aFirst2) || Precision::IsInfinite(aLast2)) )
+ {
+ pCurv = pCurv2;
+ bIsTrim2 = Standard_True;
+ if (!Precision::IsInfinite(aFirst2))
{
- Bnd_Box aEdgeBox;
- if (bIsTrim1)
- BRepBndLib::Add(S2, aEdgeBox);
- if (bIsTrim2)
- BRepBndLib::Add(S1, aEdgeBox);
- Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
- aEdgeBox.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
-
-
- TColStd_Array1OfReal arrU(1, 8);
- TColgp_Array1OfPnt arrPnt(1, 8);
-
- gp_Pnt aPnt1(Xmin, Ymin, Zmin);
- arrPnt.SetValue(1, aPnt1);
- gp_Pnt aPnt2(Xmin, Ymax, Zmin);
- arrPnt.SetValue(2, aPnt2);
- gp_Pnt aPnt3(Xmin, Ymax, Zmax);
- arrPnt.SetValue(3, aPnt3);
- gp_Pnt aPnt4(Xmin, Ymin, Zmax);
- arrPnt.SetValue(4, aPnt4);
- gp_Pnt aPnt5(Xmax, Ymax, Zmin);
- arrPnt.SetValue(5, aPnt5);
- gp_Pnt aPnt6(Xmax, Ymax, Zmax);
- arrPnt.SetValue(6, aPnt6);
- gp_Pnt aPnt7(Xmax, Ymin, Zmax);
- arrPnt.SetValue(7, aPnt7);
- gp_Pnt aPnt8(Xmax, Ymin, Zmin);
- arrPnt.SetValue(8, aPnt8);
-
- Standard_Real U;
- Standard_Integer i = 1;
-
- GeomAPI_ProjectPointOnCurve aProj(aPnt1, pCurv);
-
- for (i = 1; i <= arrPnt.Length(); i++)
- {
- gp_Pnt aPnt = arrPnt.Value(i);
- aProj.Perform(aPnt);
- U = aProj.LowerDistanceParameter();
- arrU.SetValue(i, U);
- }
-
- Standard_Real aU;
-
- if (!bUmin)
- Umin = arrU.Value(1);
+ bUmin = Standard_True;
+ Umin = aFirst2;
+ }
+ else if (!Precision::IsInfinite(aLast2))
+ {
+ bUmax = Standard_True;
+ Umax = aLast2;
+ }
+ }
+ if (bIsTrim1 || bIsTrim2)
+ {
+ Bnd_Box aEdgeBox;
+ if (bIsTrim1)
+ BRepBndLib::Add(S2, aEdgeBox);
+ if (bIsTrim2)
+ BRepBndLib::Add(S1, aEdgeBox);
+ Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
+ aEdgeBox.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
+
+ const gp_Pnt aPnt0(Xmin, Ymin, Zmin);
+ const gp_Pnt aPnt1(Xmin, Ymax, Zmin);
+ const gp_Pnt aPnt2(Xmin, Ymax, Zmax);
+ const gp_Pnt aPnt3(Xmin, Ymin, Zmax);
+ const gp_Pnt aPnt4(Xmax, Ymax, Zmin);
+ const gp_Pnt aPnt5(Xmax, Ymax, Zmax);
+ const gp_Pnt aPnt6(Xmax, Ymin, Zmax);
+ const gp_Pnt aPnt7(Xmax, Ymin, Zmin);
+
+ Standard_Real arrU[8];
+ GeomAPI_ProjectPointOnCurve aProj(aPnt0, pCurv);
+ /*szv:aProj.Perform(aPnt0);*/ arrU[0] = aProj.LowerDistanceParameter();
+ aProj.Perform(aPnt1); arrU[1] = aProj.LowerDistanceParameter();
+ aProj.Perform(aPnt2); arrU[2] = aProj.LowerDistanceParameter();
+ aProj.Perform(aPnt3); arrU[3] = aProj.LowerDistanceParameter();
+ aProj.Perform(aPnt4); arrU[4] = aProj.LowerDistanceParameter();
+ aProj.Perform(aPnt5); arrU[5] = aProj.LowerDistanceParameter();
+ aProj.Perform(aPnt6); arrU[6] = aProj.LowerDistanceParameter();
+ aProj.Perform(aPnt7); arrU[7] = aProj.LowerDistanceParameter();
+
+ if (!bUmin)
+ Umin = arrU[0];
- if (!bUmax)
- Umax = arrU.Value(1);
+ if (!bUmax)
+ Umax = arrU[0];
- for(i = 1; i <= arrU.Length(); i++)
+ Standard_Integer i = 0;
+ while (i < 8)
{
- aU = arrU.Value(i);
+ const Standard_Real aU = arrU[i++];
if (aU < Umin)
Umin = aU;
else if (aU > Umax)
Umax = aU;
-
- }
- GeomAdaptor_Curve aGAC(pCurv);
- Standard_Real tol = Precision::Confusion();
- if (bIsTrim1)
- tol = BRep_Tool::Tolerance(S1);
- else if (bIsTrim2)
- tol = BRep_Tool::Tolerance(S2);
-
- Standard_Real EpsU = aGAC.Resolution(3*tol);
- if (fabs(Umin - Umax) < EpsU)
- {
- Umin = Umin - EpsU;
- Umax = Umax + EpsU;
}
+ Standard_Real tol = Precision::Confusion();
+ if (bIsTrim1)
+ tol = BRep_Tool::Tolerance(S1);
+ else if (bIsTrim2)
+ tol = BRep_Tool::Tolerance(S2);
- Handle(Geom_Curve) result = new Geom_TrimmedCurve(pCurv, Umin, Umax);
- aResEdge = BRepBuilderAPI_MakeEdge(result);
+ const Standard_Real EpsU = GeomAdaptor_Curve(pCurv).Resolution(3.*tol);
+ if (fabs(Umin - Umax) < EpsU)
+ {
+ Umin -= EpsU;
+ Umax += EpsU;
}
+
+ Handle(Geom_Curve) result = new Geom_TrimmedCurve(pCurv, Umin, Umax);
+ aResEdge = BRepBuilderAPI_MakeEdge(result);
+ }
}
//------------------------------------------------------------------------------
// function: TRIM_INFINIT_FACE
//------------------------------------------------------------------------------
-void TRIM_INFINIT_FACE(const TopoDS_Shape& S1,
- const TopoDS_Shape& S2,
- TopoDS_Face& aResFace,
- Standard_Boolean& bIsInfinit)
+static void TRIM_INFINIT_FACE(const TopoDS_Shape& S1, const TopoDS_Shape& S2,
+ TopoDS_Face& aResFace, Standard_Boolean& bIsInfinit)
{
bIsInfinit = Standard_False;
- TopAbs_ShapeEnum Type1, Type2;
- Type1 = S1.ShapeType();
- Type2 = S2.ShapeType();
+ TopAbs_ShapeEnum Type1 = S1.ShapeType();
+ TopAbs_ShapeEnum Type2 = S2.ShapeType();
TopoDS_Edge aE;
TopoDS_Face aF;
if (Type1 == TopAbs_EDGE && Type2 == TopAbs_FACE)
- {
- aE = TopoDS::Edge(S1);
- if ( BRep_Tool::Degenerated(aE) )
- return;
- aF = TopoDS::Face(S2);
- }
+ {
+ aE = TopoDS::Edge(S1);
+ if ( BRep_Tool::Degenerated(aE) )
+ return;
+ aF = TopoDS::Face(S2);
+ }
else if (Type2 == TopAbs_EDGE && Type1 == TopAbs_FACE)
- {
- aE = TopoDS::Edge(S2);
- if ( BRep_Tool::Degenerated(aE) )
- return;
- aF = TopoDS::Face(S1);
- }
- else
- {
- bIsInfinit = Standard_False;
+ {
+ aE = TopoDS::Edge(S2);
+ if ( BRep_Tool::Degenerated(aE) )
return;
- }
- Standard_Real Umin, Umax, Vmin, Vmax;
+ aF = TopoDS::Face(S1);
+ }
+ else
+ {
+ bIsInfinit = Standard_False;
+ return;
+ }
- Standard_Boolean bIsTrim = Standard_False;
-
-
aResFace = aF;
Handle(Geom_Surface) pSurf = BRep_Tool::Surface(aF);
- Standard_Real U1, V1, U2, V2;
-
- Standard_Boolean bRestrict = BRep_Tool::NaturalRestriction(aF);
+ const Standard_Boolean bRestrict = BRep_Tool::NaturalRestriction(aF);
+ Standard_Real U1, V1, U2, V2;
+ Standard_Real Umin, Umax, Vmin, Vmax;
Standard_Boolean bUmin, bUmax, bVmin, bVmax;
bUmin = bUmax = bVmin = bVmax = Standard_False;
+ Standard_Boolean bIsTrim = Standard_False;
if (bRestrict)
+ {
+ pSurf->Bounds(U1, U2, V1, V2);
+ if (Precision::IsInfinite(U1))
+ bIsTrim = Standard_True;
+ else
{
- pSurf->Bounds(U1, U2, V1, V2);
- if (Precision::IsInfinite(U1))
- bIsTrim = Standard_True;
- else
- {
- Umin = U1;
- bUmin = Standard_True;
- }
+ Umin = U1;
+ bUmin = Standard_True;
+ }
- if (Precision::IsInfinite(U2))
- bIsTrim = Standard_True;
- else
- {
- Umax = U2;
- bUmax = Standard_True;
- }
+ if (Precision::IsInfinite(U2))
+ bIsTrim = Standard_True;
+ else
+ {
+ Umax = U2;
+ bUmax = Standard_True;
+ }
- if (Precision::IsInfinite(V1))
- bIsTrim = Standard_True;
- else
+ if (Precision::IsInfinite(V1))
+ bIsTrim = Standard_True;
+ else
{
- Vmin = V1;
- bVmin = Standard_True;
+ Vmin = V1;
+ bVmin = Standard_True;
}
- if (Precision::IsInfinite(V2))
- bIsTrim = Standard_True;
- else
+ if (Precision::IsInfinite(V2))
+ bIsTrim = Standard_True;
+ else
{
- Vmax = V2;
- bVmax = Standard_True;
- }
+ Vmax = V2;
+ bVmax = Standard_True;
}
+ }
else
- {
- BRepTools::UVBounds(aF, U1, U2, V1, V2);
- if (Precision::IsInfinite(U1) &&
- Precision::IsInfinite(U2) &&
- Precision::IsInfinite(V1) &&
- Precision::IsInfinite(V2))
- bIsTrim = Standard_True;
- }
+ {
+ BRepTools::UVBounds(aF, U1, U2, V1, V2);
+ if (Precision::IsInfinite(U1) &&
+ Precision::IsInfinite(U2) &&
+ Precision::IsInfinite(V1) &&
+ Precision::IsInfinite(V2))
+ bIsTrim = Standard_True;
+ }
if (bIsTrim)
- {
- Bnd_Box aEdgeBox;
- BRepBndLib::Add(aE, aEdgeBox);
-
- if(aEdgeBox.IsWhole())
- return;
-
- Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
- aEdgeBox.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
-
- TColStd_Array1OfReal arrU(1, 8);
- TColStd_Array1OfReal arrV(1, 8);
- TColgp_Array1OfPnt arrPnt(1, 8);
-
- gp_Pnt aPnt1(Xmin, Ymin, Zmin);
- arrPnt.SetValue(1, aPnt1);
- gp_Pnt aPnt2(Xmin, Ymax, Zmin);
- arrPnt.SetValue(2, aPnt2);
- gp_Pnt aPnt3(Xmin, Ymax, Zmax);
- arrPnt.SetValue(3, aPnt3);
- gp_Pnt aPnt4(Xmin, Ymin, Zmax);
- arrPnt.SetValue(4, aPnt4);
- gp_Pnt aPnt5(Xmax, Ymax, Zmin);
- arrPnt.SetValue(5, aPnt5);
- gp_Pnt aPnt6(Xmax, Ymax, Zmax);
- arrPnt.SetValue(6, aPnt6);
- gp_Pnt aPnt7(Xmax, Ymin, Zmax);
- arrPnt.SetValue(7, aPnt7);
- gp_Pnt aPnt8(Xmax, Ymin, Zmin);
- arrPnt.SetValue(8, aPnt8);
-
- Standard_Real U, V;
- Standard_Integer i;
- GeomAPI_ProjectPointOnSurf aProj(aPnt1, pSurf);
- for (i = 1; i <= arrPnt.Length(); i++)
- {
- gp_Pnt aPnt = arrPnt.Value(i);
- aProj.Perform(aPnt);
- if (aProj.IsDone())
- {
- aProj.LowerDistanceParameters(U, V);
- arrU.SetValue(i, U);
- arrV.SetValue(i, V);
-
- }
- }
+ {
+ Bnd_Box aEdgeBox;
+ BRepBndLib::Add(aE, aEdgeBox);
+
+ if(aEdgeBox.IsWhole())
+ return;
- Standard_Real aU, aV;
- if (!bUmin)
- Umin = arrU.Value(1);
- if (!bUmax)
- Umax = arrU.Value(1);
- if (!bVmin)
- Vmin = arrV.Value(1);
- if (!bVmax)
- Vmax = arrV.Value(1);
-
- for(i = 1; i <= arrU.Length(); i++)
+ Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
+ aEdgeBox.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
+
+ const gp_Pnt aPnt0(Xmin, Ymin, Zmin);
+ const gp_Pnt aPnt1(Xmin, Ymax, Zmin);
+ const gp_Pnt aPnt2(Xmin, Ymax, Zmax);
+ const gp_Pnt aPnt3(Xmin, Ymin, Zmax);
+ const gp_Pnt aPnt4(Xmax, Ymax, Zmin);
+ const gp_Pnt aPnt5(Xmax, Ymax, Zmax);
+ const gp_Pnt aPnt6(Xmax, Ymin, Zmax);
+ const gp_Pnt aPnt7(Xmax, Ymin, Zmin);
+
+ Standard_Real arrU[8], arrV[8];
+ GeomAPI_ProjectPointOnSurf aProj(aPnt0, pSurf);
+ /*szv:aProj.Perform(aPnt0);*/ if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[0],arrV[0]);
+ aProj.Perform(aPnt1); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[1],arrV[1]);
+ aProj.Perform(aPnt2); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[2],arrV[2]);
+ aProj.Perform(aPnt3); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[3],arrV[3]);
+ aProj.Perform(aPnt4); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[4],arrV[4]);
+ aProj.Perform(aPnt5); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[5],arrV[5]);
+ aProj.Perform(aPnt6); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[6],arrV[6]);
+ aProj.Perform(aPnt7); if (aProj.IsDone()) aProj.LowerDistanceParameters(arrU[7],arrV[7]);
+
+ if (!bUmin)
+ Umin = arrU[0];
+ if (!bUmax)
+ Umax = arrU[0];
+ if (!bVmin)
+ Vmin = arrV[0];
+ if (!bVmax)
+ Vmax = arrV[0];
+
+ Standard_Integer i = 0;
+ while (i < 8)
{
- aU = arrU.Value(i);
+ const Standard_Real aU = arrU[i];
if (aU < Umin)
Umin = aU;
else if (aU > Umax)
Umax = aU;
- aV = arrV.Value(i);
+ const Standard_Real aV = arrV[i];
if (aV < Vmin)
Vmin = aV;
else if (aV > Vmax)
Vmax = aV;
}
- GeomAdaptor_Surface aGAS(pSurf);
- Standard_Real tol = BRep_Tool::Tolerance(aF);
- Standard_Real EpsU = aGAS.UResolution(3*tol);
- Standard_Real EpsV = aGAS.VResolution(3*tol);
- if (fabs(Umin - Umax) < EpsU)
- {
- Umin = Umin - EpsU;
- Umax = Umax + EpsU;
- }
+ GeomAdaptor_Surface aGAS(pSurf);
+ const Standard_Real tol = BRep_Tool::Tolerance(aF);
- if (fabs(Vmin - Vmax) < EpsV)
- {
- Vmin = Vmin - EpsV;
- Vmax = Vmax + EpsV;
- }
+ const Standard_Real EpsU = aGAS.UResolution(3.*tol);
+ if (fabs(Umin - Umax) < EpsU)
+ {
+ Umin -= EpsU;
+ Umax += EpsU;
+ }
- Handle(Geom_Surface) result = new Geom_RectangularTrimmedSurface(pSurf, Umin, Umax, Vmin, Vmax);
- aResFace = BRepBuilderAPI_MakeFace(result);
-
- bIsInfinit = Standard_True;
+ const Standard_Real EpsV = aGAS.VResolution(3.*tol);
+ if (fabs(Vmin - Vmax) < EpsV)
+ {
+ Vmin -= EpsV;
+ Vmax += EpsV;
}
+
+ Handle(Geom_Surface) result = new Geom_RectangularTrimmedSurface(pSurf, Umin, Umax, Vmin, Vmax);
+ aResFace = BRepBuilderAPI_MakeFace(result);
+
+ bIsInfinit = Standard_True;
+ }
else
bIsInfinit = Standard_False;
}
//------------------------------------------------------------------------------
// static function: PERFORM_C0
//------------------------------------------------------------------------------
-static void PERFORM_C0(TopoDS_Edge S1,
- TopoDS_Edge S2,
- BRepExtrema_SeqOfSolution& SeqSol1,
- BRepExtrema_SeqOfSolution& SeqSol2,
- Standard_Real DstRef,
- Standard_Real& mDstRef,
- const Standard_Real& Eps)
+static void PERFORM_C0(const TopoDS_Edge &S1, const TopoDS_Edge &S2,
+ BRepExtrema_SeqOfSolution& SeqSol1,
+ BRepExtrema_SeqOfSolution& SeqSol2,
+ const Standard_Real DstRef,
+ Standard_Real& mDstRef,
+ const Standard_Real Eps)
{
-
- if ( BRep_Tool::Degenerated(S1) ||
- BRep_Tool::Degenerated(S2) )
+ if ( BRep_Tool::Degenerated(S1) || BRep_Tool::Degenerated(S2) )
return;
+
Standard_Integer iE;
-// TopoDS_Edge E, Eover;
for (iE = 0; iE < 2; iE++)
- {
- TopoDS_Edge E, Eother;
- if (iE == 0)
+ {
+ TopoDS_Edge E, Eother;
+ if (iE == 0)
{
E = S1;
Eother = S2;
}
- else
+ else
{
E = S2;
Eother = S1;
}
- Standard_Real aFirst, aLast, epsP = Precision::PConfusion(), Udeb, Ufin;
- Handle(Geom_Curve) pCurv = BRep_Tool::Curve(E, aFirst, aLast);
-
- Standard_Real aFOther, aLOther;
- Handle(Geom_Curve) pCurvOther = BRep_Tool::Curve(Eother, aFOther, aLOther);
-
+ Standard_Real aFirst, aLast;
+ Handle(Geom_Curve) pCurv = BRep_Tool::Curve(E, aFirst, aLast);
- GeomAbs_Shape s = pCurv->Continuity();
- if (s == GeomAbs_C0)
+ Standard_Real aFOther, aLOther;
+ Handle(Geom_Curve) pCurvOther = BRep_Tool::Curve(Eother, aFOther, aLOther);
+
+ if (pCurv->Continuity() == GeomAbs_C0)
{
- GeomAdaptor_Curve aAdaptorCurve(pCurv, aFirst, aLast);
- Standard_Integer nbIntervals = aAdaptorCurve.NbIntervals(GeomAbs_C1);
-
- TColStd_Array1OfReal arrInter(1,1+nbIntervals);
- aAdaptorCurve.Intervals(arrInter, GeomAbs_C1);
-
- GeomAdaptor_Curve aAdaptorCurveOther(pCurvOther, aFOther, aLOther);
- Standard_Integer nbIntervalsOther = aAdaptorCurveOther.NbIntervals(GeomAbs_C1);
- TColStd_Array1OfReal arrInterOther(1,1+nbIntervalsOther);
- aAdaptorCurveOther.Intervals(arrInterOther, GeomAbs_C1);
-
- Standard_Real Dstmin, Dst;
- gp_Pnt P1,Pt;
- gp_Pnt2d PUV;
- Standard_Boolean notavertex, inserer;
- Standard_Integer i, ii;
- BRepClass_FaceClassifier classifier;
- Standard_Real aParameter;
- for (i=1; i<=arrInter.Length(); i++)
- {
- gp_Pnt aPnt = aAdaptorCurve.Value(arrInter(i));
-
- TopoDS_Vertex V1 = BRepBuilderAPI_MakeVertex(aPnt);
-
- aParameter = arrInter(i);
- BRepExtrema_ExtPC Ext(V1,Eother);
- if ( (Ext.IsDone()) && (Ext.NbExt() > 0) )
- {
- Standard_Integer NbExtrema=Ext.NbExt();
-
- // Recherche de la distance minimum dstmin
- Dstmin=sqrt (Ext.SquareDistance(1));
- for (ii=2;ii<=NbExtrema;ii++)
- {
- Dst=sqrt (Ext.SquareDistance(ii));
- if (Dst<Dstmin)
- Dstmin=Dst;
- }
-
- if ((Dstmin < DstRef -Eps) || (fabs(Dstmin-DstRef)<Eps))
- for (ii=1;ii<=NbExtrema;ii++)
- { if (fabs(Dstmin-sqrt(Ext.SquareDistance(ii)))<Eps)
- {Pt=Ext.Point(ii);
- TRI_SOLUTION(SeqSol2,Pt,inserer);
- if (inserer)
- {
- // on regarde si le parametre ne correspondont pas a un vertex
- Standard_Real t =Ext.Parameter(ii) ;
- notavertex=Standard_True;
- BRep_Tool::Range(Eother,Udeb,Ufin);
- if ((fabs(t-Udeb)<epsP)||(fabs(t-Ufin)<=epsP )) notavertex=Standard_False;
- if (notavertex)
- {
- // Modified by Sergey KHROMOV - Tue Mar 6 12:28:51 2001 Begin
- if (mDstRef > Dstmin)
- mDstRef=Dstmin;
- // Modified by Sergey KHROMOV - Tue Mar 6 12:28:54 2001 End
- //myModif=Standard_True;
- P1=BRep_Tool::Pnt(V1);
- BRepExtrema_SolutionElem Sol1 (Dstmin,P1,BRepExtrema_IsOnEdge,E, aParameter);
- BRepExtrema_SolutionElem Sol2 (Dstmin,Pt,BRepExtrema_IsOnEdge,Eother,t);
- SeqSol1.Append(iE == 0 ? Sol1 : Sol2);
- SeqSol2.Append(iE == 0 ? Sol2 : Sol1);
- }
- }
- }
- }
-
-
- }
- Standard_Real aParameterOther;
- for (Standard_Integer i2 = 1; i2<=arrInterOther.Length(); i2++)
- {
- gp_Pnt aPntOther = aAdaptorCurveOther.Value(arrInterOther(i2));
- Dst=aPnt.Distance(aPntOther);
- aParameterOther = arrInterOther(i2);
- if( (Dst< DstRef - Eps ) || (fabs(Dst-DstRef)< Eps ))
- {
- if (mDstRef > Dst)
- mDstRef=Dst;
-
- BRepExtrema_SolutionElem Sol1 (Dst,aPnt,BRepExtrema_IsOnEdge,E, aParameter);
- BRepExtrema_SolutionElem Sol2 (Dst,aPntOther, BRepExtrema_IsOnEdge,Eother, aParameterOther);
- SeqSol1.Append(iE == 0 ? Sol1 : Sol2);
- SeqSol2.Append(iE == 0 ? Sol2 : Sol1);
- }
-
- }
- }
-
-
- }
- }
-}
+ const Standard_Real epsP = Precision::PConfusion();
-/*********************************************************************************/
+ GeomAdaptor_Curve aAdaptorCurve(pCurv, aFirst, aLast);
+ const Standard_Integer nbIntervals = aAdaptorCurve.NbIntervals(GeomAbs_C1);
-BRepExtrema_DistanceSS::BRepExtrema_DistanceSS(const TopoDS_Shape& S1,
- const TopoDS_Shape& S2,
- const Bnd_Box& B1,
- const Bnd_Box& B2,
- const Standard_Real DstRef)
+ TColStd_Array1OfReal arrInter(1,1+nbIntervals);
+ aAdaptorCurve.Intervals(arrInter, GeomAbs_C1);
-{
- myEps = Precision::Confusion();
- Perform(S1, S2, B1, B2, DstRef);
-}
+ GeomAdaptor_Curve aAdaptorCurveOther(pCurvOther, aFOther, aLOther);
+ const Standard_Integer nbIntervalsOther = aAdaptorCurveOther.NbIntervals(GeomAbs_C1);
+ TColStd_Array1OfReal arrInterOther(1,1+nbIntervalsOther);
+ aAdaptorCurveOther.Intervals(arrInterOther, GeomAbs_C1);
-/*********************************************************************************/
+ Standard_Real Udeb,Ufin;
+ BRep_Tool::Range(Eother,Udeb,Ufin);
-BRepExtrema_DistanceSS::BRepExtrema_DistanceSS(const TopoDS_Shape& S1,
- const TopoDS_Shape& S2,
- const Bnd_Box& B1,
- const Bnd_Box& B2,
- const Standard_Real DstRef,
- const Standard_Real theDeflection)
+ gp_Pnt P1,Pt;
+ Standard_Integer i, ii;
+ BRepClass_FaceClassifier classifier;
+ for (i = 1; i <= arrInter.Length(); i++)
+ {
+ const Standard_Real aParameter = arrInter(i);
+ const gp_Pnt aPnt = aAdaptorCurve.Value(aParameter);
+ const TopoDS_Vertex V1 = BRepBuilderAPI_MakeVertex(aPnt);
-{
- myEps = theDeflection;
- Perform(S1, S2, B1, B2, DstRef);
+ BRepExtrema_ExtPC Ext(V1,Eother);
+ const Standard_Integer NbExtrema = Ext.IsDone()? Ext.NbExt() : 0;
+ if ( NbExtrema > 0 )
+ {
+ // Search minimum distance dstmin
+ Standard_Real Dstmin = Ext.SquareDistance(1);
+ for (ii = 2; ii <= NbExtrema; ii++)
+ {
+ const Standard_Real sDst = Ext.SquareDistance(ii);
+ if (sDst<Dstmin)
+ Dstmin=sDst;
+ }
+ Dstmin = sqrt(Dstmin);
+
+ if ((Dstmin < DstRef - Eps) || (fabs(Dstmin-DstRef) < Eps))
+ for (ii = 1; ii <= NbExtrema; ii++)
+ {
+ if (fabs(Dstmin-sqrt(Ext.SquareDistance(ii)))<Eps)
+ {
+ Pt=Ext.Point(ii);
+ if (TRI_SOLUTION(SeqSol2,Pt))
+ {
+ // Check if the parameter does not correspond to a vertex
+ const Standard_Real t = Ext.Parameter(ii);
+ if ((fabs(t-Udeb)>=epsP)&&(fabs(t-Ufin)>epsP))
+ {
+ if (mDstRef > Dstmin)
+ mDstRef=Dstmin;
+ const BRepExtrema_SolutionElem Sol1(Dstmin,aPnt,BRepExtrema_IsOnEdge,E,aParameter);
+ const BRepExtrema_SolutionElem Sol2(Dstmin,Pt,BRepExtrema_IsOnEdge,Eother,t);
+ SeqSol1.Append(iE == 0 ? Sol1 : Sol2);
+ SeqSol2.Append(iE == 0 ? Sol2 : Sol1);
+ }
+ }
+ }
+ }
+ }
+ for (Standard_Integer i2 = 1; i2<=arrInterOther.Length(); i2++)
+ {
+ const Standard_Real aParameterOther = arrInterOther(i2);
+ const gp_Pnt aPntOther = aAdaptorCurveOther.Value(aParameterOther);
+ const Standard_Real Dst = aPnt.Distance(aPntOther);
+ if ((Dst < DstRef - Eps) || (fabs(Dst-DstRef) < Eps))
+ {
+ if (mDstRef > Dst)
+ mDstRef=Dst;
+ const BRepExtrema_SolutionElem Sol1(Dst,aPnt,BRepExtrema_IsOnEdge,E,aParameter);
+ const BRepExtrema_SolutionElem Sol2(Dst,aPntOther,BRepExtrema_IsOnEdge,Eother,aParameterOther);
+ SeqSol1.Append(iE == 0 ? Sol1 : Sol2);
+ SeqSol2.Append(iE == 0 ? Sol2 : Sol1);
+ }
+ }
+ }
+ }
+ }
}
/*********************************************************************************/
-void BRepExtrema_DistanceSS::Perform(const TopoDS_Shape& S1,
- const TopoDS_Shape& S2,
- const Bnd_Box& B1,
- const Bnd_Box& B2,
- const Standard_Real DstRef)
-
+void BRepExtrema_DistanceSS::Perform(const TopoDS_Shape& S1, const TopoDS_Shape& S2,
+ const Bnd_Box& B1, const Bnd_Box& B2)
{
-TopAbs_ShapeEnum Type1, Type2;
- Type1 = S1.ShapeType();
- Type2 = S2.ShapeType();
-// Modified by Sergey KHROMOV - Tue Mar 6 12:55:05 2001 Begin
- myDstRef = DstRef;
-// Modified by Sergey KHROMOV - Tue Mar 6 12:55:05 2001 End
- TopoDS_Face aTrimFace;
- TopoDS_Edge aTrimEdge;
- Standard_Boolean bIsInfinit;
- switch ( Type1)
- { case TopAbs_VERTEX :
- switch (Type2)
- { case TopAbs_VERTEX : { TopoDS_Vertex V1 = TopoDS::Vertex(S1);
- TopoDS_Vertex V2 = TopoDS::Vertex(S2);
- Perform ( V1 , V2, B1, B2,DstRef );}
- break;
- case TopAbs_EDGE : { TopoDS_Vertex V1 = TopoDS::Vertex(S1);
- TopoDS_Edge V2 = TopoDS::Edge(S2);
- Perform ( V1 , V2, B1, B2,DstRef );}
- break;
- case TopAbs_FACE : { TopoDS_Vertex V1 = TopoDS::Vertex(S1);
- TopoDS_Face V2 = TopoDS::Face(S2);
- Perform ( V1 , V2, B1, B2,DstRef );}
- break;
- default :{}
- }break;
-
- case TopAbs_EDGE :
- switch (Type2)
- { case TopAbs_VERTEX : { TopoDS_Edge V1 = TopoDS::Edge(S1);
- TopoDS_Vertex V2 = TopoDS::Vertex(S2);
- Perform ( V1 , V2, B1, B2,DstRef );}
- break;
- case TopAbs_EDGE : { TopoDS_Edge V1 = TopoDS::Edge(S1);
- TopoDS_Edge V2 = TopoDS::Edge(S2);
- Standard_Boolean bIsTrim1 = Standard_False;
- Standard_Boolean bIsTrim2 = Standard_False;
- TRIM_INFINIT_EDGE(V1, V2, aTrimEdge, bIsTrim1, bIsTrim2);
- if (bIsTrim1)
- V1 = aTrimEdge;
- if (bIsTrim2)
- V2 = aTrimEdge;
- Perform ( V1 , V2, B1, B2,DstRef );}
- break;
- case TopAbs_FACE : { TopoDS_Edge V1 = TopoDS::Edge(S1);
- TopoDS_Face V2 = TopoDS::Face(S2);
- TRIM_INFINIT_FACE(V1, V2, aTrimFace, bIsInfinit);
- if (bIsInfinit)
- V2 = aTrimFace;
- Perform ( V1 , V2, B1, B2,DstRef );}
- break;
- default :{} }break;
-
- case TopAbs_FACE :
- switch (Type2)
- { case TopAbs_VERTEX : { TopoDS_Face V1 = TopoDS::Face(S1);
- TopoDS_Vertex V2 = TopoDS::Vertex(S2);
- Perform ( V1 , V2, B1, B2,DstRef);}
- break;
- case TopAbs_EDGE : { TopoDS_Face V1 = TopoDS::Face(S1);
- TopoDS_Edge V2 = TopoDS::Edge(S2);
- TRIM_INFINIT_FACE(V1, V2, aTrimFace, bIsInfinit);
- if (bIsInfinit)
- V1 = aTrimFace;
- Perform ( V1 , V2, B1, B2,DstRef );}
- break;
- case TopAbs_FACE : { TopoDS_Face V1 = TopoDS::Face(S1);
- TopoDS_Face V2 = TopoDS::Face(S2);
- Perform( V1 , V2, B1, B2,DstRef);}
- break;
- default :{}
- }break;
- default :{}
- }
-}
-
-/*********************************************************************************/
+ SeqSolShape1.Clear();
+ SeqSolShape2.Clear();
+ myModif=Standard_False;
-void BRepExtrema_DistanceSS::Perform(const TopoDS_Vertex& S1, const TopoDS_Vertex& S2,
- const Bnd_Box& ,
-// const Bnd_Box& B2,
- const Bnd_Box& ,
- const Standard_Real DstRef)
-{
- gp_Pnt P1,P2;
- Standard_Real Dst;
- P1= BRep_Tool::Pnt(S1);
- P2= BRep_Tool::Pnt(S2);
- Dst=P1.Distance(P2);
- SeqSolShape1.Clear();
- SeqSolShape2.Clear();
- myModif=Standard_False;
-
- if( (Dst< DstRef -myEps ) || (fabs(Dst-DstRef)< myEps ))
- {
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:51 2001 Begin
- if (myDstRef > Dst)
- myDstRef=Dst;
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:54 2001 End
- myModif=Standard_True;
- BRepExtrema_SolutionElem Sol1 (Dst,P1,BRepExtrema_IsVertex,S1);
- BRepExtrema_SolutionElem Sol2 (Dst,P2, BRepExtrema_IsVertex,S2);
- SeqSolShape1.Append(Sol1);
- SeqSolShape2.Append(Sol2);
- }
-}
+ switch (S1.ShapeType())
+ {
+ case TopAbs_VERTEX :
+ {
+ TopoDS_Vertex V1 = TopoDS::Vertex(S1);
+ switch (S2.ShapeType())
+ {
+ case TopAbs_VERTEX :
+ {
+ TopoDS_Vertex V2 = TopoDS::Vertex(S2);
+ Perform( V1, V2 );
+ break;
+ }
+ case TopAbs_EDGE :
+ {
+ TopoDS_Edge E2 = TopoDS::Edge(S2);
+ Perform( V1, E2, B1, B2 );
+ break;
+ }
+ case TopAbs_FACE :
+ {
+ TopoDS_Face F2 = TopoDS::Face(S2);
+ Perform( V1, F2, B1, B2 );
+ break;
+ }
+ }
+ break;
+ }
-/*********************************************************************************/
+ case TopAbs_EDGE :
+ {
+ TopoDS_Edge E1 = TopoDS::Edge(S1);
+ switch (S2.ShapeType())
+ {
+ case TopAbs_VERTEX :
+ {
+ TopoDS_Vertex V2 = TopoDS::Vertex(S2);
+ Perform( E1, V2, B1, B2 );
+ break;
+ }
+ case TopAbs_EDGE :
+ {
+ TopoDS_Edge E2 = TopoDS::Edge(S2);
+ TopoDS_Edge aTrimEdge;
+ Standard_Boolean bIsTrim1 = Standard_False;
+ Standard_Boolean bIsTrim2 = Standard_False;
+ TRIM_INFINIT_EDGE( E1, E2, aTrimEdge, bIsTrim1, bIsTrim2 );
+ if (bIsTrim1)
+ E1 = aTrimEdge;
+ if (bIsTrim2)
+ E2 = aTrimEdge;
+ Perform( E1, E2, B1, B2 );
+ break;
+ }
+ case TopAbs_FACE :
+ {
+ TopoDS_Face F2 = TopoDS::Face(S2);
+ TopoDS_Face aTrimFace;
+ Standard_Boolean bIsInfinit;
+ TRIM_INFINIT_FACE( E1, F2, aTrimFace, bIsInfinit );
+ if (bIsInfinit)
+ F2 = aTrimFace;
+ Perform( E1, F2, B1, B2 );
+ break;
+ }
+ }
+ break;
+ }
-void BRepExtrema_DistanceSS::Perform(const TopoDS_Vertex& S1, const TopoDS_Edge& S2,
- const Bnd_Box& B1, const Bnd_Box& B2,
- const Standard_Real DstRef)
-{
- Standard_Real Dst,Dstmin,epsP,Udeb,Ufin ;
- gp_Pnt Pt,P1;
- Standard_Boolean inserer,notavertex;
- Standard_Integer i;
-
- epsP=Precision::PConfusion();
- SeqSolShape1.Clear();
- SeqSolShape2.Clear();
- myModif=Standard_False;
-
-
- if (!BRep_Tool::Degenerated (S2)) {
- Dst=B1.Distance(B2);
- if ( (Dst< DstRef -myEps ) || (fabs(Dst-DstRef)< myEps ))
- {
- BRepExtrema_ExtPC Ext(S1,S2);
- if ( (Ext.IsDone()) && (Ext.NbExt() > 0) )
- { Standard_Integer NbExtrema=Ext.NbExt();
-// Recherche de la distance minimum dstmin
- Dstmin=sqrt(Ext.SquareDistance(1));
- for (i=2;i<=NbExtrema;i++)
- {Dst=sqrt(Ext.SquareDistance(i));
- if (Dst<Dstmin)
- Dstmin=Dst;
- }
- if ((Dstmin < DstRef -myEps) || (fabs(Dstmin-DstRef)<myEps))
- for (i=1;i<=NbExtrema;i++)
- { if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
- {Pt=Ext.Point(i);
- TRI_SOLUTION(SeqSolShape2,Pt,inserer);
- if (inserer)
- {
- // on regarde si le parametre ne correspondont pas a un vertex
- Standard_Real t =Ext.Parameter(i) ;
- notavertex=Standard_True;
- BRep_Tool::Range(S2,Udeb,Ufin);
- if ((fabs(t-Udeb)<epsP)||(fabs(t-Ufin)<=epsP )) notavertex=Standard_False;
- if (notavertex)
- {
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:51 2001 Begin
- if (myDstRef > Dstmin)
- myDstRef=Dstmin;
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:54 2001 End
- myModif=Standard_True;
- P1=BRep_Tool::Pnt(S1);
- BRepExtrema_SolutionElem Sol1 (Dstmin,P1,BRepExtrema_IsVertex,S1);
- BRepExtrema_SolutionElem Sol2 (Dstmin,Pt,BRepExtrema_IsOnEdge,S2,t);
- SeqSolShape1.Append(Sol1);
- SeqSolShape2.Append(Sol2);
- }
- }
- }
- }
- }
- }
-}
+ case TopAbs_FACE :
+ {
+ TopoDS_Face F1 = TopoDS::Face(S1);
+ switch (S2.ShapeType())
+ {
+ case TopAbs_VERTEX :
+ {
+ TopoDS_Vertex V2 = TopoDS::Vertex(S2);
+ Perform( F1, V2, B1, B2 );
+ break;
+ }
+ case TopAbs_EDGE :
+ {
+ TopoDS_Edge E2 = TopoDS::Edge(S2);
+ TopoDS_Face aTrimFace;
+ Standard_Boolean bIsInfinit;
+ TRIM_INFINIT_FACE( F1, E2, aTrimFace, bIsInfinit );
+ if (bIsInfinit)
+ F1 = aTrimFace;
+ Perform( F1, E2, B1, B2 );
+ break;
+ }
+ case TopAbs_FACE :
+ {
+ TopoDS_Face F2 = TopoDS::Face(S2);
+ Perform( F1, F2, B1, B2 );
+ break;
+ }
+ }
+ break;
+ }
+ }
}
/*********************************************************************************/
-void BRepExtrema_DistanceSS::Perform(const TopoDS_Vertex& S1, const TopoDS_Face& S2,
- const Bnd_Box& B1, const Bnd_Box& B2,
- const Standard_Real DstRef)
-{
- Standard_Real Dst,Dstmin,epsP,U,V ;
- gp_Pnt P1,Pt;
- gp_Pnt2d PUV;
- Standard_Boolean inserer,notavertex;
- Standard_Integer i;
- BRepClass_FaceClassifier classifier;
-
- epsP=Precision::PConfusion();
- SeqSolShape1.Clear();
- SeqSolShape2.Clear();
- myModif=Standard_False;
-
-
- Dst=B1.Distance(B2);
- if ( (Dst< DstRef -myEps ) || (fabs(Dst-DstRef)< myEps ))
- {
- BRepExtrema_ExtPF Ext(S1,S2);
- if ( (Ext.IsDone()) && (Ext.NbExt() > 0) )
- { Standard_Integer NbExtrema=Ext.NbExt();
-// Recherche de la distance minimum dstmin
- Dstmin=sqrt(Ext.SquareDistance(1));
- for (i=2;i<=NbExtrema;i++)
- {Dst=sqrt (Ext.SquareDistance(i));
- if (Dst<Dstmin)
- Dstmin=Dst;
- }
- if ((Dstmin < DstRef -myEps) || (fabs(Dstmin-DstRef)<myEps))
- for (i=1;i<=NbExtrema;i++)
- { if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
- { Pt=Ext.Point(i);
- TRI_SOLUTION(SeqSolShape2,Pt,inserer);
- if (inserer)
- {
- // on regarde si le parametre ne correspondont pas a un vertex
- Ext.Parameter(i,U,V);
-
- PUV.SetCoord(U,V);
- Standard_Real tol=BRep_Tool::Tolerance(S2);
- classifier.Perform(S2,PUV,tol);
- notavertex=(classifier.State()==TopAbs_IN);
- if (notavertex)
- {
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:51 2001 Begin
- if (myDstRef > Dstmin)
- myDstRef=Dstmin;
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:54 2001 End
- myModif=Standard_True;
- P1=BRep_Tool::Pnt(S1);
- BRepExtrema_SolutionElem Sol1 (Dstmin,P1,BRepExtrema_IsVertex,S1);
- BRepExtrema_SolutionElem Sol2 (Dstmin,Pt,BRepExtrema_IsInFace,S2,U,V);
- SeqSolShape1.Append(Sol1);
- SeqSolShape2.Append(Sol2);
- }
- }
- }
- }
- }
- }
-}
-
-/*********************************************************************************/
+void BRepExtrema_DistanceSS::Perform(const TopoDS_Vertex& S1, const TopoDS_Vertex& S2)
+{
+ const gp_Pnt P1 = BRep_Tool::Pnt(S1);
+ const gp_Pnt P2 = BRep_Tool::Pnt(S2);
-void BRepExtrema_DistanceSS::Perform(const TopoDS_Edge& S1, const TopoDS_Vertex& S2,
- const Bnd_Box& B1, const Bnd_Box& B2,
- const Standard_Real DstRef)
-
-{Standard_Real Dst,Dstmin,epsP,Udeb,Ufin ;
- gp_Pnt Pt,P1;
- Standard_Boolean inserer,notavertex;
- Standard_Integer i;
-
- epsP=Precision::PConfusion();
- SeqSolShape1.Clear();
- SeqSolShape2.Clear();
- myModif=Standard_False;
-
- if (!BRep_Tool::Degenerated(S1)) {
- Dst=B1.Distance(B2);
- if ( (Dst< DstRef -myEps ) || (fabs(Dst-DstRef)< myEps ))
- {
- BRepExtrema_ExtPC Ext(S2,S1);
- if ( (Ext.IsDone()) && (Ext.NbExt() > 0) )
- { Standard_Integer NbExtrema=Ext.NbExt();
-// Recherche de la distance minimum dstmin
- Dstmin=sqrt(Ext.SquareDistance(1));
- for (i=2;i<=NbExtrema;i++)
-
- {Dst=sqrt(Ext.SquareDistance(i));
- if (Dst<Dstmin)
- Dstmin=Dst;
- }
- if ((Dstmin < DstRef -myEps) || (fabs(Dstmin-DstRef)<myEps))
- for (i=1;i<=NbExtrema;i++)
- { if (fabs(Dstmin-sqrt (Ext.SquareDistance(i)))<myEps)
- {Pt=Ext.Point(i);
- TRI_SOLUTION(SeqSolShape1,Pt,inserer);
- if (inserer)
- {
- // on regarde si le parametre ne correspondont pas a un vertex
- Standard_Real t =Ext.Parameter(i) ;
- notavertex=Standard_True;
- BRep_Tool::Range(S1,Udeb,Ufin);
- if ((fabs(t-Udeb)<epsP)||(fabs(t-Ufin)<=epsP )) notavertex=Standard_False;
- if (notavertex)
- {
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:51 2001 Begin
- if (myDstRef > Dstmin)
- myDstRef=Dstmin;
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:54 2001 End
- myModif=Standard_True;
- P1=BRep_Tool::Pnt(S2);
- BRepExtrema_SolutionElem Sol1 (Dstmin,Pt,BRepExtrema_IsOnEdge,S1,t);
- BRepExtrema_SolutionElem Sol2 (Dstmin,P1,BRepExtrema_IsVertex,S2);
- SeqSolShape1.Append(Sol1);
- SeqSolShape2.Append(Sol2);
- }
- }
- }
- }
- }
- }
-}
+ const Standard_Real Dst = P1.Distance(P2);
+ if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
+ {
+ if (myDstRef > Dst)
+ myDstRef=Dst;
+ myModif=Standard_True;
+ const BRepExtrema_SolutionElem Sol1(Dst,P1,BRepExtrema_IsVertex,S1);
+ const BRepExtrema_SolutionElem Sol2(Dst,P2,BRepExtrema_IsVertex,S2);
+ SeqSolShape1.Append(Sol1);
+ SeqSolShape2.Append(Sol2);
+ }
}
/*********************************************************************************/
-void BRepExtrema_DistanceSS::Perform(const TopoDS_Edge& S1, const TopoDS_Edge& S2,
- const Bnd_Box& B1, const Bnd_Box& B2,
- const Standard_Real DstRef)
-
-{
- Standard_Real Dst,Dstmin,epsP,Udeb,Ufin;
- gp_Pnt Pt1,Pt2;
- Standard_Boolean insere1, insere2, notavertex;
- Standard_Integer i;
-
- epsP=Precision::PConfusion();
- SeqSolShape1.Clear();
- SeqSolShape2.Clear();
- myModif=Standard_False;
-
- if (!BRep_Tool::Degenerated(S1)&& !BRep_Tool::Degenerated(S2))
-
- {
-
- Dst=B1.Distance(B2);
- if ( (Dst< DstRef -myEps ) || (fabs(Dst-DstRef)< myEps ))
- {
- BRepExtrema_ExtCC Ext(S1,S2);
- if ( (Ext.IsDone()) && (Ext.NbExt() > 0) && (!Ext.IsParallel()))
- { Standard_Integer NbExtrema=Ext.NbExt();
-// Recherche de la distance minimum dstmin
- Dstmin=sqrt (Ext.SquareDistance(1));
- for (i=2;i<=NbExtrema;i++)
- {Dst=sqrt (Ext.SquareDistance(i));
- if (Dst<Dstmin)
- Dstmin=Dst;
- }
- if ((Dstmin < DstRef -myEps) || (fabs(Dstmin-DstRef)<myEps))
- for (i=1;i<=NbExtrema;i++)
- { if (fabs(Dstmin-sqrt (Ext.SquareDistance(i)))<myEps )
- {Pt1=Ext.PointOnE1(i);
- Pt2=Ext.PointOnE2(i);
- TRI_SOLUTION(SeqSolShape1,Pt1,insere1);
- TRI_SOLUTION(SeqSolShape2,Pt2,insere2);
- if (insere1 ||insere2 )
- {
- // on regarde si le parametre ne correspondont pas a un vertex
- Standard_Real t1 =Ext.ParameterOnE1(i) ;
- Standard_Real t2 =Ext.ParameterOnE2(i) ;
-
- notavertex=Standard_True;
- BRep_Tool::Range(S1,Udeb,Ufin);
- if ((fabs(t1-Udeb)<epsP)||(fabs(t1-Ufin)<=epsP )) notavertex=Standard_False;
-
- BRep_Tool::Range(S2,Udeb,Ufin);
- if ((fabs(t2-Udeb)<epsP)||(fabs(t2-Ufin)<=epsP )) notavertex=Standard_False;
-
- if (notavertex)
- {
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:51 2001 Begin
- if (myDstRef > Dstmin)
- myDstRef=Dstmin;
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:54 2001 End
- myModif=Standard_True;
- BRepExtrema_SolutionElem Sol1 (Dstmin,Pt1,BRepExtrema_IsOnEdge,S1,t1);
- BRepExtrema_SolutionElem Sol2 (Dstmin,Pt2,BRepExtrema_IsOnEdge,S2,t2);
- SeqSolShape1.Append(Sol1);
- SeqSolShape2.Append(Sol2);
- }
- }
-
- }
- }
- }
-
- BRepExtrema_SeqOfSolution SeqSolution1;
- BRepExtrema_SeqOfSolution SeqSolution2;
-// Standard_Integer i;
-
- PERFORM_C0(S1, S2, SeqSolution1, SeqSolution2, DstRef, myDstRef, myEps);
-
- BRepExtrema_SeqOfSolution seqSol1;
- BRepExtrema_SeqOfSolution seqSol2;
-
- if (SeqSolution1.Length() > 0 && SeqSolution2.Length() > 0) {
- MIN_SOLUTION(SeqSolution1, SeqSolution2, myDstRef, myEps, seqSol1, seqSol2);
- }
-
- if (!seqSol1.IsEmpty() && !seqSol2.IsEmpty())
- {
- SeqSolShape1.Append(seqSol1);
- SeqSolShape2.Append(seqSol2);
- myModif = Standard_True;
- }
-
- }
- }
- }
-
-/*********************************************************************************/
+void BRepExtrema_DistanceSS::Perform(const TopoDS_Vertex& S1, const TopoDS_Edge& S2,
+ const Bnd_Box& B1, const Bnd_Box& B2)
+{
+ if (BRep_Tool::Degenerated(S2))
+ return;
-void BRepExtrema_DistanceSS::Perform(const TopoDS_Edge& S1, const TopoDS_Face& S2,
- const Bnd_Box& B1, const Bnd_Box& B2,
- const Standard_Real DstRef)
-{
- Standard_Real Dst,Dstmin,epsP,Udeb,Ufin,U,V ;
- gp_Pnt Pt1,Pt2;
- gp_Pnt2d PUV;
- Standard_Boolean insere1 ,insere2, notavertex;
- BRepClass_FaceClassifier classifier;
- Standard_Integer i;
-
- epsP=Precision::PConfusion();
- SeqSolShape1.Clear();
- SeqSolShape2.Clear();
- myModif=Standard_False;
-
- if (!BRep_Tool::Degenerated(S1)) {
-
- Dst=B1.Distance(B2);
- if ( (Dst< DstRef -myEps ) || (fabs(Dst-DstRef)< myEps ))
+ const Standard_Real Dst=B1.Distance(B2);
+ if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
+ {
+ BRepExtrema_ExtPC Ext(S1,S2);
+ const Standard_Integer NbExtrema = Ext.IsDone()? Ext.NbExt() : 0;
+ if ( NbExtrema > 0 )
+ {
+ // Search minimum distance Dstmin
+ Standard_Integer i;
+ Standard_Real Dstmin = Ext.SquareDistance(1);
+ for (i = 2; i <= NbExtrema; i++)
{
- BRepExtrema_ExtCF Ext(S1,S2);
- if ( (Ext.IsDone()) && ((Ext.NbExt() > 0) && (!Ext.IsParallel()) ))
- { Standard_Integer NbExtrema=Ext.NbExt();
- // Recherche de la distance minimum dstmin
- Dstmin=sqrt (Ext.SquareDistance(1));
- for (i=2;i<=NbExtrema;i++)
- {Dst=sqrt (Ext.SquareDistance(i));
- if (Dst<Dstmin)
- Dstmin=Dst;
- }
- if ((Dstmin < DstRef -myEps) || (fabs(Dstmin-DstRef)<myEps))
- for (i=1;i<=NbExtrema;i++)
- { if (fabs(Dstmin-sqrt (Ext.SquareDistance(i)))<myEps)
- {Pt1=Ext.PointOnEdge(i);
- Pt2=Ext.PointOnFace(i);
- TRI_SOLUTION (SeqSolShape1,Pt1,insere1);
- TRI_SOLUTION (SeqSolShape2,Pt2,insere2);
- if (insere1||insere2)
- {
- // on regarde si le parametre ne correspondont pas a un vertex
- Standard_Real t1 =Ext.ParameterOnEdge(i) ;
-
- notavertex=Standard_True;
- BRep_Tool::Range(S1,Udeb,Ufin);
- if ((fabs(t1-Udeb)<epsP)||(fabs(t1-Ufin)<=epsP )) notavertex=Standard_False;
-
- Ext.ParameterOnFace(i,U,V);
- PUV.SetCoord(U,V);
- Standard_Real tol=BRep_Tool::Tolerance(S2);
- classifier.Perform(S2,PUV,tol);
- if ( classifier.State()!=TopAbs_IN) notavertex=Standard_False;
-
- if (notavertex)
- {
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:51 2001 Begin
- if (myDstRef > Dstmin)
- myDstRef=Dstmin;
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:54 2001 End
- myModif=Standard_True;
- BRepExtrema_SolutionElem Sol1 (Dstmin,Pt1,BRepExtrema_IsOnEdge,S1,t1);
- BRepExtrema_SolutionElem Sol2 (Dstmin,Pt2,BRepExtrema_IsInFace,S2,U,V);
- SeqSolShape1.Append(Sol1);
- SeqSolShape2.Append(Sol2);
- }
- }
- }
- }
+ const Standard_Real sDst = Ext.SquareDistance(i);
+ if (sDst<Dstmin)
+ Dstmin=sDst;
}
- Standard_Real aFirst, aLast;
- Handle(Geom_Curve) pCurv = BRep_Tool::Curve(S1, aFirst, aLast);
- GeomAbs_Shape s = pCurv->Continuity();
- if (s == GeomAbs_C0)
- {
- BRepExtrema_SeqOfSolution SeqSolution1;
- BRepExtrema_SeqOfSolution SeqSolution2;
+ Dstmin = sqrt(Dstmin);
+ if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
+ {
+ Standard_Real Udeb,Ufin;
+ BRep_Tool::Range(S2,Udeb,Ufin);
-
- GeomAdaptor_Curve aAdaptorCurve(pCurv, aFirst, aLast);
- Standard_Integer nbIntervals = aAdaptorCurve.NbIntervals(GeomAbs_C1);
-
- TColStd_Array1OfReal arrInter(1,1+nbIntervals);
- aAdaptorCurve.Intervals(arrInter, GeomAbs_C1);
-
-// Standard_Real U,V;
- gp_Pnt P1,Pt;
-// gp_Pnt2d PUV;
-// Standard_Boolean notavertex;
-// Standard_Integer i, ii;
- Standard_Integer ii;
-// BRepClass_FaceClassifier classifier;
- Standard_Real aParameter;
- for (i=1; i<=arrInter.Length(); i++)
- {
- gp_Pnt aPnt = aAdaptorCurve.Value(arrInter(i));
-
- TopoDS_Vertex V1 = BRepBuilderAPI_MakeVertex(aPnt);
-
- aParameter = arrInter(i);
-
- BRepExtrema_ExtPF ExtPF(V1,S2);
- if ( (ExtPF.IsDone()) && (ExtPF.NbExt() > 0) )
- {
- Standard_Integer NbExtrema=ExtPF.NbExt();
- // Recherche de la distance minimum dstmin
- Dstmin=sqrt (ExtPF.SquareDistance(1));
- for (ii=2;ii<=NbExtrema;ii++)
- {Dst=sqrt(ExtPF.SquareDistance(ii));
- if (Dst<Dstmin)
- Dstmin=Dst;
- }
- if ((Dstmin < DstRef -myEps) || (fabs(Dstmin-DstRef)<myEps))
- {
-
- for (ii=1;ii<=NbExtrema;ii++)
- {
- if (fabs(Dstmin-sqrt (ExtPF.SquareDistance(ii)))<myEps)
- {
- Pt=ExtPF.Point(ii);
- // on regarde si le parametre ne correspondont pas a un vertex
- ExtPF.Parameter(ii,U,V);
- // Standard_Real t1 =Ext.ParameterOnEdge(ii) ;
-
- PUV.SetCoord(U,V);
- Standard_Real tol=BRep_Tool::Tolerance(S2);
- classifier.Perform(S2,PUV,tol);
- notavertex=(classifier.State()==TopAbs_IN);
- if (notavertex)
- {
- // Modified by Sergey KHROMOV - Tue Mar 6 12:28:51 2001 Begin
- if (myDstRef > Dstmin)
- myDstRef=Dstmin;
- // Modified by Sergey KHROMOV - Tue Mar 6 12:28:54 2001 End
- myModif=Standard_True;
- P1=BRep_Tool::Pnt(V1);
- BRepExtrema_SolutionElem Sol1 (Dstmin,P1,BRepExtrema_IsOnEdge,S1,aParameter);
- BRepExtrema_SolutionElem Sol2 (Dstmin,Pt,BRepExtrema_IsInFace,S2,U,V);
- SeqSolution1.Append(Sol1);
- SeqSolution2.Append(Sol2);
- }
- }
- }
- }
- }
- }
- BRepExtrema_SeqOfSolution seqSol1;
- BRepExtrema_SeqOfSolution seqSol2;
- Standard_Boolean bIsMini = Standard_False;
- if (SeqSolution1.Length() > 0 && SeqSolution2.Length() > 0)
- MIN_SOLUTION(SeqSolution1, SeqSolution2, myDstRef, myEps, seqSol1, seqSol2);
-
- if (!seqSol1.IsEmpty() && !seqSol2.IsEmpty())
- {
- SeqSolShape1.Append(seqSol1);
- SeqSolShape2.Append(seqSol2);
- }
- }
+ gp_Pnt Pt,P1=BRep_Tool::Pnt(S1);
+ const Standard_Real epsP=Precision::PConfusion();
+
+ for (i = 1; i <= NbExtrema; i++)
+ {
+ if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
+ {
+ Pt=Ext.Point(i);
+ if (TRI_SOLUTION(SeqSolShape2,Pt))
+ {
+ // Check if the parameter does not correspond to a vertex
+ const Standard_Real t = Ext.Parameter(i);
+ if ( (fabs(t-Udeb)>=epsP) && (fabs(t-Ufin)>epsP) )
+ {
+ if (myDstRef > Dstmin)
+ myDstRef=Dstmin;
+ myModif=Standard_True;
+ const BRepExtrema_SolutionElem Sol1(Dstmin,P1,BRepExtrema_IsVertex,S1);
+ const BRepExtrema_SolutionElem Sol2(Dstmin,Pt,BRepExtrema_IsOnEdge,S2,t);
+ SeqSolShape1.Append(Sol1);
+ SeqSolShape2.Append(Sol2);
+ }
+ }
+ }
+ }
}
+ }
}
}
/*********************************************************************************/
-void BRepExtrema_DistanceSS::Perform(const TopoDS_Face& S1, const TopoDS_Vertex& S2,
- const Bnd_Box& B1, const Bnd_Box& B2,
- const Standard_Real DstRef)
-
+void BRepExtrema_DistanceSS::Perform(const TopoDS_Vertex& S1, const TopoDS_Face& S2,
+ const Bnd_Box& B1, const Bnd_Box& B2)
{
- const Standard_Real epsP=Precision::PConfusion();
- SeqSolShape1.Clear();
- SeqSolShape2.Clear();
- myModif=Standard_False;
-
- Standard_Real Dst=B1.Distance(B2);
- if ((Dst < DstRef -myEps) || (fabs(Dst-DstRef)< myEps))
+ const Standard_Real Dst=B1.Distance(B2);
+ if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
{
- BRepExtrema_ExtPF Ext(S2,S1);
- if ( Ext.IsDone() && (Ext.NbExt() > 0) )
+ BRepExtrema_ExtPF Ext(S1,S2,myFlag,myAlgo);
+ const Standard_Integer NbExtrema = Ext.IsDone()? Ext.NbExt() : 0;
+ if ( NbExtrema > 0 )
{
- const Standard_Integer NbExtrema=Ext.NbExt();
- // Search the minimal distance Dstmin
+ // Search minimum distance Dstmin
Standard_Integer i;
Standard_Real Dstmin = Ext.SquareDistance(1);
- for (i=2;i<=NbExtrema;i++)
- {
- Dst = Ext.SquareDistance(i);
- if (Dst<Dstmin)
- Dstmin=Dst;
+ for (i = 2; i <= NbExtrema; i++)
+ {
+ const Standard_Real sDst = Ext.SquareDistance(i);
+ if (sDst<Dstmin)
+ Dstmin=sDst;
}
Dstmin = sqrt(Dstmin);
-
- if ((Dstmin < DstRef -myEps) || (fabs(Dstmin-DstRef)<myEps))
+ if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
{
Standard_Real U,V;
- gp_Pnt P1,Pt;
- gp_Pnt2d PUV;
- Standard_Boolean inserer;
+ gp_Pnt Pt,P1=BRep_Tool::Pnt(S1);
BRepClass_FaceClassifier classifier;
-
- for (i=1;i<=NbExtrema;i++)
+ const Standard_Real tol = BRep_Tool::Tolerance(S2);
+ const Standard_Real epsP = Precision::PConfusion();
+
+ for (i = 1; i <= NbExtrema; i++)
{
- if (fabs(Dstmin-sqrt (Ext.SquareDistance(i)))<myEps)
- {
+ if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
+ {
Pt=Ext.Point(i);
- TRI_SOLUTION (SeqSolShape1,Pt,inserer);
- if (inserer)
- {
- // on regarde si le parametre ne correspondont pas a un vertex
+ if (TRI_SOLUTION(SeqSolShape2,Pt))
+ {
+ // Check if the parameter does not correspond to a vertex
Ext.Parameter(i,U,V);
-
- PUV.SetCoord(U,V);
- const Standard_Real tol=BRep_Tool::Tolerance(S1);
- classifier.Perform(S1,PUV,tol);
+ const gp_Pnt2d PUV(U,V);
+ classifier.Perform(S2,PUV,tol);
if (classifier.State()==TopAbs_IN)
{
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:51 2001 Begin
- if (myDstRef > Dstmin)
- myDstRef=Dstmin;
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:54 2001 End
+ if (myDstRef > Dstmin)
+ myDstRef=Dstmin;
myModif=Standard_True;
- P1=BRep_Tool::Pnt(S2);
- BRepExtrema_SolutionElem Sol1 (Dstmin,Pt,BRepExtrema_IsInFace,S1,U,V);
- BRepExtrema_SolutionElem Sol2 (Dstmin,P1,BRepExtrema_IsVertex,S2);
+ const BRepExtrema_SolutionElem Sol1(Dstmin,P1,BRepExtrema_IsVertex,S1);
+ const BRepExtrema_SolutionElem Sol2(Dstmin,Pt,BRepExtrema_IsInFace,S2,U,V);
SeqSolShape1.Append(Sol1);
- SeqSolShape2.Append(Sol2);
+ SeqSolShape2.Append(Sol2);
}
}
}
}
- }
+ }
}
}
}
/*********************************************************************************/
-void BRepExtrema_DistanceSS::Perform(const TopoDS_Face& S1, const TopoDS_Edge& S2,
- const Bnd_Box& B1, const Bnd_Box& B2,
- const Standard_Real DstRef)
-
+void BRepExtrema_DistanceSS::Perform(const TopoDS_Edge& S1, const TopoDS_Edge& S2,
+ const Bnd_Box& B1, const Bnd_Box& B2)
{
- Standard_Real Dst,Dstmin,epsP,Udeb,Ufin,U,V ;
- gp_Pnt Pt1,Pt2;
- gp_Pnt2d PUV;
- Standard_Boolean insere1,insere2,notavertex;
- BRepClass_FaceClassifier classifier;
- Standard_Integer i;
-
- epsP=Precision::PConfusion();
- SeqSolShape1.Clear();
- SeqSolShape2.Clear();
- myModif=Standard_False;
-
- if (!BRep_Tool::Degenerated(S2))
+ if (BRep_Tool::Degenerated(S1) || BRep_Tool::Degenerated(S2))
+ return;
+
+ const Standard_Real Dst=B1.Distance(B2);
+ if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
{
- Dst=B1.Distance(B2);
- if ( (Dst< DstRef -myEps ) || (fabs(Dst-DstRef)< myEps ))
- {
- BRepExtrema_ExtCF Ext(S2,S1);
- if ( (Ext.IsDone()) && ((Ext.NbExt() > 0) && (!Ext.IsParallel())) )
- { Standard_Integer NbExtrema=Ext.NbExt();
-// Recherche de la distance minimum dstmin
- Dstmin=sqrt (Ext.SquareDistance(1));
- for (i=2;i<=NbExtrema;i++)
- {Dst=sqrt (Ext.SquareDistance(i));
- if (Dst<Dstmin)
- Dstmin=Dst;}
- if ((Dstmin < DstRef -myEps) || (fabs(Dstmin-DstRef)<myEps))
- for (i=1;i<=NbExtrema;i++)
- { if (fabs(Dstmin-sqrt (Ext.SquareDistance(i)))<myEps)
- {Pt1=Ext.PointOnFace(i);
- Pt2=Ext.PointOnEdge(i);
- TRI_SOLUTION (SeqSolShape1,Pt1,insere1);
- TRI_SOLUTION (SeqSolShape2,Pt2,insere2);
- if (insere1||insere2)
-
- {
- // on regarde si le parametre ne correspondont pas a un vertex
- Standard_Real t1 =Ext.ParameterOnEdge(i) ;
-
- notavertex=Standard_True;
- BRep_Tool::Range(S2,Udeb,Ufin);
- if ((fabs(t1-Udeb)<epsP)||(fabs(t1-Ufin)<=epsP )) notavertex=Standard_False;
-
- Ext.ParameterOnFace(i,U,V);
- PUV.SetCoord(U,V);
- Standard_Real tol=BRep_Tool::Tolerance(S1);
- classifier.Perform(S1,PUV,tol);
- if (classifier.State()!=TopAbs_IN) notavertex=Standard_False;
-
- if (notavertex)
- {
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:51 2001 Begin
- if (myDstRef > Dstmin)
- myDstRef=Dstmin;
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:54 2001 End
- myModif=Standard_True;
- BRepExtrema_SolutionElem Sol1 (Dstmin,Pt1,BRepExtrema_IsInFace,S1,U,V);
- BRepExtrema_SolutionElem Sol2 (Dstmin,Pt2,BRepExtrema_IsOnEdge,S2,t1);
- SeqSolShape1.Append(Sol1);
- SeqSolShape2.Append(Sol2);
- }
- }
- }
- }
- }
-
- Standard_Real aFirst, aLast;
- Handle(Geom_Curve) pCurv = BRep_Tool::Curve(S2, aFirst, aLast);
- GeomAbs_Shape s = pCurv->Continuity();
- if (s == GeomAbs_C0)
- {
- BRepExtrema_SeqOfSolution SeqSolution1;
- BRepExtrema_SeqOfSolution SeqSolution2;
-
-
- GeomAdaptor_Curve aAdaptorCurve(pCurv, aFirst, aLast);
- Standard_Integer nbIntervals = aAdaptorCurve.NbIntervals(GeomAbs_C1);
-
- TColStd_Array1OfReal arrInter(1,1+nbIntervals);
- aAdaptorCurve.Intervals(arrInter, GeomAbs_C1);
-
-// Standard_Real U,V;
- gp_Pnt P1,Pt;
-// gp_Pnt2d PUV;
-// Standard_Boolean notavertex;
- Standard_Integer ii;
-// BRepClass_FaceClassifier classifier;
- Standard_Real aParameter;
- for (i=1; i<=arrInter.Length(); i++)
- {
- gp_Pnt aPnt = aAdaptorCurve.Value(arrInter(i));
-
- TopoDS_Vertex V1 = BRepBuilderAPI_MakeVertex(aPnt);
-
- aParameter = arrInter(i);
-
- BRepExtrema_ExtPF ExtPF(V1,S1);
- if ( (ExtPF.IsDone()) && (ExtPF.NbExt() > 0) )
- {
- Standard_Integer NbExtrema=ExtPF.NbExt();
- // Recherche de la distance minimum dstmin
- Dstmin=sqrt(ExtPF.SquareDistance(1));
- for (ii=2;ii<=NbExtrema;ii++)
- {Dst=sqrt(ExtPF.SquareDistance(ii));
- if (Dst<Dstmin)
- Dstmin=Dst;
- }
- if ((Dstmin < DstRef -myEps) || (fabs(Dstmin-DstRef)<myEps))
- {
-
- for (ii=1;ii<=NbExtrema;ii++)
- {
- if (fabs(Dstmin-sqrt(ExtPF.SquareDistance(ii)))<myEps)
- {
- Pt=ExtPF.Point(ii);
- // on regarde si le parametre ne correspondont pas a un vertex
- ExtPF.Parameter(ii,U,V);
- // Standard_Real t1 =Ext.ParameterOnEdge(ii) ;
-
- PUV.SetCoord(U,V);
- Standard_Real tol=BRep_Tool::Tolerance(S1);
- classifier.Perform(S1,PUV,tol);
- notavertex=(classifier.State()==TopAbs_IN);
- if (notavertex)
- {
- // Modified by Sergey KHROMOV - Tue Mar 6 12:28:51 2001 Begin
- if (myDstRef > Dstmin)
- myDstRef=Dstmin;
- // Modified by Sergey KHROMOV - Tue Mar 6 12:28:54 2001 End
- myModif=Standard_True;
- P1=BRep_Tool::Pnt(V1);
- BRepExtrema_SolutionElem Sol1 (Dstmin,Pt,BRepExtrema_IsInFace,S1,U,V);
- BRepExtrema_SolutionElem Sol2 (Dstmin,P1,BRepExtrema_IsOnEdge,S2,aParameter);
- SeqSolution1.Append(Sol1);
- SeqSolution2.Append(Sol2);
- }
- }
- }
- }
- }
- }
- BRepExtrema_SeqOfSolution seqSol1;
- BRepExtrema_SeqOfSolution seqSol2;
- Standard_Boolean bIsMini = Standard_False;
- if (SeqSolution1.Length() > 0 && SeqSolution2.Length() > 0)
- MIN_SOLUTION(SeqSolution1, SeqSolution2, myDstRef, myEps, seqSol1, seqSol2);
-
- if (!seqSol1.IsEmpty() && !seqSol2.IsEmpty())
- {
- SeqSolShape1.Append(seqSol1);
- SeqSolShape2.Append(seqSol2);
- }
- }
-
- }
- }
- }
+ const Standard_Real DstRef = myDstRef;
-/*********************************************************************************/
+ BRepExtrema_ExtCC Ext(S1,S2);
+ const Standard_Integer NbExtrema = Ext.IsDone()? (Ext.IsParallel()? 0 : Ext.NbExt()) : 0;
+ if ( NbExtrema > 0 )
+ {
+ // Search minimum distance Dstmin
+ Standard_Integer i;
+ Standard_Real Dstmin = Ext.SquareDistance(1);
+ for (i = 2; i <= NbExtrema; i++)
+ {
+ const Standard_Real sDst = Ext.SquareDistance(i);
+ if (sDst<Dstmin)
+ Dstmin=sDst;
+ }
+ Dstmin = sqrt(Dstmin);
+ if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
+ {
+ Standard_Real Udeb1,Ufin1,Udeb2,Ufin2;
+ BRep_Tool::Range(S1,Udeb1,Ufin1);
+ BRep_Tool::Range(S2,Udeb2,Ufin2);
-void BRepExtrema_DistanceSS::Perform(const TopoDS_Face& S1, const TopoDS_Face& S2,
- const Bnd_Box& B1, const Bnd_Box& B2,
- const Standard_Real DstRef)
+ gp_Pnt Pt1,Pt2;
+ const Standard_Real epsP=Precision::PConfusion();
-{
- Standard_Real Dst,Dstmin,epsP,U1,V1,U2,V2,tol ;
- gp_Pnt Pt1,Pt2;
- gp_Pnt2d PUV;
- Standard_Boolean insere1,insere2,notavertex;
- BRepClass_FaceClassifier classifier;
- Standard_Integer i;
-
- epsP=Precision::PConfusion();
- SeqSolShape1.Clear();
- SeqSolShape2.Clear();
- myModif=Standard_False;
-
- Dst=B1.Distance(B2);
- if ( (Dst< DstRef -myEps ) || (fabs(Dst-DstRef)< myEps ))
- {
- BRepExtrema_ExtFF Ext(S1,S2);
- if ( (Ext.IsDone()) && ((Ext.NbExt() > 0) && (!Ext.IsParallel()) ))
- { Standard_Integer NbExtrema=Ext.NbExt();
-// Recherche de la distance minimum dstmin
- Dstmin=sqrt (Ext.SquareDistance(1));
- for (i=2;i<=NbExtrema;i++)
- {Dst=sqrt(Ext.SquareDistance(i));
- if (Dst<Dstmin)
- Dstmin=Dst;
- }
- if ((Dstmin < DstRef -myEps) || (fabs(Dstmin-DstRef)<myEps))
- for (i=1;i<=NbExtrema;i++)
- { if (fabs(Dstmin-sqrt (Ext.SquareDistance(i)))<myEps)
- {Pt1=Ext.PointOnFace1(i);
- Pt2=Ext.PointOnFace2(i);
- TRI_SOLUTION (SeqSolShape1,Pt1,insere1);
- TRI_SOLUTION (SeqSolShape2,Pt2,insere2) ;
- if (insere1||insere2)
- {
- // on regarde si le parametre ne correspondont pas a un vertex
-
-
-
- Ext.ParameterOnFace1(i,U1,V1);
- PUV.SetCoord(U1,V1);
- tol=BRep_Tool::Tolerance(S1);
- classifier.Perform(S1,PUV,tol);
- notavertex=(classifier.State()==TopAbs_IN);
-
- Ext.ParameterOnFace2(i,U2,V2);
- PUV.SetCoord(U2,V2);
- tol=BRep_Tool::Tolerance(S2);
- classifier.Perform(S2,PUV,tol);
- if (classifier.State()!=TopAbs_IN) notavertex= Standard_False;
-
- if (notavertex)
- {
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:51 2001 Begin
- if (myDstRef > Dstmin)
- myDstRef=Dstmin;
-// Modified by Sergey KHROMOV - Tue Mar 6 12:28:54 2001 End
- myModif=Standard_True;
- BRepExtrema_SolutionElem Sol1 (Dstmin,Pt1,BRepExtrema_IsInFace,S1,U1,V1);
- BRepExtrema_SolutionElem Sol2 (Dstmin,Pt2,BRepExtrema_IsInFace,S2,U2,V2);
- SeqSolShape1.Append(Sol1);
- SeqSolShape2.Append(Sol2);
- }
- }
- }
- }
- }
- }
-}
+ for (i=1;i<=NbExtrema;i++)
+ {
+ if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
+ {
+ Pt1=Ext.PointOnE1(i);
+ Pt2=Ext.PointOnE2(i);
+ if (TRI_SOLUTION(SeqSolShape1,Pt1) || TRI_SOLUTION(SeqSolShape2,Pt2))
+ {
+ // Check if the parameters do not correspond to a vertex
+ const Standard_Real t1 = Ext.ParameterOnE1(i);
+ const Standard_Real t2 = Ext.ParameterOnE2(i);
+ if ((fabs(t1-Udeb1)>=epsP)&&(fabs(t1-Ufin1)>epsP)&&(fabs(t2-Udeb2)>=epsP)&&(fabs(t2-Ufin2)>epsP))
+ {
+ if (myDstRef > Dstmin)
+ myDstRef=Dstmin;
+ myModif=Standard_True;
+ const BRepExtrema_SolutionElem Sol1(Dstmin,Pt1,BRepExtrema_IsOnEdge,S1,t1);
+ const BRepExtrema_SolutionElem Sol2(Dstmin,Pt2,BRepExtrema_IsOnEdge,S2,t2);
+ SeqSolShape1.Append(Sol1);
+ SeqSolShape2.Append(Sol2);
+ }
+ }
+ }
+ }
+ }
+ }
-/*********************************************************************************/
+ BRepExtrema_SeqOfSolution SeqSolution1;
+ BRepExtrema_SeqOfSolution SeqSolution2;
-Standard_Boolean BRepExtrema_DistanceSS::IsDone() const
-{
- return myModif;
+ PERFORM_C0(S1, S2, SeqSolution1, SeqSolution2, DstRef, myDstRef, myEps);
+
+ BRepExtrema_SeqOfSolution seqSol1;
+ BRepExtrema_SeqOfSolution seqSol2;
+
+ if (SeqSolution1.Length() > 0 && SeqSolution2.Length() > 0)
+ MIN_SOLUTION(SeqSolution1, SeqSolution2, myDstRef, myEps, seqSol1, seqSol2);
+
+ if (!seqSol1.IsEmpty() && !seqSol2.IsEmpty())
+ {
+ SeqSolShape1.Append(seqSol1);
+ SeqSolShape2.Append(seqSol2);
+ myModif = Standard_True;
+ }
+ }
}
/*********************************************************************************/
-Standard_Real BRepExtrema_DistanceSS::DistValue() const
+void BRepExtrema_DistanceSS::Perform(const TopoDS_Edge& S1, const TopoDS_Face& S2,
+ const Bnd_Box& B1, const Bnd_Box& B2)
{
- return myDstRef;
-}
+ if (BRep_Tool::Degenerated(S1))
+ return;
+
+ const Standard_Real Dst=B1.Distance(B2);
+ if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
+ {
+ BRepClass_FaceClassifier classifier;
-/*********************************************************************************/
+ BRepExtrema_ExtCF Ext(S1,S2);
+ const Standard_Integer NbExtrema = Ext.IsDone()? (Ext.IsParallel()? 0 : Ext.NbExt()) : 0;
+ if ( NbExtrema > 0 )
+ {
+ // Search minimum distance Dstmin
+ Standard_Integer i;
+ Standard_Real Dstmin = Ext.SquareDistance(1);
+ for (i = 2; i <= NbExtrema; i++)
+ {
+ const Standard_Real sDst = Ext.SquareDistance(i);
+ if (sDst<Dstmin)
+ Dstmin=sDst;
+ }
+ Dstmin = sqrt(Dstmin);
+ if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
+ {
+ Standard_Real Udeb,Ufin,U,V;
+ BRep_Tool::Range(S1,Udeb,Ufin);
+ const Standard_Real tol=BRep_Tool::Tolerance(S2);
-const BRepExtrema_SeqOfSolution& BRepExtrema_DistanceSS::Seq1Value() const
-{
- return SeqSolShape1;
+ gp_Pnt Pt1,Pt2;
+ const Standard_Real epsP=Precision::PConfusion();
+
+ for (i = 1; i <= NbExtrema; i++)
+ {
+ if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
+ {
+ Pt1=Ext.PointOnEdge(i);
+ Pt2=Ext.PointOnFace(i);
+ if (TRI_SOLUTION(SeqSolShape1,Pt1) || TRI_SOLUTION(SeqSolShape2,Pt2))
+ {
+ // Check if the parameter does not correspond to a vertex
+ const Standard_Real t1 = Ext.ParameterOnEdge(i);
+ if ((fabs(t1-Udeb)>=epsP)&&(fabs(t1-Ufin)>epsP))
+ {
+ Ext.ParameterOnFace(i,U,V);
+ const gp_Pnt2d PUV(U,V);
+ classifier.Perform(S2,PUV,tol);
+ if (classifier.State()==TopAbs_IN)
+ {
+ if (myDstRef > Dstmin)
+ myDstRef=Dstmin;
+ myModif=Standard_True;
+ const BRepExtrema_SolutionElem Sol1(Dstmin,Pt1,BRepExtrema_IsOnEdge,S1,t1);
+ const BRepExtrema_SolutionElem Sol2(Dstmin,Pt2,BRepExtrema_IsInFace,S2,U,V);
+ SeqSolShape1.Append(Sol1);
+ SeqSolShape2.Append(Sol2);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ Standard_Real aFirst, aLast;
+ Handle(Geom_Curve) pCurv = BRep_Tool::Curve(S1, aFirst, aLast);
+ if (pCurv->Continuity() == GeomAbs_C0)
+ {
+ BRepExtrema_SeqOfSolution SeqSolution1;
+ BRepExtrema_SeqOfSolution SeqSolution2;
+
+ GeomAdaptor_Curve aAdaptorCurve(pCurv, aFirst, aLast);
+ const Standard_Integer nbIntervals = aAdaptorCurve.NbIntervals(GeomAbs_C1);
+
+ TColStd_Array1OfReal arrInter(1,1+nbIntervals);
+ aAdaptorCurve.Intervals(arrInter, GeomAbs_C1);
+
+ gp_Pnt Pt;
+ Standard_Real U,V;
+ const Standard_Real tol = BRep_Tool::Tolerance(S2);
+
+ Standard_Integer i;
+ for (i = 1; i <= arrInter.Length(); i++)
+ {
+ const Standard_Real aParameter = arrInter(i);
+ gp_Pnt aPnt = aAdaptorCurve.Value(aParameter);
+ TopoDS_Vertex V1 = BRepBuilderAPI_MakeVertex(aPnt);
+
+ BRepExtrema_ExtPF ExtPF(V1,S2);
+ const Standard_Integer NbExtrema = ExtPF.IsDone()? ExtPF.NbExt() : 0;
+ if ( NbExtrema > 0 )
+ {
+ // Search minimum distance Dstmin
+ Standard_Integer ii;
+ Standard_Real Dstmin = ExtPF.SquareDistance(1);
+ for (ii = 2; ii <= NbExtrema; ii++)
+ {
+ const Standard_Real sDst = ExtPF.SquareDistance(ii);
+ if (sDst<Dstmin)
+ Dstmin=sDst;
+ }
+ Dstmin = sqrt(Dstmin);
+
+ if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
+ {
+ for (ii = 1; ii <= NbExtrema; ii++)
+ {
+ if (fabs(Dstmin-sqrt(ExtPF.SquareDistance(ii)))<myEps)
+ {
+ // Check if the parameter does not correspond to a vertex
+ ExtPF.Parameter(ii,U,V);
+ const gp_Pnt2d PUV(U,V);
+ classifier.Perform(S2,PUV,tol);
+ if (classifier.State()==TopAbs_IN)
+ {
+ if (myDstRef > Dstmin)
+ myDstRef=Dstmin;
+ myModif=Standard_True;
+ const BRepExtrema_SolutionElem Sol1(Dstmin,aPnt,BRepExtrema_IsOnEdge,S1,aParameter);
+ const BRepExtrema_SolutionElem Sol2(Dstmin,ExtPF.Point(ii),BRepExtrema_IsInFace,S2,U,V);
+ SeqSolution1.Append(Sol1);
+ SeqSolution2.Append(Sol2);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ BRepExtrema_SeqOfSolution seqSol1;
+ BRepExtrema_SeqOfSolution seqSol2;
+ Standard_Boolean bIsMini = Standard_False;
+ if (SeqSolution1.Length() > 0 && SeqSolution2.Length() > 0)
+ MIN_SOLUTION(SeqSolution1, SeqSolution2, myDstRef, myEps, seqSol1, seqSol2);
+
+ if (!seqSol1.IsEmpty() && !seqSol2.IsEmpty())
+ {
+ SeqSolShape1.Append(seqSol1);
+ SeqSolShape2.Append(seqSol2);
+ }
+ }
+ }
}
/*********************************************************************************/
-const BRepExtrema_SeqOfSolution& BRepExtrema_DistanceSS::Seq2Value() const
-{
-return SeqSolShape2;
+void BRepExtrema_DistanceSS::Perform(const TopoDS_Face& S1, const TopoDS_Face& S2,
+ const Bnd_Box& B1, const Bnd_Box& B2)
+{
+ const Standard_Real Dst=B1.Distance(B2);
+ if ((Dst < myDstRef - myEps) || (fabs(Dst-myDstRef) < myEps))
+ {
+ BRepExtrema_ExtFF Ext(S1,S2);
+ const Standard_Integer NbExtrema = Ext.IsDone()? (Ext.IsParallel()? 0 : Ext.NbExt()) : 0;
+ if ( NbExtrema > 0 )
+ {
+ // Search minimum distance Dstmin
+ Standard_Integer i;
+ Standard_Real Dstmin = Ext.SquareDistance(1);
+ for (i = 2; i <= NbExtrema; i++)
+ {
+ const Standard_Real sDst = Ext.SquareDistance(i);
+ if (sDst<Dstmin)
+ Dstmin=sDst;
+ }
+ Dstmin = sqrt(Dstmin);
+ if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin-myDstRef) < myEps))
+ {
+ const Standard_Real tol1=BRep_Tool::Tolerance(S1);
+ const Standard_Real tol2=BRep_Tool::Tolerance(S2);
+
+ gp_Pnt Pt1,Pt2;
+ gp_Pnt2d PUV;
+ Standard_Real U1,V1,U2,V2;
+ BRepClass_FaceClassifier classifier;
+ const Standard_Real epsP=Precision::PConfusion();
+
+ for (i = 1; i <= NbExtrema; i++)
+ {
+ if (fabs(Dstmin-sqrt(Ext.SquareDistance(i)))<myEps)
+ {
+ Pt1=Ext.PointOnFace1(i);
+ Pt2=Ext.PointOnFace2(i);
+ if (TRI_SOLUTION(SeqSolShape1,Pt1) || TRI_SOLUTION(SeqSolShape2,Pt2))
+ {
+ // Check if the parameter does not correspond to a vertex
+ Ext.ParameterOnFace1(i,U1,V1);
+ PUV.SetCoord(U1,V1);
+ classifier.Perform(S1,PUV,tol1);
+ if (classifier.State()==TopAbs_IN)
+ {
+ Ext.ParameterOnFace2(i,U2,V2);
+ PUV.SetCoord(U2,V2);
+ classifier.Perform(S2,PUV,tol2);
+ if (classifier.State()==TopAbs_IN)
+ {
+ if (myDstRef > Dstmin)
+ myDstRef=Dstmin;
+ myModif=Standard_True;
+ const BRepExtrema_SolutionElem Sol1(Dstmin,Pt1,BRepExtrema_IsInFace,S1,U1,V1);
+ const BRepExtrema_SolutionElem Sol2(Dstmin,Pt2,BRepExtrema_IsInFace,S2,U2,V2);
+ SeqSolShape1.Append(Sol1);
+ SeqSolShape2.Append(Sol2);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
}
/*********************************************************************************/
-/*********************************************************************************/
--- /dev/null
+// File generated by CPPExt (Value)
+//
+// Copyright (C) 1991 - 2000 by
+// Matra Datavision SA. All rights reserved.
+//
+// Copyright (C) 2001 - 2004 by
+// Open CASCADE SA. All rights reserved.
+//
+// This file is part of the Open CASCADE Technology software.
+//
+// This software may be distributed and/or modified under the terms and
+// conditions of the Open CASCADE Public License as defined by Open CASCADE SA
+// and appearing in the file LICENSE included in the packaging of this file.
+//
+// This software is distributed on an "AS IS" basis, without warranty of any
+// kind, and Open CASCADE SA hereby disclaims all such warranties,
+// including without limitation, any warranties of merchantability, fitness
+// for a particular purpose or non-infringement. Please see the License for
+// the specific terms and conditions governing rights and limitations under the
+// License.
+
+#ifndef _BRepExtrema_DistanceSS_HeaderFile
+#define _BRepExtrema_DistanceSS_HeaderFile
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#endif
+
+#ifndef _BRepExtrema_SeqOfSolution_HeaderFile
+#include <BRepExtrema_SeqOfSolution.hxx>
+#endif
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+#ifndef _Extrema_ExtFlag_HeaderFile
+#include <Extrema_ExtFlag.hxx>
+#endif
+#ifndef _Extrema_ExtAlgo_HeaderFile
+#include <Extrema_ExtAlgo.hxx>
+#endif
+#ifndef _Precision_HeaderFile
+#include <Precision.hxx>
+#endif
+class TopoDS_Shape;
+class Bnd_Box;
+class TopoDS_Vertex;
+class TopoDS_Edge;
+class TopoDS_Face;
+
+
+//! This class allows to compute minimum distance between two shapes <br>
+//! (face edge vertex) and is used in DistShapeShape class. <br>
+class BRepExtrema_DistanceSS
+{
+ public:
+
+ void* operator new(size_t,void* anAddress)
+ {
+ return anAddress;
+ }
+ void* operator new(size_t size)
+ {
+ return Standard::Allocate(size);
+ }
+ void operator delete(void *anAddress)
+ {
+ if (anAddress) Standard::Free((Standard_Address&)anAddress);
+ }
+
+ //! computes the distance between two Shapes ( face edge vertex). <br>
+ Standard_EXPORT BRepExtrema_DistanceSS(const TopoDS_Shape& S1, const TopoDS_Shape& S2,
+ const Bnd_Box& B1, const Bnd_Box& B2,
+ const Standard_Real DstRef,
+ const Extrema_ExtFlag F = Extrema_ExtFlag_MINMAX,
+ const Extrema_ExtAlgo A = Extrema_ExtAlgo_Grad)
+ : myDstRef(DstRef), myModif(Standard_False), myEps(Precision::Confusion()), myFlag(F), myAlgo(A)
+ {
+ Perform(S1, S2, B1, B2);
+ }
+ //! computes the distance between two Shapes ( face edge vertex). <br>
+ //! Parameter theDeflection is used to specify a maximum deviation <br>
+ //! of extreme distances from the minimum one. <br>
+ //! Default value is Precision::Confusion(). <br>
+ Standard_EXPORT BRepExtrema_DistanceSS(const TopoDS_Shape& S1, const TopoDS_Shape& S2,
+ const Bnd_Box& B1, const Bnd_Box& B2,
+ const Standard_Real DstRef, const Standard_Real aDeflection,
+ const Extrema_ExtFlag F = Extrema_ExtFlag_MINMAX,
+ const Extrema_ExtAlgo A = Extrema_ExtAlgo_Grad)
+ : myDstRef(DstRef), myModif(Standard_False), myEps(aDeflection), myFlag(F), myAlgo(A)
+ {
+ Perform(S1, S2, B1, B2);
+ }
+ //! True if the distance has been computed <br>
+ Standard_EXPORT Standard_Boolean IsDone() const
+ {
+ return myModif;
+ }
+ //! returns the distance value <br>
+ Standard_EXPORT Standard_Real DistValue() const
+ {
+ return myDstRef;
+ }
+ //! returns the list of solutions on the first shape <br>
+ Standard_EXPORT const BRepExtrema_SeqOfSolution& Seq1Value() const
+ {
+ return SeqSolShape1;
+ }
+ //! returns the list of solutions on the second shape <br>
+ Standard_EXPORT const BRepExtrema_SeqOfSolution& Seq2Value() const
+ {
+ return SeqSolShape2;
+ }
+ //! sets the flag controlling minimum and maximum search
+ Standard_EXPORT void SetFlag(const Extrema_ExtFlag F)
+ {
+ myFlag = F;
+ }
+ //! sets the flag controlling ...
+ Standard_EXPORT void SetAlgo(const Extrema_ExtAlgo A)
+ {
+ myAlgo = A;
+ }
+
+ private:
+
+ //! computes the distance between two Shapes ( face edge vertex) <br>
+ void Perform(const TopoDS_Shape& S1,const TopoDS_Shape& S2,const Bnd_Box& B1,const Bnd_Box& B2);
+
+ //! computes the distance between two vertices <br>
+ void Perform(const TopoDS_Vertex& S1,const TopoDS_Vertex& S2);
+ //! computes the minimum distance between a vertex and an edge <br>
+ void Perform(const TopoDS_Vertex& S1,const TopoDS_Edge& S2,const Bnd_Box& B1,const Bnd_Box& B2);
+ //! computes the minimum distance between a vertex and a face <br>
+ void Perform(const TopoDS_Vertex& S1,const TopoDS_Face& S2,const Bnd_Box& B1,const Bnd_Box& B2);
+
+ //! computes the minimum distance between an edge and a vertex <br>
+ void Perform(const TopoDS_Edge& S1,const TopoDS_Vertex& S2,const Bnd_Box& B1,const Bnd_Box& B2)
+ {
+ Perform(S2, S1, B2, B1);
+ }
+ //! computes the minimum distance between two edges <br>
+ void Perform(const TopoDS_Edge& S1,const TopoDS_Edge& S2,const Bnd_Box& B1,const Bnd_Box& B2);
+ //! computes the minimum distance an edge and a face <br>
+ void Perform(const TopoDS_Edge& S1,const TopoDS_Face& S2,const Bnd_Box& B1,const Bnd_Box& B2);
+
+ //! computes the minimum distance betwwen a face and a vertex <br>
+ void Perform(const TopoDS_Face& S1,const TopoDS_Vertex& S2,const Bnd_Box& B1,const Bnd_Box& B2)
+ {
+ Perform(S2, S1, B2, B1);
+ }
+ //! computes the minimum distance between a face and an edge <br>
+ void Perform(const TopoDS_Face& S1,const TopoDS_Edge& S2,const Bnd_Box& B1,const Bnd_Box& B2)
+ {
+ Perform(S2, S1, B2, B1);
+ }
+ //! computes the minimum distance between two faces <br>
+ void Perform(const TopoDS_Face& S1,const TopoDS_Face& S2,const Bnd_Box& B1,const Bnd_Box& B2);
+
+ BRepExtrema_SeqOfSolution SeqSolShape1;
+ BRepExtrema_SeqOfSolution SeqSolShape2;
+ Standard_Real myDstRef;
+ Standard_Boolean myModif;
+ Standard_Real myEps;
+ Extrema_ExtFlag myFlag;
+ Extrema_ExtAlgo myAlgo;
+};
+
+#endif
// File: BRepExtrema_ExtCC.cxx
// Created: Wed Dec 15 16:48:53 1993
// Author: Christophe MARION
-// <cma@sdsun1>
-#include <BRepExtrema_ExtCC.ixx>
+#include <BRepExtrema_ExtCC.hxx>
+
#include <BRep_Tool.hxx>
-#include <StdFail_NotDone.hxx>
-#include <Standard_Failure.hxx>
#include <Extrema_POnCurv.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_HCurve.hxx>
//purpose :
//=======================================================================
-BRepExtrema_ExtCC::BRepExtrema_ExtCC()
-{
-}
-
-//=======================================================================
-//function : BRepExtrema_ExtCC
-//purpose :
-//=======================================================================
-
-BRepExtrema_ExtCC::BRepExtrema_ExtCC
- (const TopoDS_Edge& E1,
- const TopoDS_Edge& E2)
+BRepExtrema_ExtCC::BRepExtrema_ExtCC(const TopoDS_Edge& E1, const TopoDS_Edge& E2)
{
Initialize(E2);
Perform(E1);
BRepAdaptor_Curve Curv(E2);
myHC = new BRepAdaptor_HCurve(Curv);
BRep_Tool::Range(E2,V1,V2);
- myExtrem.SetCurve (2, myHC->Curve(),V1,V2);
+ myExtCC.SetCurve(2,myHC->Curve(),V1,V2);
}
//=======================================================================
BRepAdaptor_Curve Curv(E1);
Handle(BRepAdaptor_HCurve) HC = new BRepAdaptor_HCurve(Curv);
BRep_Tool::Range(E1,U1,U2);
- myExtrem.SetCurve (1, HC->Curve(), U1, U2);
- myExtrem.Perform();
-}
-
-//=======================================================================
-//function : IsDone
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepExtrema_ExtCC::IsDone()const
-{
- return myExtrem.IsDone();
-}
-
-//=======================================================================
-//function : NbExt
-//purpose :
-//=======================================================================
-
-Standard_Integer BRepExtrema_ExtCC::NbExt() const
-{
- return myExtrem.NbExt();
-}
-
-//=======================================================================
-//function : IsMin
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepExtrema_ExtCC::IsParallel() const
-{
- return myExtrem.IsParallel();
-}
-
-//=======================================================================
-//function : SquareDistance
-//purpose :
-//=======================================================================
-
-Standard_Real BRepExtrema_ExtCC::SquareDistance
- (const Standard_Integer N) const
-{
- return myExtrem.SquareDistance(N);
+ myExtCC.SetCurve (1, HC->Curve(), U1, U2);
+ myExtCC.Perform();
}
//=======================================================================
//purpose :
//=======================================================================
-Standard_Real BRepExtrema_ExtCC::ParameterOnE1
- (const Standard_Integer N) const
+Standard_Real BRepExtrema_ExtCC::ParameterOnE1(const Standard_Integer N) const
{
Extrema_POnCurv POnE1, POnE2;
- myExtrem.Points(N, POnE1, POnE2);
+ myExtCC.Points(N, POnE1, POnE2);
return POnE1.Parameter();
}
//purpose :
//=======================================================================
-gp_Pnt BRepExtrema_ExtCC::PointOnE1
- (const Standard_Integer N) const
+gp_Pnt BRepExtrema_ExtCC::PointOnE1(const Standard_Integer N) const
{
Extrema_POnCurv POnE1, POnE2;
- myExtrem.Points(N, POnE1, POnE2);
- gp_Pnt P = POnE1.Value();
- return P;
+ myExtCC.Points(N, POnE1, POnE2);
+ return POnE1.Value();
}
//=======================================================================
//purpose :
//=======================================================================
-Standard_Real BRepExtrema_ExtCC::ParameterOnE2
- (const Standard_Integer N) const
+Standard_Real BRepExtrema_ExtCC::ParameterOnE2(const Standard_Integer N) const
{
Extrema_POnCurv POnE1, POnE2;
- myExtrem.Points(N, POnE1, POnE2);
+ myExtCC.Points(N, POnE1, POnE2);
return POnE2.Parameter();
}
//purpose :
//=======================================================================
-gp_Pnt BRepExtrema_ExtCC::PointOnE2
- (const Standard_Integer N) const
+gp_Pnt BRepExtrema_ExtCC::PointOnE2(const Standard_Integer N) const
{
Extrema_POnCurv POnE1, POnE2;
- myExtrem.Points(N, POnE1, POnE2);
- gp_Pnt P = POnE2.Value();
- return P;
+ myExtCC.Points(N, POnE1, POnE2);
+ return POnE2.Value();
}
gp_Pnt& pnt21,
gp_Pnt& pnt22) const
{
- myExtrem.TrimmedSquareDistances(dist11,dist12,dist21, dist22,
- pnt11,pnt12, pnt21, pnt22);
+ myExtCC.TrimmedSquareDistances(dist11,dist12,dist21,dist22,
+ pnt11,pnt12,pnt21,pnt22);
}
-
--- /dev/null
+// This file is generated by WOK (CPPExt).
+// Please do not edit this file; modify original file instead.
+// The copyright and license terms as defined for the original file apply to
+// this header file considered to be the "object code" form of the original source.
+
+#ifndef _BRepExtrema_ExtCC_HeaderFile
+#define _BRepExtrema_ExtCC_HeaderFile
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#endif
+
+#ifndef _Extrema_ExtCC_HeaderFile
+#include <Extrema_ExtCC.hxx>
+#endif
+#ifndef _Handle_BRepAdaptor_HCurve_HeaderFile
+#include <Handle_BRepAdaptor_HCurve.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#endif
+class BRepAdaptor_HCurve;
+class TopoDS_Edge;
+class gp_Pnt;
+
+
+class BRepExtrema_ExtCC
+{
+ public:
+
+ void* operator new(size_t,void* anAddress)
+ {
+ return anAddress;
+ }
+ void* operator new(size_t size)
+ {
+ return Standard::Allocate(size);
+ }
+ void operator delete(void *anAddress)
+ {
+ if (anAddress) Standard::Free((Standard_Address&)anAddress);
+ }
+
+ Standard_EXPORT BRepExtrema_ExtCC()
+ {
+ }
+ //! It calculates all the distances. <br>
+ Standard_EXPORT BRepExtrema_ExtCC(const TopoDS_Edge& E1,const TopoDS_Edge& E2);
+
+ Standard_EXPORT void Initialize(const TopoDS_Edge& E2);
+ //! An exception is raised if the fields have not been initialized. <br>
+ Standard_EXPORT void Perform(const TopoDS_Edge& E1);
+ //! True if the distances are found. <br>
+ Standard_EXPORT Standard_Boolean IsDone() const
+ {
+ return myExtCC.IsDone();
+ }
+ //! Returns the number of extremum distances. <br>
+ Standard_EXPORT Standard_Integer NbExt() const
+ {
+ return myExtCC.NbExt();
+ }
+ //! Returns True if E1 and E2 are parallel. <br>
+ Standard_EXPORT Standard_Boolean IsParallel() const
+ {
+ return myExtCC.IsParallel();
+ }
+ //! Returns the value of the <N>th extremum square distance. <br>
+ Standard_EXPORT Standard_Real SquareDistance(const Standard_Integer N) const
+ {
+ return myExtCC.SquareDistance(N);
+ }
+ //! Returns the parameter on the first edge of the <N>th extremum distance. <br>
+ Standard_EXPORT Standard_Real ParameterOnE1(const Standard_Integer N) const;
+ //! Returns the Point of the <N>th extremum distance on the edge E1. <br>
+ Standard_EXPORT gp_Pnt PointOnE1(const Standard_Integer N) const;
+ //! Returns the parameter on the second edge of the <N>th extremum distance. <br>
+ Standard_EXPORT Standard_Real ParameterOnE2(const Standard_Integer N) const;
+ //! Returns the Point of the <N>th extremum distance on the edge E2. <br>
+ Standard_EXPORT gp_Pnt PointOnE2(const Standard_Integer N) const;
+ //! if the edges is a trimmed curve, <br>
+ //! dist11 is a square distance between the point on E1 <br>
+ //! of parameter FirstParameter and the point of <br>
+ //! parameter FirstParameter on E2. <br>
+ Standard_EXPORT void TrimmedSquareDistances(Standard_Real& dist11,Standard_Real& distP12,Standard_Real& distP21,Standard_Real& distP22,gp_Pnt& P11,gp_Pnt& P12,gp_Pnt& P21,gp_Pnt& P22) const;
+
+ private:
+
+ Extrema_ExtCC myExtCC;
+ Handle_BRepAdaptor_HCurve myHC;
+};
+
+#endif
// File: BRepExtrema_ExtCF.cxx
// Created: Wed Dec 15 16:48:53 1993
// Author: Christophe MARION
-// <cma@sdsun1>
-#include <BRepExtrema_ExtCF.ixx>
+#include <BRepExtrema_ExtCF.hxx>
+
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
#include <Geom_Curve.hxx>
-#include <StdFail_NotDone.hxx>
-#include <Standard_Failure.hxx>
#include <BRepClass_FaceClassifier.hxx>
-#include <GeomAdaptor_Surface.hxx>
-#include <Extrema_POnCurv.hxx>
-#include <Extrema_POnSurf.hxx>
#include <gp_Pnt2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepAdaptor_HSurface.hxx>
//purpose :
//=======================================================================
-BRepExtrema_ExtCF::BRepExtrema_ExtCF()
-{
-}
-
-//=======================================================================
-//function : BRepExtrema_ExtCF
-//purpose :
-//=======================================================================
-
-BRepExtrema_ExtCF::BRepExtrema_ExtCF
- (const TopoDS_Edge& E,
- const TopoDS_Face& F)
+BRepExtrema_ExtCF::BRepExtrema_ExtCF(const TopoDS_Edge& E, const TopoDS_Face& F)
{
Initialize(F);
Perform(E, F);
{
BRepAdaptor_Surface Surf(F2);
myHS = new BRepAdaptor_HSurface(Surf);
- Standard_Real Tol = BRep_Tool::Tolerance(F2);
+ const Standard_Real Tol = BRep_Tool::Tolerance(F2);
Standard_Real U1, U2, V1, V2;
BRepTools::UVBounds(F2, U1, U2, V1, V2);
- myExtrem.Initialize(myHS->Surface(), U1, U2, V1, V2, Tol, Tol);
+ myExtCS.Initialize(myHS->Surface(), U1, U2, V1, V2, Tol, Tol);
}
//=======================================================================
//purpose :
//=======================================================================
-void BRepExtrema_ExtCF::Perform(const TopoDS_Edge& E,
- const TopoDS_Face& F2)
+void BRepExtrema_ExtCF::Perform(const TopoDS_Edge& E, const TopoDS_Face& F2)
{
mySqDist.Clear();
myPointsOnS.Clear();
myPointsOnC.Clear();
+
Standard_Real U1, U2;
BRep_Tool::Range(E, U1, U2);
BRepAdaptor_Curve Curv(E);
Handle(BRepAdaptor_HCurve) HC = new BRepAdaptor_HCurve(Curv);
- myExtrem.Perform(HC->Curve(), U1, U2);
-
- // exploration des points et classification:
- BRepClass_FaceClassifier classifier;
- gp_Pnt2d Puv;
- TopAbs_State state;
- Standard_Real Tol = BRep_Tool::Tolerance(F2);
- Extrema_POnCurv P1;
- Extrema_POnSurf P2;
- mynbext = 0;
+ myExtCS.Perform(HC->Curve(), U1, U2);
- if(!myExtrem.IsDone())
+ if(!myExtCS.IsDone())
return;
- if (myExtrem.IsParallel()) {
- mySqDist.Append(myExtrem.SquareDistance(1));
- mynbext = 1;
- }
- else {
- for (Standard_Integer i = 1; i <= myExtrem.NbExt(); i++) {
- myExtrem.Points(i, P1, P2);
+ if (myExtCS.IsParallel())
+ mySqDist.Append(myExtCS.SquareDistance(1));
+ else
+ {
+ // Exploration of points and classification
+ BRepClass_FaceClassifier classifier;
+ const Standard_Real Tol = BRep_Tool::Tolerance(F2);
+ Extrema_POnCurv P1;
+ Extrema_POnSurf P2;
+
+ for (Standard_Integer i = 1; i <= myExtCS.NbExt(); i++)
+ {
+ myExtCS.Points(i, P1, P2);
P2.Parameter(U1, U2);
- Puv.SetCoord(U1, U2);
+ const gp_Pnt2d Puv(U1, U2);
classifier.Perform(F2, Puv, Tol);
- state = classifier.State();
- if(state == TopAbs_ON || state == TopAbs_IN) {
- mynbext++;
- mySqDist.Append(myExtrem.SquareDistance(i));
- myPointsOnC.Append(P1);
- myPointsOnS.Append(P2);
+ const TopAbs_State state = classifier.State();
+ if (state == TopAbs_ON || state == TopAbs_IN)
+ {
+ mySqDist.Append(myExtCS.SquareDistance(i));
+ myPointsOnC.Append(P1);
+ myPointsOnS.Append(P2);
}
}
}
}
-//=======================================================================
-//function : IsDone
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepExtrema_ExtCF::IsDone()const
-{
- return myExtrem.IsDone();
-}
-
-
-//=======================================================================
-//function : IsParallel
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepExtrema_ExtCF::IsParallel()const
-{
- return myExtrem.IsParallel();
-}
-
-//=======================================================================
-//function : NbExt
-//purpose :
-//=======================================================================
-
-Standard_Integer BRepExtrema_ExtCF::NbExt() const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- return mynbext;
-}
-
-
-//=======================================================================
-//function : SquareDistance
-//purpose :
-//=======================================================================
-
-Standard_Real BRepExtrema_ExtCF::SquareDistance
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- return mySqDist.Value(N);
-}
-
-//=======================================================================
-//function : ParameterOnFace
-//purpose :
-//=======================================================================
-
-void BRepExtrema_ExtCF::ParameterOnFace(const Standard_Integer N,
- Standard_Real& U,
- Standard_Real& V) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- myPointsOnS.Value(N).Parameter(U, V);
-}
-
-//=======================================================================
-//function : ParameterOnEdge
-//purpose :
-//=======================================================================
-
-Standard_Real BRepExtrema_ExtCF::ParameterOnEdge
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- return myPointsOnC.Value(N).Parameter();
-}
-
-//=======================================================================
-//function : PointOnEdge
-//purpose :
-//=======================================================================
-
-gp_Pnt BRepExtrema_ExtCF::PointOnEdge
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- gp_Pnt P = myPointsOnC.Value(N).Value();
- return P;
-}
-
-//=======================================================================
-//function : PointOnFace
-//purpose :
-//=======================================================================
-
-gp_Pnt BRepExtrema_ExtCF::PointOnFace
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- gp_Pnt P = myPointsOnS.Value(N).Value();
- return P;
-}
-
--- /dev/null
+// This file is generated by WOK (CPPExt).
+// Please do not edit this file; modify original file instead.
+// The copyright and license terms as defined for the original file apply to
+// this header file considered to be the "object code" form of the original source.
+
+#ifndef _BRepExtrema_ExtCF_HeaderFile
+#define _BRepExtrema_ExtCF_HeaderFile
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#endif
+
+#ifndef _Extrema_ExtCS_HeaderFile
+#include <Extrema_ExtCS.hxx>
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _TColStd_SequenceOfReal_HeaderFile
+#include <TColStd_SequenceOfReal.hxx>
+#endif
+#ifndef _Extrema_SequenceOfPOnSurf_HeaderFile
+#include <Extrema_SequenceOfPOnSurf.hxx>
+#endif
+#ifndef _Extrema_SequenceOfPOnCurv_HeaderFile
+#include <Extrema_SequenceOfPOnCurv.hxx>
+#endif
+#ifndef _Handle_BRepAdaptor_HSurface_HeaderFile
+#include <Handle_BRepAdaptor_HSurface.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#endif
+#ifndef _Extrema_POnCurv_HeaderFile
+#include <Extrema_POnCurv.hxx>
+#endif
+#ifndef _Extrema_POnSurf_HeaderFile
+#include <Extrema_POnSurf.hxx>
+#endif
+class BRepAdaptor_HSurface;
+class TopoDS_Edge;
+class TopoDS_Face;
+class gp_Pnt;
+
+
+class BRepExtrema_ExtCF
+{
+ public:
+
+ void* operator new(size_t,void* anAddress)
+ {
+ return anAddress;
+ }
+ void* operator new(size_t size)
+ {
+ return Standard::Allocate(size);
+ }
+ void operator delete(void *anAddress)
+ {
+ if (anAddress) Standard::Free((Standard_Address&)anAddress);
+ }
+
+ Standard_EXPORT BRepExtrema_ExtCF()
+ {
+ }
+ //! It calculates all the distances. <br>
+ Standard_EXPORT BRepExtrema_ExtCF(const TopoDS_Edge& V,const TopoDS_Face& E);
+
+ Standard_EXPORT void Initialize(const TopoDS_Face& E);
+ //! An exception is raised if the fields have not been initialized. <br>
+ //! Be careful: this method uses the Face only for classify not for the fields. <br>
+ Standard_EXPORT void Perform(const TopoDS_Edge& V,const TopoDS_Face& F);
+ //! True if the distances are found. <br>
+ Standard_EXPORT Standard_Boolean IsDone() const
+ {
+ return myExtCS.IsDone();
+ }
+ //! Returns the number of extremum distances. <br>
+ Standard_EXPORT Standard_Integer NbExt() const
+ {
+ return mySqDist.Length();
+ }
+ //! Returns the value of the <N>th extremum square distance. <br>
+ Standard_EXPORT Standard_Real SquareDistance(const Standard_Integer N) const
+ {
+ return mySqDist.Value(N);
+ }
+ //! Returns True if the curve is on a parallel surface. <br>
+ Standard_EXPORT Standard_Boolean IsParallel() const
+ {
+ return myExtCS.IsParallel();
+ }
+ //! Returns the parameters on the Edge of the <N>th extremum distance. <br>
+ Standard_EXPORT Standard_Real ParameterOnEdge(const Standard_Integer N) const
+ {
+ return myPointsOnC.Value(N).Parameter();
+ }
+ //! Returns the parameters on the Face of the <N>th extremum distance. <br>
+ Standard_EXPORT void ParameterOnFace(const Standard_Integer N,Standard_Real& U,Standard_Real& V) const
+ {
+ myPointsOnS.Value(N).Parameter(U, V);
+ }
+ //! Returns the Point of the <N>th extremum distance. <br>
+ Standard_EXPORT gp_Pnt PointOnEdge(const Standard_Integer N) const
+ {
+ return myPointsOnC.Value(N).Value();
+ }
+ //! Returns the Point of the <N>th extremum distance. <br>
+ Standard_EXPORT gp_Pnt PointOnFace(const Standard_Integer N) const
+ {
+ return myPointsOnS.Value(N).Value();
+ }
+
+ private:
+
+ Extrema_ExtCS myExtCS;
+ TColStd_SequenceOfReal mySqDist;
+ Extrema_SequenceOfPOnSurf myPointsOnS;
+ Extrema_SequenceOfPOnCurv myPointsOnC;
+ Handle_BRepAdaptor_HSurface myHS;
+};
+
+#endif
// File: BRepExtrema_ExtFF.cxx
// Created: Wed Dec 15 16:48:53 1993
// Author: Christophe MARION
-// <cma@sdsun1>
// modified by mps (juillet 96 ): on utilise BRepAdaptor a la place de
// GeomAdaptor dans Initialize et Perform.
-#include <BRepExtrema_ExtFF.ixx>
+
+#include <BRepExtrema_ExtFF.hxx>
+
#include <BRepExtrema_ExtCF.hxx>
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
-#include <Geom_Curve.hxx>
-#include <StdFail_NotDone.hxx>
-#include <Standard_Failure.hxx>
#include <BRepClass_FaceClassifier.hxx>
-#include <TopoDS.hxx>
-#include <TopAbs_ShapeEnum.hxx>
-#include <TopExp_Explorer.hxx>
-#include <Geom_Surface.hxx>
-#include <Extrema_POnSurf.hxx>
#include <gp_Pnt2d.hxx>
#include <Precision.hxx>
#include <BRepAdaptor_HSurface.hxx>
//purpose :
//=======================================================================
-BRepExtrema_ExtFF::BRepExtrema_ExtFF()
-{
-}
-
-//=======================================================================
-//function : BRepExtrema_ExtFF
-//purpose :
-//=======================================================================
-
-BRepExtrema_ExtFF::BRepExtrema_ExtFF
- (const TopoDS_Face& F1,
- const TopoDS_Face& F2)
+BRepExtrema_ExtFF::BRepExtrema_ExtFF(const TopoDS_Face& F1, const TopoDS_Face& F2)
{
Initialize(F2);
Perform(F1,F2);
}
+
//=======================================================================
//function : Initialize
//purpose :
{
BRepAdaptor_Surface Surf(F2);
myHS = new BRepAdaptor_HSurface(Surf);
- Standard_Real Tol = BRep_Tool::Tolerance(F2);
+ const Standard_Real Tol = BRep_Tool::Tolerance(F2);
Standard_Real U1, U2, V1, V2;
BRepTools::UVBounds(F2, U1, U2, V1, V2);
- myExtrem.Initialize(myHS->Surface(), U1, U2, V1, V2, Tol);
-
+ myExtSS.Initialize(myHS->Surface(), U1, U2, V1, V2, Tol);
}
//=======================================================================
//purpose :
//=======================================================================
-void BRepExtrema_ExtFF::Perform(const TopoDS_Face& F1,
- const TopoDS_Face& F2)
+void BRepExtrema_ExtFF::Perform(const TopoDS_Face& F1, const TopoDS_Face& F2)
{
- Standard_Real U1, U2, V1, V2;
- Standard_Integer i;
mySqDist.Clear();
myPointsOnS1.Clear();
myPointsOnS2.Clear();
+
BRepAdaptor_Surface Surf1(F1);
Handle(BRepAdaptor_HSurface) HS1 = new BRepAdaptor_HSurface(Surf1);
- Standard_Real Tol1 = BRep_Tool::Tolerance(F1);
+ const Standard_Real Tol1 = BRep_Tool::Tolerance(F1);
+ Standard_Real U1, U2, V1, V2;
BRepTools::UVBounds(F1, U1, U2, V1, V2);
- myExtrem.Perform(HS1->Surface(), U1, U2, V1, V2, Tol1);
-
-
- // exploration des points et classification:
- BRepClass_FaceClassifier classifier;
- gp_Pnt2d Puv;
- TopAbs_State state1, state2;
- Standard_Real Tol2 = BRep_Tool::Tolerance(F2);
- Extrema_POnSurf P1, P2;
- mynbext = 0;
-
- if (myExtrem.IsParallel()) {
- mySqDist.Append(myExtrem.SquareDistance(1));
- mynbext = 1;
- }
- else {
- for (i = 1; i <= myExtrem.NbExt(); i++) {
- myExtrem.Points(i, P1, P2);
+ myExtSS.Perform(HS1->Surface(), U1, U2, V1, V2, Tol1);
+
+ if (!myExtSS.IsDone())
+ return;
+
+ if (myExtSS.IsParallel())
+ mySqDist.Append(myExtSS.SquareDistance(1));
+ else
+ {
+ // Exploration of points and classification
+ BRepClass_FaceClassifier classifier;
+ const Standard_Real Tol2 = BRep_Tool::Tolerance(F2);
+ Extrema_POnSurf P1, P2;
+
+ Standard_Integer i;
+ for (i = 1; i <= myExtSS.NbExt(); i++)
+ {
+ myExtSS.Points(i, P1, P2);
P1.Parameter(U1, U2);
- Puv.SetCoord(U1, U2);
- classifier.Perform(F1, Puv, Tol1);
- state1 = classifier.State();
- P2.Parameter(U1, U2);
- Puv.SetCoord(U1, U2);
- classifier.Perform(F2, Puv, Tol2);
- state2 = classifier.State();
- if((state1 == TopAbs_ON || state1 == TopAbs_IN) &&
- (state2 == TopAbs_ON || state2 == TopAbs_IN)) {
- mynbext++;
- mySqDist.Append(myExtrem.SquareDistance(i));
- myPointsOnS1.Append(P1);
- myPointsOnS2.Append(P2);
+ const gp_Pnt2d Puv1(U1, U2);
+ classifier.Perform(F1, Puv1, Tol1);
+ const TopAbs_State state1 = classifier.State();
+ if (state1 == TopAbs_ON || state1 == TopAbs_IN)
+ {
+ P2.Parameter(U1, U2);
+ const gp_Pnt2d Puv2(U1, U2);
+ classifier.Perform(F2, Puv2, Tol2);
+ const TopAbs_State state2 = classifier.State();
+ if (state2 == TopAbs_ON || state2 == TopAbs_IN)
+ {
+ mySqDist.Append(myExtSS.SquareDistance(i));
+ myPointsOnS1.Append(P1);
+ myPointsOnS2.Append(P2);
+ }
}
}
}
}
-
-//=======================================================================
-//function : IsDone
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepExtrema_ExtFF::IsDone()const
-{
- return myExtrem.IsDone();
-}
-
-//=======================================================================
-//function : IsParallel
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepExtrema_ExtFF::IsParallel()const
-{
- return myExtrem.IsParallel();
-}
-
-
-//=======================================================================
-//function : NbExt
-//purpose :
-//=======================================================================
-
-Standard_Integer BRepExtrema_ExtFF::NbExt() const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- return mynbext;
-}
-
-
-//=======================================================================
-//function : SquareDistance
-//purpose :
-//=======================================================================
-
-Standard_Real BRepExtrema_ExtFF::SquareDistance
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- return mySqDist.Value(N);
-}
-
-//=======================================================================
-//function : ParameterOnFace1
-//purpose :
-//=======================================================================
-
-void BRepExtrema_ExtFF::ParameterOnFace1(const Standard_Integer N,
- Standard_Real& U,
- Standard_Real& V) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- myPointsOnS1.Value(N).Parameter(U, V);
-}
-
-//=======================================================================
-//function : PointOnFace1
-//purpose :
-//=======================================================================
-
-gp_Pnt BRepExtrema_ExtFF::PointOnFace1
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- gp_Pnt P = myPointsOnS1.Value(N).Value();
- return P;
-}
-
-
-//=======================================================================
-//function : ParameterOnFace2
-//purpose :
-//=======================================================================
-
-void BRepExtrema_ExtFF::ParameterOnFace2(const Standard_Integer N,
- Standard_Real& U,
- Standard_Real& V) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- myPointsOnS2.Value(N).Parameter(U, V);
-}
-
-//=======================================================================
-//function : PointOnFace1
-//purpose :
-//=======================================================================
-
-gp_Pnt BRepExtrema_ExtFF::PointOnFace2
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- gp_Pnt P = myPointsOnS2.Value(N).Value();
- return P;
-}
-
-
--- /dev/null
+// This file is generated by WOK (CPPExt).
+// Please do not edit this file; modify original file instead.
+// The copyright and license terms as defined for the original file apply to
+// this header file considered to be the "object code" form of the original source.
+
+#ifndef _BRepExtrema_ExtFF_HeaderFile
+#define _BRepExtrema_ExtFF_HeaderFile
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#endif
+
+#ifndef _Extrema_ExtSS_HeaderFile
+#include <Extrema_ExtSS.hxx>
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _TColStd_SequenceOfReal_HeaderFile
+#include <TColStd_SequenceOfReal.hxx>
+#endif
+#ifndef _Extrema_SequenceOfPOnSurf_HeaderFile
+#include <Extrema_SequenceOfPOnSurf.hxx>
+#endif
+#ifndef _Handle_BRepAdaptor_HSurface_HeaderFile
+#include <Handle_BRepAdaptor_HSurface.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#endif
+#ifndef _Extrema_POnSurf_HeaderFile
+#include <Extrema_POnSurf.hxx>
+#endif
+class BRepAdaptor_HSurface;
+class TopoDS_Face;
+class gp_Pnt;
+
+
+
+class BRepExtrema_ExtFF
+{
+ public:
+
+ void* operator new(size_t,void* anAddress)
+ {
+ return anAddress;
+ }
+ void* operator new(size_t size)
+ {
+ return Standard::Allocate(size);
+ }
+ void operator delete(void *anAddress)
+ {
+ if (anAddress) Standard::Free((Standard_Address&)anAddress);
+ }
+
+
+ Standard_EXPORT BRepExtrema_ExtFF()
+ {
+ }
+ //! It calculates all the distances. <br>
+ Standard_EXPORT BRepExtrema_ExtFF(const TopoDS_Face& F1,const TopoDS_Face& F2);
+
+ Standard_EXPORT void Initialize(const TopoDS_Face& F2) ;
+ //! An exception is raised if the fields have not been initialized. <br>
+ //! Be careful: this method uses the Face F2 only for classify, not for the fields. <br>
+ Standard_EXPORT void Perform(const TopoDS_Face& F1,const TopoDS_Face& F2);
+ //! True if the distances are found. <br>
+ Standard_EXPORT Standard_Boolean IsDone() const
+ {
+ return myExtSS.IsDone();
+ }
+ //! Returns True if the surfaces are parallel. <br>
+ Standard_EXPORT Standard_Boolean IsParallel() const
+ {
+ return myExtSS.IsParallel();
+ }
+ //! Returns the number of extremum distances. <br>
+ Standard_EXPORT Standard_Integer NbExt() const
+ {
+ return mySqDist.Length();
+ }
+ //! Returns the value of the <N>th extremum square distance. <br>
+ Standard_EXPORT Standard_Real SquareDistance(const Standard_Integer N) const
+ {
+ return mySqDist.Value(N);
+ }
+ //! Returns the parameters on the Face F1 of the <N>th extremum distance. <br>
+ Standard_EXPORT void ParameterOnFace1(const Standard_Integer N,Standard_Real& U,Standard_Real& V) const
+ {
+ myPointsOnS1.Value(N).Parameter(U, V);
+ }
+ //! Returns the parameters on the Face F2 of the <N>th extremum distance. <br>
+ Standard_EXPORT void ParameterOnFace2(const Standard_Integer N,Standard_Real& U,Standard_Real& V) const
+ {
+ myPointsOnS2.Value(N).Parameter(U, V);
+ }
+ //! Returns the Point of the <N>th extremum distance. <br>
+ Standard_EXPORT gp_Pnt PointOnFace1(const Standard_Integer N) const
+ {
+ return myPointsOnS1.Value(N).Value();
+ }
+ //! Returns the Point of the <N>th extremum distance. <br>
+ Standard_EXPORT gp_Pnt PointOnFace2(const Standard_Integer N) const
+ {
+ return myPointsOnS2.Value(N).Value();
+ }
+
+ private:
+
+ Extrema_ExtSS myExtSS;
+ TColStd_SequenceOfReal mySqDist;
+ Extrema_SequenceOfPOnSurf myPointsOnS1;
+ Extrema_SequenceOfPOnSurf myPointsOnS2;
+ Handle_BRepAdaptor_HSurface myHS;
+};
+
+#endif
// File: BRepExtrema_ExtPC.cxx
// Created: Wed Dec 15 16:48:53 1993
// Author: Christophe MARION
-// <cma@sdsun1>
-#include <BRepExtrema_ExtPC.ixx>
+#include <BRepExtrema_ExtPC.hxx>
+
#include <BRep_Tool.hxx>
-#include <StdFail_NotDone.hxx>
-#include <Standard_Failure.hxx>
+//#include <StdFail_NotDone.hxx>
+//#include <Standard_Failure.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_HCurve.hxx>
//purpose :
//=======================================================================
-BRepExtrema_ExtPC::BRepExtrema_ExtPC()
-{
-}
-
-//=======================================================================
-//function : BRepExtrema_ExtPC
-//purpose :
-//=======================================================================
-
-BRepExtrema_ExtPC::BRepExtrema_ExtPC
- (const TopoDS_Vertex& V,
- const TopoDS_Edge& E)
+BRepExtrema_ExtPC::BRepExtrema_ExtPC(const TopoDS_Vertex& V, const TopoDS_Edge& E)
{
Initialize(E);
Perform(V);
BRepAdaptor_Curve Curv(E);
myHC = new BRepAdaptor_HCurve(Curv);
BRep_Tool::Range(E,U1,U2);
- myExtrem.Initialize(myHC->Curve(),U1,U2);
+ myExtPC.Initialize(myHC->Curve(),U1,U2);
}
//=======================================================================
void BRepExtrema_ExtPC::Perform(const TopoDS_Vertex& V)
{
gp_Pnt P = BRep_Tool::Pnt(V);
- myExtrem.Perform(P);
-}
-
-//=======================================================================
-//function : IsDone
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepExtrema_ExtPC::IsDone()const
-{
- return myExtrem.IsDone();
-}
-
-//=======================================================================
-//function : NbExt
-//purpose :
-//=======================================================================
-
-Standard_Integer BRepExtrema_ExtPC::NbExt() const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- return myExtrem.NbExt();
-}
-
-//=======================================================================
-//function : IsMin
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepExtrema_ExtPC::IsMin
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > myExtrem.NbExt())) Standard_OutOfRange::Raise();
- return myExtrem.IsMin(N);
+ myExtPC.Perform(P);
}
-
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
-
-Standard_Real BRepExtrema_ExtPC::SquareDistance
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > myExtrem.NbExt())) Standard_OutOfRange::Raise();
- return myExtrem.SquareDistance(N);
-}
-
-//=======================================================================
-//function : Parameter
-//purpose :
-//=======================================================================
-
-Standard_Real BRepExtrema_ExtPC::Parameter
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > myExtrem.NbExt())) Standard_OutOfRange::Raise();
- return myExtrem.Point(N).Parameter();
-}
-
-//=======================================================================
-//function : Point
-//purpose :
-//=======================================================================
-
-gp_Pnt BRepExtrema_ExtPC::Point
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > myExtrem.NbExt())) Standard_OutOfRange::Raise();
- return (myExtrem.Point(N).Value());
-}
-
-//=======================================================================
-//function : TrimmedDistances
-//purpose :
-//=======================================================================
-
-void BRepExtrema_ExtPC::TrimmedSquareDistances
- (Standard_Real& dist1,
- Standard_Real& dist2,
- gp_Pnt& pnt1,
- gp_Pnt& pnt2) const
-{
- myExtrem.TrimmedSquareDistances(dist1,dist2,pnt1,pnt2);
-}
-
--- /dev/null
+// This file is generated by WOK (CPPExt).
+// Please do not edit this file; modify original file instead.
+// The copyright and license terms as defined for the original file apply to
+// this header file considered to be the "object code" form of the original source.
+
+#ifndef _BRepExtrema_ExtPC_HeaderFile
+#define _BRepExtrema_ExtPC_HeaderFile
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#endif
+
+#ifndef _Extrema_ExtPC_HeaderFile
+#include <Extrema_ExtPC.hxx>
+#endif
+#ifndef _Handle_BRepAdaptor_HCurve_HeaderFile
+#include <Handle_BRepAdaptor_HCurve.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#endif
+class BRepAdaptor_HCurve;
+class TopoDS_Vertex;
+class TopoDS_Edge;
+class gp_Pnt;
+
+
+class BRepExtrema_ExtPC
+{
+ public:
+
+ void* operator new(size_t,void* anAddress)
+ {
+ return anAddress;
+ }
+ void* operator new(size_t size)
+ {
+ return Standard::Allocate(size);
+ }
+ void operator delete(void *anAddress)
+ {
+ if (anAddress) Standard::Free((Standard_Address&)anAddress);
+ }
+
+
+ Standard_EXPORT BRepExtrema_ExtPC()
+ {
+ }
+ //! It calculates all the distances. <br>
+ Standard_EXPORT BRepExtrema_ExtPC(const TopoDS_Vertex& V,const TopoDS_Edge& E);
+
+ Standard_EXPORT void Initialize(const TopoDS_Edge& E);
+ //! An exception is raised if the fields have not been initialized. <br>
+ Standard_EXPORT void Perform(const TopoDS_Vertex& V);
+ //! True if the distances are found. <br>
+ Standard_EXPORT Standard_Boolean IsDone() const
+ {
+ return myExtPC.IsDone();
+ }
+ //! Returns the number of extremum distances. <br>
+ Standard_EXPORT Standard_Integer NbExt() const
+ {
+ return myExtPC.NbExt();
+ }
+ //! Returns True if the <N>th extremum distance is a minimum. <br>
+ Standard_EXPORT Standard_Boolean IsMin(const Standard_Integer N) const
+ {
+ return myExtPC.IsMin(N);
+ }
+ //! Returns the value of the <N>th extremum square distance. <br>
+ Standard_EXPORT Standard_Real SquareDistance(const Standard_Integer N) const
+ {
+ return myExtPC.SquareDistance(N);
+ }
+ //! Returns the parameter on the edge of the <N>th extremum distance. <br>
+ Standard_EXPORT Standard_Real Parameter(const Standard_Integer N) const
+ {
+ return myExtPC.Point(N).Parameter();
+ }
+ //! Returns the Point of the <N>th extremum distance. <br>
+ Standard_EXPORT gp_Pnt Point(const Standard_Integer N) const
+ {
+ return myExtPC.Point(N).Value();
+ }
+ //! if the curve is a trimmed curve, <br>
+ //! dist1 is a square distance between <P> and the point <br>
+ //! of parameter FirstParameter <pnt1> and <br>
+ //! dist2 is a square distance between <P> and the point <br>
+ //! of parameter LastParameter <pnt2>. <br>
+ Standard_EXPORT void TrimmedSquareDistances(Standard_Real& dist1,Standard_Real& dist2,gp_Pnt& pnt1,gp_Pnt& pnt2) const
+ {
+ myExtPC.TrimmedSquareDistances(dist1,dist2,pnt1,pnt2);
+ }
+
+ private:
+
+ Extrema_ExtPC myExtPC;
+ Handle_BRepAdaptor_HCurve myHC;
+};
+
+#endif
// File: BRepExtrema_ExtPF.cxx
// Created: Wed Dec 15 16:48:53 1993
// Author: Christophe MARION
-// <cma@sdsun1>
// modified by MPS (june 96) : on utilise BRepClass_FaceClassifier seulement
// si IsDone de Extrema est vrai
-#include <BRepExtrema_ExtPF.ixx>
+
+#include <BRepExtrema_ExtPF.hxx>
+
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
-#include <StdFail_NotDone.hxx>
-#include <Standard_Failure.hxx>
#include <BRepClass_FaceClassifier.hxx>
#include <gp_Pnt2d.hxx>
-#include <BRepAdaptor_Curve.hxx>
-#include <BRepAdaptor_HCurve.hxx>
#include <BRepAdaptor_Surface.hxx>
-#include <BRepAdaptor_HSurface.hxx>
-
-//=======================================================================
-//function : BRepExtrema_ExtPF
-//purpose :
-//=======================================================================
-
-BRepExtrema_ExtPF::BRepExtrema_ExtPF()
-{
-}
//=======================================================================
//function : BRepExtrema_ExtPF
//purpose :
//=======================================================================
-BRepExtrema_ExtPF::BRepExtrema_ExtPF
- (const TopoDS_Vertex& V,
- const TopoDS_Face& E)
+BRepExtrema_ExtPF::BRepExtrema_ExtPF(const TopoDS_Vertex& TheVertex, const TopoDS_Face& TheFace,
+ const Extrema_ExtFlag TheFlag, const Extrema_ExtAlgo TheAlgo)
{
- Initialize(E);
- Perform(V, E);
+ Initialize(TheFace,TheFlag,TheAlgo);
+ Perform(TheVertex,TheFace);
}
//=======================================================================
//purpose :
//=======================================================================
-void BRepExtrema_ExtPF::Initialize(const TopoDS_Face& F)
+void BRepExtrema_ExtPF::Initialize(const TopoDS_Face& TheFace,
+ const Extrema_ExtFlag TheFlag, const Extrema_ExtAlgo TheAlgo)
{
// cette surface doit etre en champ. Extrema ne fait
// pas de copie et prend seulement un pointeur dessus.
- mySurf.Initialize(F, Standard_False);
- Standard_Real Tol = BRep_Tool::Tolerance(F);
+ mySurf.Initialize(TheFace, Standard_False);
+ const Standard_Real Tol = BRep_Tool::Tolerance(TheFace);
Standard_Real U1, U2, V1, V2;
- BRepTools::UVBounds(F, U1, U2, V1, V2);
- myExtrem.Initialize(mySurf, U1, U2, V1, V2, Tol, Tol);
+ BRepTools::UVBounds(TheFace, U1, U2, V1, V2);
+ myExtPS.SetFlag(TheFlag);
+ myExtPS.SetAlgo(TheAlgo);
+ myExtPS.Initialize(mySurf, U1, U2, V1, V2, Tol, Tol);
}
//=======================================================================
//purpose :
//=======================================================================
-void BRepExtrema_ExtPF::Perform(const TopoDS_Vertex& V,
- const TopoDS_Face& E)
+void BRepExtrema_ExtPF::Perform(const TopoDS_Vertex& TheVertex, const TopoDS_Face& TheFace)
{
mySqDist.Clear();
myPoints.Clear();
- gp_Pnt P = BRep_Tool::Pnt(V);
- myExtrem.Perform(P);
- // exploration des points et classification:
- if (myExtrem.IsDone()) {
- BRepClass_FaceClassifier classifier;
- gp_Pnt2d Puv;
- Standard_Real U1, U2;
- TopAbs_State state;
- Standard_Real Tol = BRep_Tool::Tolerance(E);
- mynbext = 0;
- for (Standard_Integer i = 1; i <= myExtrem.NbExt(); i++) {
- myExtrem.Point(i).Parameter(U1, U2);
- Puv.SetCoord(U1, U2);
- classifier.Perform(E, Puv, Tol);
- state = classifier.State();
- if(state == TopAbs_ON || state == TopAbs_IN) {
- mynbext++;
- mySqDist.Append(myExtrem.SquareDistance(i));
- myPoints.Append(myExtrem.Point(i));
+ const gp_Pnt P = BRep_Tool::Pnt(TheVertex);
+ myExtPS.Perform(P);
+
+ // Exploration of points and classification
+ if (myExtPS.IsDone())
+ {
+ BRepClass_FaceClassifier classifier;
+ Standard_Real U1, U2;
+ const Standard_Real Tol = BRep_Tool::Tolerance(TheFace);
+ for (Standard_Integer i = 1; i <= myExtPS.NbExt(); i++)
+ {
+ myExtPS.Point(i).Parameter(U1, U2);
+ const gp_Pnt2d Puv(U1, U2);
+ classifier.Perform(TheFace, Puv, Tol);
+ const TopAbs_State state = classifier.State();
+ if(state == TopAbs_ON || state == TopAbs_IN)
+ {
+ mySqDist.Append(myExtPS.SquareDistance(i));
+ myPoints.Append(myExtPS.Point(i));
+ }
}
}
- }
-}
-//=======================================================================
-//function : IsDone
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepExtrema_ExtPF::IsDone()const
-{
- return myExtrem.IsDone();
-}
-
-//=======================================================================
-//function : NbExt
-//purpose :
-//=======================================================================
-
-Standard_Integer BRepExtrema_ExtPF::NbExt() const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- return mynbext;
-}
-
-
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
-
-Standard_Real BRepExtrema_ExtPF::SquareDistance
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- return mySqDist.Value(N);
-}
-
-//=======================================================================
-//function : Parameters
-//purpose :
-//=======================================================================
-
-
-void BRepExtrema_ExtPF::Parameter(const Standard_Integer N,
- Standard_Real& U,
- Standard_Real& V) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- myPoints.Value(N).Parameter(U, V);
-}
-
-//=======================================================================
-//function : Point
-//purpose :
-//=======================================================================
-
-gp_Pnt BRepExtrema_ExtPF::Point
- (const Standard_Integer N) const
-{
- if(!myExtrem.IsDone()) StdFail_NotDone::Raise();
- if ((N < 1) || (N > mynbext)) Standard_OutOfRange::Raise();
- gp_Pnt P = myPoints.Value(N).Value();
- return P;
}
--- /dev/null
+// File generated by CPPExt (Value)
+//
+// Copyright (C) 1991 - 2000 by
+// Matra Datavision SA. All rights reserved.
+//
+// Copyright (C) 2001 - 2004 by
+// Open CASCADE SA. All rights reserved.
+//
+// This file is part of the Open CASCADE Technology software.
+//
+// This software may be distributed and/or modified under the terms and
+// conditions of the Open CASCADE Public License as defined by Open CASCADE SA
+// and appearing in the file LICENSE included in the packaging of this file.
+//
+// This software is distributed on an "AS IS" basis, without warranty of any
+// kind, and Open CASCADE SA hereby disclaims all such warranties,
+// including without limitation, any warranties of merchantability, fitness
+// for a particular purpose or non-infringement. Please see the License for
+// the specific terms and conditions governing rights and limitations under the
+// License.
+
+#ifndef _BRepExtrema_ExtPF_HeaderFile
+#define _BRepExtrema_ExtPF_HeaderFile
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#endif
+
+#ifndef _Extrema_ExtPS_HeaderFile
+#include <Extrema_ExtPS.hxx>
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _TColStd_SequenceOfReal_HeaderFile
+#include <TColStd_SequenceOfReal.hxx>
+#endif
+#ifndef _Extrema_SequenceOfPOnSurf_HeaderFile
+#include <Extrema_SequenceOfPOnSurf.hxx>
+#endif
+#ifndef _BRepAdaptor_Surface_HeaderFile
+#include <BRepAdaptor_Surface.hxx>
+#endif
+#ifndef _Extrema_ExtFlag_HeaderFile
+#include <Extrema_ExtFlag.hxx>
+#endif
+#ifndef _Extrema_ExtAlgo_HeaderFile
+#include <Extrema_ExtAlgo.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#endif
+class TopoDS_Vertex;
+class TopoDS_Face;
+class gp_Pnt;
+
+
+class BRepExtrema_ExtPF
+{
+ public:
+
+ void* operator new(size_t,void* anAddress)
+ {
+ return anAddress;
+ }
+ void* operator new(size_t size)
+ {
+ return Standard::Allocate(size);
+ }
+ void operator delete(void *anAddress)
+ {
+ if (anAddress) Standard::Free((Standard_Address&)anAddress);
+ }
+
+ Standard_EXPORT BRepExtrema_ExtPF()
+ {}
+ //! It calculates all the distances. <br>
+ Standard_EXPORT BRepExtrema_ExtPF(const TopoDS_Vertex& TheVertex,const TopoDS_Face& TheFace,
+ const Extrema_ExtFlag TheFlag = Extrema_ExtFlag_MINMAX,
+ const Extrema_ExtAlgo TheAlgo = Extrema_ExtAlgo_Grad);
+
+ Standard_EXPORT void Initialize(const TopoDS_Face& TheFace,
+ const Extrema_ExtFlag TheFlag = Extrema_ExtFlag_MINMAX,
+ const Extrema_ExtAlgo TheAlgo = Extrema_ExtAlgo_Grad);
+
+ //! An exception is raised if the fields have not been initialized. <br>
+ //! Be careful: this method uses the Face only for classify not for the fields. <br>
+ Standard_EXPORT void Perform(const TopoDS_Vertex& TheVertex,const TopoDS_Face& TheFace);
+ //! True if the distances are found. <br>
+ Standard_EXPORT Standard_Boolean IsDone() const
+ {
+ return myExtPS.IsDone();
+ }
+ //! Returns the number of extremum distances. <br>
+ Standard_EXPORT Standard_Integer NbExt() const
+ {
+ return myPoints.Length();
+ }
+ //! Returns the value of the <N>th extremum square distance. <br>
+ Standard_EXPORT Standard_Real SquareDistance(const Standard_Integer N) const
+ {
+ return mySqDist.Value(N);
+ }
+ //! Returns the parameters on the Face of the <N>th extremum distance. <br>
+ Standard_EXPORT void Parameter(const Standard_Integer N,Standard_Real& U,Standard_Real& V) const
+ {
+ myPoints.Value(N).Parameter(U, V);
+ }
+ //! Returns the Point of the <N>th extremum distance. <br>
+ Standard_EXPORT gp_Pnt Point(const Standard_Integer N) const
+ {
+ return myPoints.Value(N).Value();
+ }
+
+ Standard_EXPORT void SetFlag(const Extrema_ExtFlag F)
+ {
+ myExtPS.SetFlag(F);
+ }
+
+ Standard_EXPORT void SetAlgo(const Extrema_ExtAlgo A)
+ {
+ myExtPS.SetAlgo(A);
+ }
+
+ private:
+
+ Extrema_ExtPS myExtPS;
+ TColStd_SequenceOfReal mySqDist;
+ Extrema_SequenceOfPOnSurf myPoints;
+ BRepAdaptor_Surface mySurf;
+};
+
+#endif
// File: BRepExtrema_Poly.cxx
// Created: Fri Sep 8 11:03:14 1995
// Author: Christophe MARION
-// <cma@ecolox>
-#include <BRepExtrema_Poly.ixx>
+#include <BRepExtrema_Poly.hxx>
+
#include <BRep_Tool.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS.hxx>
//purpose :
//=======================================================================
-Standard_Boolean BRepExtrema_Poly::Distance (const TopoDS_Shape& S1,
- const TopoDS_Shape& S2,
- gp_Pnt& P1,
- gp_Pnt& P2,
- Standard_Real& dist)
+Standard_Boolean BRepExtrema_Poly::Distance (const TopoDS_Shape& S1, const TopoDS_Shape& S2,
+ gp_Pnt& P1, gp_Pnt& P2, Standard_Real& dist)
{
- Standard_Real dCur;
dist = Precision::Infinite();
- Standard_Integer i,i1,i2,n;
- TopExp_Explorer exFace;
- Handle(Poly_Triangulation) Tr;
+
TopLoc_Location L;
- Standard_Integer nbn1 = 0;
+ Handle(Poly_Triangulation) Tr;
+ TopExp_Explorer exFace;
+ Standard_Integer nbn1 = 0;
for (exFace.Init(S1, TopAbs_FACE);
exFace.More();
- exFace.Next()) {
+ exFace.Next())
+ {
const TopoDS_Face& F = TopoDS::Face(exFace.Current());
Tr = BRep_Tool::Triangulation(F,L);
if (!Tr.IsNull())
nbn1 += Tr->NbNodes();
}
+ if (nbn1 == 0) return Standard_False;
+
Standard_Integer nbn2 = 0;
-
for (exFace.Init(S2, TopAbs_FACE);
exFace.More();
- exFace.Next()) {
+ exFace.Next())
+ {
const TopoDS_Face& F = TopoDS::Face(exFace.Current());
Tr = BRep_Tool::Triangulation(F,L);
if (!Tr.IsNull())
nbn2 += Tr->NbNodes();
}
+ if (nbn2 == 0) return Standard_False;
- if (nbn1 == 0 || nbn2 == 0) return Standard_False;
+ Standard_Integer i,n;
TColgp_Array1OfPnt TP1(1,nbn1);
nbn1 = 0;
for (exFace.Init(S1, TopAbs_FACE);
exFace.More();
- exFace.Next()) {
+ exFace.Next())
+ {
const TopoDS_Face& F = TopoDS::Face(exFace.Current());
Tr = BRep_Tool::Triangulation(F,L);
- if (!Tr.IsNull()) {
+ if (!Tr.IsNull())
+ {
const TColgp_Array1OfPnt& Nod = Tr->Nodes();
n = Tr->NbNodes();
-
- for (i = 1;i <= n; i++) {
- nbn1++;
- TP1.SetValue(nbn1,Nod(i).Transformed(L));
+ for (i = 1; i <= n; i++)
+ {
+ nbn1++;
+ TP1.SetValue(nbn1,Nod(i).Transformed(L));
}
}
}
for (exFace.Init(S2, TopAbs_FACE);
exFace.More();
- exFace.Next()) {
+ exFace.Next())
+ {
const TopoDS_Face& F = TopoDS::Face(exFace.Current());
Tr = BRep_Tool::Triangulation(F,L);
- if (!Tr.IsNull()) {
+ if (!Tr.IsNull())
+ {
const TColgp_Array1OfPnt& Nod = Tr->Nodes();
n = Tr->NbNodes();
-
- for (i = 1;i <= n; i++) {
- nbn2++;
- TP2.SetValue(nbn2,Nod(i).Transformed(L));
+ for (i = 1; i <= n; i++)
+ {
+ nbn2++;
+ TP2.SetValue(nbn2,Nod(i).Transformed(L));
}
}
}
-
- for (i1 = 1; i1 <= nbn1; i1++) {
- gp_Pnt& PP1 = TP1(i1);
-
- for (i2 = 1; i2 <= nbn2; i2++) {
- gp_Pnt& PP2 = TP2(i2);
-
- dCur = PP1.Distance(PP2);
- if (dist > dCur) {
- P1 = PP1;
- P2 = PP2;
- dist = dCur;
+
+ Standard_Integer i1,i2;
+ for (i1 = 1; i1 <= nbn1; i1++)
+ {
+ const gp_Pnt& PP1 = TP1(i1);
+ for (i2 = 1; i2 <= nbn2; i2++)
+ {
+ const gp_Pnt& PP2 = TP2(i2);
+ const Standard_Real dCur = PP1.Distance(PP2);
+ if (dist > dCur)
+ {
+ P1 = PP1;
+ P2 = PP2;
+ dist = dCur;
}
}
}
return Standard_True;
}
-
--- /dev/null
+// This file is generated by WOK (CPPExt).
+// Please do not edit this file; modify original file instead.
+// The copyright and license terms as defined for the original file apply to
+// this header file considered to be the "object code" form of the original source.
+
+#ifndef _BRepExtrema_Poly_HeaderFile
+#define _BRepExtrema_Poly_HeaderFile
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#endif
+
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#endif
+class TopoDS_Shape;
+class gp_Pnt;
+
+
+class BRepExtrema_Poly
+{
+ public:
+
+ //! returns Standard_True if OK. <br>
+ Standard_EXPORT static Standard_Boolean Distance(const TopoDS_Shape& S1,const TopoDS_Shape& S2,gp_Pnt& P1,gp_Pnt& P2,Standard_Real& dist);
+};
+
+#endif
--- /dev/null
+// This file is generated by WOK (CPPExt).
+// Please do not edit this file; modify original file instead.
+// The copyright and license terms as defined for the original file apply to
+// this header file considered to be the "object code" form of the original source.
+
+#ifndef _BRepExtrema_SeqOfSolution_HeaderFile
+#define _BRepExtrema_SeqOfSolution_HeaderFile
+
+#ifndef _NCollection_Sequence_HeaderFile
+#include <NCollection_Sequence.hxx>
+#endif
+#ifndef _BRepExtrema_SolutionElem_HeaderFile
+#include <BRepExtrema_SolutionElem.hxx>
+#endif
+
+typedef NCollection_Sequence<BRepExtrema_SolutionElem> BRepExtrema_SeqOfSolution;
+
+#endif
--- /dev/null
+// This file is generated by WOK (CPPExt).
+// Please do not edit this file; modify original file instead.
+// The copyright and license terms as defined for the original file apply to
+// this header file considered to be the "object code" form of the original source.
+
+#ifndef _BRepExtrema_SolutionElem_HeaderFile
+#define _BRepExtrema_SolutionElem_HeaderFile
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#endif
+
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#endif
+#ifndef _gp_Pnt_HeaderFile
+#include <gp_Pnt.hxx>
+#endif
+#ifndef _BRepExtrema_SupportType_HeaderFile
+#include <BRepExtrema_SupportType.hxx>
+#endif
+#ifndef _TopoDS_Vertex_HeaderFile
+#include <TopoDS_Vertex.hxx>
+#endif
+#ifndef _TopoDS_Edge_HeaderFile
+#include <TopoDS_Edge.hxx>
+#endif
+#ifndef _TopoDS_Face_HeaderFile
+#include <TopoDS_Face.hxx>
+#endif
+class gp_Pnt;
+class TopoDS_Vertex;
+class TopoDS_Edge;
+class TopoDS_Face;
+
+
+//! This class is used to store information relative to the <br>
+//! minimum distance between two shapes. <br>
+class BRepExtrema_SolutionElem
+{
+ public:
+
+ void* operator new(size_t,void* anAddress)
+ {
+ return anAddress;
+ }
+ void* operator new(size_t size)
+ {
+ return Standard::Allocate(size);
+ }
+ void operator delete(void *anAddress)
+ {
+ if (anAddress) Standard::Free((Standard_Address&)anAddress);
+ }
+
+
+ Standard_EXPORT BRepExtrema_SolutionElem()
+ : myDist(0.), myPoint(0.,0.,0.), mySupType(BRepExtrema_IsVertex), myPar1(0.), myPar2(0.)
+ {
+ }
+ //! initialisation of the fields <br>
+ //! This constructor is used when the solution of a distance is a Vertex. <br>
+ //! The different initialized fields are: <br>
+ //! _ the distance d <br>
+ //! _ the solution point <br>
+ //! _ the type of solution <br>
+ //! _ and the Vertex. <br>
+ Standard_EXPORT BRepExtrema_SolutionElem(const Standard_Real d,const gp_Pnt& Pt,const BRepExtrema_SupportType SolType,const TopoDS_Vertex& vertex)
+ : myDist(d), myPoint(Pt), mySupType(SolType), myVertex(vertex), myPar1(0.), myPar2(0.)
+ {
+ }
+ //! initialisation of the fiels. <br>
+ //! This constructor is used when the solution of distance is on an Edge. <br>
+ //! The different initialized fields are: <br>
+ //! _ the distance d, <br>
+ //! _ the solution point, <br>
+ //! _ the type of solution, <br>
+ //! _ the Edge, <br>
+ //! _ and the parameter t to locate the solution. <br>
+ Standard_EXPORT BRepExtrema_SolutionElem(const Standard_Real d,const gp_Pnt& Pt,const BRepExtrema_SupportType SolType,const TopoDS_Edge& edge,const Standard_Real t)
+ : myDist(d), myPoint(Pt), mySupType(SolType), myEdge(edge), myPar1(t), myPar2(0.)
+ {
+ }
+ //! initialisation of the fields <br>
+ //! This constructor is used when the solution of distance is in <br>
+ //! a Face. The different initialized fields are: <br>
+ //! _ the distance d, <br>
+ //! _ the solution point, <br>
+ //! _ the type of solution, <br>
+ //! _ the Face, <br>
+ //! _ and the parameter u et v to locate the solution. <br>
+ Standard_EXPORT BRepExtrema_SolutionElem(const Standard_Real d,const gp_Pnt& Pt,const BRepExtrema_SupportType SolType,const TopoDS_Face& face,const Standard_Real u,const Standard_Real v)
+ : myDist(d), myPoint(Pt), mySupType(SolType), myFace(face), myPar1(u), myPar2(v)
+ {
+ }
+ //! returns the value of the minimum distance. <br>
+ Standard_EXPORT Standard_Real Dist() const
+ {
+ return myDist;
+ }
+ //! returns the solution point. <br>
+ Standard_EXPORT const gp_Pnt & Point() const
+ {
+ return myPoint;
+ }
+ //! returns the Support type : <br>
+ //! IsVertex => The solution is a vertex. <br>
+ //! IsOnEdge => The solution belongs to an Edge. <br>
+ //! IsInFace => The solution is inside a Face. <br>
+ Standard_EXPORT BRepExtrema_SupportType SupportKind() const
+ {
+ return mySupType;
+ }
+ //! returns the vertex if the solution is a Vertex. <br>
+ Standard_EXPORT const TopoDS_Vertex & Vertex() const
+ {
+ return myVertex;
+ }
+ //! returns the vertex if the solution is an Edge. <br>
+ Standard_EXPORT const TopoDS_Edge & Edge() const
+ {
+ return myEdge;
+ }
+ //! returns the vertex if the solution is an Face. <br>
+ Standard_EXPORT const TopoDS_Face & Face() const
+ {
+ return myFace;
+ }
+ //! returns the parameter t if the solution is on Edge. <br>
+ Standard_EXPORT void EdgeParameter(Standard_Real& par1) const
+ {
+ par1 = myPar1;
+ }
+ //! returns the parameters u et v if the solution is in a Face. <br>
+ Standard_EXPORT void FaceParameter(Standard_Real& par1,Standard_Real& par2) const
+ {
+ par1 = myPar1;
+ par2 = myPar2;
+ }
+
+ private:
+
+ Standard_Real myDist;
+ gp_Pnt myPoint;
+ BRepExtrema_SupportType mySupType;
+ TopoDS_Vertex myVertex;
+ TopoDS_Edge myEdge;
+ TopoDS_Face myFace;
+ Standard_Real myPar1;
+ Standard_Real myPar2;
+};
+
+#endif
--- /dev/null
+// This file is generated by WOK (CPPExt).
+// Please do not edit this file; modify original file instead.
+// The copyright and license terms as defined for the original file apply to
+// this header file considered to be the "object code" form of the original source.
+
+#ifndef _BRepExtrema_SupportType_HeaderFile
+#define _BRepExtrema_SupportType_HeaderFile
+
+enum BRepExtrema_SupportType
+{
+ BRepExtrema_IsVertex,
+ BRepExtrema_IsOnEdge,
+ BRepExtrema_IsInFace
+};
+
+#ifndef _Standard_PrimitiveTypes_HeaderFile
+#include <Standard_PrimitiveTypes.hxx>
+#endif
+
+#endif
--- /dev/null
+BRepExtrema_DistanceSS.hxx
+BRepExtrema_DistanceSS.cxx
+BRepExtrema_DistShapeShape.hxx
+BRepExtrema_DistShapeShape.cxx
+BRepExtrema_ExtCC.hxx
+BRepExtrema_ExtCC.cxx
+BRepExtrema_ExtCF.hxx
+BRepExtrema_ExtCF.cxx
+BRepExtrema_ExtFF.hxx
+BRepExtrema_ExtFF.cxx
+BRepExtrema_ExtPC.hxx
+BRepExtrema_ExtPC.cxx
+BRepExtrema_ExtPF.hxx
+BRepExtrema_ExtPF.cxx
+BRepExtrema_Poly.hxx
+BRepExtrema_Poly.cxx
+BRepExtrema_SeqOfSolution.hxx
+BRepExtrema_SolutionElem.hxx
+BRepExtrema_SupportType.hxx
uses Standard,
TCollection,
TColStd,
- gp
+ gp,
+ MMgt
is class Box;
(Box from Bnd,
Array1OfBox from Bnd);
+ class Sphere;
+ class Array1OfSphere instantiates Array1 from TCollection
+ (Sphere from Bnd);
+ class HArray1OfSphere instantiates HArray1 from TCollection
+ (Sphere from Bnd,
+ Array1OfSphere from Bnd);
+
class Box2d;
---Purpose: A rectangle parallel to the main axes.
--- /dev/null
+-- File: Bnd_Sphere.cdl
+-- Created: Fri Dec 3 17:39:44 2010
+-- Author: Artem SHAL
+---Copyright: OPEN CASCADE 2010
+
+class Sphere from Bnd
+
+ ---Purpose: This class represents a bounding sphere of a geometric entity
+ -- (triangle, segment of line or whatever else).
+
+uses XYZ from gp
+
+is
+
+ Create returns Sphere;
+ ---Purpose: Empty constructor
+
+ Create (theCntr : XYZ from gp; theRad : Real; theU : Integer; theV : Integer)
+ returns Sphere;
+ ---Purpose: Constructor of a definite sphere
+
+ U (me) returns Integer;
+ ---C++: inline
+ ---Purpose: Returns the U parameter on shape
+
+ V (me) returns Integer;
+ ---C++: inline
+ ---Purpose: Returns the V parameter on shape
+
+ IsValid (me) returns Boolean;
+ ---C++: inline
+ ---Purpose: Returns validity status, indicating that this
+ -- sphere corresponds to a real entity
+
+ SetValid (me : in out; isValid : Boolean);
+ ---C++: inline
+
+ Center (me) returns XYZ from gp;
+ ---C++: inline
+ ---C++: return const &
+ ---Purpose: Returns center of sphere object
+
+ Radius (me) returns Real;
+ ---C++: inline
+ ---Purpose: Returns the radius value
+
+ Distances (me; theXYZ : XYZ from gp; theMin : in out Real; theMax : in out Real) is static;
+ ---Purpose: Calculate and return minimal and maximal distance to sphere.
+ -- NOTE: This function is tightly optimized; any modifications
+ -- may affect performance!
+
+ SquareDistances (me; theXYZ : XYZ from gp; theMin : in out Real; theMax : in out Real) is static;
+ ---Purpose: Calculate and return minimal and maximal distance to sphere.
+ -- NOTE: This function is tightly optimized; any modifications
+ -- may affect performance!
+
+ Project (me; theNode : XYZ from gp; theProjNode : in out XYZ from gp; theDist : in out Real; theInside : in out Boolean)
+ ---Purpose: Projects a point on entity.
+ -- Returns true if success
+ returns Boolean;
+
+ Distance (me; theNode : XYZ from gp)
+ returns Real;
+
+ SquareDistance (me; theNode : XYZ from gp)
+ returns Real;
+
+ Add (me : in out; theOther : Sphere from Bnd);
+
+ IsOut (me; theOther : Sphere from Bnd)
+ returns Boolean;
+
+ IsOut (me; thePnt : XYZ from gp; theMaxDist : in out Real)
+ returns Boolean;
+
+ SquareExtent (me) returns Real;
+
+fields
+
+ myCenter : XYZ from gp;
+ myRadius : Real;
+ myIsValid : Boolean;
+ myU : Integer;
+ myV : Integer;
+
+end Sphere;
--- /dev/null
+#include <Bnd_Sphere.hxx>
+
+Bnd_Sphere::Bnd_Sphere()
+ : myCenter (0., 0., 0.),
+ myRadius (0.),
+ myIsValid (Standard_False),
+ myU (0),
+ myV (0)
+{}
+
+Bnd_Sphere::Bnd_Sphere( const gp_XYZ& theCenter, const Standard_Real theRadius,
+ const Standard_Integer theU, const Standard_Integer theV )
+ : myCenter (theCenter),
+ myRadius (theRadius),
+ myIsValid (Standard_False),
+ myU (theU),
+ myV (theV)
+{}
+
+void Bnd_Sphere::SquareDistances( const gp_XYZ& theXYZ,
+ Standard_Real& theMin, Standard_Real& theMax ) const
+{
+ theMax = ( theXYZ - myCenter ).SquareModulus();
+ theMin = ( theMax - myRadius <0 ? 0.0 : theMax - myRadius * myRadius );
+ theMax += myRadius * myRadius;
+}
+
+void Bnd_Sphere::Distances( const gp_XYZ& theXYZ,
+ Standard_Real& theMin, Standard_Real& theMax ) const
+{
+ theMax = ( theXYZ - myCenter ).Modulus();
+ theMin = ( theMax - myRadius <0 ? 0.0 : theMax - myRadius );
+ theMax += myRadius;
+}
+
+Standard_Boolean Bnd_Sphere::Project(const gp_XYZ& theNode, gp_XYZ& theProjNode, Standard_Real& theDist, Standard_Boolean& theInside) const
+{
+ theProjNode = myCenter;
+ theDist = ( theNode - theProjNode ).Modulus();
+ theInside = Standard_True;
+ return Standard_True;
+}
+
+Standard_Real Bnd_Sphere::Distance(const gp_XYZ& theNode) const
+{
+ return ( theNode - myCenter ).Modulus();
+}
+
+Standard_Real Bnd_Sphere::SquareDistance(const gp_XYZ& theNode) const
+{
+ return ( theNode - myCenter ).SquareModulus();
+}
+
+void Bnd_Sphere::Add( const Bnd_Sphere& theOther)
+{
+ if ( myRadius < 0.0 )
+ {
+ // not initialised yet
+ *this = theOther;
+ return;
+ }
+
+ const Standard_Real aDist = (myCenter - theOther.myCenter).Modulus();
+ if ( myRadius + aDist <= theOther.myRadius )
+ {
+ // the other sphere is larger and encloses this
+ *this = theOther;
+ return;
+ }
+
+ if ( theOther.myRadius + aDist <= myRadius )
+ return; // this sphere encloses other
+
+ // expansion
+ const Standard_Real dfR = ( aDist + myRadius + theOther.myRadius ) * 0.5;
+ const Standard_Real aParamOnDiam = ( dfR - myRadius ) / aDist;
+ myCenter = myCenter * ( 1.0 - aParamOnDiam ) + theOther.myCenter * aParamOnDiam;
+ myRadius = dfR;
+ myIsValid = Standard_False;
+}
+
+Standard_Boolean Bnd_Sphere::IsOut( const Bnd_Sphere& theOther ) const
+{
+ return (myCenter - theOther.myCenter).SquareModulus() > (myRadius + theOther.myRadius) * (myRadius + theOther.myRadius);
+}
+
+Standard_Boolean Bnd_Sphere::IsOut( const gp_XYZ& theXYZ,
+ Standard_Real& theMaxDist) const
+{
+ Standard_Real aCurMinDist, aCurMaxDist;
+ Distances( theXYZ, aCurMinDist, aCurMaxDist );
+ if ( aCurMinDist > theMaxDist )
+ return Standard_True;
+ if( myIsValid && aCurMaxDist < theMaxDist )
+ theMaxDist = aCurMaxDist;
+ return Standard_False;
+}
+
+Standard_Real Bnd_Sphere::SquareExtent() const
+{
+ return 4 * myRadius * myRadius;
+}
--- /dev/null
+
+inline Standard_Integer Bnd_Sphere::U() const
+{
+ return myU;
+}
+
+inline Standard_Integer Bnd_Sphere::V() const
+{
+ return myV;
+}
+
+inline Standard_Boolean Bnd_Sphere::IsValid() const
+{
+ return myIsValid;
+}
+
+inline void Bnd_Sphere::SetValid(const Standard_Boolean isValid)
+{
+ myIsValid = isValid;
+}
+
+inline const gp_XYZ& Bnd_Sphere::Center() const
+{
+ return myCenter;
+}
+
+inline Standard_Real Bnd_Sphere::Radius() const
+{
+ return myRadius;
+}
Adaptor3d,
Adaptor2d,
Geom,
- Geom2d
+ Geom2d,
+ Bnd
is
+ enumeration ExtFlag is ExtFlag_MIN, ExtFlag_MAX, ExtFlag_MINMAX;
+
+ enumeration ExtAlgo is ExtAlgo_Grad, ExtAlgo_Tree;
+
class CurveTool;
class Curve2dTool;
private class FuncExtPS;
class GenExtPS;
class GenLocateExtPS;
+ imported HUBTreeOfSphere;
----------------------------------------------
-- generic classes for CURVE-CURVE extremas:
SequenceOfReal from TColStd,
Surface from Adaptor3d,
SurfacePtr from Adaptor3d,
- GenExtPS from Extrema
+ GenExtPS from Extrema,
+ ExtFlag from Extrema,
+ ExtAlgo from Extrema
-- ExtPExtS from Extrema,
-- ExtPRevS from Extrema
Create returns ExtPS;
- Create (P: Pnt from gp; S: Surface from Adaptor3d; TolU,TolV: Real)
+ Create (P: Pnt from gp; S: Surface from Adaptor3d; TolU,TolV: Real;
+ F : ExtFlag from Extrema = Extrema_ExtFlag_MINMAX;
+ A : ExtAlgo from Extrema = Extrema_ExtAlgo_Grad)
returns ExtPS;
---Purpose: It calculates all the distances.
-- NbU and NbV are used to locate the close points
Create (P: Pnt from gp; S: Surface from Adaptor3d;
Uinf, Usup, Vinf, Vsup: Real;
- TolU,TolV: Real)
+ TolU,TolV: Real;
+ F : ExtFlag from Extrema = Extrema_ExtFlag_MINMAX;
+ A : ExtAlgo from Extrema = Extrema_ExtAlgo_Grad)
returns ExtPS;
---Purpose: It calculates all the distances.
-- NbU and NbV are used to locate the close points
-- dUlVl is a square distance between <P> and the point
-- of parameter LastUParameter and LastVParameter <PUlVl>.
is static;
+
+ SetFlag(me : in out; F : ExtFlag from Extrema)
+ is static;
+
+ SetAlgo(me : in out; A : ExtAlgo from Extrema)
+ is static;
Bidon(me) returns SurfacePtr from Adaptor3d
if(Step < Precision::PConfusion()) {
return Standard_False;
}
+ if(Step < Precision::PConfusion()) {
+ return Standard_False;
+ }
D1NormMax=0.;
for (T=U1;T<=U2;T=T+Step)
{
if(Step < Precision::PConfusion()) {
return Standard_False;
}
+ if(Step < Precision::PConfusion()) {
+ return Standard_False;
+ }
D1NormMax=0.;
for (T=V1;T<=V2;T=T+Step)
{
Extrema_ExtPS::Extrema_ExtPS(const gp_Pnt& P,
const Adaptor3d_Surface& S,
const Standard_Real TolU,
- const Standard_Real TolV)
+ const Standard_Real TolV,
+ const Extrema_ExtFlag F,
+ const Extrema_ExtAlgo A)
{
+ myExtPS.SetFlag(F);
+ myExtPS.SetAlgo(A);
Initialize(S, S.FirstUParameter(), S.LastUParameter(),
S.FirstVParameter(), S.LastVParameter(),
TolU, TolV);
const Standard_Real Vinf,
const Standard_Real Vsup,
const Standard_Real TolU,
- const Standard_Real TolV)
+ const Standard_Real TolV,
+ const Extrema_ExtFlag F,
+ const Extrema_ExtAlgo A)
{
+ myExtPS.SetFlag(F);
+ myExtPS.SetAlgo(A);
Initialize(S, Uinf, Usup, Vinf, Vsup, TolU, TolV);
Perform(P);
}
PUlVf = P21;
PUlVl = P22;
}
+
+void Extrema_ExtPS::SetFlag(const Extrema_ExtFlag F)
+{
+ myExtPS.SetFlag(F);
+}
+
+void Extrema_ExtPS::SetAlgo(const Extrema_ExtAlgo A)
+{
+ myExtPS.SetAlgo(A);
+}
\ No newline at end of file
uses POnSurf from Extrema,
Pnt from gp,
- HArray2OfPnt from TColgp,
FuncExtPS from Extrema,
Surface from Adaptor3d,
- SurfacePtr from Adaptor3d
+ SurfacePtr from Adaptor3d,
+ HUBTreeOfSphere from Extrema,
+ ExtFlag from Extrema,
+ ExtAlgo from Extrema,
+ HArray1OfSphere from Bnd,
+ Vector from math,
+ HArray2OfPnt from TColgp
raises NotDone from StdFail,
OutOfRange from Standard,
Create returns GenExtPS;
- Create (P: Pnt; S: Surface from Adaptor3d; NbU,NbV: Integer; TolU,TolV: Real)
+ Create (P: Pnt; S: Surface from Adaptor3d; NbU,NbV: Integer; TolU,TolV: Real; F : ExtFlag from Extrema = Extrema_ExtFlag_MINMAX; A : ExtAlgo from Extrema = Extrema_ExtAlgo_Grad)
returns GenExtPS;
---Purpose: It calculates all the distances.
-- The function F(u,v)=distance(P,S(u,v)) has an
Create (P: Pnt; S: Surface from Adaptor3d; NbU,NbV: Integer;
- Umin, Usup, Vmin, Vsup: Real; TolU,TolV: Real)
+ Umin, Usup, Vmin, Vsup: Real; TolU,TolV: Real; F : ExtFlag from Extrema = Extrema_ExtFlag_MINMAX; A : ExtAlgo from Extrema = Extrema_ExtAlgo_Grad)
returns GenExtPS;
---Purpose: It calculates all the distances.
-- The function F(u,v)=distance(P,S(u,v)) has an
-- been initialized.
raises TypeMismatch from Standard
is static;
+
+ SetFlag(me : in out; F : ExtFlag from Extrema)
+ is static;
+
+ SetAlgo(me : in out; A : ExtAlgo from Extrema)
+ is static;
IsDone (me) returns Boolean
Bidon(me) returns SurfacePtr from Adaptor3d
is static private;
+
+ BuildTree(me : in out)
+ is static private;
+
+ FindSolution(me: in out; P : Pnt from gp; UV : Vector from math; PasU, PasV : Real; f : ExtFlag from Extrema)
+ is static private;
fields
myDone : Boolean;
myvsup : Real;
myusample : Integer;
myvsample : Integer;
- mypoints : HArray2OfPnt from TColgp;
mytolu : Real;
mytolv : Real;
+ mypoints : HArray2OfPnt from TColgp;
+ mySphereUBTree : HUBTreeOfSphere from Extrema;
+ mySphereArray : HArray1OfSphere from Bnd;
myF : FuncExtPS from Extrema;
myS : SurfacePtr from Adaptor3d;
+ myFlag : ExtFlag from Extrema;
+ myAlgo : ExtAlgo from Extrema;
end GenExtPS;
#include <math_Vector.hxx>
#include <math_NewtonFunctionSetRoot.hxx>
#include <GeomAbs_IsoType.hxx>
+#include <Bnd_Sphere.hxx>
+#include <Extrema_HUBTreeOfSphere.hxx>
+#include <Extrema_ExtFlag.hxx>
+#include <Bnd_Array1OfSphere.hxx>
+#include <Bnd_HArray1OfSphere.hxx>
+//IMPLEMENT_HARRAY1(Extrema_HArray1OfSphere)
+
+
+class Bnd_SphereUBTreeSelector : public Extrema_UBTreeOfSphere::Selector
+{
+ public:
+
+ Bnd_SphereUBTreeSelector (const Handle(Bnd_HArray1OfSphere)& theSphereArray,
+Bnd_Sphere& theSol)
+ : myXYZ(0,0,0),
+ mySphereArray(theSphereArray),
+ mySol(theSol)
+ {
+ //myXYZ = gp_Pnt(0, 0, 0);
+ }
+
+ void DefineCheckPoint( const gp_Pnt& theXYZ )
+ { myXYZ = theXYZ; }
+
+ Bnd_Sphere& Sphere() const
+ { return mySol; }
+
+ virtual Standard_Boolean Reject( const Bnd_Sphere &theBnd ) const = 0;
+
+ virtual Standard_Boolean Accept(const Standard_Integer& theObj) = 0;
+
+ protected:
+ gp_Pnt myXYZ;
+ const Handle(Bnd_HArray1OfSphere)& mySphereArray;
+ Bnd_Sphere& mySol;
+
+};
+
+class Bnd_SphereUBTreeSelectorMin : public Bnd_SphereUBTreeSelector
+{
+public:
+ Bnd_SphereUBTreeSelectorMin (const Handle(Bnd_HArray1OfSphere)& theSphereArray,
+ Bnd_Sphere& theSol)
+ : Bnd_SphereUBTreeSelector(theSphereArray, theSol),
+ myMinDist(RealLast())
+ {}
+
+ void SetMinDist( const Standard_Real theMinDist )
+ { myMinDist = theMinDist; }
+
+ Standard_Real MinDist() const
+ { return myMinDist; }
+
+ Standard_Boolean Reject( const Bnd_Sphere &theBnd ) const
+ {
+ Bnd_SphereUBTreeSelectorMin* me =
+ const_cast<Bnd_SphereUBTreeSelectorMin*>(this);
+ // myMinDist is decreased each time a nearer object is found
+ return theBnd.IsOut( myXYZ.XYZ(), me->myMinDist );
+ }
+
+ Standard_Boolean Accept(const Standard_Integer&);
+
+private:
+ Standard_Real myMinDist;
+};
+
+Standard_Boolean Bnd_SphereUBTreeSelectorMin::Accept(const Standard_Integer& theInd)
+{
+ const Bnd_Sphere& aSph = mySphereArray->Value(theInd);
+ Standard_Real aCurDist;
+
+ if ( (aCurDist = aSph.SquareDistance(myXYZ.XYZ())) < mySol.SquareDistance(myXYZ.XYZ()) )
+ {
+ mySol = aSph;
+ if ( aCurDist < myMinDist )
+ myMinDist = aCurDist;
+
+ return Standard_True;
+ }
+
+ return Standard_False;
+}
+
+class Bnd_SphereUBTreeSelectorMax : public Bnd_SphereUBTreeSelector
+{
+public:
+ Bnd_SphereUBTreeSelectorMax (const Handle(Bnd_HArray1OfSphere)& theSphereArray,
+ Bnd_Sphere& theSol)
+ : Bnd_SphereUBTreeSelector(theSphereArray, theSol),
+ myMaxDist(0)
+ {}
+
+ void SetMaxDist( const Standard_Real theMaxDist )
+ { myMaxDist = theMaxDist; }
+
+ Standard_Real MaxDist() const
+ { return myMaxDist; }
+
+ Standard_Boolean Reject( const Bnd_Sphere &theBnd ) const
+ {
+ Bnd_SphereUBTreeSelectorMax* me =
+ const_cast<Bnd_SphereUBTreeSelectorMax*>(this);
+ // myMaxDist is decreased each time a nearer object is found
+ return theBnd.IsOut( myXYZ.XYZ(), me->myMaxDist );
+ }
+
+ Standard_Boolean Accept(const Standard_Integer&);
+
+private:
+ Standard_Real myMaxDist;
+};
+
+Standard_Boolean Bnd_SphereUBTreeSelectorMax::Accept(const Standard_Integer& theInd)
+{
+ const Bnd_Sphere& aSph = mySphereArray->Value(theInd);
+ Standard_Real aCurDist;
+
+ if ( (aCurDist = aSph.SquareDistance(myXYZ.XYZ())) > mySol.SquareDistance(myXYZ.XYZ()) )
+ {
+ mySol = aSph;
+ if ( aCurDist > myMaxDist )
+ myMaxDist = aCurDist;
+
+ return Standard_True;
+ }
+
+ return Standard_False;
+}
//=============================================================================
/*-----------------------------------------------------------------------------
-Fonction:
- Recherche de toutes les distances extremales entre le point P et la surface
- S a partir d'un echantillonnage (NbU,NbV).
+Function:
+ Find all extremum distances between point P and surface
+ S using sampling (NbU,NbV).
-Methode:
- L'algorithme part de l'hypothese que l'echantillonnage est suffisamment fin
+Method:
+ The algorithm bases on the hypothesis that sampling is precise enough
pour que, s'il existe N distances extremales entre le point et la surface,
alors il existe aussi N extrema entre le point et la grille.
- Ainsi, l'algorithme consiste a partir des extrema de la grille pour trouver
- les extrema de la surface.
- Les extrema sont calcules par l'algorithme math_FunctionSetRoot avec les
- arguments suivants:
- - F: Extrema_FuncExtPS cree a partir de P et S,
- - UV: math_Vector dont les composantes sont les parametres de l'extremum sur
- la grille,
- - Tol: Min(TolU,TolV), (Prov.:math_FunctionSetRoot n'autorise pas un vecteur)
- - UVinf: math_Vector dont les composantes sont les bornes inferieures de u et
- v,
- - UVsup: math_Vector dont les composantes sont les bornes superieures de u et
- v.
-
-Traitement:
- a- Constitution du tableau des distances (TbDist(0,NbU+1,0,NbV+1)):
- Le tableau est volontairement etendu; les lignes 0 et NbU+1 et les
- colonnes 0 et NbV+1 seront initialisees a RealFirst() ou RealLast()
- pour simplifier les tests effectues dans l'etape b
- (on n'a pas besoin de tester si le point est sur un bord de la grille).
- b- Calcul des extrema:
- On recherche d'abord les minima et ensuite les maxima. Ces 2 traitements
- se passent de facon similaire:
- b.a- Initialisations:
- - des 'bords' du tableau TbDist (a RealLast() dans le cas des minima
- et a RealLast() dans le cas des maxima),
- - du tableau TbSel(0,NbU+1,0,NbV+1) de selection des points pour un
- calcul d'extremum local (a 0). Lorsqu'un point sera selectionne,
- il ne sera plus selectionnable, ainsi que ses points adjacents
- (8 au maximum). Les adresses correspondantes seront mises a 1.
- b.b- Calcul des minima (ou maxima):
- On boucle sur toutes les distances du tableau TbDist:
- - recherche d'un minimum (ou maximum) sur la grille,
- - calcul de l'extremum sur la surface,
- - mise a jour du tableau TbSel.
+ So, the algorithm consists in starting from extrema of the grid to find the
+ extrema of the surface.
+ The extrema are calculated by the algorithm math_FunctionSetRoot with the
+ following arguments:
+ - F: Extrema_FuncExtPS created from P and S,
+ - UV: math_Vector the components which of are parameters of the extremum on the
+ grid,
+ - Tol: Min(TolU,TolV), (Prov.:math_FunctionSetRoot does not autorize a vector)
+ - UVinf: math_Vector the components which of are lower limits of u and v,
+ - UVsup: math_Vector the components which of are upper limits of u and v.
+
+Processing:
+ a- Creation of the table of distances (TbDist(0,NbU+1,0,NbV+1)):
+ The table is expanded at will; lines 0 and NbU+1 and
+ columns 0 and NbV+1 are initialized at RealFirst() or RealLast()
+ to simplify the tests carried out at stage b
+ (there is no need to test if the point is on border of the grid).
+ b- Calculation of extrema:
+ First the minimums and then the maximums are found. These 2 procedured
+ pass in a similar way:
+ b.a- Initialization:
+ - 'borders' of table TbDist (RealLast() in case of minimums
+ and RealLast() in case of maximums),
+ - table TbSel(0,NbU+1,0,NbV+1) of selection of points for
+ calculation of local extremum (0). When a point will selected,
+ it will not be selectable, as well as the ajacent points
+ (8 at least). The corresponding addresses will be set to 1.
+ b.b- Calculation of minimums (or maximums):
+ All distances from table TbDist are parsed in a loop:
+ - search minimum (or maximum) in the grid,
+ - calculate extremum on the surface,
+ - update table TbSel.
-----------------------------------------------------------------------------*/
static Standard_Boolean IsoIsDeg (const Adaptor3d_Surface& S,
{
myDone = Standard_False;
myInit = Standard_False;
+ myFlag = Extrema_ExtFlag_MINMAX;
+ myAlgo = Extrema_ExtAlgo_Grad;
}
const Standard_Integer NbU,
const Standard_Integer NbV,
const Standard_Real TolU,
- const Standard_Real TolV)
-: myF (P,S)
+ const Standard_Real TolV,
+ const Extrema_ExtFlag F,
+ const Extrema_ExtAlgo A)
+ : myF (P,S), myFlag(F), myAlgo(A)
{
Initialize(S, NbU, NbV, TolU, TolV);
Perform(P);
const Standard_Real Vmin,
const Standard_Real Vsup,
const Standard_Real TolU,
- const Standard_Real TolV)
-: myF (P,S)
+ const Standard_Real TolV,
+ const Extrema_ExtFlag F,
+ const Extrema_ExtAlgo A)
+ : myF (P,S), myFlag(F), myAlgo(A)
{
Initialize(S, NbU, NbV, Umin, Usup, Vmin, Vsup, TolU, TolV);
Perform(P);
myF.Initialize(S);
- mypoints = new TColgp_HArray2OfPnt(0,myusample+1,0,myvsample+1);
-
-/*
-a- Constitution du tableau des distances (TbDist(0,myusample+1,0,myvsample+1)):
- ---------------------------------------------------------------
-*/
-
-// Parametrage de l echantillon
+ mySphereUBTree.Clear();
+ if(myAlgo == Extrema_ExtAlgo_Grad)
+ {
+ //If flag was changed and extrema not reinitialized Extrema would fail
+ mypoints = new TColgp_HArray2OfPnt(0,myusample+1,0,myvsample+1);
Standard_Real PasU = myusup - myumin;
Standard_Real PasV = myvsup - myvmin;
Standard_Real U0 = PasU / myusample / 100.;
mypoints->SetValue(NoU,NoV,P1);
}
}
+ }
+
+ //mypoints = new TColgp_HArray2OfPnt(0,myusample+1,0,myvsample+1);
+
+/*
+a- Constitution du tableau des distances (TbDist(0,myusample+1,0,myvsample+1)):
+ ---------------------------------------------------------------
+*/
+
+// Parametrage de l echantillon
+
+
}
+void Extrema_GenExtPS::BuildTree()
+{
+ if(mySphereUBTree.IsEmpty())
+ {
+ Standard_Real PasU = myusup - myumin;
+ Standard_Real PasV = myvsup - myvmin;
+ Standard_Real U0 = PasU / myusample / 100.;
+ Standard_Real V0 = PasV / myvsample / 100.;
+ gp_Pnt P1;
+ PasU = (PasU - U0) / (myusample - 1);
+ PasV = (PasV - V0) / (myvsample - 1);
+ U0 = U0/2. + myumin;
+ V0 = V0/2. + myvmin;
+
+ // Calcul des distances
+
+ Standard_Integer NoU, NoV;
+ //mySphereUBTree.Clear();
+ Extrema_UBTreeFillerOfSphere aFiller(mySphereUBTree.ChangeTree());
+ Standard_Integer i = myusample * myvsample;
+ Standard_Real U, V;
+ /*for ( NoU = 1; NoU <= myusample; NoU++) {
+ for ( NoV = 1; NoV <= myvsample; NoV++) {
+ i++;
+ }
+ }*/
+ mySphereArray = new Bnd_HArray1OfSphere(0, i);
+ i = 0;
+ for ( NoU = 1, U = U0; NoU <= myusample; NoU++, U += PasU) {
+ for ( NoV = 1, V = V0; NoV <= myvsample; NoV++, V += PasV) {
+ P1 = myS->Value(U, V);
+ //mypoints->SetValue(NoU, NoV, P1);
+ Bnd_Sphere aSph(P1.XYZ(), 0/*mytolu < mytolv ? mytolu : mytolv*/, NoU, NoV);
+ aFiller.Add(i, aSph);
+ mySphereArray->SetValue( i, aSph );
+ i++;
+ }
+ }
+ aFiller.Fill();
+ }
+}
+
+void Extrema_GenExtPS::FindSolution(const gp_Pnt& P, const math_Vector& UV, const Standard_Real PasU, const Standard_Real PasV, const Extrema_ExtFlag f)
+{
+ math_Vector Tol(1,2);
+ Tol(1) = mytolu;
+ Tol(2) = mytolv;
+ math_Vector UVinf(1,2), UVsup(1,2);
+ UVinf(1) = myumin;
+ UVinf(2) = myvmin;
+ UVsup(1) = myusup;
+ UVsup(2) = myvsup;
+
+ math_Vector errors(1,2);
+ math_Vector root(1, 2);
+ Standard_Real eps = 1.e-9;
+ Standard_Integer nbsubsample = 11;
+
+ Standard_Integer aNbMaxIter = 100;
+
+ if (myF.HasDegIso())
+ aNbMaxIter = 150;
+
+ math_FunctionSetRoot S (myF,UV,Tol,UVinf,UVsup, aNbMaxIter);
+ if(S.IsDone()) {
+ root = S.Root();
+ myF.Value(root, errors);
+ if(f == Extrema_ExtFlag_MIN)
+ {
+ if(Abs(errors(1)) > eps || Abs(errors(2)) > eps) {
+ //try to improve solution on subgrid of sample points
+ gp_Pnt PSol = myS->Value(root(1), root(2));
+ Standard_Real DistSol = P.SquareDistance(PSol);
+
+ Standard_Real u1 = Max(UV(1) - PasU, myumin), u2 = Min(UV(1) + PasU, myusup);
+ Standard_Real v1 = Max(UV(2) - PasV, myvmin), v2 = Min(UV(2) + PasV, myvsup);
+
+ if(u2 - u1 < 2.*PasU) {
+ if(Abs(u1 - myumin) < 1.e-9) {
+ u2 = u1 + 2.*PasU;
+ u2 = Min(u2, myusup);
+ }
+ if(Abs(u2 - myusup) < 1.e-9) {
+ u1 = u2 - 2.*PasU;
+ u1 = Max(u1, myumin);
+ }
+ }
+
+ if(v2 - v1 < 2.*PasV) {
+ if(Abs(v1 - myvmin) < 1.e-9) {
+ v2 = v1 + 2.*PasV;
+ v2 = Min(v2, myvsup);
+ }
+ if(Abs(v2 - myvsup) < 1.e-9) {
+ v1 = v2 - 2.*PasV;
+ v1 = Max(v1, myvmin);
+ }
+ }
+
+ Standard_Real du = (u2 - u1)/(nbsubsample-1);
+ Standard_Real dv = (v2 - v1)/(nbsubsample-1);
+ Standard_Real u, v;
+ Standard_Real dist;
+
+ Standard_Boolean NewSolution = Standard_False;
+ Standard_Integer Nu, Nv;
+ for (Nu = 1, u = u1; Nu < nbsubsample; Nu++, u += du) {
+ for (Nv = 1, v = v1; Nv < nbsubsample; Nv++, v += dv) {
+ gp_Pnt Puv = myS->Value(u, v);
+ dist = P.SquareDistance(Puv);
+
+ if(dist < DistSol) {
+ UV(1) = u;
+ UV(2) = v;
+ NewSolution = Standard_True;
+ DistSol = dist;
+ }
+ }
+ }
+
+ if(NewSolution) {
+ //try to precise
+ math_FunctionSetRoot S (myF,UV,Tol,UVinf,UVsup, aNbMaxIter);
+ }
+
+ }
+ }
+ }
+ myDone = Standard_True;
+}
+
+void Extrema_GenExtPS::SetFlag(const Extrema_ExtFlag F)
+{
+ myFlag = F;
+}
+
+void Extrema_GenExtPS::SetAlgo(const Extrema_ExtAlgo A)
+{
+ myAlgo = A;
+}
void Extrema_GenExtPS::Perform(const gp_Pnt& P)
{
+ //BuildTree();
myDone = Standard_False;
myF.SetPoint(P);
-
-/*
-b- Calcul des minima:
- -----------------
- b.a) Initialisations:
-*/
-
-// Parametrage de l echantillon
-
Standard_Real PasU = myusup - myumin;
Standard_Real PasV = myvsup - myvmin;
Standard_Real U, U0 = PasU / myusample / 100.;
U0 = U0/2.+myumin;
V0 = V0/2.+myvmin;
-// - generales
- math_Vector Tol(1, 2);
- Tol(1) = mytolu;
- Tol(2) = mytolv;
- math_Vector UV(1,2), UVinf(1,2), UVsup(1,2);
- UVinf(1) = myumin;
- UVinf(2) = myvmin;
- UVsup(1) = myusup;
- UVsup(2) = myvsup;
+ //math_Vector Tol(1, 2);
+ math_Vector UV(1,2);
-// - des 'bords' du tableau mytbdist
- Standard_Integer NoU,NoV;
+ if(myAlgo == Extrema_ExtAlgo_Grad)
+ {
+ Standard_Integer NoU,NoV;
- TColStd_Array2OfReal TheDist(0, myusample+1, 0, myvsample+1);
- for ( NoU = 1, U = U0; NoU <= myusample; NoU++, U += PasU) {
- for ( NoV = 1, V = V0; NoV <= myvsample; NoV++, V += PasV) {
- TheDist(NoU, NoV) = P.SquareDistance(mypoints->Value(NoU, NoV));
+ TColStd_Array2OfReal TheDist(0, myusample+1, 0, myvsample+1);
+ for ( NoU = 1, U = U0; NoU <= myusample; NoU++, U += PasU) {
+ for ( NoV = 1, V = V0; NoV <= myvsample; NoV++, V += PasV) {
+ TheDist(NoU, NoV) = P.SquareDistance(mypoints->Value(NoU, NoV));
+ }
}
- }
-
- for (NoV = 0; NoV <= myvsample+1; NoV++) {
- TheDist(0,NoV) = RealLast();
- TheDist(myusample+1,NoV) = RealLast();
- }
- for (NoU = 1; NoU <= myusample; NoU++) {
- TheDist(NoU,0) = RealLast();
- TheDist(NoU,myvsample+1) = RealLast();
- }
-// - du tableau TbSel(0,myusample+1,0,myvsample+1) de selection des points
- TColStd_Array2OfInteger TbSel(0,myusample+1,0,myvsample+1);
- TbSel.Init(0);
-/*
- b.b) Calcul des minima:
-*/
-// - recherche d un minimum sur la grille
- math_Vector errors(1,2);
- math_Vector root(1, 2);
- Standard_Real eps = 1.e-9;
- Standard_Integer nbsubsample = 11;
- Standard_Integer Nu, Nv;
- Standard_Real Dist;
- for (NoU = 1; NoU <= myusample; NoU++) {
- for (NoV = 1; NoV <= myvsample; NoV++) {
- if (TbSel(NoU,NoV) == 0) {
- Dist = TheDist(NoU,NoV);
- if ((TheDist(NoU-1,NoV-1) >= Dist) &&
- (TheDist(NoU-1,NoV ) >= Dist) &&
- (TheDist(NoU-1,NoV+1) >= Dist) &&
- (TheDist(NoU ,NoV-1) >= Dist) &&
- (TheDist(NoU ,NoV+1) >= Dist) &&
- (TheDist(NoU+1,NoV-1) >= Dist) &&
- (TheDist(NoU+1,NoV ) >= Dist) &&
- (TheDist(NoU+1,NoV+1) >= Dist)) {
-
-// - calcul de l extremum sur la surface:
- UV(1) = U0 + (NoU - 1) * PasU;
- UV(2) = V0 + (NoV - 1) * PasV;
-// Modified by skv - Thu Sep 30 15:21:07 2004 OCC593 Begin
-// math_FunctionSetRoot S (myF,UV,Tol,UVinf,UVsup);
- // Default value for math_FunctionSetRoot.
- Standard_Integer aNbMaxIter = 100;
-
- if (myF.HasDegIso())
- aNbMaxIter = 150;
-
- math_FunctionSetRoot S (myF,UV,Tol,UVinf,UVsup, aNbMaxIter);
- if(S.IsDone()) {
- root = S.Root();
- myF.Value(root, errors);
- if(Abs(errors(1)) > eps || Abs(errors(2)) > eps) {
- //try to improve solution on subgrid of sample points
- gp_Pnt PSol = myS->Value(root(1), root(2));
- Standard_Real DistSol = P.SquareDistance(PSol);
-
- Standard_Real u1 = Max(UV(1) - PasU, myumin), u2 = Min(UV(1) + PasU, myusup);
- Standard_Real v1 = Max(UV(2) - PasV, myvmin), v2 = Min(UV(2) + PasV, myvsup);
-
- if(u2 - u1 < 2.*PasU) {
- if(Abs(u1 - myumin) < 1.e-9) {
- u2 = u1 + 2.*PasU;
- u2 = Min(u2, myusup);
- }
- if(Abs(u2 - myusup) < 1.e-9) {
- u1 = u2 - 2.*PasU;
- u1 = Max(u1, myumin);
- }
- }
+ TColStd_Array2OfInteger TbSel(0,myusample+1,0,myvsample+1);
+ TbSel.Init(0);
- if(v2 - v1 < 2.*PasV) {
- if(Abs(v1 - myvmin) < 1.e-9) {
- v2 = v1 + 2.*PasV;
- v2 = Min(v2, myvsup);
- }
- if(Abs(v2 - myvsup) < 1.e-9) {
- v1 = v2 - 2.*PasV;
- v1 = Max(v1, myvmin);
- }
- }
-
- Standard_Real du = (u2 - u1)/(nbsubsample-1);
- Standard_Real dv = (v2 - v1)/(nbsubsample-1);
- Standard_Real u, v;
- Standard_Real dist;
-
- Standard_Boolean NewSolution = Standard_False;
- for (Nu = 1, u = u1; Nu < nbsubsample; Nu++, u += du) {
- for (Nv = 1, v = v1; Nv < nbsubsample; Nv++, v += dv) {
- gp_Pnt Puv = myS->Value(u, v);
- dist = P.SquareDistance(Puv);
-
- if(dist < DistSol) {
- UV(1) = u;
- UV(2) = v;
- NewSolution = Standard_True;
- DistSol = dist;
- }
- }
- }
- if(NewSolution) {
- //try to precise
- math_FunctionSetRoot S (myF,UV,Tol,UVinf,UVsup, aNbMaxIter);
- }
+ Standard_Real Dist;
- }
- }
-// Modified by skv - Thu Sep 30 15:21:07 2004 OCC593 End
-
-// - mise a jour du tableau TbSel
- for (Nu = NoU-1; Nu <= NoU+1; Nu++) {
- for (Nv = NoV-1; Nv <= NoV+1; Nv++) {
- TbSel(Nu,Nv) = 1;
- }
- }
- }
- } // if (TbSel(NoU,NoV)
- } // for (NoV = 1; ...
- } // for (NoU = 1; ...
-/*
-c- Calcul des maxima:
- -----------------
- c.a) Initialisations:
-*/
-// - des 'bords' du tableau mytbdist
- for (NoV = 0; NoV <= myvsample+1; NoV++) {
- TheDist(0,NoV) = RealFirst();
- TheDist(myusample+1,NoV) = RealFirst();
- }
- for (NoU = 1; NoU <= myusample; NoU++) {
- TheDist(NoU,0) = RealFirst();
- TheDist(NoU,myvsample+1) = RealFirst();
+ if(myFlag == Extrema_ExtFlag_MIN || myFlag == Extrema_ExtFlag_MINMAX)
+ {
+ for (NoV = 0; NoV <= myvsample+1; NoV++) {
+ TheDist(0,NoV) = RealLast();
+ TheDist(myusample+1,NoV) = RealLast();
+ }
+ for (NoU = 1; NoU <= myusample; NoU++) {
+ TheDist(NoU,0) = RealLast();
+ TheDist(NoU,myvsample+1) = RealLast();
+ }
+ for (NoU = 1; NoU <= myusample; NoU++) {
+ for (NoV = 1; NoV <= myvsample; NoV++) {
+ if (TbSel(NoU,NoV) == 0) {
+ Dist = TheDist(NoU,NoV);
+ if ((TheDist(NoU-1,NoV-1) >= Dist) &&
+ (TheDist(NoU-1,NoV ) >= Dist) &&
+ (TheDist(NoU-1,NoV+1) >= Dist) &&
+ (TheDist(NoU ,NoV-1) >= Dist) &&
+ (TheDist(NoU ,NoV+1) >= Dist) &&
+ (TheDist(NoU+1,NoV-1) >= Dist) &&
+ (TheDist(NoU+1,NoV ) >= Dist) &&
+ (TheDist(NoU+1,NoV+1) >= Dist)) {
+ //Create array of UV vectors to calculate min
+ UV(1) = U0 + (NoU - 1) * PasU;
+ UV(2) = V0 + (NoV - 1) * PasV;
+ FindSolution(P, UV, PasU, PasV, Extrema_ExtFlag_MIN);
+ }
+ }
+ }
+ }
+ }
+
+ if(myFlag == Extrema_ExtFlag_MAX || myFlag == Extrema_ExtFlag_MINMAX)
+ {
+ for (NoV = 0; NoV <= myvsample+1; NoV++) {
+ TheDist(0,NoV) = RealFirst();
+ TheDist(myusample+1,NoV) = RealFirst();
+ }
+ for (NoU = 1; NoU <= myusample; NoU++) {
+ TheDist(NoU,0) = RealFirst();
+ TheDist(NoU,myvsample+1) = RealFirst();
+ }
+ for (NoU = 1; NoU <= myusample; NoU++) {
+ for (NoV = 1; NoV <= myvsample; NoV++) {
+ if (TbSel(NoU,NoV) == 0) {
+ Dist = TheDist(NoU,NoV);
+ if ((TheDist(NoU-1,NoV-1) <= Dist) &&
+ (TheDist(NoU-1,NoV ) <= Dist) &&
+ (TheDist(NoU-1,NoV+1) <= Dist) &&
+ (TheDist(NoU ,NoV-1) <= Dist) &&
+ (TheDist(NoU ,NoV+1) <= Dist) &&
+ (TheDist(NoU+1,NoV-1) <= Dist) &&
+ (TheDist(NoU+1,NoV ) <= Dist) &&
+ (TheDist(NoU+1,NoV+1) <= Dist)) {
+ //Create array of UV vectors to calculate max
+ UV(1) = U0 + (NoU - 1) * PasU;
+ UV(2) = V0 + (NoV - 1) * PasV;
+ FindSolution(P, UV, PasU, PasV, Extrema_ExtFlag_MAX);
+ }
+ }
+ }
+ }
+ }
}
-
-// - du tableau TbSel(0,myusample+1,0,myvsample+1) de selection des points
- for (NoU = 0; NoU <= myusample+1; NoU++) {
- for (NoV = 0; NoV <= myvsample+1; NoV++) {
- TbSel(NoU,NoV) = 0;
+ else
+ {
+ BuildTree();
+ if(myFlag == Extrema_ExtFlag_MIN || myFlag == Extrema_ExtFlag_MINMAX)
+ {
+ Bnd_Sphere aSol = mySphereArray->Value(0);
+ Bnd_SphereUBTreeSelectorMin aSelector(mySphereArray, aSol);
+ //aSelector.SetMaxDist( RealLast() );
+ aSelector.DefineCheckPoint( P );
+ Standard_Integer aNbSel = mySphereUBTree.Select( aSelector );
+ //TODO: check if no solution in binary tree
+ Bnd_Sphere& aSph = aSelector.Sphere();
+
+ UV(1) = U0 + (aSph.U() - 1) * PasU;
+ UV(2) = V0 + (aSph.V() - 1) * PasV;
+
+ FindSolution(P, UV, PasU, PasV, Extrema_ExtFlag_MIN);
+ }
+ if(myFlag == Extrema_ExtFlag_MAX || myFlag == Extrema_ExtFlag_MINMAX)
+ {
+ Bnd_Sphere aSol = mySphereArray->Value(0);
+ Bnd_SphereUBTreeSelectorMax aSelector(mySphereArray, aSol);
+ //aSelector.SetMaxDist( RealLast() );
+ aSelector.DefineCheckPoint( P );
+ Standard_Integer aNbSel = mySphereUBTree.Select( aSelector );
+ //TODO: check if no solution in binary tree
+ Bnd_Sphere& aSph = aSelector.Sphere();
+
+ UV(1) = U0 + (aSph.U() - 1) * PasU;
+ UV(2) = V0 + (aSph.V() - 1) * PasV;
+
+ FindSolution(P, UV, PasU, PasV, Extrema_ExtFlag_MAX);
}
}
-/*
- c.b) Calcul des maxima:
-*/
-// - recherche d un maximum sur la grille
- for (NoU = 1; NoU <= myusample; NoU++) {
- for (NoV = 1; NoV <= myvsample; NoV++) {
- if (TbSel(NoU,NoV) == 0) {
- Dist = TheDist(NoU,NoV);
- if ((TheDist(NoU-1,NoV-1) <= Dist) &&
- (TheDist(NoU-1,NoV ) <= Dist) &&
- (TheDist(NoU-1,NoV+1) <= Dist) &&
- (TheDist(NoU ,NoV-1) <= Dist) &&
- (TheDist(NoU ,NoV+1) <= Dist) &&
- (TheDist(NoU+1,NoV-1) <= Dist) &&
- (TheDist(NoU+1,NoV ) <= Dist) &&
- (TheDist(NoU+1,NoV+1) <= Dist)) {
-
-// - calcul de l extremum sur la surface:
- UV(1) = U0 + (NoU - 1) * PasU;
- UV(2) = V0 + (NoV - 1) * PasV;
-// Modified by skv - Thu Sep 30 15:21:07 2004 OCC593 Begin
-// math_FunctionSetRoot S (myF,UV,Tol,UVinf,UVsup);
- // Default value for math_FunctionSetRoot.
- Standard_Integer aNbMaxIter = 100;
-
- if (myF.HasDegIso())
- aNbMaxIter = 150;
-
- math_FunctionSetRoot S (myF,UV,Tol,UVinf,UVsup, aNbMaxIter);
- if(S.IsDone()) {
- root = S.Root();
- myF.Value(root, errors);
- }
-// Modified by skv - Thu Sep 30 15:21:07 2004 OCC593 End
-
-// - mise a jour du tableau TbSel
- for (Nu = NoU-1; Nu <= NoU+1; Nu++) {
- for (Nv = NoV-1; Nv <= NoV+1; Nv++) {
- TbSel(Nu,Nv) = 1;
- }
- }
- }
- } // if (TbSel(NoU,NoV))
- } // for (NoV = 1; ...)
- } // for (NoU = 1; ...)
- myDone = Standard_True;
}
//=============================================================================
return myF.Point(N);
}
//=============================================================================
-
--- /dev/null
+// File: BestFitBnd_HUBTreeOfSphere.cxx
+// Created: Thu Mar 17 14:30:42 2005
+// Author: OPEN CASCADE Support
+// Copyright: OPEN CASCADE SA 2005
+
+#include <Extrema_HUBTreeOfSphere.hxx>
+
+IMPLEMENT_HUBTREE(Extrema_HUBTreeOfSphere,MMgt_TShared)
--- /dev/null
+// File: BestFitBnd_HUBTreeOfSphere.hxx
+// Created: Thu Mar 17 14:30:42 2005
+// Author: OPEN CASCADE Support
+// Copyright: OPEN CASCADE SA 2005
+
+#ifndef _Extrema_HUBTreeOfSphere_HeaderFile
+#define _Extrema_HUBTreeOfSphere_HeaderFile
+
+#include <NCollection_UBTree.hxx>
+#include <NCollection_UBTreeFiller.hxx>
+#include <Bnd_Sphere.hxx>
+
+typedef NCollection_UBTree<Standard_Integer,Bnd_Sphere> Extrema_UBTreeOfSphere;
+typedef NCollection_UBTreeFiller<Standard_Integer,Bnd_Sphere> Extrema_UBTreeFillerOfSphere;
+DEFINE_HUBTREE(Extrema_HUBTreeOfSphere, Standard_Integer, Bnd_Sphere, MMgt_TShared)
+
+#endif //_Extrema_HUBTreeOfSphere_HeaderFile
--- /dev/null
+Extrema_HUBTreeOfSphere.hxx
+Extrema_HUBTreeOfSphere.cxx
projects / occt.git / commitdiff