//#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-2022 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;
};