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);

503
src/IntAna/IntAna_QuadQuadGeo.cdl
View File

@ -36,7 +36,8 @@ class QuadQuadGeo from IntAna
uses Pln from gp,
Cylinder from gp,
Cone from gp,
Sphere from gp,
Sphere from gp,
Torus from gp,
Pnt from gp,
Lin from gp,
Circ from gp,
@ -49,40 +50,34 @@ uses Pln from gp,
raises NotDone from StdFail,
DomainError from Standard,
OutOfRange from Standard
DomainError from Standard,
OutOfRange from Standard
is
Create
---Purpose: Empty constructor.
returns QuadQuadGeo from IntAna;
---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;
---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;
---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;
Create(P : Pln from gp;
@ -98,16 +93,14 @@ 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;
Perform(me: in out;
P : Pln from gp;
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,325 +110,333 @@ 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;
---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;
---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
-- to the plane, and if the generating line of the cone
-- is parallel to the plane.
-- Tol is the tolerance used to determine if the apex
-- of the cone is in the plane.
---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
-- to the plane, and if the generating line of the cone
-- 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;
returns QuadQuadGeo from IntAna;
Perform(me: in out;
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
-- to the plane, and if the generating line of the cone
-- is parallel to the plane.
-- Tol is the tolerance used to determine if the apex
-- of the cone is in the plane.
is static;
---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
-- to the plane, and if the generating line of the cone
-- 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;
---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;
---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;
---Purpose: Creates the intersection between a Cylinder and a Sphere.
returns QuadQuadGeo from IntAna;
Perform(me : in out;
Cyl: Cylinder from gp;
Sph: Sphere from gp;
Tol: Real from Standard)
---Purpose: Intersects a cylinder and a sphere.
is static;
---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;
---Purpose: Creates the intersection between a Cylinder and a Cone
returns QuadQuadGeo from IntAna;
Perform(me : in out;
Cyl: Cylinder from gp;
Con: Cone from gp;
Tol: Real from Standard)
---Purpose: Intersects a cylinder and a cone.
is static;
---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;
---Purpose: Creates the intersection between two Spheres.
returns QuadQuadGeo from IntAna;
Perform(me : in out;
Sph1: Sphere from gp;
Sph2: Sphere from gp;
Tol : Real from Standard)
---Purpose: Intersects a two spheres.
is static;
---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;
---Purpose: Creates the intersection beween a Sphere and a Cone.
returns QuadQuadGeo from IntAna;
Perform(me : in out;
Sph: Sphere from gp;
Con: Cone from gp;
Tol: Real from Standard)
---Purpose: Intersects a sphere and a cone.
is static;
---Purpose: Intersects a sphere and a cone.
is static;
Create(Con1: Cone from gp; Con2: Cone from gp; Tol:Real from Standard)
---Purpose: Creates the intersection beween two cones.
returns QuadQuadGeo from IntAna;
Create(Con1: Cone from gp;
Con2: Cone from gp;
Tol : Real from Standard)
---Purpose: Creates the intersection beween two cones.
returns QuadQuadGeo from IntAna;
Perform(me : in out;
Con1: Cone from gp;
Con2: Cone from gp;
Tol :Real from Standard)
---Purpose: Intersects two cones.
is static;
---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;
---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.
is static;
NbSolutions(me)
---Purpose: Returns the number of interesections.
-- The possible intersections are :
-- - 1 point
-- - 1 or 2 line(s)
-- - 1 Point and 1 Line
-- - 1 circle
-- - 1 ellipse
-- - 1 parabola
-- - 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.
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 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.
---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.
is static;
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 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 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)
NbSolutions(me)
---Purpose: Returns the number of interesections.
-- The possible intersections are :
-- - 1 point
-- - 1 or 2 line(s)
-- - 1 Point and 1 Line
-- - 1 circle
-- - 1 ellipse
-- - 1 parabola
-- - 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.
is static;
---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 DomainError is raised if TypeInter does not return
-- IntAna_Ellipse.
-- The exception OutOfRange is raised if Num < 1 or Num > NbSolutions.
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 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;
is static;
Parabola(me; Num: Integer from Standard)
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 DomainError is raised if TypeInter does not return
-- IntAna_Line.
-- The exception OutOfRange is raised if Num < 1 or Num > NbSolutions.
is static;
---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 DomainError is raised if TypeInter does not return
-- IntAna_Parabola.
-- 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 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 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 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 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;
---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 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;
PChar(me) returns Pnt from gp;
---C++: return const&
InitTolerances(me:out)
---Purpose: Initialize the values of inner tolerances.
is protected;
---Purpose: Initialize the values of inner tolerances.
is protected;
fields
done : Boolean from Standard is protected;
@ -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;
--
@ -463,5 +470,5 @@ fields
--
myCommonGen : Boolean from Standard is protected;
myPChar : Pnt from gp is protected;
end QuadQuadGeo;

1438
src/IntAna/IntAna_QuadQuadGeo.cxx
View File

File diff suppressed because it is too large Load Diff

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&);

573
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 :
@ -28,11 +33,11 @@ IntPatch_ImpImpIntersection::IntPatch_ImpImpIntersection ():
//=======================================================================
IntPatch_ImpImpIntersection::IntPatch_ImpImpIntersection
(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang)
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang)
{
Perform(S1,D1,S2,D2,TolArc,TolTang);
}
@ -41,11 +46,11 @@ IntPatch_ImpImpIntersection::IntPatch_ImpImpIntersection
//purpose :
//=======================================================================
void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang) {
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang) {
done = Standard_False;
spnt.Clear();
slin.Clear();
@ -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)) {
return;
}
}
break;
case GeomAbs_Cylinder:
{
quad2.SetValue(S2->Cylinder());
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_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;
}
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;
}
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)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
case GeomAbs_Cylinder:
{
quad2.SetValue(S2->Cylinder());
if (!IntCyCy(quad1,quad2,TolTang,empt,SameSurf,multpoint,slin,spnt)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
case GeomAbs_Sphere:
{
quad2.SetValue(S2->Sphere());
if (!IntCySp(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 (!IntCyCo(quad1,quad2,TolTang,Standard_False,empt,multpoint,
slin,spnt)) {
return;
}
if (empt) {
done = Standard_True;
return;
}
}
break;
default:
{
Standard_ConstructionError::Raise();
break;
}
//
case 12:
case 21: { // Plane/Cylinder
Standard_Real VMin, VMax, H;
//
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, bReverse, empt, slin, H)) {
return;
}
bEmpty = empt;
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) {
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;
}
//
case 13:
case 31: { // Plane/Cone
if (!IntPCo(quad1, quad2, Tolang, TolTang, bReverse, empt, multpoint, slin, spnt)) {
return;
}
bEmpty = empt;
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;
}
//
case 14:
case 41: { // Plane/Sphere
if (!IntPSp(quad1, quad2, Tolang, TolTang, bReverse, empt, slin, spnt)) {
return;
}
bEmpty = empt;
break;
}
break;
default:
{
//
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 44: { // Sphere/Sphere
if (!IntSpSp(quad1, quad2, TolTang, empt, SameSurf, slin, spnt)) {
return;
}
bEmpty = empt;
break;
}
//
case 45:
case 54: { // Sphere/Torus
if (!IntSpTo(quad1, quad2, TolTang, bReverse, empt, slin)) {
return;
}
bEmpty = empt;
break;
}
//
case 55: { // Torus/Torus
if (!IntToTo(quad1, quad2, TolTang, SameSurf, empt, slin)) {
return;
}
bEmpty = empt;
break;
}
//
default: {
Standard_ConstructionError::Raise();
break;
}
} //switch (typs1) {
}
//
if (bEmpty) {
done = Standard_True;
return;
}
//
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;
}
@ -475,10 +342,10 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
empt = Standard_False;
// C est la qu il faut commencer a bosser...
PutPointsOnLine(S1,S2,pnt1, slin, Standard_True, D1, quad1,quad2,
multpoint,TolArc);
multpoint,TolArc);
PutPointsOnLine(S1,S2,pnt2, slin, Standard_False,D2, quad2,quad1,
multpoint,TolArc);
multpoint,TolArc);
if (edg1.Length() != 0) {
ProcessSegments(edg1,slin,quad1,quad2,Standard_True,TolArc);
@ -519,7 +386,7 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
aState2=D2->Classify(aP2D, TolArc);
//
if(aState1!=TopAbs_OUT && aState2!=TopAbs_OUT) {
aSIP.Append(aIP);
aSIP.Append(aIP);
}
}
//
@ -567,22 +434,22 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
const Handle(IntPatch_GLine)& glin = *((Handle(IntPatch_GLine)*)&slin.Value(i));
nbv = glin->NbVertex();
if(glin->NbVertex() == 0) {
gp_Circ Circ = glin->Circle();
P=ElCLib::Value(0.0,Circ);
quad1.Parameters(P,u1,v1);
quad2.Parameters(P,u2,v2);
point.SetValue(P,TolArc,Standard_False);
point.SetParameters(u1,v1,u2,v2);
point.SetParameter(0.0);
glin->AddVertex(point);
gp_Circ Circ = glin->Circle();
P=ElCLib::Value(0.0,Circ);
quad1.Parameters(P,u1,v1);
quad2.Parameters(P,u2,v2);
point.SetValue(P,TolArc,Standard_False);
point.SetParameters(u1,v1,u2,v2);
point.SetParameter(0.0);
glin->AddVertex(point);
P=ElCLib::Value(0.0,Circ);
quad1.Parameters(P,u1,v1);
quad2.Parameters(P,u2,v2);
point.SetValue(P,TolArc,Standard_False);
point.SetParameters(u1,v1,u2,v2);
point.SetParameter(M_PI+M_PI);
glin->AddVertex(point);
P=ElCLib::Value(0.0,Circ);
quad1.Parameters(P,u1,v1);
quad2.Parameters(P,u2,v2);
point.SetValue(P,TolArc,Standard_False);
point.SetParameters(u1,v1,u2,v2);
point.SetParameter(M_PI+M_PI);
glin->AddVertex(point);
}
}
@ -590,25 +457,63 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
const Handle(IntPatch_GLine)& glin = *((Handle(IntPatch_GLine)*)&slin.Value(i));
nbv = glin->NbVertex();
if(glin->NbVertex() == 0) {
gp_Elips Elips = glin->Ellipse();
P=ElCLib::Value(0.0,Elips);
quad1.Parameters(P,u1,v1);
quad2.Parameters(P,u2,v2);
point.SetValue(P,TolArc,Standard_False);
point.SetParameters(u1,v1,u2,v2);
point.SetParameter(0.0);
glin->AddVertex(point);
gp_Elips Elips = glin->Ellipse();
P=ElCLib::Value(0.0,Elips);
quad1.Parameters(P,u1,v1);
quad2.Parameters(P,u2,v2);
point.SetValue(P,TolArc,Standard_False);
point.SetParameters(u1,v1,u2,v2);
point.SetParameter(0.0);
glin->AddVertex(point);
P=ElCLib::Value(0.0,Elips);
quad1.Parameters(P,u1,v1);
quad2.Parameters(P,u2,v2);
point.SetValue(P,TolArc,Standard_False);
point.SetParameters(u1,v1,u2,v2);
point.SetParameter(M_PI+M_PI);
glin->AddVertex(point);
P=ElCLib::Value(0.0,Elips);
quad1.Parameters(P,u1,v1);
quad2.Parameters(P,u2,v2);
point.SetValue(P,TolArc,Standard_False);
point.SetParameters(u1,v1,u2,v2);
point.SetParameter(M_PI+M_PI);
glin->AddVertex(point);
}
}
}
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;
}

678
src/IntPatch/IntPatch_ImpImpIntersection_3.gxx
View File

@ -17,18 +17,21 @@
//modified by NIZNHY-PKV Thu Sep 15 11:09:12 2011
static
void SeamPosition(const gp_Pnt& aPLoc,
const gp_Ax3& aPos,
gp_Ax2& aSeamPos);
const gp_Ax3& aPos,
gp_Ax2& aSeamPos);
static
void AdjustToSeam (const gp_Cylinder& aQuad,
gp_Circ& aCirc);
gp_Circ& aCirc);
static
void AdjustToSeam (const gp_Sphere& aQuad,
gp_Circ& aCirc,
const Standard_Real aTolAng);
gp_Circ& aCirc,
const Standard_Real aTolAng);
static
void AdjustToSeam (const gp_Cone& aQuad,
gp_Circ& aCirc);
gp_Circ& aCirc);
static
void AdjustToSeam (const gp_Torus& aQuad,
gp_Circ& aCirc);
//modified by NIZNHY-PKV Thu Sep 15 11:09:13 2011
//=======================================================================
@ -37,11 +40,11 @@ static
// Traitement du cas Plan/Plan
//=======================================================================
Standard_Boolean IntPP (const IntSurf_Quadric& Quad1,
const IntSurf_Quadric& Quad2,
const Standard_Real Tolang,
const Standard_Real TolTang,
Standard_Boolean& Same,
IntPatch_SequenceOfLine& slin)
const IntSurf_Quadric& Quad2,
const Standard_Real Tolang,
const Standard_Real TolTang,
Standard_Boolean& Same,
IntPatch_SequenceOfLine& slin)
{
IntSurf_TypeTrans trans1,trans2;
@ -82,12 +85,12 @@ Standard_Boolean IntPP (const IntSurf_Quadric& Quad1,
// Traitement du cas Plan/Cylindre et reciproquement
//=======================================================================
Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
const IntSurf_Quadric& Quad2,
const Standard_Real Tolang,
const Standard_Real TolTang,
const Standard_Boolean Reversed,
Standard_Boolean& Empty,
IntPatch_SequenceOfLine& slin,
const IntSurf_Quadric& Quad2,
const Standard_Real Tolang,
const Standard_Real TolTang,
const Standard_Boolean Reversed,
Standard_Boolean& Empty,
IntPatch_SequenceOfLine& slin,
const Standard_Real H)
{
@ -113,7 +116,7 @@ Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
Empty = Standard_False;
switch (typint) {
case IntAna_Empty : {
Empty = Standard_True;
}
@ -123,78 +126,78 @@ Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
gp_Lin linsol = inter.Line(1);
gp_Pnt orig(linsol.Location());
if (NbSol == 1) { // ligne de tangence
gp_Vec TestCurvature(orig,Cy.Location());
gp_Vec Normp,Normcyl;
if (!Reversed) {
Normp = Quad1.Normale(orig);
Normcyl = Quad2.Normale(orig);
}
else {
Normp = Quad2.Normale(orig);
Normcyl = Quad1.Normale(orig);
}
IntSurf_Situation situcyl;
IntSurf_Situation situp;
gp_Vec TestCurvature(orig,Cy.Location());
gp_Vec Normp,Normcyl;
if (!Reversed) {
Normp = Quad1.Normale(orig);
Normcyl = Quad2.Normale(orig);
}
else {
Normp = Quad2.Normale(orig);
Normcyl = Quad1.Normale(orig);
}
IntSurf_Situation situcyl;
IntSurf_Situation situp;
if (Normp.Dot(TestCurvature) > 0.) {
situcyl = IntSurf_Outside;
if (Normp.Dot(Normcyl) > 0.) {
situp = IntSurf_Inside;
}
else {
situp = IntSurf_Outside;
}
}
else {
situcyl = IntSurf_Inside;
if (Normp.Dot(Normcyl) > 0.) {
situp = IntSurf_Outside;
}
else {
situp = IntSurf_Inside;
}
}
Handle(IntPatch_GLine) glig;
if (!Reversed) {
glig = new IntPatch_GLine(linsol, Standard_True, situp, situcyl);
}
else {
glig = new IntPatch_GLine(linsol, Standard_True, situcyl, situp);
}
slin.Append(glig);
if (Normp.Dot(TestCurvature) > 0.) {
situcyl = IntSurf_Outside;
if (Normp.Dot(Normcyl) > 0.) {
situp = IntSurf_Inside;
}
else {
situp = IntSurf_Outside;
}
}
else {
situcyl = IntSurf_Inside;
if (Normp.Dot(Normcyl) > 0.) {
situp = IntSurf_Outside;
}
else {
situp = IntSurf_Inside;
}
}
Handle(IntPatch_GLine) glig;
if (!Reversed) {
glig = new IntPatch_GLine(linsol, Standard_True, situp, situcyl);
}
else {
glig = new IntPatch_GLine(linsol, Standard_True, situcyl, situp);
}
slin.Append(glig);
}
else {
// on a 2 droites. Il faut determiner les transitions
// de chacune.
if (linsol.Direction().DotCross(Quad2.Normale(orig),
Quad1.Normale(orig)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
Handle(IntPatch_GLine) glig =
new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
slin.Append(glig);
linsol = inter.Line(2);
orig = linsol.Location();
// on a 2 droites. Il faut determiner les transitions
// de chacune.
if (linsol.Direction().DotCross(Quad2.Normale(orig),
Quad1.Normale(orig)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
Handle(IntPatch_GLine) glig =
new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
slin.Append(glig);
linsol = inter.Line(2);
orig = linsol.Location();
if (linsol.Direction().DotCross(Quad2.Normale(orig),
Quad1.Normale(orig)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
slin.Append(glig);
if (linsol.Direction().DotCross(Quad2.Normale(orig),
Quad1.Normale(orig)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
slin.Append(glig);
}
}
break;
@ -211,12 +214,12 @@ Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
ElCLib::D1(0.,cirsol,ptref,Tgt);
if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) > 0.0) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2);
slin.Append(glig);
@ -230,12 +233,12 @@ Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
ElCLib::D1(0.,elipsol,ptref,Tgt);
if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) > 0.0) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
Handle(IntPatch_GLine) glig = new IntPatch_GLine(elipsol,Standard_False,trans1,trans2);
slin.Append(glig);
@ -254,15 +257,15 @@ Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
// Traitement du cas Plan/Sphere et reciproquement
//=======================================================================
Standard_Boolean IntPSp (const IntSurf_Quadric& Quad1,
const IntSurf_Quadric& Quad2,
//modified by NIZNHY-PKV Tue Sep 20 08:59:36 2011f
const Standard_Real Tolang,
//modified by NIZNHY-PKV Tue Sep 20 08:59:39 2011t
const Standard_Real TolTang,
const Standard_Boolean Reversed,
Standard_Boolean& Empty,
IntPatch_SequenceOfLine& slin,
IntPatch_SequenceOfPoint& spnt)
const IntSurf_Quadric& Quad2,
//modified by NIZNHY-PKV Tue Sep 20 08:59:36 2011f
const Standard_Real Tolang,
//modified by NIZNHY-PKV Tue Sep 20 08:59:39 2011t
const Standard_Real TolTang,
const Standard_Boolean Reversed,
Standard_Boolean& Empty,
IntPatch_SequenceOfLine& slin,
IntPatch_SequenceOfPoint& spnt)
{
@ -316,12 +319,12 @@ Standard_Boolean IntPSp (const IntSurf_Quadric& Quad1,
ElCLib::D1(0.,cirsol,ptref,Tgt);
if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2);
slin.Append(glig);
@ -340,14 +343,14 @@ Standard_Boolean IntPSp (const IntSurf_Quadric& Quad1,
// Traitement du cas Plan/Cone et reciproquement
//=======================================================================
Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
const IntSurf_Quadric& Quad2,
const Standard_Real Tolang,
const Standard_Real TolTang,
const Standard_Boolean Reversed,
Standard_Boolean& Empty,
Standard_Boolean& Multpoint,
IntPatch_SequenceOfLine& slin,
IntPatch_SequenceOfPoint& spnt)
const IntSurf_Quadric& Quad2,
const Standard_Real Tolang,
const Standard_Real TolTang,
const Standard_Boolean Reversed,
Standard_Boolean& Empty,
Standard_Boolean& Multpoint,
IntPatch_SequenceOfLine& slin,
IntPatch_SequenceOfPoint& spnt)
{
@ -396,7 +399,7 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
case IntAna_Line: {
gp_Lin linsol = inter.Line(1);
if (linsol.Direction().Dot(Co.Axis().Direction()) <0.) {
linsol.SetDirection(linsol.Direction().Reversed());
linsol.SetDirection(linsol.Direction().Reversed());
}
Standard_Real para = ElCLib::Parameter(linsol, apex);
gp_Pnt ptbid (ElCLib::Value(para+5.,linsol));
@ -405,149 +408,149 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
Quad2.Parameters(apex,U2,V2);
if (NbSol == 1) { // ligne de tangence
IntPatch_Point ptsol;
ptsol.SetValue(apex,TolTang,Standard_False);
ptsol.SetParameters(U1,V1,U2,V2);
ptsol.SetParameter(para);
gp_Pnt ptbid2(apex.XYZ() + 5.*Co.Axis().Direction().XYZ());
gp_Vec TestCurvature(ptbid,ptbid2);
gp_Vec Normp,Normco;
if (!Reversed) {
Normp = Quad1.Normale(ptbid);
Normco = Quad2.Normale(ptbid);
}
else {
Normp = Quad2.Normale(ptbid);
Normco = Quad1.Normale(ptbid);
}
IntSurf_Situation situco,situco_otherside;
IntSurf_Situation situp,situp_otherside;
if (Normp.Dot(TestCurvature) > 0.) {
situco = IntSurf_Outside;
situco_otherside = IntSurf_Inside;
if (Normp.Dot(Normco) > 0.) {
situp = IntSurf_Inside;
situp_otherside = IntSurf_Outside;
}
else {
situp = IntSurf_Outside;
situp_otherside = IntSurf_Inside;
}
}
else {
situco = IntSurf_Inside;
situco_otherside = IntSurf_Outside;
if (Normp.Dot(Normco) > 0.) {
situp = IntSurf_Outside;
situp_otherside = IntSurf_Inside;
}
else {
situp = IntSurf_Inside;
situp_otherside = IntSurf_Outside;
}
}
//----------------------------------------------------------
//-- Apex ---> Cone.Direction
//--
Handle(IntPatch_GLine) glig;
if (!Reversed) {
glig = new IntPatch_GLine(linsol, Standard_True, situp, situco);
}
else {
glig = new IntPatch_GLine(linsol, Standard_True, situco, situp);
}
glig->AddVertex(ptsol);
glig->SetFirstPoint(1);
slin.Append(glig);
//----------------------------------------------------------
//-- -Cone.Direction <------- Apex
//--
linsol.SetDirection(linsol.Direction().Reversed());
if (!Reversed) {
glig = new IntPatch_GLine(linsol, Standard_True, situp_otherside, situco_otherside);
}
else {
glig = new IntPatch_GLine(linsol, Standard_True, situco_otherside, situp_otherside);
}
glig->AddVertex(ptsol);
glig->SetFirstPoint(1);
slin.Append(glig);
IntPatch_Point ptsol;
ptsol.SetValue(apex,TolTang,Standard_False);
ptsol.SetParameters(U1,V1,U2,V2);
ptsol.SetParameter(para);
gp_Pnt ptbid2(apex.XYZ() + 5.*Co.Axis().Direction().XYZ());
gp_Vec TestCurvature(ptbid,ptbid2);
gp_Vec Normp,Normco;
if (!Reversed) {
Normp = Quad1.Normale(ptbid);
Normco = Quad2.Normale(ptbid);
}
else {
Normp = Quad2.Normale(ptbid);
Normco = Quad1.Normale(ptbid);
}
IntSurf_Situation situco,situco_otherside;
IntSurf_Situation situp,situp_otherside;
if (Normp.Dot(TestCurvature) > 0.) {
situco = IntSurf_Outside;
situco_otherside = IntSurf_Inside;
if (Normp.Dot(Normco) > 0.) {
situp = IntSurf_Inside;
situp_otherside = IntSurf_Outside;
}
else {
situp = IntSurf_Outside;
situp_otherside = IntSurf_Inside;
}
}
else {
situco = IntSurf_Inside;
situco_otherside = IntSurf_Outside;
if (Normp.Dot(Normco) > 0.) {
situp = IntSurf_Outside;
situp_otherside = IntSurf_Inside;
}
else {
situp = IntSurf_Inside;
situp_otherside = IntSurf_Outside;
}
}
//----------------------------------------------------------
//-- Apex ---> Cone.Direction
//--
Handle(IntPatch_GLine) glig;
if (!Reversed) {
glig = new IntPatch_GLine(linsol, Standard_True, situp, situco);
}
else {
glig = new IntPatch_GLine(linsol, Standard_True, situco, situp);
}
glig->AddVertex(ptsol);
glig->SetFirstPoint(1);
slin.Append(glig);
//----------------------------------------------------------
//-- -Cone.Direction <------- Apex
//--
linsol.SetDirection(linsol.Direction().Reversed());
if (!Reversed) {
glig = new IntPatch_GLine(linsol, Standard_True, situp_otherside, situco_otherside);
}
else {
glig = new IntPatch_GLine(linsol, Standard_True, situco_otherside, situp_otherside);
}
glig->AddVertex(ptsol);
glig->SetFirstPoint(1);
slin.Append(glig);
}
else {
// on a 2 droites. Il faut determiner les transitions
// de chacune. On oriente chaque ligne dans le sens
// de l axe du cone. Les transitions de chaque ligne seront
// inverses l une de l autre => on ne fait le calcul que sur
// la premiere.
if (linsol.Direction().DotCross
(Quad2.Normale(ptbid),Quad1.Normale(ptbid)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
// on a 2 droites. Il faut determiner les transitions
// de chacune. On oriente chaque ligne dans le sens
// de l axe du cone. Les transitions de chaque ligne seront
// inverses l une de l autre => on ne fait le calcul que sur
// la premiere.
if (linsol.Direction().DotCross
(Quad2.Normale(ptbid),Quad1.Normale(ptbid)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
Multpoint = Standard_True;
//------------------------------------------- Ligne 1 -------
IntPatch_Point ptsol;
ptsol.SetValue(apex,TolTang,Standard_False);
ptsol.SetParameters(U1,V1,U2,V2);
ptsol.SetParameter(para);
ptsol.SetMultiple(Standard_True);
Handle(IntPatch_GLine) glig;
glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
glig->AddVertex(ptsol);
glig->SetFirstPoint(1);
slin.Append(glig);
//-----------------------------------------------------------
//-- Other Side : Les transitions restent les memes
//-- linsol -> -linsol et Quad1(2).N -> -Quad1(2).N
//--
linsol.SetDirection(linsol.Direction().Reversed());
glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
para = ElCLib::Parameter(linsol, apex);
ptsol.SetParameter(para);
glig->AddVertex(ptsol);
glig->SetFirstPoint(1);
slin.Append(glig);
//------------------------------------------- Ligne 2 -------
linsol = inter.Line(2);
if (linsol.Direction().Dot(Co.Axis().Direction()) <0.) {
linsol.SetDirection(linsol.Direction().Reversed());
}
para = ElCLib::Parameter(linsol, apex);
ptbid = ElCLib::Value(para+5.,linsol);
if (linsol.Direction().DotCross
(Quad2.Normale(ptbid),Quad1.Normale(ptbid)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
ptsol.SetParameter(para);
glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
para = ElCLib::Parameter(linsol, apex);
ptsol.SetParameter(para);
glig->AddVertex(ptsol);
glig->SetFirstPoint(1);
slin.Append(glig);
//-----------------------------------------------------------
//-- Other Side : Les transitions restent les memes
//-- linsol -> -linsol et Quad1(2).N -> -Quad1(2).N
//--
linsol.SetDirection(linsol.Direction().Reversed());
glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
para = ElCLib::Parameter(linsol, apex);
ptsol.SetParameter(para);
glig->AddVertex(ptsol);
glig->SetFirstPoint(1);
slin.Append(glig);
Multpoint = Standard_True;
//------------------------------------------- Ligne 1 -------
IntPatch_Point ptsol;
ptsol.SetValue(apex,TolTang,Standard_False);
ptsol.SetParameters(U1,V1,U2,V2);
ptsol.SetParameter(para);
ptsol.SetMultiple(Standard_True);
Handle(IntPatch_GLine) glig;
glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
glig->AddVertex(ptsol);
glig->SetFirstPoint(1);
slin.Append(glig);
//-----------------------------------------------------------
//-- Other Side : Les transitions restent les memes
//-- linsol -> -linsol et Quad1(2).N -> -Quad1(2).N
//--
linsol.SetDirection(linsol.Direction().Reversed());
glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
para = ElCLib::Parameter(linsol, apex);
ptsol.SetParameter(para);
glig->AddVertex(ptsol);
glig->SetFirstPoint(1);
slin.Append(glig);
//------------------------------------------- Ligne 2 -------
linsol = inter.Line(2);
if (linsol.Direction().Dot(Co.Axis().Direction()) <0.) {
linsol.SetDirection(linsol.Direction().Reversed());
}
para = ElCLib::Parameter(linsol, apex);
ptbid = ElCLib::Value(para+5.,linsol);
if (linsol.Direction().DotCross
(Quad2.Normale(ptbid),Quad1.Normale(ptbid)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
ptsol.SetParameter(para);
glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
para = ElCLib::Parameter(linsol, apex);
ptsol.SetParameter(para);
glig->AddVertex(ptsol);
glig->SetFirstPoint(1);
slin.Append(glig);
//-----------------------------------------------------------
//-- Other Side : Les transitions restent les memes
//-- linsol -> -linsol et Quad1(2).N -> -Quad1(2).N
//--
linsol.SetDirection(linsol.Direction().Reversed());
glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
para = ElCLib::Parameter(linsol, apex);
ptsol.SetParameter(para);
glig->AddVertex(ptsol);
glig->SetFirstPoint(1);
slin.Append(glig);
}
}
break;
@ -562,12 +565,12 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
ElCLib::D1(0.,cirsol,ptref,Tgt);
if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2);
slin.Append(glig);
@ -581,12 +584,12 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
ElCLib::D1(0.,elipsol,ptref,Tgt);
if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
Handle(IntPatch_GLine) glig = new IntPatch_GLine(elipsol,Standard_False,trans1,trans2);
slin.Append(glig);
@ -598,17 +601,17 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
gp_Vec Tgtorig(parabsol.YAxis().Direction());
Standard_Real ptran = Tgtorig.DotCross(Quad2.Normale(parabsol.Location()),
Quad1.Normale(parabsol.Location()));
Quad1.Normale(parabsol.Location()));
if (ptran >0.00000001) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else if (ptran <-0.00000001) {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
else {
trans1=trans2=IntSurf_Undecided;
trans1=trans2=IntSurf_Undecided;
}
Handle(IntPatch_GLine) glig = new IntPatch_GLine(parabsol,Standard_False,trans1,trans2);
slin.Append(glig);
@ -620,26 +623,26 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
gp_Vec Tgttop;
for(Standard_Integer i=1; i<=2; i++) {
gp_Hypr hyprsol = inter.Hyperbola(i);
tophypr = ElCLib::Value(hyprsol.MajorRadius(),
hyprsol.XAxis());
Tgttop = hyprsol.YAxis().Direction();
Standard_Real qwe = Tgttop.DotCross(Quad2.Normale(tophypr),
Quad1.Normale(tophypr));
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(hyprsol,Standard_False,trans1,trans2);
slin.Append(glig);
gp_Hypr hyprsol = inter.Hyperbola(i);
tophypr = ElCLib::Value(hyprsol.MajorRadius(),
hyprsol.XAxis());
Tgttop = hyprsol.YAxis().Direction();
Standard_Real qwe = Tgttop.DotCross(Quad2.Normale(tophypr),
Quad1.Normale(tophypr));
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(hyprsol,Standard_False,trans1,trans2);
slin.Append(glig);
}
}
break;
@ -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
//=======================================================================
@ -657,7 +727,7 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
//purpose :
//=======================================================================
void AdjustToSeam (const gp_Cone& aQuad,
gp_Circ& aCirc)
gp_Circ& aCirc)
{
gp_Ax2 aAx2;
//
@ -671,8 +741,8 @@ void AdjustToSeam (const gp_Cone& aQuad,
//purpose :
//=======================================================================
void AdjustToSeam (const gp_Sphere& aQuad,
gp_Circ& aCirc,
const Standard_Real aTolAng)
gp_Circ& aCirc,
const Standard_Real aTolAng)
{
gp_Ax2 aAx2;
//
@ -693,7 +763,7 @@ void AdjustToSeam (const gp_Sphere& aQuad,
//purpose :
//=======================================================================
void AdjustToSeam (const gp_Cylinder& aQuad,
gp_Circ& aCirc)
gp_Circ& aCirc)
{
gp_Ax2 aAx2;
//
@ -703,17 +773,31 @@ 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 :
//=======================================================================
void SeamPosition(const gp_Pnt& aPLoc,
const gp_Ax3& aPos,
gp_Ax2& aSeamPos)
const gp_Ax3& aPos,
gp_Ax2& aSeamPos)
{
const gp_Dir& aDZ=aPos.Direction();
const gp_Dir& aDX=aPos.XDirection();
gp_Ax2 aAx2(aPLoc, aDZ, aDX);
aSeamPos=aAx2;
}
//modified by NIZNHY-PKV Thu Sep 15 10:53:41 2011t

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;
}

18
src/IntPatch/IntPatch_LineConstructor.cxx
View File

@ -134,12 +134,12 @@ static void Recadre(const Handle(Adaptor3d_HSurface)& myHS1,
//=======================================================================
static void Parameters(const Handle(Adaptor3d_HSurface)& myHS1,
const Handle(Adaptor3d_HSurface)& myHS2,
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1,
Standard_Real& U2,
Standard_Real& V2)
const Handle(Adaptor3d_HSurface)& myHS2,
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1,
Standard_Real& U2,
Standard_Real& V2)
{
IntSurf_Quadric quad1,quad2;
GeomAbs_SurfaceType typs = myHS1->Surface().GetType();
@ -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");
}

20
src/IntSurf/IntSurf_Quadric.cdl
View File

@ -27,7 +27,8 @@ uses Ax3 from gp,
Pln from gp,
Cylinder from gp,
Sphere from gp,
Cone from gp,
Cone from gp,
Torus from gp,
SurfaceType from GeomAbs
is
@ -55,6 +56,11 @@ is
Create(C: Cone from gp)
returns Quadric from IntSurf;
Create(T: Torus from gp)
returns Quadric from IntSurf;
SetValue(me: in out; P: Pln from gp)
@ -75,6 +81,10 @@ is
SetValue(me: in out; C: Cone from gp)
is static;
SetValue(me: in out; T: Torus from gp)
is static;
Distance(me; P: Pnt from gp)
@ -135,6 +145,14 @@ is
---C++: inline
is static;
Torus(me)
returns Torus from gp
---C++: inline
is static;

170
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:
{
}
@ -163,11 +201,29 @@ gp_Vec IntSurf_Quadric::Gradient (const gp_Pnt& P) const {
ElSLib::ConeD1(U,V,ax3,prm1,prm2,Pp,D1u,D1v);
grad=D1u.Crossed(D1v);
if(ax3direc==Standard_False) {
grad.Reverse();
grad.Reverse();
}
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;
@ -176,8 +232,8 @@ gp_Vec IntSurf_Quadric::Gradient (const gp_Pnt& P) const {
}
// ============================================================
void IntSurf_Quadric::ValAndGrad (const gp_Pnt& P,
Standard_Real& Dist,
gp_Vec& Grad) const
Standard_Real& Dist,
gp_Vec& Grad) const
{
switch (typ) {
@ -221,19 +277,39 @@ void IntSurf_Quadric::ValAndGrad (const gp_Pnt& P,
Dist = dist;
Grad=D1u.Crossed(D1v);
if(ax3direc==Standard_False) {
Grad.Reverse();
Grad.Reverse();
}
//-- lbr le 7 mars 96
//-- Si le gardient est nul, on est sur l axe
//-- et dans ce cas dist vaut 0
//-- On peut donc renvoyer une valeur quelconque.
if( Grad.X() > 1e-13
|| Grad.Y() > 1e-13
|| Grad.Z() > 1e-13) {
Grad.Normalize();
|| Grad.Y() > 1e-13
|| Grad.Z() > 1e-13) {
Grad.Normalize();
}
}
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;
@ -241,7 +317,7 @@ void IntSurf_Quadric::ValAndGrad (const gp_Pnt& P,
}
// ============================================================
gp_Pnt IntSurf_Quadric::Value(const Standard_Real U,
const Standard_Real V) const
const Standard_Real V) const
{
switch (typ) {
@ -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);
@ -265,10 +343,10 @@ gp_Pnt IntSurf_Quadric::Value(const Standard_Real U,
}
// ============================================================
void IntSurf_Quadric::D1(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V) const
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V) const
{
switch (typ) {
case GeomAbs_Plane:
@ -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:
{
}
@ -291,9 +372,9 @@ void IntSurf_Quadric::D1(const Standard_Real U,
}
// ============================================================
gp_Vec IntSurf_Quadric::DN(const Standard_Real U,
const Standard_Real V,
const Standard_Integer Nu,
const Standard_Integer Nv) const
const Standard_Real V,
const Standard_Integer Nu,
const Standard_Integer Nv) const
{
switch (typ) {
case GeomAbs_Plane:
@ -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);
@ -316,7 +399,7 @@ gp_Vec IntSurf_Quadric::DN(const Standard_Real U,
}
// ============================================================
gp_Vec IntSurf_Quadric::Normale(const Standard_Real U,
const Standard_Real V) const
const Standard_Real V) const
{
switch (typ) {
case GeomAbs_Plane:
@ -334,11 +417,13 @@ gp_Vec IntSurf_Quadric::Normale(const Standard_Real U,
gp_Vec D1u,D1v;
ElSLib::ConeD1(U,V,ax3,prm1,prm2,P,D1u,D1v);
if(D1u.Magnitude()<0.0000001) {
gp_Vec Vn(0.0,0.0,0.0);
return(Vn);
gp_Vec Vn(0.0,0.0,0.0);
return(Vn);
}
return(D1u.Crossed(D1v));
}
case GeomAbs_Torus:
return Normale(Value(U,V));
default:
{
gp_Vec v(0,0,0);
@ -361,30 +446,47 @@ gp_Vec IntSurf_Quadric::Normale (const gp_Pnt& P) const
case GeomAbs_Cylinder:
{
if(ax3direc) {
return lin.Normal(P).Direction();
return lin.Normal(P).Direction();
}
else {
gp_Dir D(lin.Normal(P).Direction());
D.Reverse();
return(D);
gp_Dir D(lin.Normal(P).Direction());
D.Reverse();
return(D);
}
}
case GeomAbs_Sphere:
{
if(ax3direc) {
gp_Vec ax3P(ax3.Location(),P);
return gp_Dir(ax3P);
gp_Vec ax3P(ax3.Location(),P);
return gp_Dir(ax3P);
}
else {
gp_Vec Pax3(P,ax3.Location());
return gp_Dir(Pax3);
gp_Vec Pax3(P,ax3.Location());
return gp_Dir(Pax3);
}
}
case GeomAbs_Cone:
{
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:
{
@ -395,8 +497,8 @@ gp_Vec IntSurf_Quadric::Normale (const gp_Pnt& P) const
}
// ============================================================
void IntSurf_Quadric::Parameters (const gp_Pnt& P,
Standard_Real& U,
Standard_Real& V) const
Standard_Real& U,
Standard_Real& V) const
{
switch (typ) {
case GeomAbs_Plane:
@ -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);
}
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");
}

9
src/IntTools/IntTools_LineConstructor.cxx
View File

@ -594,9 +594,9 @@ void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
//purpose :
//=======================================================================
void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1)
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1)
{
IntSurf_Quadric quad1;
//
@ -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