Loading files
// Created on: 1992-03-02
// 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 <Standard_ConstructionError.hxx>
#include <IntRes2d_Domain.hxx>
#include <IntRes2d_IntersectionPoint.hxx>
#include <IntRes2d_IntersectionSegment.hxx>
#include <NCollection_Sequence.hxx>
#include <IntRes2d_Transition.hxx>
#include <IntRes2d_Position.hxx>
#include <IntImpParGen.hxx>
#include <math_FunctionSample.hxx>
#include <math_FunctionAllRoots.hxx>
#include <NCollection_Array1.hxx>
#include <gp.hxx>
#include <gp_Vec2d.hxx>
//======================================================================
#define EPSDIST Tol
#define EPSNUL TolConf
#define EPSX ParTool::EpsX(TheParCurve)
#define NB_ECHANTILLONS
//=================================================================================================
void IntImpParGen_Intersector::And_Domaine_Objet1_Intersections(
const ImpTool& TheImpTool,
const ParCurve& TheParCurve,
const IntRes2d_Domain& TheImpCurveDomain,
const IntRes2d_Domain& TheParCurveDomain,
int& NbResultats,
NCollection_Array1<double>& Inter2_And_Domain2,
NCollection_Array1<double>& Inter1,
NCollection_Array1<double>& Resultat1,
NCollection_Array1<double>& Resultat2,
const double EpsNul) const
{
int Nb_Bornes_Intersection = NbResultats;
NbResultats = 0;
for (int i = 1; i <= Nb_Bornes_Intersection; i += 2)
{
double param1 = Inter1.Value(i);
double param2 = Inter1.Value(i + 1);
int indice_1 = i;
int indice_2 = i + 1;
if (param1 > param2)
{
double t = param1;
param1 = param2;
param2 = t;
indice_1 = i + 1;
indice_2 = i;
}
gp_Pnt2d Pt1 = TheImpTool.Value(param1);
gp_Pnt2d Pt2 = TheImpTool.Value(param2);
gp_Pnt2d Pt;
bool IsOnTheImpCurveDomain1 = true;
bool IsOnTheImpCurveDomain2 = true;
//--------------------------------------------------------------------
if (TheImpCurveDomain.HasFirstPoint())
{
if (param1 < TheImpCurveDomain.FirstParameter())
{
if (Pt1.Distance(TheImpCurveDomain.FirstPoint()) > TheImpCurveDomain.FirstTolerance())
{
IsOnTheImpCurveDomain1 = false;
}
}
}
if (IsOnTheImpCurveDomain1 && TheImpCurveDomain.HasLastPoint())
{
if (param1 > TheImpCurveDomain.LastParameter())
{
if (Pt1.Distance(TheImpCurveDomain.LastPoint()) > TheImpCurveDomain.LastTolerance())
{
IsOnTheImpCurveDomain1 = false;
}
}
}
//--------------------------------------------------------------------
if (TheImpCurveDomain.HasFirstPoint())
{
if (param2 < TheImpCurveDomain.FirstParameter())
{
if (Pt2.Distance(TheImpCurveDomain.FirstPoint()) > TheImpCurveDomain.FirstTolerance())
{
IsOnTheImpCurveDomain2 = false;
}
}
}
if (IsOnTheImpCurveDomain2 && TheImpCurveDomain.HasLastPoint())
{
if (param2 > TheImpCurveDomain.LastParameter())
{
if (Pt2.Distance(TheImpCurveDomain.LastPoint()) > TheImpCurveDomain.LastTolerance())
{
IsOnTheImpCurveDomain2 = false;
}
}
}
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 ---
double t;
NbResultats++;
t = TheImpCurveDomain.LastParameter();
Resultat1.SetValue(NbResultats, t);
// double 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)
{
double 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())
{
double 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 = false;
}
//----------------------------------------------------------------------
//--
IntImpParGen_Intersector::IntImpParGen_Intersector(const ImpTool& TheImpTool,
const IntRes2d_Domain& TheImpCurveDomain,
const ParCurve& TheParCurve,
const IntRes2d_Domain& TheParCurveDomain,
const double TolConf,
const double 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 double TolConf,
const double Tol)
{
int i, nb_segments_solution, nb_points_solution;
double 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
//--
bool HeadOnImp = false;
bool HeadOnPar = false;
bool EndOnImp = false;
bool EndOnPar = false;
this->ResetFields();
IntImpParGen_MyImpParTool TheImpParTool(TheImpTool, TheParCurve);
if (!(TheParCurveDomain.HasFirstPoint() && TheParCurveDomain.HasLastPoint()))
{
throw Standard_ConstructionError("Domaine sur courbe incorrect");
}
int 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;
double 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 = 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);
}
bool IsOnTheImpCurveDomain = true;
if (TheImpCurveDomain.HasFirstPoint())
{
if (param1 < TheImpCurveDomain.FirstParameter())
{
if (Pt.Distance(TheImpCurveDomain.FirstPoint()) > TheImpCurveDomain.FirstTolerance())
{
IsOnTheImpCurveDomain = false;
}
}
}
if (IsOnTheImpCurveDomain && TheImpCurveDomain.HasLastPoint())
{
if (param1 > TheImpCurveDomain.LastParameter())
{
if (Pt.Distance(TheImpCurveDomain.LastPoint()) > TheImpCurveDomain.LastTolerance())
{
IsOnTheImpCurveDomain = 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 = true;
else if (Pos1 == IntRes2d_Head)
HeadOnImp = true;
if (Pos2 == IntRes2d_End)
EndOnPar = true;
else if (Pos2 == IntRes2d_Head)
HeadOnPar = 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
//--
NCollection_Array1<double> Inter2_and_Domaine2(1, 2 + 8 * nb_segments_solution);
NCollection_Array1<double> Inter1(1, 2 + 8 * nb_segments_solution);
int nb_segments_crees = 0;
for (int j2 = 1, j = 1; j <= nb_segments_solution; j++, j2 += 2)
{
double param2_inf, param2_sup;
double 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_Vec2d T1, T2, N1, N2;
double param1_origine, param1_fin;
TheImpCurveDomain.EquivalentParameters(param1_origine, param1_fin);
double 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
//------------------------------------------------------------------
//--
NCollection_Array1<double> Resultat1(1, 2 + (1 + nb_segments_solution) * 2);
NCollection_Array1<double> Resultat2(1, 2 + (1 + nb_segments_solution) * 2);
nb_segments_solution += nb_segments_crees;
int 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
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
{
gp_Pnt2d Pt1_on1, Pt2_on1, Pt1_on2, Pt2_on2;
double Param1_on1, Param2_on1, Param1_on2, Param2_on2;
double Dist_Mini_ImpCurve = EPSNUL;
double ToleranceAngulaireDistMini = Dist_Mini_ImpCurve;
for (int k = 1; k <= NbResultats; k += 2)
{
int ip1 = k + 1;
bool OnlyOnePoint = false;
Param1_on1 = Resultat1.Value(k);
Param1_on2 = Resultat2.Value(k);
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 = 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 = true;
else if (Pos1 == IntRes2d_Head)
HeadOnImp = true;
if (Pos2 == IntRes2d_End)
EndOnPar = true;
else if (Pos2 == IntRes2d_Head)
HeadOnPar = true;
IntImpParGen::DetermineTransition(Pos1,
Tan1,
Norm1,
Trans1,
Pos2,
Tan2,
Norm2,
Trans2,
ToleranceAngulaireDistMini);
//============== Detection du cas : L intersection est en bout
//============== sur les 2 domaines
if (Pos1 != IntRes2d_Middle && Pos2 != IntRes2d_Middle)
{
double 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 = true;
else if (Pos1 == IntRes2d_Head)
HeadOnImp = true;
if (Pos2 == IntRes2d_End)
EndOnPar = true;
else if (Pos2 == IntRes2d_Head)
HeadOnPar = true;
IntImpParGen::DetermineTransition(Pos1,
Tan1,
Norm1,
Trans1,
Pos2,
Tan2,
Norm2,
Trans2,
ToleranceAngulaireDistMini);
//============== Detection du cas : L intersection est en bout
//============== sur les 2 domaines
if (Pos1 != IntRes2d_Middle && Pos2 != IntRes2d_Middle)
{
double 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());
bool segopposite = ((Tan1.Dot(Tan2) < 0.0) ? true : 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())
<= std::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())
<= std::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())
<= std::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())
<= std::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 = true;
}
double IntImpParGen_Intersector::FindU(const double parameter,
gp_Pnt2d& point,
const ParCurve& TheParCurve,
const ImpTool& TheImpTool) const
{
point = ParTool::Value(TheParCurve, parameter);
return (TheImpTool.FindParameter(point));
}
double IntImpParGen_Intersector::FindV(const double parameter,
gp_Pnt2d& point,
const ImpTool& TheImpTool,
const ParCurve& TheParCurve,
const IntRes2d_Domain& TheParCurveDomain,
const double V0,
const double V1,
const double Tolerance) const
{
point = TheImpTool.Value(parameter);
if (TheParCurveDomain.IsClosed())
{
double V = ProjectOnPCurveTool::FindParameter(TheParCurve, point, Tolerance);
return (IntImpParGen::NormalizeOnDomain(V, TheParCurveDomain));
}
else
{
double VV0 = V0;
double VV1 = V1;
if (V1 < V0)
{
VV0 = V1;
VV1 = V0;
}
//-- ??????????????????????????????????????????????????????????????????????
//-- Modif le 15 Septembre 1992 : On Teste le parametre retourne
//--??????????????????????????????????????????????????????????????????????
double X = ProjectOnPCurveTool::FindParameter(TheParCurve, point, VV0, VV1, Tolerance);
if (X > VV1)
X = VV1;
else if (X < VV0)
X = VV0;
return (X);
}
}
4f95ecaa3This file is pinned to the selected release. Download the original to open it in your design tool.