OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-21 10:13:43 +03:00
Code

0022771: An extra vertex produced in result of Boolean section for the cases of closed intersection curves.

Browse Source
This commit is contained in:
PKV 2011-12-16 11:57:49 +00:00 committed by bugmaster
parent 999d2599ea
commit 3928aec6c9
4 changed files with 685 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/BOPTools/BOPTools_PaveFiller.cdl
View File

@ -496,6 +496,18 @@ is
---Purpose: ---Purpose:
--- Try to put 3D-point <aP> (parameter aT) on the curve <aBC> --- Try to put 3D-point <aP> (parameter aT) on the curve <aBC>
--- ---
--modified by NIZNHY-PKV Thu Oct 20 07:17:11 2011f
PutClosingPaveOnCurve (me:out;
aBC :out Curve from BOPTools;
aFF :out SSInterference from BOPTools)
is protected;
---Purpose:
--- Put paves on the curve <aBC> in case when <aBC>
-- is closed 3D-curve
---
--modified by NIZNHY-PKV Thu Oct 20 07:17:11 2011t
FindPave (me:out; FindPave (me:out;
aP :Pnt from gp; aP :Pnt from gp;
aTpV: Real from Standard; aTpV: Real from Standard;
@ -560,13 +572,11 @@ is
RecomputeCommonBlocks(me: in out; nE: Integer from Standard) RecomputeCommonBlocks(me: in out; nE: Integer from Standard)
is private; is private;
--modified by NIZNHY-PKV Tue Oct 19 10:28:42 2004f
ExtendedTolerance(me:out; ExtendedTolerance(me:out;
nV : Integer from Standard; nV : Integer from Standard;
aTolExt : out Real from Standard) aTolExt : out Real from Standard)
returns Boolean from Standard returns Boolean from Standard
is protected; is protected;
--modified by NIZNHY-PKV Tue Oct 19 10:28:44 2004t
fields fields

176
src/BOPTools/BOPTools_PaveFiller_3.cxx
View File

@ -130,7 +130,6 @@ static
BOPTools_PaveFiller& aPF, BOPTools_PaveFiller& aPF,
TColStd_SequenceOfInteger& aSeqVx, TColStd_SequenceOfInteger& aSeqVx,
TColStd_SequenceOfReal& aSeqTolVx); TColStd_SequenceOfReal& aSeqTolVx);
//modified by NIZNHY-PKV Wed Aug 31 10:32:52 2011f
static static
void ProcessAloneStickVertices(const Standard_Integer nF1, void ProcessAloneStickVertices(const Standard_Integer nF1,
const Standard_Integer nF2, const Standard_Integer nF2,
@ -139,7 +138,6 @@ static
BOPTools_PaveFiller& aPF, BOPTools_PaveFiller& aPF,
TColStd_SequenceOfInteger& aSeqVx, TColStd_SequenceOfInteger& aSeqVx,
TColStd_SequenceOfReal& aSeqTolVx); TColStd_SequenceOfReal& aSeqTolVx);
//modified by NIZNHY-PKV Wed Aug 31 10:32:59 2011t
//wkar OCC334 t //wkar OCC334 t
static static
@ -191,13 +189,11 @@ static Standard_Integer RejectBuildingEdge(const IntTools_Curve& theC,
const TopTools_ListOfShape& theL, const TopTools_ListOfShape& theL,
Standard_Real& theTF); Standard_Real& theTF);
//modified by NIZNHY-PKV Sat Mar 05 12:23:05 2011f
static static
void CorrectTolR3D(BOPTools_PaveFiller& aPF, void CorrectTolR3D(BOPTools_PaveFiller& aPF,
const BOPTools_SSInterference& aFF, const BOPTools_SSInterference& aFF,
const TColStd_MapOfInteger& aMVStick, const TColStd_MapOfInteger& aMVStick,
Standard_Real& aTolR3D); Standard_Real& aTolR3D);
//modified by NIZNHY-PKV Sat Mar 05 12:23:07 2011t
//======================================================================= //=======================================================================
// function: PerformFF // function: PerformFF
@ -206,7 +202,7 @@ static
void BOPTools_PaveFiller::PerformFF() void BOPTools_PaveFiller::PerformFF()
{ {
myIsDone=Standard_False; myIsDone=Standard_False;
Standard_Boolean bIsFound; Standard_Boolean bIsFound, bToSplit;
Standard_Integer n1, n2, anIndexIn=0, nF1, nF2, aNbFFs, aBlockLength; Standard_Integer n1, n2, anIndexIn=0, nF1, nF2, aNbFFs, aBlockLength;
BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger aMapWhat, aMapWith; BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger aMapWhat, aMapWith;
// //
@ -222,6 +218,10 @@ static
aFFs.SetBlockLength(aNbFFs); aFFs.SetBlockLength(aNbFFs);
} }
// //
//modified by NIZNHY-PKV Thu Oct 20 07:09:57 2011f
bToSplit=Standard_False;
//modified by NIZNHY-PKV Thu Oct 20 07:09:59 2011t
for (; myDSIt.More(); myDSIt.Next()) { for (; myDSIt.More(); myDSIt.Next()) {
Standard_Boolean justaddinterference = Standard_True; Standard_Boolean justaddinterference = Standard_True;
myDSIt.Current(n1, n2, justaddinterference); myDSIt.Current(n1, n2, justaddinterference);
@ -402,7 +402,10 @@ static
if (aTolR3D < 1.e-7){ if (aTolR3D < 1.e-7){
aTolR3D=1.e-7; aTolR3D=1.e-7;
} }
aFF.PrepareLines3D(); //modified by NIZNHY-PKV Thu Oct 20 07:10:38 2011f
aFF.PrepareLines3D(bToSplit);
//aFF.PrepareLines3D();
//modified by NIZNHY-PKV Thu Oct 20 07:10:41 2011t
// //
anIndexIn=0; anIndexIn=0;
Standard_Integer aNbCurves, aNbPoints; Standard_Integer aNbCurves, aNbPoints;
@ -1360,11 +1363,9 @@ static
aPaveSet.Append(aPaveNew); aPaveSet.Append(aPaveNew);
//<-B //<-B
BOPTools_Tools::UpdateVertex (aC, aT, aV); BOPTools_Tools::UpdateVertex (aC, aT, aV);
//modified by NIZNHY-PKV Sat Mar 05 13:43:27 2011f
if(aTolR3D<aTolTresh) { if(aTolR3D<aTolTresh) {
aBB.UpdateVertex(aV, aTolR3D); aBB.UpdateVertex(aV, aTolR3D);
} }
//modified by NIZNHY-PKV Sat Mar 05 13:43:29 2011t
} }
} }
// //
@ -1455,7 +1456,7 @@ static
BOPTools_PaveSet aPSF; BOPTools_PaveSet aPSF;
PrepareSetForFace (nF1, nF2, aPSF); PrepareSetForFace (nF1, nF2, aPSF);
// //
//modified by NIZNHY-PKV Sat Mar 05 12:12:05 2011f //f
{ {
Standard_Integer nVX; Standard_Integer nVX;
BOPTools_ListIteratorOfListOfPave aItLP; BOPTools_ListIteratorOfListOfPave aItLP;
@ -1471,7 +1472,7 @@ static
// //
CorrectTolR3D(*this, aFFi, aMVStick, aTolR3D); CorrectTolR3D(*this, aFFi, aMVStick, aTolR3D);
} }
//modified by NIZNHY-PKV Sat Mar 05 12:12:07 2011t //t
// //
BOPTools_SequenceOfCurves& aSCvs=aFFi.Curves(); BOPTools_SequenceOfCurves& aSCvs=aFFi.Curves();
aNbCurves=aSCvs.Length(); aNbCurves=aSCvs.Length();
@ -1483,7 +1484,7 @@ static
// //
PutPaveOnCurve (aPSF, aTolR3D, aBC); PutPaveOnCurve (aPSF, aTolR3D, aBC);
} }
//modified by NIZNHY-PKV Tue Aug 30 14:54:50 2011f //f
{ {
Standard_Integer aNbVtx, jx; Standard_Integer aNbVtx, jx;
Standard_Real aTolVRange; Standard_Real aTolVRange;
@ -1519,7 +1520,7 @@ static
} }
} }
} }
//modified by NIZNHY-PKV Tue Aug 30 14:54:56 2011t //t
// //
// Put bounding paves on curves // Put bounding paves on curves
//Check very specific case of cone-cone intersection (OCC13211) //Check very specific case of cone-cone intersection (OCC13211)
@ -1552,14 +1553,23 @@ static
} }
} }
// //
//modified by NIZNHY-PKV Thu Oct 20 07:14:32 2011f
// Put closing pave if needded
for (j=1; j<=aNbCurves; ++j) {
BOPTools_Curve& aBC=aSCvs(j);
PutClosingPaveOnCurve (aBC, aFFi);
}
//modified by NIZNHY-PKV Thu Oct 20 07:14:34 2011t
//
// xxx // xxx
for (j=1; j<=aNbCurves; j++) { for (j=1; j<=aNbCurves; j++) {
BOPTools_Curve& aBC=aSCvs(j); BOPTools_Curve& aBC=aSCvs(j);
BOPTools_ListOfPave anOldList; BOPTools_ListOfPave anOldList;
anOldList = aBC.Set().Set(); anOldList = aBC.Set().Set();
if (aBC.NewPaveBlocks().IsEmpty()) if (aBC.NewPaveBlocks().IsEmpty()) {
continue; continue;
}
// //
BOPTools_CArray1OfESInterference& aESs = myIntrPool->ESInterferences(); BOPTools_CArray1OfESInterference& aESs = myIntrPool->ESInterferences();
@ -1885,7 +1895,7 @@ void ProcessAloneStickVertices(const Standard_Integer nF1,
TColStd_SequenceOfInteger& aSeqVx, TColStd_SequenceOfInteger& aSeqVx,
TColStd_SequenceOfReal& aSeqTolVx) TColStd_SequenceOfReal& aSeqTolVx)
{ {
Standard_Boolean bFound; Standard_Boolean bFound, bIsClosed;
Standard_Integer aNbVtx, jx, nV; Standard_Integer aNbVtx, jx, nV;
Standard_Real aTolVRange; Standard_Real aTolVRange;
TColStd_IndexedMapOfInteger aMapUnUsed; TColStd_IndexedMapOfInteger aMapUnUsed;
@ -1937,8 +1947,15 @@ void ProcessAloneStickVertices(const Standard_Integer nF1,
aNbSCvs=aSCvs.Length(); aNbSCvs=aSCvs.Length();
if (aNbSCvs==1) { if (aNbSCvs==1) {
BOPTools_Curve& aBC=aSCvs(1); BOPTools_Curve& aBC=aSCvs(1);
const IntTools_Curve& aC=aBC.Curve(); const IntTools_Curve& aIC=aBC.Curve();
Handle (Geom_Curve) aC3D= aC.Curve(); Handle (Geom_Curve) aC3D= aIC.Curve();
//modified by NIZNHY-PKV Wed Nov 02 13:33:42 2011f
//
bIsClosed=IntTools_Tools::IsClosed(aC3D);
if (bIsClosed) {
return;
}
//modified by NIZNHY-PKV Wed Nov 02 13:33:44 2011t
GeomAPI_ProjectPointOnCurve& aProjPT=aCtx.ProjPT(aC3D); GeomAPI_ProjectPointOnCurve& aProjPT=aCtx.ProjPT(aC3D);
// //
for (jx=1; jx<=aNbVtx; ++jx) { for (jx=1; jx<=aNbVtx; ++jx) {
@ -1962,7 +1979,6 @@ void ProcessAloneStickVertices(const Standard_Integer nF1,
} }
} }
} }
//modified by NIZNHY-PKV Wed Aug 31 10:29:29 2011f
//======================================================================= //=======================================================================
// function: ProcessAloneStickVertices // function: ProcessAloneStickVertices
// purpose: // purpose:
@ -2061,7 +2077,6 @@ void ProcessAloneStickVertices(const Standard_Integer nF1,
}//for (jVU=1; jVU=aNbVU; ++jVU) { }//for (jVU=1; jVU=aNbVU; ++jVU) {
}//if(aType1==GeomAbs_Torus || aType2==GeomAbs_Torus) { }//if(aType1==GeomAbs_Torus || aType2==GeomAbs_Torus) {
} }
//modified by NIZNHY-PKV Wed Aug 31 10:29:37 2011t
//======================================================================= //=======================================================================
// function: UnUsedMap // function: UnUsedMap
// purpose: // purpose:
@ -3073,33 +3088,69 @@ Standard_Boolean RejectPaveBlock(const IntTools_Curve& theC,
const TopoDS_Vertex& theV, const TopoDS_Vertex& theV,
Standard_Real& theRT) Standard_Real& theRT)
{ {
Standard_Boolean bIsPeriodic, bClosed, isp, c3d;
Standard_Real aPeriod, dt, pf, pl, dp, aTol;
Handle(Geom_Curve) aC;
//
theRT = BRep_Tool::Tolerance(theV); theRT = BRep_Tool::Tolerance(theV);
Handle(Geom_Curve) aC = theC.Curve(); aC = theC.Curve();
//
Standard_Real pf = aC->FirstParameter(); pf = aC->FirstParameter();
Standard_Real pl = aC->LastParameter(); pl = aC->LastParameter();
Standard_Real dp = fabs(pl-pf); dp = fabs(pl-pf);
aTol=1.e-9;
bIsPeriodic=aC->IsPeriodic();
bClosed=IntTools_Tools::IsClosed(aC);
//
isp=Standard_False;
if (bIsPeriodic) {
aPeriod=aC->Period();
isp=(fabs(aPeriod-dp) <= aTol);
dt = fabs(theT2-theT1);
isp = (isp || fabs(aPeriod-dt) <= aTol);
}
c3d=(bClosed || isp);
//
/*
Standard_Boolean isp = (aC->IsPeriodic() && fabs(aC->Period()-dp) <= 1.e-9); Standard_Boolean isp = (aC->IsPeriodic() && fabs(aC->Period()-dp) <= 1.e-9);
Standard_Real dt = fabs(theT2-theT1); Standard_Real dt = fabs(theT2-theT1);
isp = (isp || (aC->IsPeriodic() && fabs(aC->Period()-dt) <= 1.e-9)); isp = (isp || (aC->IsPeriodic() && fabs(aC->Period()-dt) <= 1.e-9));
Standard_Boolean c3d = (aC->IsClosed() || isp); Standard_Boolean c3d = (aC->IsClosed() || isp);
*/
if(c3d) if(c3d) {
return Standard_False; return !c3d;
}
Standard_Real p1 = Max(pf,theT1); //
Standard_Real p2 = Min(pl,theT2); Standard_Real p1, p2, tp, d3d2, aRT2;;
//
p1 = Max(pf,theT1);
p2 = Min(pl,theT2);
if(p2 != p1) { if(p2 != p1) {
if(p2 < p1) { if(p2 < p1) {
Standard_Real tp = p1; p1 = p2; p2 = tp; tp = p1;
p1 = p2;
p2 = tp;
} }
gp_Pnt pntf, pntl; gp_Pnt pntf, pntl;
aC->D0(p1,pntf); aC->D0(p1,pntf);
aC->D0(p2,pntl); aC->D0(p2,pntl);
//
//modified by NIZNHY-PKV Thu Oct 20 09:13:45 2011f
//
aRT2=theRT*theRT;
d3d2 = pntf.SquareDistance(pntl);
if(d3d2 > aRT2) {
theRT=sqrt(d3d2);
}
//
/*
Standard_Real d3d = pntf.Distance(pntl); Standard_Real d3d = pntf.Distance(pntl);
if(d3d > theRT) if(d3d > theRT) {
theRT = d3d; theRT = d3d;
} }
*/
//modified by NIZNHY-PKV Thu Oct 20 09:15:20 2011t
}
return Standard_True; return Standard_True;
} }
@ -3328,3 +3379,66 @@ void CorrectTolR3D(BOPTools_PaveFiller& aPF,
aTolR3D=aTolR; aTolR3D=aTolR;
} }
} }
//modified by NIZNHY-PKV Thu Oct 20 07:18:39 2011f
//=======================================================================
// function: PutClosingPaveOnCurve
// purpose:
//=======================================================================
void BOPTools_PaveFiller::PutClosingPaveOnCurve(BOPTools_Curve& aBC,
BOPTools_SSInterference& aFFi)
{
Standard_Boolean bIsClosed, bHasBounds, bAdded;
Standard_Integer nVC, j;
Standard_Real aT[2], aTolR3D, aTC, dT, aTx;
gp_Pnt aP[2] ;
BOPTools_Pave aPVx;
BOPTools_ListIteratorOfListOfPave aItLP;
//
const IntTools_Curve& aIC=aBC.Curve();
const Handle (Geom_Curve)& aC3D=aIC.Curve();
if(aC3D.IsNull()) {
return;
}
//
bIsClosed=IntTools_Tools::IsClosed(aC3D);
if (!bIsClosed) {
return;
}
//
bHasBounds=aIC.HasBounds ();
if (!bHasBounds){
return;
}
//
bAdded=Standard_False;
dT=Precision::PConfusion();
aTolR3D=aFFi.TolR3D();
aIC.Bounds (aT[0], aT[1], aP[0], aP[1]);
//
BOPTools_PaveSet& aFFiPS=aFFi.NewPaveSet();
BOPTools_PaveSet& aCPS=aBC.Set();
//
const BOPTools_ListOfPave& aLP=aCPS.Set();
aItLP.Initialize(aLP);
for (; aItLP.More() && !bAdded; aItLP.Next()) {
const BOPTools_Pave& aPC=aItLP.Value();
nVC=aPC.Index();
const TopoDS_Vertex aVC=TopoDS::Vertex(myDS->Shape(nVC));
aTC=aPC.Param();
//
for (j=0; j<2; ++j) {
if (fabs(aTC-aT[j]) < dT) {
aTx=(!j) ? aT[1] : aT[0];
aPVx.SetIndex(nVC);
aPVx.SetParam(aTx);
//
aCPS.Append(aPVx);
aFFiPS.Append(aPVx);
//
bAdded=Standard_True;
break;
}
}
}
}
//modified by NIZNHY-PKV Thu Oct 20 07:18:42 2011t

21
src/IntTools/IntTools_FaceFace.cxx
View File

@ -2709,16 +2709,25 @@ Standard_Boolean IsDegeneratedZone(const gp_Pnt2d& aP2d,
// of the points is less than 2. // of the points is less than 2.
//========================================================================= //=========================================================================
Handle(IntPatch_WLine) ComputePurgedWLine(const Handle(IntPatch_WLine)& theWLine) { Handle(IntPatch_WLine) ComputePurgedWLine(const Handle(IntPatch_WLine)& theWLine) {
Handle(IntPatch_WLine) aResult;
Handle(IntPatch_WLine) aLocalWLine;
Handle(IntPatch_WLine) aTmpWLine = theWLine;
Handle(IntSurf_LineOn2S) aLineOn2S = new IntSurf_LineOn2S(); //modified by NIZNHY-PKV Tue Nov 29 12:14:07 2011f
aLocalWLine = new IntPatch_WLine(aLineOn2S, Standard_False);
Standard_Integer i, k, v, nb, nbvtx; Standard_Integer i, k, v, nb, nbvtx;
Handle(IntPatch_WLine) aResult;
nbvtx = theWLine->NbVertex(); nbvtx = theWLine->NbVertex();
nb = theWLine->NbPnts(); nb = theWLine->NbPnts();
if (nb==2) {
const IntSurf_PntOn2S& p1 = theWLine->Point(1);
const IntSurf_PntOn2S& p2 = theWLine->Point(2);
if(p1.Value().IsEqual(p2.Value(), gp::Resolution())) {
return aResult;
}
}
//
Handle(IntPatch_WLine) aLocalWLine;
Handle(IntPatch_WLine) aTmpWLine = theWLine;
Handle(IntSurf_LineOn2S) aLineOn2S = new IntSurf_LineOn2S();
aLocalWLine = new IntPatch_WLine(aLineOn2S, Standard_False);
//modified by NIZNHY-PKV Tue Nov 29 12:13:19 2011t
for(i = 1; i <= nb; i++) { for(i = 1; i <= nb; i++) {
aLineOn2S->Add(theWLine->Point(i)); aLineOn2S->Add(theWLine->Point(i));
} }

747
src/IntTools/IntTools_LineConstructor.cxx
View File

@ -32,130 +32,32 @@
// //
#include <TColStd_IndexedMapOfInteger.hxx> #include <TColStd_IndexedMapOfInteger.hxx>
static
//======================================================================= void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
//function : Recadre const gp_Pnt& Ptref,
//purpose : Standard_Real& U1,
//======================================================================= Standard_Real& V1);
static void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1, static
const Handle(GeomAdaptor_HSurface)& myHS2, void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
Standard_Real& u1,
Standard_Real& v1,
Standard_Real& u2,
Standard_Real& v2)
{
Standard_Boolean myHS1IsUPeriodic,myHS1IsVPeriodic;
const GeomAbs_SurfaceType typs1 = myHS1->GetType();
switch (typs1)
{
case GeomAbs_Cylinder:
case GeomAbs_Cone:
case GeomAbs_Sphere:
{
myHS1IsUPeriodic = Standard_True;
myHS1IsVPeriodic = Standard_False;
break;
}
case GeomAbs_Torus:
{
myHS1IsUPeriodic = myHS1IsVPeriodic = Standard_True;
break;
}
default:
{
//-- Case of periodic biparameters is processed upstream
myHS1IsUPeriodic = myHS1IsVPeriodic = Standard_False;
break;
}
}
Standard_Boolean myHS2IsUPeriodic,myHS2IsVPeriodic;
const GeomAbs_SurfaceType typs2 = myHS2->GetType();
switch (typs2)
{
case GeomAbs_Cylinder:
case GeomAbs_Cone:
case GeomAbs_Sphere:
{
myHS2IsUPeriodic = Standard_True;
myHS2IsVPeriodic = Standard_False;
break;
}
case GeomAbs_Torus:
{
myHS2IsUPeriodic = myHS2IsVPeriodic = Standard_True;
break;
}
default:
{
//-- Case of periodic biparameters is processed upstream
myHS2IsUPeriodic = myHS2IsVPeriodic = Standard_False;
break;
}
}
if(myHS1IsUPeriodic) {
const Standard_Real lmf = M_PI+M_PI; //-- myHS1->UPeriod();
const Standard_Real f = myHS1->FirstUParameter();
const Standard_Real l = myHS1->LastUParameter();
while(u1 < f) { u1+=lmf; }
while(u1 > l) { u1-=lmf; }
}
if(myHS1IsVPeriodic) {
const Standard_Real lmf = M_PI+M_PI; //-- myHS1->VPeriod();
const Standard_Real f = myHS1->FirstVParameter();
const Standard_Real l = myHS1->LastVParameter();
while(v1 < f) { v1+=lmf; }
while(v1 > l) { v1-=lmf; }
}
if(myHS2IsUPeriodic) {
const Standard_Real lmf = M_PI+M_PI; //-- myHS2->UPeriod();
const Standard_Real f = myHS2->FirstUParameter();
const Standard_Real l = myHS2->LastUParameter();
while(u2 < f) { u2+=lmf; }
while(u2 > l) { u2-=lmf; }
}
if(myHS2IsVPeriodic) {
const Standard_Real lmf = M_PI+M_PI; //-- myHS2->VPeriod();
const Standard_Real f = myHS2->FirstVParameter();
const Standard_Real l = myHS2->LastVParameter();
while(v2 < f) { v2+=lmf; }
while(v2 > l) { v2-=lmf; }
}
}
//=======================================================================
//function : Parameters
//purpose :
//=======================================================================
static void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
const Handle(GeomAdaptor_HSurface)& myHS2, const Handle(GeomAdaptor_HSurface)& myHS2,
const gp_Pnt& Ptref, const gp_Pnt& Ptref,
Standard_Real& U1, Standard_Real& U1,
Standard_Real& V1, Standard_Real& V1,
Standard_Real& U2, Standard_Real& U2,
Standard_Real& V2) Standard_Real& V2);
{
IntSurf_Quadric quad1,quad2;
switch (myHS1->Surface().GetType())
{
case GeomAbs_Plane: quad1.SetValue(myHS1->Surface().Plane()); break;
case GeomAbs_Cylinder: quad1.SetValue(myHS1->Surface().Cylinder()); break;
case GeomAbs_Cone: quad1.SetValue(myHS1->Surface().Cone()); break;
case GeomAbs_Sphere: quad1.SetValue(myHS1->Surface().Sphere()); break;
default: Standard_ConstructionError::Raise("IntTools_LineConstructor::Parameters");
}
switch (myHS2->Surface().GetType())
{
case GeomAbs_Plane: quad2.SetValue(myHS2->Surface().Plane()); break;
case GeomAbs_Cylinder: quad2.SetValue(myHS2->Surface().Cylinder()); break;
case GeomAbs_Cone: quad2.SetValue(myHS2->Surface().Cone()); break;
case GeomAbs_Sphere: quad2.SetValue(myHS2->Surface().Sphere()); break;
default: Standard_ConstructionError::Raise("IntTools_LineConstructor::Parameters");
}
quad1.Parameters(Ptref,U1,V1);
quad2.Parameters(Ptref,U2,V2);
}
static
void GLinePoint(const IntPatch_IType typl,
const Handle(IntPatch_GLine)& GLine,
const Standard_Real aT,
gp_Pnt& aP);
static
void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
const Handle(GeomAdaptor_HSurface)& myHS2,
Standard_Real& u1,
Standard_Real& v1,
Standard_Real& u2,
Standard_Real& v2);
//======================================================================= //=======================================================================
//function : Perform //function : Perform
@ -168,18 +70,15 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
const Standard_Real Tol = Precision::PConfusion() * 35.0; const Standard_Real Tol = Precision::PConfusion() * 35.0;
const IntPatch_IType typl = L->ArcType(); const IntPatch_IType typl = L->ArcType();
if(typl == IntPatch_Analytic) if(typl == IntPatch_Analytic) {
{
Standard_Real u1,v1,u2,v2; Standard_Real u1,v1,u2,v2;
Handle(IntPatch_ALine)& ALine = *((Handle(IntPatch_ALine) *)&L); Handle(IntPatch_ALine)& ALine = *((Handle(IntPatch_ALine) *)&L);
seqp.Clear(); seqp.Clear();
nbvtx = GeomInt_LineTool::NbVertex(L); nbvtx = GeomInt_LineTool::NbVertex(L);
for(i=1;i<nbvtx;i++) for(i=1;i<nbvtx;i++) {
{
firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine(); firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
lastp = GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine(); lastp = GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
if(firstp!=lastp) if(firstp!=lastp) {
{
const Standard_Real pmid = (firstp+lastp)*0.5; const Standard_Real pmid = (firstp+lastp)*0.5;
const gp_Pnt Pmid = ALine->Value(pmid); const gp_Pnt Pmid = ALine->Value(pmid);
Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2); Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
@ -196,21 +95,17 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
} }
done = Standard_True; done = Standard_True;
return; return;
} } // if(typl == IntPatch_Analytic) {
else if(typl == IntPatch_Walking) else if(typl == IntPatch_Walking) {
{
Standard_Real u1,v1,u2,v2; Standard_Real u1,v1,u2,v2;
Handle(IntPatch_WLine)& WLine = *((Handle(IntPatch_WLine) *)&L); Handle(IntPatch_WLine)& WLine = *((Handle(IntPatch_WLine) *)&L);
seqp.Clear(); seqp.Clear();
nbvtx = GeomInt_LineTool::NbVertex(L); nbvtx = GeomInt_LineTool::NbVertex(L);
for(i=1;i<nbvtx;i++) for(i=1;i<nbvtx;i++) {
{
firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine(); firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
lastp = GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine(); lastp = GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
if(firstp!=lastp) if(firstp!=lastp) {
{ if(lastp != firstp+1) {
if(lastp != firstp+1)
{
const Standard_Integer pmid = (Standard_Integer )( (firstp+lastp)/2); const Standard_Integer pmid = (Standard_Integer )( (firstp+lastp)/2);
const IntSurf_PntOn2S& Pmid = WLine->Point(pmid); const IntSurf_PntOn2S& Pmid = WLine->Point(pmid);
Pmid.Parameters(u1,v1,u2,v2); Pmid.Parameters(u1,v1,u2,v2);
@ -224,8 +119,7 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
} }
} }
} }
else else {
{
const IntSurf_PntOn2S& Pfirst = WLine->Point((Standard_Integer)(firstp)); const IntSurf_PntOn2S& Pfirst = WLine->Point((Standard_Integer)(firstp));
Pfirst.Parameters(u1,v1,u2,v2); Pfirst.Parameters(u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2); Recadre(myHS1,myHS2,u1,v1,u2,v2);
@ -246,12 +140,9 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
} }
} }
} }
} }
} }
} }
//XX
// 904/L7
// //
// The One resulting curve consists of 7 segments that are // The One resulting curve consists of 7 segments that are
// connected between each other. // connected between each other.
@ -261,16 +152,34 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
// Why -? It is not known yet. // Why -? It is not known yet.
// PKV 22.Apr.2002 // PKV 22.Apr.2002
// //
const GeomAbs_SurfaceType aST1 = myHS1->Surface().GetType(); Standard_Integer aNbParts;
const GeomAbs_SurfaceType aST2 = myHS2->Surface().GetType(); //
if ((aST1==GeomAbs_Plane && aST2==GeomAbs_SurfaceOfExtrusion) || aNbParts = seqp.Length()/2;
(aST2==GeomAbs_Plane && aST1==GeomAbs_SurfaceOfExtrusion)) if (aNbParts > 1) {
{ Standard_Boolean bCond;
GeomAbs_SurfaceType aST1, aST2;
aST1 = myHS1->Surface().GetType();
aST2 = myHS2->Surface().GetType();
//
bCond=Standard_False;
if (aST1==GeomAbs_Plane) {
if (aST2==GeomAbs_SurfaceOfExtrusion ||
aST2==GeomAbs_SurfaceOfRevolution) {//+zft
bCond=!bCond;
}
}
else if (aST2==GeomAbs_Plane) {
if (aST1==GeomAbs_SurfaceOfExtrusion ||
aST1==GeomAbs_SurfaceOfRevolution) {//+zft
bCond=!bCond;
}
}
//
if (bCond) {
Standard_Integer aNb, anIndex, aNbTmp, jx;
TColStd_IndexedMapOfInteger aMap; TColStd_IndexedMapOfInteger aMap;
TColStd_SequenceOfReal aSeqTmp; TColStd_SequenceOfReal aSeqTmp;
//
Standard_Integer aNb, anIndex, aNbTmp, jx;
aNb=seqp.Length(); aNb=seqp.Length();
for(i=1; i<=aNb; ++i) { for(i=1; i<=aNb; ++i) {
lastp =seqp(i); lastp =seqp(i);
@ -295,35 +204,84 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
seqp.Append(firstp); seqp.Append(firstp);
seqp.Append(lastp); seqp.Append(lastp);
} }
}//if (bCond) {
} }
////XX done = Standard_True;
return;
}// else if(typl == IntPatch_Walking) {
//
else if (typl != IntPatch_Restriction) {
Standard_Boolean intrvtested;
Standard_Real u1,v1,u2,v2;
//
seqp.Clear();
//
Handle(IntPatch_GLine)& GLine = *((Handle(IntPatch_GLine) *)&L);
// reject micro circles, ellipses
switch (typl) {
case IntPatch_Circle: {
Standard_Real aR;
gp_Circ aCirc;
//
aCirc=GLine->Circle();
aR=aCirc.Radius();
if (aR<Tol) {
done = Standard_True; done = Standard_True;
return; return;
} }
else if (typl != IntPatch_Restriction) break;
{ }
Standard_Real u1,v1,u2,v2; case IntPatch_Ellipse: {
Handle(IntPatch_GLine)& GLine = *((Handle(IntPatch_GLine) *)&L); Standard_Real aR;
seqp.Clear(); gp_Elips aEllipse;
//
aEllipse=GLine->Ellipse();
aR=aEllipse.MajorRadius();
if (aR<Tol) {
done = Standard_True;
return;
}
break;
}
default:
break;
}
//modified by NIZNHY-PKV Wed Nov 02 11:50:23 2011t
//
nbvtx = GeomInt_LineTool::NbVertex(L); nbvtx = GeomInt_LineTool::NbVertex(L);
Standard_Boolean intrvtested = Standard_False; intrvtested = Standard_False;
for(i=1;i<nbvtx;i++) for(i=1; i<nbvtx; ++i) {
{
firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine(); firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
lastp = GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine(); lastp = GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
if(Abs(firstp-lastp)>Precision::PConfusion()) if(Abs(firstp-lastp)>Precision::PConfusion()) {
{
intrvtested = Standard_True; intrvtested = Standard_True;
const Standard_Real pmid = (firstp+lastp)*0.5; const Standard_Real pmid = (firstp+lastp)*0.5;
gp_Pnt Pmid; gp_Pnt Pmid;
switch (typl) //modified by NIZNHY-PKV Fri Nov 11 10:27:01 2011f
{ GLinePoint(typl, GLine, pmid, Pmid);
case IntPatch_Lin: Pmid = ElCLib::Value(pmid,GLine->Line()); break; /*
case IntPatch_Circle: Pmid = ElCLib::Value(pmid,GLine->Circle()); break; switch (typl) {
case IntPatch_Ellipse: Pmid = ElCLib::Value(pmid,GLine->Ellipse()); break; case IntPatch_Lin:
case IntPatch_Hyperbola: Pmid = ElCLib::Value(pmid,GLine->Hyperbola()); break; Pmid = ElCLib::Value(pmid,GLine->Line());
case IntPatch_Parabola: Pmid = ElCLib::Value(pmid,GLine->Parabola()); break; break;
case IntPatch_Circle:
Pmid = ElCLib::Value(pmid,GLine->Circle());
break;
case IntPatch_Ellipse:
Pmid = ElCLib::Value(pmid,GLine->Ellipse());
break;
case IntPatch_Hyperbola:
Pmid = ElCLib::Value(pmid,GLine->Hyperbola());
break;
case IntPatch_Parabola:
Pmid = ElCLib::Value(pmid,GLine->Parabola());
break;
default:
break;
} }
*/
//modified by NIZNHY-PKV Fri Nov 11 12:25:40 2011t
//
Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2); Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2); Recadre(myHS1,myHS2,u1,v1,u2,v2);
const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol); const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
@ -336,27 +294,30 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
} }
} }
} }
//
if(typl == IntPatch_Circle || typl == IntPatch_Ellipse) if(typl == IntPatch_Circle || typl == IntPatch_Ellipse) {
{
firstp = GeomInt_LineTool::Vertex(L,nbvtx).ParameterOnLine(); firstp = GeomInt_LineTool::Vertex(L,nbvtx).ParameterOnLine();
lastp = M_PI + M_PI + GeomInt_LineTool::Vertex(L,1).ParameterOnLine(); lastp = M_PI + M_PI + GeomInt_LineTool::Vertex(L,1).ParameterOnLine();
const Standard_Real cadrinf = GeomInt_LineTool::FirstParameter(L); const Standard_Real cadrinf = GeomInt_LineTool::FirstParameter(L);
const Standard_Real cadrsup = GeomInt_LineTool::LastParameter(L); const Standard_Real cadrsup = GeomInt_LineTool::LastParameter(L);
Standard_Real acadr = (firstp+lastp)*0.5; Standard_Real acadr = (firstp+lastp)*0.5;
while(acadr < cadrinf) { acadr+=M_PI+M_PI; } while(acadr < cadrinf) {
while(acadr > cadrsup) { acadr-=M_PI+M_PI; } acadr+=M_PI+M_PI;
if(acadr>=cadrinf && acadr<=cadrsup) }
{ while(acadr > cadrsup) {
if(Abs(firstp-lastp)>Precision::PConfusion()) acadr-=M_PI+M_PI;
{ }
if(acadr>=cadrinf && acadr<=cadrsup) {
if(Abs(firstp-lastp)>Precision::PConfusion()) {
intrvtested = Standard_True; intrvtested = Standard_True;
const Standard_Real pmid = (firstp+lastp)*0.5; const Standard_Real pmid = (firstp+lastp)*0.5;
gp_Pnt Pmid; gp_Pnt Pmid;
if (typl == IntPatch_Circle) if (typl == IntPatch_Circle) {
Pmid = ElCLib::Value(pmid,GLine->Circle()); Pmid = ElCLib::Value(pmid,GLine->Circle());
else }
else {
Pmid = ElCLib::Value(pmid,GLine->Ellipse()); Pmid = ElCLib::Value(pmid,GLine->Ellipse());
}
Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2); Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2); Recadre(myHS1,myHS2,u1,v1,u2,v2);
const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol); const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
@ -377,47 +338,104 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
seqp.Append(GeomInt_LineTool::LastParameter(L)); seqp.Append(GeomInt_LineTool::LastParameter(L));
} }
// //
//modified by NIZNHY-PKV Mon Jan 21 17:02:12 2002 f // Treatment Circles/Ellipses that are the results of intersection
// between Plane / (Cylinder, Sphere).
// In these cases the intersection curves can contain
// a lot of 'vertices' on the curve that leads to a lot of parts
// of the curve. Some adjacent parts can be united to the one part.
// //
// Unite neighbouring intervals if it's possible. Standard_Integer aNbParts;
// It is valid when 3D intersection curve does not go through
// the apex on surface. So for the moment we take into account
// Plane and Cylinder - surfaces that do not contain an apex.
// by NIZNHY-PKV Tue Jan 22 14:00:51 2002
const GeomAbs_SurfaceType aST1 = myHS1->Surface().GetType();
const GeomAbs_SurfaceType aST2 = myHS2->Surface().GetType();
if ((aST1==GeomAbs_Plane || aST1==GeomAbs_Cylinder) &&
(aST2==GeomAbs_Plane || aST2==GeomAbs_Cylinder))
{
if(typl == IntPatch_Circle || typl == IntPatch_Ellipse)
{
Standard_Integer aNbParts = seqp.Length()/2;
// //
if (aNbParts > 1) aNbParts = seqp.Length()/2;
{ if (aNbParts > 1 && (typl == IntPatch_Circle || typl == IntPatch_Ellipse)) {
Standard_Integer j, i2, j2; Standard_Boolean bCond, bPCS, bPCS1, bPCS2, bCC;
Standard_Real aFi = seqp(1), aLi, aFj, aLj, aF, aL; GeomAbs_SurfaceType aST1, aST2;
//
aST1 = myHS1->Surface().GetType();
aST2 = myHS2->Surface().GetType();
//
bPCS1=((aST1==GeomAbs_Plane) && (aST2==GeomAbs_Cylinder || aST2==GeomAbs_Sphere));
bPCS2=((aST2==GeomAbs_Plane) && (aST1==GeomAbs_Cylinder || aST1==GeomAbs_Sphere));
bPCS=(bPCS1 || bPCS2);
bCC=(aST1==GeomAbs_Cylinder && aST2==GeomAbs_Cylinder);
//
// ZZ
//modified by NIZNHY-PKV Fri Nov 11 10:13:58 2011f
Standard_Integer j, i1, i2;
Standard_Real aT, aU, aV;
Handle(GeomAdaptor_HSurface) aHS;
//
bCond=Standard_False;
//
if (bCC) {
bCond=Standard_True;
}
else if (bPCS) {
if ((aST1==GeomAbs_Sphere) || (aST2==GeomAbs_Sphere)) {
if (aST1==GeomAbs_Sphere) {
aHS=myHS1;
}
else if (aST2==GeomAbs_Sphere){
aHS=myHS2;
}
//
Standard_Integer aNbP;
Standard_Real aHalfPI, aPPC;
//
bCond=Standard_True;
//
aNbP=seqp.Length();
aPPC=Precision::PConfusion();
aHalfPI=0.5*PI;
i1=0;
i2=0;
//
for (i=1; i<=aNbP; ++i) {
gp_Pnt aP;
//
aT=seqp(i);
GLinePoint(typl, GLine, aT, aP);
Parameters(aHS, aP, aU, aV);
if (aV<0.) {
if (fabs(aV+aHalfPI) < aPPC) {
++i2;
}
}
else {
if (fabs(aV-aHalfPI) < aPPC) {
++i1;
}
}
}
if (i1==2 || i2==2) {
bCond=Standard_False;
}
}
}// else if (bPCS1 || bPCS2) {
//modified by NIZNHY-PKV Fri Nov 11 10:14:00 2011t
//
if (bCond){
Standard_Integer i2, j2;
Standard_Real aFi, aLi, aFj, aLj, aF, aL;
TColStd_SequenceOfReal aSeq; TColStd_SequenceOfReal aSeq;
//
aFi=seqp(1);
aSeq.Append(aFi); aSeq.Append(aFi);
for (i=1; i<aNbParts; ++i) for (i=1; i<aNbParts; ++i) {
{
j=i+1; j=i+1;
i2=2*i; i2=2*i;
j2=2*j; j2=2*j;
//
aFi=seqp(i2-1); aFi=seqp(i2-1);
aLi=seqp(i2); aLi=seqp(i2);
//
aFj=seqp(j2-1); aFj=seqp(j2-1);
aLj=seqp(j2); aLj=seqp(j2);
//
if (fabs (aFj-aLi) < Tol) if (fabs (aFj-aLi) < Tol) {
{
aL=aLj; aL=aLj;
} }
else else {
{
aL=aLi; aL=aLi;
aSeq.Append(aL); aSeq.Append(aL);
aF=aFj; aF=aFj;
@ -428,19 +446,16 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
// //
seqp.Clear(); seqp.Clear();
aNbParts=aSeq.Length(); aNbParts=aSeq.Length();
for (i=1; i<=aNbParts; ++i) for (i=1; i<=aNbParts; ++i) {
{
aF=aSeq(i); aF=aSeq(i);
seqp.Append(aF); seqp.Append(aF);
} }
} }
} }
}
//modified by NIZNHY-PKV Mon Jan 21 17:02:17 2002 t
// //
done =Standard_True; done =Standard_True;
return; return;
} }// else if (typl != IntPatch_Restriction) {
done = Standard_False; done = Standard_False;
seqp.Clear(); seqp.Clear();
@ -456,42 +471,37 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
GeomInt_SequenceOfParameterAndOrientation seqpss; GeomInt_SequenceOfParameterAndOrientation seqpss;
TopAbs_Orientation or1=TopAbs_FORWARD,or2=TopAbs_FORWARD; TopAbs_Orientation or1=TopAbs_FORWARD,or2=TopAbs_FORWARD;
for (i=1; i<=nbvtx; i++) for (i=1; i<=nbvtx; i++) {
{
const IntPatch_Point& thevtx = GeomInt_LineTool::Vertex(L,i); const IntPatch_Point& thevtx = GeomInt_LineTool::Vertex(L,i);
const Standard_Real prm = thevtx.ParameterOnLine(); const Standard_Real prm = thevtx.ParameterOnLine();
if (thevtx.IsOnDomS1()) if (thevtx.IsOnDomS1()) {
{ switch (thevtx.TransitionLineArc1().TransitionType()) {
switch (thevtx.TransitionLineArc1().TransitionType())
{
case IntSurf_In: or1 = TopAbs_FORWARD; break; case IntSurf_In: or1 = TopAbs_FORWARD; break;
case IntSurf_Out: or1 = TopAbs_REVERSED; break; case IntSurf_Out: or1 = TopAbs_REVERSED; break;
case IntSurf_Touch: or1 = TopAbs_INTERNAL; break; case IntSurf_Touch: or1 = TopAbs_INTERNAL; break;
case IntSurf_Undecided: or1 = TopAbs_INTERNAL; break; case IntSurf_Undecided: or1 = TopAbs_INTERNAL; break;
} }
} }
else else {
or1 = TopAbs_INTERNAL; or1 = TopAbs_INTERNAL;
}
if (thevtx.IsOnDomS2()) if (thevtx.IsOnDomS2()) {
{ switch (thevtx.TransitionLineArc2().TransitionType()) {
switch (thevtx.TransitionLineArc2().TransitionType())
{
case IntSurf_In: or2 = TopAbs_FORWARD; break; case IntSurf_In: or2 = TopAbs_FORWARD; break;
case IntSurf_Out: or2 = TopAbs_REVERSED; break; case IntSurf_Out: or2 = TopAbs_REVERSED; break;
case IntSurf_Touch: or2 = TopAbs_INTERNAL; break; case IntSurf_Touch: or2 = TopAbs_INTERNAL; break;
case IntSurf_Undecided: or2 = TopAbs_INTERNAL; break; case IntSurf_Undecided: or2 = TopAbs_INTERNAL; break;
} }
} }
else else {
or2 = TopAbs_INTERNAL; or2 = TopAbs_INTERNAL;
}
//
const Standard_Integer nbinserted = seqpss.Length(); const Standard_Integer nbinserted = seqpss.Length();
Standard_Boolean inserted = Standard_False; Standard_Boolean inserted = Standard_False;
for (Standard_Integer j=1; j<=nbinserted;j++) for (Standard_Integer j=1; j<=nbinserted;j++) {
{ if (Abs(prm-seqpss(j).Parameter()) <= Tol) {
if (Abs(prm-seqpss(j).Parameter()) <= Tol)
{
// accumulate // accumulate
GeomInt_ParameterAndOrientation& valj = seqpss.ChangeValue(j); GeomInt_ParameterAndOrientation& valj = seqpss.ChangeValue(j);
if (or1 != TopAbs_INTERNAL) { if (or1 != TopAbs_INTERNAL) {
@ -538,24 +548,19 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
Standard_Boolean dansS2 = Standard_False; Standard_Boolean dansS2 = Standard_False;
nbvtx = seqpss.Length(); nbvtx = seqpss.Length();
for (i=1; i<= nbvtx; i++) for (i=1; i<= nbvtx; i++) {
{
or1 = seqpss(i).Orientation1(); or1 = seqpss(i).Orientation1();
if (or1 != TopAbs_INTERNAL) if (or1 != TopAbs_INTERNAL) {
{
trim = Standard_True; trim = Standard_True;
dansS1 = (or1 != TopAbs_FORWARD); dansS1 = (or1 != TopAbs_FORWARD);
break; break;
} }
} }
if (i > nbvtx) if (i > nbvtx) {
{
Standard_Real U,V; Standard_Real U,V;
for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ ) for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ ) {
{ if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS1() ) {
if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS1() )
{
GeomInt_LineTool::Vertex(L,i).ParametersOnS1(U,V); GeomInt_LineTool::Vertex(L,i).ParametersOnS1(U,V);
gp_Pnt2d PPCC(U,V); gp_Pnt2d PPCC(U,V);
if (myDom1->Classify(PPCC,Tol) == TopAbs_OUT) { if (myDom1->Classify(PPCC,Tol) == TopAbs_OUT) {
@ -567,25 +572,20 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
} }
dansS1 = Standard_True; // Keep in doubt dansS1 = Standard_True; // Keep in doubt
} }
//
for (i=1; i<= nbvtx; i++) for (i=1; i<= nbvtx; i++) {
{
or2 = seqpss(i).Orientation2(); or2 = seqpss(i).Orientation2();
if (or2 != TopAbs_INTERNAL) if (or2 != TopAbs_INTERNAL) {
{
trim = Standard_True; trim = Standard_True;
dansS2 = (or2 != TopAbs_FORWARD); dansS2 = (or2 != TopAbs_FORWARD);
break; break;
} }
} }
if (i > nbvtx) if (i > nbvtx) {
{
Standard_Real U,V; Standard_Real U,V;
for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ ) for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ ) {
{ if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS2() ) {
if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS2() )
{
GeomInt_LineTool::Vertex(L,i).ParametersOnS2(U,V); GeomInt_LineTool::Vertex(L,i).ParametersOnS2(U,V);
if (myDom2->Classify(gp_Pnt2d(U,V),Tol) == TopAbs_OUT) { if (myDom2->Classify(gp_Pnt2d(U,V),Tol) == TopAbs_OUT) {
done = Standard_True; done = Standard_True;
@ -606,27 +606,22 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
// sequence seqpss is peeled to create valid ends // sequence seqpss is peeled to create valid ends
// and store them in seqp(2*i+1) and seqp(2*i+2) // and store them in seqp(2*i+1) and seqp(2*i+2)
Standard_Real thefirst = GeomInt_LineTool::FirstParameter(L); Standard_Real thefirst = GeomInt_LineTool::FirstParameter(L);
Standard_Real thelast = GeomInt_LineTool::LastParameter(L); Standard_Real thelast = GeomInt_LineTool::LastParameter(L);
firstp = thefirst; firstp = thefirst;
for (i=1; i<=nbvtx; i++) for (i=1; i<=nbvtx; i++) {
{
or1 = seqpss(i).Orientation1(); or1 = seqpss(i).Orientation1();
or2 = seqpss(i).Orientation2(); or2 = seqpss(i).Orientation2();
if (dansS1 && dansS2) if (dansS1 && dansS2) {
{ if (or1 == TopAbs_REVERSED){
if (or1 == TopAbs_REVERSED)
dansS1 = Standard_False; dansS1 = Standard_False;
/*else if (or1 == TopAbs_FORWARD) { }
}*/
if (or2 == TopAbs_REVERSED) if (or2 == TopAbs_REVERSED){
dansS2 = Standard_False; dansS2 = Standard_False;
/*else if (or2 == TopAbs_FORWARD) { }
}*/ if (!dansS1 || !dansS2) {
if (!dansS1 || !dansS2)
{
lastp = seqpss(i).Parameter(); lastp = seqpss(i).Parameter();
Standard_Real stofirst = Max(firstp, thefirst); Standard_Real stofirst = Max(firstp, thefirst);
Standard_Real stolast = Min(lastp, thelast) ; Standard_Real stolast = Min(lastp, thelast) ;
@ -635,48 +630,40 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
seqp.Append(stofirst); seqp.Append(stofirst);
seqp.Append(stolast); seqp.Append(stolast);
} }
if (lastp > thelast) if (lastp > thelast) {
break; break;
} }
} }
else }
{ else {
if (dansS1) if (dansS1) {
{ if (or1 == TopAbs_REVERSED) {
if (or1 == TopAbs_REVERSED)
dansS1 = Standard_False; dansS1 = Standard_False;
/*else if (or1 == TopAbs_FORWARD) {
}*/
} }
else }
{ else {
if (or1 == TopAbs_FORWARD) if (or1 == TopAbs_FORWARD){
dansS1 = Standard_True; dansS1 = Standard_True;
/*else if (or1 == TopAbs_REVERSED) {
}*/
} }
if (dansS2) }
{ if (dansS2) {
if (or2 == TopAbs_REVERSED) if (or2 == TopAbs_REVERSED) {
dansS2 = Standard_False; dansS2 = Standard_False;
/*else if (or2 == TopAbs_FORWARD) {
}*/
} }
else }
{ else {
if (or2 == TopAbs_FORWARD) if (or2 == TopAbs_FORWARD){
dansS2 = Standard_True; dansS2 = Standard_True;
/*else if (or2 == TopAbs_REVERSED) {
}*/
} }
if (dansS1 && dansS2) }
if (dansS1 && dansS2){
firstp = seqpss(i).Parameter(); firstp = seqpss(i).Parameter();
} }
} }
}
//
// finally to add // finally to add
if (dansS1 && dansS2) if (dansS1 && dansS2) {
{
lastp = thelast; lastp = thelast;
firstp = Max(firstp,thefirst); firstp = Max(firstp,thefirst);
if (lastp > firstp) { if (lastp > firstp) {
@ -752,3 +739,191 @@ void IntTools_LineConstructor::PeriodicLine (const Handle(IntPatch_Line)& L) con
} }
} }
} }
//modified by NIZNHY-PKV Fri Nov 11 10:30:34 2011f
//=======================================================================
//function : Recadre
//purpose :
//=======================================================================
void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
const Handle(GeomAdaptor_HSurface)& myHS2,
Standard_Real& u1,
Standard_Real& v1,
Standard_Real& u2,
Standard_Real& v2)
{
Standard_Boolean myHS1IsUPeriodic,myHS1IsVPeriodic;
const GeomAbs_SurfaceType typs1 = myHS1->GetType();
switch (typs1)
{
case GeomAbs_Cylinder:
case GeomAbs_Cone:
case GeomAbs_Sphere:
{
myHS1IsUPeriodic = Standard_True;
myHS1IsVPeriodic = Standard_False;
break;
}
case GeomAbs_Torus:
{
myHS1IsUPeriodic = myHS1IsVPeriodic = Standard_True;
break;
}
default:
{
//-- Case of periodic biparameters is processed upstream
myHS1IsUPeriodic = myHS1IsVPeriodic = Standard_False;
break;
}
}
Standard_Boolean myHS2IsUPeriodic,myHS2IsVPeriodic;
const GeomAbs_SurfaceType typs2 = myHS2->GetType();
switch (typs2)
{
case GeomAbs_Cylinder:
case GeomAbs_Cone:
case GeomAbs_Sphere:
{
myHS2IsUPeriodic = Standard_True;
myHS2IsVPeriodic = Standard_False;
break;
}
case GeomAbs_Torus:
{
myHS2IsUPeriodic = myHS2IsVPeriodic = Standard_True;
break;
}
default:
{
//-- Case of periodic biparameters is processed upstream
myHS2IsUPeriodic = myHS2IsVPeriodic = Standard_False;
break;
}
}
if(myHS1IsUPeriodic) {
const Standard_Real lmf = PI+PI; //-- myHS1->UPeriod();
const Standard_Real f = myHS1->FirstUParameter();
const Standard_Real l = myHS1->LastUParameter();
while(u1 < f) { u1+=lmf; }
while(u1 > l) { u1-=lmf; }
}
if(myHS1IsVPeriodic) {
const Standard_Real lmf = PI+PI; //-- myHS1->VPeriod();
const Standard_Real f = myHS1->FirstVParameter();
const Standard_Real l = myHS1->LastVParameter();
while(v1 < f) { v1+=lmf; }
while(v1 > l) { v1-=lmf; }
}
if(myHS2IsUPeriodic) {
const Standard_Real lmf = PI+PI; //-- myHS2->UPeriod();
const Standard_Real f = myHS2->FirstUParameter();
const Standard_Real l = myHS2->LastUParameter();
while(u2 < f) { u2+=lmf; }
while(u2 > l) { u2-=lmf; }
}
if(myHS2IsVPeriodic) {
const Standard_Real lmf = PI+PI; //-- myHS2->VPeriod();
const Standard_Real f = myHS2->FirstVParameter();
const Standard_Real l = myHS2->LastVParameter();
while(v2 < f) { v2+=lmf; }
while(v2 > l) { v2-=lmf; }
}
}
//=======================================================================
//function : Parameters
//purpose :
//=======================================================================
void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
const Handle(GeomAdaptor_HSurface)& myHS2,
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1,
Standard_Real& U2,
Standard_Real& V2)
{
//modified by NIZNHY-PKV Fri Nov 11 10:07:55 2011f
Parameters(myHS1, Ptref, U1, V1);
Parameters(myHS2, Ptref, U2, V2);
/*
IntSurf_Quadric quad1,quad2;
switch (myHS1->Surface().GetType())
{
case GeomAbs_Plane: quad1.SetValue(myHS1->Surface().Plane()); break;
case GeomAbs_Cylinder: quad1.SetValue(myHS1->Surface().Cylinder()); break;
case GeomAbs_Cone: quad1.SetValue(myHS1->Surface().Cone()); break;
case GeomAbs_Sphere: quad1.SetValue(myHS1->Surface().Sphere()); break;
default: Standard_ConstructionError::Raise("IntTools_LineConstructor::Parameters");
}
switch (myHS2->Surface().GetType())
{
case GeomAbs_Plane: quad2.SetValue(myHS2->Surface().Plane()); break;
case GeomAbs_Cylinder: quad2.SetValue(myHS2->Surface().Cylinder()); break;
case GeomAbs_Cone: quad2.SetValue(myHS2->Surface().Cone()); break;
case GeomAbs_Sphere: quad2.SetValue(myHS2->Surface().Sphere()); break;
default: Standard_ConstructionError::Raise("IntTools_LineConstructor::Parameters");
}
quad1.Parameters(Ptref,U1,V1);
quad2.Parameters(Ptref,U2,V2);
*/
//modified by NIZNHY-PKV Fri Nov 11 10:08:38 2011t
}
//modified by NIZNHY-PKV Fri Nov 11 10:06:02 2011f
//=======================================================================
//function : Parameter
//purpose :
//=======================================================================
void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1)
{
IntSurf_Quadric quad1;
//
switch (myHS1->Surface().GetType()) {
case GeomAbs_Plane:
quad1.SetValue(myHS1->Surface().Plane());
break;
case GeomAbs_Cylinder:
quad1.SetValue(myHS1->Surface().Cylinder());
break;
case GeomAbs_Cone:
quad1.SetValue(myHS1->Surface().Cone());
break;
case GeomAbs_Sphere:
quad1.SetValue(myHS1->Surface().Sphere());
break;
default:
Standard_ConstructionError::Raise("IntTools_LineConstructor::Parameters");
}
quad1.Parameters(Ptref,U1,V1);
}
//=======================================================================
//function : GLinePoint
//purpose :
//=======================================================================
void GLinePoint(const IntPatch_IType typl,
const Handle(IntPatch_GLine)& GLine,
const Standard_Real aT,
gp_Pnt& aP)
{
switch (typl) {
case IntPatch_Lin:
aP = ElCLib::Value(aT, GLine->Line());
break;
case IntPatch_Circle:
aP = ElCLib::Value(aT, GLine->Circle());
break;
case IntPatch_Ellipse:
aP = ElCLib::Value(aT, GLine->Ellipse());
break;
case IntPatch_Hyperbola:
aP = ElCLib::Value(aT, GLine->Hyperbola());
break;
case IntPatch_Parabola:
aP = ElCLib::Value(aT, GLine->Parabola());
break;
default:
Standard_ConstructionError::Raise("IntTools_LineConstructor::Parameters");
}
}
//modified by NIZNHY-PKV Fri Nov 11 10:06:04 2011t