//
#include <TColStd_IndexedMapOfInteger.hxx>
-
-//=======================================================================
-//function : Recadre
-//purpose :
-//=======================================================================
-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)
-{
- 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 gp_Pnt& Ptref,
- Standard_Real& U1,
- Standard_Real& V1,
- Standard_Real& U2,
- 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 Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
+ const gp_Pnt& Ptref,
+ Standard_Real& U1,
+ Standard_Real& V1);
+static
+ 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);
+
+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
const Standard_Real Tol = Precision::PConfusion() * 35.0;
const IntPatch_IType typl = L->ArcType();
- if(typl == IntPatch_Analytic)
- {
+ if(typl == IntPatch_Analytic) {
Standard_Real u1,v1,u2,v2;
Handle(IntPatch_ALine)& ALine = *((Handle(IntPatch_ALine) *)&L);
seqp.Clear();
nbvtx = GeomInt_LineTool::NbVertex(L);
- for(i=1;i<nbvtx;i++)
- {
+ for(i=1;i<nbvtx;i++) {
firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
lastp = GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
- if(firstp!=lastp)
- {
+ if(firstp!=lastp) {
const Standard_Real pmid = (firstp+lastp)*0.5;
const gp_Pnt Pmid = ALine->Value(pmid);
Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
}
done = Standard_True;
return;
- }
- else if(typl == IntPatch_Walking)
- {
+ } // if(typl == IntPatch_Analytic) {
+ else if(typl == IntPatch_Walking) {
Standard_Real u1,v1,u2,v2;
Handle(IntPatch_WLine)& WLine = *((Handle(IntPatch_WLine) *)&L);
seqp.Clear();
nbvtx = GeomInt_LineTool::NbVertex(L);
- for(i=1;i<nbvtx;i++)
- {
+ for(i=1;i<nbvtx;i++) {
firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
lastp = GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
- if(firstp!=lastp)
- {
- if(lastp != firstp+1)
- {
+ if(firstp!=lastp) {
+ if(lastp != firstp+1) {
const Standard_Integer pmid = (Standard_Integer )( (firstp+lastp)/2);
const IntSurf_PntOn2S& Pmid = WLine->Point(pmid);
Pmid.Parameters(u1,v1,u2,v2);
}
}
}
- else
- {
+ else {
const IntSurf_PntOn2S& Pfirst = WLine->Point((Standard_Integer)(firstp));
Pfirst.Parameters(u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
}
}
}
-
}
}
}
- //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.
- // The aim of the block is to reject these segments and have
+ // The aim of the block is to reject these segments and have
// one segment instead of 7.
// The other reason to do that is value of TolReached3D=49.
// Why -? It is not known yet.
// PKV 22.Apr.2002
//
- const GeomAbs_SurfaceType aST1 = myHS1->Surface().GetType();
- const GeomAbs_SurfaceType aST2 = myHS2->Surface().GetType();
- if ((aST1==GeomAbs_Plane && aST2==GeomAbs_SurfaceOfExtrusion) ||
- (aST2==GeomAbs_Plane && aST1==GeomAbs_SurfaceOfExtrusion))
- {
- TColStd_IndexedMapOfInteger aMap;
- TColStd_SequenceOfReal aSeqTmp;
-
- Standard_Integer aNb, anIndex, aNbTmp, jx;
-
- aNb=seqp.Length();
- for(i=1; i<=aNb;++i) {
- lastp =seqp(i);
- anIndex=(Standard_Integer)lastp;
- if (!aMap.Contains(anIndex)){
- aMap.Add(anIndex);
- aSeqTmp.Append(lastp);
+ Standard_Integer aNbParts;
+ //
+ aNbParts = seqp.Length()/2;
+ 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 {
- aNbTmp=aSeqTmp.Length();
- aSeqTmp.Remove(aNbTmp);
+ }
+ else if (aST2==GeomAbs_Plane) {
+ if (aST1==GeomAbs_SurfaceOfExtrusion ||
+ aST1==GeomAbs_SurfaceOfRevolution) {//+zft
+ bCond=!bCond;
}
}
//
- seqp.Clear();
- //
- aNb=aSeqTmp.Length()/2;
- for(i=1; i<=aNb;++i) {
- jx=2*i;
- firstp=aSeqTmp(jx-1);
- lastp =aSeqTmp(jx);
- seqp.Append(firstp);
- seqp.Append(lastp);
- }
+ if (bCond) {
+ Standard_Integer aNb, anIndex, aNbTmp, jx;
+ TColStd_IndexedMapOfInteger aMap;
+ TColStd_SequenceOfReal aSeqTmp;
+ //
+ aNb=seqp.Length();
+ for(i=1; i<=aNb; ++i) {
+ lastp =seqp(i);
+ anIndex=(Standard_Integer)lastp;
+ if (!aMap.Contains(anIndex)){
+ aMap.Add(anIndex);
+ aSeqTmp.Append(lastp);
+ }
+ else {
+ aNbTmp=aSeqTmp.Length();
+ aSeqTmp.Remove(aNbTmp);
+ }
+ }
+ //
+ seqp.Clear();
+ //
+ aNb=aSeqTmp.Length()/2;
+ for(i=1; i<=aNb;++i) {
+ jx=2*i;
+ firstp=aSeqTmp(jx-1);
+ lastp =aSeqTmp(jx);
+ seqp.Append(firstp);
+ seqp.Append(lastp);
+ }
+ }//if (bCond) {
}
- ////XX
done = Standard_True;
return;
- }
- else if (typl != IntPatch_Restriction)
- {
+ }// else if(typl == IntPatch_Walking) {
+ //
+ else if (typl != IntPatch_Restriction) {
+ Standard_Boolean intrvtested;
Standard_Real u1,v1,u2,v2;
- Handle(IntPatch_GLine)& GLine = *((Handle(IntPatch_GLine) *)&L);
+ //
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;
+ return;
+ }
+ break;
+ }
+ case IntPatch_Ellipse: {
+ Standard_Real aR;
+ 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);
- Standard_Boolean intrvtested = Standard_False;
- for(i=1;i<nbvtx;i++)
- {
+ intrvtested = Standard_False;
+ for(i=1; i<nbvtx; ++i) {
firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
lastp = GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
- if(Abs(firstp-lastp)>Precision::PConfusion())
- {
+ if(Abs(firstp-lastp)>Precision::PConfusion()) {
intrvtested = Standard_True;
const Standard_Real pmid = (firstp+lastp)*0.5;
gp_Pnt Pmid;
- switch (typl)
- {
- case IntPatch_Lin: Pmid = ElCLib::Value(pmid,GLine->Line()); 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;
+ //modified by NIZNHY-PKV Fri Nov 11 10:27:01 2011f
+ GLinePoint(typl, GLine, pmid, Pmid);
+ /*
+ switch (typl) {
+ case IntPatch_Lin:
+ Pmid = ElCLib::Value(pmid,GLine->Line());
+ 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);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
}
}
}
-
- if(typl == IntPatch_Circle || typl == IntPatch_Ellipse)
- {
+ //
+ if(typl == IntPatch_Circle || typl == IntPatch_Ellipse) {
firstp = GeomInt_LineTool::Vertex(L,nbvtx).ParameterOnLine();
lastp = M_PI + M_PI + GeomInt_LineTool::Vertex(L,1).ParameterOnLine();
const Standard_Real cadrinf = GeomInt_LineTool::FirstParameter(L);
const Standard_Real cadrsup = GeomInt_LineTool::LastParameter(L);
Standard_Real acadr = (firstp+lastp)*0.5;
- while(acadr < cadrinf) { acadr+=M_PI+M_PI; }
- while(acadr > cadrsup) { acadr-=M_PI+M_PI; }
- if(acadr>=cadrinf && acadr<=cadrsup)
- {
- if(Abs(firstp-lastp)>Precision::PConfusion())
- {
+ while(acadr < cadrinf) {
+ acadr+=M_PI+M_PI;
+ }
+ while(acadr > cadrsup) {
+ acadr-=M_PI+M_PI;
+ }
+ if(acadr>=cadrinf && acadr<=cadrsup) {
+ if(Abs(firstp-lastp)>Precision::PConfusion()) {
intrvtested = Standard_True;
const Standard_Real pmid = (firstp+lastp)*0.5;
gp_Pnt Pmid;
- if (typl == IntPatch_Circle)
+ if (typl == IntPatch_Circle) {
Pmid = ElCLib::Value(pmid,GLine->Circle());
- else
+ }
+ else {
Pmid = ElCLib::Value(pmid,GLine->Ellipse());
+ }
Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
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.
+ //
+ Standard_Integer aNbParts;
//
- // Unite neighbouring intervals if it's possible.
- // 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)
- {
- Standard_Integer j, i2, j2;
- Standard_Real aFi = seqp(1), aLi, aFj, aLj, aF, aL;
- TColStd_SequenceOfReal aSeq;
- aSeq.Append(aFi);
- for (i=1; i<aNbParts; ++i)
- {
- j=i+1;
- i2=2*i;
- j2=2*j;
-
- aFi=seqp(i2-1);
- aLi=seqp(i2);
-
- aFj=seqp(j2-1);
- aLj=seqp(j2);
-
- if (fabs (aFj-aLi) < Tol)
- {
- aL=aLj;
+ aNbParts = seqp.Length()/2;
+ if (aNbParts > 1 && (typl == IntPatch_Circle || typl == IntPatch_Ellipse)) {
+ Standard_Boolean bCond, bPCS, bPCS1, bPCS2, bCC;
+ 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
- {
- aL=aLi;
- aSeq.Append(aL);
- aF=aFj;
- aSeq.Append(aF);
+ else {
+ if (fabs(aV-aHalfPI) < aPPC) {
+ ++i1;
+ }
}
}
- aSeq.Append(aLj);
+ 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;
+ //
+ aFi=seqp(1);
+ aSeq.Append(aFi);
+ for (i=1; i<aNbParts; ++i) {
+ j=i+1;
+ i2=2*i;
+ j2=2*j;
//
- seqp.Clear();
- aNbParts=aSeq.Length();
- for (i=1; i<=aNbParts; ++i)
- {
- aF=aSeq(i);
- seqp.Append(aF);
+ aFi=seqp(i2-1);
+ aLi=seqp(i2);
+ //
+ aFj=seqp(j2-1);
+ aLj=seqp(j2);
+ //
+ if (fabs (aFj-aLi) < Tol) {
+ aL=aLj;
+ }
+ else {
+ aL=aLi;
+ aSeq.Append(aL);
+ aF=aFj;
+ aSeq.Append(aF);
}
}
+ aSeq.Append(aLj);
+ //
+ seqp.Clear();
+ aNbParts=aSeq.Length();
+ for (i=1; i<=aNbParts; ++i) {
+ aF=aSeq(i);
+ seqp.Append(aF);
+ }
}
}
- //modified by NIZNHY-PKV Mon Jan 21 17:02:17 2002 t
//
done =Standard_True;
return;
- }
+ }// else if (typl != IntPatch_Restriction) {
done = Standard_False;
seqp.Clear();
GeomInt_SequenceOfParameterAndOrientation seqpss;
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 Standard_Real prm = thevtx.ParameterOnLine();
- if (thevtx.IsOnDomS1())
- {
- switch (thevtx.TransitionLineArc1().TransitionType())
- {
+ if (thevtx.IsOnDomS1()) {
+ switch (thevtx.TransitionLineArc1().TransitionType()) {
case IntSurf_In: or1 = TopAbs_FORWARD; break;
case IntSurf_Out: or1 = TopAbs_REVERSED; break;
case IntSurf_Touch: or1 = TopAbs_INTERNAL; break;
case IntSurf_Undecided: or1 = TopAbs_INTERNAL; break;
}
}
- else
+ else {
or1 = TopAbs_INTERNAL;
+ }
- if (thevtx.IsOnDomS2())
- {
- switch (thevtx.TransitionLineArc2().TransitionType())
- {
+ if (thevtx.IsOnDomS2()) {
+ switch (thevtx.TransitionLineArc2().TransitionType()) {
case IntSurf_In: or2 = TopAbs_FORWARD; break;
case IntSurf_Out: or2 = TopAbs_REVERSED; break;
case IntSurf_Touch: or2 = TopAbs_INTERNAL; break;
case IntSurf_Undecided: or2 = TopAbs_INTERNAL; break;
}
}
- else
+ else {
or2 = TopAbs_INTERNAL;
-
+ }
+ //
const Standard_Integer nbinserted = seqpss.Length();
Standard_Boolean inserted = Standard_False;
- for (Standard_Integer j=1; j<=nbinserted;j++)
- {
- if (Abs(prm-seqpss(j).Parameter()) <= Tol)
- {
+ for (Standard_Integer j=1; j<=nbinserted;j++) {
+ if (Abs(prm-seqpss(j).Parameter()) <= Tol) {
// accumulate
GeomInt_ParameterAndOrientation& valj = seqpss.ChangeValue(j);
if (or1 != TopAbs_INTERNAL) {
Standard_Boolean dansS2 = Standard_False;
nbvtx = seqpss.Length();
- for (i=1; i<= nbvtx; i++)
- {
+ for (i=1; i<= nbvtx; i++) {
or1 = seqpss(i).Orientation1();
- if (or1 != TopAbs_INTERNAL)
- {
+ if (or1 != TopAbs_INTERNAL) {
trim = Standard_True;
dansS1 = (or1 != TopAbs_FORWARD);
break;
}
}
- if (i > nbvtx)
- {
+ if (i > nbvtx) {
Standard_Real U,V;
- for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ )
- {
- if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS1() )
- {
+ for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ ) {
+ if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS1() ) {
GeomInt_LineTool::Vertex(L,i).ParametersOnS1(U,V);
gp_Pnt2d PPCC(U,V);
if (myDom1->Classify(PPCC,Tol) == TopAbs_OUT) {
}
dansS1 = Standard_True; // Keep in doubt
}
-
- for (i=1; i<= nbvtx; i++)
- {
+ //
+ for (i=1; i<= nbvtx; i++) {
or2 = seqpss(i).Orientation2();
- if (or2 != TopAbs_INTERNAL)
- {
+ if (or2 != TopAbs_INTERNAL) {
trim = Standard_True;
dansS2 = (or2 != TopAbs_FORWARD);
break;
}
}
- if (i > nbvtx)
- {
+ if (i > nbvtx) {
Standard_Real U,V;
- for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ )
- {
- if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS2() )
- {
+ for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ ) {
+ if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS2() ) {
GeomInt_LineTool::Vertex(L,i).ParametersOnS2(U,V);
if (myDom2->Classify(gp_Pnt2d(U,V),Tol) == TopAbs_OUT) {
done = Standard_True;
// sequence seqpss is peeled to create valid ends
// and store them in seqp(2*i+1) and seqp(2*i+2)
-
Standard_Real thefirst = GeomInt_LineTool::FirstParameter(L);
Standard_Real thelast = GeomInt_LineTool::LastParameter(L);
firstp = thefirst;
- for (i=1; i<=nbvtx; i++)
- {
+ for (i=1; i<=nbvtx; i++) {
or1 = seqpss(i).Orientation1();
or2 = seqpss(i).Orientation2();
- if (dansS1 && dansS2)
- {
- if (or1 == TopAbs_REVERSED)
+ if (dansS1 && dansS2) {
+ if (or1 == TopAbs_REVERSED){
dansS1 = Standard_False;
- /*else if (or1 == TopAbs_FORWARD) {
- }*/
- if (or2 == TopAbs_REVERSED)
+ }
+
+ if (or2 == TopAbs_REVERSED){
dansS2 = Standard_False;
- /*else if (or2 == TopAbs_FORWARD) {
- }*/
- if (!dansS1 || !dansS2)
- {
+ }
+ if (!dansS1 || !dansS2) {
lastp = seqpss(i).Parameter();
Standard_Real stofirst = Max(firstp, thefirst);
Standard_Real stolast = Min(lastp, thelast) ;
seqp.Append(stofirst);
seqp.Append(stolast);
}
- if (lastp > thelast)
+ if (lastp > thelast) {
break;
+ }
}
}
- else
- {
- if (dansS1)
- {
- if (or1 == TopAbs_REVERSED)
+ else {
+ if (dansS1) {
+ if (or1 == TopAbs_REVERSED) {
dansS1 = Standard_False;
- /*else if (or1 == TopAbs_FORWARD) {
- }*/
+ }
}
- else
- {
- if (or1 == TopAbs_FORWARD)
+ else {
+ if (or1 == TopAbs_FORWARD){
dansS1 = Standard_True;
- /*else if (or1 == TopAbs_REVERSED) {
- }*/
+ }
}
- if (dansS2)
- {
- if (or2 == TopAbs_REVERSED)
+ if (dansS2) {
+ if (or2 == TopAbs_REVERSED) {
dansS2 = Standard_False;
- /*else if (or2 == TopAbs_FORWARD) {
- }*/
+ }
}
- else
- {
- if (or2 == TopAbs_FORWARD)
+ else {
+ if (or2 == TopAbs_FORWARD){
dansS2 = Standard_True;
- /*else if (or2 == TopAbs_REVERSED) {
- }*/
+ }
}
- if (dansS1 && dansS2)
+ if (dansS1 && dansS2){
firstp = seqpss(i).Parameter();
+ }
}
}
-
+ //
// finally to add
- if (dansS1 && dansS2)
- {
+ if (dansS1 && dansS2) {
lastp = thelast;
firstp = Max(firstp,thefirst);
if (lastp > firstp) {
}
}
}
+//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
projects / occt.git / blobdiff