lili/OCCT
1
0
Fork 0
mirror of https://github.com/Open-Cascade-SAS/OCCT.git synced 2026-05-22 12:48:37 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
53aa7b3237abbedc109bb6cfebef1933c008788d
OCCT/src/IntImpParGen/IntImpParGen_Intersector.gxx
bugmaster b311480ed5 0023024: Update headers of OCCT files 
Added appropriate copyright and license information in source files
2012-03-21 19:43:04 +04:00

717 lines
25 KiB
Plaintext
Executable File
Raw Blame History

// Created on: 1992-03-02
// Created by: Laurent BUCHARD
// Copyright (c) 1992-1999 Matra Datavision
// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.
#include <Standard_ConstructionError.hxx>
#include <IntRes2d_Domain.hxx>
#include <IntRes2d_IntersectionPoint.hxx>
#include <IntRes2d_IntersectionSegment.hxx>
#include <IntRes2d_SequenceOfIntersectionPoint.hxx>
#include <IntRes2d_SequenceOfIntersectionSegment.hxx>
#include <IntRes2d_Transition.hxx>
#include <IntRes2d_Position.hxx>
#include <IntImpParGen.hxx>
#include <math_FunctionSample.hxx>
#include <math_FunctionAllRoots.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <gp.hxx>
#include <gp_Vec2d.hxx>
//======================================================================
#define EPSDIST Tol
#define EPSNUL TolConf
#define EPSX ParTool::EpsX(TheParCurve)
#define NB_ECHANTILLONS
static Standard_Real PIpPI = M_PI + M_PI;
//======================================================================
void IntImpParGen_Intersector::And_Domaine_Objet1_Intersections(const ImpTool& TheImpTool,
const ParCurve& TheParCurve,
const IntRes2d_Domain& TheImpCurveDomain,
const IntRes2d_Domain& TheParCurveDomain,
Standard_Integer& NbResultats,
TColStd_Array1OfReal& Inter2_And_Domain2,
TColStd_Array1OfReal& Inter1,
TColStd_Array1OfReal& Resultat1,
TColStd_Array1OfReal& Resultat2,
const Standard_Real EpsNul) const {
Standard_Integer Nb_Bornes_Intersection=NbResultats;
NbResultats=0;
for(Standard_Integer i=1; i<=Nb_Bornes_Intersection; i+=2) {
Standard_Boolean reverse=Standard_False;
Standard_Real param1=Inter1.Value(i);
Standard_Real param2=Inter1.Value(i+1);
Standard_Integer indice_1=i;
Standard_Integer indice_2=i+1;
if(param1>param2) {
Standard_Real t=param1; param1=param2; param2=t;
indice_1=i+1;
indice_2=i;
reverse=Standard_True;
}
gp_Pnt2d Pt1=TheImpTool.Value(param1);
gp_Pnt2d Pt2=TheImpTool.Value(param2);
gp_Pnt2d Pt;
Standard_Boolean IsOnTheImpCurveDomain1=Standard_True;
Standard_Boolean IsOnABoundary1=Standard_False;
Standard_Boolean IsOnTheImpCurveDomain2=Standard_True;
Standard_Boolean IsOnABoundary2=Standard_False;
//--------------------------------------------------------------------
if(TheImpCurveDomain.HasFirstPoint()) {
if(param1<TheImpCurveDomain.FirstParameter()) {
if(Pt1.Distance(TheImpCurveDomain.FirstPoint())
> TheImpCurveDomain.FirstTolerance()) {
IsOnTheImpCurveDomain1=Standard_False;
}
else { IsOnABoundary1=Standard_True; }
}
}
if(IsOnTheImpCurveDomain1 && TheImpCurveDomain.HasLastPoint()) {
if(param1>TheImpCurveDomain.LastParameter()) {
if(Pt1.Distance(TheImpCurveDomain.LastPoint())
> TheImpCurveDomain.FirstTolerance()) {
IsOnTheImpCurveDomain1=Standard_False;
}
else { IsOnABoundary1=Standard_True; }
}
}
//--------------------------------------------------------------------
if(TheImpCurveDomain.HasFirstPoint()) {
if(param2<TheImpCurveDomain.FirstParameter()) {
if(Pt2.Distance(TheImpCurveDomain.FirstPoint())
> TheImpCurveDomain.FirstTolerance()) {
IsOnTheImpCurveDomain2=Standard_False;
}
else { IsOnABoundary2=Standard_True; }
}
}
if(IsOnTheImpCurveDomain2 && TheImpCurveDomain.HasLastPoint()) {
if(param2>TheImpCurveDomain.LastParameter()) {
if(Pt2.Distance(TheImpCurveDomain.LastPoint())
> TheImpCurveDomain.FirstTolerance()) {
IsOnTheImpCurveDomain2=Standard_False;
}
else { IsOnABoundary2=Standard_True; }
}
}
if(IsOnTheImpCurveDomain1) {
//------------------------------------------------------------------
//--- la borne 1 est sur le domaine --
NbResultats++;
Resultat1.SetValue(NbResultats,Inter1.Value(indice_1));
Resultat2.SetValue(NbResultats,Inter2_And_Domain2.Value(indice_1));
//--- la borne2 est aussi sur le domaine ---
if(IsOnTheImpCurveDomain2) {
NbResultats++;
Resultat1.SetValue(NbResultats,Inter1.Value(indice_2));
Resultat2.SetValue(NbResultats,Inter2_And_Domain2.Value(indice_2));
}
else {
//--- Borne1 sur domaine et Borne 2 Hors Domaine ---
Standard_Real t;
NbResultats++;
t=TheImpCurveDomain.LastParameter();
Resultat1.SetValue(NbResultats,t);
// Standard_Real popResult = FindV(t,Pt,TheImpTool,TheParCurve,
// TheParCurveDomain,
// Inter2_And_Domain2.Value(indice_1),
// Inter2_And_Domain2.Value(indice_2),
// EpsNul);
//
// Resultat2.SetValue(NbResultats,popResult);
Resultat2.SetValue(NbResultats,
IntImpParGen_Intersector::FindV(t,Pt,TheImpTool,TheParCurve,
TheParCurveDomain,
Inter2_And_Domain2.Value(indice_1),
Inter2_And_Domain2.Value(indice_2),
EpsNul));
}
}
else { //======= la borne1 n est pas sur le domaine ========
if(IsOnTheImpCurveDomain2) {
Standard_Real t;
NbResultats++;
t=TheImpCurveDomain.FirstParameter();
Resultat1.SetValue(NbResultats,t);
Resultat2.SetValue(NbResultats,
IntImpParGen_Intersector::FindV(t,Pt,TheImpTool,TheParCurve,
TheParCurveDomain,
Inter2_And_Domain2.Value(indice_1),
Inter2_And_Domain2.Value(indice_2),
EpsNul));
NbResultats++;
Resultat1.SetValue(NbResultats,Inter1.Value(indice_2));
Resultat2.SetValue(NbResultats,Inter2_And_Domain2.Value(indice_2));
}
else { //====== la borne2 et la borne1 sont hors domaine =====
if(param1<TheImpCurveDomain.FirstParameter()
&& param2>TheImpCurveDomain.LastParameter()) {
Standard_Real t;
NbResultats++;
t=TheImpCurveDomain.FirstParameter();
Resultat1.SetValue(NbResultats,t);
Resultat2.SetValue(NbResultats,
IntImpParGen_Intersector::FindV(t,Pt,TheImpTool,TheParCurve,
TheParCurveDomain,
Inter2_And_Domain2.Value(indice_1),
Inter2_And_Domain2.Value(indice_2),
EpsNul));
NbResultats++;
t=TheImpCurveDomain.LastParameter();
Resultat1.SetValue(NbResultats,t);
Resultat2.SetValue(NbResultats,
IntImpParGen_Intersector::FindV(t,Pt,TheImpTool,TheParCurve,
TheParCurveDomain,
Inter2_And_Domain2.Value(indice_1),
Inter2_And_Domain2.Value(indice_2),
EpsNul));
}
}
}
}
}
//======================================================================
//-- C o n s t r u c t e u r s e t P e r f o r m
IntImpParGen_Intersector::IntImpParGen_Intersector() {
done=Standard_False;
}
//----------------------------------------------------------------------
//--
IntImpParGen_Intersector::IntImpParGen_Intersector(const ImpTool& TheImpTool,
const IntRes2d_Domain& TheImpCurveDomain,
const ParCurve& TheParCurve,
const IntRes2d_Domain& TheParCurveDomain,
const Standard_Real TolConf,
const Standard_Real Tol) {
Perform(TheImpTool,TheImpCurveDomain,TheParCurve,TheParCurveDomain,TolConf,Tol);
}
//----------------------------------------------------------------------
//--
void IntImpParGen_Intersector::Perform(const ImpTool& TheImpTool,
const IntRes2d_Domain& TheImpCurveDomain,
const ParCurve& TheParCurve,
const IntRes2d_Domain& TheParCurveDomain,
const Standard_Real TolConf,
const Standard_Real Tol) {
Standard_Integer i,nb_segments_solution, nb_points_solution;
Standard_Real param1,param2,EpsX, EpsNul, EpsDist;
IntRes2d_Transition Trans1,Trans2;
gp_Pnt2d pt1,pt2;
gp_Vec2d Tan1,Tan2,Norm1,Norm2;
IntRes2d_Position Pos1,Pos2;
//----------------------------------------------
//-- On teste apres appel aux maths si les bornes
//-- des domaines sont des solutions
//--
Standard_Boolean HeadOnImp =Standard_False;
Standard_Boolean HeadOnPar =Standard_False;
Standard_Boolean EndOnImp =Standard_False;
Standard_Boolean EndOnPar =Standard_False;
this->ResetFields();
IntImpParGen_MyImpParTool TheImpParTool(TheImpTool,TheParCurve);
if (! (TheParCurveDomain.HasFirstPoint() &&
TheParCurveDomain.HasLastPoint())) {
Standard_ConstructionError::Raise("Domaine sur courbe incorrect");
}
Standard_Integer nb_echantillons = ParTool::NbSamples(TheParCurve,
TheParCurveDomain.FirstParameter(),
TheParCurveDomain.LastParameter());
EpsX = EPSX;
if(EpsX>1.0e-10) EpsX = 1.0e-10;
EpsNul=(TolConf<=1.0e-10)? 1.0e-10: TolConf;
EpsDist=(Tol<=1.0e-10)? 1.0e-10: Tol;
Standard_Real Tolerance_Angulaire=EpsDist;
if((TheParCurveDomain.LastParameter() - TheParCurveDomain.FirstParameter()) < 100.0*EpsX) {
EpsX = (TheParCurveDomain.LastParameter() - TheParCurveDomain.FirstParameter())*0.01;
}
math_FunctionSample Sample2(TheParCurveDomain.FirstParameter(),
TheParCurveDomain.LastParameter(),
nb_echantillons);
math_FunctionAllRoots Sol(TheImpParTool,
Sample2,
EpsX,
EpsDist,
EpsNul);
if(!Sol.IsDone()) {done = Standard_False; return; }
nb_segments_solution=Sol.NbIntervals();
nb_points_solution=Sol.NbPoints();
//--------------------------------------------------------------------
//-- T r a i t e m e n t d e s P o i n t s S o l u t i o n s
for(i=1; i<=nb_points_solution; i++) {
gp_Pnt2d Pt;
param2=Sol.GetPoint(i);
param1=FindU(param2,Pt,TheParCurve,TheImpTool);
if(TheImpCurveDomain.IsClosed()) {
param1 = IntImpParGen::NormalizeOnDomain( param1
,TheImpCurveDomain);
}
Standard_Boolean IsOnTheImpCurveDomain=Standard_True;
if(TheImpCurveDomain.HasFirstPoint()) {
if(param1<TheImpCurveDomain.FirstParameter()) {
if(Pt.Distance(TheImpCurveDomain.FirstPoint())
> TheImpCurveDomain.FirstTolerance()) {
IsOnTheImpCurveDomain=Standard_False;
}
}
}
if(IsOnTheImpCurveDomain && TheImpCurveDomain.HasLastPoint()) {
if(param1>TheImpCurveDomain.LastParameter()) {
if(Pt.Distance(TheImpCurveDomain.LastPoint())
> TheImpCurveDomain.FirstTolerance()) {
IsOnTheImpCurveDomain=Standard_False;
}
}
}
if(IsOnTheImpCurveDomain) {
TheImpTool.D2(param1,pt1,Tan1,Norm1);
ParTool::D2(TheParCurve,param2,pt2,Tan2,Norm2);
IntImpParGen::DeterminePosition(Pos1,TheImpCurveDomain,pt1,param1);
IntImpParGen::DeterminePosition(Pos2,TheParCurveDomain,pt2,param2);
if(Pos1==IntRes2d_End) EndOnImp = Standard_True;
else if(Pos1==IntRes2d_Head) HeadOnImp = Standard_True;
if(Pos2==IntRes2d_End) EndOnPar = Standard_True;
else if(Pos2==IntRes2d_Head) HeadOnPar = Standard_True;
IntImpParGen::DetermineTransition(Pos1,Tan1,Norm1,Trans1,
Pos2,Tan2,Norm2,Trans2,
Tolerance_Angulaire);
IntRes2d_IntersectionPoint IP(pt1,param1,param2
,Trans1,Trans2
,ReversedParameters());
Insert(IP);
}
}
//-- F i n d u T r a i t e m e n t d e s P t s S o l.
//--------------------------------------------------------------------
//-- T r a i t e m e n t D e s S e g m e n t s ---
//--------------------------------------------------------------------
//-- On a N segments solution sur le domaine de V soit au pire :
//-- --> N segments solution sur le domaine de U
//-- -->2N segments si la courbe en U est fermee
//--
TColStd_Array1OfReal Inter2_and_Domaine2(1,2+8*nb_segments_solution);
TColStd_Array1OfReal Inter1(1,2+8*nb_segments_solution);
Standard_Integer nb_segments_crees=0;
for (Standard_Integer j2=1,j=1;j<=nb_segments_solution;j++,j2+=2) {
Standard_Real param2_inf,param2_sup;
Standard_Real param1_inf,param1_sup;
gp_Pnt2d Ptemp;
Sol.GetInterval(j,param2_inf,param2_sup);
param1_inf=FindU(param2_inf,Ptemp,TheParCurve,TheImpTool);
param1_sup=FindU(param2_sup,Ptemp,TheParCurve,TheImpTool);
//----------------------------------------------------------------------
//-- C o u r b e I m p l i c i t e F e r m e e
if(TheImpCurveDomain.IsClosed()) {
gp_Pnt2d Ptemp;
gp_Vec2d T1,T2,N1,N2;
Standard_Real param1_origine,param1_fin;
TheImpCurveDomain.EquivalentParameters(param1_origine,param1_fin);
Standard_Real Periode=param1_fin-param1_origine;
while(param1_inf<param1_origine) { param1_inf+=Periode; }
while(param1_sup<param1_origine) { param1_sup+=Periode; }
ParTool::D2(TheParCurve,param2_inf,Ptemp,T2,N2);
TheImpTool.D2(param1_inf,Ptemp,T1,N1);
if(T1.Magnitude()<=gp::Resolution()) T1=N1;
if(T2.Magnitude()<=gp::Resolution()) T2=N2;
if(T1.Dot(T2) >=0.0) {
//--- param1_inf designe un point entrant (et T1 est vers la matiere)
if(param1_inf>=param1_sup) { param1_sup+=Periode; }
}
else { //--- param1_inf : point sortant (et T1 est Hors matiere)
if(param1_inf<=param1_sup) { param1_inf+=Periode; }
}
//--- On cree un nouveau segment decale de Periode
//-- Exemple de Pb : Domaine PI/4 PI/2 et intervalle 0,PI
//-- Domaine 1.5PI 2.5PI et intervalle 0,PI
//-- -2pi 0 2pi
//-- ------|--------------------|-----------------|-----------
//-- [----------------------------] Domaine
//-- [~~~~~~~~~~~~~~~~~] Inters.
//--
//-- On cree un nouvel intervalle
//-- interv decale
//-- [a~~~~~~~~~~~~b] [a~~~~~~~~~~~~~~~b] et [a~~~]
//--
//
if(TheImpCurveDomain.LastParameter()
> ((param1_inf>param1_sup)? (param1_sup+Periode):
(param1_inf+Periode))) {
Inter2_and_Domaine2.SetValue(j2,param2_inf);
Inter1.SetValue(j2,param1_inf+Periode);
Inter2_and_Domaine2.SetValue(j2+1,param2_sup);
Inter1.SetValue(j2+1,param1_sup+Periode);
j2+=2;
nb_segments_crees++;
}
if(TheImpCurveDomain.FirstParameter()
<((param1_inf<param1_sup)? (param1_sup-Periode): (param1_inf-Periode))) {
Inter2_and_Domaine2.SetValue(j2,param2_inf);
Inter1.SetValue(j2,param1_inf-Periode);
Inter2_and_Domaine2.SetValue(j2+1,param2_sup);
Inter1.SetValue(j2+1,param1_sup-Periode);
j2+=2;
nb_segments_crees++;
}
}
//-- F i n C o u r b e I m p l i c i t e F e r m e e
//----------------------------------------------------------------------
Inter2_and_Domaine2.SetValue(j2,param2_inf);
Inter1.SetValue(j2,param1_inf);
Inter2_and_Domaine2.SetValue(j2+1,param2_sup);
Inter1.SetValue(j2+1,param1_sup);
}
//------------------------------------------------------------------
//-- INTER2_DOMAINE2 : Intersection AND CurveDomain : Function of PARAM2
//-- INTER1 : Intersection AND CurveDomain : Function of PARAM1
//------------------------------------------------------------------
//--
TColStd_Array1OfReal Resultat1(1,2+(1+nb_segments_solution)*2);
TColStd_Array1OfReal Resultat2(1,2+(1+nb_segments_solution)*2);
nb_segments_solution+=nb_segments_crees;
Standard_Integer NbResultats=nb_segments_solution*2;
And_Domaine_Objet1_Intersections(TheImpTool,
TheParCurve,
TheImpCurveDomain,
TheParCurveDomain,
NbResultats,
Inter2_and_Domaine2,Inter1,
Resultat1,Resultat2,EpsNul);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//Calcule_Toutes_Transitions(NbResultats,
// Resultat1,Resultat2,
// TheImpTool,
// TheImpCurveDomain,
// TheParCurve,
// TheParCurveDomain);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~ Fonction Calcule_Toutes_Transitions Repportee ici pour cause ~~~~~
//~~~~~ D acces aux methodes Protected APPEND
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
{
IntRes2d_Position Pos1,Pos2;
IntRes2d_Transition Trans1,Trans2;
gp_Vec2d Tan1,Tan2,Norm1,Norm2;
gp_Pnt2d Pt1_on1,Pt2_on1,Pt1_on2,Pt2_on2;
Standard_Real Param1_on1,Param2_on1,Param1_on2,Param2_on2;
Standard_Real Dist_Mini_ImpCurve=EPSNUL;
Standard_Real Tolerance_Angulaire=Dist_Mini_ImpCurve;
for(Standard_Integer i=1; i<=NbResultats ; i+=2) {
Standard_Integer ip1=i+1;
Standard_Boolean OnlyOnePoint=Standard_False;
Param1_on1=Resultat1.Value(i);
Param1_on2=Resultat2.Value(i);
Param2_on1=Resultat1.Value(ip1);
Param2_on2=Resultat2.Value(ip1);
Pt1_on1=TheImpTool.Value(Param1_on1);
Pt2_on1=TheImpTool.Value(Param2_on1);
Pt1_on2=ParTool::Value(TheParCurve,Param1_on2);
Pt2_on2=ParTool::Value(TheParCurve,Param2_on2);
if(!TheImpCurveDomain.IsClosed()) {
if( Pt1_on1.Distance(Pt2_on1) <= Dist_Mini_ImpCurve ) {
if( Pt1_on2.Distance(Pt2_on2) <= Dist_Mini_ImpCurve ) {
OnlyOnePoint=Standard_True;
}
}
}
Param1_on1=IntImpParGen::NormalizeOnDomain(Param1_on1,TheImpCurveDomain);
Param1_on2=IntImpParGen::NormalizeOnDomain(Param1_on2,TheParCurveDomain);
TheImpTool.D2(Param1_on1,Pt1_on1,Tan1,Norm1);
ParTool::D2(TheParCurve,Param1_on2,Pt1_on2,Tan2,Norm2);
IntImpParGen::DeterminePosition(Pos1,TheImpCurveDomain,Pt1_on1,Param1_on1);
IntImpParGen::DeterminePosition(Pos2,TheParCurveDomain,Pt1_on2,Param1_on2);
if(Pos1==IntRes2d_End) EndOnImp = Standard_True;
else if(Pos1==IntRes2d_Head) HeadOnImp = Standard_True;
if(Pos2==IntRes2d_End) EndOnPar = Standard_True;
else if(Pos2==IntRes2d_Head) HeadOnPar = Standard_True;
IntImpParGen::DetermineTransition(Pos1,Tan1,Norm1,Trans1,
Pos2,Tan2,Norm2,Trans2,
Tolerance_Angulaire);
//============== Detection du cas : L intersection est en bout
//============== sur les 2 domaines
if(Pos1!=IntRes2d_Middle && Pos2!=IntRes2d_Middle) {
Standard_Real m=0.5*(Pt1_on1.X() + Pt1_on2.X());
Pt1_on1.SetX(m);
m=0.5*(Pt1_on1.Y() + Pt1_on2.Y());
Pt1_on1.SetY(m);
}
IntRes2d_IntersectionPoint new_p1(Pt1_on1
,Param1_on1,Param1_on2
,Trans1,Trans2
,ReversedParameters());
if(!OnlyOnePoint) {
IntRes2d_IntersectionPoint new_p2;
Param2_on1=IntImpParGen::NormalizeOnDomain(Param2_on1,TheImpCurveDomain);
Param2_on2=IntImpParGen::NormalizeOnDomain(Param2_on2,TheParCurveDomain);
TheImpTool.D2(Param2_on1,Pt2_on1,Tan1,Norm1);
ParTool::D2(TheParCurve,Param2_on2,Pt2_on2,Tan2,Norm2);
IntImpParGen::DeterminePosition(Pos1,TheImpCurveDomain,Pt2_on1,Param2_on1);
IntImpParGen::DeterminePosition(Pos2,TheParCurveDomain,Pt2_on2,Param2_on2);
if(Pos1==IntRes2d_End) EndOnImp = Standard_True;
else if(Pos1==IntRes2d_Head) HeadOnImp = Standard_True;
if(Pos2==IntRes2d_End) EndOnPar = Standard_True;
else if(Pos2==IntRes2d_Head) HeadOnPar = Standard_True;
IntImpParGen::DetermineTransition(Pos1,Tan1,Norm1,Trans1,
Pos2,Tan2,Norm2,Trans2,
Tolerance_Angulaire);
//============== Detection du cas : L intersection est en bout
//============== sur les 2 domaines
if(Pos1!=IntRes2d_Middle && Pos2!=IntRes2d_Middle) {
Standard_Real m=0.5*(Pt2_on1.X() + Pt2_on2.X() );
Pt2_on1.SetX(m);
m=0.5*(Pt2_on1.Y() + Pt2_on2.Y());
Pt2_on1.SetY(m);
}
new_p2.SetValues(Pt2_on1,Param2_on1,Param2_on2
,Trans1,Trans2
,ReversedParameters());
Standard_Boolean segopposite=((Tan1.Dot(Tan2) < 0.0)?
Standard_True : Standard_False);
IntRes2d_IntersectionSegment new_seg(new_p1,new_p2
,segopposite
,ReversedParameters());
Append(new_seg);
}
else {
Insert(new_p1);
}
}
} //~~~~~~~~~~~~ Fin du corps de la fonction Calc...Transitions~~~~~~~~~~
//-------------------------------------------
//-- On teste les points en bouts solutions
//--
if(!HeadOnImp && TheImpCurveDomain.HasFirstPoint()) {
if(!HeadOnPar) {
if(TheImpCurveDomain.FirstPoint().Distance(TheParCurveDomain.FirstPoint())
<= Max(TheImpCurveDomain.FirstTolerance(),TheParCurveDomain.FirstTolerance())) {
param1 = TheImpCurveDomain.FirstParameter();
param2 = TheParCurveDomain.FirstParameter();
TheImpTool.D2(param1,pt1,Tan1,Norm1);
ParTool::D2(TheParCurve,param2,pt2,Tan2,Norm2);
IntImpParGen::DetermineTransition(IntRes2d_Head,Tan1,Norm1,Trans1,
IntRes2d_Head,Tan2,Norm2,Trans2,
Tolerance_Angulaire);
IntRes2d_IntersectionPoint IP(TheImpCurveDomain.FirstPoint(),
param1,param2,
Trans1,Trans2,
ReversedParameters());
Insert(IP);
}
}
if(!EndOnPar) {
if(TheImpCurveDomain.FirstPoint().Distance(TheParCurveDomain.LastPoint())
<= Max(TheImpCurveDomain.FirstTolerance(),TheParCurveDomain.LastTolerance())) {
param1 = TheImpCurveDomain.FirstParameter();
param2 = TheParCurveDomain.LastParameter();
TheImpTool.D2(param1,pt1,Tan1,Norm1);
ParTool::D2(TheParCurve,param2,pt2,Tan2,Norm2);
IntImpParGen::DetermineTransition(IntRes2d_Head,Tan1,Norm1,Trans1,
IntRes2d_End ,Tan2,Norm2,Trans2,
Tolerance_Angulaire);
IntRes2d_IntersectionPoint IP(TheImpCurveDomain.FirstPoint(),
param1,param2,
Trans1,Trans2,
ReversedParameters());
Insert(IP);
}
}
}
if(!EndOnImp && TheImpCurveDomain.HasLastPoint()) {
if(!HeadOnPar) {
if(TheImpCurveDomain.LastPoint().Distance(TheParCurveDomain.FirstPoint())
<= Max(TheImpCurveDomain.LastTolerance(),TheParCurveDomain.FirstTolerance())) {
param1 = TheImpCurveDomain.LastParameter();
param2 = TheParCurveDomain.FirstParameter();
TheImpTool.D2(param1,pt1,Tan1,Norm1);
ParTool::D2(TheParCurve,param2,pt2,Tan2,Norm2);
IntImpParGen::DetermineTransition(IntRes2d_End,Tan1,Norm1,Trans1,
IntRes2d_Head,Tan2,Norm2,Trans2,
Tolerance_Angulaire);
IntRes2d_IntersectionPoint IP(TheImpCurveDomain.LastPoint(),
param1,param2,
Trans1,Trans2,
ReversedParameters());
Insert(IP);
}
}
if(!EndOnPar) {
if(TheImpCurveDomain.LastPoint().Distance(TheParCurveDomain.LastPoint())
<= Max(TheImpCurveDomain.LastTolerance(),TheParCurveDomain.LastTolerance())) {
param1 = TheImpCurveDomain.LastParameter();
param2 = TheParCurveDomain.LastParameter();
TheImpTool.D2(param1,pt1,Tan1,Norm1);
ParTool::D2(TheParCurve,param2,pt2,Tan2,Norm2);
IntImpParGen::DetermineTransition(IntRes2d_End,Tan1,Norm1,Trans1,
IntRes2d_End,Tan2,Norm2,Trans2,
Tolerance_Angulaire);
IntRes2d_IntersectionPoint IP(TheImpCurveDomain.LastPoint(),
param1,param2,
Trans1,Trans2,
ReversedParameters());
Insert(IP);
}
}
}
done=Standard_True;
}
Standard_Real IntImpParGen_Intersector::FindU(const Standard_Real parameter
,gp_Pnt2d& point
,const ParCurve& TheParCurve
,const ImpTool& TheImpTool) const
{
point=ParTool::Value(TheParCurve,parameter);
return(TheImpTool.FindParameter(point));
}
Standard_Real IntImpParGen_Intersector::FindV(const Standard_Real parameter
,gp_Pnt2d& point
,const ImpTool& TheImpTool
,const ParCurve& TheParCurve
,const IntRes2d_Domain& TheParCurveDomain
,const Standard_Real V0
,const Standard_Real V1
,const Standard_Real Tolerance) const
{
point=TheImpTool.Value(parameter);
if(TheParCurveDomain.IsClosed()) {
Standard_Real V = ProjectOnPCurveTool::FindParameter(TheParCurve,
point,
Tolerance);
return(IntImpParGen::NormalizeOnDomain(V,TheParCurveDomain));
}
else {
Standard_Real VV0 = V0;
Standard_Real VV1 = V1;
if(V1<V0) { VV0 = V1; VV1 = V0; }
//-- ??????????????????????????????????????????????????????????????????????
//-- Modif le 15 Septembre 1992 : On Teste le parametre retourne
//--??????????????????????????????????????????????????????????????????????
Standard_Real X = ProjectOnPCurveTool::FindParameter(TheParCurve,
point,
VV0,VV1,Tolerance);
if(X>VV1) X=VV1; else if(X<VV0) X=VV0;
return(X);
}
}
Reference in New Issue View Git Blame Copy Permalink