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

Coding - Combining multiple gxx IntWalk and IntPatch #222

Browse Source 
Refactor IntWalk and IntPatch to remove unused gxx files
  and combine to one with refactoring
This commit is contained in:
dpasukhi 2024-12-28 23:20:35 +00:00
parent fade88f72d
commit abf2e1bacb
19 changed files with 12519 additions and 12106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/BRepFill/BRepFill_OffsetWire.cxx
View File

@ -2675,7 +2675,7 @@ static void QuasiFleche(const Adaptor3d_Curve& C,
Standard_Real theFleche=0;
Standard_Boolean flecheok = Standard_False;
if (Norme > Eps) {
// Evaluation of the arrow by interpolation. See IntWalk_IWalking_5.gxx
// Evaluation of the arrow by interpolation. See IntWalk_IWalking::TestDeflection
Standard_Real N1 = Vdeb.SquareMagnitude();
Standard_Real N2 = Vdelta.SquareMagnitude();
if (N1 > Eps && N2 > Eps) {

2
src/GCPnts/GCPnts_QuasiUniformDeflection.cxx
View File

@ -109,7 +109,7 @@ static void QuasiFleche (const TheCurve& theC,
Standard_Boolean isFlecheOk = Standard_False;
if (aNorme > theEps && aNorme > 16. * theDeflection2)
{
// Evaluation de la fleche par interpolation . Voir IntWalk_IWalking_5.gxx
// Evaluation de la fleche par interpolation . Voir IntWalk_IWalking::TestDeflection
Standard_Real N1 = theVdeb.SquareMagnitude();
Standard_Real N2 = aVdelta.SquareMagnitude();
if (N1 > theEps && N2 > theEps)

7
src/IntPatch/FILES
View File

@ -23,13 +23,6 @@ IntPatch_IType.hxx
IntPatch_ImpImpIntersection.cxx
IntPatch_ImpImpIntersection.hxx
IntPatch_ImpImpIntersection.lxx
IntPatch_ImpImpIntersection_0.gxx
IntPatch_ImpImpIntersection_1.gxx
IntPatch_ImpImpIntersection_2.gxx
IntPatch_ImpImpIntersection_3.gxx
IntPatch_ImpImpIntersection_4.gxx
IntPatch_ImpImpIntersection_5.gxx
IntPatch_ImpImpIntersection_6.gxx
IntPatch_ImpPrmIntersection.cxx
IntPatch_ImpPrmIntersection.hxx
IntPatch_ImpPrmIntersection.lxx

9455
src/IntPatch/IntPatch_ImpImpIntersection.cxx
View File

File diff suppressed because it is too large Load Diff

2075
src/IntPatch/IntPatch_ImpImpIntersection_0.gxx
View File

File diff suppressed because it is too large Load Diff

164
src/IntPatch/IntPatch_ImpImpIntersection_1.gxx
View File

@ -1,164 +0,0 @@
// Created on: 1992-05-07
// Created by: Jacques GOUSSARD
// Copyright (c) 1992-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Bnd_Box2d.hxx>
static Standard_Boolean IntPP (const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
const Standard_Real,
Standard_Boolean&,
IntPatch_SequenceOfLine&);
static Standard_Boolean IntPCy (const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
const Standard_Real,
const Standard_Boolean,
Standard_Boolean&,
IntPatch_SequenceOfLine&,
const Standard_Real H=0.);
static Standard_Boolean IntPSp (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_Boolean,
Standard_Boolean&,
IntPatch_SequenceOfLine&,
IntPatch_SequenceOfPoint&);
static Standard_Boolean IntPCo (const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
const Standard_Real,
const Standard_Boolean,
Standard_Boolean&,
Standard_Boolean&,
IntPatch_SequenceOfLine&,
IntPatch_SequenceOfPoint&);
static void ProcessBounds(const Handle(IntPatch_ALine)&,
const IntPatch_SequenceOfLine&,
const IntSurf_Quadric&,
const IntSurf_Quadric&,
Standard_Boolean&,
const gp_Pnt&,
const Standard_Real,
Standard_Boolean&,
const gp_Pnt&,
const Standard_Real,
Standard_Boolean&,
const Standard_Real);
static
IntPatch_ImpImpIntersection::IntStatus IntCyCy(const IntSurf_Quadric& theQuad1,
const IntSurf_Quadric& theQuad2,
const Standard_Real theTol3D,
const Standard_Real theTol2D,
const Bnd_Box2d& theUVSurf1,
const Bnd_Box2d& theUVSurf2,
Standard_Boolean& isTheEmpty,
Standard_Boolean& isTheSameSurface,
Standard_Boolean& isTheMultiplePoint,
IntPatch_SequenceOfLine& theSlin,
IntPatch_SequenceOfPoint& theSPnt);
static Standard_Boolean IntCySp(const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
const Standard_Boolean,
Standard_Boolean&,
Standard_Boolean&,
IntPatch_SequenceOfLine&,
IntPatch_SequenceOfPoint&);
static Standard_Boolean IntCyCo(const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
const Standard_Boolean,
Standard_Boolean&,
Standard_Boolean&,
IntPatch_SequenceOfLine&,
IntPatch_SequenceOfPoint&);
static Standard_Boolean IntSpSp(const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
Standard_Boolean&,
Standard_Boolean&,
IntPatch_SequenceOfLine&,
IntPatch_SequenceOfPoint&);
static Standard_Boolean IntCoSp(const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
const Standard_Boolean,
Standard_Boolean&,
Standard_Boolean&,
IntPatch_SequenceOfLine&,
IntPatch_SequenceOfPoint&);
static Standard_Boolean IntCoCo(const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,
Standard_Boolean&,
Standard_Boolean&,
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&);

582
src/IntPatch/IntPatch_ImpImpIntersection_2.gxx
View File

@ -1,582 +0,0 @@
// Created on: 1992-05-07
// Created by: Jacques GOUSSARD
// Copyright (c) 1992-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <IntPatch_WLine.hxx>
static
Standard_Integer SetQuad(const Handle(Adaptor3d_Surface)& theS,
GeomAbs_SurfaceType& theTS,
IntSurf_Quadric& theQuad);
//=======================================================================
//function : IntPatch_ImpImpIntersection
//purpose :
//=======================================================================
IntPatch_ImpImpIntersection::IntPatch_ImpImpIntersection ():
myDone(IntStatus_Fail),
empt(Standard_True),
tgte(Standard_False),
oppo(Standard_False)
{
}
//=======================================================================
//function : IntPatch_ImpImpIntersection
//purpose :
//=======================================================================
IntPatch_ImpImpIntersection::IntPatch_ImpImpIntersection
(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang,
const Standard_Boolean theIsReqToKeepRLine)
{
Perform(S1,D1,S2,D2,TolArc,TolTang, theIsReqToKeepRLine);
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang,
const Standard_Boolean theIsReqToKeepRLine)
{
myDone = IntStatus_Fail;
spnt.Clear();
slin.Clear();
Standard_Boolean isPostProcessingRequired = Standard_True;
empt = Standard_True;
tgte = Standard_False;
oppo = Standard_False;
Standard_Boolean all1 = Standard_False;
Standard_Boolean all2 = Standard_False;
Standard_Boolean SameSurf = Standard_False;
Standard_Boolean multpoint = Standard_False;
Standard_Boolean nosolonS1 = Standard_False;
// indique s il y a des points sur restriction du carreau 1
Standard_Boolean nosolonS2 = Standard_False;
// indique s il y a des points sur restriction du carreau 2
Standard_Integer i, nbpt, nbseg;
IntPatch_SequenceOfSegmentOfTheSOnBounds edg1,edg2;
IntPatch_SequenceOfPathPointOfTheSOnBounds pnt1,pnt2;
//
// On commence par intersecter les supports des surfaces
IntSurf_Quadric quad1, quad2;
IntPatch_ArcFunction AFunc;
const Standard_Real Tolang = 1.e-8;
GeomAbs_SurfaceType typs1, typs2;
Standard_Boolean bEmpty = Standard_False;
//
const Standard_Integer iT1 = SetQuad(S1, typs1, quad1);
const Standard_Integer iT2 = SetQuad(S2, typs2, quad2);
//
if (!iT1 || !iT2) {
throw Standard_ConstructionError();
return;
}
//
const Standard_Boolean bReverse = iT1 > iT2;
const Standard_Integer iTT = iT1*10 + iT2;
//
switch (iTT) {
case 11: { // Plane/Plane
if (!IntPP(quad1, quad2, Tolang, TolTang, SameSurf, slin)) {
return;
}
break;
}
//
case 12:
case 21: { // Plane/Cylinder
Standard_Real VMin, VMax, H;
//
const Handle(Adaptor3d_Surface)& aSCyl = bReverse ? S1 : S2;
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;
}
//
case 13:
case 31: { // Plane/Cone
if (!IntPCo(quad1, quad2, Tolang, TolTang, bReverse, empt, multpoint, slin, spnt)) {
return;
}
bEmpty = empt;
break;
}
//
case 14:
case 41: { // Plane/Sphere
if (!IntPSp(quad1, quad2, Tolang, TolTang, bReverse, empt, slin, spnt)) {
return;
}
bEmpty = empt;
break;
}
//
case 15:
case 51: { // Plane/Torus
if (!IntPTo(quad1, quad2, TolTang, bReverse, empt, slin)) {
return;
}
bEmpty = empt;
break;
}
//
case 22:
{ // Cylinder/Cylinder
Bnd_Box2d aBox1, aBox2;
const Standard_Real aU1f = S1->FirstUParameter();
Standard_Real aU1l = S1->LastUParameter();
const Standard_Real aU2f = S2->FirstUParameter();
Standard_Real aU2l = S2->LastUParameter();
const Standard_Real anUperiod = 2.0*M_PI;
if(aU1l - aU1f > anUperiod)
aU1l = aU1f + anUperiod;
if(aU2l - aU2f > anUperiod)
aU2l = aU2f + anUperiod;
aBox1.Add(gp_Pnt2d(aU1f, S1->FirstVParameter()));
aBox1.Add(gp_Pnt2d(aU1l, S1->LastVParameter()));
aBox2.Add(gp_Pnt2d(aU2f, S2->FirstVParameter()));
aBox2.Add(gp_Pnt2d(aU2l, S2->LastVParameter()));
// Resolution is too big if the cylinder radius is
// too small. Therefore, we shall bind its value above.
// Here, we use simple constant.
const Standard_Real a2DTol = Min(1.0e-4, Min( S1->UResolution(TolTang),
S2->UResolution(TolTang)));
myDone = IntCyCy(quad1, quad2, TolTang, a2DTol, aBox1, aBox2,
empt, SameSurf, multpoint, slin, spnt);
if (myDone == IntPatch_ImpImpIntersection::IntStatus_Fail)
{
return;
}
bEmpty = empt;
if(!slin.IsEmpty())
{
const Handle(IntPatch_WLine)& aWLine =
Handle(IntPatch_WLine)::DownCast(slin.Value(1));
if(!aWLine.IsNull())
{//No geometric solution
isPostProcessingRequired = Standard_False;
}
}
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: {
throw Standard_ConstructionError();
break;
}
}
//
if (bEmpty) {
if (myDone == IntStatus_Fail)
myDone = IntStatus_OK;
return;
}
//
if(isPostProcessingRequired)
{
if (!SameSurf) {
AFunc.SetQuadric(quad2);
AFunc.Set(S1);
solrst.Perform(AFunc, D1, TolArc, TolTang);
if (!solrst.IsDone()) {
return;
}
if (solrst.AllArcSolution() && typs1 == typs2) {
all1 = Standard_True;
}
nbpt = solrst.NbPoints();
nbseg= solrst.NbSegments();
for (i = 1; i <= nbpt; i++)
{
const IntPatch_ThePathPointOfTheSOnBounds& aPt = solrst.Point(i);
pnt1.Append(aPt);
}
for (i = 1; i <= nbseg; i++)
{
const IntPatch_TheSegmentOfTheSOnBounds& aSegm = solrst.Segment(i);
edg1.Append(aSegm);
}
nosolonS1 = (nbpt == 0) && (nbseg == 0);
if (nosolonS1 && all1) { // cas de face sans restrictions
all1 = Standard_False;
}
}//if (!SameSurf) {
else {
nosolonS1 = Standard_True;
}
if (!SameSurf) {
AFunc.SetQuadric(quad1);
AFunc.Set(S2);
solrst.Perform(AFunc, D2, TolArc, TolTang);
if (!solrst.IsDone()) {
return;
}
if (solrst.AllArcSolution() && typs1 == typs2) {
all2 = Standard_True;
}
nbpt = solrst.NbPoints();
nbseg= solrst.NbSegments();
for (i=1; i<= nbpt; i++) {
const IntPatch_ThePathPointOfTheSOnBounds& aPt = solrst.Point(i);
pnt2.Append(aPt);
}
for (i=1; i<= nbseg; i++) {
const IntPatch_TheSegmentOfTheSOnBounds& aSegm = solrst.Segment(i);
edg2.Append(aSegm);
}
nosolonS2 = (nbpt == 0) && (nbseg == 0);
if (nosolonS2 && all2) { // cas de face sans restrictions
all2 = Standard_False;
}
}// if (!SameSurf) {
else {
nosolonS2 = Standard_True;
}
//
if (SameSurf || (all1 && all2)) {
// faces "paralleles" parfaites
empt = Standard_False;
tgte = Standard_True;
slin.Clear();
spnt.Clear();
gp_Pnt Ptreference;
switch (typs1) {
case GeomAbs_Plane: {
Ptreference = (S1->Plane()).Location();
}
break;
case GeomAbs_Cylinder: {
Ptreference = ElSLib::Value(0.,0.,S1->Cylinder());
}
break;
case GeomAbs_Sphere: {
Ptreference = ElSLib::Value(M_PI/4.,M_PI/4.,S1->Sphere());
}
break;
case GeomAbs_Cone: {
Ptreference = ElSLib::Value(0.,10.,S1->Cone());
}
break;
case GeomAbs_Torus: {
Ptreference = ElSLib::Value(0.,0.,S1->Torus());
}
break;
default:
break;
}
//
oppo = quad1.Normale(Ptreference).Dot(quad2.Normale(Ptreference)) < 0.0;
myDone = IntStatus_OK;
return;
}// if (SameSurf || (all1 && all2)) {
if (!nosolonS1 || !nosolonS2) {
empt = Standard_False;
// C est la qu il faut commencer a bosser...
PutPointsOnLine(S1,S2,pnt1, slin, Standard_True, D1, quad1,quad2,
multpoint,TolArc);
PutPointsOnLine(S1,S2,pnt2, slin, Standard_False,D2, quad2,quad1,
multpoint,TolArc);
if (edg1.Length() != 0) {
ProcessSegments(edg1,slin,quad1,quad2,Standard_True,TolArc);
}
if (edg2.Length() != 0) {
ProcessSegments(edg2,slin,quad1,quad2,Standard_False,TolArc);
}
if (edg1.Length() !=0 || edg2.Length() !=0) {
// ProcessRLine(slin,S1,S2,TolArc);
ProcessRLine(slin,quad1,quad2,TolArc, theIsReqToKeepRLine);
}
}//if (!nosolonS1 || !nosolonS2) {
else {
empt = ((slin.Length()==0) && (spnt.Length()==0));
}
}
Standard_Integer nblin = slin.Length(),
aNbPnt = spnt.Length();
//
//modified by NIZNHY-PKV Tue Sep 06 10:03:35 2011f
if (aNbPnt) {
IntPatch_SequenceOfPoint aSIP;
//
for(i=1; i<=aNbPnt; ++i) {
Standard_Real aU1, aV1, aU2, aV2;
gp_Pnt2d aP2D;
TopAbs_State aState1, aState2;
//
const IntPatch_Point& aIP=spnt(i);
aIP.Parameters(aU1, aV1, aU2, aV2);
//
aP2D.SetCoord(aU1, aV1);
aState1=D1->Classify(aP2D, TolArc);
//
aP2D.SetCoord(aU2, aV2);
aState2=D2->Classify(aP2D, TolArc);
//
if(aState1!=TopAbs_OUT && aState2!=TopAbs_OUT) {
aSIP.Append(aIP);
}
}
//
spnt.Clear();
//
aNbPnt=aSIP.Length();
for(i=1; i<=aNbPnt; ++i) {
const IntPatch_Point& aIP=aSIP(i);
spnt.Append(aIP);
}
//
}// if (aNbPnt) {
//modified by NIZNHY-PKV Tue Sep 06 10:18:20 2011t
//
for(i=1; i<=nblin; i++) {
IntPatch_IType thetype = slin.Value(i)->ArcType();
if( (thetype == IntPatch_Ellipse)
||(thetype == IntPatch_Circle)
||(thetype == IntPatch_Lin)
||(thetype == IntPatch_Parabola)
||(thetype == IntPatch_Hyperbola)) {
Handle(IntPatch_GLine)& glin = *((Handle(IntPatch_GLine)*)&slin.Value(i));
glin->ComputeVertexParameters(TolArc);
}
else if(thetype == IntPatch_Analytic) {
Handle(IntPatch_ALine)& aligold = *((Handle(IntPatch_ALine)*)&slin.Value(i));
aligold->ComputeVertexParameters(TolArc);
}
else if(thetype == IntPatch_Restriction) {
Handle(IntPatch_RLine)& rlig = *((Handle(IntPatch_RLine)*)&slin.Value(i));
rlig->ComputeVertexParameters(TolArc);
}
}
//
//----------------------------------------------------------------
//-- On place 2 vertex sur les courbes de GLine qui n en
//-- contiennent pas.
for(i=1; i<=nblin; i++) {
gp_Pnt P;
IntPatch_Point point;
Standard_Real u1,v1,u2,v2;
if(slin.Value(i)->ArcType() == IntPatch_Circle) {
const Handle(IntPatch_GLine)& glin = *((Handle(IntPatch_GLine)*)&slin.Value(i));
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);
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);
}
}
else if(slin.Value(i)->ArcType() == IntPatch_Ellipse) {
const Handle(IntPatch_GLine)& glin = *((Handle(IntPatch_GLine)*)&slin.Value(i));
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);
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);
}
}
}
myDone = IntStatus_OK;
}
//=======================================================================
//function : SetQuad
//purpose :
//=======================================================================
Standard_Integer SetQuad(const Handle(Adaptor3d_Surface)& 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;
}

803
src/IntPatch/IntPatch_ImpImpIntersection_3.gxx
View File

@ -1,803 +0,0 @@
// Created on: 1992-05-07
// Created by: Jacques GOUSSARD
// Copyright (c) 1992-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//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);
static
void AdjustToSeam (const gp_Torus& 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,
const IntSurf_Quadric& Quad2,
const Standard_Real Tolang,
const Standard_Real TolTang,
Standard_Boolean& Same,
IntPatch_SequenceOfLine& slin)
{
IntSurf_TypeTrans trans1,trans2;
IntAna_ResultType typint;
gp_Pln pl1(Quad1.Plane());
gp_Pln pl2(Quad2.Plane());
IntAna_QuadQuadGeo inter(pl1,pl2,Tolang,TolTang);
if (!inter.IsDone()) {return Standard_False;}
Same = Standard_False;
typint = inter.TypeInter();
if (typint == IntAna_Same) { // cas faces confondues
Same = Standard_True;
}
else if (typint != IntAna_Empty) { // on a une ligne
gp_Lin linsol = inter.Line(1);
Standard_Real discri = linsol.Direction().DotCross
(Quad2.Normale(linsol.Location()),
Quad1.Normale(linsol.Location()));
if (discri>0.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);
}
return Standard_True;
}
//=======================================================================
//function : IntPCy
//purpose :
// 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 Standard_Real H)
{
gp_Pln Pl;
gp_Cylinder Cy;
IntSurf_TypeTrans trans1,trans2;
IntAna_ResultType typint;
IntAna_QuadQuadGeo inter;
if (!Reversed) {
Pl = Quad1.Plane();
Cy = Quad2.Cylinder();
}
else {
Pl = Quad2.Plane();
Cy = Quad1.Cylinder();
}
inter.Perform(Pl,Cy,Tolang,TolTang,H);
if (!inter.IsDone()) {return Standard_False;}
typint = inter.TypeInter();
Standard_Integer NbSol = inter.NbSolutions();
Empty = Standard_False;
switch (typint) {
case IntAna_Empty : {
Empty = Standard_True;
}
break;
case IntAna_Line: {
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;
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();
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;
//
case IntAna_Circle: {
gp_Circ cirsol;
gp_Pnt ptref;
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);
if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) > 0.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);
}
break;
//
case IntAna_Ellipse: {
gp_Elips elipsol = inter.Ellipse(1);
gp_Pnt ptref;
gp_Vec Tgt;
ElCLib::D1(0.,elipsol,ptref,Tgt);
if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) > 0.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);
}
break;
//
default: {
return Standard_False; // on ne doit pas passer ici
}
}
return Standard_True;
}
//=======================================================================
//function : IntPSp
//purpose :
// 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)
{
gp_Circ cirsol;
gp_Pln Pl;
gp_Sphere Sp;
IntSurf_TypeTrans trans1,trans2;
IntAna_ResultType typint;
IntAna_QuadQuadGeo inter;
if (!Reversed) {
Pl = Quad1.Plane();
Sp = Quad2.Sphere();
}
else {
Pl = Quad2.Plane();
Sp = Quad1.Sphere();
}
inter.Perform(Pl,Sp);
if (!inter.IsDone()) {return Standard_False;}
typint = inter.TypeInter();
Empty = Standard_False;
switch (typint) {
case IntAna_Empty : {
Empty = Standard_True;
}
break;
//
case IntAna_Point: {
gp_Pnt psol = inter.Point(1);
Standard_Real U1,V1,U2,V2;
Quad1.Parameters(psol,U1,V1);
Quad2.Parameters(psol,U2,V2);
IntPatch_Point ptsol;
ptsol.SetValue(psol,TolTang,Standard_True);
ptsol.SetParameters(U1,V1,U2,V2);
spnt.Append(ptsol);
}
break;
//
case IntAna_Circle: {
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_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);
}
break;
default: {
return Standard_False; // on ne doit pas passer ici
}
}
return Standard_True;
}
//=======================================================================
//function : IntPCo
//purpose :
// 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)
{
gp_Pnt apex;
gp_Pln Pl;
gp_Cone Co;
IntSurf_TypeTrans trans1,trans2;
IntAna_ResultType typint;
IntAna_QuadQuadGeo inter;
if (!Reversed) {
Pl = Quad1.Plane();
Co = Quad2.Cone();
apex = Co.Apex();
}
else {
Pl = Quad2.Plane();
Co = Quad1.Cone();
apex = Co.Apex();
}
inter.Perform(Pl,Co,Tolang,TolTang);
if (!inter.IsDone()) {
return Standard_False;
}
//
typint = inter.TypeInter();
Standard_Integer NbSol = inter.NbSolutions();
Empty = Standard_False;
switch (typint) {
case IntAna_Point: {
gp_Pnt psol = inter.Point(1);
Standard_Real U1,V1,U2,V2;
Quad1.Parameters(psol,U1,V1);
Quad2.Parameters(psol,U2,V2);
IntPatch_Point ptsol;
ptsol.SetValue(psol,TolTang,Standard_False);
ptsol.SetParameters(U1,V1,U2,V2);
spnt.Append(ptsol);
}
break;
case IntAna_Line: {
gp_Lin linsol = inter.Line(1);
if (linsol.Direction().Dot(Co.Axis().Direction()) <0.) {
linsol.SetDirection(linsol.Direction().Reversed());
}
Standard_Real para = ElCLib::Parameter(linsol, apex);
gp_Pnt ptbid (ElCLib::Value(para+5.,linsol));
Standard_Real U1,V1,U2,V2;
Quad1.Parameters(apex,U1,V1);
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);
}
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;
}
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;
case IntAna_Circle: {
gp_Circ cirsol = inter.Circle(1);
//modified by NIZNHY-PKV Thu Sep 15 11:34:04 2011f
AdjustToSeam(Co, cirsol);
//modified by NIZNHY-PKV Thu Sep 15 11:36:08 2011t
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;
}
else {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2);
slin.Append(glig);
}
break;
case IntAna_Ellipse: {
gp_Elips elipsol = inter.Ellipse(1);
gp_Pnt ptref;
gp_Vec Tgt;
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);
}
break;
case IntAna_Parabola: {
gp_Parab parabsol = inter.Parabola(1);
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);
}
break;
case IntAna_Hyperbola: {
gp_Pnt tophypr;
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);
}
}
break;
default: {
return Standard_False;
}
}
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
//=======================================================================
//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 : 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_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

4438
src/IntPatch/IntPatch_ImpImpIntersection_4.gxx
View File

File diff suppressed because it is too large Load Diff

832
src/IntPatch/IntPatch_ImpImpIntersection_5.gxx
View File

@ -1,832 +0,0 @@
// Created on: 1992-05-07
// Created by: Jacques GOUSSARD
// Copyright (c) 1992-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <gce_MakeLin.hxx>
//=======================================================================
//function : IntCoCo
//purpose :
//=======================================================================
Standard_Boolean IntCoCo(const IntSurf_Quadric& Quad1,
const IntSurf_Quadric& Quad2,
const Standard_Real Tol,
Standard_Boolean& Empty,
Standard_Boolean& Same,
Standard_Boolean& Multpoint,
IntPatch_SequenceOfLine& slin,
IntPatch_SequenceOfPoint& spnt)
{
Standard_Integer i, NbSol;
Standard_Real U1,V1,U2,V2;
IntSurf_TypeTrans trans1,trans2;
IntAna_ResultType typint;
//
gp_Cone Co1(Quad1.Cone());
gp_Cone Co2(Quad2.Cone());
//
IntAna_QuadQuadGeo inter(Co1,Co2,Tol);
if (!inter.IsDone()) {
return Standard_False;
}
//
typint = inter.TypeInter();
NbSol = inter.NbSolutions();
Empty = Standard_False;
Same = Standard_False;
switch (typint) {
case IntAna_Empty :
{
Empty = Standard_True;
}
break;
case IntAna_Same:
{
Same = Standard_True;
}
break;
//modified by NIZNHY-PKV Wed Nov 30 12:56:06 2005f
case IntAna_Line :{
Standard_Real para, aDot;
gp_Pnt aPApex1, aPApex2, ptbid;
gp_Lin linsol;
gp_Vec NormC1,NormC2;
IntPatch_Point aPtsol;
Handle(IntPatch_GLine) glig;
//
aPApex1=Co1.Apex();
aPApex2=Co2.Apex();
//
if (NbSol==1) {
IntSurf_Situation situC1, situC2;
//
linsol = inter.Line(1);
para =ElCLib::Parameter(linsol, aPApex1);
ptbid=ElCLib::Value(para+5., linsol);
Quad1.Parameters(aPApex1, U1, V1);
Quad2.Parameters(aPApex1, U2, V2);
//
aPtsol.SetValue(aPApex1, Tol, Standard_False);
aPtsol.SetParameters(U1, V1, U2, V2);
aPtsol.SetParameter(para);
//
NormC1=Quad1.Normale(ptbid);
NormC2=Quad2.Normale(ptbid);
aDot=NormC1.Dot(NormC2);
if (aDot<0.) {
situC1=IntSurf_Outside;
situC2=IntSurf_Outside;
}
else {
Standard_Real aR1, aR2;
gp_Lin aLAx1(aPApex1, Co1.Axis().Direction());
gp_Lin aLAx2(aPApex2, Co2.Axis().Direction());
//
aR1=aLAx1.Distance(ptbid);
aR2=aLAx2.Distance(ptbid);
//
situC1=IntSurf_Inside;
situC2=IntSurf_Outside;
if (aR1>aR2) { // Intersection line parametrizes from Apex1 to Apex2,
situC1=IntSurf_Outside; // So the distance between ptbid and aLAx1 is greater than the
situC2=IntSurf_Inside; // distance between ptbid and aLAx2 and in that case Cone2
// is inside Cone 1
}
}
// 1
glig=new IntPatch_GLine(linsol, Standard_True, situC1, situC2);
glig->AddVertex(aPtsol);
glig->SetFirstPoint(1);
slin.Append(glig);
// 2
linsol.SetDirection(linsol.Direction().Reversed());
para =ElCLib::Parameter(linsol, aPApex1);
aPtsol.SetParameter(para);
glig = new IntPatch_GLine(linsol, Standard_True, situC2, situC1);
glig->AddVertex(aPtsol);
glig->SetFirstPoint(1);
slin.Append(glig);
} // if (NbSol==1) {
//////////////////////
else if (NbSol==2) {
//
for (i=1; i<=2; ++i) {
linsol = inter.Line(i);
para =ElCLib::Parameter(linsol, aPApex1);
ptbid=ElCLib::Value(para+5., linsol);
Quad1.Parameters(aPApex1, U1, V1);
Quad2.Parameters(aPApex1, U2, V2);
//
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
if (linsol.Direction().
DotCross(Quad2.Normale(ptbid),Quad1.Normale(ptbid)) >0.) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
//
Multpoint = Standard_True;
// 1,3
aPtsol.SetValue(aPApex1, Tol, Standard_False);
aPtsol.SetParameters(U1,V1,U2,V2);
aPtsol.SetParameter(para);
aPtsol.SetMultiple(Standard_True);
glig = new IntPatch_GLine(linsol, Standard_False, trans1, trans2);
glig->AddVertex(aPtsol);
glig->SetFirstPoint(1);
slin.Append(glig);
// 2,4
linsol.SetDirection(linsol.Direction().Reversed());
para = ElCLib::Parameter(linsol, aPApex1);
aPtsol.SetParameter(para);
glig = new IntPatch_GLine(linsol, Standard_False, trans1, trans2);
glig->AddVertex(aPtsol);
glig->SetFirstPoint(1);
slin.Append(glig);
//
} //for (i=1; i<=2; ++i)
} //else if (NbSol==2)
}
break;
//modified by NIZNHY-PKV Wed Nov 30 12:56:10 2005t
case IntAna_Point : {
gp_Pnt ptcontact;
gp_Pnt apex1(Co1.Apex());
gp_Pnt apex2(Co2.Apex());
Standard_Real param1,param2;
Standard_Real paramapex1 = ElCLib::LineParameter(Co1.Axis(),apex1);
Standard_Real paramapex2 = ElCLib::LineParameter(Co2.Axis(),apex2);
for (i=1; i <= NbSol; i++) {
ptcontact = inter.Point(i);
param1 = ElCLib::LineParameter(Co1.Axis(),ptcontact);
param2 = ElCLib::LineParameter(Co2.Axis(),ptcontact);
Quad1.Parameters(ptcontact,U1,V1);
Quad2.Parameters(ptcontact,U2,V2);
if (apex1.Distance(ptcontact) <= Tol &&
apex2.Distance(ptcontact) <= Tol) {
IntPatch_Point ptsol;
ptsol.SetValue(ptcontact,Tol,Standard_False);
ptsol.SetParameters(U1,V1,U2,V2);
spnt.Append(ptsol);
}
else if (param1 >= paramapex1 && param2 >= paramapex2) {
IntPatch_Point ptsol;
ptsol.SetValue(ptcontact,Tol,Standard_True);
ptsol.SetParameters(U1,V1,U2,V2);
spnt.Append(ptsol);
}
}
}
break;
case IntAna_Circle:
{
IntPatch_Point aPtsol;
gp_Vec Tgt;
gp_Pnt ptref;
for (i = 1; i <= NbSol; i++) {
gp_Circ cirsol = inter.Circle(i);
ElCLib::D1(0.,cirsol,ptref,Tgt);
Standard_Real qwe=Tgt.DotCross(Quad2.Normale(ptref),Quad1.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(cirsol,Standard_False,trans1,trans2);
if(inter.HasCommonGen()) {
const gp_Pnt& aPChar = inter.PChar();
Quad1.Parameters(aPChar, U1, V1);
Quad2.Parameters(aPChar, U2, V2);
aPtsol.SetValue(aPChar, Tol, Standard_False);
aPtsol.SetParameters(U1, V1, U2, V2);
aPtsol.SetParameter(0.);
glig->AddVertex(aPtsol);
}
slin.Append(glig);
}
}
break;
case IntAna_Ellipse:
{
IntPatch_Point aPtsol;
gp_Elips elipsol = inter.Ellipse(1);
gp_Vec Tgt;
gp_Pnt ptref;
ElCLib::D1(0.,elipsol,ptref,Tgt);
Standard_Real qwe=Tgt.DotCross(Quad2.Normale(ptref),Quad1.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(elipsol,Standard_False,trans1,trans2);
if(inter.HasCommonGen()) {
const gp_Pnt& aPChar = inter.PChar();
Quad1.Parameters(aPChar, U1, V1);
Quad2.Parameters(aPChar, U2, V2);
aPtsol.SetValue(aPChar, Tol, Standard_False);
aPtsol.SetParameters(U1, V1, U2, V2);
aPtsol.SetParameter(0.);
glig->AddVertex(aPtsol);
}
slin.Append(glig);
}
break;
case IntAna_Hyperbola:
{
IntPatch_Point aPtsol;
gp_Vec Tgt;
gp_Pnt ptref;
for(i=1; i<=2; i++) {
gp_Hypr hyprsol = inter.Hyperbola(i);
ElCLib::D1(0.,hyprsol,ptref,Tgt);
Standard_Real qwe=Tgt.DotCross(Quad2.Normale(ptref),Quad1.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(hyprsol,Standard_False,trans1,trans2);
if(inter.HasCommonGen()) {
const gp_Pnt& aPChar = inter.PChar();
Quad1.Parameters(aPChar, U1, V1);
Quad2.Parameters(aPChar, U2, V2);
aPtsol.SetValue(aPChar, Tol, Standard_False);
aPtsol.SetParameters(U1, V1, U2, V2);
aPtsol.SetParameter(0.);
glig->AddVertex(aPtsol);
}
slin.Append(glig);
}
}
break;
case IntAna_Parabola:
{
IntPatch_Point aPtsol;
gp_Parab parabsol = inter.Parabola(1);
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);
if(inter.HasCommonGen()) {
const gp_Pnt& aPChar = inter.PChar();
Quad1.Parameters(aPChar, U1, V1);
Quad2.Parameters(aPChar, U2, V2);
aPtsol.SetValue(aPChar, Tol, Standard_False);
aPtsol.SetParameters(U1, V1, U2, V2);
aPtsol.SetParameter(0.);
glig->AddVertex(aPtsol);
}
slin.Append(glig);
}
break;
case IntAna_NoGeometricSolution:
{
gp_Pnt psol;
IntAna_IntQuadQuad anaint(Co1,Co2,Tol);
if (!anaint.IsDone()) {
return Standard_False;
}
if (anaint.NbPnt() == 0 && anaint.NbCurve() == 0) {
Empty = Standard_True;
}
else {
NbSol = anaint.NbPnt();
for (i = 1; i <= NbSol; i++) {
psol = anaint.Point(i);
Quad1.Parameters(psol,U1,V1);
Quad2.Parameters(psol,U2,V2);
IntPatch_Point ptsol;
ptsol.SetValue(psol,Tol,Standard_True);
ptsol.SetParameters(U1,V1,U2,V2);
spnt.Append(ptsol);
}
gp_Pnt ptvalid, ptf, ptl;
gp_Vec tgvalid;
Standard_Real first,last,para;
Standard_Boolean tgfound,firstp,lastp,kept;
Standard_Integer kount;
NbSol = anaint.NbCurve();
for (i = 1; i <= NbSol; i++) {
Handle(IntPatch_ALine) alig;
kept = Standard_False;
IntAna_Curve curvsol = anaint.Curve(i);
curvsol.Domain(first,last);
firstp = !curvsol.IsFirstOpen();
lastp = !curvsol.IsLastOpen();
if (firstp) {
ptf = curvsol.Value(first);
}
if (lastp) {
ptl = curvsol.Value(last);
}
para = last;
kount = 1;
tgfound = Standard_False;
while (!tgfound) {
para = (1.123*first + para)/2.123;
tgfound = curvsol.D1u(para,ptvalid,tgvalid);
if(tgvalid.SquareMagnitude() < 1e-14) {
//-- on se trouve ds un cas ou les normales n'auront pas de sens
tgfound = Standard_False;
}
if (!tgfound) {
kount ++;
tgfound = kount > 5;
}
}
if (kount <= 5) {
Standard_Real qwe= tgvalid.DotCross(Quad2.Normale(ptvalid),
Quad1.Normale(ptvalid));
if(qwe > 0.000000001) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else if(qwe < -0.000000001) {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
else {
trans1=trans2=IntSurf_Undecided;
}
alig = new IntPatch_ALine(curvsol,Standard_False,trans1,trans2);
kept = Standard_True;
}
else {
ptvalid = curvsol.Value(para);
alig = new IntPatch_ALine(curvsol,Standard_False);
kept = Standard_True;
//-- cout << "Transition indeterminee" << endl;
}
if (kept) {
Standard_Boolean Nfirstp = !firstp;
Standard_Boolean Nlastp = !lastp;
ProcessBounds(alig,slin,Quad1,Quad2,Nfirstp,ptf,first,
Nlastp,ptl,last,Multpoint,Tol);
slin.Append(alig);
}
}
}
}
break;
default:
{
return Standard_False;
}
}
//When two cones have common generatrix passing through apexes
//it is necessary to add it is solution
if(inter.HasCommonGen()) {
Standard_Real para;
IntPatch_Point aPtsol;
gp_Pnt aPApex1, aPApex2;
aPApex1=Co1.Apex();
aPApex2=Co2.Apex();
//common generatrix of cones
gce_MakeLin aMkLin(aPApex1, aPApex2);
const gp_Lin& linsol = aMkLin.Value();
Handle(IntPatch_GLine) glig =
new IntPatch_GLine(linsol,Standard_True,IntSurf_Undecided,IntSurf_Undecided);
const gp_Pnt& aPChar = inter.PChar();
Quad1.Parameters(aPChar, U1, V1);
Quad2.Parameters(aPChar, U2, V2);
aPtsol.SetValue(aPChar, Tol, Standard_False);
aPtsol.SetParameters(U1, V1, U2, V2);
para = ElCLib::Parameter(linsol, aPChar);
aPtsol.SetParameter(para);
glig->AddVertex(aPtsol);
slin.Append(glig);
}
return Standard_True;
}
//=======================================================================
//function : IntCoSp
//purpose :
//=======================================================================
Standard_Boolean IntCoSp(const IntSurf_Quadric& Quad1,
const IntSurf_Quadric& Quad2,
const Standard_Real Tol,
const Standard_Boolean Reversed,
Standard_Boolean& Empty,
Standard_Boolean& Multpoint,
IntPatch_SequenceOfLine& slin,
IntPatch_SequenceOfPoint& spnt)
{
Standard_Integer i;
IntSurf_TypeTrans trans1,trans2;
IntAna_ResultType typint;
gp_Sphere Sp;
gp_Cone Co;
Standard_Real U1,V1,U2,V2;
if (!Reversed) {
Co = Quad1.Cone();
Sp = Quad2.Sphere();
}
else {
Co = Quad2.Cone();
Sp = Quad1.Sphere();
}
IntAna_QuadQuadGeo inter(Sp,Co,Tol);
if (!inter.IsDone()) {return Standard_False;}
typint = inter.TypeInter();
Standard_Integer NbSol = inter.NbSolutions();
Empty = Standard_False;
switch (typint) {
case IntAna_Empty :
{
Empty = Standard_True;
}
break;
case IntAna_Point :
{
gp_Pnt ptcontact;
gp_Pnt apex(Co.Apex());
Standard_Real param;
Standard_Real paramapex = ElCLib::LineParameter(Co.Axis(),apex);
for (i=1; i <= NbSol; i++) {
ptcontact = inter.Point(i);
param = ElCLib::LineParameter(Co.Axis(),ptcontact);
Quad1.Parameters(ptcontact,U1,V1);
Quad2.Parameters(ptcontact,U2,V2);
if (apex.Distance(ptcontact) <= Tol) {
IntPatch_Point ptsol;
ptsol.SetValue(ptcontact,Tol,Standard_False);
ptsol.SetParameters(U1,V1,U2,V2);
spnt.Append(ptsol);
}
else if (param >= paramapex) {
IntPatch_Point ptsol;
ptsol.SetValue(ptcontact,Tol,Standard_True);
ptsol.SetParameters(U1,V1,U2,V2);
spnt.Append(ptsol);
}
}
}
break;
case IntAna_Circle:
{
gp_Vec Tgt;
gp_Pnt ptref;
for (i=1; i<=NbSol; i++) {
gp_Circ cirsol = inter.Circle(i);
//-- param = ElCLib::LineParameter(Co.Axis(),
//-- cirsol.Location());
//-- if (param >= paramapex) {
ElCLib::D1(0.,cirsol,ptref,Tgt);
Standard_Real qwe = Tgt.DotCross(Quad2.Normale(ptref),
Quad1.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(cirsol,Standard_False,trans1,trans2);
slin.Append(glig);
//-- }
}
}
break;
case IntAna_PointAndCircle:
{
gp_Vec Tgt;
gp_Pnt ptref;
gp_Pnt apex(Co.Apex());
Standard_Real param;
Standard_Real paramapex = ElCLib::LineParameter(Co.Axis(),apex);
// le point est necessairement l apex
Quad1.Parameters(apex,U1,V1);
Quad2.Parameters(apex,U2,V2);
IntPatch_Point ptsol;
ptsol.SetValue(apex,Tol,Standard_False);
ptsol.SetParameters(U1,V1,U2,V2);
spnt.Append(ptsol);
gp_Circ cirsol = inter.Circle(1);
param = ElCLib::LineParameter(Co.Axis(),
cirsol.Location());
ElCLib::D1(0., cirsol, ptref, Tgt);
Standard_Real qwe = Tgt.DotCross(Quad2.Normale(ptref),
Quad1.Normale(ptref));
if (param >= paramapex)
{
if (qwe > Precision::PConfusion())
{
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else if (qwe < -Precision::PConfusion())
{
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
else
{
trans1 = trans2 = IntSurf_Undecided;
}
}
else
{
if (qwe < -Precision::PConfusion())
{
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else if (qwe > Precision::PConfusion())
{
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
else
{
trans1 = trans2 = IntSurf_Undecided;
}
}
Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol, Standard_False, trans1, trans2);
slin.Append(glig);
}
break;
case IntAna_NoGeometricSolution:
{
gp_Pnt psol;
IntAna_IntQuadQuad anaint(Co,Sp,Tol);
if (!anaint.IsDone()) {
return Standard_False;
}
if (anaint.NbPnt()==0 && anaint.NbCurve()==0) {
Empty = Standard_True;
}
else {
NbSol = anaint.NbPnt();
for (i = 1; i <= NbSol; i++) {
psol = anaint.Point(i);
Quad1.Parameters(psol,U1,V1);
Quad2.Parameters(psol,U2,V2);
IntPatch_Point ptsol;
ptsol.SetValue(psol,Tol,Standard_True);
ptsol.SetParameters(U1,V1,U2,V2);
spnt.Append(ptsol);
}
gp_Pnt ptvalid, ptf, ptl;
gp_Vec tgvalid;
Standard_Real first,last,para;
Standard_Boolean tgfound,firstp,lastp,kept;
Standard_Integer kount;
NbSol = anaint.NbCurve();
for (i = 1; i <= NbSol; i++) {
Handle(IntPatch_ALine) alig;
kept = Standard_False;
IntAna_Curve curvsol = anaint.Curve(i);
curvsol.Domain(first,last);
firstp = !curvsol.IsFirstOpen();
lastp = !curvsol.IsLastOpen();
if (firstp) {
ptf = curvsol.Value(first);
}
if (lastp) {
ptl = curvsol.Value(last);
}
para = last;
kount = 1;
tgfound = Standard_False;
while (!tgfound) {
para = (1.123*first + para)/2.123;
tgfound = curvsol.D1u(para,ptvalid,tgvalid);
if (!tgfound) {
kount ++;
tgfound = kount > 5;
}
}
if (kount <= 5) {
para = ElCLib::LineParameter(Co.Axis(),ptvalid);
Standard_Real qwe = tgvalid.DotCross(Quad2.Normale(ptvalid),
Quad1.Normale(ptvalid));
if(qwe> 0.000000001) {
trans1 = IntSurf_Out;
trans2 = IntSurf_In;
}
else if(qwe<-0.000000001) {
trans1 = IntSurf_In;
trans2 = IntSurf_Out;
}
else {
trans1=trans2=IntSurf_Undecided;
}
alig = new IntPatch_ALine(curvsol,Standard_False,trans1,trans2);
kept = Standard_True;
}
else {
ptvalid = curvsol.Value(para);
para = ElCLib::LineParameter(Co.Axis(),ptvalid);
alig = new IntPatch_ALine(curvsol,Standard_False);
kept = Standard_True;
//-- cout << "Transition indeterminee" << endl;
}
if (kept) {
Standard_Boolean Nfirstp = !firstp;
Standard_Boolean Nlastp = !lastp;
ProcessBounds(alig,slin,Quad1,Quad2,Nfirstp,ptf,first,
Nlastp,ptl,last,Multpoint,Tol);
slin.Append(alig);
}
}
}
}
break;
default:
{
return Standard_False;
}
}
return Standard_True;
}
//=======================================================================
//function : IntSpSp
//purpose :
//=======================================================================
Standard_Boolean IntSpSp(const IntSurf_Quadric& Quad1,
const IntSurf_Quadric& Quad2,
const Standard_Real Tol,
Standard_Boolean& Empty,
Standard_Boolean& Same,
IntPatch_SequenceOfLine& slin,
IntPatch_SequenceOfPoint& spnt)
// Traitement du cas Sphere/Sphere
{
IntSurf_TypeTrans trans1,trans2;
IntAna_ResultType typint;
gp_Sphere sph1(Quad1.Sphere());
gp_Sphere sph2(Quad2.Sphere());
IntAna_QuadQuadGeo inter(sph1,sph2,Tol);
if (!inter.IsDone()) {return Standard_False;}
typint = inter.TypeInter();
Empty = Standard_False;
Same = Standard_False;
switch (typint) {
case IntAna_Empty :
{
Empty = Standard_True;
}
break;
case IntAna_Same:
{
Same = Standard_True;
}
break;
case IntAna_Point:
{
gp_Pnt psol(inter.Point(1));
Standard_Real U1,V1,U2,V2;
Quad1.Parameters(psol,U1,V1);
Quad2.Parameters(psol,U2,V2);
IntPatch_Point ptsol;
ptsol.SetValue(psol,Tol,Standard_True);
ptsol.SetParameters(U1,V1,U2,V2);
spnt.Append(ptsol);
}
break;
case IntAna_Circle:
{
gp_Circ cirsol = inter.Circle(1);
gp_Pnt ptref;
gp_Vec Tgt;
ElCLib::D1(0.,cirsol,ptref,Tgt);
Standard_Real qwe=Tgt.DotCross(Quad2.Normale(ptref),Quad1.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(cirsol,Standard_False,trans1,trans2);
slin.Append(glig);
}
break;
default:
{
return Standard_False; // on ne doit pas passer ici
}
}
return Standard_True;
}

181
src/IntPatch/IntPatch_ImpImpIntersection_6.gxx
View File

@ -1,181 +0,0 @@
// 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 License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
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;
}

6
src/IntWalk/FILES
View File

@ -1,11 +1,5 @@
IntWalk_IWalking.gxx
IntWalk_IWalking.lxx
IntWalk_IWalking_1.gxx
IntWalk_IWalking_2.gxx
IntWalk_IWalking_3.gxx
IntWalk_IWalking_4.gxx
IntWalk_IWalking_5.gxx
IntWalk_IWalking_6.gxx
IntWalk_IWLine.gxx
IntWalk_IWLine.lxx
IntWalk_PWalking.cxx

3096
src/IntWalk/IntWalk_IWalking.gxx
View File

File diff suppressed because it is too large Load Diff

362
src/IntWalk/IntWalk_IWalking_1.gxx
View File

@ -1,362 +0,0 @@
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifdef CHRONO
#include <OSD_Chronometer.hxx>
OSD_Chronometer Chronrsnld;
#endif
#include <NCollection_IncAllocator.hxx>
#include <Precision.hxx>
//==================================================================================
// function : IsTangentExtCheck
// purpose : Additional check if the point (theU, theV) in parametric surface
// is a tangent point.
// If that is TRUE then we can go along any (!) direction in order to
// obtain next intersection point. At present, this case is difficult
// for processing. Therefore, we will return an empty intersection line
// in this case.
//==================================================================================
static Standard_Boolean IsTangentExtCheck(TheIWFunction& theFunc,
const Standard_Real theU,
const Standard_Real theV,
const Standard_Real theStepU,
const Standard_Real theStepV,
const Standard_Real theUinf,
const Standard_Real theUsup,
const Standard_Real theVinf,
const Standard_Real theVsup)
{
const Standard_Real aTol = theFunc.Tolerance();
const Standard_Integer aNbItems = 4;
const Standard_Real aParU[aNbItems] = { Min(theU + theStepU, theUsup),
Max(theU - theStepU, theUinf),
theU, theU};
const Standard_Real aParV[aNbItems] = { theV, theV,
Min(theV + theStepV, theVsup),
Max(theV - theStepV, theVinf)};
math_Vector aX(1, 2), aVal(1, 1);
for(Standard_Integer i = 0; i < aNbItems; i++)
{
aX.Value(1) = aParU[i];
aX.Value(2) = aParV[i];
if(!theFunc.Value(aX, aVal))
continue;
if(Abs(theFunc.Root()) > aTol)
return Standard_False;
}
return Standard_True;
}
IntWalk_IWalking::IntWalk_IWalking (const Standard_Real Epsilon,
const Standard_Real Deflection,
const Standard_Real Increment,
const Standard_Boolean theToFillHoles) :
done(Standard_False),
fleche(Deflection),
pas(Increment),
tolerance(1,2),
epsilon(Epsilon*Epsilon),
reversed(Standard_False),
wd1 (IntWalk_VectorOfWalkingData::allocator_type (new NCollection_IncAllocator)),
wd2 (wd1.get_allocator()),
nbMultiplicities (wd1.get_allocator()),
Um(0.0),
UM(0.0),
Vm(0.0),
VM(0.0),
ToFillHoles(theToFillHoles)
{
}
//=======================================================================
//function : Reset
//purpose : Clears NCollection_Vector-based containers and adds
// dummy data to maintain start index of 1 and consistent with
// previous TCollection_Sequence-based implementation and other
// used TCollection-based containers
//=======================================================================
void IntWalk_IWalking::Clear()
{
wd1.clear();
wd2.clear();
IntWalk_WalkingData aDummy;
aDummy.etat = -10;
aDummy.ustart = aDummy.vstart = 0.;
wd1.push_back (aDummy);
wd2.push_back (aDummy);
nbMultiplicities.clear();
nbMultiplicities.push_back (-1);
done = Standard_False;
seqAjout.Clear();
lines.Clear();
}
// ***************************************************************************
// etat1=12 not tangent, not passes
// etat1=11 tangent, not passes
// etat1=2 not tangent, passes
// etat1=1 tangent, passes
// after a point is processed its state becomes negative.
// ***************************************************************************
// etat2=13 interior start point on closed line
// etat2=12 interior start point on open line
// (line initially closed -> la line s is open)
// after a point is processed (or if it is passed over during
// routing) its state becomes negative.
// ****************************************************************************
//
// Perform with interior points
//
void IntWalk_IWalking::Perform(const ThePOPIterator& Pnts1,
const ThePOLIterator& Pnts2,
TheIWFunction& Func,
const ThePSurface& Caro,
const Standard_Boolean Reversed)
{
Standard_Integer I;
Standard_Boolean Rajout = Standard_False;
Standard_Integer nbPnts1 = Pnts1.Length();
Standard_Integer nbPnts2 = Pnts2.Length();
Standard_Real U,V;
Clear();
reversed = Reversed;
Um = ThePSurfaceTool::FirstUParameter(Caro);
Vm = ThePSurfaceTool::FirstVParameter(Caro);
UM = ThePSurfaceTool::LastUParameter(Caro);
VM = ThePSurfaceTool::LastVParameter(Caro);
if (UM < Um) {
Standard_Real utemp = UM;
UM = Um;
Um = utemp;
}
if (VM < Vm) {
Standard_Real vtemp = VM;
VM = Vm;
Vm = vtemp;
}
const Standard_Real aStepU = pas*(UM-Um), aStepV = pas*(VM-Vm);
// Loading of etat1 and etat2 as well as ustart and vstart.
TColStd_SequenceOfReal Umult;
TColStd_SequenceOfReal Vmult;
Standard_Integer decal=0;
wd1.reserve (nbPnts1+decal);
nbMultiplicities.reserve (nbPnts1+decal);
for (I=1;I <= nbPnts1+decal; I++) {
const ThePointOfPath& PathPnt = Pnts1.Value(I-decal);
IntWalk_WalkingData aWD1;
aWD1.etat = 1;
if (!ThePointOfPathTool::IsPassingPnt(PathPnt))
aWD1.etat = 11;
if (!ThePointOfPathTool::IsTangent(PathPnt))
++aWD1.etat;
if(aWD1.etat==2) {
aWD1.etat=11;
}
ThePointOfPathTool::Value2d(PathPnt, aWD1.ustart, aWD1.vstart);
mySRangeU.Add(aWD1.ustart);
mySRangeV.Add(aWD1.vstart);
wd1.push_back (aWD1);
Standard_Integer aNbMult = ThePointOfPathTool::Multiplicity(PathPnt);
nbMultiplicities.push_back(aNbMult);
for (Standard_Integer J = 1; J <= aNbMult; J++) {
ThePointOfPathTool::Parameters(PathPnt, J, U, V);
Umult.Append(U);
Vmult.Append(V);
}
}
wd2.reserve (nbPnts2);
for (I = 1; I <= nbPnts2; I++) {
IntWalk_WalkingData aWD2;
aWD2.etat = 1;
const IntSurf_InteriorPoint& anIP = Pnts2.Value(I);
ThePointOfLoopTool::Value2d(anIP, aWD2.ustart, aWD2.vstart);
mySRangeU.Add(aWD2.ustart);
mySRangeV.Add(aWD2.vstart);
if (!IsTangentExtCheck(Func, aWD2.ustart, aWD2.vstart, aStepU, aStepV, Um, UM, Vm, VM))
aWD2.etat = 13;
wd2.push_back (aWD2);
}
tolerance(1) = ThePSurfaceTool::UResolution(Caro,Precision::Confusion());
tolerance(2) = ThePSurfaceTool::VResolution(Caro,Precision::Confusion());
Func.Set(Caro);
if (mySRangeU.Delta() > Max(tolerance(1), Precision::PConfusion()))
{
mySRangeU.Enlarge(mySRangeU.Delta());
mySRangeU.Common(Bnd_Range(Um, UM));
}
else
{
mySRangeU = Bnd_Range(Um, UM);
}
if (mySRangeV.Delta() > Max(tolerance(2), Precision::PConfusion()))
{
mySRangeV.Enlarge(mySRangeV.Delta());
mySRangeV.Common(Bnd_Range(Vm, VM));
}
else
{
mySRangeV = Bnd_Range(Vm, VM);
}
// calculation of all open lines
if (nbPnts1 != 0)
ComputeOpenLine(Umult,Vmult,Pnts1,Func,Rajout);
// calculation of all closed lines
if (nbPnts2 != 0)
ComputeCloseLine(Umult,Vmult,Pnts1,Pnts2,Func,Rajout);
if (ToFillHoles)
{
Standard_Integer MaxNbIter = 10, nb_iter = 0;
while (seqAlone.Length() > 1 && nb_iter < MaxNbIter)
{
nb_iter++;
IntSurf_SequenceOfInteriorPoint PntsInHoles;
TColStd_SequenceOfInteger CopySeqAlone = seqAlone;
FillPntsInHoles(Func, CopySeqAlone, PntsInHoles);
wd2.clear();
IntWalk_WalkingData aDummy;
aDummy.etat = -10;
aDummy.ustart = aDummy.vstart = 0.;
wd2.push_back (aDummy);
Standard_Integer nbHoles = PntsInHoles.Length();
wd2.reserve(nbHoles);
for (I = 1; I <= nbHoles; I++)
{
IntWalk_WalkingData aWD2;
aWD2.etat = 13;
const IntSurf_InteriorPoint& anIP = PntsInHoles.Value(I);
ThePointOfLoopTool::Value2d(anIP, aWD2.ustart, aWD2.vstart);
wd2.push_back (aWD2);
}
ComputeCloseLine(Umult,Vmult,Pnts1,PntsInHoles,Func,Rajout);
}
}
for (I = 1; I <= nbPnts1; I++) {
if (wd1[I].etat >0) seqSingle.Append(Pnts1(I));
}
done = Standard_True;
}
//
// Perform without interior point
//
void IntWalk_IWalking::Perform(const ThePOPIterator& Pnts1,
TheIWFunction& Func,
const ThePSurface& Caro,
const Standard_Boolean Reversed)
{
Standard_Integer I;
Standard_Boolean Rajout = Standard_False;
Standard_Integer nbPnts1 = Pnts1.Length();
Standard_Real U,V;
reversed = Reversed;
// Loading of etat1 as well as ustart1 and vstart1.
TColStd_SequenceOfReal Umult;
TColStd_SequenceOfReal Vmult;
wd1.reserve (nbPnts1);
for (I=1;I <= nbPnts1; I++) {
const ThePointOfPath& PathPnt = Pnts1.Value(I);
IntWalk_WalkingData aWD1;
aWD1.etat = 1;
if (!ThePointOfPathTool::IsPassingPnt(PathPnt)) aWD1.etat = 11;
if (!ThePointOfPathTool::IsTangent(PathPnt)) ++aWD1.etat;
ThePointOfPathTool::Value2d(PathPnt, aWD1.ustart, aWD1.vstart);
wd1.push_back (aWD1);
Standard_Integer aNbMult = ThePointOfPathTool::Multiplicity(PathPnt);
nbMultiplicities.push_back(aNbMult);
for (Standard_Integer J = 1; J <= aNbMult; J++) {
ThePointOfPathTool::Parameters(PathPnt, J, U, V);
Umult.Append(U);
Vmult.Append(V);
}
}
tolerance(1) = ThePSurfaceTool::UResolution(Caro,Precision::Confusion());
tolerance(2) = ThePSurfaceTool::VResolution(Caro,Precision::Confusion());
Um = ThePSurfaceTool::FirstUParameter(Caro);
Vm = ThePSurfaceTool::FirstVParameter(Caro);
UM = ThePSurfaceTool::LastUParameter(Caro);
VM = ThePSurfaceTool::LastVParameter(Caro);
if (UM < Um) {
Standard_Real utemp = UM;
UM = Um;
Um = utemp;
}
if (VM < Vm) {
Standard_Real vtemp = VM;
VM = Vm;
Vm = vtemp;
}
Func.Set(Caro);
// calcul de toutes les lignes ouvertes
if (nbPnts1 != 0) ComputeOpenLine(Umult,Vmult,Pnts1,Func,Rajout);
for (I = 1; I <= nbPnts1; I++) {
if (wd1[I].etat >0) seqSingle.Append(Pnts1(I));
}
done = Standard_True;
}

935
src/IntWalk/IntWalk_IWalking_2.gxx
View File

@ -1,935 +0,0 @@
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//-- IntWalk_IWalking_2.gxx
#include <Bnd_Range.hxx>
#include <TColStd_MapOfInteger.hxx>
#ifndef OCCT_DEBUG
#define No_Standard_RangeError
#define No_Standard_OutOfRange
#endif
static void CutVectorByTolerances (gp_Vec2d& theVector,
const math_Vector& theTolerance)
{
if (Abs(theVector.X()) < theTolerance(1))
theVector.SetX (0.);
if (Abs(theVector.Y()) < theTolerance(2))
theVector.SetY (0.);
}
// _______________________________________________
//
// Location of point (u, v) in the natural domain of a surface AND update
// of couple (u, v) for the calculation of the next point.
//
Standard_Boolean IntWalk_IWalking::Cadrage
(math_Vector& BornInf,
math_Vector& BornSup,
math_Vector& UVap,
Standard_Real& Step,
// Standard_Real& StepV,
const Standard_Integer StepSign) const
// there are always :
// BorInf(1) <= UVap(1) <= BornSup(1) et BorInf(2) <= UVap(2) <= BornSup(2)
// 1) check if the process point is out of the natural domain of the surface.
// 2) if yes the approximated point is located on border taking the best direction
// the step and a limit blocating one of the parameters during the recent call of
// FunctionSetRoot are modified;
// 3) couple (u, v) is recomputed by approximation for the calculation of the next point.
// 4) return Standard_True if location, Standard_False if no location.
{
Standard_Real Duvx = previousd2d.X();
Standard_Real Duvy = previousd2d.Y();
if (!reversed) {
previousPoint.ParametersOnS2(UVap(1),UVap(2));
}
else {
previousPoint.ParametersOnS1(UVap(1),UVap(2));
}
Standard_Real U1 = UVap(1) + Step * Duvx * StepSign;
Standard_Real V1 = UVap(2) + Step * Duvy * StepSign;
Standard_Boolean infu = (U1 <= BornInf(1)+Precision::PConfusion());
Standard_Boolean supu = (U1 >= BornSup(1)-Precision::PConfusion());
Standard_Boolean infv = (V1 <= BornInf(2)+Precision::PConfusion());
Standard_Boolean supv = (V1 >= BornSup(2)-Precision::PConfusion());
Standard_Real theStepU,theStepV;
if (!infu && !supu && !infv && !supv) {
UVap(1) = U1;
UVap(2) = V1;
return Standard_False;
}
if ((infu || supu) && (infv || supv)) {
if (infu) { // jag 940616
if(Duvx) {
theStepU = Abs((BornInf(1) - UVap(1)) / Duvx); // iso U =BornInf(1)
}
else {
theStepU = Step;
}
}
else {
if(Duvx) {
theStepU = Abs((BornSup(1) - UVap(1)) / Duvx); // iso U =BornSup(1)
}
else {
theStepU = Step;
}
}
if (infv) { // jag 940616
if(Duvy) {
theStepV = Abs((BornInf(2) - UVap(2)) / Duvy); // iso V =BornInf(2)
}
else {
theStepV = Step;
}
}
else {
if(Duvy) {
theStepV = Abs((BornSup(2) - UVap(2)) / Duvy); // iso V =BornSup(2)
}
else {
theStepV = Step;
}
}
if (theStepU <= theStepV) {
Step = theStepU;
if (infu) {
UVap(1) = BornInf(1);
BornSup(1) = BornInf(1);
}
else {
UVap(1) = BornSup(1);
BornInf(1) = BornSup(1);
}
UVap(2) += Step*Duvy*StepSign;
}
else {
Step = theStepV;
if (infv) {
UVap(2) = BornInf(2);
BornSup(2) = BornInf(2);
}
else {
UVap(2) = BornSup(2);
BornInf(2) = BornSup(2);
}
UVap(1) += Step*Duvx*StepSign;
}
return Standard_True;
}
else if (infu) { // jag 940616
if(Duvx) {
Standard_Real aStep = Abs((BornInf(1) - UVap(1)) / Duvx); // iso U =BornInf(1)
if(aStep<Step) Step=aStep;
}
BornSup(1) = BornInf(1); // limit the parameter
UVap(1) = BornInf(1);
UVap(2) += Step*Duvy*StepSign;
return Standard_True;
}
else if (supu) { // jag 940616
if(Duvx) {
Standard_Real aStep = Abs((BornSup(1) - UVap(1)) / Duvx); // iso U =BornSup(1)
if(aStep<Step) Step=aStep;
}
BornInf(1) = BornSup(1); // limit the parameter
UVap(1) = BornSup(1);
UVap(2) += Step*Duvy*StepSign;
return Standard_True;
}
else if (infv) { // jag 940616
if(Duvy) {
Standard_Real aStep = Abs((BornInf(2) - UVap(2)) / Duvy); // iso V =BornInf(2)
if(aStep<Step) Step=aStep;
}
BornSup(2) = BornInf(2);
UVap(1) += Step*Duvx*StepSign;
UVap(2) = BornInf(2);
return Standard_True;
}
else if (supv) { // jag 940616
if(Duvy) {
Standard_Real aStep = Abs((BornSup(2) - UVap(2)) / Duvy); // iso V =BornSup(2)
if(aStep<Step) Step=aStep;
}
BornInf(2) = BornSup(2);
UVap(1) += Step*Duvx*StepSign;
UVap(2) = BornSup(2);
return Standard_True;
}
return Standard_True;
}
Standard_Boolean IntWalk_IWalking::TestArretPassage
(const TColStd_SequenceOfReal& Umult,
const TColStd_SequenceOfReal& Vmult,
TheIWFunction& sp,
math_Vector& UV,
Standard_Integer& Irang)
// Umult et Vmult : table of stop (or crossing) points on border,
// here only the crossing points are taken into account.
// UV : the current point.
// Irang : at exit : give index of the stop point in uvstart1 or 0.
// consider that there is no risk of crossing only if there is one crossing point.
// test of stop for an OPEN intersection line
// 1) crossing test on all interior points
// 2) stop test on all start points
// if a stop is detected, the index of the stop point (Irang) is returned
// in the iterator of start points and the associated parameters in UV space.
{
Standard_Real Up, Vp, Du, Dv, Dup, Dvp, Utest,Vtest;
Standard_Integer j, N, ind;
Standard_Real tolu = tolerance(1);
Standard_Real tolv = tolerance(2);
Standard_Real tolu2 = 10.*tolerance(1);
Standard_Real tolv2 = 10.*tolerance(2);
Standard_Boolean Arrive = Standard_False;
// crossing test on point that can start a loop; mark
// as processed if passes through an open line
if (!reversed) {
previousPoint.ParametersOnS2(Up,Vp);
}
else {
previousPoint.ParametersOnS1(Up,Vp);
}
for (size_t i = 1; i < wd2.size(); i++) {
if (wd2[i].etat > 0) {
// debug jag 05.04.94
// if ((Up-wd2[i].ustart)*(UV(1)-wd2[i].ustart) +
// (Vp-wd2[i].vstart)*(UV(2)-wd2[i].vstart) <= 0)
Utest = wd2[i].ustart;
Vtest = wd2[i].vstart;
Du = UV(1)-Utest;
Dv = UV(2)-Vtest;
Dup = Up - Utest;
Dvp = Vp - Vtest;
//-- lbr le 30 oct 97
//IFV for OCC20285
if ((Abs(Du) < tolu2 && Abs(Dv) < tolv2) ||
(Abs(Dup) < tolu2 && Abs(Dvp) < tolv2)) {
wd2[i].etat = -wd2[i].etat;
}
else {
Standard_Real DDu = (UV(1)-Up);
Standard_Real DDv = (UV(2)-Vp);
Standard_Real DDD = DDu*DDu+DDv*DDv;
Standard_Real DD1 = Du*Du+Dv*Dv;
if(DD1<=DDD) {
Standard_Real DD2 = Dup*Dup+Dvp*Dvp;
if(DD2<=DDD && ((Du*Dup) + (Dv*Dvp*tolu/tolv) <= 0.)) {
wd2[i].etat = -wd2[i].etat;
}
}
}
}
}
// stop test on point given at input and not yet processed
// Modified by Sergey KHROMOV - Tue Nov 20 10:55:01 2001 Begin
// Check of all path points in the following order:
// * First check all not treated points;
// * After that check of already treated ones.
Standard_Integer l;
//// Modified by jgv, 28.07.2010 for OCC21914 ////
// There are several path points between (Up,Vp) and UV
// So several path points satisfy the condition
// Dup*UV1mUtest + Dvp*UV2mVtest) < 0
// We choose from them the path point with
// minimum distance to (Up,Vp)
TColStd_SequenceOfInteger i_candidates;
TColStd_SequenceOfReal SqDist_candidates;
for (l = 1; l <= 2 && !Arrive; l++) {
Standard_Boolean isToCheck;
for (size_t i = 1; i < wd1.size(); i++) {
if (l == 1)
isToCheck = (wd1[i].etat > 0);
else
isToCheck = (wd1[i].etat < 0);
if (isToCheck) {
// Modified by Sergey KHROMOV - Tue Nov 20 11:03:16 2001 End
// debug jag voir avec isg
Utest = wd1[i].ustart;
Vtest = wd1[i].vstart;
Dup = Up - Utest;
Dvp = Vp - Vtest;
if (Abs(Dup) >= tolu || Abs(Dvp) >= tolv) {
Standard_Real UV1mUtest = UV(1)-Utest;
Standard_Real UV2mVtest = UV(2)-Vtest;
if(( (Dup*UV1mUtest + Dvp*UV2mVtest) < 0) ||
( Abs(UV1mUtest) < tolu
&& Abs(UV2mVtest) < tolv)) {
i_candidates.Append((Standard_Integer)i);
SqDist_candidates.Append(Dup*Dup + Dvp*Dvp);
/*
Irang=i;
Arrive = Standard_True;
UV(1) = Utest;
UV(2) = Vtest;
*/
}
else if (nbMultiplicities[i] > 0 && i_candidates.IsEmpty()) {
N=0;
for (size_t k = 1; k < i; k++) {
N+=nbMultiplicities[k];
}
for (j = N + 1; j <= N + nbMultiplicities[i]; j++) {
if (((Up-Umult(j))*(UV(1)-Umult(j)) +
(Vp-Vmult(j))*(UV(2)-Vmult(j)) < 0) ||
(Abs(UV(1)-Umult(j)) < tolu &&
Abs(UV(2)-Vmult(j)) < tolv)) {
Irang=(Standard_Integer)i;
Arrive = Standard_True;
UV(1) = Utest;
UV(2) = Vtest;
break;
}
}
}
if (Arrive) {
Standard_Real abidF[1], abidD[1][2];
math_Vector bidF(abidF,1,1);
math_Matrix bidD(abidD,1,1,1,2);
sp.Values(UV,bidF,bidD);
break;
}
}
}
} //end of for (i = 1; i < wd1.size(); i++)
if (!i_candidates.IsEmpty())
{
Standard_Real MinSqDist = RealLast();
for (ind = 1; ind <= i_candidates.Length(); ind++)
if (SqDist_candidates(ind) < MinSqDist)
{
MinSqDist = SqDist_candidates(ind);
Irang = i_candidates(ind);
}
Arrive = Standard_True;
UV(1) = wd1[Irang].ustart;
UV(2) = wd1[Irang].vstart;
}
} //end of for (l = 1; l <= 2 && !Arrive; l++)
return Arrive;
}
Standard_Boolean IntWalk_IWalking::TestArretPassage
(const TColStd_SequenceOfReal& Umult,
const TColStd_SequenceOfReal& Vmult,
const math_Vector& UV,
const Standard_Integer Index,
Standard_Integer& Irang)
{
// Umult, Vmult : table of stop (or crossing) points on border, here
// only crossing points are taken into account.
// UV : the current point.
// Index : index of the start point in uvstart2 of the current line
// (this is an interior point).
// Irang : at output : gives the index of the point passing in uvstart1 or 0.
// consider that there is risk to cross only one crossing point.
// test of stop for a CLOSED intersection line.
// 1) test of crossing on all interior points.
// 2) test of crossing on all crossing points.
Standard_Real Up, Vp, Scal;
Standard_Boolean Arrive = Standard_False;
Standard_Integer N, k, i;
Standard_Real Utest,Vtest;
Standard_Real tolu = tolerance(1);
Standard_Real tolv = tolerance(2);
// tests of stop and of crossing on all interior points.
if (!reversed) {
previousPoint.ParametersOnS2(Up,Vp);
}
else {
previousPoint.ParametersOnS1(Up,Vp);
}
Standard_Real UV1=UV(1);
Standard_Real UV2=UV(2);
//Normalizing factor. If it is less than 1.0 then the range will be expanded.
//This is no good for computation. Therefore, it is limited.
//Do not limit this factor in case of highly anisotropic parametrization
//(parametric space is considerably larger in one direction than another).
const Standard_Boolean isHighlyAnisotropic = Max(tolu, tolv) > 1000. * Min(tolu, tolv);
const Standard_Real deltau = mySRangeU.IsVoid() ? UM - Um
: (isHighlyAnisotropic ? mySRangeU.Delta()
: Max(mySRangeU.Delta(), 1.0));
const Standard_Real deltav = mySRangeV.IsVoid() ? VM - Vm
: (isHighlyAnisotropic ? mySRangeV.Delta()
: Max(mySRangeV.Delta(), 1.0));
Up/=deltau; UV1/=deltau;
Vp/=deltav; UV2/=deltav;
tolu/=deltau;
tolv/=deltav;
Standard_Real tolu2=tolu+tolu;
Standard_Real tolv2=tolv+tolv;
Standard_Real dPreviousCurrent = (Up-UV1)*(Up-UV1)+(Vp-UV2)*(Vp-UV2);
for (k = 1; k < (int)wd2.size(); k++) {
if (wd2[k].etat > 0) {
Utest = wd2[k].ustart;
Vtest = wd2[k].vstart;
Utest/=deltau;
Vtest/=deltav;
Standard_Real UV1mUtest=UV1-Utest;
Standard_Real UV2mVtest=UV2-Vtest;
if( (UV1mUtest<tolu2 && UV1mUtest>-tolu2)
&& (UV2mVtest<tolv2 && UV2mVtest>-tolv2)) {
if(Index!=k) {
//-- cout<<"* etat2 : ("<<k<<")"<<endl;
wd2[k].etat=-wd2[k].etat; //-- mark the point as a crossing point
}
else { //-- Index == k
//-- cout<<"* Arrive"<<endl;
Arrive=Standard_True;
}
}
else {
Standard_Real UpmUtest = (Up-Utest);
Standard_Real VpmVtest = (Vp-Vtest);
Standard_Real dPreviousStart = (UpmUtest)*(UpmUtest)+(VpmVtest)*(VpmVtest);
Standard_Real dCurrentStart = UV1mUtest * UV1mUtest + UV2mVtest * UV2mVtest;
Scal=(UpmUtest)*(UV1mUtest)+(VpmVtest)*(UV2mVtest);
if( (Abs(UpmUtest)<tolu && Abs(VpmVtest)<tolv)) {
if(Index != k ) {
//-- cout<<"** etat2 : ("<<k<<")"<<endl;
wd2[k].etat = -wd2[k].etat;
}
}
else if(Scal<0 && (dPreviousStart+dCurrentStart < dPreviousCurrent)) {
if (Index == k ) { // on a boucle.
Arrive = Standard_True;
//-- cout<<"** Arrive : k="<<k<<endl;
}
else {
//-- cout<<"*** etat2 : ("<<k<<")"<<endl;
wd2[k].etat = -wd2[k].etat; // mark the point as a crossing point
}
}
else if(k!=Index) {
if(dPreviousStart < dPreviousCurrent*0.25) {
wd2[k].etat = -wd2[k].etat; // mark the point as a crossing point
//-- cout<<"**** etat2 : ("<<k<<")"<<endl;
}
else {
if(dCurrentStart < dPreviousCurrent*0.25) {
//-- cout<<"***** etat2 : ("<<k<<")"<<endl;
wd2[k].etat = -wd2[k].etat; // mark the point as a crossing point
}
else {
Standard_Real UMidUtest = 0.5*(UV1+Up)-Utest;
Standard_Real VMidVtest = 0.5*(UV2+Vp)-Vtest;
Standard_Real dMiddleStart = UMidUtest* UMidUtest+VMidVtest*VMidVtest;
if(dMiddleStart < dPreviousCurrent*0.5) {
//-- cout<<"*********** etat2 : ("<<k<<")"<<endl;
wd2[k].etat = -wd2[k].etat; // mark the point as a crossing point
}
}
}
}
}
}
}
// crossing test on crossing points.
Irang =0;
for (i = 1; i < (int)wd1.size(); i++) {
if (wd1[i].etat > 0 && wd1[i].etat < 11) { //test of crossing points
Utest = wd1[i].ustart;
Vtest = wd1[i].vstart;
Utest/=deltau;
Vtest/=deltav;
if (((Up-Utest) * (UV1-Utest) + (Vp-Vtest) * (UV2-Vtest) < 0) ||
(Abs(UV1-Utest) < tolu && Abs(UV2-Vtest) < tolv))
Irang = i;
else if (nbMultiplicities[i] > 0) {
N=0;
for (k = 1; k < i; k++) N = N + nbMultiplicities[k];
for (Standard_Integer j = N + 1; j <= N + nbMultiplicities[i]; j++) {
Standard_Real Umultj = Umult(j)/deltau;
Standard_Real Vmultj = Vmult(j)/deltav;
if (((Up-Umultj)*(UV1-Umultj) +
(Vp-Vmultj)*(UV2-Vmultj) < 0) ||
(Abs(UV1-Umultj) < tolu &&
Abs(UV2-Vmultj) < tolv)) {
Irang=i;
break;
}
}
}
}
}
return Arrive;
}
Standard_Boolean IntWalk_IWalking::TestArretAjout
(TheIWFunction& sp,
math_Vector& UV,
Standard_Integer& Irang,
IntSurf_PntOn2S& Psol)
// test of stop on added points
// these are the points on the natural biorder that were not given at input
// return : Psol, the added point.
// Irang, index in the iterator of added points.
// UV, parameter of the added point.
//
{
Standard_Boolean Arrive = Standard_False;
Standard_Real U1,V1;
Standard_Real Up,Vp;
if (!reversed) {
previousPoint.ParametersOnS2(Up,Vp);
}
else {
previousPoint.ParametersOnS1(Up,Vp);
}
Standard_Integer nbAjout = seqAjout.Length();
for (Standard_Integer i = 1; i <= nbAjout; i++) {
Irang = seqAjout.Value(i);
// add test Abs(Irang) <= lines.Length() for the case when
// a closed line is opened by adding a 1 point on this same
// line. Anyway there is a huge problem as 2 points will be
// added on this line...
if (Abs(Irang) <= lines.Length()) {
const Handle(IntWalk_TheIWLine)& Line = lines.Value(Abs(Irang));
if (Irang>0)
Psol = Line->Value(Line->NbPoints());
else
Psol = Line->Value(1);
if (!reversed) {
Psol.ParametersOnS2(U1, V1);
}
else {
Psol.ParametersOnS1(U1, V1);
}
if (((Up-U1) * (UV(1)-U1) +
(Vp-V1) * (UV(2)-V1)) < 0 ||
(Abs(UV(1)-U1) < tolerance(1) &&
Abs(UV(2)-V1) < tolerance(2))) {
//jag 940615 Irang= -Abs(Irang);
Arrive = Standard_True;
UV(1) = U1;
UV(2) = V1;
Standard_Real abidF[1], abidD[1][2];
math_Vector bidF(abidF,1,1);
math_Matrix bidD(abidD,1,1,1,2);
sp.Values(UV,bidF,bidD);
break;
}
}
}
return Arrive;
}
void IntWalk_IWalking::FillPntsInHoles(TheIWFunction& sp,
TColStd_SequenceOfInteger& CopySeqAlone,
IntSurf_SequenceOfInteriorPoint& PntsInHoles)
{
math_Vector BornInf(1,2), BornSup(1,2);
BornInf(1) = Um;
BornSup(1) = UM;
BornInf(2) = Vm;
BornSup(2) = VM;
PointLineLine.Clear();
TColStd_SequenceOfInteger SeqToRemove;
TColStd_MapOfInteger BadSolutions;
for (Standard_Integer i = 1; i < CopySeqAlone.Length(); i++)
{
Standard_Integer Irang1 = CopySeqAlone(i);
if (Irang1 == 0)
continue;
Standard_Boolean ToRemove = Standard_False;
IntSurf_PntOn2S PointAlone1, PointAlone2;
const Handle(IntWalk_TheIWLine)& Line1 = lines.Value(Abs(Irang1));
if (Irang1 > 0)
PointAlone1 = Line1->Value(Line1->NbPoints());
else
PointAlone1 = Line1->Value(1);
gp_Pnt2d P2d1 = PointAlone1.ValueOnSurface(reversed), P2d2;
Standard_Real MinSqDist = RealLast();
Standard_Integer MinRang = 0, MinIndex = 0;
for (Standard_Integer j = i+1; j <= CopySeqAlone.Length(); j++)
{
Standard_Integer Irang2 = CopySeqAlone(j);
if (Irang2 == 0 ||
BadSolutions.Contains(Irang2))
continue;
const Handle(IntWalk_TheIWLine)& Line2 = lines.Value(Abs(Irang2));
if (Irang2 > 0)
PointAlone2 = Line2->Value(Line2->NbPoints());
else
PointAlone2 = Line2->Value(1);
P2d2 = PointAlone2.ValueOnSurface(reversed);
Standard_Real aSqDist = P2d1.SquareDistance(P2d2);
if (aSqDist < MinSqDist)
{
MinSqDist = aSqDist;
MinRang = Irang2;
MinIndex = j;
}
}
//processing points from Irang1 and MinRang
if (MinRang == 0)
{
SeqToRemove.Append(Irang1);
BadSolutions.Clear();
continue;
}
//Ends of same line
if (Abs(Irang1) == Abs(MinRang) &&
lines.Value(Abs(Irang1))->NbPoints() == 2)
{
SeqToRemove.Append(Irang1);
SeqToRemove.Append(MinRang);
CopySeqAlone(i) = 0;
CopySeqAlone(MinIndex) = 0;
BadSolutions.Clear();
continue;
}
///////////////////
const Handle(IntWalk_TheIWLine)& Line2 = lines.Value(Abs(MinRang));
if (MinRang > 0)
PointAlone2 = Line2->Value(Line2->NbPoints());
else
PointAlone2 = Line2->Value(1);
gp_Pnt Pnt1 = PointAlone1.Value();
gp_Pnt Pnt2 = PointAlone2.Value();
P2d2 = PointAlone2.ValueOnSurface(reversed);
Standard_Real MinSqDist3d = Pnt1.SquareDistance(Pnt2);
if (MinSqDist3d <= epsilon ||
(Abs(P2d1.X() - P2d2.X()) <= tolerance(1) &&
Abs(P2d1.Y() - P2d2.Y()) <= tolerance(2))) //close points
ToRemove = Standard_True;
else //real curve
{
math_Vector UVap(1,2), UV(1,2);
UVap(1) = (P2d1.X() + P2d2.X())/2;
UVap(2) = (P2d1.Y() + P2d2.Y())/2;
math_FunctionSetRoot Rsnld(sp, tolerance);
Rsnld.Perform(sp, UVap, BornInf, BornSup);
if (Rsnld.IsDone() &&
Abs(sp.Root()) <= sp.Tolerance() &&
!sp.IsTangent())
{
Rsnld.Root(UV);
gp_Pnt2d Pmid(UV(1),UV(2));
gp_Vec2d P1P2(P2d1, P2d2);
gp_Vec2d P1Pmid(P2d1, Pmid);
gp_Vec2d P2Pmid(P2d2, Pmid);
Standard_Real ScalProd1 = P1P2 * P1Pmid;
Standard_Real ScalProd2 = P1P2 * P2Pmid;
Standard_Boolean IsPmidValid = (ScalProd1 > 0. && ScalProd2 < 0); //Pmid is in the middle
if (IsPmidValid)
{
for (Standard_Integer iline = 1; iline <= lines.Length(); iline++)
if (IsPointOnLine(Pmid,iline))
{
IsPmidValid = Standard_False;
break;
}
}
if (IsPmidValid)
{
IntSurf_InteriorPoint aPoint(sp.Point(), UV(1), UV(2),
sp.Direction3d(),
sp.Direction2d());
PntsInHoles.Append(aPoint);
TColStd_ListOfInteger LineLine;
LineLine.Append(Irang1);
LineLine.Append(MinRang);
PointLineLine.Bind(PntsInHoles.Length(), LineLine);
}
else
{
BadSolutions.Add(MinRang);
i--;
continue;
}
}
else
{
BadSolutions.Add(MinRang);
i--;
continue;
}
}
CopySeqAlone(i) = 0;
CopySeqAlone(MinIndex) = 0;
if (ToRemove)
{
SeqToRemove.Append(Irang1);
SeqToRemove.Append(MinRang);
}
BadSolutions.Clear();
}
for (Standard_Integer i = 1; i <= SeqToRemove.Length(); i++)
for (Standard_Integer j = 1; j <= seqAlone.Length(); j++)
if (seqAlone(j) == SeqToRemove(i))
{
seqAlone.Remove(j);
break;
}
}
void IntWalk_IWalking::TestArretCadre
(const TColStd_SequenceOfReal& Umult,
const TColStd_SequenceOfReal& Vmult,
const Handle(IntWalk_TheIWLine)& Line,
TheIWFunction& sp,
math_Vector& UV,
Standard_Integer& Irang)
// test of stop when located on border.
// tried all tests of stop and arrived.
// test of stop on all given departure points already marked and on the entire current line.
// This line can be shortened if the stop point is found.
// Abs(Irang) = index in the iterator of departure points or 0
// if Irang <0 , it is necessary to add this point on the line (no Line->Cut)
// UV = parameter of the departure point
{
Standard_Real Scal, Up, Vp, Uc, Vc;
Standard_Integer N;
Standard_Boolean Found = Standard_False;
Irang =0;
for (Standard_Integer i = 1; i < (int)wd1.size(); i++) {
if (wd1[i].etat < 0) {
N=0; // range in UVMult.
if (nbMultiplicities[i] > 0) {
for (Standard_Integer k = 1; k < i; k++)
N+=nbMultiplicities[k];
}
if (!reversed) {
Line->Value(1).ParametersOnS2(Up,Vp);
}
else {
Line->Value(1).ParametersOnS1(Up,Vp);
}
Standard_Integer nbp= Line->NbPoints();
for (Standard_Integer j = 2; j <= nbp; j++) {
if (!reversed) {
Line->Value(j).ParametersOnS2(Uc,Vc);
}
else {
Line->Value(j).ParametersOnS1(Uc,Vc);
}
gp_Vec2d aVec1 (Up-wd1[i].ustart, Vp-wd1[i].vstart),
aVec2 (Uc-wd1[i].ustart, Vc-wd1[i].vstart);
CutVectorByTolerances (aVec1, tolerance);
CutVectorByTolerances (aVec2, tolerance);
Scal = aVec1 * aVec2;
// if a stop point is found: stop the line on this point.
if (Scal < 0) {
Line->Cut(j); nbp= Line->NbPoints();
Irang = i;
UV(1) = wd1[Irang].ustart;
UV(2) = wd1[Irang].vstart;
Found = Standard_True;
}
else if (Abs(Uc-wd1[i].ustart) < tolerance(1) &&
Abs(Vc-wd1[i].vstart) < tolerance(2) ) {
Line->Cut(j); nbp= Line->NbPoints();
Irang=i;
UV(1) = wd1[Irang].ustart;
UV(2) = wd1[Irang].vstart;
Found = Standard_True;
}
else if (nbMultiplicities[i] > 0) {
for (Standard_Integer k = N+1; k <= N + nbMultiplicities[i]; k++) {
aVec1.SetCoord (Up-Umult(k), Vp-Vmult(k)),
aVec2.SetCoord (Uc-Umult(k), Vc-Vmult(k));
CutVectorByTolerances (aVec1, tolerance);
CutVectorByTolerances (aVec2, tolerance);
Scal = aVec1 * aVec2;
if (Scal < 0) {
Line->Cut(j); nbp= Line->NbPoints();
Irang=i;
UV(1) = wd1[Irang].ustart;
UV(2) = wd1[Irang].vstart;
Found = Standard_True;
break;
}
else if (Abs(Uc-Umult(k)) < tolerance(1) &&
Abs(Vc-Vmult(k)) < tolerance(2)) {
Line->Cut(j); nbp= Line->NbPoints();
Irang=i;
UV(1) = wd1[Irang].ustart;
UV(2) = wd1[Irang].vstart;
Found = Standard_True;
break;
}
}
}
if (Found) {
Standard_Real abidF[1], abidD[1][2];
math_Vector bidF(abidF,1,1);
math_Matrix bidD(abidD,1,1,1,2);
sp.Values(UV,bidF,bidD);
Standard_Integer NBP = Line->NbPoints();
Standard_Integer Indextg;
Line->TangentVector(Indextg);
if(Indextg > NBP) {
if(j>3 && j<=NBP+1) {
gp_Vec Dir3d = sp.Direction3d();
gp_Vec Dir3d1 = gp_Vec(Line->Value(j-2).Value(),Line->Value(j-1).Value());
Standard_Real dot = Dir3d.Dot(Dir3d1);
if(dot<0.0) { // Normally this Function should not be used often !!!
Dir3d.Reverse();
//-- cout<<" IntWalk_IWalking_2.gxx REVERSE "<<endl;
}
Line->SetTangentVector(previousd3d,j-1);
}
#ifdef OCCT_DEBUG
else {
std::cout<<" IntWalk_IWalking_2.gxx : bizarrerie 30 10 97 "<<std::endl;
}
#endif
}
return;
}
Up = Uc;
Vp = Vc;
}
// now the last point of the line and the last calculated point are compated.
// there will be no need to "Cut"
gp_Vec2d aVec1 (Up-wd1[i].ustart, Vp-wd1[i].vstart),
aVec2 (UV(1)-wd1[i].ustart, UV(2)-wd1[i].vstart);
CutVectorByTolerances (aVec1, tolerance);
CutVectorByTolerances (aVec2, tolerance);
Scal = aVec1 * aVec2;
if (Scal < 0) {
Irang = i;
UV(1) = wd1[Irang].ustart;
UV(2) = wd1[Irang].vstart;
Found = Standard_True;
}
else if (Abs(UV(1)-wd1[i].ustart) < tolerance(1) &&
Abs(UV(2)-wd1[i].vstart) < tolerance(2)) {
Irang=i;
UV(1) = wd1[Irang].ustart;
UV(2) = wd1[Irang].vstart;
Found = Standard_True;
}
else if (nbMultiplicities[i] > 0) {
for (Standard_Integer j = N+1; j <= N+nbMultiplicities[i]; j++) {
aVec1.SetCoord (Up-Umult(j), Vp-Vmult(j));
aVec2.SetCoord (UV(1)-Umult(j), UV(2)-Vmult(j));
CutVectorByTolerances (aVec1, tolerance);
CutVectorByTolerances (aVec2, tolerance);
Scal = aVec1 * aVec2;
if (Scal < 0) {
Irang=i;
UV(1) = wd1[Irang].ustart;
UV(2) = wd1[Irang].vstart;
Found = Standard_True;
break;
}
else if (Abs(UV(1)-Umult(j)) < tolerance(1) &&
Abs(UV(2)-Vmult(j)) < tolerance(2)) {
Irang=i;
UV(1) = wd1[Irang].ustart;
UV(2) = wd1[Irang].vstart;
Found = Standard_True;
break;
}
}
}
if (Found) {
Irang = -Irang; // jag 941017
Standard_Real abidF[1], abidD[1][2];
math_Vector bidF(abidF,1,1);
math_Matrix bidD(abidD,1,1,1,2);
sp.Values(UV,bidF,bidD);
return;
}
}
}
}

531
src/IntWalk/IntWalk_IWalking_3.gxx
View File

@ -1,531 +0,0 @@
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <NCollection_IncAllocator.hxx>
#include <NCollection_LocalArray.hxx>
// modified by NIZHNY-MKK Thu Nov 2 15:07:26 2000.BEGIN
static Standard_Boolean TestPassedSolutionWithNegativeState(const IntWalk_VectorOfWalkingData& wd,
const TColStd_SequenceOfReal& Umult,
const TColStd_SequenceOfReal& Vmult,
const Standard_Real& prevUp,
const Standard_Real& prevVp,
const IntWalk_VectorOfInteger& nbMultiplicities,
const math_Vector& tolerance,
TheIWFunction& sp,
math_Vector& UV,
Standard_Integer& Irang);
// modified by NIZHNY-MKK Thu Nov 2 15:07:39 2000.END
void IntWalk_IWalking::ComputeOpenLine(const TColStd_SequenceOfReal& Umult,
const TColStd_SequenceOfReal& Vmult,
const ThePOPIterator& Pnts1,
TheIWFunction& Func,
Standard_Boolean& Rajout)
// Processing of open line.
//
// 1) for any starting point, which is not passing and not tangent and not yet processed,
// calculation of the step of advancement = step depending on the arrow and the maximum step.
//
// 2) calculate a point of approach (this point is on the tangent to the section
// of distance = no point in the interior)
//
// 3) conditions {
// (all calculated points do not exceed a point in the
// list of starting points)
// or
// (all points do not form an open line going
// from one border of the domain to the other or from a point tangent
// to border or from 2 tangent points : single cases)
//
// 1) framing of approached point on borders if necessary (there is
// calculation of step)
// 2) calculation of the point
// 3) if the point is not found the step is divided
// 4) stop tests
// 5) calculation of the step depending on the arrow and the max step,
// (TestDeflection)
// stop possible.
// end of conditions.
{
Standard_Integer I = 0, N = 0, SaveN = 0;
Standard_Real aBornInf[2] = {}, aBornSup[2] = {}, aUVap[2] = {};
math_Vector BornInf(aBornInf,1,2), BornSup(aBornSup,1,2), UVap(aUVap,1,2);
Standard_Real PasC = 0.0, PasCu = 0.0, PasCv = 0.0;
Standard_Boolean Arrive = false; // shows if the line ends
Standard_Boolean Cadre = false; // shows if one is on border of the domain
Standard_Boolean ArretAjout = false; //shows if one is on added point
IntSurf_PntOn2S Psol;
Handle(IntWalk_TheIWLine) CurrentLine; // line under construction
Standard_Boolean Tgtend = false;
IntWalk_StatusDeflection aStatus = IntWalk_OK, StatusPrecedent = IntWalk_OK;
Standard_Integer NbDivision = 0;
// number of divisions of step for each section
Standard_Integer StepSign = 0;
ThePointOfPath PathPnt;
BornInf(1) = Um;
BornSup(1) = UM;
BornInf(2) = Vm;
BornSup(2) = VM;
math_FunctionSetRoot Rsnld(Func, tolerance);
Standard_Integer nbPath = Pnts1.Length();
// modified by NIZHNY-MKK Fri Oct 27 12:32:34 2000.BEGIN
NCollection_LocalArray<Standard_Integer> movementdirectioninfoarr (nbPath + 1);
Standard_Integer* movementdirectioninfo = movementdirectioninfoarr;
for (I = 0; I <= nbPath; I++) {
movementdirectioninfo[I] = 0;
}
// modified by NIZHNY-MKK Fri Oct 27 12:32:38 2000.END
TheIWFunction aFuncForDuplicate = Func;
for (I = 1; I <= nbPath; I++) {
//start point of the progression
// if (wd1[I].etat > 11) {
// modified by NIZHNY-MKK Fri Oct 27 12:33:37 2000.BEGIN
if ((wd1[I].etat > 11) || ((wd1[I].etat < -11) && (movementdirectioninfo[I]!=0))) {
// modified by NIZHNY-MKK Fri Oct 27 12:33:43 2000.END
PathPnt = Pnts1.Value(I);
UVap(1) = wd1[I].ustart;
UVap(2) = wd1[I].vstart;
MakeWalkingPoint(11, UVap(1), UVap(2), Func, previousPoint);
if (IsPointOnLine(previousPoint, BornInf, BornSup, Rsnld, aFuncForDuplicate))
{
wd1[I].etat = -Abs(wd1[I].etat); //mark point as processed
continue;
}
CurrentLine = new IntWalk_TheIWLine (new NCollection_IncAllocator());
CurrentLine->SetTangencyAtBegining(Standard_False);
Tgtend = Standard_False;
CurrentLine->AddStatusFirst(Standard_False, Standard_True, I, PathPnt);
previousd3d = Func.Direction3d();
previousd2d = Func.Direction2d();
CurrentLine->AddPoint(previousPoint);
// modified by NIZHNY-MKK Fri Oct 27 12:34:32 2000.BEGIN
if(movementdirectioninfo[I] !=0) {
if(movementdirectioninfo[I] < 0) {
StepSign = -1;
CurrentLine->SetTangentVector(previousd3d.Reversed(),1);
} else {
StepSign = 1;
CurrentLine->SetTangentVector(previousd3d,1);
}
} else {
Standard_Real tyutuyt=ThePointOfPathTool::Direction3d(PathPnt) * previousd3d;
if( tyutuyt < 0) {
StepSign = -1;
CurrentLine->SetTangentVector(previousd3d.Reversed(),1);
}
else {
StepSign = 1;
CurrentLine->SetTangentVector(previousd3d,1);
}
}
// modified by NIZHNY-MKK Fri Oct 27 12:34:37 2000.END
// Modified by Sergey KHROMOV - Tue Nov 20 10:41:45 2001 Begin
wd1[I].etat = -Abs(wd1[I].etat);
movementdirectioninfo[I] = (movementdirectioninfo[I]==0) ? StepSign : 0;
// Modified by Sergey KHROMOV - Tue Nov 20 10:41:56 2001 End
// first step of advancement
Standard_Real d2dx = Abs(previousd2d.X());
Standard_Real d2dy = Abs(previousd2d.Y());
if (d2dx < tolerance(1)) {
PasC = pas * (VM-Vm)/d2dy;
}
else if (d2dy < tolerance(2)) {
PasC = pas * (UM-Um)/d2dx;
}
else {
PasC = pas * Min((UM-Um)/d2dx,(VM-Vm)/d2dy);
}
Arrive = Standard_False;
ArretAjout = Standard_False;
NbDivision = 0;
StatusPrecedent = IntWalk_OK;
// modified by NIZHNY-MKK Fri Oct 27 12:39:37 2000
Standard_Integer IndexOfPathPointDoNotCheck=0;
Standard_Integer aNbIter = 10;
while (!Arrive) { // as one of stop tests is not checked
Cadre = Cadrage(BornInf,BornSup,UVap,PasC,StepSign);
// Border?
#ifdef CHRONO
Chronrsnld.Start();
#endif
Rsnld.Perform(Func,UVap,BornInf,BornSup);
#ifdef CHRONO
Chronrsnld.Stop();
#endif
if (Cadre) {
BornInf(1) = Um; BornSup(1) = UM; BornInf(2) = Vm; BornSup(2) = VM;
}
if (Rsnld.IsDone()) {
if (Abs(Func.Root()) > Func.Tolerance()) {
PasC = PasC / 2.0;
PasCu = Abs(PasC*previousd2d.X());
PasCv = Abs(PasC*previousd2d.Y());
if (PasCu <= tolerance(1) && PasCv <= tolerance(2)) {
if (CurrentLine->NbPoints() == 1) break;
Arrive = Standard_True;
CurrentLine->AddStatusLast(Standard_False);
Tgtend = Standard_True; // check
Rajout = Standard_True;
seqAlone.Append(lines.Length() + 1);
seqAjout.Append(lines.Length() + 1);
}
}
else { // test stop
Rsnld.Root(UVap);
Arrive = TestArretPassage(Umult, Vmult, Func, UVap, N);
if (Arrive) {
Cadre = Standard_False;
//in case if there is a frame and arrive at the same time
}
else {
if (Rajout) {
ArretAjout =TestArretAjout(Func, UVap, N, Psol);
SaveN = N;
if (ArretAjout) {
// jag 940615
Tgtend = lines.Value(N)->IsTangentAtEnd();
N = -N;
}
}
// modified by NIZHNY-MKK Thu Nov 2 15:09:08 2000.BEGIN
if(!(Rajout && ArretAjout)) {
Standard_Real prevUp, prevVp;
if (!reversed) {
previousPoint.ParametersOnS2(prevUp, prevVp);
}
else {
previousPoint.ParametersOnS1(prevUp, prevVp);
}
Arrive = TestPassedSolutionWithNegativeState(wd1, Umult, Vmult, prevUp, prevVp,
nbMultiplicities, tolerance, Func, UVap, N);
if(Arrive) {
Cadre = Standard_False;
}
}
// modified by NIZHNY-MKK Thu Nov 2 15:09:13 2000.END
if (!ArretAjout && Cadre) {
if (CurrentLine->NbPoints() == 1) break; // cancel the line
TestArretCadre(Umult, Vmult, CurrentLine, Func, UVap, N);
// if (N == 0) {
if (N <= 0) { // jag 941017
MakeWalkingPoint(2, UVap(1), UVap(2), Func, Psol);
Tgtend = Func.IsTangent();
N = -N;
}
}
}
aStatus = TestDeflection(Func, Arrive, UVap, StatusPrecedent,
NbDivision,PasC,StepSign);
StatusPrecedent = aStatus;
if (aStatus == IntWalk_PasTropGrand) {
Arrive = Standard_False;
ArretAjout = Standard_False;
Tgtend = Standard_False; // jag 940615
if (!reversed) {
previousPoint.ParametersOnS2(UVap(1), UVap(2));
}
else {
previousPoint.ParametersOnS1(UVap(1), UVap(2));
}
}
else if (ArretAjout || Cadre) {
Arrive = Standard_True;
CurrentLine->AddStatusLast(Standard_False);
//if (aStatus != IntWalk_ArretSurPointPrecedent)
CurrentLine->AddPoint(Psol);
//Remove <SaveN> from <seqAlone>
for (Standard_Integer iseq = 1; iseq <= seqAlone.Length(); iseq++)
if (seqAlone(iseq) == SaveN)
{
seqAlone.Remove(iseq);
break;
}
if (Cadre && N==0) {
Rajout = Standard_True;
seqAjout.Append(lines.Length()+1);
}
}
else if (aStatus == IntWalk_ArretSurPointPrecedent) {
if (CurrentLine->NbPoints() == 1) { //cancel the line
Arrive = Standard_False;
break;
}
Arrive = Standard_True;
Rajout = Standard_True;
//AddAlonePoint();
seqAlone.Append(lines.Length() + 1);
seqAjout.Append(lines.Length() + 1);
CurrentLine->AddStatusLast(Standard_False);
Tgtend = Standard_True; // check
}
else if (Arrive) {
if (CurrentLine->NbPoints() == 1 && // cancel the line
(N == I || aStatus == IntWalk_PointConfondu) ) {
// if N == I the main uv is probably lost
// or the point is a point of accumulation
// if point is confused the start data is bad
Arrive = Standard_False;
break;
}
// necessarily N > 0 jag 940617
// point of stop given at input
PathPnt = Pnts1.Value(N);
Standard_Integer etat1N=wd1[N].etat;
// modified by NIZHNY-MKK Thu Nov 2 15:09:51 2000.BEGIN
// if (etat1N < 11) { // passing point that is a stop
if (Abs(etat1N) < 11) { // passing point that is a stop
// modified by NIZHNY-MKK Thu Nov 2 15:12:11 2000.END
if (aStatus == IntWalk_ArretSurPoint) {
CurrentLine->AddStatusLast(Standard_False);
Tgtend = Standard_True; // need check
}
else {
Arrive = Standard_False;
}
CurrentLine->AddIndexPassing(N);
}
else { // point of stop given at input
if (etat1N == 11) {
Tgtend = Standard_True;
}
CurrentLine->AddStatusLast(Standard_True, N, PathPnt);
}
AddPointInCurrentLine(N,PathPnt,CurrentLine);
if ((etat1N != 1 && etat1N != 11)) {
// modified by NIZHNY-MKK Fri Oct 27 12:43:05 2000.BEGIN
// wd1[N].etat= - wd1[N].etat;
wd1[N].etat = - Abs(etat1N);
movementdirectioninfo[N] = (movementdirectioninfo[N]==0) ? StepSign : 0;
if(Arrive && movementdirectioninfo[N]!=0) {
IndexOfPathPointDoNotCheck = N;
}
if(Arrive) {
Rajout = Standard_True;
seqAjout.Append(lines.Length() + 1);
}
// modified by NIZHNY-MKK Fri Oct 27 12:45:33 2000.END
}
}
else if (aStatus == IntWalk_ArretSurPoint) {
Arrive = Standard_True;
CurrentLine->AddStatusLast(Standard_False);
Tgtend = Standard_True;
MakeWalkingPoint(1, UVap(1), UVap(2), Func, Psol);
CurrentLine->AddPoint(Psol);
Rajout = Standard_True;
seqAlone.Append(lines.Length() + 1);
seqAjout.Append(lines.Length() + 1);
}
else if (aStatus == IntWalk_OK) {
MakeWalkingPoint(2, UVap(1), UVap(2), Func, previousPoint);
previousd3d = Func.Direction3d();
previousd2d = Func.Direction2d();
CurrentLine->AddPoint(previousPoint);
}
else if (aStatus == IntWalk_PointConfondu)
{
aNbIter --;
}
}
}
else { // no numerical solution
PasC = PasC / 2.;
PasCu = Abs(PasC*previousd2d.X());
PasCv = Abs(PasC*previousd2d.Y());
if (PasCu <= tolerance(1) && PasCv <= tolerance(2)) {
if (CurrentLine->NbPoints()==1) break;
Arrive = Standard_True;
CurrentLine->AddStatusLast(Standard_False);
Tgtend = Standard_True; // need check
Rajout = Standard_True;
seqAlone.Append(lines.Length() + 1);
seqAjout.Append(lines.Length() + 1);
}
}
if(aNbIter < 0)
break;
} // end of started line
if (Arrive) {
CurrentLine->SetTangencyAtEnd(Tgtend);
lines.Append(CurrentLine);
// modified by NIZHNY-MKK Fri Oct 27 12:59:29 2000.BEGIN
movementdirectioninfo[I]=0;
if(wd1[I].etat > 0)
// modified by NIZHNY-MKK Fri Oct 27 12:59:42 2000.END
wd1[I].etat=-wd1[I].etat;
//-- lbr le 5 juin 97 (Pb ds Contap)
for(Standard_Integer av=1; av<=nbPath; av++) {
// modified by NIZHNY-MKK Fri Oct 27 13:00:22 2000.BEGIN
// if (wd1[av].etat > 11) {
if ((wd1[av].etat > 11) ||
((av!=I) &&
(av!=IndexOfPathPointDoNotCheck) &&
(wd1[av].etat < -11) &&
(movementdirectioninfo[av]!=0)))
{
// modified by NIZHNY-MKK Fri Oct 27 13:00:26 2000.END
Standard_Real Uav=wd1[av].ustart;
Standard_Real Vav=wd1[av].vstart;
Standard_Real Uavp,Vavp;
const IntSurf_PntOn2S &avP=CurrentLine->Value(CurrentLine->NbPoints());
if (!reversed) {
avP.ParametersOnS2(Uavp,Vavp);
}
else {
avP.ParametersOnS1(Uavp,Vavp);
}
Uav-=Uavp;
Vav-=Vavp;
Uav*=0.001; Vav*=0.001;
if(Abs(Uav)<tolerance(1) && Abs(Vav)<tolerance(2)) {
// modified by NIZHNY-MKK Fri Oct 27 13:01:38 2000.BEGIN
// wd1[av].etat=-wd1[av].etat;
if(wd1[av].etat < 0) {
movementdirectioninfo[av] = 0;
} else {
wd1[av].etat=-wd1[av].etat;
movementdirectioninfo[av] = StepSign;
}
// modified by NIZHNY-MKK Fri Oct 27 13:01:42 2000.END
CurrentLine->AddStatusLast(Standard_True, av, Pnts1.Value(av));
//-- cout<<"\n Debug ? lbr ds IntWalk_IWalking_3.gxx"<<endl;
}
const IntSurf_PntOn2S &avPP=CurrentLine->Value(1);
if (!reversed) {
avPP.ParametersOnS2(Uavp,Vavp);
}
else {
avPP.ParametersOnS1(Uavp,Vavp);
}
Uav=wd1[av].ustart;
Vav=wd1[av].vstart;
Uav-=Uavp;
Vav-=Vavp;
Uav*=0.001; Vav*=0.001;
if(Abs(Uav)<tolerance(1) && Abs(Vav)<tolerance(2)) {
// modified by NIZHNY-MKK Fri Oct 27 13:02:49 2000.BEGIN
// wd1[av].etat=-wd1[av].etat;
if(wd1[av].etat < 0) {
movementdirectioninfo[av] = 0;
} else {
wd1[av].etat=-wd1[av].etat;
movementdirectioninfo[av] = -StepSign;
}
// modified by NIZHNY-MKK Fri Oct 27 13:02:52 2000.END
//-- cout<<"\n Debug ? lbr ds IntWalk_IWalking_3.gxx"<<endl;
CurrentLine->AddStatusFirst(Standard_False, Standard_True, av, Pnts1.Value(av));
}
}
}
}
} //end of point processing
} //end of all points
}
// modified by NIZHNY-MKK Thu Nov 2 15:07:53 2000.BEGIN
static Standard_Boolean TestPassedSolutionWithNegativeState(const IntWalk_VectorOfWalkingData& wd,
const TColStd_SequenceOfReal& Umult,
const TColStd_SequenceOfReal& Vmult,
const Standard_Real& prevUp,
const Standard_Real& prevVp,
const IntWalk_VectorOfInteger& nbMultiplicities,
const math_Vector& tolerance,
TheIWFunction& sp,
math_Vector& UV,
Standard_Integer& Irang) {
Standard_Boolean Arrive = Standard_False;
Standard_Real Dup, Dvp, Utest,Vtest;
Standard_Real tolu = tolerance(1);
Standard_Real tolv = tolerance(2);
Standard_Integer i, j, k, N;
for (i = 1; i < (int)wd.size(); i++) {
if (wd[i].etat < -11) {
// debug jag see with isg
Utest = wd[i].ustart;
Vtest = wd[i].vstart;
Dup = prevUp - Utest;
Dvp = prevVp - Vtest;
if (Abs(Dup) >= tolu || Abs(Dvp) >= tolv) {
Standard_Real UV1mUtest = UV(1)-Utest;
Standard_Real UV2mVtest = UV(2)-Vtest;
if(( (Dup*UV1mUtest + Dvp*UV2mVtest) < 0) ||
( Abs(UV1mUtest) < tolu
&& Abs(UV2mVtest) < tolv)) {
Irang=i;
Arrive = Standard_True;
UV(1) = Utest;
UV(2) = Vtest;
}
else if (nbMultiplicities[i] > 0) {
N=0;
for (k = 1; k < i; k++) {
N+=nbMultiplicities[k];
}
for (j = N + 1; j <= N + nbMultiplicities[i]; j++) {
if (((prevUp-Umult(j))*(UV(1)-Umult(j)) +
(prevVp-Vmult(j))*(UV(2)-Vmult(j)) < 0) ||
(Abs(UV(1)-Umult(j)) < tolu &&
Abs(UV(2)-Vmult(j)) < tolv)) {
Irang=i;
Arrive = Standard_True;
UV(1) = Utest;
UV(2) = Vtest;
break;
}
}
}
if (Arrive) {
Standard_Real abidF[1], abidD[1][2];
math_Vector bidF(abidF,1,1);
math_Matrix bidD(abidD,1,1,1,2);
sp.Values(UV,bidF,bidD);
break;
}
}
}
}
return Arrive;
}
// modified by NIZHNY-MKK Thu Nov 2 15:07:58 2000.END

572
src/IntWalk/IntWalk_IWalking_4.gxx
View File

@ -1,572 +0,0 @@
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <NCollection_IncAllocator.hxx>
void IntWalk_IWalking::ComputeCloseLine(const TColStd_SequenceOfReal& Umult,
const TColStd_SequenceOfReal& Vmult,
const ThePOPIterator& Pnts1,
const ThePOLIterator& Pnts2,
TheIWFunction& Func,
Standard_Boolean& Rajout )
// *********** Processing of closed line **********************
//
// for any interior non-processed point
// calculate the step of advancement=step depending on the arrow and max step
// calculate a point of approach (this point is on the tangent to the section
// of distance = no interior point)
// conditions
// (all calculated points do not form a closed loop)
// or
// (all points do not form an open line going from
// one border of the domain to the other or from a point tangent
// to the border or from 2 tangent points : single cases)
//
// frame the point of approach on borders if necessary
// calculate the point
// if point not found divide the step
// test of stop
// calculate step depending on the arrow and the max step (stop possible)
//
// ********************************************************************
{
Standard_Integer I = 0, N = 0,SaveN = 0;
Standard_Real aBornInf[2] = {}, aBornSup[2] = {}, aUVap[2] = {};
math_Vector BornInf(aBornInf,1,2), BornSup(aBornSup,1,2);
math_Vector Uvap(aUVap,1,2);// parameters of current approach
Standard_Real PasC = 0.0; // step of advancement on the tangent
Standard_Real PasCu = 0.0; // step of advancement current by U
Standard_Real PasCv = 0.0; // step of advancement current by V
Standard_Real PasSav = 0.0; // save first step of advancement
Standard_Boolean Arrive = false;// show if line ends
Standard_Boolean Cadre = false; // show if on border of the domains
Standard_Boolean ArretAjout = false; // show if on the added point
IntSurf_PntOn2S Psol;
Handle(IntWalk_TheIWLine) CurrentLine; //line under construction
ThePointOfPath PathPnt;
ThePointOfLoop LoopPnt;
Standard_Boolean Tgtbeg = false, Tgtend = false;
Standard_Integer StepSign = 0;
IntWalk_StatusDeflection aStatus = IntWalk_OK, StatusPrecedent;
Standard_Integer NbDivision = 0; // number of divisions of step
// during calculation of 1 section
Standard_Integer Ipass = 0;
//index in the iterator of points on edge of point of passage
BornInf(1) = Um;
BornSup(1) = UM;
BornInf(2) = Vm;
BornSup(2) = VM;
math_FunctionSetRoot Rsnld(Func,tolerance);
Standard_Integer nbLoop = Pnts2.Length();
// Check borders for degeneracy:
math_Matrix D(1,1,1,2);
const Standard_Integer aNbSamplePnt = 10;
Standard_Boolean isLeftDegeneratedBorder[2] = {Standard_True, Standard_True};
Standard_Boolean isRightDegeneratedBorder[2] = {Standard_True, Standard_True};
math_Vector aStep(1,2);
aStep = (BornSup - BornInf) / (aNbSamplePnt - 1);
for(Standard_Integer aBorderIdx = 1; aBorderIdx <= 2; aBorderIdx++)
{
Standard_Integer aChangeIdx = aBorderIdx == 2? 1 : 2;
math_Vector UV(1,2);
// Left border.
UV(aBorderIdx) = BornInf(aBorderIdx);
for(Standard_Integer aParamIdx = 0; aParamIdx < aNbSamplePnt; aParamIdx++)
{
Standard_Real aParam = BornInf(aChangeIdx) + aParamIdx * aStep(aChangeIdx);
UV(aChangeIdx) = aParam;
Func.Derivatives(UV, D);
if ( Abs(D(1, aChangeIdx) ) > Precision::Confusion())
{
isLeftDegeneratedBorder[aBorderIdx - 1] = Standard_False;
break;
}
}
// Right border.
UV(aBorderIdx) = BornSup(aBorderIdx);
for(Standard_Integer aParamIdx = 0; aParamIdx < aNbSamplePnt; aParamIdx++)
{
Standard_Real aParam = BornInf(aChangeIdx) + aParamIdx * aStep(aChangeIdx);
UV(aChangeIdx) = aParam;
Func.Derivatives(UV, D);
if ( Abs(D(1, aChangeIdx) ) > Precision::Confusion())
{
isRightDegeneratedBorder[aBorderIdx - 1] = Standard_False;
break;
}
}
}
TheIWFunction aFuncForDuplicate = Func;
for (I = 1;I<=nbLoop;I++) {
if (wd2[I].etat > 12)
{ // start point of closed line
LoopPnt = Pnts2.Value(I);
previousPoint.SetValue(ThePointOfLoopTool::Value3d(LoopPnt), reversed,
wd2[I].ustart, wd2[I].vstart);
if (IsPointOnLine(previousPoint, BornInf, BornSup, Rsnld, aFuncForDuplicate))
{
wd2[I].etat = -wd2[I].etat; //mark point as processed
continue;
}
previousd3d = ThePointOfLoopTool::Direction3d(LoopPnt);
previousd2d = ThePointOfLoopTool::Direction2d(LoopPnt);
CurrentLine = new IntWalk_TheIWLine (new NCollection_IncAllocator());
CurrentLine->AddPoint(previousPoint);
CurrentLine->SetTangentVector(previousd3d,1);
Tgtbeg = Standard_False;
Tgtend = Standard_False;
Uvap(1) = wd2[I].ustart;
Uvap(2) = wd2[I].vstart;
StepSign = 1;
// first step of advancement
Standard_Real d2dx = Abs(previousd2d.X());
Standard_Real d2dy = Abs(previousd2d.Y());
if (d2dx < tolerance(1)) {
PasC = pas * (VM-Vm)/d2dy;
}
else if (d2dy < tolerance(2)) {
PasC = pas * (UM-Um)/d2dx;
}
else {
PasC = pas * Min((UM-Um)/d2dx,(VM-Vm)/d2dy);
}
PasSav = PasC;
Arrive = Standard_False;
ArretAjout = Standard_False;
NbDivision = 0;
StatusPrecedent = IntWalk_OK;
Standard_Integer aNbIter = 10;
while (!Arrive) { // as no test of stop is passed
Cadre=Cadrage(BornInf,BornSup,Uvap,PasC, StepSign); // border?
#ifdef CHRONO
Chronrsnld.Start();
#endif
Rsnld.Perform(Func,Uvap,BornInf,BornSup);
#ifdef CHRONO
Chronrsnld.Stop();
#endif
Standard_Boolean isOnDegeneratedBorder = Standard_False;
if (Cadre) { // update of limits.
BornInf(1) = Um;BornSup(1) = UM;BornInf(2) = Vm;BornSup(2) = VM;
}
if (Rsnld.IsDone()) {
if (Abs(Func.Root()) > Func.Tolerance()) { // no solution for the tolerance
PasC = PasC/2.;
PasCu = Abs(PasC*previousd2d.X());
PasCv = Abs(PasC*previousd2d.Y());
if (PasCu <= tolerance(1) && PasCv <= tolerance(2)) {
if (CurrentLine->NbPoints()==1)
{
RemoveTwoEndPoints(I);
break; //cancel the line
}
if (wd2[I].etat >12) { //the line should become open
wd2[I].etat = 12; //declare it open
ArretAjout = Standard_False;
OpenLine(0,Psol,Pnts1,Func,CurrentLine);
StepSign = -1;
StatusPrecedent = IntWalk_OK;
Arrive = Standard_False;
PasC = PasSav;
Rajout = Standard_True;
seqAlone.Append(-lines.Length()-1);
seqAjout.Append(-lines.Length()-1);
}
else { // line s is open
Arrive =Standard_True;
CurrentLine->AddStatusLast(Standard_False);
Rajout = Standard_True;
seqAlone.Append(lines.Length()+1);
seqAjout.Append(lines.Length()+1);
Tgtend = Standard_True;
}
/*
Arrive = Standard_True;
CurrentLine->AddStatusFirstLast(Standard_False,
Standard_False,Standard_False);
Rajout = Standard_True;
seqAlone.Append(lines.Length()+1);
seqAjout.Append(lines.Length()+1);
Tgtend = Standard_True;
*/
}
}
else { // there is a solution
Rsnld.Root(Uvap);
// Avoid uninitialized memory access.
if (CurrentLine->NbPoints() > 2)
{
for(Standard_Integer aCoordIdx = 1; aCoordIdx <= 2; aCoordIdx++)
{
// Check degenerated cases and fix if possible.
if ( ( isLeftDegeneratedBorder[aCoordIdx - 1]
&& Abs (Uvap(aCoordIdx) - BornInf(aCoordIdx)) < Precision::PConfusion())||
(isRightDegeneratedBorder[aCoordIdx - 1]
&& Abs (Uvap(aCoordIdx) - BornSup(aCoordIdx)) < Precision::PConfusion()) )
{
Standard_Real uvprev[2], uv[2];
if (!reversed)
{
CurrentLine->Value(CurrentLine->NbPoints() - 1).ParametersOnS2(uvprev[0], uvprev[1]);
CurrentLine->Value(CurrentLine->NbPoints()).ParametersOnS2(uv[0], uv[1]);
}
else
{
CurrentLine->Value(CurrentLine->NbPoints() - 1).ParametersOnS1(uvprev[0], uvprev[1]);
CurrentLine->Value(CurrentLine->NbPoints()).ParametersOnS1(uv[0], uv[1]);
}
Standard_Real aScaleCoeff = 0.0;
// Avoid finite cycle which lead to stop computing iline.
if (aStatus != IntWalk_PasTropGrand)
{
// Make linear extrapolation.
if ( Abs(uv[aCoordIdx - 1] - uvprev[aCoordIdx - 1]) > gp::Resolution())
aScaleCoeff = Abs ((Uvap(aCoordIdx) - uv[aCoordIdx - 1])
/ (uv[aCoordIdx - 1] - uvprev[aCoordIdx - 1]) );
Standard_Integer aFixIdx = aCoordIdx == 1? 2 : 1; // Fixing index;
Uvap(aFixIdx) = uv[aFixIdx - 1] + (uv[aFixIdx - 1] - uvprev[aFixIdx - 1]) * aScaleCoeff;
isOnDegeneratedBorder = Standard_True;
}
}
}
}
Arrive = TestArretPassage(Umult,Vmult,Uvap,I,Ipass);
if (Arrive) {//reset proper parameter to test the arrow.
Psol = CurrentLine->Value(1);
if (!reversed) {
Psol.ParametersOnS2(Uvap(1),Uvap(2));
}
else {
Psol.ParametersOnS1(Uvap(1),Uvap(2));
}
Cadre=Standard_False;
//in case if there is a frame and arrival at the same time
}
else { // modif jag 940615
if (Rajout) { // test on added points
ArretAjout =TestArretAjout(Func,Uvap,N,Psol);
SaveN = N;
if (ArretAjout) {
if (N >0) {
Tgtend = lines.Value(N)->IsTangentAtEnd();
N = -N;
}
else {
Tgtend = lines.Value(-N)->IsTangentAtBegining();
}
Arrive = (wd2[I].etat == 12);
}
}
if (!ArretAjout&& Cadre) { // test on already marked points
if (CurrentLine->NbPoints() == 1)
{
RemoveTwoEndPoints(I);
break; // cancel the line
}
TestArretCadre(Umult,Vmult,CurrentLine,Func,Uvap,N);
SaveN = N;
// if (N==0) {
if (N <= 0) { // jag 941017
MakeWalkingPoint(2,Uvap(1),Uvap(2),Func,Psol);
Tgtend = Func.IsTangent(); // jag 940616
if (isOnDegeneratedBorder)
Tgtend = Standard_True;
N = -N;
}
Arrive = (wd2[I].etat == 12); // the line is open
}
}
aStatus = TestDeflection(Func, Arrive,Uvap,StatusPrecedent,
NbDivision,PasC,StepSign);
if (isOnDegeneratedBorder && Tgtend)
aStatus = IntWalk_ArretSurPoint;
StatusPrecedent = aStatus;
if (aStatus == IntWalk_PasTropGrand) {// division of the step
Arrive = Standard_False;
ArretAjout = Standard_False;
Tgtend = Standard_False; // jag 940616
if (!reversed) {
previousPoint.ParametersOnS2(Uvap(1),Uvap(2));
}
else {
previousPoint.ParametersOnS1(Uvap(1),Uvap(2));
}
}
else if (ArretAjout || Cadre) {
if (Arrive) { // line s is open
CurrentLine->AddStatusLast(Standard_False);
//if (aStatus != IntWalk_ArretSurPointPrecedent)
CurrentLine->AddPoint(Psol);
//Remove <SaveN> from <seqAlone> and, if it is first found point,
//from <seqAjout> too
if (IsValidEndPoint(I, SaveN))
{
for (Standard_Integer iseq = 1; iseq <= seqAlone.Length(); iseq++)
if (seqAlone(iseq) == SaveN)
{
seqAlone.Remove(iseq);
break;
}
if (CurrentLine->NbPoints() <= 3)
for (Standard_Integer iseq = 1; iseq <= seqAjout.Length(); iseq++)
if (seqAjout(iseq) == SaveN)
{
seqAjout.Remove(iseq);
break;
}
}
else
{
if (seqAlone.Last() == -lines.Length()-1)
{
seqAlone.Remove(seqAlone.Length());
seqAjout.Remove(seqAjout.Length());
}
RemoveTwoEndPoints(I);
Arrive = Standard_False;
break; //cancel the line
}
if (Cadre && N==0) {
Rajout = Standard_True;
//seqAlone.Append(lines.Length()+1);
seqAjout.Append(lines.Length()+1);
}
}
else { // open
wd2[I].etat = 12; // declare it open
Tgtbeg = Tgtend;
Tgtend = Standard_False;
ArretAjout = Standard_False;
StepSign = -1;
StatusPrecedent = IntWalk_OK;
PasC = PasSav;
//Check if <Psol> has been really updated
if (Arrive || Rajout || (!ArretAjout && Cadre && SaveN <= 0))
{
if (aStatus == IntWalk_ArretSurPointPrecedent) {
CurrentLine->AddPoint(Psol);
OpenLine(0,Psol,Pnts1,Func,CurrentLine);
}
else {
OpenLine(-lines.Length()-1,Psol,Pnts1,Func,CurrentLine);
}
}
//Remove <SaveN> from <seqAlone> and, if it is first found point,
//from <seqAjout> too
if (IsValidEndPoint(I, SaveN))
{
for (Standard_Integer iseq = 1; iseq <= seqAlone.Length(); iseq++)
if (seqAlone(iseq) == SaveN)
{
seqAlone.Remove(iseq);
break;
}
if (CurrentLine->NbPoints() <= 2)
for (Standard_Integer iseq = 1; iseq <= seqAjout.Length(); iseq++)
if (seqAjout(iseq) == SaveN)
{
seqAjout.Remove(iseq);
break;
}
}
else
{
RemoveTwoEndPoints(I);
break; //cancel the line
}
if (Cadre && N==0) {
Rajout = Standard_True;
seqAjout.Append(-lines.Length()-1);
}
}
}
else if (aStatus == IntWalk_ArretSurPointPrecedent) {
if (CurrentLine->NbPoints() == 1) { //cancel the line
Arrive = Standard_False;
RemoveTwoEndPoints(I);
break;
}
if (wd2[I].etat >12) { //the line should become open
wd2[I].etat = 12; //declare it open
ArretAjout = Standard_False;
OpenLine(0,Psol,Pnts1,Func,CurrentLine);
StepSign = -1;
StatusPrecedent = IntWalk_OK;
Arrive = Standard_False;
PasC = PasSav;
Rajout = Standard_True;
seqAlone.Append(-lines.Length()-1);
seqAjout.Append(-lines.Length()-1);
}
else { // line s is open
Arrive =Standard_True;
CurrentLine->AddStatusLast(Standard_False);
Rajout = Standard_True;
seqAlone.Append(lines.Length()+1);
seqAjout.Append(lines.Length()+1);
}
}
else if (Arrive) {
if (wd2[I].etat > 12) { //line closed good case
CurrentLine->AddStatusFirstLast(Standard_True,
Standard_False,Standard_False);
CurrentLine->AddPoint(CurrentLine->Value(1));
}
else if ((N >0) && (Pnts1.Length() >= N))
{
//point of stop given at input
PathPnt = Pnts1.Value(N);
CurrentLine->AddStatusLast(Standard_True,N,PathPnt);
AddPointInCurrentLine(N,PathPnt,CurrentLine);
}
}
else if (aStatus == IntWalk_ArretSurPoint) {
if (wd2[I].etat >12) { //line should become open
wd2[I].etat = 12; //declare it open
Tgtbeg = Standard_True;
Tgtend = Standard_False;
N= -lines.Length()-1;
Psol.SetValue(Func.Point(),reversed,Uvap(1),Uvap(2));
OpenLine(N,Psol,Pnts1,Func,CurrentLine);
StepSign = -1;
Rajout = Standard_True;
seqAlone.Append(N);
seqAjout.Append(N);
StatusPrecedent = IntWalk_OK;
Arrive = Standard_False;
PasC = PasSav;
}
else {
Arrive = Standard_True;
if (Ipass!=0) { //point of passage, point of stop
PathPnt = Pnts1.Value(Ipass);
CurrentLine->AddStatusLast(Standard_True,Ipass,PathPnt);
AddPointInCurrentLine(Ipass,PathPnt,CurrentLine);
}
else {
CurrentLine->AddStatusLast(Standard_False);
IntSurf_PntOn2S newP;
newP.SetValue(Func.Point(),reversed,Uvap(1),Uvap(2));
CurrentLine->AddPoint(newP);
Rajout = Standard_True;
seqAlone.Append(lines.Length()+1);
seqAjout.Append(lines.Length()+1);
}
}
}
else if (aStatus == IntWalk_OK) {
if (Ipass!=0) CurrentLine->AddIndexPassing(Ipass);
previousPoint.SetValue(Func.Point(),reversed,Uvap(1),Uvap(2));
previousd3d = Func.Direction3d();
previousd2d = Func.Direction2d();
CurrentLine->AddPoint(previousPoint);
}
else if (aStatus == IntWalk_PointConfondu)
{
aNbIter --;
}
}
}
else { //no numerical solution NotDone
PasC = PasC/2.;
PasCu = Abs(PasC*previousd2d.X());
PasCv = Abs(PasC*previousd2d.Y());
if (PasCu <= tolerance(1) && PasCv <= tolerance(2)) {
if (CurrentLine->NbPoints() == 1)
{
RemoveTwoEndPoints(I);
break; // cancel the line
}
if (wd2[I].etat >12) { //the line should become open
wd2[I].etat = 12; //declare it open
ArretAjout = Standard_False;
OpenLine(0,Psol,Pnts1,Func,CurrentLine);
StepSign = -1;
StatusPrecedent = IntWalk_OK;
Arrive = Standard_False;
PasC = PasSav;
Rajout = Standard_True;
seqAlone.Append(-lines.Length()-1);
seqAjout.Append(-lines.Length()-1);
}
else { // line s is open
Arrive =Standard_True;
CurrentLine->AddStatusLast(Standard_False);
Tgtend = Standard_True;
Rajout = Standard_True;
seqAlone.Append(lines.Length()+1);
seqAjout.Append(lines.Length()+1);
}
/*
Arrive = Standard_True;
CurrentLine->AddStatusFirstLast(Standard_False,Standard_False,
Standard_False);
Tgtend = Standard_True;
Rajout = Standard_True;
seqAlone.Append(lines.Length()+1);
seqAjout.Append(lines.Length()+1);
*/
}
}
if(aNbIter < 0)
break;
}// end of started line
if (Arrive) {
CurrentLine->SetTangencyAtBegining(Tgtbeg);
CurrentLine->SetTangencyAtEnd(Tgtend);
lines.Append(CurrentLine);
wd2[I].etat=-wd2[I].etat; //mark point as processed
}
} //end of processing of start point
} //end of all start points
}

310
src/IntWalk/IntWalk_IWalking_5.gxx
View File

@ -1,310 +0,0 @@
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
namespace {
static const Standard_Real CosRef3D = 0.98;// rule by tests in U4
// correspond to 11.478 d
static const Standard_Real CosRef2D = 0.88; // correspond to 25 d
static const Standard_Integer MaxDivision = 60; // max number of step division
// because the angle is too great in 2d (U4)
}
IntWalk_StatusDeflection IntWalk_IWalking::TestDeflection
(TheIWFunction& sp,
const Standard_Boolean Finished,
const math_Vector& UV,
const IntWalk_StatusDeflection StatusPrecedent,
Standard_Integer& NbDivision,
Standard_Real& Step,
const Standard_Integer StepSign)
{
// Check the step of advancement, AND recalculate this step :
//
// 1) test point confused
// if yes other tests are not done
// 2) test angle 3d too great
// if yes divide the step and leave
// angle3d = angle ((previous point, calculated point),
// previous tangent)
// 3) check step of advancement in 2d
// 4) test point confused
// 5) test angle 2d too great
// 6) test point of tangency
// if yes leave
// 7) calculate the tangent by u,v of the section
// 8) test angle 3d too great
// angle3d = angle ((previous point, calculated point),
// new tangent)
// 9) test angle 2d too great
//10) test change of side (pass the tangent point not knowing it)
//11) calculate the step of advancement depending on the vector
//12) adjust the step depending on the previous steps
IntWalk_StatusDeflection aStatus = IntWalk_OK;
//---------------------------------------------------------------------------------
//-- lbr le 4 Avril 95 : it is possible that the status returns points confused
//-- if epsilon is great enough (1e-11). In this case one loops
//-- without ever changing the values sent to Rsnld.
//---------------------------------------------------------------------------------
Standard_Real Paramu = 0.0, Paramv = 0.0;
if (!reversed) {
previousPoint.ParametersOnS2(Paramu, Paramv);
}
else
{
previousPoint.ParametersOnS1(Paramu, Paramv);
}
const Standard_Real Du = UV(1) - Paramu;
const Standard_Real Dv = UV(2) - Paramv;
const Standard_Real Duv = Du * Du + Dv * Dv;
gp_Vec Corde(previousPoint.Value(), sp.Point());
const Standard_Real Norme = Corde.SquareMagnitude();
if ((Norme <= 4.0*Precision::SquareConfusion()) &&
((Duv <= Precision::SquarePConfusion()) || (StatusPrecedent != IntWalk_OK)))
{ // the square is already taken in the constructor
aStatus = IntWalk_PointConfondu;
if (StatusPrecedent == IntWalk_PasTropGrand)
{
return IntWalk_ArretSurPointPrecedent;
}
}
else
{
Standard_Real Cosi = Corde * previousd3d;
Standard_Real Cosi2 = 0.0;
if (Cosi*StepSign >= 0.) {// angle 3d <= pi/2 !!!!
const Standard_Real aDiv = previousd3d.SquareMagnitude()*Norme;
if(aDiv == 0)
return aStatus;
Cosi2 = Cosi * Cosi / aDiv;
}
if (Cosi2 < CosRef3D) { //angle 3d too great
Step = Step /2.0;
Standard_Real StepU = Abs(Step*previousd2d.X()),
StepV = Abs(Step*previousd2d.Y());
if (StepU < tolerance(1) && StepV < tolerance(2))
aStatus = IntWalk_ArretSurPointPrecedent;
else
aStatus = IntWalk_PasTropGrand;
return aStatus;
}
}
const Standard_Real aMinTolU = 0.1*Abs(Step*previousd2d.X()),
aMinTolV = 0.1*Abs(Step*previousd2d.Y());
const Standard_Real aTolU = (aMinTolU > 0.0) ? Min(tolerance(1), aMinTolU) : tolerance(1),
aTolV = (aMinTolV > 0.0) ? Min(tolerance(2), aMinTolV) : tolerance(2);
//If aMinTolU==0.0 then (Abs(Du) < aMinTolU) is equivalent of (Abs(Du) < 0.0).
//It is impossible. Therefore, this case should be processed separately.
//Analogically for aMinTolV.
if ((Abs(Du) < aTolU) && (Abs(Dv) < aTolV))
{
//Thin shapes (for which Ulast-Ufirst or/and Vlast-Vfirst is quite small)
//exists (see bug #25820). In this case, step is quite small too.
//Nevertheless, it not always means that we mark time. Therefore, Du and Dv
//must consider step (aMinTolU and aMinTolV parameters).
return IntWalk_ArretSurPointPrecedent; //confused point 2d
}
Standard_Real Cosi = StepSign * (Du * previousd2d.X() + Dv * previousd2d.Y());
if (Cosi < 0 && aStatus == IntWalk_PointConfondu)
return IntWalk_ArretSurPointPrecedent; // leave as step back
// with confused point
if (sp.IsTangent())
return IntWalk_ArretSurPoint;
//if during routing one has subdivided more than MaxDivision for each
//previous step, bug on the square; do nothing (experience U4)
if ((NbDivision < MaxDivision) && (aStatus != IntWalk_PointConfondu) &&
(StatusPrecedent!= IntWalk_PointConfondu))
{
Standard_Real Cosi2 = Cosi * Cosi / Duv;
if (Cosi2 < CosRef2D || Cosi < 0 ) {
Step = Step / 2.0;
Standard_Real StepU = Abs(Step*previousd2d.X()),
StepV = Abs(Step*previousd2d.Y());
if (StepU < tolerance(1) && StepV < tolerance(2))
aStatus = IntWalk_ArretSurPointPrecedent;
else
aStatus = IntWalk_PasTropGrand;
NbDivision = NbDivision + 1;
return aStatus;
}
Cosi = Corde * sp.Direction3d();
Cosi2 = Cosi * Cosi / sp.Direction3d().SquareMagnitude() / Norme;
if (Cosi2 < CosRef3D ){ //angle 3d too great
Step = Step / 2.;
Standard_Real StepU = Abs(Step*previousd2d.X()),
StepV = Abs(Step*previousd2d.Y());
if (StepU < tolerance(1) && StepV < tolerance(2))
aStatus = IntWalk_ArretSurPoint;
else
aStatus = IntWalk_PasTropGrand;
return aStatus;
}
Cosi = Du * sp.Direction2d().X() +
Dv * sp.Direction2d().Y();
Cosi2 = Cosi * Cosi / Duv;
if (Cosi2 < CosRef2D ||
sp.Direction2d() * previousd2d < 0) {
//angle 2d too great or change the side
Step = Step / 2.;
Standard_Real StepU = Abs(Step*previousd2d.X()),
StepV = Abs(Step*previousd2d.Y());
if (StepU < tolerance(1) && StepV < tolerance(2))
aStatus = IntWalk_ArretSurPointPrecedent;
else
aStatus = IntWalk_PasTropGrand;
return aStatus;
}
}
if (!Finished) {
if (aStatus == IntWalk_PointConfondu)
{
Standard_Real StepU = Min(Abs(1.5 * Du),pas*(UM-Um)),
StepV = Min(Abs(1.5 * Dv),pas*(VM-Vm));
Standard_Real d2dx = Abs(previousd2d.X());
Standard_Real d2dy = Abs(previousd2d.Y());
if (d2dx < tolerance(1))
{
Step = StepV/d2dy;
}
else if (d2dy < tolerance(2))
{
Step = StepU/d2dx;
}
else
{
Step = Min(StepU/d2dx,StepV/d2dy);
}
}
else
{
// estimate the current vector.
// if vector/2<=current vector<= vector it is considered that the criterion
// is observed.
// otherwise adjust the step depending on the previous step
/*
Standard_Real Dist = Sqrt(Norme)/3.;
TColgp_Array1OfPnt Poles(1,4);
gp_Pnt POnCurv,Milieu;
Poles(1) = previousPoint.Value();
Poles(4) = sp.Point();
Poles(2) = Poles(1).XYZ() +
StepSign * Dist* previousd3d.Normalized().XYZ();
Poles(3) = Poles(4).XYZ() -
StepSign * Dist*sp.Direction3d().Normalized().XYZ();
BzCLib::PntPole(0.5,Poles,POnCurv);
Milieu = (Poles(1).XYZ() + Poles(4).XYZ())*0.5;
// FlecheCourante = Milieu.Distance(POnCurv);
Standard_Real FlecheCourante = Milieu.SquareDistance(POnCurv);
*/
// Direct calculation :
// POnCurv=(((p1+p2)/2.+(p2+p3)/2.)/2. + ((p2+p3)/2.+(p3+P4)/2.)/2.)/2.
// either POnCurv = p1/8. + 3.p2/8. + 3.p3/8. + p4/8.
// Or p2 = p1 + lambda*d1 et p3 = p4 - lambda*d4
// So POnCurv = (p1 + p4)/2. + 3.*(lambda d1 - lambda d4)/8.
// Calculate the deviation with (p1+p4)/2. . So it is just necessary to calculate
// the norm (square) of 3.*lambda (d1 - d4)/8.
// either the norm of :
// 3.*(Sqrt(Norme)/3.)*StepSign*(d1-d4)/8.
// which produces, taking the square :
// Norme * (d1-d4).SquareMagnitude()/64.
Standard_Real FlecheCourante =
(previousd3d.Normalized().XYZ()-sp.Direction3d().Normalized().XYZ()).SquareModulus()*Norme/64.;
// if (FlecheCourante <= 0.5*fleche) {
if (FlecheCourante <= 0.25*fleche*fleche)
{
Standard_Real d2dx = Abs(sp.Direction2d().X());
Standard_Real d2dy = Abs(sp.Direction2d().Y());
Standard_Real StepU = Min(Abs(1.5*Du),pas*(UM-Um)),
StepV = Min(Abs(1.5*Dv),pas*(VM-Vm));
if (d2dx < tolerance(1))
{
Step = StepV/d2dy;
}
else if (d2dy < tolerance(2))
{
Step = StepU/d2dx;
}
else
{
Step = Min(StepU/d2dx,StepV/d2dy);
}
}
else
{
//if (FlecheCourante > fleche) { // step too great
if (FlecheCourante > fleche*fleche)
{ // step too great
Step = Step /2.;
Standard_Real StepU = Abs(Step*previousd2d.X()),
StepV = Abs(Step*previousd2d.Y());
if (StepU < tolerance(1) && StepV < tolerance(2))
aStatus = IntWalk_ArretSurPointPrecedent;
else
aStatus = IntWalk_PasTropGrand;
}
else
{
Standard_Real d2dx = Abs(sp.Direction2d().X());
Standard_Real d2dy = Abs(sp.Direction2d().Y());
Standard_Real StepU = Min(Abs(1.5*Du),pas*(UM-Um)),
StepV = Min(Abs(1.5*Dv),pas*(VM-Vm));
if (d2dx < tolerance(1))
{
Step = Min(Step,StepV/d2dy);
}
else if (d2dy < tolerance(2))
{
Step = Min(Step,StepU/d2dx);
}
else
{
Step = Min(Step,Min(StepU/d2dx,StepV/d2dy));
}
}
}
}
}
return aStatus;
}

272
src/IntWalk/IntWalk_IWalking_6.gxx
View File

@ -1,272 +0,0 @@
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef OCCT_DEBUG
#define No_Standard_RangeError
#define No_Standard_OutOfRange
#endif
void IntWalk_IWalking::AddPointInCurrentLine
(const Standard_Integer N,
const ThePointOfPath& PathPnt,
const Handle(IntWalk_TheIWLine)& CurrentLine) const {
IntSurf_PntOn2S Psol;
Psol.SetValue(ThePointOfPathTool::Value3d(PathPnt),
reversed,wd1[N].ustart,wd1[N].vstart);
CurrentLine->AddPoint(Psol);
}
void IntWalk_IWalking::MakeWalkingPoint
(const Standard_Integer Case,
const Standard_Real U,
const Standard_Real V,
TheIWFunction& sp,
IntSurf_PntOn2S& Psol )
{
// Case == 1 : make a WalkinkPoint.
// Case == 2 : make a WalkinkPoint.
// The computation of the tangency on is done
// Case == 10 + i : make a WalkinkPoint according to i.
// but F is updated according to U and V
// Case == other : the exception Standard_Failure is raised.
if ((Case == 1) || (Case == 2))
{
Psol.SetValue(sp.Point(), reversed, U, V);
}
else if (Case == 11 || Case == 12)
{
Standard_Real aUV[2] = {}, aFF[1] = {}, aDD[1][2] = {};
math_Vector UV(aUV, 1, 2);
math_Vector FF(aFF, 1, 1);
math_Matrix DD(aDD, 1, 1, 1, 2);
UV(1) = U;
UV(2) = V;
sp.Values(UV, FF, DD);
MakeWalkingPoint(Case - 10, U, V, sp, Psol);
}
else
{
throw Standard_ConstructionError();
}
}
void IntWalk_IWalking::OpenLine(const Standard_Integer N,
const IntSurf_PntOn2S& Psol,
const ThePOPIterator& Pnts1,
TheIWFunction& sp,
const Handle(IntWalk_TheIWLine)& Line )
// **************** open the line and restart in the other direction********
{
ThePointOfPath PathPnt;
Standard_Real aUV[2], aFF[1], aDD[1][2];
math_Vector UV(aUV,1, 2);
math_Vector FF(aFF,1, 1);
math_Matrix DD(aDD,1, 1, 1, 2);
previousPoint = Line->Value(1);
if (!reversed) {
previousPoint.ParametersOnS2(UV(1),UV(2));
}
else {
previousPoint.ParametersOnS1(UV(1),UV(2));
}
sp.Values(UV, FF, DD);
previousd3d = sp.Direction3d();
previousd2d = sp.Direction2d();
if (N>0) { //departure point given at input
PathPnt = Pnts1.Value(N);
//mark the line as open with a given stop point
Line->AddStatusFirst(Standard_False,Standard_True,N,PathPnt);
AddPointInCurrentLine(N,PathPnt,Line);
}
else {
if (N <0) Line->AddPoint(Psol);
Line->AddStatusFirst(Standard_False,Standard_False);
//mark the line as open without given stop point
}
Line->Reverse(); //inverser la ligne
Line->SetTangentVector(previousd3d.Reversed(),Line->NbPoints());
}
Standard_Boolean IntWalk_IWalking::IsValidEndPoint(const Standard_Integer IndOfPoint,
const Standard_Integer IndOfLine)
{
if (PointLineLine.IsEmpty())
return Standard_True;
TColStd_ListIteratorOfListOfInteger itl(PointLineLine(IndOfPoint));
for (; itl.More(); itl.Next())
if (itl.Value() == IndOfLine)
{
PointLineLine(IndOfPoint).Remove(itl);
return Standard_True;
}
return Standard_False;
}
void IntWalk_IWalking::RemoveTwoEndPoints(const Standard_Integer IndOfPoint)
{
if (PointLineLine.IsBound(IndOfPoint))
{
Standard_Integer Line1 = PointLineLine(IndOfPoint).First();
Standard_Integer Line2 = PointLineLine(IndOfPoint).Last();
for (Standard_Integer iseq = 1; iseq <= seqAlone.Length(); iseq++)
{
if (seqAlone(iseq) == Line1 ||
seqAlone(iseq) == Line2)
seqAlone.Remove(iseq--);
}
}
}
Standard_Boolean IntWalk_IWalking::IsPointOnLine(const gp_Pnt2d& theP2d,
const Standard_Integer Irang)
{
const Handle(IntWalk_TheIWLine)& aLine = lines.Value(Abs(Irang));
for (Standard_Integer i = 1; i <= aLine->NbPoints(); i++)
{
gp_Pnt2d P2d1 = aLine->Value(i).ValueOnSurface(reversed);
if (Abs(P2d1.X() - theP2d.X()) <= tolerance(1) &&
Abs(P2d1.Y() - theP2d.Y()) <= tolerance(2))
return Standard_True;
if (i < aLine->NbPoints())
{
gp_Pnt2d P2d2 = aLine->Value(i+1).ValueOnSurface(reversed);
gp_Vec2d PP1(theP2d, P2d1);
gp_Vec2d PP2(theP2d, P2d2);
if (PP1 * PP2 < 0)
return Standard_True;
}
}
return Standard_False;
}
//==================================================================================
//function : IsPointOnLine
//purpose : Projects thePOn2S on the nearest segment of the already computed line.
// The retrieved projection point (aPa) is refined using theSolver.
// After the refinement, we will obtain a point aPb.
// If thePOn2S is quite far from aPb then thePOn2S is not
// in the line.
// Every already computed line is checked.
//==================================================================================
Standard_Boolean IntWalk_IWalking::IsPointOnLine(const IntSurf_PntOn2S& thePOn2S,
const math_Vector& theInfBounds,
const math_Vector& theSupBounds,
math_FunctionSetRoot& theSolver,
TheIWFunction& theFunc)
{
const Standard_Real eps = Epsilon(1.);
const gp_Pnt &aP3d = thePOn2S.Value();
for (Standard_Integer aLIdx = 1; aLIdx <= lines.Length(); aLIdx++)
{
const Handle(IntSurf_LineOn2S) &aL = lines(aLIdx)->Line();
if (aL->IsOutBox(aP3d))
continue;
//Look for the nearest segment
Standard_Real aUMin = 0.0, aVMin = 0.0;
Standard_Real aMinSqDist = RealLast();
for (Standard_Integer aPtIdx = 1; aPtIdx < aL->NbPoints(); aPtIdx++)
{
const gp_Pnt &aP1 = aL->Value(aPtIdx).Value();
const gp_Pnt &aP2 = aL->Value(aPtIdx + 1).Value();
const gp_XYZ aP1P(aP3d.XYZ() - aP1.XYZ());
const gp_XYZ aP1P2(aP2.XYZ() - aP1.XYZ());
const Standard_Real aSq12 = aP1P2.SquareModulus();
if (aSq12 < gp::Resolution())
continue;
const Standard_Real aDP = aP1P.Dot(aP1P2);
Standard_Real aSqD = RealLast();
if (aDP < 0.0)
{
continue;
}
else if (aDP > aSq12)
{
continue;
}
else
{
aSqD = aP1P.CrossSquareMagnitude(aP1P2) / aSq12;
}
if (aSqD < aMinSqDist)
{
aMinSqDist = aSqD;
const Standard_Real aL1 = aDP / aSq12;
const Standard_Real aL2 = 1.0 - aL1;
if (aL1 < eps || aL2 < eps)
{
return Standard_True;
}
Standard_Real aU1, aV1, aU2, aV2;
aL->Value(aPtIdx).ParametersOnSurface(reversed, aU1, aV1);
aL->Value(aPtIdx + 1).ParametersOnSurface(reversed, aU2, aV2);
aUMin = aL1*aU2 + aL2*aU1;
aVMin = aL1*aV2 + aL2*aV1;
}
}
if (aMinSqDist > Precision::Infinite())
continue;
math_Vector aVecPrms(1, 2);
aVecPrms(1) = aUMin;
aVecPrms(2) = aVMin;
theSolver.Perform(theFunc, aVecPrms, theInfBounds, theSupBounds);
if (!theSolver.IsDone())
continue;
theSolver.Root(aVecPrms);
const gp_Pnt aPa(theFunc.PSurface()->Value(aUMin, aVMin)),
aPb(theFunc.PSurface()->Value(aVecPrms(1), aVecPrms(2)));
const Standard_Real aSqD1 = aPb.SquareDistance(aP3d);
const Standard_Real aSqD2 = aPa.SquareDistance(aPb);
if (aSqD1 < 4.0*aSqD2)
{
return Standard_True;
}
}
return Standard_False;
}