OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0024470: Wrong result done by General Fuse algorithm.

Browse Source 
Modifications:
1. The validity of the intersection point between edge and face is checked with sum of the tolerance values of the edge and face.
2. The intersection between toroidal surface and one of the following surfaces: Plane, Cylinder, Sphere, Cone or Torus
   is treated as analytical in the following cases:
   1) Torus and Plane: a. Axes of the surfaces are parallel;
                       b. Axes of the surfaces are perpendicular and location of the torus is lying on the plane;
   2) Torus and Sphere: The location of the sphere is lying on the line made from toruses axis;
   3) Torus and Cone, Cylinder or Torus: The axis of the surfaces are collinear.
   In all cases the intersection line(s) is(are) circle(s).

Added test cases bugs/modalg_5/bug24470

The intersection between torus with minor radius more than (or equal to) the major radius and any other surface is considered as parametric.
This commit is contained in:
emv 2014-01-09 12:01:01 +04:00 committed by bugmaster
parent 547702a15d
commit 7eed5d29a9
21 changed files with 2489 additions and 1360 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/BOPAlgo/BOPAlgo_PaveFiller_3.cxx
View File

@ -328,14 +328,11 @@
break;
//
case TopAbs_EDGE: {
Standard_Boolean bHasSameBounds;
Standard_Integer aNbComPrt2;
//
aNbComPrt2=aCPart.Ranges2().Length();
if (aNbComPrt2>1){
if (aNbCPrts > 1) {
break;
}
//// <-LXBR
//
Standard_Boolean bHasSameBounds;
bHasSameBounds=aPB1->HasSameBounds(aPB2);
if (!bHasSameBounds) {
break;

2
src/BOPAlgo/BOPAlgo_PaveFiller_5.cxx
View File

@ -231,7 +231,7 @@
}
//
const gp_Pnt& aPnew = BRep_Tool::Pnt(aVnew);
if (!myContext->IsValidPointForFace(aPnew, aF, aTolE)) {
if (!myContext->IsValidPointForFace(aPnew, aF, aTolE+aTolF)) {
continue;
}
//

1
src/GeomInt/GeomInt_IntSS_1.cxx
View File

@ -1113,6 +1113,7 @@ Standard_Real ProjectPointOnSurf::LowerDistance() const
case GeomAbs_Cylinder: quad1.SetValue(HS1->Surface().Cylinder()); break;
case GeomAbs_Cone: quad1.SetValue(HS1->Surface().Cone()); break;
case GeomAbs_Sphere: quad1.SetValue(HS1->Surface().Sphere()); break;
case GeomAbs_Torus: quad1.SetValue(HS1->Surface().Torus()); break;
default: Standard_ConstructionError::Raise("GeomInt_IntSS::MakeCurve");
}
}

2
src/GeomInt/GeomInt_LineConstructor.cxx
View File

@ -148,6 +148,7 @@ static void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
case GeomAbs_Cylinder: quad1.SetValue(myHS1->Surface().Cylinder()); break;
case GeomAbs_Cone: quad1.SetValue(myHS1->Surface().Cone()); break;
case GeomAbs_Sphere: quad1.SetValue(myHS1->Surface().Sphere()); break;
case GeomAbs_Torus: quad1.SetValue(myHS1->Surface().Torus()); break;
default: Standard_ConstructionError::Raise("GeomInt_LineConstructor::Parameters");
}
switch (myHS2->Surface().GetType())
@ -156,6 +157,7 @@ static void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
case GeomAbs_Cylinder: quad2.SetValue(myHS2->Surface().Cylinder()); break;
case GeomAbs_Cone: quad2.SetValue(myHS2->Surface().Cone()); break;
case GeomAbs_Sphere: quad2.SetValue(myHS2->Surface().Sphere()); break;
case GeomAbs_Torus: quad2.SetValue(myHS2->Surface().Torus()); break;
default: Standard_ConstructionError::Raise("GeomInt_LineConstructor::Parameters");
}
quad1.Parameters(Ptref,U1,V1);

177
src/IntAna/IntAna_QuadQuadGeo.cdl
View File

@ -37,6 +37,7 @@ uses Pln from gp,
Cylinder from gp,
Cone from gp,
Sphere from gp,
Torus from gp,
Pnt from gp,
Lin from gp,
Circ from gp,
@ -54,34 +55,28 @@ raises NotDone from StdFail,
is
Create
---Purpose: Empty constructor.
returns QuadQuadGeo from IntAna;
Create(P1,P2 : Pln from gp;
TolAng, Tol : Real from Standard)
---Purpose: Creates the intersection between two planes.
-- TolAng is the angular tolerance used to determine
-- if the planes are parallel.
-- Tol is the tolerance used to determine if the planes
-- are identical (only when they are parallel).
returns QuadQuadGeo from IntAna;
Perform(me : in out;
P1,P2 : Pln from gp;
TolAng, Tol : Real from Standard)
---Purpose: Intersects two planes.
-- TolAng is the angular tolerance used to determine
-- if the planes are parallel.
-- Tol is the tolerance used to determine if the planes
-- are identical (only when they are parallel).
is static;
@ -98,7 +93,6 @@ is
-- center is less than Tol, the result will be the circle.
-- H is the height of the cylinder <Cyl>. It is used to check
-- whether the plane and cylinder are parallel.
returns QuadQuadGeo from IntAna;
@ -107,7 +101,6 @@ is
C : Cylinder from gp;
Tolang,Tol: Real from Standard;
H :Real from Standard = 0)
---Purpose: Intersects a plane and a cylinder.
-- TolAng is the angular tolerance used to determine
-- if the axis of the cylinder is parallel to the plane.
@ -117,31 +110,25 @@ is
-- center is less than Tol, the result will be the circle.
-- H is the height of the cylinder <Cyl>. It is used to check
-- whether the plane and cylinder are parallel.
is static;
Create(P : Pln from gp;
S : Sphere from gp)
---Purpose: Creates the intersection between a plane and a sphere.
returns QuadQuadGeo from IntAna;
Perform(me: in out;
P : Pln from gp;
S : Sphere from gp)
---Purpose: Intersects a plane and a sphere.
is static;
Create(P : Pln from gp;
C : Cone from gp;
Tolang,Tol: Real from Standard)
---Purpose: Creates the intersection between a plane and a cone.
-- TolAng is the angular tolerance used to determine
-- if the axis of the cone is parallel or perpendicular
@ -149,7 +136,6 @@ is
-- is parallel to the plane.
-- Tol is the tolerance used to determine if the apex
-- of the cone is in the plane.
returns QuadQuadGeo from IntAna;
@ -157,7 +143,6 @@ is
P : Pln from gp;
C : Cone from gp;
Tolang,Tol: Real from Standard)
---Purpose: Intersects a plane and a cone.
-- TolAng is the angular tolerance used to determine
-- if the axis of the cone is parallel or perpendicular
@ -165,33 +150,26 @@ is
-- is parallel to the plane.
-- Tol is the tolerance used to determine if the apex
-- of the cone is in the plane.
is static;
Create(Cyl1,Cyl2: Cylinder from gp;
Tol : Real from Standard)
---Purpose: Creates the intersection between two cylinders.
returns QuadQuadGeo from IntAna;
Perform(me : in out;
Cyl1,Cyl2: Cylinder from gp;
Tol : Real from Standard)
---Purpose: Intersects two cylinders
is static;
Create(Cyl: Cylinder from gp;
Sph: Sphere from gp;
Tol: Real from Standard)
---Purpose: Creates the intersection between a Cylinder and a Sphere.
returns QuadQuadGeo from IntAna;
@ -199,18 +177,14 @@ is
Cyl: Cylinder from gp;
Sph: Sphere from gp;
Tol: Real from Standard)
---Purpose: Intersects a cylinder and a sphere.
is static;
Create(Cyl: Cylinder from gp;
Con: Cone from gp;
Tol: Real from Standard)
---Purpose: Creates the intersection between a Cylinder and a Cone
returns QuadQuadGeo from IntAna;
@ -218,18 +192,14 @@ is
Cyl: Cylinder from gp;
Con: Cone from gp;
Tol: Real from Standard)
---Purpose: Intersects a cylinder and a cone.
is static;
Create(Sph1: Sphere from gp;
Sph2: Sphere from gp;
Tol : Real from Standard)
---Purpose: Creates the intersection between two Spheres.
returns QuadQuadGeo from IntAna;
@ -237,18 +207,14 @@ is
Sph1: Sphere from gp;
Sph2: Sphere from gp;
Tol : Real from Standard)
---Purpose: Intersects a two spheres.
is static;
Create(Sph: Sphere from gp;
Con: Cone from gp;
Tol: Real from Standard)
---Purpose: Creates the intersection beween a Sphere and a Cone.
returns QuadQuadGeo from IntAna;
@ -256,16 +222,14 @@ is
Sph: Sphere from gp;
Con: Cone from gp;
Tol: Real from Standard)
---Purpose: Intersects a sphere and a cone.
is static;
Create(Con1: Cone from gp; Con2: Cone from gp; Tol:Real from Standard)
Create(Con1: Cone from gp;
Con2: Cone from gp;
Tol : Real from Standard)
---Purpose: Creates the intersection beween two cones.
returns QuadQuadGeo from IntAna;
@ -273,38 +237,104 @@ is
Con1: Cone from gp;
Con2: Cone from gp;
Tol :Real from Standard)
---Purpose: Intersects two cones.
is static;
Create(Pln : Pln from gp;
Tor : Torus from gp;
Tol : Real from Standard)
---Purpose: Creates the intersection beween plane and torus.
returns QuadQuadGeo from IntAna;
Perform(me :in out;
Pln : Pln from gp;
Tor : Torus from gp;
Tol : Real from Standard)
---Purpose: Intersects plane and torus.
is static;
Create(Cyl : Cylinder from gp;
Tor : Torus from gp;
Tol : Real from Standard)
---Purpose: Creates the intersection beween cylinder and torus.
returns QuadQuadGeo from IntAna;
Perform(me : in out;
Cyl : Cylinder from gp;
Tor : Torus from gp;
Tol : Real from Standard)
---Purpose: Intersects cylinder and torus.
is static;
Create(Con : Cone from gp;
Tor : Torus from gp;
Tol : Real from Standard)
---Purpose: Creates the intersection beween cone and torus.
returns QuadQuadGeo from IntAna;
Perform(me : in out;
Con : Cone from gp;
Tor : Torus from gp;
Tol : Real from Standard)
---Purpose: Intersects cone and torus.
is static;
Create(Sph : Sphere from gp;
Tor : Torus from gp;
Tol : Real from Standard)
---Purpose: Creates the intersection beween sphere and torus.
returns QuadQuadGeo from IntAna;
Perform(me : in out;
Sph : Sphere from gp;
Tor : Torus from gp;
Tol : Real from Standard)
---Purpose: Intersects sphere and torus.
is static;
Create(Tor1 : Torus from gp;
Tor2 : Torus from gp;
Tol : Real from Standard)
---Purpose: Creates the intersection beween two toruses.
returns QuadQuadGeo from IntAna;
Perform(me : in out;
Tor1 : Torus from gp;
Tor2 : Torus from gp;
Tol : Real from Standard)
---Purpose: Intersects two toruses.
is static;
IsDone(me)
---Purpose: Returns Standard_True if the computation was successful.
--
---C++: inline
returns Boolean from Standard
is static;
TypeInter(me)
---Purpose: Returns the type of intersection.
--
---C++: inline
returns ResultType from IntAna
raises NotDone from StdFail
--- The exception NotDone is raised if IsDone return Standard_False.
-- The exception NotDone is raised if IsDone return Standard_False.
is static;
NbSolutions(me)
---Purpose: Returns the number of interesections.
-- The possible intersections are :
-- - 1 point
@ -316,114 +346,87 @@ is
-- - 1 or 2 hyperbola(s).
--
---C++: inline
returns Integer from Standard
raises NotDone from StdFail
--- The exception NotDone is raised if IsDone returns Standard_False.
-- The exception NotDone is raised if IsDone returns Standard_False.
is static;
Point(me; Num: Integer from Standard)
---Purpose: Returns the point solution of range Num.
returns Pnt from gp
raises DomainError from Standard,
OutOfRange from Standard,
NotDone from StdFail
--- The exception NotDone is raised if IsDone return Standard_False.
-- The exception NotDone is raised if IsDone return Standard_False.
-- The exception DomainError is raised if TypeInter does not return
-- IntAna_Point or TypeInter does not return IntAna_PointAndCircle.
-- The exception OutOfRange is raised if Num < 1 or Num > NbSolutions.
is static;
Line(me; Num: Integer from Standard)
---Purpose: Returns the line solution of range Num.
returns Lin from gp
raises DomainError from Standard,
OutOfRange from Standard,
NotDone from StdFail
--- The exception NotDone is raised if IsDone return Standard_False.
-- The exception NotDone is raised if IsDone return Standard_False.
-- The exception DomainError is raised if TypeInter does not return
-- IntAna_Line.
-- The exception OutOfRange is raised if Num < 1 or Num > NbSolutions.
is static;
Circle(me; Num: Integer from Standard)
---Purpose: Returns the circle solution of range Num.
returns Circ from gp
raises DomainError from Standard,
OutOfRange from Standard,
NotDone from StdFail
--- The exception NotDone is raised if IsDone return Standard_False.
-- The exception NotDone is raised if IsDone return Standard_False.
-- The exception DomainError is raised if TypeInter does not return
-- IntAna_Circle or TypeInter does not return IntAna_PointAndCircle.
-- The exception OutOfRange is raised if Num < 1 or Num > NbSolutions.
is static;
Ellipse(me; Num: Integer from Standard)
---Purpose: Returns the ellipse solution of range Num.
returns Elips from gp
raises DomainError from Standard,
OutOfRange from Standard,
NotDone from StdFail
--- The exception NotDone is raised if IsDone return Standard_False.
-- The exception NotDone is raised if IsDone return Standard_False.
-- The exception DomainError is raised if TypeInter does not return
-- IntAna_Ellipse.
-- The exception OutOfRange is raised if Num < 1 or Num > NbSolutions.
is static;
Parabola(me; Num: Integer from Standard)
---Purpose: Returns the parabola solution of range Num.
returns Parab from gp
raises DomainError from Standard,
OutOfRange from Standard,
NotDone from StdFail
--- The exception NotDone is raised if IsDone return Standard_False.
-- The exception NotDone is raised if IsDone return Standard_False.
-- The exception DomainError is raised if TypeInter does not return
-- IntAna_Parabola.
-- The exception OutOfRange is raised if Num < 1 or Num > NbSolutions.
is static;
Hyperbola(me; Num: Integer from Standard)
---Purpose: Returns the hyperbola solution of range Num.
returns Hypr from gp
raises DomainError from Standard,
OutOfRange from Standard,
NotDone from StdFail
--- The exception NotDone is raised if IsDone return Standard_False.
-- The exception NotDone is raised if IsDone return Standard_False.
-- The exception DomainError is raised if TypeInter does not return
-- IntAna_Hyperbola.
-- The exception OutOfRange is raised if Num < 1 or Num > NbSolutions.
is static;
HasCommonGen(me) returns Boolean from Standard;
@ -431,9 +434,7 @@ is
---C++: return const&
InitTolerances(me:out)
---Purpose: Initialize the values of inner tolerances.
is protected;
fields
@ -445,12 +446,18 @@ fields
pt1 : Pnt from gp is protected;
pt2 : Pnt from gp is protected;
pt3 : Pnt from gp is protected;
pt4 : Pnt from gp is protected;
dir1 : Dir from gp is protected;
dir2 : Dir from gp is protected;
dir3 : Dir from gp is protected;
dir4 : Dir from gp is protected;
param1 : Real from Standard is protected;
param2 : Real from Standard is protected;
param3 : Real from Standard is protected;
param4 : Real from Standard is protected;
param1bis : Real from Standard is protected;
param2bis : Real from Standard is protected;
--

586
src/IntAna/IntAna_QuadQuadGeo.cxx
View File

@ -247,8 +247,12 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
@ -282,8 +286,12 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
@ -360,8 +368,12 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
@ -546,8 +558,12 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
@ -758,8 +774,12 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
@ -823,8 +843,12 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
@ -1023,8 +1047,12 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
@ -1075,8 +1103,12 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
@ -1137,8 +1169,12 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
@ -1589,8 +1625,12 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
@ -1697,8 +1737,12 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
@ -1794,6 +1838,542 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
}
}
}
//=======================================================================
//function : IntAna_QuadQuadGeo
//purpose : Plane - Torus
//=======================================================================
IntAna_QuadQuadGeo::IntAna_QuadQuadGeo(const gp_Pln& Pln,
const gp_Torus& Tor,
const Standard_Real Tol)
: done(Standard_False),
nbint(0),
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
myPChar(0,0,0)
{
InitTolerances();
Perform(Pln,Tor,Tol);
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
void IntAna_QuadQuadGeo::Perform(const gp_Pln& Pln,
const gp_Torus& Tor,
const Standard_Real Tol)
{
done = Standard_True;
//
Standard_Real aRMin, aRMaj;
//
aRMin = Tor.MinorRadius();
aRMaj = Tor.MajorRadius();
if (aRMin >= aRMaj) {
typeres = IntAna_NoGeometricSolution;
return;
}
//
const gp_Ax1 aPlnAx = Pln.Axis();
const gp_Ax1 aTorAx = Tor.Axis();
//
Standard_Boolean bParallel, bNormal;
//
bParallel = aTorAx.IsParallel(aPlnAx, myEPSILON_AXES_PARA);
bNormal = !bParallel ? aTorAx.IsNormal(aPlnAx, myEPSILON_AXES_PARA) : Standard_False;
if (!bNormal && !bParallel) {
typeres = IntAna_NoGeometricSolution;
return;
}
//
Standard_Real aDist;
//
gp_Pnt aTorLoc = aTorAx.Location();
if (bParallel) {
Standard_Real aDt, X, Y, Z, A, B, C, D;
//
Pln.Coefficients(A,B,C,D);
aTorLoc.Coord(X,Y,Z);
aDist = A*X + B*Y + C*Z + D;
//
if ((Abs(aDist) - aRMin) > Tol) {
typeres=IntAna_Empty;
return;
}
//
typeres = IntAna_Circle;
//
pt1.SetCoord(X - aDist*A, Y - aDist*B, Z - aDist*C);
aDt = Sqrt(Abs(aRMin*aRMin - aDist*aDist));
param1 = aRMaj + aDt;
dir1 = aTorAx.Direction();
nbint = 1;
if ((Abs(aDist) < aRMin) && (aDt > Tol)) {
pt2 = pt1;
param2 = aRMaj - aDt;
dir2 = dir1;
nbint = 2;
}
}
//
else {
aDist = Pln.Distance(aTorLoc);
if (aDist > myEPSILON_DISTANCE) {
typeres = IntAna_NoGeometricSolution;
return;
}
//
typeres = IntAna_Circle;
param2 = param1 = aRMin;
dir2 = dir1 = aPlnAx.Direction();
nbint = 2;
//
gp_Dir aDir = aTorAx.Direction()^dir1;
pt1.SetXYZ(aTorLoc.XYZ() + aRMaj*aDir.XYZ());
pt2.SetXYZ(aTorLoc.XYZ() - aRMaj*aDir.XYZ());
}
}
//=======================================================================
//function : IntAna_QuadQuadGeo
//purpose : Cylinder - Torus
//=======================================================================
IntAna_QuadQuadGeo::IntAna_QuadQuadGeo(const gp_Cylinder& Cyl,
const gp_Torus& Tor,
const Standard_Real Tol)
: done(Standard_False),
nbint(0),
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
myPChar(0,0,0)
{
InitTolerances();
Perform(Cyl,Tor,Tol);
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
void IntAna_QuadQuadGeo::Perform(const gp_Cylinder& Cyl,
const gp_Torus& Tor,
const Standard_Real Tol)
{
done = Standard_True;
//
Standard_Real aRMin, aRMaj;
//
aRMin = Tor.MinorRadius();
aRMaj = Tor.MajorRadius();
if (aRMin >= aRMaj) {
typeres = IntAna_NoGeometricSolution;
return;
}
//
const gp_Ax1 aCylAx = Cyl.Axis();
const gp_Ax1 aTorAx = Tor.Axis();
//
const gp_Lin aLin(aTorAx);
const gp_Pnt aLocCyl = Cyl.Location();
//
if (!aTorAx.IsParallel(aCylAx, myEPSILON_AXES_PARA) ||
(aLin.Distance(aLocCyl) > myEPSILON_DISTANCE)) {
typeres = IntAna_NoGeometricSolution;
return;
}
//
Standard_Real aRCyl;
//
aRCyl = Cyl.Radius();
if (((aRCyl + Tol) < (aRMaj - aRMin)) || ((aRCyl - Tol) > (aRMaj + aRMin))) {
typeres = IntAna_Empty;
return;
}
//
typeres = IntAna_Circle;
//
Standard_Real aDist = Sqrt(Abs(aRMin*aRMin - (aRCyl-aRMaj)*(aRCyl-aRMaj)));
gp_XYZ aTorLoc = aTorAx.Location().XYZ();
//
dir1 = aTorAx.Direction();
pt1.SetXYZ(aTorLoc + aDist*dir1.XYZ());
param1 = aRCyl;
nbint = 1;
if ((aDist > Tol) && (aRCyl > (aRMaj - aRMin)) &&
(aRCyl < (aRMaj + aRMin))) {
dir2 = dir1;
pt2.SetXYZ(aTorLoc - aDist*dir2.XYZ());
param2 = param1;
nbint = 2;
}
}
//=======================================================================
//function : IntAna_QuadQuadGeo
//purpose : Cone - Torus
//=======================================================================
IntAna_QuadQuadGeo::IntAna_QuadQuadGeo(const gp_Cone& Con,
const gp_Torus& Tor,
const Standard_Real Tol)
: done(Standard_False),
nbint(0),
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
myPChar(0,0,0)
{
InitTolerances();
Perform(Con,Tor,Tol);
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
void IntAna_QuadQuadGeo::Perform(const gp_Cone& Con,
const gp_Torus& Tor,
const Standard_Real Tol)
{
done = Standard_True;
//
Standard_Real aRMin, aRMaj;
//
aRMin = Tor.MinorRadius();
aRMaj = Tor.MajorRadius();
if (aRMin >= aRMaj) {
typeres = IntAna_NoGeometricSolution;
return;
}
//
const gp_Ax1 aConAx = Con.Axis();
const gp_Ax1 aTorAx = Tor.Axis();
//
const gp_Lin aLin(aTorAx);
const gp_Pnt aConApex = Con.Apex();
//
if (!aTorAx.IsParallel(aConAx, myEPSILON_AXES_PARA) ||
(aLin.Distance(aConApex) > myEPSILON_DISTANCE)) {
typeres = IntAna_NoGeometricSolution;
return;
}
//
Standard_Real anAngle, aDist, aParam[4];
Standard_Integer i;
gp_Pnt aTorLoc, aPCT, aPN, aPt[4];
gp_Dir aDir[4];
//
anAngle = Con.SemiAngle();
aTorLoc = aTorAx.Location();
//
aPN.SetXYZ(aTorLoc.XYZ() + aRMaj*Tor.YAxis().Direction().XYZ());
gp_Dir aDN (gp_Vec(aTorLoc, aPN));
gp_Ax1 anAxCLRot(aConApex, aDN);
gp_Lin aConL = aLin.Rotated(anAxCLRot, anAngle);
gp_Dir aDL = aConL.Position().Direction();
gp_Dir aXDir = Tor.XAxis().Direction();
//
typeres = IntAna_Empty;
//
for (i = 0; i < 2; ++i) {
if (i) {
aXDir.Reverse();
}
aPCT.SetXYZ(aTorLoc.XYZ() + aRMaj*aXDir.XYZ());
//
aDist = aConL.Distance(aPCT);
if (aDist > aRMin+Tol) {
continue;
}
//
typeres = IntAna_Circle;
//
gp_XYZ aPh = aPCT.XYZ() - aDist*aConL.Normal(aPCT).Direction().XYZ();
aDist = Sqrt(Abs(aRMin*aRMin - aDist*aDist));
//
gp_Pnt aP;
gp_XYZ aDVal = aDist*aDL.XYZ();
aP.SetXYZ(aPh + aDVal);
aParam[nbint] = aLin.Distance(aP);
aPt[nbint].SetXYZ(aP.XYZ() - aParam[nbint]*aXDir.XYZ());
aDir[nbint] = aTorAx.Direction();
++nbint;
if ((aDist < aRMin) && (aDVal.Modulus() > Tol)) {
aP.SetXYZ(aPh - aDVal);
aParam[nbint] = aLin.Distance(aP);
aPt[nbint].SetXYZ(aP.XYZ() - aParam[nbint]*aXDir.XYZ());
aDir[nbint] = aDir[nbint-1];
++nbint;
}
}
//
for (i = 0; i < nbint; ++i) {
switch (i) {
case 0:{
pt1 = aPt[i];
param1 = aParam[i];
dir1 = aDir[i];
break;
}
case 1:{
pt2 = aPt[i];
param2 = aParam[i];
dir2 = aDir[i];
break;
}
case 2:{
pt3 = aPt[i];
param3 = aParam[i];
dir3 = aDir[i];
break;
}
case 3:{
pt4 = aPt[i];
param4 = aParam[i];
dir4 = aDir[i];
break;
}
default:
break;
}
}
}
//=======================================================================
//function : IntAna_QuadQuadGeo
//purpose : Sphere - Torus
//=======================================================================
IntAna_QuadQuadGeo::IntAna_QuadQuadGeo(const gp_Sphere& Sph,
const gp_Torus& Tor,
const Standard_Real Tol)
: done(Standard_False),
nbint(0),
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
myPChar(0,0,0)
{
InitTolerances();
Perform(Sph,Tor,Tol);
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
void IntAna_QuadQuadGeo::Perform(const gp_Sphere& Sph,
const gp_Torus& Tor,
const Standard_Real Tol)
{
done = Standard_True;
//
Standard_Real aRMin, aRMaj;
//
aRMin = Tor.MinorRadius();
aRMaj = Tor.MajorRadius();
if (aRMin >= aRMaj) {
typeres = IntAna_NoGeometricSolution;
return;
}
//
const gp_Ax1 aTorAx = Tor.Axis();
const gp_Lin aLin(aTorAx);
const gp_Pnt aSphLoc = Sph.Location();
//
if (aLin.Distance(aSphLoc) > myEPSILON_DISTANCE) {
typeres = IntAna_NoGeometricSolution;
return;
}
//
Standard_Real aRSph, aDist;
gp_Pnt aTorLoc;
//
gp_Dir aXDir = Tor.XAxis().Direction();
aTorLoc.SetXYZ(aTorAx.Location().XYZ() + aRMaj*aXDir.XYZ());
aRSph = Sph.Radius();
//
gp_Vec aVec12(aTorLoc, aSphLoc);
aDist = aVec12.Magnitude();
if (((aDist - Tol) > (aRMin + aRSph)) ||
((aDist + Tol) < Abs(aRMin - aRSph))) {
typeres = IntAna_Empty;
return;
}
//
typeres = IntAna_Circle;
//
Standard_Real anAlpha, aBeta;
//
anAlpha = 0.5*(aRMin*aRMin - aRSph*aRSph + aDist*aDist ) / aDist;
aBeta = Sqrt(Abs(aRMin*aRMin - anAlpha*anAlpha));
//
gp_Dir aDir12(aVec12);
gp_XYZ aPh = aTorLoc.XYZ() + anAlpha*aDir12.XYZ();
gp_Dir aDC = Tor.YAxis().Direction()^aDir12;
//
gp_Pnt aP;
gp_XYZ aDVal = aBeta*aDC.XYZ();
aP.SetXYZ(aPh + aDVal);
param1 = aLin.Distance(aP);
pt1.SetXYZ(aP.XYZ() - param1*aXDir.XYZ());
dir1 = aTorAx.Direction();
nbint = 1;
if ((aDist < (aRSph + aRMin)) && (aDist > Abs(aRSph - aRMin)) &&
(aDVal.Modulus() > Tol)) {
aP.SetXYZ(aPh - aDVal);
param2 = aLin.Distance(aP);
pt2.SetXYZ(aP.XYZ() - param2*aXDir.XYZ());
dir2 = dir1;
nbint = 2;
}
}
//=======================================================================
//function : IntAna_QuadQuadGeo
//purpose : Torus - Torus
//=======================================================================
IntAna_QuadQuadGeo::IntAna_QuadQuadGeo(const gp_Torus& Tor1,
const gp_Torus& Tor2,
const Standard_Real Tol)
: done(Standard_False),
nbint(0),
typeres(IntAna_Empty),
pt1(0,0,0),
pt2(0,0,0),
pt3(0,0,0),
pt4(0,0,0),
param1(0),
param2(0),
param3(0),
param4(0),
param1bis(0),
param2bis(0),
myCommonGen(Standard_False),
myPChar(0,0,0)
{
InitTolerances();
Perform(Tor1,Tor2,Tol);
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
void IntAna_QuadQuadGeo::Perform(const gp_Torus& Tor1,
const gp_Torus& Tor2,
const Standard_Real Tol)
{
done = Standard_True;
//
Standard_Real aRMin1, aRMin2, aRMaj1, aRMaj2;
//
aRMin1 = Tor1.MinorRadius();
aRMaj1 = Tor1.MajorRadius();
aRMin2 = Tor2.MinorRadius();
aRMaj2 = Tor2.MajorRadius();
if (aRMin1 >= aRMaj1 || aRMin2 >= aRMaj2) {
typeres = IntAna_NoGeometricSolution;
return;
}
//
const gp_Ax1 anAx1 = Tor1.Axis();
const gp_Ax1 anAx2 = Tor2.Axis();
//
gp_Lin aL1(anAx1);
if (!anAx1.IsParallel(anAx2, myEPSILON_AXES_PARA) ||
(aL1.Distance(anAx2.Location()) > myEPSILON_DISTANCE)) {
typeres = IntAna_NoGeometricSolution;
return;
}
//
gp_Pnt aLoc1, aLoc2;
//
aLoc1 = anAx1.Location();
aLoc2 = anAx2.Location();
//
if (aLoc1.IsEqual(aLoc2, Tol) &&
(Abs(aRMin1 - aRMin2) <= Tol) &&
(Abs(aRMaj1 - aRMaj2) <= Tol)) {
typeres = IntAna_Same;
return;
}
//
Standard_Real aDist;
gp_Pnt aP1, aP2;
//
gp_Dir aXDir1 = Tor1.XAxis().Direction();
aP1.SetXYZ(aLoc1.XYZ() + aRMaj1*aXDir1.XYZ());
aP2.SetXYZ(aLoc2.XYZ() + aRMaj2*aXDir1.XYZ());
//
gp_Vec aV12(aP1, aP2);
aDist = aV12.Magnitude();
if (((aDist - Tol) > (aRMin1 + aRMin2)) ||
((aDist + Tol) < Abs(aRMin1 - aRMin2))) {
typeres = IntAna_Empty;
return;
}
//
typeres = IntAna_Circle;
//
Standard_Real anAlpha, aBeta;
//
anAlpha = 0.5*(aRMin1*aRMin1 - aRMin2*aRMin2 + aDist*aDist ) / aDist;
aBeta = Sqrt(Abs(aRMin1*aRMin1 - anAlpha*anAlpha));
//
gp_Dir aDir12(aV12);
gp_XYZ aPh = aP1.XYZ() + anAlpha*aDir12.XYZ();
gp_Dir aDC = Tor1.YAxis().Direction()^aDir12;
//
gp_Pnt aP;
gp_XYZ aDVal = aBeta*aDC.XYZ();
aP.SetXYZ(aPh + aDVal);
param1 = aL1.Distance(aP);
pt1.SetXYZ(aP.XYZ() - param1*aXDir1.XYZ());
dir1 = anAx1.Direction();
nbint = 1;
if ((aDist < (aRMin1 + aRMin2)) && (aDist > Abs(aRMin1 - aRMin2)) &&
aDVal.Modulus() > Tol) {
aP.SetXYZ(aPh - aDVal);
param2 = aL1.Distance(aP);
pt2.SetXYZ(aP.XYZ() - param2*aXDir1.XYZ());
dir2 = dir1;
nbint = 2;
}
}
//=======================================================================
//function : Point
//purpose : Returns a Point
@ -1843,8 +2423,10 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
else if((n>nbint) || (n<1) || (typeres!=IntAna_Circle)) {
Standard_DomainError::Raise();
}
if(n==1) { return(gp_Circ(DirToAx2(pt1,dir1),param1)); }
else { return(gp_Circ(DirToAx2(pt2,dir2),param2)); }
if (n==1) { return(gp_Circ(DirToAx2(pt1,dir1),param1));}
else if (n==2) { return(gp_Circ(DirToAx2(pt2,dir2),param2));}
else if (n==3) { return(gp_Circ(DirToAx2(pt3,dir3),param3));}
else { return(gp_Circ(DirToAx2(pt4,dir4),param4));}
}
//=======================================================================

1
src/IntPatch/FILES
View File

@ -4,3 +4,4 @@ IntPatch_ImpImpIntersection_2.gxx
IntPatch_ImpImpIntersection_3.gxx
IntPatch_ImpImpIntersection_4.gxx
IntPatch_ImpImpIntersection_5.gxx
IntPatch_ImpImpIntersection_6.gxx

6
src/IntPatch/IntPatch_ALineToWLine.cxx
View File

@ -856,6 +856,9 @@ static
case GeomAbs_Sphere:
pu1=M_PI+M_PI;
break;
case GeomAbs_Torus:
pu1=pv1=M_PI+M_PI;
break;
default:
break;
}
@ -865,6 +868,9 @@ static
case GeomAbs_Sphere:
pu2=M_PI+M_PI;
break;
case GeomAbs_Torus:
pu2=pv2=M_PI+M_PI;
break;
default:
break;
}

1
src/IntPatch/IntPatch_ImpImpIntersection.cxx
View File

@ -52,3 +52,4 @@
#include <IntPatch_ImpImpIntersection_3.gxx>
#include <IntPatch_ImpImpIntersection_4.gxx>
#include <IntPatch_ImpImpIntersection_5.gxx>
#include <IntPatch_ImpImpIntersection_6.gxx>

36
src/IntPatch/IntPatch_ImpImpIntersection_1.gxx
View File

@ -120,3 +120,39 @@ static Standard_Boolean IntCoCo(const IntSurf_Quadric&,
Standard_Boolean&,
IntPatch_SequenceOfLine&,
IntPatch_SequenceOfPoint&);
//torus
static Standard_Boolean IntPTo(const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
const Standard_Boolean,
Standard_Boolean&,
IntPatch_SequenceOfLine&);
static Standard_Boolean IntCyTo(const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
const Standard_Boolean,
Standard_Boolean&,
IntPatch_SequenceOfLine&);
static Standard_Boolean IntCoTo(const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
const Standard_Boolean,
Standard_Boolean&,
IntPatch_SequenceOfLine&);
static Standard_Boolean IntSpTo(const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
const Standard_Boolean,
Standard_Boolean&,
IntPatch_SequenceOfLine&);
static Standard_Boolean IntToTo(const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
Standard_Boolean&,
Standard_Boolean&,
IntPatch_SequenceOfLine&);

449
src/IntPatch/IntPatch_ImpImpIntersection_2.gxx
View File

@ -14,6 +14,11 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
static
Standard_Integer SetQuad(const Handle(Adaptor3d_HSurface)& theS,
GeomAbs_SurfaceType& theTS,
IntSurf_Quadric& theQuad);
//=======================================================================
//function : IntPatch_ImpImpIntersection
//purpose :
@ -68,312 +73,170 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
IntPatch_SequenceOfPathPointOfTheSOnBounds pnt1,pnt2;
//
// On commence par intersecter les supports des surfaces
IntSurf_Quadric quad1;
IntSurf_Quadric quad2;
IntSurf_Quadric quad1, quad2;
IntPatch_ArcFunction AFunc;
const Standard_Real Tolang = 1.e-8;
GeomAbs_SurfaceType typs1 = S1->GetType();
GeomAbs_SurfaceType typs2 = S2->GetType();
GeomAbs_SurfaceType typs1, typs2;
Standard_Boolean bEmpty = Standard_False;
//
switch (typs1) {
case GeomAbs_Plane :
{
quad1.SetValue(S1->Plane());
switch (typs2) {
case GeomAbs_Plane:
{
quad2.SetValue(S2->Plane());
if (!IntPP(quad1,quad2,Tolang,TolTang,SameSurf,slin)) {
const Standard_Integer iT1 = SetQuad(S1, typs1, quad1);
const Standard_Integer iT2 = SetQuad(S2, typs2, quad2);
//
if (!iT1 || !iT2) {
Standard_ConstructionError::Raise();
return;
}
//
const Standard_Boolean bReverse = iT1 > iT2;
const Standard_Integer iTT = iT1*10 + iT2;
//
switch (iTT) {
case 11: { // Plane/Plane
if (!IntPP(quad1, quad2, Tolang, TolTang, SameSurf, slin)) {
return;
}
break;
case GeomAbs_Cylinder:
{
quad2.SetValue(S2->Cylinder());
}
//
case 12:
case 21: { // Plane/Cylinder
Standard_Real VMin, VMax, H;
//
VMin = S1->FirstVParameter();
VMax = S1->LastVParameter();
const Handle(Adaptor3d_HSurface)& aSCyl = bReverse ? S2 : S1;
VMin = aSCyl->FirstVParameter();
VMax = aSCyl->LastVParameter();
H = (Precision::IsNegativeInfinite(VMin) ||
Precision::IsPositiveInfinite(VMax)) ? 0 : (VMax - VMin);
if (!IntPCy(quad1,quad2,Tolang,TolTang,Standard_False,empt,slin,H)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
case GeomAbs_Sphere:
{
quad2.SetValue(S2->Sphere());
//modified by NIZNHY-PKV Tue Sep 20 09:03:06 2011f
if (!IntPSp(quad1,quad2,Tolang,TolTang,Standard_False,empt,slin,spnt)) {
//if (!IntPSp(quad1,quad2,TolTang,Standard_False,empt,slin,spnt)) {
//modified by NIZNHY-PKV Tue Sep 20 09:03:10 2011t
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
case GeomAbs_Cone:
{
quad2.SetValue(S2->Cone());
if (!IntPCo(quad1,quad2,Tolang,TolTang,Standard_False,
empt,multpoint,slin,spnt)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
default:
{
Standard_ConstructionError::Raise();
break;
}
}
}
break;
case GeomAbs_Cylinder:
{
quad1.SetValue(S1->Cylinder());
switch (typs2){
case GeomAbs_Plane:
{
quad2.SetValue(S2->Plane());
Standard_Real VMin, VMax, H;
//
VMin = S1->FirstVParameter();
VMax = S1->LastVParameter();
H = (Precision::IsNegativeInfinite(VMin) ||
Precision::IsPositiveInfinite(VMax)) ? 0 : (VMax - VMin);
if (!IntPCy(quad1,quad2,Tolang,TolTang,Standard_True,empt,slin,H)) {
if (!IntPCy(quad1, quad2, Tolang, TolTang, bReverse, empt, slin, H)) {
return;
}
if (empt) {
done = Standard_True;
bEmpty = empt;
break;
}
//
case 13:
case 31: { // Plane/Cone
if (!IntPCo(quad1, quad2, Tolang, TolTang, bReverse, empt, multpoint, slin, spnt)) {
return;
}
bEmpty = empt;
break;
}
//
case 14:
case 41: { // Plane/Sphere
if (!IntPSp(quad1, quad2, Tolang, TolTang, bReverse, empt, slin, spnt)) {
return;
}
bEmpty = empt;
break;
}
//
case 15:
case 51: { // Plane/Torus
if (!IntPTo(quad1, quad2, TolTang, bReverse, empt, slin)) {
return;
}
bEmpty = empt;
break;
}
//
case 22: { // Cylinder/Cylinder
if (!IntCyCy(quad1, quad2, TolTang, empt, SameSurf, multpoint, slin, spnt)) {
return;
}
bEmpty = empt;
break;
}
//
case 23:
case 32: { // Cylinder/Cone
if (!IntCyCo(quad1, quad2, TolTang, bReverse, empt, multpoint, slin, spnt)) {
return;
}
bEmpty = empt;
break;
}
//
case 24:
case 42: { // Cylinder/Sphere
if (!IntCySp(quad1, quad2, TolTang, bReverse, empt, multpoint, slin, spnt)) {
return;
}
bEmpty = empt;
break;
}
//
case 25:
case 52: { // Cylinder/Torus
if (!IntCyTo(quad1, quad2, TolTang, bReverse, empt, slin)) {
return;
}
bEmpty = empt;
break;
}
//
case 33: { // Cone/Cone
if (!IntCoCo(quad1, quad2, TolTang, empt, SameSurf, multpoint, slin, spnt)) {
return;
}
bEmpty = empt;
break;
}
//
case 34:
case 43: { // Cone/Sphere
if (!IntCoSp(quad1, quad2, TolTang, bReverse, empt, multpoint, slin, spnt)) {
return;
}
bEmpty = empt;
break;
}
//
case 35:
case 53: { // Cone/Torus
if (!IntCoTo(quad1, quad2, TolTang, bReverse, empt, slin)) {
return;
}
break;
case GeomAbs_Cylinder:
{
quad2.SetValue(S2->Cylinder());
if (!IntCyCy(quad1,quad2,TolTang,empt,SameSurf,multpoint,slin,spnt)) {
}
//
case 44: { // Sphere/Sphere
if (!IntSpSp(quad1, quad2, TolTang, empt, SameSurf, slin, spnt)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
bEmpty = empt;
break;
case GeomAbs_Sphere:
{
quad2.SetValue(S2->Sphere());
if (!IntCySp(quad1,quad2,TolTang,Standard_False,empt,multpoint,
slin,spnt)) {
}
//
case 45:
case 54: { // Sphere/Torus
if (!IntSpTo(quad1, quad2, TolTang, bReverse, empt, slin)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
bEmpty = empt;
break;
case GeomAbs_Cone:
{
quad2.SetValue(S2->Cone());
if (!IntCyCo(quad1,quad2,TolTang,Standard_False,empt,multpoint,
slin,spnt)) {
}
//
case 55: { // Torus/Torus
if (!IntToTo(quad1, quad2, TolTang, SameSurf, empt, slin)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
bEmpty = empt;
break;
default:
{
}
//
default: {
Standard_ConstructionError::Raise();
break;
}
}
}
break;
case GeomAbs_Sphere:
{
quad1.SetValue(S1->Sphere());
switch (typs2){
case GeomAbs_Plane:
{
quad2.SetValue(S2->Plane());
//modified by NIZNHY-PKV Tue Sep 20 09:03:35 2011f
if (!IntPSp(quad1,quad2,Tolang,TolTang,Standard_True,empt,slin,spnt)) {
//if (!IntPSp(quad1,quad2,TolTang,Standard_True,empt,slin,spnt)) {
//modified by NIZNHY-PKV Tue Sep 20 09:03:38 2011t
return;
}
if (empt) {
//
if (bEmpty) {
done = Standard_True;
return;
}
}
break;
case GeomAbs_Cylinder:
{
quad2.SetValue(S2->Cylinder());
if (!IntCySp(quad1,quad2,TolTang,Standard_True,empt,multpoint,
slin,spnt)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
case GeomAbs_Sphere:
{
quad2.SetValue(S2->Sphere());
if (!IntSpSp(quad1,quad2,TolTang,empt,SameSurf,slin,spnt)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
case GeomAbs_Cone:
{
quad2.SetValue(S2->Cone());
if (!IntCoSp(quad1,quad2,TolTang,Standard_True,empt,multpoint,
slin,spnt)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
default:
{
Standard_ConstructionError::Raise();
break;
}
}
}
break;
case GeomAbs_Cone:
{
quad1.SetValue(S1->Cone());
switch (typs2){
case GeomAbs_Plane:
{
quad2.SetValue(S2->Plane());
if (!IntPCo(quad1,quad2,Tolang,TolTang,Standard_True,
empt,multpoint,slin,spnt)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
case GeomAbs_Cylinder:
{
quad2.SetValue(S2->Cylinder());
if (!IntCyCo(quad1,quad2,TolTang,Standard_True,empt,multpoint,
slin,spnt)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
case GeomAbs_Sphere:
{
quad2.SetValue(S2->Sphere());
if (!IntCoSp(quad1,quad2,TolTang,Standard_False,empt,multpoint,
slin,spnt)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
case GeomAbs_Cone:
{
quad2.SetValue(S2->Cone());
if (!IntCoCo(quad1,quad2,TolTang,empt,SameSurf,multpoint,
slin,spnt)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
default:
{
Standard_ConstructionError::Raise();
break;
}
}
}
break;
default:
{
Standard_ConstructionError::Raise();
break;
}
} //switch (typs1) {
//
if (!SameSurf) {
AFunc.SetQuadric(quad2);
@ -462,6 +325,10 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
Ptreference = ElSLib::Value(0.,10.,S1->Cone());
}
break;
case GeomAbs_Torus: {
Ptreference = ElSLib::Value(0.,0.,S1->Torus());
}
break;
default:
break;
}
@ -612,3 +479,41 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
done = Standard_True;
}
//=======================================================================
//function : SetQuad
//purpose :
//=======================================================================
Standard_Integer SetQuad(const Handle(Adaptor3d_HSurface)& theS,
GeomAbs_SurfaceType& theTS,
IntSurf_Quadric& theQuad)
{
theTS = theS->GetType();
Standard_Integer iRet = 0;
switch (theTS) {
case GeomAbs_Plane:
theQuad.SetValue(theS->Plane());
iRet = 1;
break;
case GeomAbs_Cylinder:
theQuad.SetValue(theS->Cylinder());
iRet = 2;
break;
case GeomAbs_Cone:
theQuad.SetValue(theS->Cone());
iRet = 3;
break;
case GeomAbs_Sphere:
theQuad.SetValue(theS->Sphere());
iRet = 4;
break;
case GeomAbs_Torus:
theQuad.SetValue(theS->Torus());
iRet = 5;
break;
default:
break;
}
//
return iRet;
}

84
src/IntPatch/IntPatch_ImpImpIntersection_3.gxx
View File

@ -29,6 +29,9 @@ static
static
void AdjustToSeam (const gp_Cone& aQuad,
gp_Circ& aCirc);
static
void AdjustToSeam (const gp_Torus& aQuad,
gp_Circ& aCirc);
//modified by NIZNHY-PKV Thu Sep 15 11:09:13 2011
//=======================================================================
@ -650,6 +653,73 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
}
return Standard_True;
}
//=======================================================================
//function : IntPTo
//purpose :
//=======================================================================
Standard_Boolean IntPTo(const IntSurf_Quadric& theQuad1,
const IntSurf_Quadric& theQuad2,
const Standard_Real theTolTang,
const Standard_Boolean bReversed,
Standard_Boolean& bEmpty,
IntPatch_SequenceOfLine& theSeqLin)
{
const gp_Pln aPln = bReversed ? theQuad2.Plane() : theQuad1.Plane();
const gp_Torus aTorus = bReversed ? theQuad1.Torus() : theQuad2.Torus();
//
IntAna_QuadQuadGeo inter(aPln, aTorus, theTolTang);
Standard_Boolean bRet = inter.IsDone();
//
if (!bRet) {
return bRet;
}
//
IntAna_ResultType typint = inter.TypeInter();
Standard_Integer NbSol = inter.NbSolutions();
bEmpty = Standard_False;
//
switch (typint) {
case IntAna_Empty :
bEmpty = Standard_True;
break;
//
case IntAna_Circle : {
Standard_Integer i;
IntSurf_TypeTrans trans1, trans2;
gp_Pnt ptref;
gp_Vec Tgt;
//
for (i = 1; i <= NbSol; ++i) {
gp_Circ aC = inter.Circle(i);
if (!aPln.Axis().IsNormal(aTorus.Axis(), Precision::Angular())) {
AdjustToSeam(aTorus, aC);
}
ElCLib::D1(0., aC, ptref, Tgt);
//
if (Tgt.DotCross(theQuad2.Normale(ptref),theQuad1.Normale(ptref)) > 0.0) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
//
Handle(IntPatch_GLine) glig =
new IntPatch_GLine(aC, Standard_False, trans1, trans2);
theSeqLin.Append(glig);
}
}
break;
//
case IntAna_NoGeometricSolution:
default:
bRet = Standard_False;
break;
}
//
return bRet;
}
//
//modified by NIZNHY-PKV Thu Sep 15 10:53:39 2011f
//=======================================================================
@ -703,6 +773,20 @@ void AdjustToSeam (const gp_Cylinder& aQuad,
aCirc.SetPosition(aAx2);
}
//=======================================================================
//function : AdjustToSeam
//purpose :
//=======================================================================
void AdjustToSeam (const gp_Torus& aQuad,
gp_Circ& aCirc)
{
gp_Ax2 aAx2;
//
const gp_Pnt& aPLoc=aCirc.Location();
const gp_Ax3& aAx3=aQuad.Position();
SeamPosition(aPLoc, aAx3, aAx2);
aCirc.SetPosition(aAx2);
}
//=======================================================================
//function : SeamPosition
//purpose :
//=======================================================================

181
src/IntPatch/IntPatch_ImpImpIntersection_6.gxx Normal file
View File

@ -0,0 +1,181 @@
// Created on: 1992-05-07
// Created by: Jacques GOUSSARD
// Copyright (c) 1992-1999 Matra Datavision
// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and / or modify it
// under the terms of the GNU Lesser General Public version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
static
Standard_Boolean TreatResultTorus(const IntSurf_Quadric& theQuad1,
const IntSurf_Quadric& theQuad2,
const IntAna_QuadQuadGeo& anInt,
Standard_Boolean& bEmpty,
IntPatch_SequenceOfLine& theSeqLin);
//=======================================================================
//function : IntCyTo
//purpose :
//=======================================================================
Standard_Boolean IntCyTo(const IntSurf_Quadric& theQuad1,
const IntSurf_Quadric& theQuad2,
const Standard_Real theTolTang,
const Standard_Boolean bReversed,
Standard_Boolean& bEmpty,
IntPatch_SequenceOfLine& theSeqLin)
{
const gp_Cylinder aCyl = bReversed ? theQuad2.Cylinder() : theQuad1.Cylinder();
const gp_Torus aTorus = bReversed ? theQuad1.Torus() : theQuad2.Torus();
//
IntAna_QuadQuadGeo anInt(aCyl, aTorus, theTolTang);
Standard_Boolean bRet =
TreatResultTorus(theQuad1, theQuad2, anInt, bEmpty, theSeqLin);
//
return bRet;
}
//=======================================================================
//function : IntCoTo
//purpose :
//=======================================================================
Standard_Boolean IntCoTo(const IntSurf_Quadric& theQuad1,
const IntSurf_Quadric& theQuad2,
const Standard_Real theTolTang,
const Standard_Boolean bReversed,
Standard_Boolean& bEmpty,
IntPatch_SequenceOfLine& theSeqLin)
{
const gp_Cone aCone = bReversed ? theQuad2.Cone() : theQuad1.Cone();
const gp_Torus aTorus = bReversed ? theQuad1.Torus() : theQuad2.Torus();
//
IntAna_QuadQuadGeo anInt(aCone, aTorus, theTolTang);
Standard_Boolean bRet =
TreatResultTorus(theQuad1, theQuad2, anInt, bEmpty, theSeqLin);
//
return bRet;
}
//=======================================================================
//function : IntSpTo
//purpose :
//=======================================================================
Standard_Boolean IntSpTo(const IntSurf_Quadric& theQuad1,
const IntSurf_Quadric& theQuad2,
const Standard_Real theTolTang,
const Standard_Boolean bReversed,
Standard_Boolean& bEmpty,
IntPatch_SequenceOfLine& theSeqLin)
{
const gp_Sphere aSphere = bReversed ? theQuad2.Sphere() : theQuad1.Sphere();
const gp_Torus aTorus = bReversed ? theQuad1.Torus() : theQuad2.Torus();
//
IntAna_QuadQuadGeo anInt(aSphere, aTorus, theTolTang);
Standard_Boolean bRet =
TreatResultTorus(theQuad1, theQuad2, anInt, bEmpty, theSeqLin);
//
return bRet;
}
//=======================================================================
//function : IntToTo
//purpose :
//=======================================================================
Standard_Boolean IntToTo(const IntSurf_Quadric& theQuad1,
const IntSurf_Quadric& theQuad2,
const Standard_Real theTolTang,
Standard_Boolean& bSameSurf,
Standard_Boolean& bEmpty,
IntPatch_SequenceOfLine& theSeqLin)
{
const gp_Torus aTorus1 = theQuad1.Torus();
const gp_Torus aTorus2 = theQuad2.Torus();
//
IntAna_QuadQuadGeo anInt(aTorus1, aTorus2, theTolTang);
Standard_Boolean bRet = anInt.IsDone();
if (bRet) {
if (anInt.TypeInter() == IntAna_Same) {
bEmpty = Standard_False;
bSameSurf = Standard_True;
} else {
bRet = TreatResultTorus(theQuad1, theQuad2, anInt, bEmpty, theSeqLin);
}
}
//
return bRet;
}
//=======================================================================
//function : TreatResultTorus
//purpose :
//=======================================================================
static Standard_Boolean TreatResultTorus(const IntSurf_Quadric& theQuad1,
const IntSurf_Quadric& theQuad2,
const IntAna_QuadQuadGeo& anInt,
Standard_Boolean& bEmpty,
IntPatch_SequenceOfLine& theSeqLin)
{
Standard_Boolean bRet = anInt.IsDone();
//
if (!bRet) {
return bRet;
}
//
IntAna_ResultType typint = anInt.TypeInter();
Standard_Integer NbSol = anInt.NbSolutions();
bEmpty = Standard_False;
//
switch (typint) {
case IntAna_Empty :
bEmpty = Standard_True;
break;
//
case IntAna_Circle : {
Standard_Integer i;
IntSurf_TypeTrans trans1, trans2;
gp_Vec Tgt;
gp_Pnt ptref;
//
for (i = 1; i <= NbSol; ++i) {
gp_Circ aC = anInt.Circle(i);
if (theQuad1.TypeQuadric() == theQuad2.TypeQuadric()) {
AdjustToSeam(theQuad1.Torus(), aC);
}
ElCLib::D1(0., aC, ptref, Tgt);
Standard_Real qwe = Tgt.DotCross(theQuad2.Normale(ptref),
theQuad1.Normale(ptref));
if(qwe> 0.00000001) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else if(qwe< -0.00000001) {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
else {
trans1=trans2=IntSurf_Undecided;
}
//
Handle(IntPatch_GLine) glig =
new IntPatch_GLine(aC, Standard_False, trans1, trans2);
theSeqLin.Append(glig);
}
}
break;
//
case IntAna_NoGeometricSolution:
default:
bRet = Standard_False;
break;
}
//
return bRet;
}

156
src/IntPatch/IntPatch_Intersection.cxx
View File

@ -849,7 +849,79 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1,
case GeomAbs_Cone: ts2 = 1; break;
default: break;
}
//
// treatment of the cases with torus and any other geom surface
if ((typs1 == GeomAbs_Torus && ts2) ||
(typs2 == GeomAbs_Torus && ts1) ||
(typs1 == GeomAbs_Torus && typs2 == GeomAbs_Torus)) {
// check if axes collinear
//
const Handle(Adaptor3d_HSurface)& aTorSurf =
(typs1 == GeomAbs_Torus) ? theS1 : theS2;
const Handle(Adaptor3d_HSurface)& aGeomSurf =
(typs1 == GeomAbs_Torus) ? theS2 : theS1;
//
Standard_Boolean bValid =
aTorSurf->Torus().MajorRadius() > aTorSurf->Torus().MinorRadius();
if (bValid && (typs1 == typs2)) {
bValid = aGeomSurf->Torus().MajorRadius() > aGeomSurf->Torus().MinorRadius();
}
//
if (bValid) {
Standard_Boolean bCheck, bImpImp;
const gp_Ax1 aTorAx = aTorSurf->Torus().Axis();
const gp_Lin aL1(aTorAx);
//
bCheck = Standard_True;
bImpImp = Standard_False;
//
gp_Ax1 aGeomAx;
switch (aGeomSurf->GetType()) {
case GeomAbs_Plane: {
aGeomAx = aGeomSurf->Plane().Axis();
if (aTorAx.IsParallel(aGeomAx, Precision::Angular()) ||
(aTorAx.IsNormal(aGeomAx, Precision::Angular()) &&
(aGeomSurf->Plane().Distance(aTorAx.Location()) < Precision::Confusion()))) {
bImpImp = Standard_True;
}
bCheck = Standard_False;
break;
}
case GeomAbs_Sphere: {
if (aL1.Distance(aGeomSurf->Sphere().Location()) < Precision::Confusion()) {
bImpImp = Standard_True;
}
bCheck = Standard_False;
break;
}
case GeomAbs_Cylinder:
aGeomAx = aGeomSurf->Cylinder().Axis();
break;
case GeomAbs_Cone:
aGeomAx = aGeomSurf->Cone().Axis();
break;
case GeomAbs_Torus:
aGeomAx = aGeomSurf->Torus().Axis();
break;
default:
bCheck = Standard_False;
break;
}
//
if (bCheck) {
if (aTorAx.IsParallel(aGeomAx, Precision::Angular()) &&
(aL1.Distance(aGeomAx.Location()) <= Precision::Confusion())) {
bImpImp = Standard_True;
}
}
//
if (bImpImp) {
ts1 = 1;
ts2 = 1;
}
}
}
//
// Possible intersection types: 1. ts1 == ts2 == 1 <Geom-Geom>
// 2. ts1 != ts2 <Geom-Param>
// 3. ts1 == ts2 == 0 <Param-Param>
@ -1028,7 +1100,79 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1,
case GeomAbs_Cone: ts2 = 1; break;
default: break;
}
//
// treatment of the cases with torus and any other geom surface
if ((typs1 == GeomAbs_Torus && ts2) ||
(typs2 == GeomAbs_Torus && ts1) ||
(typs1 == GeomAbs_Torus && typs2 == GeomAbs_Torus)) {
// check if axes collinear
//
const Handle(Adaptor3d_HSurface)& aTorSurf =
(typs1 == GeomAbs_Torus) ? theS1 : theS2;
const Handle(Adaptor3d_HSurface)& aGeomSurf =
(typs1 == GeomAbs_Torus) ? theS2 : theS1;
//
Standard_Boolean bValid =
aTorSurf->Torus().MajorRadius() > aTorSurf->Torus().MinorRadius();
if (bValid && (typs1 == typs2)) {
bValid = aGeomSurf->Torus().MajorRadius() > aGeomSurf->Torus().MinorRadius();
}
//
if (bValid) {
Standard_Boolean bCheck, bImpImp;
const gp_Ax1 aTorAx = aTorSurf->Torus().Axis();
const gp_Lin aL1(aTorAx);
//
bCheck = Standard_True;
bImpImp = Standard_False;
//
gp_Ax1 aGeomAx;
switch (aGeomSurf->GetType()) {
case GeomAbs_Plane: {
aGeomAx = aGeomSurf->Plane().Axis();
if (aTorAx.IsParallel(aGeomAx, Precision::Angular()) ||
(aTorAx.IsNormal(aGeomAx, Precision::Angular()) &&
(aGeomSurf->Plane().Distance(aTorAx.Location()) < Precision::Confusion()))) {
bImpImp = Standard_True;
}
bCheck = Standard_False;
break;
}
case GeomAbs_Sphere: {
if (aL1.Distance(aGeomSurf->Sphere().Location()) < Precision::Confusion()) {
bImpImp = Standard_True;
}
bCheck = Standard_False;
break;
}
case GeomAbs_Cylinder:
aGeomAx = aGeomSurf->Cylinder().Axis();
break;
case GeomAbs_Cone:
aGeomAx = aGeomSurf->Cone().Axis();
break;
case GeomAbs_Torus:
aGeomAx = aGeomSurf->Torus().Axis();
break;
default:
bCheck = Standard_False;
break;
}
//
if (bCheck) {
if (aTorAx.IsParallel(aGeomAx, Precision::Angular()) &&
(aL1.Distance(aGeomAx.Location()) <= Precision::Confusion())) {
bImpImp = Standard_True;
}
}
//
if (bImpImp) {
ts1 = 1;
ts2 = 1;
}
}
}
//
// Possible intersection types: 1. ts1 == ts2 == 1 <Geom-Geom>
// 2. ts1 != ts2 <Geom-Param>
// 3. ts1 == ts2 == 0 <Param-Param>
@ -1215,6 +1359,10 @@ void IntPatch_Intersection::GeomGeomPerfom(const Handle(Adaptor3d_HSurface)& the
Quad1.SetValue(theS1->Cone());
break;
case GeomAbs_Torus:
Quad1.SetValue(theS1->Torus());
break;
default:
break;
}
@ -1236,6 +1384,10 @@ void IntPatch_Intersection::GeomGeomPerfom(const Handle(Adaptor3d_HSurface)& the
Quad2.SetValue(theS2->Cone());
break;
case GeomAbs_Torus:
Quad2.SetValue(theS2->Torus());
break;
default:
break;
}

6
src/IntPatch/IntPatch_LineConstructor.cxx
View File

@ -156,6 +156,9 @@ static void Parameters(const Handle(Adaptor3d_HSurface)& myHS1,
case GeomAbs_Sphere:
quad1.SetValue(myHS1->Surface().Sphere());
break;
case GeomAbs_Torus:
quad1.SetValue(myHS1->Surface().Torus());
break;
default:
Standard_ConstructionError::Raise("IntPatch_IntSS::MakeCurve");
}
@ -174,6 +177,9 @@ static void Parameters(const Handle(Adaptor3d_HSurface)& myHS1,
case GeomAbs_Sphere:
quad2.SetValue(myHS2->Surface().Sphere());
break;
case GeomAbs_Torus:
quad2.SetValue(myHS2->Surface().Torus());
break;
default:
Standard_ConstructionError::Raise("IntPatch_IntSS::MakeCurve");
}

18
src/IntSurf/IntSurf_Quadric.cdl
View File

@ -28,6 +28,7 @@ uses Ax3 from gp,
Cylinder from gp,
Sphere from gp,
Cone from gp,
Torus from gp,
SurfaceType from GeomAbs
is
@ -57,6 +58,11 @@ is
returns Quadric from IntSurf;
Create(T: Torus from gp)
returns Quadric from IntSurf;
SetValue(me: in out; P: Pln from gp)
is static;
@ -76,6 +82,10 @@ is
is static;
SetValue(me: in out; T: Torus from gp)
is static;
Distance(me; P: Pnt from gp)
@ -137,6 +147,14 @@ is
is static;
Torus(me)
returns Torus from gp
---C++: inline
is static;
Value(me; U,V: Real)

112
src/IntSurf/IntSurf_Quadric.cxx
View File

@ -20,7 +20,6 @@
#include <gp.hxx>
// ============================================================
IntSurf_Quadric::IntSurf_Quadric ():typ(GeomAbs_OtherSurface),
prm1(0.), prm2(0.), prm3(0.), prm4(0.)
@ -63,6 +62,18 @@ IntSurf_Quadric::IntSurf_Quadric (const gp_Cone& C):
prm4 = 0.0;
}
// ============================================================
IntSurf_Quadric::IntSurf_Quadric (const gp_Torus& T):
ax3(T.Position()),typ(GeomAbs_Torus)
{
ax3direc = ax3.Direct();
lin.SetPosition(ax3.Axis());
prm1 = T.MajorRadius();
prm2 = T.MinorRadius();
prm3 = 0.0;
prm4 = 0.0;
}
// ============================================================
void IntSurf_Quadric::SetValue (const gp_Pln& P)
{
typ = GeomAbs_Plane;
@ -103,6 +114,18 @@ void IntSurf_Quadric::SetValue (const gp_Cone& C)
prm4 = 0.0;
}
// ============================================================
void IntSurf_Quadric::SetValue (const gp_Torus& T)
{
typ = GeomAbs_Torus;
ax3 = T.Position();
ax3direc = ax3.Direct();
lin.SetPosition(ax3.Axis());
prm1 = T.MajorRadius();
prm2 = T.MinorRadius();
prm3 = 0.0;
prm4 = 0.0;
}
// ============================================================
Standard_Real IntSurf_Quadric::Distance (const gp_Pnt& P) const {
switch (typ) {
case GeomAbs_Plane: // plan
@ -121,6 +144,21 @@ Standard_Real IntSurf_Quadric::Distance (const gp_Pnt& P) const {
dist = (dist-distp)/prm3;
return(dist);
}
case GeomAbs_Torus: // torus
{
gp_Pnt O, Pp, PT;
//
O = ax3.Location();
gp_Vec OZ (ax3.Direction());
Pp = P.Translated(OZ.Multiplied(-(gp_Vec(O,P).Dot(ax3.Direction()))));
//
gp_Dir DOPp = (O.SquareDistance(Pp) < 1e-14) ?
ax3.XDirection() : gp_Dir(gp_Vec(O, Pp));
PT.SetXYZ(O.XYZ() + DOPp.XYZ()*prm1);
//
Standard_Real dist = P.Distance(PT) - prm2;
return dist;
}
default:
{
}
@ -168,6 +206,24 @@ gp_Vec IntSurf_Quadric::Gradient (const gp_Pnt& P) const {
grad.Normalize();
}
break;
case GeomAbs_Torus: // torus
{
gp_Pnt O, Pp, PT;
//
O = ax3.Location();
gp_Vec OZ (ax3.Direction());
Pp = P.Translated(OZ.Multiplied(-(gp_Vec(O,P).Dot(ax3.Direction()))));
//
gp_Dir DOPp = (O.SquareDistance(Pp) < 1e-14) ?
ax3.XDirection() : gp_Dir(gp_Vec(O, Pp));
PT.SetXYZ(O.XYZ() + DOPp.XYZ()*prm1);
//
grad.SetXYZ(P.XYZ() - PT.XYZ());
Standard_Real N = grad.Magnitude();
if(N>1e-14) { grad.Divide(N); }
else { grad.SetCoord(0., 0., 0.); }
}
break;
default:
{}
break;
@ -234,6 +290,26 @@ void IntSurf_Quadric::ValAndGrad (const gp_Pnt& P,
}
}
break;
case GeomAbs_Torus:
{
gp_Pnt O, Pp, PT;
//
O = ax3.Location();
gp_Vec OZ (ax3.Direction());
Pp = P.Translated(OZ.Multiplied(-(gp_Vec(O,P).Dot(ax3.Direction()))));
//
gp_Dir DOPp = (O.SquareDistance(Pp) < 1e-14) ?
ax3.XDirection() : gp_Dir(gp_Vec(O, Pp));
PT.SetXYZ(O.XYZ() + DOPp.XYZ()*prm1);
//
Dist = P.Distance(PT) - prm2;
//
Grad.SetXYZ(P.XYZ()-PT.XYZ());
Standard_Real N = Grad.Magnitude();
if(N>1e-14) { Grad.Divide(N); }
else { Grad.SetCoord(0., 0., 0.); }
}
break;
default:
{}
break;
@ -253,6 +329,8 @@ gp_Pnt IntSurf_Quadric::Value(const Standard_Real U,
return ElSLib::SphereValue(U,V,ax3,prm1);
case GeomAbs_Cone:
return ElSLib::ConeValue(U,V,ax3,prm1,prm2);
case GeomAbs_Torus:
return ElSLib::TorusValue(U,V,ax3,prm1,prm2);
default:
{
gp_Pnt p(0,0,0);
@ -283,6 +361,9 @@ void IntSurf_Quadric::D1(const Standard_Real U,
case GeomAbs_Cone:
ElSLib::ConeD1(U,V,ax3,prm1,prm2,P,D1U,D1V);
break;
case GeomAbs_Torus:
ElSLib::TorusD1(U,V,ax3,prm1,prm2,P,D1U,D1V);
break;
default:
{
}
@ -304,6 +385,8 @@ gp_Vec IntSurf_Quadric::DN(const Standard_Real U,
return ElSLib::SphereDN(U,V,ax3,prm1,Nu,Nv);
case GeomAbs_Cone:
return ElSLib::ConeDN(U,V,ax3,prm1,prm2,Nu,Nv);
case GeomAbs_Torus:
return ElSLib::TorusDN(U,V,ax3,prm1,prm2,Nu,Nv);
default:
{
gp_Vec v(0,0,0);
@ -339,6 +422,8 @@ gp_Vec IntSurf_Quadric::Normale(const Standard_Real U,
}
return(D1u.Crossed(D1v));
}
case GeomAbs_Torus:
return Normale(Value(U,V));
default:
{
gp_Vec v(0,0,0);
@ -384,7 +469,24 @@ gp_Vec IntSurf_Quadric::Normale (const gp_Pnt& P) const
{
Standard_Real U,V;
ElSLib::ConeParameters(ax3,prm1,prm2,P,U,V);
return Normale(U,V);;
return Normale(U,V);
}
case GeomAbs_Torus:
{
gp_Pnt O, Pp, PT;
//
O = ax3.Location();
gp_Vec OZ (ax3.Direction());
Pp = P.Translated(OZ.Multiplied(-(gp_Vec(O,P).Dot(ax3.Direction()))));
//
gp_Dir DOPp = (O.SquareDistance(Pp) < 1e-14) ?
ax3.XDirection() : gp_Dir(gp_Vec(O, Pp));
PT.SetXYZ(O.XYZ() + DOPp.XYZ()*prm1);
if (PT.SquareDistance(P) < 1e-14) {
return gp_Dir(OZ);
}
gp_Dir aD(ax3direc ? gp_Vec(PT, P) : gp_Vec(P, PT));
return aD;
}
default:
{
@ -409,12 +511,12 @@ void IntSurf_Quadric::Parameters (const gp_Pnt& P,
ElSLib::SphereParameters(ax3,prm1,P,U,V);
break;
case GeomAbs_Cone:
{
ElSLib::ConeParameters(ax3,prm1,prm2,P,U,V);
}
break;
case GeomAbs_Torus:
ElSLib::TorusParameters(ax3,prm1,prm2,P,U,V);
break;
default:
{}
break;
}
}

5
src/IntSurf/IntSurf_Quadric.lxx
View File

@ -58,4 +58,9 @@ inline gp_Cone IntSurf_Quadric::Cone () const {
return gp_Cone(ax3,prm2,prm1);
}
inline gp_Torus IntSurf_Quadric::Torus () const {
return gp_Torus(ax3, prm1, prm2);
}

12
src/IntTools/IntTools_FaceFace.cxx
View File

@ -1645,6 +1645,9 @@ reapprox:;
case GeomAbs_Sphere:
quad1.SetValue(myHS1->Surface().Sphere());
break;
case GeomAbs_Torus:
quad1.SetValue(myHS1->Surface().Torus());
break;
default:
Standard_ConstructionError::Raise("GeomInt_IntSS::MakeCurve 1");
}
@ -1664,6 +1667,9 @@ reapprox:;
case GeomAbs_Sphere:
quad2.SetValue(myHS2->Surface().Sphere());
break;
case GeomAbs_Torus:
quad2.SetValue(myHS2->Surface().Torus());
break;
default:
Standard_ConstructionError::Raise("GeomInt_IntSS::MakeCurve 2");
}
@ -2437,6 +2443,9 @@ reapprox:;
case GeomAbs_Sphere:
quad1.SetValue(HS1->Surface().Sphere());
break;
case GeomAbs_Torus:
quad1.SetValue(HS1->Surface().Torus());
break;
default:
Standard_ConstructionError::Raise("GeomInt_IntSS::MakeCurve");
}
@ -2455,6 +2464,9 @@ reapprox:;
case GeomAbs_Sphere:
quad2.SetValue(HS2->Surface().Sphere());
break;
case GeomAbs_Torus:
quad2.SetValue(HS2->Surface().Torus());
break;
default:
Standard_ConstructionError::Raise("GeomInt_IntSS::MakeCurve");
}

3
src/IntTools/IntTools_LineConstructor.cxx
View File

@ -613,6 +613,9 @@ void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
case GeomAbs_Sphere:
quad1.SetValue(myHS1->Surface().Sphere());
break;
case GeomAbs_Torus:
quad1.SetValue(myHS1->Surface().Torus());
break;
default:
Standard_ConstructionError::Raise("IntTools_LineConstructor::Parameters");
}

28
tests/bugs/modalg_5/bug24470 Normal file
View File

@ -0,0 +1,28 @@
puts "=========="
puts "OCC24470"
puts "=========="
puts ""
##################################################
# Wrong result done by General Fuse algorithm
##################################################
restore [locate_data_file bug24470_box.brep] b1
restore [locate_data_file bug24470_cone.brep] b2
restore [locate_data_file bug24470_cylinder.brep] b3
restore [locate_data_file bug24470_rotBox.brep] b4
restore [locate_data_file bug24470_rotCyl.brep] b5
restore [locate_data_file bug24470_sphere.brep] b6
restore [locate_data_file bug24470_torus.brep] b7
bclearobjects
bcleartools
baddobjects b1 b2 b3 b4 b5 b6 b7
bfillds
bbuild result
checkshape result
set square 595443
set 2dviewer 1