212 lines
6.8 KiB
C++
Executable file
212 lines
6.8 KiB
C++
Executable file
//#include "Debug.h"
|
|
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
|
|
#include "Plan.h"
|
|
#include "ConstMath.h"
|
|
#include "MathUtil.h"
|
|
#include "Util.h"
|
|
|
|
// CONSTRUCTEURS :
|
|
// par defaut
|
|
Plan::Plan () :
|
|
A(), N()
|
|
{};
|
|
// avec les datas
|
|
Plan::Plan ( const Coordonnee& B, const Coordonnee& vec) :
|
|
A(B), N(vec)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (B.Dimension() != vec.Dimension())
|
|
{ cout << "\nErreur : les dimensions du point et du vecteur ne sont pas identique !";
|
|
cout <<"\ndim point = " <<B.Dimension() <<", dim vecteur =" << vec.Dimension();
|
|
cout << "\nPlan::Plan (Coordonnee& B,Coordonnee& vec)" << endl;
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
double d = N.Norme();
|
|
if (d <= ConstMath::petit)
|
|
{ cout << "\nErreur : la norme du vecteur est trop petite !";
|
|
cout <<"\nnorme = " << d;
|
|
cout << "\nPlan::Plan (Coordonnee& B,Coordonnee& vec)" << endl;
|
|
Sortie(1);
|
|
};
|
|
N /= d; // N est ainsi norme
|
|
};
|
|
// avec la dimension
|
|
Plan::Plan (int dim) :
|
|
A(dim), N(dim)
|
|
{ };
|
|
// de copie
|
|
Plan::Plan ( const Plan& a) :
|
|
A(a.A), N(a.N)
|
|
{};
|
|
// DESTRUCTEUR :
|
|
Plan::~Plan () {};
|
|
// surcharge des operator
|
|
Plan& Plan::operator = ( const Plan & P)
|
|
{ this->A = P.A; this->N = P.N;
|
|
return *this;
|
|
};
|
|
|
|
// METHODES PUBLIQUES :
|
|
|
|
// change le point de ref du plan
|
|
void Plan::Change_ptref( const Coordonnee& B)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (B.Dimension() != N.Dimension())
|
|
{ cout << "\nErreur : les dimensions du point et du vecteur ne sont pas identique !";
|
|
cout <<"\ndim point = " <<B.Dimension() <<", dim vecteur =" << N.Dimension();
|
|
cout << "\nPlan::Change_ptref(Coordonnee& B)" << endl;
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
A = B;
|
|
};
|
|
// change le vecteur normal du plan
|
|
void Plan::Change_normal( const Coordonnee& vec)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (A.Dimension() != vec.Dimension())
|
|
{ cout << "\nErreur : les dimensions du point et du vecteur ne sont pas identique !";
|
|
cout <<"\ndim point = " <<A.Dimension() <<", dim vecteur =" << vec.Dimension();
|
|
cout << "\nPlan::Change_normal(Coordonnee& vec)" << endl;
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
double d = vec.Norme();
|
|
if (d <= ConstMath::petit)
|
|
{ cout << "\nErreur : la norme du vecteur est trop petite !";
|
|
cout <<"\nnorme = " << d;
|
|
cout << "\nPlan::Change_normal(Coordonnee& vec)" << endl;
|
|
Sortie(1);
|
|
};
|
|
N = vec / d; // N est ainsi norme
|
|
};
|
|
// change toutes les donnees
|
|
void Plan::change_donnees( const Coordonnee& B, const Coordonnee& vec)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (B.Dimension() != vec.Dimension())
|
|
{ cout << "\nErreur : les dimensions du point et du vecteur ne sont pas identique !";
|
|
cout <<"\ndim point = " <<B.Dimension() <<", dim vecteur =" << vec.Dimension();
|
|
cout << "\nPlan::change_donnees(Coordonnee& B,Coordonnee& vec)" << endl;
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
A = B;
|
|
double d = vec.Norme();
|
|
if (d <= ConstMath::petit)
|
|
{ cout << "\nErreur : la norme du vecteur est trop petite !";
|
|
cout <<"\nnorme = " << d;
|
|
cout << "\nPlan::change_donnees(Coordonnee& B,Coordonnee& vec)" << endl;
|
|
Sortie(1);
|
|
};
|
|
N = vec / d; // N est ainsi norme
|
|
};
|
|
|
|
// calcul l'intercection M d'une droite avec le plan, ramene 0 s'il n'y
|
|
// a pas d'intercection, ramene -1 si l'intercection ne peut pas etre calculee
|
|
// et 1 s'il y a un point d'intercection
|
|
int Plan::Intersection( const Droite & D,Coordonnee& M)const
|
|
{ const Coordonnee & B = D.PointDroite(); // par commodite d'ecriture
|
|
const Coordonnee & V = D.VecDroite(); // ""
|
|
Coordonnee AB = B - A;double Nab = AB.Norme();
|
|
// existance du point d'intercection et cas particulier
|
|
// - droite // au plan ?
|
|
double abN = AB * N;
|
|
double vn = V * N;
|
|
//cout << "\n **Plan::Intersection debug ** ";
|
|
//cout << "\n B ";B.Affiche();
|
|
//cout << "\n V ";V.Affiche();
|
|
//cout << "\n N ";N.Affiche();
|
|
//cout << "\n M ";M.Affiche();
|
|
//cout << "\n abN= "<<abN << " vn= "<<vn << endl;
|
|
//
|
|
|
|
if ( Dabs(vn) <= ConstMath::pasmalpetit)
|
|
// cas //
|
|
// - on regarde si la droite appartiend au plan
|
|
if ( Dabs(abN) <= ConstMath::pasmalpetit)
|
|
// droite dans le plan -> indetermination
|
|
return -1;
|
|
else
|
|
// il n'y a pas d'intercection
|
|
return 0;
|
|
else
|
|
// cas ou il y a intersection
|
|
{ M = B - (abN /vn) * V;
|
|
return 1;
|
|
}
|
|
};
|
|
|
|
// calcul la distance d'un point à la droite
|
|
double Plan::Distance_au_plan(const Coordonnee& M) const
|
|
{ int dima = ParaGlob::Dimension();
|
|
Coordonnee AM(M-A);
|
|
return Dabs(AM * N);
|
|
};
|
|
|
|
// ramène true si les deux points sont du même coté du plan, false sinon
|
|
bool Plan::DuMemeCote(const Coordonnee& M1, const Coordonnee& M2) const
|
|
{ Coordonnee AM1 = M1-A;
|
|
Coordonnee AM2 = M2-A;
|
|
return ((AM1 * N) * (AM2 * N) >= 0);
|
|
};
|
|
|
|
// surcharge de l'operateur de lecture
|
|
istream & operator >> (istream & entree, Plan & pl)
|
|
{ // vérification du type
|
|
string nom;
|
|
entree >> nom;
|
|
#ifdef MISE_AU_POINT
|
|
if (nom != "_plan_")
|
|
{ cout << "\nErreur, en lecture d'une instance Plan "
|
|
<< " on attendait _plan_ et on a lue: " << nom ;
|
|
cout << "istream & operator >> (istream & entree, Plan & pl)\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// puis lecture des différents éléments
|
|
entree >> nom >> pl.A >> nom >> pl.N;
|
|
return entree;
|
|
};
|
|
|
|
// surcharge de l'operateur d'ecriture
|
|
ostream & operator << ( ostream & sort,const Plan & pl)
|
|
{ // tout d'abord un indicateur donnant le type
|
|
sort << " _plan_ " ;
|
|
// puis les différents éléments
|
|
sort << "\n A= " << pl.A << " U= " << pl.N << " ";
|
|
return sort;
|
|
};
|
|
|