OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-06-10 11:34:06 +03:00
Code
occt/src/IntCurve/IntCurve_IntCurveCurveGen.gxx
aml 5ae6e53dec 0027341: Incorrect exact HLR results 
- removal of excess interferences in case of simple hiding face
- correct processing of boundary edges coinciding with outlines
- change of API for testing Draw Command
- correction of Draw command "build3d"
- test cases are added.

Linux reference data is changed.

Partially fixed 0027340: Insufficient exact HLR speed

Number of samples in PolyPoly intersection algorithm tuned in each instance of generic class.
Default number of the samples in Geom2dAdaptor is changed according to the Adaptor2d_Curve2d class.
Minimal number of points in case of B-Spline is changed.
Minimal number of samples support is added in intersection algorithms.
2016-05-27 11:57:50 +03:00

1136 lines
29 KiB
Plaintext
Raw Blame History

// Created on: 1992-10-12
// Created by: Laurent BUCHARD
// Copyright (c) 1992-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomAbs_CurveType.hxx>
#include <IntCurve_IntConicConic.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Circ2d.hxx>
#include <gp_Elips2d.hxx>
#include <gp_Parab2d.hxx>
#include <gp_Hypr2d.hxx>
#include <Precision.hxx>
#include <TColStd_Array1OfReal.hxx>
void IntCurve_IntCurveCurveGen::Perform(const TheCurve& C,
const Standard_Real TolConf,
const Standard_Real Tol) {
IntRes2d_Domain D1;
Standard_Real TolDomain = Tol;
if(Tol<TolConf) TolDomain = TolConf;
GeomAbs_CurveType typ = TheCurveTool::GetType(C);
switch(typ) {
case GeomAbs_Ellipse:
case GeomAbs_Circle:
case GeomAbs_Parabola:
case GeomAbs_Hyperbola:
case GeomAbs_Line:
ResetFields();
done = Standard_True;
return;
default:
{
Standard_Real paraminf = TheCurveTool::FirstParameter(C);
Standard_Real paramsup = TheCurveTool::LastParameter(C);
if(paraminf>-Precision::Infinite()) {
if(paramsup<Precision::Infinite()) {
//-- paraminf-----------paramsup
D1.SetValues(TheCurveTool::Value(C,paraminf),
paraminf,
TolDomain,
TheCurveTool::Value(C,paramsup),
paramsup,
TolDomain);
}
else {
//-- paraminf------------...
D1.SetValues(TheCurveTool::Value(C,paraminf),
paraminf,
TolDomain,
Standard_True);
}
}
else {
if(paramsup<Precision::Infinite()) {
//-- ...-----------------paramsup
D1.SetValues(TheCurveTool::Value(C,paramsup),
paramsup,
TolDomain,
Standard_False);
}
}
this->ResetFields();
intcurvcurv.SetReversedParameters(Standard_False);
intcurvcurv.Perform(C,D1,TolConf,Tol);
this->SetValues(intcurvcurv);
done = Standard_True;
}
}
}
void IntCurve_IntCurveCurveGen::Perform(const TheCurve& C,
const IntRes2d_Domain& D,
const Standard_Real TolConf,
const Standard_Real Tol) {
GeomAbs_CurveType typ = TheCurveTool::GetType(C);
switch(typ) {
case GeomAbs_Ellipse:
case GeomAbs_Circle:
case GeomAbs_Parabola:
case GeomAbs_Hyperbola:
case GeomAbs_Line:
ResetFields();
done = Standard_True;
return;
default:
{
this->ResetFields();
intcurvcurv.SetReversedParameters(Standard_False);
intcurvcurv.Perform(C,D,TolConf,Tol);
this->SetValues(intcurvcurv);
done = Standard_True;
}
}
}
//----------------------------------------------------------------------
IntRes2d_Domain IntCurve_IntCurveCurveGen::ComputeDomain(const TheCurve& C1,
const Standard_Real TolDomain) const {
IntRes2d_Domain D1;
GeomAbs_CurveType typ = TheCurveTool::GetType(C1);
switch(typ) {
case GeomAbs_Ellipse:
case GeomAbs_Circle: {
//---------------------------------------------------------------
//-- if the curve is a trimmed curve, first and last parameters
//-- will be the parameters used to buid the domain
//--
Standard_Real firstparameter = TheCurveTool::FirstParameter(C1);
Standard_Real lastparameter = TheCurveTool::LastParameter(C1);
gp_Pnt2d P1(TheCurveTool::Value(C1,firstparameter));
gp_Pnt2d P2(TheCurveTool::Value(C1,lastparameter));
D1.SetValues(P1,firstparameter ,TolDomain,
P2,lastparameter ,TolDomain);
D1.SetEquivalentParameters(firstparameter,firstparameter+M_PI+M_PI);
break;
}
default: {
Standard_Real paraminf = TheCurveTool::FirstParameter(C1);
Standard_Real paramsup = TheCurveTool::LastParameter(C1);
if(paraminf>-Precision::Infinite()) {
if(paramsup<Precision::Infinite()) {
//-- paraminf-----------paramsup
D1.SetValues(TheCurveTool::Value(C1,paraminf),
paraminf,
TolDomain,
TheCurveTool::Value(C1,paramsup),
paramsup,
TolDomain);
}
else {
//-- paraminf------------...
D1.SetValues(TheCurveTool::Value(C1,paraminf),
paraminf,
TolDomain,
Standard_True);
}
}
else {
if(paramsup<Precision::Infinite()) {
//-- ...-----------------paramsup
D1.SetValues(TheCurveTool::Value(C1,paramsup),
paramsup,
TolDomain,
Standard_False);
}
}
break;
}
}
return(D1);
}
//----------------------------------------------------------------------
//-- Perform : Si Une des courbes est Composite Alors decompose les appels
//----------------------------------------------------------------------
void IntCurve_IntCurveCurveGen::Perform (const TheCurve& C1,
const IntRes2d_Domain& D1,
const TheCurve& C2,
const IntRes2d_Domain& D2,
const Standard_Real TolConf,
const Standard_Real Tol) {
this->ResetFields();
Standard_Integer nbi1 = TheCurveTool::NbIntervals(C1);
if(nbi1 > 1) {
param1inf = TheCurveTool::FirstParameter(C1);
param1sup = TheCurveTool::LastParameter(C1);
}
else {
param1inf = (D1.HasFirstPoint())? (D1.FirstParameter()) : -Precision::Infinite();
param1sup = (D1.HasLastPoint()) ? (D1.LastParameter()) : Precision::Infinite();
}
Standard_Integer nbi2 = TheCurveTool::NbIntervals(C2);
if(nbi2 > 1) {
param2inf = TheCurveTool::FirstParameter(C2);
param2sup = TheCurveTool::LastParameter(C2);
}
else {
param2inf = (D2.HasFirstPoint())? (D2.FirstParameter()) : -Precision::Infinite();
param2sup = (D2.HasLastPoint()) ? (D2.LastParameter()) : Precision::Infinite();
}
if(nbi1>1 || nbi2>1) {
TColStd_Array1OfReal Tab1(1,nbi1+1);
TColStd_Array1OfReal Tab2(1,nbi2+1);
TheCurveTool::Intervals(C1,Tab1);
TheCurveTool::Intervals(C2,Tab2);
InternalCompositePerform(C1,D1,1,nbi1,Tab1,
C2,D2,1,nbi2,Tab2,
TolConf,Tol,Standard_True);
return;
}
else {
InternalPerform(C1,D1,C2,D2,TolConf,Tol,Standard_False);
}
}
//----------------------------------------------------------------------
//-- InternalPerform
//-- Suppose des Courbes Lin...Other
//-- Si Composite == True
//-- Les Resultats sont Ajoutes
//-- Sinon
//-- Les Resultats sont Copies
//----------------------------------------------------------------------
void IntCurve_IntCurveCurveGen::InternalPerform (const TheCurve& C1,
const IntRes2d_Domain& D1,
const TheCurve& C2,
const IntRes2d_Domain& D2,
const Standard_Real TolConf,
const Standard_Real Tol,
const Standard_Boolean Composite)
{
GeomAbs_CurveType typ1 = TheCurveTool::GetType(C1);
GeomAbs_CurveType typ2 = TheCurveTool::GetType(C2);
switch (typ1)
{
case GeomAbs_Line:
switch (typ2)
{
case GeomAbs_Line:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Line(C1),D1,
TheCurveTool::Line(C2),D2,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Circle:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Line(C1),D1,
TheCurveTool::Circle(C2),D2,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Ellipse:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Line(C1),D1,
TheCurveTool::Ellipse(C2),D2,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Parabola:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Line(C1),D1,
TheCurveTool::Parabola(C2),D2,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Hyperbola:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Line(C1),D1,
TheCurveTool::Hyperbola(C2),D2,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(TheCurveTool::Line(C1),D1,
C2,D2,TolConf,Tol);
if(Composite)
{
this->Append(intconicurv,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconicurv);
}
}
break;
}
break;
case GeomAbs_Circle:
switch (typ2)
{
case GeomAbs_Line:
{
intconiconi.SetReversedParameters(Standard_True);
intconiconi.Perform(TheCurveTool::Line(C2),D2,
TheCurveTool::Circle(C1),D1,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Circle:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Circle(C1),D1,
TheCurveTool::Circle(C2),D2,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Ellipse:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Circle(C1),D1,
TheCurveTool::Ellipse(C2),D2,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Parabola:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Circle(C1),D1,
TheCurveTool::Parabola(C2),D2,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Hyperbola:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Circle(C1),D1,
TheCurveTool::Hyperbola(C2),D2,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(TheCurveTool::Circle(C1),D1,
C2,D2,TolConf,Tol);
if(Composite)
{
this->Append(intconicurv,
param1inf,
param1sup,
param2inf,
param2sup); }
else
{
this->SetValues(intconicurv);
}
}
break;
}
break;
case GeomAbs_Ellipse:
switch (typ2)
{
case GeomAbs_Line:
{
intconiconi.SetReversedParameters(Standard_True);
intconiconi.Perform(TheCurveTool::Line(C2),D2,
TheCurveTool::Ellipse(C1),D1,
TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Circle:
{
intconiconi.SetReversedParameters(Standard_True);
intconiconi.Perform(TheCurveTool::Circle(C2),D2,
TheCurveTool::Ellipse(C1),D1,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Ellipse:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Ellipse(C1),D1,
TheCurveTool::Ellipse(C2),D2,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Parabola:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Ellipse(C1),D1,
TheCurveTool::Parabola(C2),D2,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Hyperbola:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Ellipse(C1),D1,
TheCurveTool::Hyperbola(C2),D2,
TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(TheCurveTool::Ellipse(C1),D1,
C2,D2,TolConf,Tol);
if(Composite)
{
this->Append(intconicurv,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconicurv);
}
}
break;
}
break;
case GeomAbs_Parabola:
switch (typ2)
{
case GeomAbs_Line:
{
intconiconi.SetReversedParameters(Standard_True);
intconiconi.Perform(TheCurveTool::Line(C2),D2,
TheCurveTool::Parabola(C1),D1,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Circle:
{
intconiconi.SetReversedParameters(Standard_True);
intconiconi.Perform(TheCurveTool::Circle(C2),D2,
TheCurveTool::Parabola(C1),D1,TolConf,Tol);
if(Composite)
{ this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Ellipse:
{
intconiconi.SetReversedParameters(Standard_True);
intconiconi.Perform(TheCurveTool::Ellipse(C2),D2,
TheCurveTool::Parabola(C1),D1,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Parabola:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Parabola(C1),D1,
TheCurveTool::Parabola(C2),D2,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Hyperbola:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Parabola(C1),D1,
TheCurveTool::Hyperbola(C2),D2,
TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(TheCurveTool::Parabola(C1),D1,
C2,D2,TolConf,Tol);
if(Composite)
{
this->Append(intconicurv,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconicurv);
}
}
break;
}
break;
case GeomAbs_Hyperbola:
switch (typ2)
{
case GeomAbs_Line:
{
intconiconi.SetReversedParameters(Standard_True);
intconiconi.Perform(TheCurveTool::Line(C2),D2,
TheCurveTool::Hyperbola(C1),D1,TolConf,Tol);
if(Composite)
{
this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconiconi);
}
}
break;
case GeomAbs_Circle:
{
intconiconi.SetReversedParameters(Standard_True);
intconiconi.Perform(TheCurveTool::Circle(C2),D2,
TheCurveTool::Hyperbola(C1),D1,TolConf,Tol);
if(Composite) { this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup); }
else { this->SetValues(intconiconi); }
}
break;
case GeomAbs_Ellipse:
{
intconiconi.SetReversedParameters(Standard_True);
intconiconi.Perform(TheCurveTool::Ellipse(C2),D2,
TheCurveTool::Hyperbola(C1),D1,TolConf,Tol);
if(Composite) { this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup); }
else { this->SetValues(intconiconi); }
}
break;
case GeomAbs_Parabola:
{
intconiconi.SetReversedParameters(Standard_True);
intconiconi.Perform(TheCurveTool::Parabola(C2),D2,
TheCurveTool::Hyperbola(C1),D1,TolConf,Tol);
if(Composite) { this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup); }
else { this->SetValues(intconiconi); }
}
break;
case GeomAbs_Hyperbola:
{
intconiconi.SetReversedParameters(Standard_False);
intconiconi.Perform(TheCurveTool::Hyperbola(C1),D1,
TheCurveTool::Hyperbola(C2),D2,
TolConf,Tol);
if(Composite) { this->Append(intconiconi,
param1inf,
param1sup,
param2inf,
param2sup); }
else { this->SetValues(intconiconi); }
}
break;
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(TheCurveTool::Hyperbola(C1),D1,
C2,D2,TolConf,Tol);
if(Composite) { this->Append(intconicurv,
param1inf,
param1sup,
param2inf,
param2sup); }
else { this->SetValues(intconicurv); }
}
break;
}
break;
default:
switch (typ2)
{
case GeomAbs_Line:
{
intconicurv.SetReversedParameters(Standard_True);
intconicurv.Perform(TheCurveTool::Line(C2),D2, C1,D1,TolConf,Tol);
if(Composite)
{
this->Append(intconicurv,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconicurv);
}
}
break;
case GeomAbs_Circle:
{
intconicurv.SetReversedParameters(Standard_True);
intconicurv.Perform(TheCurveTool::Circle(C2),D2, C1,D1,TolConf,Tol);
if(Composite)
{
this->Append(intconicurv,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconicurv);
}
}
break;
case GeomAbs_Ellipse:
{
intconicurv.SetReversedParameters(Standard_True);
intconicurv.Perform(TheCurveTool::Ellipse(C2),D2, C1,D1,TolConf,Tol);
if(Composite)
{
this->Append(intconicurv,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconicurv);
}
}
break;
case GeomAbs_Parabola:
{
intconicurv.SetReversedParameters(Standard_True);
intconicurv.Perform(TheCurveTool::Parabola(C2),D2,C1,D1,TolConf,Tol);
if(Composite)
{
this->Append(intconicurv,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconicurv);
}
}
break;
case GeomAbs_Hyperbola:
{
intconicurv.SetReversedParameters(Standard_True);
intconicurv.Perform(TheCurveTool::Hyperbola(C2),D2,C1,D1,
TolConf,Tol);
if(Composite)
{
this->Append(intconicurv,
param1inf,
param1sup,
param2inf,
param2sup);
}
else
{
this->SetValues(intconicurv);
}
}
break;
default:
{
intcurvcurv.SetReversedParameters(Standard_False);
intcurvcurv.Perform(C1,D1, C2,D2,TolConf,Tol);
if(Composite)
{
this->Append(intcurvcurv,
param1inf,
param1sup,
param2inf,
param2sup); }
else
{
this->SetValues(intcurvcurv);
}
done = Standard_True;
}
break;
}
break;
}
}
void IntCurve_IntCurveCurveGen::InternalCompositePerform_noRecurs(
const Standard_Integer NbInterC1,
const TheCurve& C1,
const Standard_Integer NumInterC1,
const TColStd_Array1OfReal& Tab1,
const IntRes2d_Domain& D1,
const Standard_Integer NbInterC2,
const TheCurve& C2,
const Standard_Integer NumInterC2,
const TColStd_Array1OfReal& Tab2,
const IntRes2d_Domain& D2,
const Standard_Real TolConf,
const Standard_Real Tol)
{
if(NumInterC2>NbInterC2)
return;
IntRes2d_Domain DomainC1NumInter;
IntRes2d_Domain DomainC2NumInter;
//----------------------------------------------------------------------
//-- Creation du domaine associe a la portion de C1
//----------------------------------------------------------------------
Standard_Boolean DomainIsOK = Standard_True;
Standard_Real ParamInf,ParamSup;
if(NbInterC1>1) {
TheCurveTool::GetInterval(C1,NumInterC1,Tab1,ParamInf,ParamSup);
//--------------------------------------------------------------
//-- Verification : Domaine Inclu dans Intervalle de Definition
//--------------------------------------------------------------
Standard_Real u;
u = D1.FirstParameter();
if(ParamInf < u) { ParamInf = u; }
u = D1.LastParameter();
if(ParamSup > u) { ParamSup = u; }
if((ParamSup - ParamInf) > 1e-10) {
DomainC1NumInter.SetValues(TheCurveTool::Value(C1,ParamInf),
ParamInf,
D1.FirstTolerance(),
TheCurveTool::Value(C1,ParamSup),
ParamSup,
D1.LastTolerance());
} else {
DomainIsOK = Standard_False;
}
} else {
DomainC1NumInter = D1;
}
//----------------------------------------------------------------------
//-- Creation du domaine associe a la portion de C2
//----------------------------------------------------------------------
if(NbInterC2 > 1) {
TheCurveTool::GetInterval(C2,NumInterC2,Tab2,ParamInf,ParamSup);
//--------------------------------------------------------------
//-- Verification : Domaine Inclu dans Intervalle de Definition
//--------------------------------------------------------------
Standard_Real u;
u = D2.FirstParameter();
if(ParamInf < u) { ParamInf = u; }
u = D2.LastParameter();
if(ParamSup > u) { ParamSup = u; }
if((ParamSup - ParamInf) > 1e-10) {
DomainC2NumInter.SetValues(TheCurveTool::Value(C2,ParamInf),
ParamInf,
D2.FirstTolerance(),
TheCurveTool::Value(C2,ParamSup),
ParamSup,
D2.LastTolerance());
} else {
DomainIsOK = Standard_False;
}
} else {
DomainC2NumInter = D2;
}
if(DomainIsOK) {
InternalPerform(C2,DomainC2NumInter,
C1,DomainC1NumInter,
TolConf,Tol,
Standard_True);
}
}
//-- C1 ou C2 sont des courbes composites
//--
void
IntCurve_IntCurveCurveGen::InternalCompositePerform(const TheCurve& C1,
const IntRes2d_Domain& D1,
const Standard_Integer XXXNumInterC1,
const Standard_Integer NbInterC1,
const TColStd_Array1OfReal& Tab1,
const TheCurve& C2,
const IntRes2d_Domain& D2,
const Standard_Integer XXXNumInterC2,
const Standard_Integer NbInterC2,
const TColStd_Array1OfReal& Tab2,
const Standard_Real TolConf,
const Standard_Real Tol,
const Standard_Boolean RecursOnC2) {
Standard_Integer NumInterC2=XXXNumInterC2;
Standard_Integer NumInterC1=XXXNumInterC1;
// Standard_Boolean Arret=Standard_False;
if(NumInterC2>NbInterC2)
return;
if(!RecursOnC2){
InternalCompositePerform_noRecurs(NbInterC1, C1, NumInterC1, Tab1, D1, NbInterC2, C2, NumInterC2, Tab2, D2, TolConf, Tol);
return;
}
for(Standard_Integer i=NumInterC1 ; i<=NbInterC1; i++) {
NumInterC1=i;
/*
InternalCompositePerform(C2,D2,NumInterC2,NbInterC2,Tab2,
C1,D1,NumInterC1,NbInterC1,Tab1,
TolConf,Tol,Standard_False);
*/
InternalCompositePerform_noRecurs(NbInterC2,C2,NumInterC2,Tab2,D2,NbInterC1,C1,NumInterC1,Tab1,D1,TolConf,Tol);
}
if(NumInterC2<NbInterC2) {
NumInterC2++;
NumInterC1=1;
InternalCompositePerform(C1,D1,NumInterC1,NbInterC1,Tab1,
C2,D2,NumInterC2,NbInterC2,Tab2,
TolConf,Tol,
Standard_True);
}
}
//=======================================================================
//function : SetMinNbSamples
//purpose :
//=======================================================================
void IntCurve_IntCurveCurveGen::SetMinNbSamples(const Standard_Integer theMinNbSamples)
{
intcurvcurv.SetMinNbSamples(theMinNbSamples);
}
//=======================================================================
//function : GetMinNbSamples
//purpose :
//=======================================================================
Standard_Integer IntCurve_IntCurveCurveGen::GetMinNbSamples() const
{
return intcurvcurv.GetMinNbSamples();
}
View Git Blame Copy Permalink