extern R TailleArete;// >0 => Taille souhaitee des aretes du maillage
// =0 => Emploi de la fonction Taille_Ideale() (A FAIRE)
// <0 => Emploi d'une carte de taille des aretes(A FAIRE)
// sur un maillage de fond

extern R3 PtMIN, PtMAX; // Points de coordonnees extremales

extern MemoirePx3d fenetrecran;//Fenetre de l'ecran ou sont faits les traces
extern MemoirePx3d mpxPLSV; //Memoire de Pixels ou sont faits les traces
extern MemoirePx3d mpxModif; //Memoire de Pixels des traces des modifications

extern MemoirePxInvite mpxInvite; //Memoire de Pixels pour l'invite
extern MemoirePxMenu mpxMenu; //Memoire de Pixels pour les menus
extern MemoirePxAccroche mpxAccroche;//Memoire de Pixels d'accrochage des Points

//==============================================================================

class PLSV // Definition et Maillage d'un Point,Ligne,Surface,Volume
// c'est a dire le nom et les
// donnees des Sommets et Numero des Sommets de ses EF
//(donnees des Tangentes et Numero des Tangentes des EF)
//(A FAIRE...)
{
public :
Nom nom; // Nom du PLSV
R date; // Date+Heure+Minute+Sec+...de creation du maillage du PLSV

Z NbSommet; // Nombre de sommets du maillage du PLSV
R3 *XyzSommet; // Tableau dynamique XyzSommet[NbSommet] des xyz des sommets

Z NbEF; // Nombre d'EF de PLSV
Z NbStEF; // Nombre de sommets par EF
// =1 par sommet ou EF d'un POINT
// =2 par arete ou EF d'une LIGNE
// =4 par face ou EF d'une SURFACE
// triangle => 4-eme sommet nul
// =8 par polyedre ou EF d'un VOLUME
// tetraedre=> 5 6 7 8-eme sommets nuls
// pentaedre=> 7 8-eme sommets nuls
// hexaedre => 8 sommets non nuls
Z *NoStEF; // Tableau dynamique NoStEF[NbEF * NbStEF]

public :
PLSV(); // Constructeur de la classe de BASE => date la creation
};

//==============================================================================

class Point : public PLSV // Definition et Maillage d'un Point
{
public :
Point *PSuivant; // public necessaire car modification
// par fonction membre de la classe Points
Point(); //Constructeur de base: demande le nom
Point( Nom NomPt ); //Constructeur avec nom en argument
virtual ~Point(); //Destructeur virtuel pour agir selon la classe

virtual void AfficherDefinition()=0; //fonction virtuelle pure
//=>Impose sa redefinition dans toute classe derivee
void AfficherMaillage(); //Affiche sous forme de texte
void TracerMaillage(MemoirePx3d & mpx); //Trace graphique
void Deplacer(); //Deplacer a l'aide de la souris un Point

};

class Pointxyz : public Point //Point avec donnee des coordonnees cartesiennes
{
private :
R x, y, z; //Abscisse, Ordonnee et Cote du Point xyz

public :
Pointxyz(); //Constructeur par clic souris sur le plan XY du SCU
Pointxyz( Nom NomPt, R abscisse, R ordonnee, R cote );
//Constructeur a partir des arguments
virtual ~Pointxyz(); //Destructeur du Pointxyz
virtual void AfficherDefinition();
//Affiche les donnees de definition du Pointxyz
};

class PointCyl : public Point //Point avec donnee des coordonnees cylindriques
{
private :
R rayon, teta, z; //rayon, longitude et cote du Point Cyl

public :
PointCyl(); //Constructeur par demande et frappe des donnees membres
PointCyl( Nom NomPt, R Rayon, R Teta, R Cote );
//Constructeur a partir des arguments
virtual ~PointCyl(); //Destructeur du pointCyl
virtual void AfficherDefinition();
//Affiche les donnees de definition du PointCyl
};

//==============================================================================

class Points
{
public:
Point *P1Point; //Tete du chainage sur le suivant des Points
public:
Points(); //initialise la tete de chainage
~Points(); //destructeur de la liste des points
Point *RetrouverPoint( Nom NomPt, Point * & PtAvant ); //a partir de son nom
Point *RetrouverPointControle( Nom NomPt, Z nbn, Point *pc[] );//par son nom
Point *CliquerPoint( void ); //avec le bouton gauche de la souris
Point *CliquerPointControle( Z nbn, Point *pc[] ); //avec la souris
void Ajouter1Point( Point *PPoint ); //dans le chainage des Points
int EntrerPoints(); //frappe au clavier des donnees des Points
void AfficherPoints(); //affichage texte des donnees des Points
R Dist2Pt( Point *P1, Point *P2 ); //distance entre 2 points
void TracerPoints(MemoirePx3d & mpx); //trace graphique des Points
};

//==============================================================================

class Ligne : public PLSV // Definition et Maillage d'une Ligne NURBS:
// Droite, Cercle, BEZIER, NURBS, ...
{
public :
Ligne *PSuivant; // public necessaire car modification
// par fonction membre de la classe Lignes

Z degre; // degre des polynomes
Z nbn; // nombre(-1-degre-1) de noeuds
R *U; // U[1+nbn+1+degre] valeurs des noeuds
Point **PC; // PC[1+nbn] tableau de pointeurs sur les points controle
R *Poids; // si *Poids==NULL => Courbe polynomiale (pas de Poids)
// si *Poids!=NULL => Courbe rationnelle NURBS
// Poids[1+nbn] les poids des Points de Controle
public :
Ligne(); // demande le nom au clavier
Ligne( Nom NomLg ); // initialise le nom par argument
~Ligne(); // destructeur des tableaux dynamiques NoStEF XyzSommet

virtual void AfficherDefinition()=0;//virtuelle pure pour redefinition forcee
virtual int Mailler(Points *LesPoints);//creation des aretes de la Ligne
virtual void VerifierMaillage(Points *LesPoints)=0;//virtuelle pure
//si date des points ulterieur a la ligne => Re maillage
void AfficherMaillage(); //sous forme de texte
void TracerMaillage(MemoirePx3d & mpx); //trace graphique
void TracerPolygone(MemoirePx3d & mpx); //de controle de la courbe
void TracerDeriveeNURBS(MemoirePx3d & mpx);
//Trace des vecteurs derivees aux noeuds de la courbe
void TracerDeriveesNURBS( MemoirePx3d & mpx, R u );
//Trace des vecteurs derivees en la valeur u du parametre de la courbe
R3 PointMilieuLigne(); //Le maillage de la ligne doit exister
int IntervalleNURBS( R u ); //version optimisee
//Retrouve i tel que u verifie U[i]<=u<U[i+1] intervalle des noeuds U
//sauf pour u=U[nbn+1] => i=nbn
int DichoIntervalleNURBS( int min, int max, R u );
//Retrouve recursivement i tel que u verifie U[i]<=u<U[i+1] des noeuds
int MultipliciteDuNoeud( R u, int & i );
//la multiplicite du noeud ou -1 si u n'est pas dans l'intervalle des Noeuds
//l'indice i tel que U[i]<=u<U[i+1] sauf si u=U[nbn+1] => i=nbn
void ValeurBaseNURBS( int i, Z NbEtape, R u, R N[] ); //version optimisee
//NbEtape<degre si arret demande avant (pour la derivation)
//la valeur des degre+1 fonctions de base N utiles de la NURBS en u
void ValeurBaseNSpline( int i, Z NbEtape, R u, R N[] );
//la valeur des degre+1 fonctions de base N utiles de la NURBS en u
//NbEtape<degre si arret demande avant (pour la derivation)
void Derivee1BaseNURBS( int i, R u, R N[] );
//Calcul des N'j,degre(u) pour j=i-degre a i
void Derivee2BaseNURBS( int i, R u, R N[] );
//Calcul des N''j,degre(u) pour j=i-degre a i
void Derivee3BaseNURBS( int i, R u, R N[] );
//Calcul des N'''j,degre(u) pour j=i-degre a i
void PointCourbeNURBS( R u, R3 & P );
//les coordonnees du point de la courbe NURBS en u
void Derivee1CourbeNURBS( R u, R3 & P );
//les composantes de la tangente a la courbe NURBS en u
void Derivee2CourbeNURBS( R u, R3 & P );
//les composantes de la derivee seconde a la courbe NURBS en u
void Derivee3CourbeNURBS( R u, R3 & P );
//les composantes de la derivee troisieme a la courbe NURBS en u
void CourbureNormaleNURBS( R u, R3 & D, R3 & DD,
R3 & n, R3 & bn, R & Courbure );
//Calcul de la derivee premiere, seconde, courbure et vecteur
//normal et binormal au noeud u d'une courbe NURBS
void TorsionBiNormaleNURBS( R u, R3 & D, R3 & DD, R3 & DDD, R3 & n, R3 & bn,
R & Courbure, R & Torsion );
//Calcul de la derivee premiere, seconde, troisieme, du vecteur normal
//et binormal, de la courbure et torsion au noeud u d'une courbe NURBS
R LongueurNURBS(); //approximation de la longueur de la courbe
virtual void Elevation1Degre(Points *LesPoints); //Effectif pour Bezier SEUL
//le degre des polynomes est augmente de 1 sans modifier la courbe
void InsererNoeudNURBS( Points *LesPoints, R u, Z NbInsertion );
//Inserer le noeud u NbInsertion fois et sa multiplicite reste <=degre
//sans modifier la courbe
void DeplacerPC( Points * LesPoints, Point * PPointCourant );
//Deplacer a l'aide de la souris un Point de controle d'une courbe NURBS
};

class LigneDroite : public Ligne
{
private :
Point *PtInitial;
Point *PtFinal;
public :
LigneDroite(Points *LesPoints); //constructeur a l'aide de la souris
LigneDroite(Points *LesPoints, Nom NomLg, Nom ptinitial, Nom ptfinal);
void LigneDroiteNURBS(); //creation des noeuds et points de controle
virtual void AfficherDefinition(); //par texte
virtual void VerifierMaillage(Points *LesPoints);
//si date des points ulterieur a la ligne => Re maillage
};

class LigneCercle : public Ligne // CERCLE dans le plan Z=0
{
private :
Point *PtCentre;
R rayon;
public :
LigneCercle(Points *LesPoints); //constructeur a l'aide de la souris
LigneCercle(Points *LesPoints, Nom NomLg, Nom ptcentre, R rayon);
void LigneCercleNURBS(Points *LesPoints); //creation noeuds et PC
virtual void AfficherDefinition(); //par texte
virtual void VerifierMaillage(Points *LesPoints);
//si date des points ulterieur a la ligne => Re maillage
};

class LigneBEZIER : public Ligne // COURBE de BEZIER Polynomiale ou Rationnelle
{
public :
LigneBEZIER(Points *LesPoints); //constructeur a l'aide de la souris
LigneBEZIER(Points *LesPoints, int clavier); //constructeur au clavier
LigneBEZIER(Points *LesPoints, Nom NomLg,
int degrepol, Nom pc[], R poids[]);
virtual void AfficherDefinition(); //par texte
virtual void VerifierMaillage(Points *LesPoints);
//si date des points ulterieur a la ligne => Re maillage
void Elevation1Degre(Points *LesPoints);
};

class LigneNURBS : public Ligne // COURBE NURBS
{
public :
LigneNURBS(Points *LesPoints); //constructeur a l'aide de la souris
LigneNURBS(Points *LesPoints, int clavier); //constructeur au clavier
LigneNURBS(Points *LesPoints, Nom NomLg,
int degrepol, int nbtpoints, //nombre total de points
R u[], Nom pc[], R poids[]);
virtual void AfficherDefinition(); //par texte
virtual void VerifierMaillage(Points *LesPoints);
//si date des points ulterieur a la ligne => Re maillage
};

//==============================================================================

class Lignes
{
public:
Ligne *P1Ligne; //tete du chainage des Lignes
public:
Lignes(); //initialise la tete de chainage a NULL
~Lignes(); //destruction des lignes
Ligne *RetrouverLigne( Nom NomLg, Ligne * & LgAvant ); //par son nom
Ligne *CliquerLigne( void ); //retrouver une ligne par clic souris
int EntrerLignes( Points *LesPoints ); //par nom au clavier
void Ajouter1Ligne( Ligne *PLigne ); //dans le chainage des Lignes
void AfficherLignes(); //par texte
void TracerLignes( MemoirePx3d & mpx, Points *LesPoints ); //graphique
};

//==============================================================================
//Fonstions utilitaires
//==============================================================================
int ProjectionDansXYSCU( MemoirePx3d & mpx, R3 SCU[], R3 P, R3 & Pscu );
//Projection du point P (dans SCG) selon la direction PtVu->OEIL
//sur le plan XY du SCU actuel
//Pscu est le point (dans SCG) projete de P dans le plan XY du SCU
//retourne 1 si le Point projete Pscu existe et 0 sinon

void PlusProcheXYSCU( MemoirePx3d & mpx, R3 SCU[], R3 Pt, R3 & PtCoin );
//retourne pour le point Pt appartenant au plan XY du SCU
//le point PtCoin du coin le plus proche du plan XY du SCU
//Pt de coordonnees SCG
//PtCoin de coordonnees SCG

int ProjectionClicSourisSCU( MemoirePx3d & mpx, R3 SCU[], XPoint pxy,
R3 & PgSCU );
//retourne 1 si PgSCU est le point projete PgSCU dans plan XY du SCU du pt pxy
// 0 si pas de projection possible
//==============================================================================

#endif

#endif