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

0024915: Wrong intersection curves between two cylinders

Browse Source 
Existing method of Cylinder-Cylinder intersection computing is based on finding the analytic line (as a function of one argument) and converting one into the walking-line with set of equidistant (along the line parameter) points.

The main advantage of applied method is using adaptively computed step. Necessary step is computed into every point of the obtained walking-line. At that we receive final walking-line directly (without preliminary analytic line) and we determine moments more precisely, when it should be split (see IntPatch_ImpImpIntersection_4.gxx).

The main disadvantages is bad working this method for non-trimmed cylinders (with infinite bounds), because step value is depend on the boundaries values.

More over, new method always returns walking-line, while intersection result can be an analytic curve (lines, circle, ellipse). That is NO good. Therefore, analytic curve is computed by existing method.

In conclusion, in spite of covering almost all more often meeting cases, new method has limited application. Then we should use the existing old method.

Additionally, method MinMax() is added (see Standard_Real.hxx file). It uses into new algorithm.

Some test cases is changed according to their new behavior.

Test case for issue CR24915 is added.

Into GeometryTest_APICommands.cxx only tabulations were chaged.

"Extending" of isolines (see Geom2dHatch_Hatcher.cxx).

Small correction of test case for issue CR24915.
This commit is contained in:
nbv 2014-08-15 14:35:04 +04:00 committed by bugmaster
parent d15f387afa
commit ecc4f1489d
22 changed files with 2800 additions and 827 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
src/DBRep/DBRep_IsoBuilder.cxx
View File

@ -46,32 +46,32 @@ static Standard_Real HatcherConfusion3d = 1.e-8 ;
//=======================================================================
DBRep_IsoBuilder::DBRep_IsoBuilder (const TopoDS_Face& TopologicalFace,
const Standard_Real Infinite,
const Standard_Integer NbIsos) :
Geom2dHatch_Hatcher (Geom2dHatch_Intersector (IntersectorConfusion,
IntersectorTangency),
HatcherConfusion2d,
HatcherConfusion3d,
Standard_True,
Standard_False) ,
myInfinite (Infinite) ,
myUMin (0.0) ,
myUMax (0.0) ,
myVMin (0.0) ,
myVMax (0.0) ,
myUPrm (1, NbIsos) ,
myUInd (1, NbIsos) ,
myVPrm (1, NbIsos) ,
myVInd (1, NbIsos) ,
myNbDom (0)
const Standard_Real Infinite,
const Standard_Integer NbIsos) :
Geom2dHatch_Hatcher (Geom2dHatch_Intersector (IntersectorConfusion,
IntersectorTangency),
HatcherConfusion2d,
HatcherConfusion3d,
Standard_True,
Standard_False) ,
myInfinite (Infinite) ,
myUMin (0.0) ,
myUMax (0.0) ,
myVMin (0.0) ,
myVMax (0.0) ,
myUPrm (1, NbIsos) ,
myUInd (1, NbIsos) ,
myVPrm (1, NbIsos) ,
myVInd (1, NbIsos) ,
myNbDom (0)
{
myUInd.Init(0);
myVInd.Init(0);
//-----------------------------------------------------------------------
// If the Min Max bounds are infinite, there are bounded to Infinite
// value.
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// If the Min Max bounds are infinite, there are bounded to Infinite
// value.
//-----------------------------------------------------------------------
BRepTools::UVBounds (TopologicalFace, myUMin, myUMax, myVMin, myVMax) ;
Standard_Boolean InfiniteUMin = Precision::IsNegativeInfinite (myUMin) ;
@ -95,9 +95,9 @@ DBRep_IsoBuilder::DBRep_IsoBuilder (const TopoDS_Face& TopologicalFace,
myVMax = myVMin + Infinite ;
}
//-----------------------------------------------------------------------
// Retreiving the edges and loading them into the hatcher.
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// Retreiving the edges and loading them into the hatcher.
//-----------------------------------------------------------------------
TopExp_Explorer ExpEdges;
for (ExpEdges.Init (TopologicalFace, TopAbs_EDGE); ExpEdges.More(); ExpEdges.Next())
@ -108,22 +108,22 @@ DBRep_IsoBuilder::DBRep_IsoBuilder (const TopoDS_Face& TopologicalFace,
if (PCurve.IsNull())
{
#ifdef DEB
#ifdef DEB
cout << "DBRep_IsoBuilder : PCurve is null\n";
#endif
#endif
return;
}
else if (U1 == U2)
{
#ifdef DEB
#ifdef DEB
cout << "DBRep_IsoBuilder PCurve : U1==U2\n";
#endif
#endif
return;
}
//-- Test if a TrimmedCurve is necessary
if (Abs(PCurve->FirstParameter()-U1)<= Precision::PConfusion()
&& Abs(PCurve->LastParameter()-U2)<= Precision::PConfusion())
&& Abs(PCurve->LastParameter()-U2)<= Precision::PConfusion())
{
AddElement (PCurve, TopologicalEdge.Orientation());
}
@ -135,16 +135,16 @@ DBRep_IsoBuilder::DBRep_IsoBuilder (const TopoDS_Face& TopologicalFace,
if (!TrimPCurve.IsNull())
{
if (TrimPCurve->BasisCurve()->FirstParameter() - U1 > Precision::PConfusion() ||
TrimPCurve->BasisCurve()->FirstParameter() - U2 > Precision::PConfusion() ||
U1 - TrimPCurve->BasisCurve()->LastParameter() > Precision::PConfusion() ||
U2 - TrimPCurve->BasisCurve()->LastParameter() > Precision::PConfusion())
TrimPCurve->BasisCurve()->FirstParameter() - U2 > Precision::PConfusion() ||
U1 - TrimPCurve->BasisCurve()->LastParameter() > Precision::PConfusion() ||
U2 - TrimPCurve->BasisCurve()->LastParameter() > Precision::PConfusion())
{
AddElement (PCurve, TopologicalEdge.Orientation());
#ifdef DEB
#ifdef DEB
cout << "DBRep_IsoBuilder TrimPCurve : parameters out of range\n";
cout << " U1(" << U1 << "), Umin(" << PCurve->FirstParameter()
<< "), U2(" << U2 << "), Umax(" << PCurve->LastParameter() << ")\n";
#endif
<< "), U2(" << U2 << "), Umax(" << PCurve->LastParameter() << ")\n";
#endif
return;
}
}
@ -152,34 +152,34 @@ DBRep_IsoBuilder::DBRep_IsoBuilder (const TopoDS_Face& TopologicalFace,
{
if (PCurve->FirstParameter() - U1 > Precision::PConfusion())
{
#ifdef DEB
#ifdef DEB
cout << "DBRep_IsoBuilder PCurve : parameters out of range\n";
cout << " U1(" << U1 << "), Umin(" << PCurve->FirstParameter() << ")\n";
#endif
#endif
U1 = PCurve->FirstParameter();
}
if (PCurve->FirstParameter() - U2 > Precision::PConfusion())
{
#ifdef DEB
#ifdef DEB
cout << "DBRep_IsoBuilder PCurve : parameters out of range\n";
cout << " U2(" << U2 << "), Umin(" << PCurve->FirstParameter() << ")\n";
#endif
#endif
U2 = PCurve->FirstParameter();
}
if (U1 - PCurve->LastParameter() > Precision::PConfusion())
{
#ifdef DEB
#ifdef DEB
cout << "DBRep_IsoBuilder PCurve : parameters out of range\n";
cout << " U1(" << U1 << "), Umax(" << PCurve->LastParameter() << ")\n";
#endif
#endif
U1 = PCurve->LastParameter();
}
if (U2 - PCurve->LastParameter() > Precision::PConfusion())
{
#ifdef DEB
#ifdef DEB
cout << "DBRep_IsoBuilder PCurve : parameters out of range\n";
cout << " U2(" << U2 << "), Umax(" << PCurve->LastParameter() << ")\n";
#endif
#endif
U2 = PCurve->LastParameter();
}
}
@ -192,9 +192,9 @@ DBRep_IsoBuilder::DBRep_IsoBuilder (const TopoDS_Face& TopologicalFace,
}
}
//-----------------------------------------------------------------------
// Loading and trimming the hatchings.
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// Loading and trimming the hatchings.
//-----------------------------------------------------------------------
Standard_Integer IIso ;
Standard_Real DeltaU = Abs (myUMax - myUMin) ;
@ -228,29 +228,36 @@ DBRep_IsoBuilder::DBRep_IsoBuilder (const TopoDS_Face& TopologicalFace,
}
}
//-----------------------------------------------------------------------
// Computation.
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// Computation.
//-----------------------------------------------------------------------
Trim() ;
myNbDom = 0 ;
for (IIso = 1 ; IIso <= NbIsos ; IIso++) {
for (IIso = 1 ; IIso <= NbIsos ; IIso++)
{
Standard_Integer Index ;
Index = myUInd(IIso) ;
if (Index != 0) {
if (TrimDone (Index) && !TrimFailed (Index)) {
ComputeDomains (Index);
if (IsDone (Index)) myNbDom = myNbDom + Geom2dHatch_Hatcher::NbDomains (Index) ;
if (Index != 0)
{
if (TrimDone (Index) && !TrimFailed (Index))
{
ComputeDomains (Index);
if (IsDone (Index))
myNbDom = myNbDom + Geom2dHatch_Hatcher::NbDomains (Index) ;
}
}
Index = myVInd(IIso) ;
if (Index != 0) {
if (TrimDone (Index) && !TrimFailed (Index)) {
ComputeDomains (Index);
if (IsDone (Index)) myNbDom = myNbDom + Geom2dHatch_Hatcher::NbDomains (Index) ;
if (Index != 0)
{
if (TrimDone (Index) && !TrimFailed (Index))
{
ComputeDomains (Index);
if (IsDone (Index))
myNbDom = myNbDom + Geom2dHatch_Hatcher::NbDomains (Index) ;
}
}
}

4
src/Geom/Geom_CylindricalSurface.cdl
View File

@ -19,6 +19,10 @@ class CylindricalSurface from Geom inherits ElementarySurface from Geom
---Purpose : This class defines the infinite cylindrical surface.
--
-- Every cylindrical surface is set by the following equation:
-- S(U,V) = Location + R*cos(U)*XAxis + R*sin(U)*YAxis + V*ZAxis,
-- where R is cylinder radius.
--
-- The local coordinate system of the CylindricalSurface is defined
-- with an axis placement (see class ElementarySurface).
--

828
src/Geom2dHatch/Geom2dHatch_Hatcher.cxx
View File

@ -951,8 +951,11 @@ void Geom2dHatch_Hatcher::ComputeDomains (const Standard_Integer IndH)
Hatching.IsDone (Standard_False) ;
if (!Hatching.TrimDone()) Trim (IndH) ;
if (Hatching.Status() != HatchGen_NoProblem) return ;
if (!Hatching.TrimDone())
Trim (IndH);
if (Hatching.Status() != HatchGen_NoProblem)
return;
Standard_Boolean Points = myKeepPoints ;
Standard_Boolean Segments = myKeepSegments ;
@ -962,19 +965,23 @@ void Geom2dHatch_Hatcher::ComputeDomains (const Standard_Integer IndH)
Standard_Integer NbPnt = Hatching.NbPoints() ;
Standard_Integer IPnt =1;
if (NbPnt == 0) {
if(NbPnt == 0)
{
//-- cout << "The hatching # " << setw(3) << IndH << " has to be classified" << endl ;
Geom2dHatch_Classifier Classifier(myElements,Hatching.ClassificationPoint(),0.0000001);
if(Classifier.State() == TopAbs_IN) {
if(Classifier.State() == TopAbs_IN)
{
HatchGen_Domain domain ;
Hatching.AddDomain (domain) ;
}
Hatching.IsDone (Standard_True) ;
return ;
}
//for (Standard_Integer IPnt = 1 ; IPnt <= NbPnt ; IPnt++) {
for (IPnt = 1 ; IPnt <= NbPnt ; IPnt++) {
for (IPnt = 1 ; IPnt <= NbPnt ; IPnt++)
{
Standard_Boolean NoDomain = Hatching.NbDomains() == 0 ;
Standard_Boolean FirstPoint = IPnt == 1 ;
Standard_Boolean LastPoint = IPnt == NbPnt ;
@ -1003,34 +1010,52 @@ void Geom2dHatch_Hatcher::ComputeDomains (const Standard_Integer IndH)
// Initialisations dues au premier point.
//-----------------------------------------------------------------------
if (FirstPoint) {
if (FirstPoint)
{
SavPnt = Standard_False ;
ISav = 0 ;
NbOpenedSegments = 0 ;
if (SegmentEnd && SegmentBegin) {
if (StateAfter == TopAbs_UNKNOWN) StateAfter = TopAbs_IN ;
if (StateBefore == TopAbs_UNKNOWN) StateBefore = TopAbs_IN ;
if (Segments) {
SavPnt = Standard_True ;
ISav = 0 ;
}
} else if (SegmentEnd) {
if (StateAfter == TopAbs_UNKNOWN) StateAfter = TopAbs_IN ;
if (Segments) {
SavPnt = Standard_True ;
ISav = 0 ;
}
} else if (SegmentBegin) {
if (StateBefore == TopAbs_UNKNOWN) StateBefore = TopAbs_IN ;
if (StateBefore == TopAbs_IN) {
SavPnt = Standard_True ;
ISav = 0 ;
}
} else {
if (StateBefore == TopAbs_IN) {
SavPnt = Standard_True ;
ISav = 0 ;
}
if (SegmentEnd && SegmentBegin)
{
if (StateAfter == TopAbs_UNKNOWN)
StateAfter = TopAbs_IN ;
if (StateBefore == TopAbs_UNKNOWN)
StateBefore = TopAbs_IN ;
if (Segments)
{
SavPnt = Standard_True ;
ISav = 0 ;
}
}
else if (SegmentEnd)
{
if (StateAfter == TopAbs_UNKNOWN)
StateAfter = TopAbs_IN ;
if (Segments)
{
SavPnt = Standard_True ;
ISav = 0 ;
}
}
else if (SegmentBegin)
{
if (StateBefore == TopAbs_UNKNOWN)
StateBefore = TopAbs_IN ;
if (StateBefore == TopAbs_IN)
{
SavPnt = Standard_True ;
ISav = 0 ;
}
}
else
{
if (StateBefore == TopAbs_IN)
{
SavPnt = Standard_True ;
ISav = 0 ;
}
}
}
@ -1038,15 +1063,28 @@ void Geom2dHatch_Hatcher::ComputeDomains (const Standard_Integer IndH)
// Initialisations dues au dernier point.
//-----------------------------------------------------------------------
if (LastPoint) {
if (SegmentEnd && SegmentBegin) {
if (StateAfter == TopAbs_UNKNOWN) StateAfter = TopAbs_IN ;
if (StateBefore == TopAbs_UNKNOWN) StateBefore = TopAbs_IN ;
} else if (SegmentEnd) {
if (StateAfter == TopAbs_UNKNOWN) StateAfter = TopAbs_IN ;
} else if (SegmentBegin) {
if (StateBefore == TopAbs_UNKNOWN) StateBefore = TopAbs_IN ;
} else {
if (LastPoint)
{
if (SegmentEnd && SegmentBegin)
{
if (StateAfter == TopAbs_UNKNOWN)
StateAfter = TopAbs_IN ;
if (StateBefore == TopAbs_UNKNOWN)
StateBefore = TopAbs_IN ;
}
else if (SegmentEnd)
{
if (StateAfter == TopAbs_UNKNOWN)
StateAfter = TopAbs_IN ;
}
else if (SegmentBegin)
{
if (StateBefore == TopAbs_UNKNOWN)
StateBefore = TopAbs_IN ;
}
else
{
}
}
@ -1056,337 +1094,461 @@ void Geom2dHatch_Hatcher::ComputeDomains (const Standard_Integer IndH)
Standard_Boolean ToAppend = Standard_False ;
if (SegmentEnd && SegmentBegin) {
if (SegmentEnd && SegmentBegin)
{
if (StateBefore != TopAbs_IN && StateAfter != TopAbs_IN)
{
Hatching.Status (HatchGen_IncompatibleStates) ;
return ;
}
if (StateBefore != TopAbs_IN && StateAfter != TopAbs_IN) {
Hatching.Status (HatchGen_IncompatibleStates) ;
return ;
}
if (Points) {
if (Segments) {
if (!SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0) domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_True ;
ISav = IPnt ;
} else {
Standard_Boolean isININ = (StateBefore == TopAbs_IN && StateAfter == TopAbs_IN);
if (SavPnt && !isININ) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
domain.SetPoints (CurPnt, CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_False ;
ISav = 0 ;
}
}
} else if (SegmentEnd) {
if (Points)
{
if (Segments)
{
if (!SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
return ;
}
if (Segments) {
if (StateAfter == TopAbs_OUT) {
if (!SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0) domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
} else {
if (Points) {
if (ISav != 0) domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_True ;
ISav = IPnt ;
}
}
} else {
if (StateAfter == TopAbs_IN) {
SavPnt = Standard_True ;
ISav = IPnt ;
}
if (ISav != 0)
domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_True ;
ISav = IPnt ;
}
else
{
Standard_Boolean isININ = (StateBefore == TopAbs_IN && StateAfter == TopAbs_IN);
if (SavPnt && !isININ)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
return ;
}
domain.SetPoints (CurPnt, CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_False ;
ISav = 0 ;
}
}
}
else if (SegmentEnd)
{
if (Segments)
{
if (StateAfter == TopAbs_OUT)
{
if (!SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0)
domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
}
else
{
if (Points)
{
if (ISav != 0)
domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_True ;
ISav = IPnt ;
}
}
}
else
{
if (StateAfter == TopAbs_IN)
{
SavPnt = Standard_True ;
ISav = IPnt ;
}
}
NbOpenedSegments-- ;
} else if (SegmentBegin) {
}
else if (SegmentBegin)
{
if (Segments)
{
if (StateBefore == TopAbs_OUT)
{
SavPnt = Standard_True ;
ISav = IPnt ;
}
else
{
if (Points)
{
if (!SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
if (Segments) {
if (StateBefore == TopAbs_OUT) {
SavPnt = Standard_True ;
ISav = IPnt ;
} else {
if (Points) {
if (!SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0) domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_True ;
ISav = IPnt ;
}
}
} else {
if (StateBefore == TopAbs_IN) {
if (!SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0) domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
// Modified by Sergey KHROMOV - Fri Jan 5 12:05:30 2001
// SavPnt = Standard_False ;
// ISav = 0 ;
SavPnt = Standard_True ;
ISav = IPnt ;
// Modified by Sergey KHROMOV - Fri Jan 5 12:05:31 2001
}
return ;
}
if (ISav != 0)
domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_True ;
ISav = IPnt ;
}
}
}
else
{
if (StateBefore == TopAbs_IN)
{
if (!SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0)
domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
//Modified by Sergey KHROMOV - Fri Jan 5 12:05:30 2001
//SavPnt = Standard_False ;
//ISav = 0 ;
SavPnt = Standard_True ;
ISav = IPnt ;
//Modified by Sergey KHROMOV - Fri Jan 5 12:05:31 2001
}
}
NbOpenedSegments++ ;
} else {
}
else
{
//-- ???????????????????????????????????????????????????????????????????????????
//-- Solution provisoire (lbr le 11 Aout 97 )
//-- si On a 2 points dont des points OUT OUT ou IN IN qui delimitent une isos
//-- on transforme les transitions
if (StateBefore == TopAbs_OUT && StateAfter == TopAbs_OUT) {
if(NbPnt == 2) {
if(FirstPoint)
StateAfter = TopAbs_IN;
else
StateBefore = TopAbs_IN;
}
if (StateBefore == TopAbs_OUT && StateAfter == TopAbs_OUT)
{
if(NbPnt == 2)
{
if(FirstPoint)
StateAfter = TopAbs_IN;
else
StateBefore = TopAbs_IN;
}
}
//-- ???????????????????????????????????????????????????????????????????????????
if (StateBefore == TopAbs_OUT && StateAfter == TopAbs_OUT) {
if(StateBefore == TopAbs_OUT && StateAfter == TopAbs_OUT)
{
if (SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
if (SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
if (Points) {
domain.SetPoints (CurPnt, CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_True ;
ISav = IPnt ;
}
} else if (StateBefore == TopAbs_OUT && StateAfter == TopAbs_IN ) {
SavPnt = Standard_True ;
ISav = IPnt ;
} else if (StateBefore == TopAbs_IN && StateAfter == TopAbs_OUT) {
if (!SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0) domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_False ;
ISav = 0 ;
} else if (StateBefore == TopAbs_IN && StateAfter == TopAbs_IN ) {
if (Points) {
if (NbOpenedSegments == 0) {
if (!SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0) domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_True ;
ISav = IPnt ;
} else {
if (Segments) {
if (!SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0) domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_True ;
ISav = IPnt ;
} else {
if (SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
domain.SetPoints (CurPnt, CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_False ;
ISav = 0 ;
}
}
}
} else {
Hatching.Status (HatchGen_IncompatibleStates) ;
return ;
return ;
}
if (Points)
{
domain.SetPoints (CurPnt, CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_True ;
ISav = IPnt ;
}
}
else if (StateBefore == TopAbs_OUT && StateAfter == TopAbs_IN )
{
SavPnt = Standard_True ;
ISav = IPnt ;
}
else if (StateBefore == TopAbs_IN && StateAfter == TopAbs_OUT)
{
if (!SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0)
domain.SetFirstPoint (Hatching.Point(ISav));
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_False ;
ISav = 0 ;
}
else if (StateBefore == TopAbs_IN && StateAfter == TopAbs_IN )
{
if (Points)
{
if (NbOpenedSegments == 0)
{
if (!SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
//return;
continue;
}
if (ISav != 0)
domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_True ;
ISav = IPnt ;
}
else
{
if (Segments)
{
if (!SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0)
domain.SetFirstPoint (Hatching.Point(ISav)) ;
domain.SetSecondPoint (CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_True ;
ISav = IPnt ;
}
else
{
if (SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
return ;
}
domain.SetPoints (CurPnt, CurPnt) ;
ToAppend = Standard_True ;
SavPnt = Standard_False ;
ISav = 0 ;
}
}
}
}
else
{
Hatching.Status (HatchGen_IncompatibleStates) ;
return ;
}
}
//-----------------------------------------------------------------------
// Ajout du domaine.
//-----------------------------------------------------------------------
if (ToAppend) Hatching.AddDomain (domain) ;
if (ToAppend)
Hatching.AddDomain (domain) ;
//-----------------------------------------------------------------------
// Traitement lie au dernier point.
//-----------------------------------------------------------------------
if (LastPoint) {
if (LastPoint)
{
domain.SetPoints () ;
ToAppend = Standard_False ;
if (SegmentEnd && SegmentBegin) {
if (Segments) {
if (!SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0) domain.SetFirstPoint (Hatching.Point(ISav)) ;
ToAppend = Standard_True ;
}
} else if (SegmentEnd) {
if (SegmentEnd && SegmentBegin)
{
if (Segments)
{
if (!SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
if (StateAfter == TopAbs_IN) {
if (!SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0) domain.SetFirstPoint (Hatching.Point(ISav)) ;
ToAppend = Standard_True ;
}
} else if (SegmentBegin) {
if (Segments) {
if (!SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0) domain.SetFirstPoint (Hatching.Point(ISav)) ;
ToAppend = Standard_True ;
}
return ;
}
} else {
if (StateAfter == TopAbs_IN) {
if (!SavPnt) {
if(NoDomain) {
Hatching.Status (HatchGen_IncoherentParity) ;
}
else {
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0) domain.SetFirstPoint (Hatching.Point(ISav)) ;
ToAppend = Standard_True ;
}
if(ISav != 0)
domain.SetFirstPoint (Hatching.Point(ISav)) ;
ToAppend = Standard_True ;
}
}
if (ToAppend) Hatching.AddDomain (domain) ;
else if (SegmentEnd)
{
if (StateAfter == TopAbs_IN)
{
if (!SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0)
domain.SetFirstPoint (Hatching.Point(ISav)) ;
ToAppend = Standard_True ;
}
}
else if (SegmentBegin)
{
if (Segments)
{
if (!SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0)
domain.SetFirstPoint (Hatching.Point(ISav)) ;
ToAppend = Standard_True ;
}
}
else
{
if (StateAfter == TopAbs_IN)
{
if(!SavPnt)
{
if(NoDomain)
{
Hatching.Status (HatchGen_IncoherentParity) ;
}
else
{
Hatching.IsDone(Standard_True);
}
return ;
}
if (ISav != 0)
domain.SetFirstPoint (Hatching.Point(ISav)) ;
ToAppend = Standard_True ;
}
}
if (ToAppend)
Hatching.AddDomain (domain) ;
}
}
Hatching.IsDone(Standard_True) ;
}

48
src/GeometryTest/GeometryTest_APICommands.cxx
View File

@ -49,12 +49,12 @@ Standard_IMPORT Draw_Viewer dout;
//=======================================================================
static Standard_Integer proj (Draw_Interpretor& di, Standard_Integer n, const char** a)
{
{
if ( n < 5)
{
{
cout << " Use proj curve/surf x y z [extrema algo: g(grad)/t(tree)]" << endl;
return 1;
}
}
gp_Pnt P(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4]));
@ -68,9 +68,9 @@ static Standard_Integer proj (Draw_Interpretor& di, Standard_Integer n, const ch
aProjAlgo = Extrema_ExtAlgo_Tree;
if (GC.IsNull())
{
{
GS = DrawTrSurf::GetSurface(a[1]);
if (GS.IsNull())
return 1;
@ -81,21 +81,21 @@ static Standard_Integer proj (Draw_Interpretor& di, Standard_Integer n, const ch
Standard_Real UU,VV;
for ( Standard_Integer i = 1; i <= proj.NbPoints(); i++)
{
{
gp_Pnt P1 = proj.Point(i);
if ( P.Distance(P1) > Precision::Confusion())
{
{
Handle(Geom_Line) L = new Geom_Line(P,gp_Vec(P,P1));
Handle(Geom_TrimmedCurve) CT =
new Geom_TrimmedCurve(L, 0., P.Distance(P1));
Sprintf(name,"%s%d","ext_",i);
Sprintf(name,"%s%d","ext_",i);
char* temp = name; // portage WNT
DrawTrSurf::Set(temp, CT);
di << name << " ";
}
}
else
{
Sprintf(name,"%s%d","ext_",i);
{
Sprintf(name,"%s%d","ext_",i);
di << name << " ";
char* temp = name; // portage WNT
DrawTrSurf::Set(temp, P1);
@ -103,47 +103,47 @@ static Standard_Integer proj (Draw_Interpretor& di, Standard_Integer n, const ch
di << " Le point est sur la surface." << "\n";
di << " Ses parametres sont: UU = " << UU << "\n";
di << " VV = " << VV << "\n";
}
}
}
}
else
{
{
GeomAPI_ProjectPointOnCurve proj(P,GC,GC->FirstParameter(),
GC->LastParameter());
GC->LastParameter());
if(proj.NbPoints() == 0)
{
{
cout << "No project point was found." << endl;
return 0;
}
}
for ( Standard_Integer i = 1; i <= proj.NbPoints(); i++)
{
{
gp_Pnt P1 = proj.Point(i);
Standard_Real UU = proj.Parameter(i);
di << " parameter " << i << " = " << UU << "\n";
if ( P.Distance(P1) > Precision::Confusion())
{
{
Handle(Geom_Line) L = new Geom_Line(P,gp_Vec(P,P1));
Handle(Geom_TrimmedCurve) CT =
new Geom_TrimmedCurve(L, 0., P.Distance(P1));
Sprintf(name,"%s%d","ext_",i);
new Geom_TrimmedCurve(L, 0., P.Distance(P1));
Sprintf(name,"%s%d","ext_",i);
char* temp = name; // portage WNT
DrawTrSurf::Set(temp, CT);
di << name << " ";
}
}
else
{
Sprintf(name,"%s%d","ext_",i);
{
Sprintf(name,"%s%d","ext_",i);
char* temp = name; // portage WNT
DrawTrSurf::Set(temp, P1);
di << name << " ";
UU = proj.Parameter(i);
di << " Le point est sur la courbe." << "\n";
di << " Son parametre est U = " << UU << "\n";
}
}
}
}
return 0;
}

104
src/IntAna/IntAna_QuadQuadGeo.cxx
View File

@ -955,16 +955,21 @@ void IntAna_QuadQuadGeo::Perform(const gp_Cylinder& Cyl1,
Standard_Real DistA1A2=A1A2.Distance();
if(A1A2.Parallel()) {
if(DistA1A2<=Tol) {
if(RmR<=Tol) {
if(A1A2.Parallel())
{
if(DistA1A2<=Tol)
{
if(RmR<=Tol)
{
typeres=IntAna_Same;
}
else {
else
{
typeres=IntAna_Empty;
}
}
else { //-- DistA1A2 > Tol
else
{ //-- DistA1A2 > Tol
gp_Pnt P1=Cyl1.Location();
gp_Pnt P2t=Cyl2.Location();
gp_Pnt P2;
@ -972,28 +977,30 @@ void IntAna_QuadQuadGeo::Perform(const gp_Cylinder& Cyl1,
gp_Dir DirCyl = Cyl1.Position().Direction();
Standard_Real ProjP2OnDirCyl1=gp_Vec(DirCyl).Dot(gp_Vec(P1,P2t));
P2.SetCoord( P2t.X() - ProjP2OnDirCyl1*DirCyl.X()
,P2t.Y() - ProjP2OnDirCyl1*DirCyl.Y()
,P2t.Z() - ProjP2OnDirCyl1*DirCyl.Z());
P2.SetCoord(P2t.X() - ProjP2OnDirCyl1*DirCyl.X(),
P2t.Y() - ProjP2OnDirCyl1*DirCyl.Y(),
P2t.Z() - ProjP2OnDirCyl1*DirCyl.Z());
//--
Standard_Real R1pR2=R1+R2;
if(DistA1A2>(R1pR2+Tol)) {
if(DistA1A2>(R1pR2+Tol))
{
typeres=IntAna_Empty;
nbint=0;
}
else if(DistA1A2>(R1pR2)) {
else if(DistA1A2>(R1pR2))
{
//-- 1 Tangent line -------------------------------------OK
typeres=IntAna_Line;
nbint=1;
dir1=DirCyl;
Standard_Real R1_R1pR2=R1/R1pR2;
pt1.SetCoord( P1.X() + R1_R1pR2 * (P2.X()-P1.X())
,P1.Y() + R1_R1pR2 * (P2.Y()-P1.Y())
,P1.Z() + R1_R1pR2 * (P2.Z()-P1.Z()));
pt1.SetCoord( P1.X() + R1_R1pR2 * (P2.X()-P1.X()),
P1.Y() + R1_R1pR2 * (P2.Y()-P1.Y()),
P1.Z() + R1_R1pR2 * (P2.Z()-P1.Z()));
}
else if(DistA1A2>RmR) {
else if(DistA1A2>RmR)
{
//-- 2 lines ---------------------------------------------OK
typeres=IntAna_Line;
nbint=2;
@ -1004,38 +1011,42 @@ void IntAna_QuadQuadGeo::Perform(const gp_Cylinder& Cyl1,
dir2=dir1;
Standard_Real Alpha=0.5*(R1*R1-R2*R2+DistA1A2*DistA1A2)/(DistA1A2);
// Standard_Real Beta = Sqrt(R1*R1-Alpha*Alpha);
//Standard_Real Beta = Sqrt(R1*R1-Alpha*Alpha);
Standard_Real anSqrtArg = R1*R1-Alpha*Alpha;
Standard_Real Beta = (anSqrtArg > 0.) ? Sqrt(anSqrtArg) : 0.;
if((Beta+Beta)<Tol) {
if((Beta+Beta)<Tol)
{
nbint=1;
pt1.SetCoord( P1.X() + Alpha*DirA1A2.X()
,P1.Y() + Alpha*DirA1A2.Y()
,P1.Z() + Alpha*DirA1A2.Z());
}
else {
pt1.SetCoord( P1.X() + Alpha*DirA1A2.X() + Beta*Ortho_dir1_P1P2.X()
,P1.Y() + Alpha*DirA1A2.Y() + Beta*Ortho_dir1_P1P2.Y()
,P1.Z() + Alpha*DirA1A2.Z() + Beta*Ortho_dir1_P1P2.Z() );
else
{
pt1.SetCoord( P1.X() + Alpha*DirA1A2.X() + Beta*Ortho_dir1_P1P2.X(),
P1.Y() + Alpha*DirA1A2.Y() + Beta*Ortho_dir1_P1P2.Y(),
P1.Z() + Alpha*DirA1A2.Z() + Beta*Ortho_dir1_P1P2.Z());
pt2.SetCoord( P1.X() + Alpha*DirA1A2.X() - Beta*Ortho_dir1_P1P2.X()
,P1.Y() + Alpha*DirA1A2.Y() - Beta*Ortho_dir1_P1P2.Y()
,P1.Z() + Alpha*DirA1A2.Z() - Beta*Ortho_dir1_P1P2.Z());
pt2.SetCoord( P1.X() + Alpha*DirA1A2.X() - Beta*Ortho_dir1_P1P2.X(),
P1.Y() + Alpha*DirA1A2.Y() - Beta*Ortho_dir1_P1P2.Y(),
P1.Z() + Alpha*DirA1A2.Z() - Beta*Ortho_dir1_P1P2.Z());
}
}
else if(DistA1A2>(RmR-Tol)) {
else if(DistA1A2>(RmR-Tol))
{
//-- 1 Tangent ------------------------------------------OK
typeres=IntAna_Line;
nbint=1;
dir1=DirCyl;
Standard_Real R1_RmR=R1/RmR;
if(R1 < R2) R1_RmR = -R1_RmR;
if(R1 < R2)
R1_RmR = -R1_RmR;
pt1.SetCoord( P1.X() + R1_RmR * (P2.X()-P1.X())
,P1.Y() + R1_RmR * (P2.Y()-P1.Y())
,P1.Z() + R1_RmR * (P2.Z()-P1.Z()));
pt1.SetCoord( P1.X() + R1_RmR * (P2.X()-P1.X()),
P1.Y() + R1_RmR * (P2.Y()-P1.Y()),
P1.Z() + R1_RmR * (P2.Z()-P1.Z()));
}
else {
nbint=0;
@ -1045,7 +1056,8 @@ void IntAna_QuadQuadGeo::Perform(const gp_Cylinder& Cyl1,
}
else { //-- No Parallel Axis ---------------------------------OK
if((RmR_Relative<=myEPSILON_CYLINDER_DELTA_RADIUS)
&& (DistA1A2 <= myEPSILON_CYLINDER_DELTA_DISTANCE)) {
&& (DistA1A2 <= myEPSILON_CYLINDER_DELTA_DISTANCE))
{
//-- PI/2 between the two axis and Intersection
//-- and identical radius
typeres=IntAna_Ellipse;
@ -1059,12 +1071,12 @@ void IntAna_QuadQuadGeo::Perform(const gp_Cylinder& Cyl1,
B=Abs(Sin(0.5*(M_PI-A)));
A=Abs(Sin(0.5*A));
if(A==0.0 || B==0.0) {
if(A==0.0 || B==0.0)
{
typeres=IntAna_Same;
return;
}
gp_Vec dircyl1(DirCyl1);gp_Vec dircyl2(DirCyl2);
dir1 = gp_Dir(dircyl1.Added(dircyl2));
dir2 = gp_Dir(dircyl1.Subtracted(dircyl2));
@ -1072,15 +1084,24 @@ void IntAna_QuadQuadGeo::Perform(const gp_Cylinder& Cyl1,
param2 = Cyl1.Radius() / A;
param1 = Cyl1.Radius() / B;
param2bis= param1bis = Cyl1.Radius();
if(param1 < param1bis) {
A=param1; param1=param1bis; param1bis=A;
if(param1 < param1bis)
{
A=param1;
param1=param1bis;
param1bis=A;
}
if(param2 < param2bis) {
A=param2; param2=param2bis; param2bis=A;
if(param2 < param2bis)
{
A=param2;
param2=param2bis;
param2bis=A;
}
}
else {
if(Abs(DistA1A2-Cyl1.Radius()-Cyl2.Radius())<Tol) {
else
{
if(Abs(DistA1A2-Cyl1.Radius()-Cyl2.Radius())<Tol)
{
typeres = IntAna_Point;
Standard_Real d,p1,p2;
@ -1091,19 +1112,24 @@ void IntAna_QuadQuadGeo::Perform(const gp_Cylinder& Cyl1,
gp_Pnt P1(P.X() - p1*D1.X(),
P.Y() - p1*D1.Y(),
P.Z() - p1*D1.Z());
P = Cyl2.Axis().Location();
gp_Pnt P2(P.X() - p2*D2.X(),
P.Y() - p2*D2.Y(),
P.Z() - p2*D2.Z());
gp_Vec P1P2(P1,P2);
D1=gp_Dir(P1P2);
p1=Cyl1.Radius();
pt1.SetCoord(P1.X() + p1*D1.X(),
P1.Y() + p1*D1.Y(),
P1.Z() + p1*D1.Z());
nbint = 1;
}
else {
else
{
typeres=IntAna_NoGeometricSolution;
}
}

3
src/IntPatch/IntPatch_ImpImpIntersection.cdl
View File

@ -54,7 +54,8 @@ is
Perform (me: in out;
S1: HSurface from Adaptor3d; D1: TopolTool from Adaptor3d;
S2: HSurface from Adaptor3d; D2: TopolTool from Adaptor3d;
TolArc,TolTang: Real from Standard)
TolArc,TolTang: Real from Standard;
isTheTrimmed: Boolean from Standard = Standard_False)
raises ConstructionError from Standard

14
src/IntPatch/IntPatch_ImpImpIntersection_1.gxx
View File

@ -14,6 +14,8 @@
// 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,
@ -77,6 +79,18 @@ static Standard_Boolean IntCyCy(const IntSurf_Quadric&,
IntPatch_SequenceOfLine&,
IntPatch_SequenceOfPoint&);
static Standard_Boolean IntCyCyTrim(const IntSurf_Quadric& theQuad1,
const IntSurf_Quadric& theQuad2,
const Standard_Real theTol3D,
const Standard_Real theTol2D,
const Bnd_Box2d& theUVSurf1,
const Bnd_Box2d& theUVSurf2,
const Standard_Boolean isTheReverse,
Standard_Boolean& isTheEmpty,
IntPatch_SequenceOfLine& theSlin,
IntPatch_SequenceOfPoint& theSPnt);
static Standard_Boolean IntCySp(const IntSurf_Quadric&,
const IntSurf_Quadric&,
const Standard_Real,

293
src/IntPatch/IntPatch_ImpImpIntersection_2.gxx
View File

@ -50,8 +50,10 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang) {
const Standard_Real TolTang,
const Standard_Boolean isTheTrimmed) {
done = Standard_False;
Standard_Boolean isTrimmed = isTheTrimmed;
spnt.Clear();
slin.Clear();
@ -142,13 +144,61 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
break;
}
//
case 22: { // Cylinder/Cylinder
if (!IntCyCy(quad1, quad2, TolTang, empt, SameSurf, multpoint, slin, spnt)) {
return;
case 22:
{ // Cylinder/Cylinder
Standard_Boolean isDONE = Standard_False;
if(!isTrimmed)
{
isDONE = IntCyCy(quad1, quad2, TolTang, empt,
SameSurf, multpoint, slin, spnt);
}
else
{
Bnd_Box2d aBox1, aBox2;
const Standard_Real aU1f = S1->FirstUParameter();
const Standard_Real aU1l = S1->LastUParameter();
const Standard_Real aU2f = S2->FirstUParameter();
const Standard_Real aU2l = S2->LastUParameter();
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()));
const Standard_Real a2DTol = Min( S1->UResolution(TolTang),
S2->UResolution(TolTang));
Standard_Boolean isReversed = ((aU2l - aU2f) < (aU1l - aU1f));
if(isReversed)
{
isDONE = IntCyCyTrim(quad2, quad1, TolTang, a2DTol, aBox2, aBox1,
isReversed, empt, slin, spnt);
}
else
{
isDONE = IntCyCyTrim(quad1, quad2, TolTang, a2DTol, aBox1, aBox2,
isReversed, empt, slin, spnt);
}
if(!isDONE)
{
isDONE = IntCyCy(quad1, quad2, TolTang, empt,
SameSurf, multpoint, slin, spnt);
isTrimmed = Standard_False;
}
}
if (!isDONE)
{
return;
}
bEmpty = empt;
break;
}
bEmpty = empt;
break;
}
//
case 23:
case 32: { // Cylinder/Cone
@ -238,136 +288,140 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
return;
}
//
if (!SameSurf) {
AFunc.SetQuadric(quad2);
AFunc.Set(S1);
if(!isTrimmed)
{
if (!SameSurf) {
AFunc.SetQuadric(quad2);
AFunc.Set(S1);
solrst.Perform(AFunc, D1, TolArc, TolTang);
if (!solrst.IsDone()) {
return;
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++) {
pnt1.Append(solrst.Point(i));
}
for (i=1; i<= nbseg; i++) {
edg1.Append(solrst.Segment(i));
}
nosolonS1 = (nbpt == 0) && (nbseg == 0);
if (nosolonS1 && all1) { // cas de face sans restrictions
all1 = Standard_False;
}
}//if (!SameSurf) {
else {
nosolonS1 = Standard_True;
}
if (solrst.AllArcSolution() && typs1 == typs2) {
all1 = Standard_True;
}
nbpt = solrst.NbPoints();
nbseg= solrst.NbSegments();
for (i=1; i<= nbpt; i++) {
pnt1.Append(solrst.Point(i));
}
for (i=1; i<= nbseg; i++) {
edg1.Append(solrst.Segment(i));
}
nosolonS1 = (nbpt == 0) && (nbseg == 0);
if (!SameSurf) {
AFunc.SetQuadric(quad1);
AFunc.Set(S2);
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;
}
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++) {
pnt2.Append(solrst.Point(i));
}
if (solrst.AllArcSolution() && typs1 == typs2) {
all2 = Standard_True;
}
nbpt = solrst.NbPoints();
nbseg= solrst.NbSegments();
for (i=1; i<= nbpt; i++) {
pnt2.Append(solrst.Point(i));
}
for (i=1; i<= nbseg; i++) {
edg2.Append(solrst.Segment(i));
}
nosolonS2 = (nbpt == 0) && (nbseg == 0);
for (i=1; i<= nbseg; i++) {
edg2.Append(solrst.Segment(i));
}
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;
if (nosolonS2 && all2) { // cas de face sans restrictions
all2 = Standard_False;
}
}// if (!SameSurf) {
else {
nosolonS2 = Standard_True;
}
//
oppo = quad1.Normale(Ptreference).Dot(quad2.Normale(Ptreference)) < 0.0;
done = Standard_True;
return;
}// if (SameSurf || (all1 && all2)) {
if (SameSurf || (all1 && all2)) {
// faces "paralleles" parfaites
empt = Standard_False;
tgte = Standard_True;
slin.Clear();
spnt.Clear();
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);
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;
done = Standard_True;
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);
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 (edg1.Length() != 0) {
ProcessSegments(edg1,slin,quad1,quad2,Standard_True,TolArc);
}
if (edg2.Length() != 0) {
ProcessSegments(edg2,slin,quad1,quad2,Standard_False,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);
if (edg1.Length() !=0 || edg2.Length() !=0) {
// ProcessRLine(slin,S1,S2,TolArc);
ProcessRLine(slin,quad1,quad2,TolArc);
}
}//if (!nosolonS1 || !nosolonS2) {
else {
empt = ((slin.Length()==0) && (spnt.Length()==0));
}
}//if (!nosolonS1 || !nosolonS2) {
else {
empt = ((slin.Length()==0) && (spnt.Length()==0));
}
//
Standard_Integer nblin, aNbPnt;
Standard_Integer nblin = slin.Length(),
aNbPnt = spnt.Length();
//
//modified by NIZNHY-PKV Tue Sep 06 10:03:35 2011f
aNbPnt=spnt.Length();
if (aNbPnt) {
IntPatch_SequenceOfPoint aSIP;
//
@ -401,7 +455,6 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
}// if (aNbPnt) {
//modified by NIZNHY-PKV Tue Sep 06 10:18:20 2011t
//
nblin = slin.Length();
for(i=1; i<=nblin; i++) {
IntPatch_IType thetype = slin.Value(i)->ArcType();
if( (thetype == IntPatch_Ellipse)

1961
src/IntPatch/IntPatch_ImpImpIntersection_4.gxx
View File

File diff suppressed because it is too large Load Diff

10
src/IntPatch/IntPatch_Intersection.cdl
View File

@ -143,6 +143,16 @@ is
typs1, typs2: SurfaceType from GeomAbs)
is private;
GeomGeomPerfomTrimSurf( me: in out;
S1: HSurface from Adaptor3d; D1: TopolTool from Adaptor3d;
S2: HSurface from Adaptor3d; D2: TopolTool from Adaptor3d;
TolArc,TolTang: Real from Standard;
LOfPnts: in out ListOfPntOn2S from IntSurf;
RestrictLine: Boolean from Standard;
typs1, typs2: SurfaceType from GeomAbs)
is private;
GeomParamPerfom(me: in out;
S1: HSurface from Adaptor3d; D1: TopolTool from Adaptor3d;

76
src/IntPatch/IntPatch_Intersection.cxx
View File

@ -1137,7 +1137,16 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1,
}
else if(ts1 == 1)
{
GeomGeomPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
if(theD1->DomainIsInfinite() || theD2->DomainIsInfinite())
{
GeomGeomPerfom(theS1, theD1, theS2, theD2, TolArc,
TolTang, ListOfPnts, RestrictLine, typs1, typs2);
}
else
{
GeomGeomPerfomTrimSurf(theS1, theD1, theS2, theD2,
TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
}
}
}
@ -1357,16 +1366,17 @@ void IntPatch_Intersection::GeomGeomPerfom(const Handle(Adaptor3d_HSurface)& the
}
//=======================================================================
////function : GeomParamPerfom
//function : GeomParamPerfom
//purpose :
//=======================================================================
void IntPatch_Intersection::GeomParamPerfom(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_TopolTool)& theD1,
const Handle(Adaptor3d_HSurface)& theS2,
const Handle(Adaptor3d_TopolTool)& theD2,
const Standard_Boolean isNotAnalitical,
const GeomAbs_SurfaceType typs1,
const GeomAbs_SurfaceType typs2)
void IntPatch_Intersection::
GeomParamPerfom(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_TopolTool)& theD1,
const Handle(Adaptor3d_HSurface)& theS2,
const Handle(Adaptor3d_TopolTool)& theD2,
const Standard_Boolean isNotAnalitical,
const GeomAbs_SurfaceType typs1,
const GeomAbs_SurfaceType typs2)
{
IntPatch_ImpPrmIntersection interip;
if (myIsStartPnt)
@ -1439,6 +1449,54 @@ void IntPatch_Intersection::GeomParamPerfom(const Handle(Adaptor3d_HSurface)& t
}
}
//=======================================================================
//function : GeomGeomPerfomTrimSurf
//purpose : This function returns ready walking-line (which is not need
// in convertation) as an intersection line between two
// trimmed surfaces.
//=======================================================================
void IntPatch_Intersection::
GeomGeomPerfomTrimSurf( const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_TopolTool)& theD1,
const Handle(Adaptor3d_HSurface)& theS2,
const Handle(Adaptor3d_TopolTool)& theD2,
const Standard_Real theTolArc,
const Standard_Real theTolTang,
IntSurf_ListOfPntOn2S& theListOfPnts,
const Standard_Boolean RestrictLine,
const GeomAbs_SurfaceType theTyps1,
const GeomAbs_SurfaceType theTyps2)
{
IntSurf_Quadric Quad1,Quad2;
if((theTyps1 == GeomAbs_Cylinder) && (theTyps2 == GeomAbs_Cylinder))
{
IntPatch_ImpImpIntersection anInt;
anInt.Perform(theS1, theD1, theS2, theD2, theTolArc, theTolTang, Standard_True);
done = anInt.IsDone();
const Standard_Integer aNbLin = anInt.NbLines();
const Standard_Integer aNbPts = anInt.NbPnts();
for(Standard_Integer aLID = 1; aLID <= aNbLin; aLID++)
{
const Handle(IntPatch_Line)& aLine = anInt.Line(aLID);
slin.Append(aLine);
}
for(Standard_Integer aPID = 1; aPID <= aNbPts; aPID++)
{
const IntPatch_Point& aPoint = anInt.Point(aPID);
spnt.Append(aPoint);
}
}
else
{
GeomGeomPerfom(theS1, theD1, theS2, theD2, theTolArc, theTolTang, theListOfPnts, RestrictLine, theTyps1, theTyps2);
}
}
void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_TopolTool)& D1,

15
src/Standard/Standard_Real.hxx
View File

@ -243,6 +243,21 @@ inline Standard_Real Min (const Standard_Real Val1,
return Val1 <= Val2 ? Val1 : Val2;
}
// ------------------------------------------------------------------
// MinMax : Replaces theParMIN = MIN(theParMIN, theParMAX),
// theParMAX = MAX(theParMIN, theParMAX).
// ------------------------------------------------------------------
inline void MinMax(Standard_Real& theParMIN, Standard_Real& theParMAX)
{
if(theParMIN > theParMAX)
{
const Standard_Real aux = theParMAX;
theParMAX = theParMIN;
theParMIN = aux;
}
}
//-------------------------------------------------------------------
// Pow : Returns a real to a given power
//-------------------------------------------------------------------

2
tests/blend/bfuseblend/B7
View File

@ -6,4 +6,4 @@ tscale s1 0 0 0 SCALE1
tscale s2 0 0 0 SCALE1
bfuseblend result s1 s2 1*SCALE1
set square 54092.4
set square 53457.8

12
tests/bugs/modalg_2/bug22864
View File

@ -18,15 +18,15 @@ add f2 aShape
#
set status 0
#
set nb_v_good 2
set nb_e_good 3
set nb_w_good 1
set nb_f_good 1
set nb_v_good 8
set nb_e_good 12
set nb_w_good 4
set nb_f_good 4
set nb_sh_good 0
set nb_sol_good 0
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 8
set nb_shape_good 29
#
set Numbers 11
#
@ -95,7 +95,7 @@ if {${status} == 0} {
puts "Faulty ${BugNumber}"
}
set square 6935.38
set square 8444.76
set 2dviewer 0

4
tests/bugs/modalg_2/bug22967
View File

@ -7,7 +7,7 @@ puts ""
###########################################################################################################
set BugNumber OCC22967
set check_value 1.04742e-05
set check_value 3.46945e-006
restore [locate_data_file bug22967_Cylinder_1.brep] b1
restore [locate_data_file bug22967_Scale_1.brep] b2
@ -54,6 +54,6 @@ if {${status} > 0} {
puts "OK ${BugNumber}"
}
set square 671262
set square 669221
set 2dviewer 0

2
tests/bugs/modalg_2/bug23218
View File

@ -19,7 +19,7 @@ set result [bopcurves b1 b2]
puts $result
puts "Finish project operation ..."
set GoodToleranceReached 8.9651741230950248e-06
set GoodToleranceReached 2.4950140688989345e-006
regexp {Tolerance Reached=([-0-9.+eE]+)} $result full ToleranceReached
proc GetPercent {Value GoodValue} {

6
tests/bugs/modalg_5/bug24798
View File

@ -15,14 +15,14 @@ bopcut result
set square 1826.15
# Analysis of "nbshapes res"
set nb_v_good 44
set nb_e_good 67
set nb_v_good 49
set nb_e_good 72
set nb_w_good 29
set nb_f_good 22
set nb_sh_good 1
set nb_sol_good 1
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 165
set nb_shape_good 175
set 2dviewer 1

6
tests/bugs/modalg_5/bug24825_common
View File

@ -45,14 +45,14 @@ bbop result 0
set square 10008.5
set nb_v_good 86
set nb_e_good 132
set nb_v_good 260
set nb_e_good 306
set nb_w_good 126
set nb_f_good 126
set nb_sh_good 40
set nb_sol_good 40
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 551
set nb_shape_good 899
set 2dviewer 1

6
tests/bugs/modalg_5/bug24825_cut
View File

@ -45,14 +45,14 @@ bbop result 2
set square 103838
set nb_v_good 106
set nb_e_good 164
set nb_v_good 280
set nb_e_good 338
set nb_w_good 142
set nb_f_good 80
set nb_sh_good 3
set nb_sol_good 3
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 499
set nb_shape_good 847
set 2dviewer 1

6
tests/bugs/modalg_5/bug24825_fuse
View File

@ -46,14 +46,14 @@ bbop result 1
set square 157211
set nb_v_good 106
set nb_e_good 164
set nb_v_good 280
set nb_e_good 338
set nb_w_good 142
set nb_f_good 80
set nb_sh_good 1
set nb_sol_good 1
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 495
set nb_shape_good 843
set 2dviewer 1

96
tests/bugs/modalg_5/bug24915 Executable file
View File

@ -0,0 +1,96 @@
puts "========="
puts "CR24915"
puts "========="
puts ""
###############################
## Wrong intersection curves between two cylinders
###############################
proc checkList {List Tolerance D_good Limit_Tol} {
set L1 [llength ${List}]
set L2 10
set L3 5
set N [expr (${L1} - ${L2})/${L3} + 1]
for {set i 1} {${i} <= ${N}} {incr i} {
set j1 [expr ${L2} + (${i}-1)*${L3}]
set j2 [expr ${j1} + 2]
set T [lindex ${List} ${j1}]
set D [lindex ${List} ${j2}]
#puts "i=${i} j1=${j1} j2=${j2} T=${T} D=${D}"
if { [expr abs(${D} - ${D_good})] > ${Tolerance} } {
puts "Error : T=${T} D=${D}"
}
if { [expr abs(${D} - ${D_good})] > ${Limit_Tol}
&& [expr abs(${D} - ${D_good})] <= ${Tolerance} } {
puts "Attention (critical value of tolerance) : T=${T} D=${D}"
}
}
}
puts "##############################"
puts "#!!!Searh \"Attention\" keyword on this web-page for additinal checking!!!"
puts "##############################"
restore [locate_data_file bug24915_ft2.brep] b1
restore [locate_data_file bug24915_ft3.brep] b2
# 1. topology
bclearobjects
bcleartools
baddobjects b1 b2
bfillds
bbuild r
checkshape r
# 2. geometry
set MaxTol 1.5e-6
set log [bopcurves b1 b2]
mksurface s1 b1
mksurface s2 b2
regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} ${log} full Toler NbCurv
if {${Toler} > ${MaxTol}} {
puts "Error: Tolerance is too big!"
}
for {set i 1} {$i <= ${NbCurv}} {incr i} {
set log [dump c_$i]
regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles
set Knot 1
set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U1 Mult1
set Knot ${KnotsPoles}
set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U2 Mult2
dlog reset
dlog on
xdistcs c_$i s1 ${U1} ${U2} 100
set Log2 [dlog get]
set List2 [split ${Log2} {TD= \t\n}]
set Tolerance 1.6e-5
set Limit_Tol 1.0e-7
set D_good 0.
catch {checkList ${List2} ${Tolerance} ${D_good} ${Limit_Tol}}
dlog reset
dlog on
xdistcs c_$i s2 ${U1} ${U2} 100
set Log2 [dlog get]
set List2 [split ${Log2} {TD= \t\n}]
set Tolerance 1.6e-5
set Limit_Tol 1.0e-7
set D_good 0.
catch {checkList ${List2} ${Tolerance} ${D_good} ${Limit_Tol}}
}
smallview
donly b2 c_2
fit
set only_screen_axo 1

6
tests/bugs/modalg_5/bug24981
View File

@ -20,14 +20,14 @@ baddtools b_1 b_2 b_3 b_4 b_5 b_6 b_7 b_8 b_9 b_10 b_11 b_12 b_13 b_14 b_15 b_16
bfillds
bbuild result
set nb_v_good 122
set nb_e_good 220
set nb_v_good 268
set nb_e_good 366
set nb_w_good 243
set nb_f_good 195
set nb_sh_good 75
set nb_sol_good 75
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 931
set nb_shape_good 1223
set 2dviewer 1