#include "LesFichiers.h"
#include "Rn.h"

// ========================================================================
// Les DONNEES PUBLIQUES de Vu
// ========================================================================
static R epzero=1e-6;
//Precison absolue pour identifier 2 points de R3 dans le voisinage de zero

static R epsxyz=1e-5;
//Precison relative pour identifier 2 points de R3 hors le voisinage de zero

static int langag=0;
//Choix du langage des impressions: 0=>Francais 1=>Anglais

static long nbs1970=0;
//Initialisation du nombre d'appels a la fonction Secondes1970()
//sert a dissocier les decimales des secondes depuis 1970
//pour que 2 appels successifs n'aient pas la meme date

//Le numero des couleurs imposees dans la palette des couleurs
extern int Noir, Rouge, Vert, Bleu, Cyan, Jaune, Magenta, Blanc,
GrisSombre, Gris, GrisClair, Beige, Orange, Saumon, Rose, Turquoise;

extern int noforeground,nobackground;//no dans norgb couleurs trace fond
extern unsigned long foreground, background;//couleur X de trace et fond

extern int lapxfe, lhpxfe; //nombre de pixels de la fenetre en largeur hauteur
extern int largbouton, hautbouton, hauttexte; //trace d'un bouton de Menu ...

extern R3 SCG[4], SCU[4];
//Le Systeme de Coordonnees Global SCG et Utilisateur SCU
//Le point origine et les 3 vecteurs orthonormes du SCx dans le SCG
//Le plan XY du SCU peut etre trace avec une grille dite GrilleSCU
extern int AccrocherGrilleSCU; //Mode Accrocher aux coins de la grille
//0:non actif 1:actif
extern int CouleurGrilleSCU; //couleur de trace de la grille
//si <0 pas de trace de la grille
extern R2 PasGrilleSCU; //pas de la grille en largeur et hauteur

extern int CouleurChiffre; //couleur de trace des chiffres des graduations

extern Window fenetre_vu; //la fenetre de l'ecran ou sont faits les traces

//=======================================================================
// LES PROTOTYPES des FONCTIONS PUBLIQUES du logiciel Vu
//=======================================================================

// La session X-windows
// ======================================================================
void VuInitier( void );
// Initialiser le display et l'ecran X

void VuOuvrir( char *titre_fenetre_vu, int lafepx, int hafepx, int nphfco );
//Initialiser et ouvrir la fenetre graphique x
//selon la largeur et hauteur pixels de la fenetre a ouvrir et
//a partir du coin superieur gauche de l'ecran
//Definir la palette des couleurs
//Recuperer les caracteristiques des fontes de caracteres
//Charger la fonte de hauteur pixels precisee
//a partir des entrees:
// titre_fenetre_vu : chaine de caracteres du titre de la fenetre Vu
// lafepx : nombre de pixels de la largeur de la fenetre a ouvrir
// hafepx : nombre de pixels de la hauteur de la fenetre a ouvrir
// nphfco : nombre de pixels en hauteur de la fonte de caracteres X a charger

void VuFermer( void );
//Fermer la fenetre, l'ecran graphique et le display

void VuEffacer( void );
//Effacer la fenetre graphique X (et PostScript) avec la couleur du fond

// Recuperer des informations sur l'ecran graphique et la fenetre X
//=======================================================================
void VuPxEcran( int & lapxec, int & lhpxec );
//nombre de pixels de la largeur et hauteur de l'ecran total

void VuMMEcran( int & lammec, int & lhmmec );
//largeur et hauteur de l'ecran total en MILLIMETRES

void VuPxFenetre( int & lapxfe, int & lhpxfe );
//RECUPERER le nombre de pixels de la largeur et hauteur de la FENETRE

// Recuperer les evenements survenus a la souris ou au clavier
//======================================================================
void VuSouris( int & notypeevt, int & nbc, XPoint & xy1 );
// RETOURNER le type et les caracteristiques du dernier EVENEMENT
// notypeevt : = 0 Si ABANDON demand'e par clic du bouton 2 de la souris
// ou par frappe de la touche Echappement ou @
// = 1 Si CLIC ENFONCE et RELACHE D'UN BOUTON DE LA SOURIS => xy1
// =-1 Si CLIC SEULEMENT ENFONCE D'UN BOUTON DE LA SOURIS => xy1
// =-2 Si DEPLACEMENT du POINTEUR de la SOURIS => xy1
// = 2 Si FRAPPE d'un CARACTERE au CLAVIER
// et nbc=numero du caractere dans la table ASCII

// Le traitement des couleurs
//=======================================================================
void VuPaletteCouleurs( int nopacoul );
//IMPOSER la palette nopacoul (1 a 12) de couleurs

void VuCouleur( int icolor );
//IMPOSER pour tous les traces a venir la couleur icolor de la palette actuelle

void VuCouleurFond( int icolor );
//IMPOSER une couleur comme FOND de FENETRE

// Les chaines de caracteres
//=======================================================================
void VuChargerFonte( int nufont );
//CHARGER en memoire la fonte de caracteres X de numero nufont

void VuChoisirFonte( int lhpxfonte );
//CHARGER en memoire la fonte de caracteres de hauteur en pixels
//proche de lhpxfonte

void VuNbPxTexte( char *texte, int & nbpxla, int & nbpxha );
//Retrouver les dimensions en pixels de la chaine de caracteres texte

// Les types de traces des traits
//======================================================================
void VuTypeTrait( int type );
//IMPOSER le type de trace d'un trait
// type : =0 LIGNE CONTINUE
// =1 LIGNE TIRETEE
// =2 LIGNE TIRETEE D'EPAISSEUR DOUBLE

void VuEpaisseur( int epais );
//IMPOSER le nombre d'epaisseurs des traits

//=========================================================================
// la classe des memoires de pixels (fenetre de l'ecran ou pixmap)
//=========================================================================
class MemoirePx //Dans une memoire de pixels se font les traces
{ //MAIS seule une fenetre rend visible ces traces
public :
Drawable mempx; //Pixmap (trace non visible) ou fenetre (visible)
unsigned int largeurpx; //en pixels de la memoire de pixels
unsigned int hauteurpx; //en pixels de la memoire de pixels
XPoint pxcsgdf; //xy du pixel du coin superieur gauche de la memoirepx
//dans la fenetre rendant le trace visible

static const int minint=-1024; // les limites de l'ecran au dela
static const int maxint= 2048; // desquelles le trace est rejete

int visee; // numero du mode de visee pour cette MemoirePx
// 0 si visee non initialisee
// 2 si visee 2d par execution de VuFenetre2d
// 3 si visee 3d par axonometrie avec PTV OEIL
// AXOLAR AXOHAU AXOARR AXOAVA

// La gestion de la fenetre_vu et des pixmap de sauvegarde ou traces
//==================================================================
MemoirePx(){}; //Constructeur des donnees mais pas du Pixmap ou fenetre
~MemoirePx(); //Destructeur

void VuCreerPixmap( unsigned int largpix,unsigned int hautpix, XPoint csgdf );
//Creation du Pixmap de largpix pixels en largeur et hautpix pixels en hauteur
//a positionner au pixel csgdf coin superieur gauche de la fenetre visible

void VuEffacerMemoirePx( void );
//Effacer le contenu de la MemoirePx

void VuCombinerFenetreDansMemoirePx( int GX ,
XPoint xyfen, unsigned int largfen, unsigned int hautfen, //source
XPoint xympx ); //destination
// Combiner les pixels de la fenetre_vu dans MemoirePx selon le code GX
// a partir de xyfen coin superieur gauche de fenetre_vu
// dans MemoirePx.mempx a partir du coin superieur gauche xympx
//
// Les pixels du pixmap mempx (src) et la fenetre_vu (dst) se combinent selon
// la valeur de GX qui peut prendre les valeurs suivantes:
//
// GXclear 0x0 <=> 0
// GXand 0x1 <=> src AND dst src comme source
// GXandReverse 0x2 <=> src AND (NOT dst) dst comme destination
// GXcopy 0x3 <=> src
// GXandInverted 0x4 <=> (NOT src) AND dst
// GXnoop 0x5 <=> dst
// GXxor 0x6 <=> src XOR dst (XOR ouexclusif) (2 fois redonne src)
// GXor 0x7 <=> src OR dst
// GXnor 0x8 <=> (NOT src) AND (NOT dst)
// GXequiv 0x9 <=> (NOT src) XOR dst
// GXinvert 0xa <=> (NOT dst)
// GXorReverse 0xb <=> src OR (NOT dst)
// GXcopyInverted 0xc <=> (NOT src)
// GXorInverted 0xd <=> (NOT src) OR dst
// GXnand 0xe <=> (NOT src) AND (NOT dst)
// GXset 0xf <=> 1

void VuCombinerMemoirePxDansFenetre( int GX,
XPoint xympx, unsigned int largmpx, unsigned int hautmpx,//source
XPoint xyfen ); //destination
// Combiner les pixels de MemoirePx dans la fenetre_vu selon le code GX
// a partir de xympx coin superieur gauche de MemoirePx.mempx
// avec fenetre_vu a partir du coin superieur gauche xyfen
// le resultat devient apparent dans la fenetre de l'ecran
//
// Les pixels du pixmap mempx (src) et la fenetre_vu (dst) se combinent selon
// la valeur de GX qui peut prendre les valeurs suivantes vues au dessus

// Les traces dans MemoirePx en mode pixel
//=========================================================================
void VuTexte( XPoint xy, char *texte );
//Tracer un texte a partir du pixel xy de la fenetre avec la couleur courante

void VuSymbole( XPoint xy, char *texte );
// Trace le symbole texte avec la couleur courante au XPoint xy
// la chaine est decalee d'un demi caractere vers le bas et a gauche

void VuEntier( XPoint xy, int entier );
// Tracer les caracteres de l'entier avec la couleur courante
// a partir du point xy en coordonnees pixel

void VuReel( XPoint xy, R vreel, int nbchif10 );
// Tracer les caracteres de la valeur de vreel avec la couleur courante
// a partir du point xy en coordonnees pixel
// nbchif10 est le nombre de chiffres demandes de la partie decimale

void VuTrait( XPoint xy1, XPoint xy2 );
//TRACER du point (x1,y1) PIXELS au point (x2,y2) PIXELS
//avec la couleur courante

void VuTraits( int nbpoints, XPoint *points );
//ATTENTION XPoint p => short p.x et p.y
//TRACER les segments points(i) points(i+1) pour i=1 a nbpoints-1
//avec la couleur courante

void VuBordRectangle( XPoint xy, int largeur, int hauteur );
//TRACER les aretes du contour d'un rectangle avec la couleur courante

void VuRectangle( XPoint xy, int largeur, int hauteur );
//TRACER le remplissage du contour d'un rectangle avec la couleur courante

void VuFace( int nbpoints, XPoint *pts );
//TRACER le remplissage du polygone defini par les n points pts
//avec la couleur courante

void VuBordArcEllipse( XPoint xy, int largeur, int hauteur,
R angle1, R angle2 );
//TRACER le bord d'un secteur d'une ellipse avec la couleur courante

void VuArcEllipse( XPoint xy, int largeur, int hauteur,
R angle1, R angle2 );
//TRACER le remplissage d'un secteur d'une ellipse avec la couleur courante

void VuBordTriangle( XPoint xys1, XPoint xys2, XPoint xys3 );
// Trace les 3 aretes du triangle de sommets xys

void VuTriangleCouleur( XPoint xys1, XPoint xys2, XPoint xys3,
R coul1, R coul2, R coul3 );
// Trace le remplissage du triangle de sommets xys et de couleurs coul
// selon les couleurs intermediaires (PALETTE 11 arc en ciel RECOMMANDEE)
};

//=========================================================================
// la classe des memoires de pixels en coordonnees objet 2d
//=========================================================================
class MemoirePx2d : public MemoirePx
{
public : //Les donnees Vu2d
R xobmin,xobmax, yobmin,yobmax;
// xobmin : abscisse objet de la gauche de la fenetre
// xobmax : abscisse objet de la droite de la fenetre
// yobmin : ordonnee objet du bas de la fenetre
// yobmax : ordonnee objet du haut de la fenetre

R axobpx,bxobpx, ayobpx,byobpx;
// xob -> x pixels par nupxex(x) = axobpx * x + bxobpx
// xob2px(nx) = ( nx - bxobpx ) / axobpx
// axobpx = largeurpx / ( xobmax - xobmin )
// bxobpx = - 1.0 / ( xobmax - xobmin )
//
// yob -> y pixels par nupxey(y) = ayobpx * y + byobpx
// yob2px(ny) = ( ny - byobpx ) / ayobpx
// ayobpx = - hauteurpx / ( yobmax - yobmin )
// byobpx = 1.0 / ( yobmax - yobmin )

// Les traces en coordonnees objet 2d
//======================================================================
inline int Vunupxex( R xob );
// Retourne le numero du pixel ( abscisse ) de xob dans la fenetre

inline int Vunupxey( R yob );
// Retourne le numero du pixel ( ordonnee ) de yob dans la fenetre

R Vuxob2px( int nxpx );
// Retourne la valeur de l'abscisse objet 2d d'un pixel d'abscisse
// nxpx de la fenetre actuelle ( fonction inverse de nupxex )

R Vuyob2px( int nypx );
// Retourne la valeur de l'ordonnee objet 2d d'un pixel d'ordonnee
// nypx de la fenetre actuelle ( fonction inverse de nupxey )

void VuFenetre2d( R xutmin, R xutmax, R yutmin, R yutmax );
// Definir la mise a l'echelle pour voir la fenetre actuelle
// selon les coordonnees objet 2d donnes ici
// selon un repere a priori non orthonorme
// et stocker les coefficients de conversion a partir des entrees:
// xutmin : abscisse objet de la gauche de la fenetre
// xutmax : abscisse objet de la droite de la fenetre
// yutmin : ordonnee objet du bas de la fenetre
// yutmax : ordonnee objet du haut de la fenetre

void VuIsoFenetre2d( R xobjmi, R xobjmx, R yobjmi, R yobjmx );
// Definir la mise a l'echelle pour voir la fenetre actuelle
// selon les coordonnees objet donnes ici
// selon un repere orthonorme => le plus grand ecart en x ou y
// est ajuste a la fenetre
// stocker les coefficients de conversion a partir des entrees:
// xobjmi : abscisse objet de la gauche de la fenetre
// xobjmx : abscisse objet de la droite de la fenetre
// yobjmi : ordonnee objet du bas de la fenetre
// yobjmx : ordonnee objet du haut de la fenetre

void VuTrait( R2 xy1, R2 xy2 );
// Trace le trait 2d de xy1 a xy2
// la transformation en pixels est assuree dans cette fonction

void VuTraits( int nbs, R2 xy[] );
// Trace les segments de droite (x(i),y(i)) (x(i+1),y(i+1)) pour i=1 a nbs
// Attention (x,y) en coordonnees objet 2d
// la transformation en pixels est assuree dans cette fonction
// nbs : nombre de sommets des traits a tracer
// x : abscisse objet des nbs sommets des traits
// y : ordonnee objet des nbs sommets des traits

void VuVecteur( R2 xypt, R2 xyvect );
// Tracer le vecteur xyvect a partir du point de coordonnees xypt

void VuAxes( );
// Tracer les axes en 2d, leurs graduations et le plan XY du SCU

void VuCourbeP3H( int nca, int nepa, R porear,
int ncotg, int neptg, int ntrtg,
R2 xys1, R2 xys2, R2 xytg1, R2 xytg2 );
// Trace la courbe 2d interpolation P3-HERMITE passant par
// les 2 sommets xys1 et xys2 et de tangentes xytg1 et xytg2
// Attention la direction de la tangente en xys2 est xys2->xys1
// nca : numero de la couleur des aretes a tracer
// <0 pas de trace des aretes de la courbe
// nepa : nombre d'epaisseurs a ajouter au trait d'une arete
// porear : pourcentage de reduction du trace d'une arete 0.0<=porear<=100.0
// nctg : >=0 numero de la couleur des 2 tangentes a tracer
// < 0 pas de trace des 2 tangentes
// neptg : >=0 nombre d'epaisseurs a ajouter au trait d'une tg
// ntrtg : trace en continu(0) ou pointille (1) ou double pointille(2)

void VuFace( int nbpoints, R2 xy[] );
// Trace la face 2d de sommets (x,y) avec les couleurs ncf nca
// la transformation en pixels est assuree dans cette fonction
// entrees:
// nbpoints: nombre de sommets de la face a tracer
// xy : abscisse ordonnee objet des nbpoints sommets de la face

void VuBordTriangle( R2 xys1, R2 xys2, R2 xys3 );
// Trace les 3 aretes du triangle de sommets xys

void VuTriangleCouleur( R2 xys1, R2 xys2, R2 xys3,
R couleur1, R couleur2, R couleur3 );
// Trace le triangle de sommets xys1, xys2, xys3 de couleurs 1 2 3
// selon les couleurs intermediaires (PALETTE 11 RECOMMANDEE)
// entrees:
// couleur i: couleur entre n1coul et ndcoul dans la palette actuelle
// xys i : coordonnees du sommet i=1,2,3

void VuTexte( R2 xy, char *texte );
// Trace les caracteres du texte
// a partir du point (x,y) en coordonnees objet 2d
// les autres caracteristiques du trace sont celles actuelles
// entrees:
// xy : abscisse ordonnee objet2d du texte a tracer
// texte : les caracteres a tracer

void VuSymbole( R2 xy, char *texte );
// Trace le texte avec la couleur nc
// a partir du point (x,y) en coordonnees objet 2d
// la transformation en pixels est assuree dans cette fonction
// la chaine est decalee d'un demi caractere vers le bas et a gauche
// entrees:
// xy : abscisse ordonnee objet2d du symbole
// texte : la chaine de caracteres servant de symbole

void VuEntier( R2 xy, int entier );
// Trace les caracteres de l'entier
// a partir du point (x,y) en coordonnees objet 2d
// la transformation en pixels est assuree dans cette fonction
// les autres caracteristiques du trace sont celles actuelles
// entrees:
// nc : numero de la couleur des caracteres de l'entier
// xy : abscisse ordonnee objet2d des caracteres de la valeur de l'entier
// entier : entier dont la valeur doit etre tracee precedee de '.'

void VuReel( R2 xy, R vreel, int nbchif10 );
// Trace les caracteres de vreel
// a partir du point (x,y) en coordonnees objet 2d
// la transformation en pixels est assuree dans cette fonction
// les autres caracteristiques du trace sont celles actuelles
// entrees :
// nc : numero de la couleur des caracteres de vreel
// xy : abscisse ordonnee objet2d des caracteres de vreel
// vreel : valeur Reelle a tracer
// nbchif10: nombre de chiffres demandes de la partie decimale
};

//=========================================================================
// la classe des memoires de pixels en coordonnees objet 3d
//=========================================================================
class MemoirePx3d : public MemoirePx2d
{
public :
//Les donnees Vu3d
R axolar; // LARGEUR/2 VUE SUR L'ECRAN (EN VALEUR ABSOLUE )
R axohau; // HAUTEUR/2 VUE SUR L'ECRAN
R axoarr; // DISTANCE A PTV DU PLAN ARRIERE DE SECTION
R axoava; // DISTANCE A PTV DU PLAN AVANT DE SECTION
R3 axoptv; // XYZ DU POINT VISE
R3 axoeil; // XYZ DE L'OEIL
R axomat[9];// MATRICE DE LA TRANSFORMATION (XYZAXO = AXOMAT * (xyz - PTV))
// stockee [ 0, 3, 6 ]
// [ 1, 4, 7 ]
// [ 2, 5, 8 ]

int nblampe; // NOMBRE DE LAMPES si 0 => OEIL sert d'unique lampe
R3 *axolampe; // XYZ axonometrique de chacune des nblampe lampes
// en fait si pointeur non NULL tableau R3 axolampe[nblampe]

MemoirePx3d():MemoirePx2d() {}; //constructeur des donnees mais pas du Pixmap

void VuCreerPixmap( unsigned int largpix, unsigned int hautpix, XPoint csgdf )
{MemoirePx::VuCreerPixmap(largpix,hautpix,csgdf); nblampe=0; axolampe=NULL;};
//Creer le pixmap de largpix pixels en largeur et hautpix pixels en hauteur
//a positionner au pixel csgdf coin superieur gauche de la fenetre visible

// Les traces en coordonnees objet 3d
//======================================================================
void VuLonLat( R deglon, R deglat );
// Definir la position de l'oeil en fonction de longitude et latitude
// a partir des entrees :
// deglon : degres de longitude compris entre 0 et 360 degres
// deglat : degres de latitude compris entre -90 et 90 degres

void VuPtVuLonLat( R3 ptv, R deglon, R deglat );
// Definir point vise et oeil en fonction de longitude et latitude
// Definir la nouvelle matrice d'axonometrie
// a partir des entrees:
// ptv : position du point vise
// deglon : degres de longitude compris entre 0 et 360 degres
// deglat : degres de latitude compris entre -90 et 90 degres

void VumataxoId( void );
//Initialiser la matrice axomat a l'Identite dans R3x3

void Vumataxo(void);
//Construire la matrice axomat[3,3] de la projection axonometrique
//a partir des 3 coordonnees du point vise ptv
// des 3 coordonnees position de l'oeil

void Vuxyzaxo( R3 xyz, R3 & axyz );
//Calculer les 3 coordonnees axonometriques axyz
//a partir des 3 coordonnees du point xyz dans le SCG

void Vuaxoxyz( R3 axyz, R3 & xyz );
//Calculer les 3 coordonnees xyz dans le repere SCG
//a partir des 3 coordonnees axonometriques

void VuAxonometrie( R3 axptv, R3 axeil,
R axlar, R axhau, R axarr, R axava );
//Construire la matrice axomat[3,3] de la projection axonometrique
//a partir des 3 coordonnees du point vise ptv
// des 3 coordonnees position de l'oeil
// de la largeur et hauteur de la fenetre ecran
// de la profondeur et avance dans la direction de visee
//a partir des entrees:
// axlar : largeur/2 vue sur l'ecran (en valeur absolue )
// axhau : hauteur/2 vue sur l'ecran
// axarr : distance a ptv du plan arriere de section
// axava : distance a ptv du plan avant de section
// axptv : xyz du point vise
// axeil : xyz de l'oeil
// et fournir les sorties en donnees membres
// visee : numero du mode de la visee
// 0 si non initialise (pixels)
// 2 si initialise en 2d
// 3 si axonometrie par ptv oeil axoarr et axoava
// axolar : largeur/2 vue sur l'ecran (en valeur absolue )
// axohau : hauteur/2 vue sur l'ecran
// axoarr : distance a ptv du plan arriere de section
// axoava : distance a ptv du plan avant de section
// axoptv : xyz du point vise
// axoeil : xyz de l'oeil
// axomat : matrice de la transformation (xyzaxo = axomat * (xyz - ptv))

void VuHexaedre( R3 PtMIN, R3 PtMAX );
//Definir l'axonometrie pour voir l'hexaedre PtMIN-PtMAX
//Tracer les axes et le plan XY du SCU actuel

void VuTrait( R3 xyz1, R3 xyz2 );
//Tracer le trait 3d de (x1,y1,z1) a (x2,y2,z2)

void VuTraits( int nbs, R3 xyzs[] );
//Tracer les segments de droite (xyz[i] xyz[i+1]) pour i=1 a nbs
// la transformation en pixels est assuree dans cette fonction
// a partir des entrees:
// nbs : nombre de sommets des traits a tracer
// xyzs : abscisse ordonnee cote des nbs sommets des traits

void VuFace( int nbs, R3 xyz[] );
//Tracer la face 3d de nbs sommets XYZ
//a partir des entrees :
// nbs : nombre de sommets de la face a tracer
// xyz : abscisse, ordonnee, cote des nbs sommets de la face

void VuBordTriangle( R3 xyzs1, R3 xyzs2, R3 xyzs3 );
//Tracer les 3 aretes du triangle de sommets xyzs 123

R CouleurEclairage( R3 normale );
//Calculer la couleur proportionnellement au cosinus de l'angle
//entre la normale au point et les directions des eclairages
//definis par les lampes (ou l'oeil) et le point vu
//la couleur est comprise entre n1coul et ndcoul

void VuVecteur( R3 xyzpt, R3 xyzvect );
//Tracer le vecteur xyzvect a partir du point de coordonnees xyzpt

void VuAxes( R3 PtMin, R3 PtMax );
//Tracer l'hexaedre entre PtMin et PtMax) et la grille du SCU

void VuCourbeP3H( int nca, int nepa, R porear,
int ncotg, int neptg, int ntrtg,
R3 xyzs1, R3 xyzs2,
R3 xyztg1, R3 xyztg2 );
//Tracer la courbe 3d interpolation P3-HERMITE passant par
//les 2 sommets xyzs1 et xyzs2 et tangente aux vecteurs xyztg1 et xyztg2
//Attention la direction de la tangente en xyzs2 est xyzs2->xyzs1
// nca : >=0 numero de la couleur des aretes a tracer
// < 0 pas de trace des aretes de la courbe
// nepa : nombre d'epaisseurs a ajouter au trait d'une arete
// porear : pourcentage de reduction du trace d'une arete 0.0<=porear<=100.0
// nctg : >=0 numero de la couleur des 2 tangentes a tracer
// < 0 pas de trace des 2 tangentes
// neptg : >=0 nombre d'epaisseurs a ajouter au trait d'une tg
// ntrtg : trace en continu(0) ou pointille (1) ou double pointille(2)

void VuTriangleCouleur( R3 xyzs1, R3 xyzs2, R3 xyzs3,
R couleur1, R couleur2, R couleur3 );
//Tracer le triangle de sommets xyzs1, xyzs2, xyzs3 de couleurs 1 2 3
//selon les couleurs intermediaires (la palette doit etre initialisee)
//ainsi que les aretes du triangle selon la couleur nca
//a partir des entrees:
// couleur i: couleur entre n1coul et ndcoul dans la palette actuelle i=1,2,3
// xyzs i : coordonnees du sommet i=1,2,3
// nca : couleur de trace des 3 aretes sauf si nca<0 => pas de trace

void VuTriangleHCT( int lcritr, int ncf, R porefa,
int ncsa, int nca, int neparf,
int ncotgf, int neptgf, int ntrtgf,
R x[9], R y[9], R z[9] );
//Tracer le triangle HCT-reduit de sommets et tangentes rangees
//dans les tableaux x,y,z (sommets 1 a 3, tangentes 4 a 9) et
//selon la couleur ncf pour la face et nca pour les aretes
//a partir des entrees:
// lcritr :=0 prise en compte de la normale et des eclairages
// sur un decoupage en sous triangles du triangle et
// les fonctions de base de l'ef HCT reduit
// dans ce cas ncf est inactif
// Palette de couleurs 3 a 9 recommandee
// >0 prise en compte de la couleur ncf sur tout le triangle
// ncf : numero de la couleur de remplissage de la face a tracer
// si lcritr>0 inactif sinon
// <0 pas de trace de l'interieur de la face
// porefa : pourcentage de reduction du trace du triangle par rapport
// au barycentre ( 0.0<=porefa<100.0 )
// nca : >=0 numero de la couleur des 3 aretes du triangle
// <0 pas de trace des 3 aretes du triangle
// ncsa : >=0 numero de la couleur des aretes des n*n sous-triangles
// <0 pas de trace des aretes des n*n sous-triangles
// neparf : nombre d'epaisseurs en plus de trace des aretes du triangle
// ncotgf : >=0 numero de la couleur de trace des tangentes
// < 0 pas de trace des tangentes
// neptgf : nombre d'epaisseurs supplementaires du trace des tangentes
// ntrtgf : numero du type de trait de trace des tangentes
// 0 continu, 1: tirete, 2: doublement tirete
// x : abscisse objet des 3 sommets et 6 tangentes a la face
// y : ordonnee objet des 3 sommets et 6 tangentes a la face
// z : cote objet des 3 sommets et 6 tangentes a la face
// x, y, z: a ranger selon l'ordre suivant
// au sommet1, au sommet2, au sommet3,
// au sommet1 la tangente1 selon s1->s2
// au sommet1 la tangente2 selon s1->s3
// au sommet2 la tangente1 selon s2->s3
// au sommet2 la tangente2 selon s2->s1
// au sommet3 la tangente1 selon s3->s1
// au sommet3 la tangente2 selon s3->s2
// ce choix permet une boucle sur les tangentes par les sommets

void VuTriangleHCT( int lcritr, int ncf, R porefa,
int ncsa, int nca, int neparf,
int ncotgf, int neptgf, int ntrtgf,
int nost[3], R3 xyzst[],
int notg[6], R3 xyztg[] );
//Tracer le triangle HCT-reduit de sommets nost dans xyzst
//et de tangentes notg rangees dangees dans xyztg
//selon la couleur ncf pour la face et nca pour les aretes
//a partir des entrees:
// lcritr :=0 prise en compte de la normale et des eclairages
// sur un decoupage en sous triangles du triangle et
// les fonctions de base de l'ef HCT reduit
// dans ce cas ncf est inactif
// Palette de couleurs 3 a 9 recommandee
// >0 prise en compte de la couleur ncf sur tout le triangle
// ncf : numero de la couleur de remplissage de la face a tracer
// si lcritr>0 inactif sinon
// <0 pas de trace de l'interieur de la face
// porefa : pourcentage de reduction du trace du triangle par rapport
// au barycentre ( 0.0<=porefa<100.0 )
// nca : >=0 numero de la couleur des 3 aretes du triangle
// <0 pas de trace des 3 aretes du triangle
// ncsa : >=0 numero de la couleur des aretes des n*n sous-triangles
// <0 pas de trace des aretes des n*n sous-triangles
// neparf : nombre d'epaisseurs en plus de trace des aretes du triangle
// ncotgf : >=0 numero de la couleur de trace des tangentes
// < 0 pas de trace des tangentes
// neptgf : nombre d'epaisseurs supplementaires du trace des tangentes
// ntrtgf : numero du type de trait de trace des tangentes
// 0 continu, 1: tirete, 2: doublement tirete
// nost : numero des 3 sommets dans le tableau xyzst (de 1 a Nombre de sommets)
// xyzst: X Y Z des sommets
// notg : numero des 2 tangentes en chacun des 3 sommets du triangle
// (de 1 a Nombre de sommets) avec 3 cas >0 =0 et <0 possibles
// 1: au sommet1 la tangente1 est selon s1->s2
// 2: au sommet1 la tangente2 est selon s1->s3
// 3: au sommet2 la tangente1 est selon s2->s3
// 4: au sommet2 la tangente2 est selon s2->s1
// 5: au sommet3 la tangente1 est selon s3->s1
// 6: au sommet3 la tangente2 est selon s3->s2
// attention:
// - un numero negatif de tg demande l'inversion des signes
// des 3 composantes de la tangente
// - un numero nul de tg entraine une tangente egale a l'arete correspondante
//
//Dans la suite de cette fonction sont formes 3 tableaux X[9], Y[9], Z[9]
//contenant respectivement l'abscisse X, l'ordonnee Y et la cote Z
//pour calculer rapidement la valeur de HCT(u,v)
// x : abscisse objet des 3 sommets et 6 tangentes a la face
// y : ordonnee objet des 3 sommets et 6 tangentes a la face
// z : cote objet des 3 sommets et 6 tangentes a la face
// x, y, z: a ranger selon l'ordre suivant
// au sommet1, au sommet2, au sommet3,
// au sommet1 la tangente1 selon s1->s2
// au sommet1 la tangente2 selon s1->s3
// au sommet2 la tangente1 selon s2->s3
// au sommet2 la tangente2 selon s2->s1
// au sommet3 la tangente1 selon s3->s1
// au sommet3 la tangente2 selon s3->s2
//ce choix permet une boucle sur les tangentes par les sommets

void VuQuadrangleDVS( int lcritr, int ncf, R porefa,
int ncsa, int nca, int neparf,
int ncotgf, int neptgf, int ntrtgf,
R x[12], R y[12], R z[12] );
//Tracer le quadrangle dVS-reduit de sommets et tangentes rangees
//dans les tableaux x,y,z (sommets 1 a 4, tangentes 5 a 12) et
//selon la couleur ncf pour la face et nca pour les aretes
//a partir des entrees:
// lcritr :=0 prise en comptetriangle de la normale et des eclairages
// sur un decoupage en sous quadrangles du quadrangle et
// les fonctions de base de l'ef HCT reduit
// dans ce cas ncf est inactif
// Palette de couleurs 3 a 9 recommandee
// >0 prise en compte de la couleur ncf sur tout le quadrangle
// ncf : numero de la couleur de remplissage de la face a tracer
// si lcritr>0 inactif sinon
// <0 pas de trace de l'interieur de la face
// porefa : pourcentage de reduction du trace du quadrangle par rapport
// au barycentre ( 0.0<=porefa<100.0 )
// nca : >=0 numero de la couleur des 4 aretes du quadrangle
// <0 pas de trace des 4 aretes du quadrangle
// ncsa : >=0 numero de la couleur des aretes des n*n sous-quadrangles
// <0 pas de trace des aretes des n*n sous-quadrangles
// neparf : nombre d'epaisseurs en plus de trace des aretes du quadrangle
// ncotgf : >=0 numero de la couleur de trace des tangentes
// < 0 pas de trace des tangentes
// neptgf : nombre d'epaisseurs supplementaires du trace des tangentes
// ntrtgf : numero du type de trait de trace des tangentes
// 0 continu, 1: tirete, 2: doublement tirete
// nost : numero des 3 sommets dans le tableau xyzst (de 1 a Nombre de sommets)
// xyzst: X Y Z des sommets
// notg : numero des 2 tangentes en chacun des 4 sommets du quadrangle
// (de 1 a Nombre de sommets) avec 3 cas >0 =0 et <0 possibles
// 1: au sommet1 la tangente1 est selon s1->s2
// 2: au sommet1 la tangente2 est selon s1->s3
// 3: au sommet2 la tangente1 est selon s2->s3
// 4: au sommet2 la tangente2 est selon s2->s1
// 5: au sommet3 la tangente1 est selon s3->s1
// 6: au sommet3 la tangente2 est selon s3->s2
// attention:
// - un numero negatif de tg demande l'inversion des signes
// des 3 composantes de la tangente
// - un numero nul de tg entraine une tangente egale a l'arete correspondante
//
// Dans la suite de cette fonction sont formes 3 tableaux X[9], Y[9], Z[9]
// contenant respectivement l'abscisse X, l'ordonnee Y et la cote Z
// pour calculer rapidement la valeur de HCT(u,v)
// x : abscisse objet des 3 sommets et 6 tangentes a la face
// y : ordonnee objet des 3 sommets et 6 tangentes a la face
// z : cote objet des 3 sommets et 6 tangentes a la face
// x, y, z: a ranger selon l'ordre suivant
// au sommet1, au sommet2, au sommet3,
// au sommet1 la tangente1 selon s1->s2
// au sommet1 la tangente2 selon s1->s3
// au sommet2 la tangente1 selon s2->s3
// au sommet2 la tangente2 selon s2->s1
// au sommet3 la tangente1 selon s3->s4
// au sommet3 la tangente2 selon s3->s2
// au sommet4 la tangente1 selon s4->s1
// au sommet4 la tangente2 selon s4->s3
// ce choix permet une boucle sur les tangentes par les sommets

void VuQuadrangleDVS( int lcritr, int ncf, R porefa,
int ncsa, int nca, int neparf,
int ncotgf, int neptgf, int ntrtgf,
int nost[4], R3 xyzst[],
int notg[8], R3 xyztg[] );
//Tracer le quadrangle dVS-reduit de sommets et tangentes rangees
//dans les tableaux x,y,z (sommets 1 a 4, tangentes 5 a 12) et
//selon la couleur ncf pour la face et nca pour les aretes
//a partir des entrees:
// lcritr :=0 prise en comptetriangle de la normale et des eclairages
// sur un decoupage en sous quadrangles du quadrangle et
// les fonctions de base de l'ef HCT reduit
// dans ce cas ncf est inactif
// Palette de couleurs 3 a 9 recommandee
// >0 prise en compte de la couleur ncf sur tout le quadrangle
// ncf : numero de la couleur de remplissage de la face a tracer
// si lcritr>0 inactif sinon
// <0 pas de trace de l'interieur de la face
// porefa : pourcentage de reduction du trace du quadrangle par rapport
// au barycentre ( 0.0<=porefa<100.0 )
// nca : >=0 numero de la couleur des 4 aretes du quadrangle
// <0 pas de trace des 4 aretes du quadrangle
// ncsa : >=0 numero de la couleur des aretes des n*n sous-quadrangles
// <0 pas de trace des aretes des n*n sous-quadrangles
// neparf : nombre d'epaisseurs en plus de trace des aretes du quadrangle
// ncotgf : >=0 numero de la couleur de trace des tangentes
// < 0 pas de trace des tangentes
// neptgf : nombre d'epaisseurs supplementaires du trace des tangentes
// ntrtgf : numero du type de trait de trace des tangentes
// 0 continu, 1: tirete, 2: doublement tirete
// nost : numero des 4 sommets dans le tableau xyzst (de 1 a Nombre de sommets)
// xyzst: X Y Z des sommets
// notg : numero des 2 tangentes en chacun des 4 sommets du quadrangle
// (de 1 a Nombre de sommets) avec 3 cas >0 =0 et <0 possibles
// 1: au sommet1 la tangente1 est selon s1->s2
// 2: au sommet1 la tangente2 est selon s1->s3
// 3: au sommet2 la tangente1 est selon s2->s3
// 4: au sommet2 la tangente2 est selon s2->s1
// 5: au sommet3 la tangente1 est selon s3->s4
// 6: au sommet3 la tangente2 est selon s3->s2
// 7: au sommet4 la tangente1 est selon s4->s1
// 8: au sommet4 la tangente2 est selon s4->s3
// attention:
// - un numero negatif de tg demande l'inversion des signes
// des 3 composantes de la tangente
// - un numero nul de tg entraine une tangente egale a l'arete correspondante
//
// Dans la suite de cette fonction sont formes 3 tableaux X[12], Y[12], Z[12]
// contenant respectivement l'abscisse X, l'ordonnee Y et la cote Z
// pour calculer rapidement la valeur de HCT(u,v)
// x : abscisse objet des 4 sommets et 8 tangentes a la face
// y : ordonnee objet des 4 sommets et 8 tangentes a la face
// z : cote objet des 4 sommets et 8 tangentes a la face
// x, y, z: a ranger selon l'ordre suivant
// au sommet1, au sommet2, au sommet3,
// au sommet1 la tangente1 selon s1->s2
// au sommet1 la tangente2 selon s1->s3
// au sommet2 la tangente1 selon s2->s3
// au sommet2 la tangente2 selon s2->s1
// au sommet3 la tangente1 selon s3->s4
// au sommet3 la tangente2 selon s3->s2
// au sommet4 la tangente1 selon s4->s1
// au sommet4 la tangente2 selon s4->s3
// ce choix permet une boucle sur les tangentes par les sommets

void VuTriangle3s3n( int lcritr, int nca, int nepa, int ncn, int nepn,
R3 xyzs1, R3 xyzs2, R3 xyzs3,
R3 xyzn1, R3 xyzn2, R3 xyzn3 );
//Tracer le triangle defini par les 3 coordonnees de ses 3 sommets
//et des 3 normales aux sommets selon le code lcritr
//a partir des entrees:
// lcritr : =-1 pas de trace de la face du triangle
// = 0 trace du triangle avec une couleur obtenue selon
// l'eclairage et a partir de la normale moyenne des 3 normales
// = 1 trace du triangle avec une couleur obtenue selon
// l'eclairage et a partir des 3 normales aux sommets
// = 2 trace du triangle avec une couleur obtenue selon
// l'eclairage et les 6 tangentes obtenues a partir
// des 3 aretes et des 3 normales puis triangle HCT
// nca : >=0 numero de la couleur des 3 aretes du triangle
// < 0 pas de trace des 3 aretes du triangle
// nepa : >=0 nombre d'epaisseurs en plus de trace des aretes du triangle
// ncn : >=0 numero de la couleur des normales aux sommets
// <0 pas de trace des aretes des n*n sous-triangles
// nepn : >=0 nombre d'epaisseurs en plus de trace des normales
// xyzs1 : X Y Z du sommet 1
// xyzs2 : X Y Z du sommet 2
// xyzs3 : X Y Z du sommet 3
// xyzn1 : X Y Z de la normale au sommet 1
// xyzn2 : X Y Z de la normale au sommet 2
// xyzn3 : X Y Z de la normale au sommet 3

void VuTexte( R3 xyz, char *texte );
//Tracer les caracteres du texte
//a partir du point (x,y,z) en coordonnees objet 3d

void VuSymbole( R3 xyz, char *texte );
//Tracer le texte qui sert de symbole
//a partir du point (x,y,z) en coordonnees objet 3d
//la chaine est decalee d'un demi caractere vers le bas et a gauche

void VuEntier( R3 xyz, int entier );
//Tracer les caracteres de la valeur de entier
//a partir du point (x,y,z) en coordonnees objet 3d

void VuReel( R3 xyz, R vreel, int nbchif10 );
//Tracer les caracteres de la valeur de R
//a partir du point xyz en coordonnees objet 3d
//nbchif10: nombre de chiffres a tracer de la partie decimale
};

//=========================================================================
// la classe des memoires de pixels des Menus
//=========================================================================
class MemoirePxMenu : public MemoirePx
{
public :

// Les traitement d'un menu horizontal ou vertical ou lateral
//======================================================================
void VuBoutonCadre( XPoint pxy0, int largbouton, int hautbouton );
//Tracer le cadre d'un bouton de menu avec son eclairage
//en haut a gauche et un ombrage en bas a droite
//a partir des entrees:
// pxy0 : coordonnees pixels du coin superieur gauche du bouton
// largbouton : nombre de pixels en largeur d'un bouton
// hautbouton : nombre de pixels en hauteur d'un bouton

void VuBoutonCadreActif( XPoint pxy0, int largbouton, int hautbouton );
//Tracer le cadre d'un bouton enfonce du menu avec son eclairage
//en haut a gauche et un ombrage en bas a droite
//a partir des entrees:
// pxy0 : coordonnees pixels du coin superieur gauche du bouton
// largbouton : nombre de pixels en largeur d'un bouton
// hautbouton : nombre de pixels en hauteur d'un bouton

void VuBoutonMenu( char *textebouton, int couleurbouton,
int hauttexte, int decaltexte,
XPoint xy0, int largbouton, int hautbouton );
//Tracer un bouton de menu avec son texte et un eclairage
//en haut a gauche et un ombrage en bas a droite
//a partir des entrees:
// textebouton : caracteres du texte du bouton
// couleurbouton: couleur du fond d'un bouton
// xy0 : coordonnees pixels du coin superieur gauche du bouton
// largbouton : nombre de pixels en largeur d'un bouton
// hautbouton : nombre de pixels en hauteur d'un bouton
// hauttexte : nombre de pixels en hauteur de la fonte des caracteres
// decaltexte : nombre de pixels de decalage du texte par rapport a la
// base et gauche du bouton

void VuBoutonMenuActif( char *textebouton, int couleurbouton,
int hauttexte, int decaltexte,
XPoint xy0, int largbouton, int hautbouton );
//Tracer un bouton de menu avec son texte et un eclairage inverse
//c-a-d en bas a droite et un ombrage en haut a gauche
//Produire un effet de bouton enfonce / VuBoutonMenu
//a partir des entrees:
// textebouton : caracteres du texte du bouton
// couleurbouton: couleur du fond d'un bouton
// xy0 : coordonnees pixels du coin superieur gauche du bouton
// largbouton : nombre de pixels en largeur d'un bouton
// hautbouton : nombre de pixels en hauteur d'un bouton
// hauttexte : nombre de pixels en hauteur de la fonte des caracteres
// decaltexte : nombre de pixels de decalage du texte par rapport a la
// base et gauche du bouton

void VuMenuHorizontal( int nbbouton, char **textebouton,
int largbouton, int couleurbouton,
XPoint xy0,
int & largmenu, int & hautmenu, int & nobouton );
//Tracer un menu horizontal compose de nbbouton et retourner
//le numero du bouton choisi par clic d'un bouton ou frappe
//de l'unique majuscule du texte de l'un des boutons du menu
//a partir des entrees:
// nbbouton : nombre de boutons du menu horizontal
// textebouton : caracteres du texte de chacun des boutons du menu
// textebouton[nbbouton][]
// largbouton : nombre de pixels en largeur d'un bouton
// nbepbordbouton : nombre d'epaisseurs du trait du bord d'un bouton
// hautbouton : nombre de pixels en hauteur d'un bouton
// couleurbouton : couleur du fond d'un bouton
// hauttexte : nombre de pixels en hauteur de la fonte des caracteres
// decaltexte : nombre de pixels de decalage du texte par rapport a la
// base et gauche du bouton
// xy0 : coordonnees pixels du coin superieur gauche du menu
//et fournir les sorties:
// largmenu: nombre de pixels de la largeur totale du menu
// hautmenu: nombre de pixels de la hauteur totale du menu
// nobouton: numero du bouton choisi par l'utilisateur
// =-1 => demande d'abandon de l'entree de la saisie
// >=0 => numero du bouton choisi

void VuMenuVertical( int nbbouton, char **textebouton,
int largbouton, int couleurbouton,
XPoint xy0,
int & largmenu, int & hautmenu, int & nobouton );
//Tracer un menu vertical compose de nbbouton et retourner
//le numero du bouton choisi par clic d'un bouton ou frappe
//de l'unique majuscule du texte de l'un des boutons du menu
//a partir des entrees:
// nbbouton : nombre de boutons du menu horizontal
// textebouton : caracteres du texte de chacun des boutons du menu
// textebouton[nbbouton][]
// largbouton : nombre de pixels en largeur d'un bouton
// hautbouton : nombre de pixels en hauteur d'un bouton
// nbepbordbouton : nombre d'epaisseurs du trait du bord d'un bouton
// couleurbouton : couleur du fond d'un bouton
// hauttexte : nombre de pixels en hauteur de la fonte des caracteres
// decaltexte : nombre de pixels de decalage du texte par rapport a la
// base et gauche du bouton
// xy0 : coordonnees pixels du coin superieur gauche du menu
//et fournir les sorties:
// largmenu: nombre de pixels de la largeur totale du menu
// hautmenu: nombre de pixels de la hauteur totale du menu
// nobouton: numero du bouton choisi par l'utilisateur
// =-1 => demande d'abandon de la saisie
// >=0 => numero du bouton choisi

void VuMenuLateral( int nbbouton, char **textebouton,
int largbouton, int couleurbouton,
XPoint xy0,
int & largmenu, int & hautmenu, int & nobouton );
//Tracer un menu lateral a un menu vertical compose de nbbouton et
//retourner le numero du bouton choisi par clic d'un bouton ou
//frappe de l'unique majuscule du texte de l'un des boutons du menu
//a partir des entrees:
// nbbouton : nombre de boutons du menu horizontal
// textebouton : caracteres du texte de chacun des boutons du menu
// textebouton[nbbouton][]
// largbouton : nombre de pixels en largeur d'un bouton
// hautbouton : nombre de pixels en hauteur d'un bouton
// nbepbordbouton : nombre d'epaisseurs du trait du bord d'un bouton
// couleurbouton : couleur du fond d'un bouton
// hauttexte : nombre de pixels en hauteur de la fonte des caracteres
// decaltexte : nombre de pixels de decalage du texte par rapport a la
// base et gauche du bouton
//et fournir les sorties:
// xy0 : coordonnees pixels du coin superieur gauche du menu
// largmenu : nombre de pixels de la largeur totale du menu
// hautmenu : nombre de pixels de la hauteur totale du menu
// nobouton : numero du bouton choisi par l'utilisateur
// =-1 => demande d'abandon de l'entree d'un bouton
// >=0 => numero du bouton choisi
};

//=========================================================================
// la classe des memoires de pixels de l'Invite
//=========================================================================
class MemoirePxInvite : public MemoirePxMenu
{
public :

void VuInvite( char *texteinvite );
// Tracer le texteinvite comme invite en bas a gauche de l'ecran

void VuLigneClavier( char *LigneClavier );
// Concatener TexteInvite et LigneClavier et tracer en ligne basse du menu

char lire1Caractere();
// Retourner le caractere ASCII saisi au clavier ou
// char(27) si clic du bouton2 de la souris

void lire1LigneTexte( int no1car, char *ChaineCar );
// Saisir interactivement une ligne de caracteres sur le clavier
// a partir du no1car-eme caractere de ChaineCar, terminee par '\0'

void lireZ( int & ncvals, Z & entier );
//Lire une chaine de caracteres representant un entier
//Retourner la valeur de l'entier
//la demande est toujours satisfaite car pas de retour tant que
//la valeur de l' entier est incorrecte sauf @ demandant l'abandon
//et fournir les sorties :
//ncvals : 1 l'entier est initialise
// -1 abandon de la lecture par entree de @ ou Echappement
//entier : la valeur de l' entier lu

void lireR( int & ncvals, R & Reel );
//Lire une chaine de caracteres representant un Reel
//Retourner la valeur du Reel de type R
//la demande est toujours satisfaite car pas de retour tant que
//la valeur du Reel est incorrecte sauf @ demandant l'abandon
//et fournir les sorties :
//ncvals : 1 le Reel est initialise
// -1 abandon de la lecture par entree de @ ou Echappement
//Reel : la valeur du Reel lu

void lireXYZ( int & ncvals, R3 & XYZ );
//Lire une chaine de caracteres representant un point XYZ
//c-a-d 3 reels avec invite pour X puis Y puis Z
//Retourner la valeur du XYZ de type R3
//la demande est toujours satisfaite car pas de retour tant que
//la valeur du XYZ est incorrecte sauf @ demandant l'abandon
//et fournir les sorties :
//ncvals : 1 le XYZ est initialise
// -1 abandon de la lecture par entree de @ ou Echappement
//XYZ : la valeur du XYZ de type R3 lu

void VuSourisXYZ( int & notypeevt, int & nobouton, XPoint & xy1,
R3 & XYZ );
//Retourner le type et les caracteristiques d'un EVENEMENT
//Variante de VuSouris avec retour eventuel des 3 coordonnees
//d'un point de R3 par frappe au clavier de X puis Y puis Z
//les sorties:
// notypeevt : = 0 Si ABANDON demande par clic du bouton 2 de la souris
// ou par frappe de la touche Echappement ou @
// = 1 Si CLIC ENFONCE et RELACHE D'UN BOUTON DE LA SOURIS => xy1
// =-1 Si CLIC SEULEMENT ENFONCE D'UN BOUTON DE LA SOURIS => xy1
// =-2 Si DEPLACEMENT du POINTEUR de la SOURIS => xy1
// = 2 Si FRAPPE des 3 coordonnees
// nobouton : seulement actif si notypeevt est non nul
// si notypeevt=1 nobouton=numero du bouton
// si notypeevt=2 nobouton=numero du caractere dans la table ASCII
// xy1 : seulement actif si notypeevt=+-1
// coordonnees PIXELS du point clique par rapport au coin
// superieur gauche de la fenetre
// XYZ : les 3 coordonnees du point frappees au clavier si notypeevt=2

void VuSourisTexte( int & notypeevt, int & nobouton, XPoint & xy1,
char texte[] );
//Retourner le type et les caracteristiques d'un EVENEMENT
//Variante de VuSouris avec retour eventuel d'un texte ponctue par \r
//les sorties:
// notypeevt : = 0 Si ABANDON demande par clic du bouton 2 de la souris
// ou par frappe de la touche Echappement ou @
// = 1 Si CLIC ENFONCE et RELACHE D'UN BOUTON DE LA SOURIS => xy1
// =-1 Si CLIC SEULEMENT ENFONCE D'UN BOUTON DE LA SOURIS => xy1
// =-2 Si DEPLACEMENT du POINTEUR de la SOURIS => xy1
// = 2 Si FRAPPE d'un texte fini par \r
// nobouton : seulement actif si notypeevt est non nul
// si notypeevt=1 nobouton=numero du bouton
// si notypeevt=2 nobouton=numero du caractere dans la table ASCII
// xy1 : seulement actif si notypeevt=+-1
// coordonnees pixels du point clique par rapport au coin
// superieur gauche de la fenetre
// texte : chaine de caracteres saisie au clavier et finie par \r
// initialisee seulement si notypeevt=2

}; //Fin de la classe MemoirePxInvite

//=========================================================================
// la classe des memoires de pixels de l'accrochage
//=========================================================================
class MemoirePxAccroche : public MemoirePx
{
public :
void VuCreerPixmap(unsigned int largpx=15, unsigned int hautpx=15);
//Initialiser une MemoirePx d'accrochage contenant le carre de sa visualisation
};

//=========================================================================
// Les traces en PostScript
//=========================================================================
void VuPostscript( int lasops );
//IMPOSER la nouvelle option de sortie du trace du maillage en POSTSCRIPT

void VuInitierps( int modeps );
//INITIALISER le POSTSCRIPT selon le mode modeps

void VuSauverps( char nomfichier[], int & erreur );
//CONCATENER LES DONNEES DE DESSIN PS CONTENUES DANS TEMPORAIRE.EPS
//AVEC LES PROCEDURES PS dans nomfichier.eps

void VuImprimerps( char nomfichier[] );
//IMPRIMER le nomfichier.eps du trace PostScript

//=========================================================================
// Les diverses fonctions internes au logiciel Vu
//=========================================================================
void VuCouleursImposees( int & n1coel, int & ndcoel,
R red[], R green[], R blue[] );
//Definir les couleurs imposees dans toute palette

void VuColormapToRGB( Colormap color_map,
R r[], R g[], R b[], int nbcolor);
//Transfere les nbcolor couleurs de la palette color_map dans les
//tableaux r, v, b dans la classe PseudoColor

void VuRGBtoColormap( int visual_class, int nbcells,
R red[], R green[], R blue[],
unsigned long norgb[], Colormap color_map );
//Imposer dans la palette des couleurs color_map modifiable
//les couleurs red green blue

void VuChargerLaFonte( int & n, char *namefonts, int & largpx, int & hautpx );
//Charger la fonte n de nom namefonts parmi les fontes disponibles

void VuVoir(void);
//Voir les traces encore dans la memoire tampon

void VuPause(void);
//Faire une pause jusqu'a l'entree d'un evenement:
//entree d'un caractere au clavier ou clic relache d'un bouton de la souris

//=========================================================================
// Des FONCTIONS UTILITAIRES
// ========================================================================
int nudcnb( char *texte );
//Retourner le nombre de caracteres avant le caractere '\0' dans texte

char *strstrtab( char **tabcar, int nbvtab, char *mot );
//Retourner le pointeur sur le premier caractere de mot retrouve dans tabcar
//tableau de nbvtab chaines de caracteres et NULL si non retrouve

void itoa( int entier, int & nbcar, char * texte );
//Retourner le nombre et les caracteres du texte de l'entier

void rtoa( R vreel, int nbchif10, int & nbcar, char * texte );
//Retourner le nombre et les caracteres du texte de vR
//avec nbchif10 nombre de chiffres de la partie decimale
//Forme normalisee du texte: -0.partie10Eexposant10

int nbchiffre1R( R r );
//Calculer l'exposant de 10 d'un nombre R r tel que
// r = rr * 10**nbchiffre1R avec 1 <= rr < 10

void VuGraduation( R rmin, R rmax,
R &premier, R &pas, int &nbpas, int &nbchif );
//Calculer la graduation a tracer entre rmin et rmax
//pour obtenir une lecture aisee (peu de decimales tracees)
//avec a peu pres 10 nombres reels a tracer
//a partir des entrees:
// rmin, rmax: mininmum et maximum de la graduation
//et fournir les sorties:
// premier: premier R a tracer
// pas : entre 2 nombres a tracer
// nbpas : nombre de pas
// nbchif : nombre de decimales a tracer

R Secondes1970();
//Retourner le nombre de secondes depuis le 1/1/1970 minuit
//les micro-secondes factices ont pour but de dissocier 2 appels
//memes tres rapproches et notamment dans la meme seconde

R Tempscpu( R *tclock );
//Retourner le temps CPU utilise

void NomOrdinateurHote( char *Nom, int *nbcar);
//Retourne le nom de l'ordinateur hote
//et nbcar lenombre de caracteres de ce nom

void LaDate( int *an, int *mois, int *jour );
//Retourner la date du jour en an mois jour

void HeureMinuteSeconde( int *heure, int *minute, int *seconde, int *millisec );
//Retourner l'heure en heure minute seconde et millisecondes

void ValVarEnv( char *nom, int *lval_admis,
char *val, int *lval_trouve );
//Retourner la valeur de la variable d'environnement nom
//a partir des entrees :
// nom : nom de la variable d'environnement termine par '\0'
// lval_admis : nombre maximal de caracteres admis pour sa valeur
//et fournir les sorties :
// val : la chaine de caracteres valeur de la variable d'environnement
// lval_trouve : < 0 si le nom de la variable n'est pas trouvee
// > strlen(nom) si la valeur de la variable a ete tronquee

void ProduitVectoriel( R3 v1, R3 v2, R3 & v3 );
//Calculer le vecteur v3 = v1 produit vectoriel v2

bool xyzide( R3 xyz1, R3 xyz2 );
//Identifier ou non 2 points definis par 3 coordonnees
// true si les 2 points sont juges identiques, false sinon

//=========================================================================
// La courbe P3-Hermite
// ========================================================================
R ValeurP3H( R u, R f0, R f1, R tg0, R tg1 );
//Calculer la valeur d'interpolation du polynome P3 HERMITE
//d'une fonction valant f0 en 0, f1 en 1 et
//de derivee tg0 en 0 et -derivee tg1 en 1
//c'est a dire
// VALP3H(0) = F0 = F(0)
// VALP3H(1) = F1 = F(1)
// d VALP3H / du (0)(1-0) = T0 = DF(0) (1-0)
// d VALP3H / du (1)(0-1) = T1 = DF(1) (0-1) = -DF(1)
// ATTENTION: d VALP3H / du (1) = -T1 ...!

//=========================================================================
// Le triangle HCT reduit (Hsieh, Clough, Tocher)
// ========================================================================
void peci33( R x[9] );
//Permuter circulairement les 3 sommets et 6 tangentes croisees
//du triangle hct lorsque le sommet 2 devient le sommet 1

void pecm33( R x[9] );
//Permuter circulairement les 3 sommets et 6 tangentes croisees
//du triangle hct lorsque le sommet 3 devient le sommet 1;

void vfbhct( R u, R v, R fb[9] );
//Calculer la valeur au point [u,v] des 9 fonctions de base de l'ef
//du triangle rectangle unite Hsieh-Clough-Tocher reduit
//[reduit => derivee normale p1 sur les 3 cotes]
//cf article de m. bernardou et k.hassan [1981]
// ^
// | v
// |
// s3=[0,1]
// x
// | \ \
// | \ ^
// - \ \
// | \ \
// | \ \
// | e2 \ \
// | \ e1 \
// ^ / \ ^
// | / \ \
// | / e3 \ \
// x----->------------<-----x ----> u
// s1=[0,0] s2=[1,0]
//
//a partir des entrees:
// u,v: valeurs des 2 parametres sur le triangle rectangle unite
// [ 0=<u,v<=1 et v<=1-u ]
//et fournir les sorties:
// fb: la valeur au point [u,v] des 9 fonctions de base
// du hct reduit rangees selon k
// k=1 f[s1], k=2 f[s2], k=3 f[s3],
// k=4 df[s1][s2-s1], k=5 df[s1][s3-s1],
// k=6 df[s2][s3-s2], k=7 df[s2][s1-s2],
// k=8 df[s3][s1-s3], k=9 df[s3][s2-s3]

void xyhct( R u, R v, R x[9], R y[9],
R & xhct, R & yhct );
//Calculer la valeur de l'interpolation au point [u,v]
//du triangle rectangle unite Hsieh-Clough-Tocher reduit
//[reduit => derivee normale p1 sur les 3 cotes]
//et pour les 9 degres de liberte stockes dans x et y
//a partir des entrees :
// u,v : valeurs des 2 parametres sur le triangle rectangle unite
// [ 0=<u,v<=1 et v<=1-u ]
// x, y : valeurs des 9 degres de liberte rangees selon k pour x et y
// k=1 f[s1], k=2 f[s2], k=3 f[s3],
// k=4 df[s1][s2-s1], k=5 df[s1][s3-s1],
// k=6 df[s2][s3-s2], k=7 df[s2][s1-s2],
// k=8 df[s3][s1-s3], k=9 df[s3][s2-s3]
//et fournir les sorties:
// xhct : abscisse hct au point [u,v] du triangle rectangle unite
// yhct : ordonnee hct au point [u,v] du triangle rectangle unite

void xyzhct( R u, R v, R x[9], R y[9], R z[9],
R & xhct, R & yhct, R & zhct );
//Calculer la valeur de l'interpolation au point [u,v]
//du triangle rectangle unite Hsieh-Clough-Tocher reduit
//[reduit => derivee normale p1 sur les 3 cotes]
//et pour les 9 degres de liberte stockes dans x y z
//a partir des entrees:
// u, v : valeurs des 2 parametres sur le triangle rectangle unite
// [ 0=<u,v<=1 et v<=1-u ]
// x, y, z: valeurs des 9 degres de liberte rangees selon k pour x, y, z
// k=1 f[s1], k=2 f[s2], k=3 f[s3],
// k=4 df[s1][s2-s1], k=5 df[s1][s3-s1],
// k=6 df[s2][s3-s2], k=7 df[s2][s1-s2],
// k=8 df[s3][s1-s3], k=9 df[s3][s2-s3]
//et fournir les sorties:
// xhct : abscisse hct au point [u,v] du triangle rectangle unite
// yhct : ordonnee hct au point [u,v] du triangle rectangle unite
// zhct : cote hct au point [u,v] du triangle rectangle unite

void dduhct( R u, R v, R ddufb[9] );
//Calculer la valeur au point [u,v] de la derivee par rapport
//au parametre u des 9 fontions de base de l'ef
//du triangle rectangle unite hsieh-Clough-Tocher reduit
//[reduit => derivee normale p1 sur les 3 cotes]
//a partir des entrees :
// u,v : valeurs des 2 parametres sur le triangle rectangle unite
// [ 0=<u,v<=1 et v<=1-u ]
//et fournir les sorties:
// ddufb : la derivee par rapport a u des 9 fonctions de base
// du hct reduit rangees selon k
// k=1 f[s1], k=2 f[s2], k=3 f[s3],
// k=4 df[s1][s2-s1], k=5 df[s1][s3-s1],
// k=6 df[s2][s3-s2], k=7 df[s2][s1-s2],
// k=8 df[s3][s1-s3], k=9 df[s3][s2-s3]

void ddvhct( R u, R v, R ddvfb[9] );
//Calculer la valeur au point [u,v] des 9 fontions de base de l'ef
//du triangle rectangle unite Hsieh-Clough-Tocher reduit
//[reduit => derivee normale p1 sur les 3 cotes]
//a partir des entrees :
// u,v : valeurs des 2 parametres sur le triangle rectangle unite
// [ 0=<u,v<=1 et v<=1-u ]
//et fournir les sorties :
// ddvfb : la derivee par rapport a v des 9 fonctions de base
// du hct reduit rangees selon k
// k=1 f[s1], k=2 f[s2], k=3 f[s3],
// k=4 df[s1][s2-s1], k=5 df[s1][s3-s1],
// k=6 df[s2][s3-s2], k=7 df[s2][s1-s2],
// k=8 df[s3][s1-s3], k=9 df[s3][s2-s3]

void tguhct( R u, R v, R x[9], R y[9], R z[9],
R & tgxhct, R & tgyhct, R & tgzhct );
//Calculer la valeur des 3 composantes de la derivee en u
//de l'interpolation au point [u,v]
//du triangle rectangle unite Hsieh-Clough-Tocher reduit
//[reduit => derivee normale p1 sur les 3 cotes]
//et pour les 9 degres de liberte stockes dans x y z
//a partir des entrees:
// u, v : valeurs des 2 parametres sur le triangle rectangle unite
// [ 0=<u,v<=1 et v<=1-u ]
// x, y, z: valeurs des 9 degres de liberte rangees selon k pour x, y, z
// k=1 f[s1], k=2 f[s2], k=3 f[s3],
// k=4 df[s1][s2-s1], k=5 df[s1][s3-s1],
// k=6 df[s2][s3-s2], k=7 df[s2][s1-s2],
// k=8 df[s3][s1-s3], k=9 df[s3][s2-s3]
//et fournir les sorties:
// tgxhct : abscisse au point [u,v] de la tg
// tgyhct : ordonnee au point [u,v] de la tg
// tgzhct : cote au point [u,v] de la tg

void tgvhct( R u, R v, R x[9], R y[9], R z[9],
R & tgxhct, R & tgyhct, R & tgzhct );
//Calculer la valeur des 3 composantes de la derivee en v
//de l'interpolation au point [u,v]
//du triangle rectangle unite Hsieh-Clough-Tocher reduit
//[reduit => derivee normale p1 sur les 3 cotes]
//et pour les 9 degres de liberte stockes dans x y z
//a partir des entrees:
// u, v : valeurs des 2 parametres sur le triangle rectangle unite
// [ 0=<u,v<=1 et v<=1-u ]
// x, y, z: valeurs des 9 degres de liberte rangees selon k pour x, y, z
// k=1 f[s1], k=2 f[s2], k=3 f[s3],
// k=4 df[s1][s2-s1], k=5 df[s1][s3-s1],
// k=6 df[s2][s3-s2], k=7 df[s2][s1-s2],
// k=8 df[s3][s1-s3], k=9 df[s3][s2-s3]
//et fournir les sorties:
// tgxhct : abscisse au point [u,v] de la tg
// tgyhct : ordonnee au point [u,v] de la tg
// tgzhct : cote au point [u,v] de la tg

void norhct( R u, R v, R x[9], R y[9], R z[9],
R3 & normale, int & ierr );
//Calculer la valeur au point [u,v] des 3 composantes de la normale
//orthogonale aux 2 tangentes en u et v de l'interpolation
//du triangle rectangle unite Hsieh-Clough-Tocher reduit
//[reduit => derivee normale p1 sur les 3 cotes]
//et pour les 9 degres de liberte stockes dans x y z
//a partir des entrees:
// u, v : valeurs des 2 parametres sur le triangle rectangle unite
// [ 0=<u,v<=1 et v<=1-u ]
// x, y, z: valeurs des 9 degres de liberte rangees selon k pour x, y, z
// k=1 f[s1], k=2 f[s2], k=3 f[s3],
// k=4 df[s1][s2-s1], k=5 df[s1][s3-s1],
// k=6 df[s2][s3-s2], k=7 df[s2][s1-s2],
// k=8 df[s3][s1-s3], k=9 df[s3][s2-s3]
//et fournir les sorties:
// normale: 3 composantes de la normale unitaire au point [u,v]
// ierr : 1 si les 2 tangentes sont colinaires
// 0 si pas d'erreur

//=========================================================================
// Le quadrangle DVS reduit (de Veubeke, Sander)
// ========================================================================
void pecm4r( R x[4] );
//Permuter circulairement les valeurs 0 1 2 3 => 1 2 3 0

void peci4r( R x[4] );
//Permuter circulairement les valeurs 0 1 2 3 => 3 0 1 2

void pe4inv( R x[4] );
//Inverser l'ordre 1 2 3 4 en 1 4 3 2 des 4 valeurs du tableau

void pec24r( R x[4] );
//Permuter circulairement les valeurs 0<->2 1<->3

void peci44( R x[12] );
//Le sommet 1 du quadrangle dvs devient le sommet 0
//et dans le sens direct les permutations des sommets
//et tangentes croisees suivent

void pec244( R x[12] );
//Le sommet 2 du quadrangle dvs devient le sommet 0
//et dans le sens direct les permutations des sommets
//et tangentes croisees suivent

void pe44in( R x[12] );
//Inverser l'ordre 1 2 3 4 en 1 4 3 2 des 4 sommets et tangentes
//du quadrangle DVS

void pecm44( R x[12] );
//Le sommet 3 du quadrangle dvs devient le sommet 0
//et dans le sens direct les permutations des sommets
//et tangentes croisees suivent

void vfbdvs( R u, R v, R fbdvsr[12] );
//Calculer la valeur au point [u,v] du carre unite des
//12 fonctions de base de l'interpolation c1 de
//Fraeijs de Veubeke Sander reduite
//[derivee normale p1 sur les 4 cotes]
// ^ v
// |
// |
// |
// s4=[0,1] s3=[1,1]
// x----->------------<---x
// | \ p1+p2+p3 / |
// | \ / |
// - \ / -
// | \ / |
// | \ / |
// | p1+p3 / \ p1+p2 |
// | / \ |
// ^ / \ ^
// | / \ |
// | / p1 \|
// x----->----------<-----x ------------> u
// s1=[0,0] s2=[1,0]
//
//a partir des entrees:
// u,v : valeurs des 2 parametres sur le carre unite [ 0<u,v<1 ]
//et fournir les sorties:
// fbdvsr : valeur au point [u,v] des 12 fonctions de base selon l'ordre k
// k=1 f[s1], k=2 f[s2], k=3 f[s3], k=4 f[s4],
// k=5 df[s1][s2-s1], k=6 df[s1][s4-s1], k=7 df[s2][s3-s2], k=8 df[s2][s1-s2]
// k=9 df[s3][s4-s3], k=10 df[s3][s2-s3], k=11 df[s4][s1-s4], k=12 df[s4][s3-s4]

void xydvs( R u, R v, R x[12], R y[12],
R & xdvs, R & ydvs );
//Calculer la valeur de l'interpolation au point [u,v]
//du carre unite de Fraeijs de Veubeke Sander reduit
//a partir des entrees:
// u,v : valeurs des 2 parametres sur le triangle rectangle unite
// [ 0=<u,v<=1 et v<=1-u ]
// x, y: valeurs des 12 degres de liberte rangees selon k pour x y
// k=1 f[s1], k=2 f[s2], k=3 f[s3], k=4 f[s4],
// k=5 df[s1][s2-s1], k=6 df[s1][s4-s1], k=7 df[s2][s3-s2], k=8 df[s2][s1-s2]
// k=9 df[s3][s4-s3], k=10 df[s3][s2-s3], k=11 df[s4][s1-s4], k=12 df[s4][s3-s4]
//et fournir les sorties:
// xdvs : abscisse dvs au point [u,v] du carre unite
// ydvs : ordonnee dvs au point [u,v] du carre unite

void xyzdvs( R u, R v, R x[12], R y[12], R z[12],
R & xdvs, R & ydvs, R & zdvs );
//Calculer la valeur de l'interpolation au point [u,v]
//du carre unite de Fraeijs de Veubeke Sander reduit
//a partir des entrees:
// u,v : valeurs des 2 parametres sur le triangle rectangle unite
// [ 0=<u,v<=1 et v<=1-u ]
// x, y, z: valeurs des 12 degres de liberte rangees selon k pour x y z
// k=1 f[s1], k=2 f[s2], k=3 f[s3], k=4 f[s4],
// k=5 df[s1][s2-s1], k=6 df[s1][s4-s1], k=7 df[s2][s3-s2], k=8 df[s2][s1-s2]
// k=9 df[s3][s4-s3], k=10 df[s3][s2-s3], k=11 df[s4][s1-s4], k=12 df[s4][s3-s4]
//et fournir les sorties:
// xdvs : abscisse dvs au point [u,v] du carre unite
// ydvs : ordonnee dvs au point [u,v] du carre unite
// zdvs : cote dvs au point [u,v] du carre unite

void ddudvs( R u, R v, R dudvsr[12] );
//Calculer la valeur au point [u,v] du carre unite de la derivee
//par rapport au parametre u des 12 fonctions de base de
//l'interpolation c1 de Fraeijs de veubeke Sander reduite
//a partir des entrees:
// u,v : valeurs des 2 parametres sur le carre unite [ 0<u,v<1 ]
//
//et fournir les sorties:
// dudvsr : valeur au point [u,v] des 12 fonctions de base selon l'ordre k
// k=1 f[s1], k=2 f[s2], k=3 f[s3], k=4 f[s4],
// k=5 df[s1][s2-s1], k=6 df[s1][s4-s1], k=7 df[s2][s3-s2], k=8 df[s2][s1-s2]
// k=9 df[s3][s4-s3], k=10 df[s3][s2-s3], k=11 df[s4][s1-s4], k=12 df[s4][s3-s4]

void ddvdvs( R u, R v, R dvdvsr[12] );
//Calculer la valeur au point [u,v] du carre unite de la derivee
//par rapport au parametre v des 12 fonctions de base de
//l'interpolation c1 de Fraeijs de Veubeke Sander reduite
//a partir des entrees:
// u,v : valeurs des 2 parametres sur le carre unite [ 0<u,v<1 ]
//et fournir les sorties:
// dvdvsr : valeur au point [u,v] des 12 fonctions de base selon l'ordre k
// k=1 f[s1], k=2 f[s2], k=3 f[s3], k=4 f[s4],
// k=5 df[s1][s2-s1], k=6 df[s1][s4-s1], k=7 df[s2][s3-s2], k=8 df[s2][s1-s2]
// k=9 df[s3][s4-s3], k=10 df[s3][s2-s3], k=11 df[s4][s1-s4], k=12 df[s4][s3-s4]

void tgudvs( R u, R v, R x[12], R y[12], R z[12],
R & xtgdvs, R & ytgdvs, R & ztgdvs );
//Calculer la valeur de la derivee en u de l'interpolation
//au point [u,v] du carre unite de Fraeijs de Veubeke Sander reduit
//a partir des entrees:
// u,v : valeurs des 2 parametres sur le triangle rectangle unite
// [ 0=<u,v<=1 et v<=1-u ]
// x, y, z: valeurs des 12 degres de liberte rangees selon k pour x y z
// k=1 f[s1], k=2 f[s2], k=3 f[s3], k=4 f[s4],
// k=5 df[s1][s2-s1], k=6 df[s1][s4-s1], k=7 df[s2][s3-s2], k=8 df[s2][s1-s2]
// k=9 df[s3][s4-s3], k=10 df[s3][s2-s3], k=11 df[s4][s1-s4], k=12 df[s4][s3-s4]
//et fournir les sorties:
// xtgdvs : abscisse de la tg selon u au point [u,v] du carre unite
// ytgdvs : ordonnee de la tg selon u au point [u,v] du carre unite
// ztgdvs : cote de la tg selon u au point [u,v] du carre unite

void tgvdvs( R u, R v, R x[12], R y[12], R z[12],
R & xtgdvs, R & ytgdvs, R & ztgdvs );
//Calculer la valeur de la derivee en v de l'interpolation
//au point [u,v] du carre unite de Fraeijs de Veubeke Sander reduit
//a partir des entrees:
// u,v : valeurs des 2 parametres sur le triangle rectangle unite
// [ 0=<u,v<=1 et v<=1-u ]
// x, y, z: valeurs des 12 degres de liberte rangees selon k pour x y z
// k=1 f[s1], k=2 f[s2], k=3 f[s3], k=4 f[s4],
// k=5 df[s1][s2-s1], k=6 df[s1][s4-s1], k=7 df[s2][s3-s2], k=8 df[s2][s1-s2]
// k=9 df[s3][s4-s3], k=10 df[s3][s2-s3], k=11 df[s4][s1-s4], k=12 df[s4][s3-s4]
//et fournir les sorties:
// xtgdvs : abscisse de la tg selon v au point [u,v] du carre unite
// ytgdvs : ordonnee de la tg selon v au point [u,v] du carre unite
// ztgdvs : cote de la tg selon v au point [u,v] du carre unite

void nordvs( R u, R v, R x[12], R y[12], R z[12],
R3 & normale, int ierr );
//Calculer le vecteur normal unitaire au point [u,v] du carre unite
//de l'interpolation c1 de Fraeijs de Veubeke Sander reduite
//a partir des entrees:
// u,v : valeurs des 2 parametres sur le carre unite [ 0<u,v<1 ]
// x, y, z: valeurs des 12 degres de liberte rangees selon k pour x y z
// k=1 f[s1], k=2 f[s2], k=3 f[s3], k=4 f[s4],
// k=5 df[s1][s2-s1], k=6 df[s1][s4-s1], k=7 df[s2][s3-s2], k=8 df[s2][s1-s2]
// k=9 df[s3][s4-s3], k=10 df[s3][s2-s3], k=11 df[s4][s1-s4], k=12 df[s4][s3-s4]
//et fournir les sorties:
// normale: 3 composantes de la normale unitaire au point [u,v]
// ierr : 1 si les 2 tangentes sont colinaires
// 0 si pas d'erreur

int IntersectionDroiteHexaedre( R3 PtMin, R3 PtMax, R3 & pt0, R3 & pt1 );
//Retourner 0 si pas d'interction entre la droite pt0pt1 et hexaedre PtMin-PtMax
// 1 et les coordonnees dans pt0 pt1 des points d'intersection de la
// droite avec l'hexaedre PtMin-PtMax

int Point3Axe3( R3 p1, R3 p2, R3 p3, R3 axe[3] );
//A partir de 3 points former les axes orthonormes tels que
// axe( . , 1 ) = p1p2 / norme( p1p2 )
// axe( . , 3 ) = axe( . , 1 ) produit vectoriel p1p3 / norme(p1p3)
// axe( . , 2 ) = axe( . , 3 ) produit vectoriel axe( . , 1 )
//Retourner 1 si les 3 points sont alignes ou confondus, 0 sinon
// axe[i][j]=j-eme coordonnee du i-eme axe orthonorme

int NormeA1( R3 & v );
//Rendre la norme du vecteur egale a 1 sauf si le vecteur est nul
//Retourner 1 si le vecteur est normalise a 1
// 0 si le vecteur est nul

void ScgScu( R3 SCU[], R3 xyzscg, R3 & xyzscu );
//Calculer les 3 coordonnees du point dans le SCU
//a partir des 3 coordonnees du point dans le SCG
//a partir des entrees:
// SCU : Origine, 3 vecteurs orthonormes de coordonnees dans le SCG
// xyzscg : les 3 coordonnees du point dans le repere SCG
//et fournir les sorties :
// xyzscu : les 3 coordonnees du point dans le repere SCU

void ScuScg( R3 SCU[], R3 xyzscu, R3 & xyzscg );
//Calculer les 3 coordonnees du point dans le SCG
//a partir des 3 coordonnees du point dans le SCU
//a partir des entrees:
// SCU : Origine, 3 vecteurs orthonormes de coordonnees dans le SCG
// xyzscu : les 3 coordonnees du point dans le repere SCU
//et fournir les sorties :
// xyzscg : les 3 coordonnees du point dans le repere SCG

void VecteurScgScu( R3 SCU[], R3 vecteurscg, R3 & vecteurscu );
//Calculer les 3 coordonnees du vecteur dans le SCU
//a partir des 3 coordonnees du vecteur dans le SCG
//Attention: Version sans translation des origines
//a partir des entrees:
// SCU : Origine, 3 vecteurs orthonormes de coordonnees dans le SCG
// vecteurscg : les 3 coordonnees du vecteur dans le repere SCG
//et fournir les sorties :
// vecteurecteurscu : les 3 coordonnees du vecteur dans le repere SCU

void VecteurScuScg( R3 SCU[], R3 vecteurscu, R3 & vecteurscg );
//Calculer les 3 coordonnees du vecteur dans le SCG
//a partir des 3 coordonnees du vecteur dans le SCU
//Attention: Version sans translation des origines
//a partir des entrees:
// SCU : Origine, 3 vecteurs orthonormes de coordonnees dans le SCG
// vecteurscu : les 3 coordonnees du vecteur dans le repere SCU
//et fournir les sorties :
// vecteurscg : les 3 coordonnees du vecteur dans le repere SCG

#endif

void VecteurScgScu( R3 SCU[], R3 vecteurscg, R3 & vecteurscu );
//Calculer les 3 coordonnees du vecteur dans le SCU
//a partir des 3 coordonnees du vecteur dans le SCG
//Attention: Version sans translation des origines
//a partir des entrees:
// SCU : Origine, 3 vecteurs orthonormes de coordonnees dans le SCG
// vecteurscg : les 3 coordonnees du vecteur dans le repere SCG
//et fournir les sorties :
// vecteurecteurscu : les 3 coordonnees du vecteur dans le repere SCU

void VecteurScuScg( R3 SCU[], R3 vecteurscu, R3 & vecteurscg );
//Calculer les 3 coordonnees du vecteur dans le SCG
//a partir des 3 coordonnees du vecteur dans le SCU
//Attention: Version sans translation des origines
//a partir des entrees:
// SCU : Origine, 3 vecteurs orthonormes de coordonnees dans le SCG
// vecteurscu : les 3 coordonnees du vecteur dans le repere SCU
//et fournir les sorties :
// vecteurscg : les 3 coordonnees du vecteur dans le repere SCG

#endif