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

0022723: Wrong intersection curve for the case of intersection between cylinder and plane

Browse Source
This commit is contained in:
PKV 2011-09-21 12:19:34 +00:00 committed by bugmaster
parent 1c72dff612
commit a9f7b6b58e
5 changed files with 268 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/IntPatch/IntPatch_ImpImpIntersection_1.gxx
View File

@ -21,6 +21,9 @@ static Standard_Boolean IntPCy (const IntSurf_Quadric&,
static Standard_Boolean IntPSp (const IntSurf_Quadric&, static Standard_Boolean IntPSp (const IntSurf_Quadric&,
const IntSurf_Quadric&, const IntSurf_Quadric&,
//modified by NIZNHY-PKV Tue Sep 20 08:59:56 2011t
const Standard_Real,
//modified by NIZNHY-PKV Tue Sep 20 08:59:52 2011t
const Standard_Real, const Standard_Real,
const Standard_Boolean, const Standard_Boolean,
Standard_Boolean&, Standard_Boolean&,

10
src/IntPatch/IntPatch_ImpImpIntersection_2.gxx
View File

@ -98,7 +98,10 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
case GeomAbs_Sphere: case GeomAbs_Sphere:
{ {
quad2.SetValue(S2->Sphere()); quad2.SetValue(S2->Sphere());
if (!IntPSp(quad1,quad2,TolTang,Standard_False,empt,slin,spnt)) { //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; return;
} }
if (empt) { if (empt) {
@ -208,7 +211,10 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
case GeomAbs_Plane: case GeomAbs_Plane:
{ {
quad2.SetValue(S2->Plane()); quad2.SetValue(S2->Plane());
if (!IntPSp(quad1,quad2,TolTang,Standard_True,empt,slin,spnt)) { //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; return;
} }
if (empt) { if (empt) {

331
src/IntPatch/IntPatch_ImpImpIntersection_3.gxx
View File

@ -3,13 +3,35 @@
// Author: Jacques GOUSSARD // Author: Jacques GOUSSARD
// Copyright: OPEN CASCADE 1992 // Copyright: OPEN CASCADE 1992
//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);
static
void AdjustToSeam (const gp_Cylinder& aQuad,
gp_Circ& aCirc);
static
void AdjustToSeam (const gp_Sphere& aQuad,
gp_Circ& aCirc,
const Standard_Real aTolAng);
static
void AdjustToSeam (const gp_Cone& aQuad,
gp_Circ& aCirc);
//modified by NIZNHY-PKV Thu Sep 15 11:09:13 2011
//=======================================================================
//function : IntPP
//purpose :
// Traitement du cas Plan/Plan
//=======================================================================
Standard_Boolean IntPP (const IntSurf_Quadric& Quad1, Standard_Boolean IntPP (const IntSurf_Quadric& Quad1,
const IntSurf_Quadric& Quad2, const IntSurf_Quadric& Quad2,
const Standard_Real Tolang, const Standard_Real Tolang,
const Standard_Real TolTang, const Standard_Real TolTang,
Standard_Boolean& Same, Standard_Boolean& Same,
IntPatch_SequenceOfLine& slin) IntPatch_SequenceOfLine& slin)
// Traitement du cas Plan/Plan
{ {
IntSurf_TypeTrans trans1,trans2; IntSurf_TypeTrans trans1,trans2;
IntAna_ResultType typint; IntAna_ResultType typint;
@ -37,12 +59,17 @@ Standard_Boolean IntPP (const IntSurf_Quadric& Quad1,
trans1 = IntSurf_In; trans1 = IntSurf_In;
trans2 = IntSurf_Out; trans2 = IntSurf_Out;
} }
Handle(IntPatch_GLine) glig = new IntPatch_GLine (linsol,Standard_False,trans1,trans2); Handle(IntPatch_GLine) glig =
new IntPatch_GLine (linsol,Standard_False,trans1,trans2);
slin.Append(glig); slin.Append(glig);
} }
return Standard_True; return Standard_True;
} }
//==================================================================================== //=======================================================================
//function : IntPCy
//purpose :
// Traitement du cas Plan/Cylindre et reciproquement
//=======================================================================
Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1, Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
const IntSurf_Quadric& Quad2, const IntSurf_Quadric& Quad2,
const Standard_Real Tolang, const Standard_Real Tolang,
@ -51,7 +78,6 @@ Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
Standard_Boolean& Empty, Standard_Boolean& Empty,
IntPatch_SequenceOfLine& slin) IntPatch_SequenceOfLine& slin)
// Traitement du cas Plan/Cylindre et reciproquement
{ {
gp_Pln Pl; gp_Pln Pl;
gp_Cylinder Cy; gp_Cylinder Cy;
@ -76,14 +102,12 @@ Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
switch (typint) { switch (typint) {
case IntAna_Empty : case IntAna_Empty : {
{
Empty = Standard_True; Empty = Standard_True;
} }
break; break;
case IntAna_Line: case IntAna_Line: {
{
gp_Lin linsol = inter.Line(1); gp_Lin linsol = inter.Line(1);
gp_Pnt orig(linsol.Location()); gp_Pnt orig(linsol.Location());
if (NbSol == 1) { // ligne de tangence if (NbSol == 1) { // ligne de tangence
@ -128,7 +152,8 @@ Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
} }
slin.Append(glig); slin.Append(glig);
} }
else { // on a 2 droites. Il faut determiner les transitions else {
// on a 2 droites. Il faut determiner les transitions
// de chacune. // de chacune.
if (linsol.Direction().DotCross(Quad2.Normale(orig), if (linsol.Direction().DotCross(Quad2.Normale(orig),
@ -140,7 +165,8 @@ Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
trans1 = IntSurf_In; trans1 = IntSurf_In;
trans2 = IntSurf_Out; trans2 = IntSurf_Out;
} }
Handle(IntPatch_GLine) glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2); Handle(IntPatch_GLine) glig =
new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
slin.Append(glig); slin.Append(glig);
linsol = inter.Line(2); linsol = inter.Line(2);
@ -159,13 +185,17 @@ Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
slin.Append(glig); slin.Append(glig);
} }
} }
break; break;
//
case IntAna_Circle: case IntAna_Circle: {
{ gp_Circ cirsol;
gp_Circ cirsol = inter.Circle(1);
gp_Pnt ptref; gp_Pnt ptref;
gp_Vec Tgt; gp_Vec Tgt;
//
cirsol = inter.Circle(1);
//modified by NIZNHY-PKV Thu Sep 15 11:30:03 2011f
AdjustToSeam(Cy, cirsol);
//modified by NIZNHY-PKV Thu Sep 15 11:30:15 2011t
ElCLib::D1(0.,cirsol,ptref,Tgt); ElCLib::D1(0.,cirsol,ptref,Tgt);
if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) > 0.0) { if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) > 0.0) {
@ -179,10 +209,9 @@ Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2); Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2);
slin.Append(glig); slin.Append(glig);
} }
break; break;
//
case IntAna_Ellipse: case IntAna_Ellipse: {
{
gp_Elips elipsol = inter.Ellipse(1); gp_Elips elipsol = inter.Ellipse(1);
gp_Pnt ptref; gp_Pnt ptref;
gp_Vec Tgt; gp_Vec Tgt;
@ -199,25 +228,31 @@ Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
Handle(IntPatch_GLine) glig = new IntPatch_GLine(elipsol,Standard_False,trans1,trans2); Handle(IntPatch_GLine) glig = new IntPatch_GLine(elipsol,Standard_False,trans1,trans2);
slin.Append(glig); slin.Append(glig);
} }
break; break;
//
default: default: {
{
return Standard_False; // on ne doit pas passer ici return Standard_False; // on ne doit pas passer ici
} }
} }
return Standard_True; return Standard_True;
} }
//==================================================================================== //=======================================================================
//function : IntPSp
//purpose :
// Traitement du cas Plan/Sphere et reciproquement
//=======================================================================
Standard_Boolean IntPSp (const IntSurf_Quadric& Quad1, Standard_Boolean IntPSp (const IntSurf_Quadric& Quad1,
const IntSurf_Quadric& Quad2, 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_Real TolTang,
const Standard_Boolean Reversed, const Standard_Boolean Reversed,
Standard_Boolean& Empty, Standard_Boolean& Empty,
IntPatch_SequenceOfLine& slin, IntPatch_SequenceOfLine& slin,
IntPatch_SequenceOfPoint& spnt) IntPatch_SequenceOfPoint& spnt)
// Traitement du cas Plan/Sphere et reciproquement
{ {
gp_Circ cirsol; gp_Circ cirsol;
gp_Pln Pl; gp_Pln Pl;
@ -242,15 +277,12 @@ Standard_Boolean IntPSp (const IntSurf_Quadric& Quad1,
Empty = Standard_False; Empty = Standard_False;
switch (typint) { switch (typint) {
case IntAna_Empty : {
case IntAna_Empty :
{
Empty = Standard_True; Empty = Standard_True;
} }
break; break;
//
case IntAna_Point: case IntAna_Point: {
{
gp_Pnt psol = inter.Point(1); gp_Pnt psol = inter.Point(1);
Standard_Real U1,V1,U2,V2; Standard_Real U1,V1,U2,V2;
Quad1.Parameters(psol,U1,V1); Quad1.Parameters(psol,U1,V1);
@ -260,11 +292,13 @@ Standard_Boolean IntPSp (const IntSurf_Quadric& Quad1,
ptsol.SetParameters(U1,V1,U2,V2); ptsol.SetParameters(U1,V1,U2,V2);
spnt.Append(ptsol); spnt.Append(ptsol);
} }
break; break;
//
case IntAna_Circle: case IntAna_Circle: {
{
cirsol = inter.Circle(1); cirsol = inter.Circle(1);
//modified by NIZNHY-PKV Thu Sep 15 11:30:03 2011f
AdjustToSeam(Sp, cirsol, Tolang);
//modified by NIZNHY-PKV Thu Sep 15 11:30:15 2011t
gp_Pnt ptref; gp_Pnt ptref;
gp_Vec Tgt; gp_Vec Tgt;
ElCLib::D1(0.,cirsol,ptref,Tgt); ElCLib::D1(0.,cirsol,ptref,Tgt);
@ -280,16 +314,19 @@ Standard_Boolean IntPSp (const IntSurf_Quadric& Quad1,
Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2); Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2);
slin.Append(glig); slin.Append(glig);
} }
break; break;
default: default: {
{
return Standard_False; // on ne doit pas passer ici return Standard_False; // on ne doit pas passer ici
} }
} }
return Standard_True; return Standard_True;
} }
//==================================================================================== //=======================================================================
//function : IntPCo
//purpose :
// Traitement du cas Plan/Cone et reciproquement
//=======================================================================
Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1, Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
const IntSurf_Quadric& Quad2, const IntSurf_Quadric& Quad2,
const Standard_Real Tolang, const Standard_Real Tolang,
@ -300,7 +337,7 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
IntPatch_SequenceOfLine& slin, IntPatch_SequenceOfLine& slin,
IntPatch_SequenceOfPoint& spnt) IntPatch_SequenceOfPoint& spnt)
// Traitement du cas Plan/Cone et reciproquement
{ {
gp_Pnt apex; gp_Pnt apex;
@ -323,16 +360,16 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
} }
inter.Perform(Pl,Co,Tolang,TolTang); inter.Perform(Pl,Co,Tolang,TolTang);
if (!inter.IsDone()) {return Standard_False;} if (!inter.IsDone()) {
return Standard_False;
}
//
typint = inter.TypeInter(); typint = inter.TypeInter();
Standard_Integer NbSol = inter.NbSolutions(); Standard_Integer NbSol = inter.NbSolutions();
Empty = Standard_False; Empty = Standard_False;
switch (typint) { switch (typint) {
case IntAna_Point: {
case IntAna_Point:
{
gp_Pnt psol = inter.Point(1); gp_Pnt psol = inter.Point(1);
Standard_Real U1,V1,U2,V2; Standard_Real U1,V1,U2,V2;
Quad1.Parameters(psol,U1,V1); Quad1.Parameters(psol,U1,V1);
@ -342,10 +379,9 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
ptsol.SetParameters(U1,V1,U2,V2); ptsol.SetParameters(U1,V1,U2,V2);
spnt.Append(ptsol); spnt.Append(ptsol);
} }
break; break;
case IntAna_Line: case IntAna_Line: {
{
gp_Lin linsol = inter.Line(1); gp_Lin linsol = inter.Line(1);
if (linsol.Direction().Dot(Co.Axis().Direction()) <0.) { if (linsol.Direction().Dot(Co.Axis().Direction()) <0.) {
linsol.SetDirection(linsol.Direction().Reversed()); linsol.SetDirection(linsol.Direction().Reversed());
@ -372,7 +408,6 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
Normp = Quad2.Normale(ptbid); Normp = Quad2.Normale(ptbid);
Normco = Quad1.Normale(ptbid); Normco = Quad1.Normale(ptbid);
} }
IntSurf_Situation situco,situco_otherside; IntSurf_Situation situco,situco_otherside;
IntSurf_Situation situp,situp_otherside; IntSurf_Situation situp,situp_otherside;
@ -505,99 +540,70 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
} }
break; break;
case IntAna_Circle: case IntAna_Circle: {
{
gp_Circ cirsol = inter.Circle(1); gp_Circ cirsol = inter.Circle(1);
#if 0 //modified by NIZNHY-PKV Thu Sep 15 11:34:04 2011f
if (ElCLib::LineParameter(Co.Axis(),cirsol.Location()) < AdjustToSeam(Co, cirsol);
ElCLib::LineParameter(Co.Axis(),apex) ) { //modified by NIZNHY-PKV Thu Sep 15 11:36:08 2011t
Empty = Standard_True; gp_Pnt ptref;
gp_Vec Tgt;
ElCLib::D1(0.,cirsol,ptref,Tgt);
if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
} }
#endif
if(0) { }
else { else {
trans1 = IntSurf_In;
gp_Pnt ptref; trans2 = IntSurf_Out;
gp_Vec Tgt;
ElCLib::D1(0.,cirsol,ptref,Tgt);
if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2);
slin.Append(glig);
} }
Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2);
slin.Append(glig);
} }
break; break;
case IntAna_Ellipse: case IntAna_Ellipse: {
{
gp_Elips elipsol = inter.Ellipse(1); gp_Elips elipsol = inter.Ellipse(1);
#if 0 gp_Pnt ptref;
if (ElCLib::LineParameter(Co.Axis(),elipsol.Location()) < gp_Vec Tgt;
ElCLib::LineParameter(Co.Axis(),apex) ) { ElCLib::D1(0.,elipsol,ptref,Tgt);
Empty = Standard_True;
if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
} }
#endif
if(0) { }
else { else {
gp_Pnt ptref; trans1 = IntSurf_In;
gp_Vec Tgt; trans2 = IntSurf_Out;
ElCLib::D1(0.,elipsol,ptref,Tgt);
if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
Handle(IntPatch_GLine) glig = new IntPatch_GLine(elipsol,Standard_False,trans1,trans2);
slin.Append(glig);
} }
Handle(IntPatch_GLine) glig = new IntPatch_GLine(elipsol,Standard_False,trans1,trans2);
slin.Append(glig);
} }
break; break;
case IntAna_Parabola: case IntAna_Parabola: {
{
gp_Parab parabsol = inter.Parabola(1); gp_Parab parabsol = inter.Parabola(1);
#if 0
if (ElCLib::LineParameter(Co.Axis(),parabsol.Focus()) < gp_Vec Tgtorig(parabsol.YAxis().Direction());
ElCLib::LineParameter(Co.Axis(),apex) ) { Standard_Real ptran = Tgtorig.DotCross(Quad2.Normale(parabsol.Location()),
Empty = Standard_True; Quad1.Normale(parabsol.Location()));
if (ptran >0.00000001) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else if (ptran <-0.00000001) {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
} }
#endif
if(0) { }
else { else {
trans1=trans2=IntSurf_Undecided;
gp_Vec Tgtorig(parabsol.YAxis().Direction());
Standard_Real ptran = Tgtorig.DotCross(Quad2.Normale(parabsol.Location()),
Quad1.Normale(parabsol.Location()));
if (ptran >0.00000001) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else if (ptran <-0.00000001) {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
else {
trans1=trans2=IntSurf_Undecided;
}
Handle(IntPatch_GLine) glig = new IntPatch_GLine(parabsol,Standard_False,trans1,trans2);
slin.Append(glig);
} }
Handle(IntPatch_GLine) glig = new IntPatch_GLine(parabsol,Standard_False,trans1,trans2);
slin.Append(glig);
} }
break; break;
case IntAna_Hyperbola: case IntAna_Hyperbola: {
{
gp_Pnt tophypr; gp_Pnt tophypr;
gp_Vec Tgttop; gp_Vec Tgttop;
@ -624,13 +630,78 @@ Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
slin.Append(glig); slin.Append(glig);
} }
} }
break; break;
default: default: {
{
return Standard_False; return Standard_False;
} }
} }
return Standard_True; return Standard_True;
} }
//==================================================================================== //
//modified by NIZNHY-PKV Thu Sep 15 10:53:39 2011f
//=======================================================================
//function : AdjustToSeam
//purpose :
//=======================================================================
void AdjustToSeam (const gp_Cone& 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 : AdjustToSeam
//purpose :
//=======================================================================
void AdjustToSeam (const gp_Sphere& aQuad,
gp_Circ& aCirc,
const Standard_Real aTolAng)
{
gp_Ax2 aAx2;
//
const gp_Ax1& aAx1C=aCirc.Axis();
const gp_Ax3& aAx3=aQuad.Position();
const gp_Ax1& aAx1Q=aAx3.Axis();
//
const gp_Dir& aDirC=aAx1C.Direction();
const gp_Dir& aDirQ=aAx1Q.Direction();
if (aDirC.IsParallel(aDirQ, aTolAng)) {
const gp_Pnt& aPLoc=aCirc.Location();
SeamPosition(aPLoc, aAx3, aAx2);
aCirc.SetPosition(aAx2);
}
}
//=======================================================================
//function : AdjustToSeam
//purpose :
//=======================================================================
void AdjustToSeam (const gp_Cylinder& 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_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

18
src/IntTools/IntTools_FaceFace.cdl
View File

@ -102,13 +102,17 @@ is
---Purpose: ---Purpose:
--- Returns True if faces are tangent --- Returns True if faces are tangent
--- ---
--modified by NIZNHY-PKV Fri Sep 16 07:44:22 2011
PrepareLines3D (me:out); PrepareLines3D (me:out;
bToSplit: Boolean from Standard=Standard_True);
--PrepareLines3D (me:out);
---Purpose: ---Purpose:
--- Provides post-processing the result lines, --- Provides post-processing the result lines.
--- which includes spliting closed curves. --- <bToSplit> - the flag.
--- -- In case of <bToSplit> is true the closed 3D-curves will be splitted
--amv -- on parts.
-- In case of <bToSplit> is false the closed 3D-curves remain untouched.
SetList (me: in out; ListOfPnts: in out ListOfPntOn2S from IntSurf); SetList (me: in out; ListOfPnts: in out ListOfPntOn2S from IntSurf);
---------------------------------------------------------- ----------------------------------------------------------
@ -119,10 +123,8 @@ is
D2 : TopolTool from Adaptor3d) D2 : TopolTool from Adaptor3d)
is protected; is protected;
--modified by NIZNHY-PKV Tue Jul 10 10:01:27 2007f
ComputeTolReached3d(me:out) ComputeTolReached3d(me:out)
is protected; is protected;
--modified by NIZNHY-PKV Tue Jul 10 10:01:30 2007t
fields fields

72
src/IntTools/IntTools_FaceFace.cxx
View File

@ -821,7 +821,7 @@ void IntTools_FaceFace::SetList(IntSurf_ListOfPntOn2S& aListOfPnts)
myTolReached3d=1.1*myTolReached3d; myTolReached3d=1.1*myTolReached3d;
} }
}// if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Torus) || }// if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Torus) ||
//modified by NIZNHY-PKV Mon Sep 12 09:32:44 2011f //
if ((aType1==GeomAbs_SurfaceOfRevolution && aType2==GeomAbs_Cylinder) || if ((aType1==GeomAbs_SurfaceOfRevolution && aType2==GeomAbs_Cylinder) ||
(aType2==GeomAbs_SurfaceOfRevolution && aType1==GeomAbs_Cylinder)) { (aType2==GeomAbs_SurfaceOfRevolution && aType1==GeomAbs_Cylinder)) {
Standard_Boolean bIsDone; Standard_Boolean bIsDone;
@ -912,8 +912,7 @@ void IntTools_FaceFace::SetList(IntSurf_ListOfPntOn2S& aListOfPnts)
if (aDSmax > aDS) { if (aDSmax > aDS) {
myTolReached3d=sqrt(aDSmax); myTolReached3d=sqrt(aDSmax);
} }
}// if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Torus) || }//if((aType1==GeomAbs_SurfaceOfRevolution ...
//modified by NIZNHY-PKV Mon Sep 12 09:32:46 2011t
} }
//======================================================================= //=======================================================================
//function : MakeCurve //function : MakeCurve
@ -2216,59 +2215,57 @@ Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine
return new Geom2d_BSplineCurve(poles,knots,mults,1); return new Geom2d_BSplineCurve(poles,knots,mults,1);
} }
//modified by NIZNHY-PKV Fri Sep 16 07:57:30 2011f
//======================================================================= //=======================================================================
//function : PrepareLines3D //function : PrepareLines3D
//purpose : //purpose :
//======================================================================= //=======================================================================
void IntTools_FaceFace::PrepareLines3D() void IntTools_FaceFace::PrepareLines3D(const Standard_Boolean bToSplit)
{ {
Standard_Integer i, aNbCurves, j, aNbNewCurves; Standard_Integer i, aNbCurves;
GeomAbs_SurfaceType aType1, aType2;
IntTools_SequenceOfCurves aNewCvs; IntTools_SequenceOfCurves aNewCvs;
// //
// 1. Treatment of periodic and closed curves // 1. Treatment closed curves
aNbCurves=mySeqOfCurve.Length(); aNbCurves=mySeqOfCurve.Length();
for (i=1; i<=aNbCurves; i++) { for (i=1; i<=aNbCurves; ++i) {
const IntTools_Curve& aIC=mySeqOfCurve(i); const IntTools_Curve& aIC=mySeqOfCurve(i);
// DEBUG
// const Handle(Geom_Curve)& aC3D =aIC.Curve();
// const Handle(Geom2d_Curve)& aC2D1=aIC.FirstCurve2d();
// const Handle(Geom2d_Curve)& aC2D2=aIC.SecondCurve2d();
// //
IntTools_SequenceOfCurves aSeqCvs; if (bToSplit) {
aNbNewCurves=IntTools_Tools::SplitCurve(aIC, aSeqCvs); Standard_Integer j, aNbC;
IntTools_SequenceOfCurves aSeqCvs;
if (aNbNewCurves) { //
for (j=1; j<=aNbNewCurves; j++) { aNbC=IntTools_Tools::SplitCurve(aIC, aSeqCvs);
const IntTools_Curve& aICNew=aSeqCvs(j); if (aNbC) {
aNewCvs.Append(aICNew); for (j=1; j<=aNbC; ++j) {
const IntTools_Curve& aICNew=aSeqCvs(j);
aNewCvs.Append(aICNew);
}
}
else {
aNewCvs.Append(aIC);
} }
} }
//
else { else {
aNewCvs.Append(aIC); aNewCvs.Append(aIC);
} }
} }
// //
// 2. Plane\Cone intersection when we had 4 curves // 2. Plane\Cone intersection when we had 4 curves
GeomAbs_SurfaceType aType1, aType2; aType1=myHS1->GetType();
BRepAdaptor_Surface aBS1, aBS2; aType2=myHS2->GetType();
aNbCurves=aNewCvs.Length();
aBS1.Initialize(myFace1); //
aType1=aBS1.GetType();
aBS2.Initialize(myFace2);
aType2=aBS2.GetType();
if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Cone) || if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Cone) ||
(aType2==GeomAbs_Plane && aType1==GeomAbs_Cone)) { (aType2==GeomAbs_Plane && aType1==GeomAbs_Cone)) {
aNbCurves=aNewCvs.Length();
if (aNbCurves==4) { if (aNbCurves==4) {
GeomAbs_CurveType aCType1=aNewCvs(1).Type(); GeomAbs_CurveType aCType1;
//
aCType1=aNewCvs(1).Type();
if (aCType1==GeomAbs_Line) { if (aCType1==GeomAbs_Line) {
IntTools_SequenceOfCurves aSeqIn, aSeqOut; IntTools_SequenceOfCurves aSeqIn, aSeqOut;
// //
for (i=1; i<=aNbCurves; i++) { for (i=1; i<=aNbCurves; ++i) {
const IntTools_Curve& aIC=aNewCvs(i); const IntTools_Curve& aIC=aNewCvs(i);
aSeqIn.Append(aIC); aSeqIn.Append(aIC);
} }
@ -2277,26 +2274,23 @@ Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine
// //
aNewCvs.Clear(); aNewCvs.Clear();
aNbCurves=aSeqOut.Length(); aNbCurves=aSeqOut.Length();
for (i=1; i<=aNbCurves; i++) { for (i=1; i<=aNbCurves; ++i) {
const IntTools_Curve& aIC=aSeqOut(i); const IntTools_Curve& aIC=aSeqOut(i);
aNewCvs.Append(aIC); aNewCvs.Append(aIC);
} }
//
} }
} }
}// end of if ((aType1==GeomAbs_Plane && ... }// if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Cone)...
// //
// 3. Fill mySeqOfCurve // 3. Fill mySeqOfCurve
mySeqOfCurve.Clear(); mySeqOfCurve.Clear();
aNbCurves=aNewCvs.Length(); aNbCurves=aNewCvs.Length();
for (i=1; i<=aNbCurves; i++) { for (i=1; i<=aNbCurves; ++i) {
const IntTools_Curve& aIC=aNewCvs(i); const IntTools_Curve& aIC=aNewCvs(i);
mySeqOfCurve.Append(aIC); mySeqOfCurve.Append(aIC);
} }
} }
//modified by NIZNHY-PKV Fri Sep 16 07:57:32 2011t
//======================================================================= //=======================================================================
//function : CorrectSurfaceBoundaries //function : CorrectSurfaceBoundaries
//purpose : //purpose :