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