REPOS_ERICCA/mesh/Fenetre.cpp

//---------------------------------------------------------------------------
#include <vcl\vcl.h>
#include <process.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <dir.h>
#pragma hdrstop

#include "Fenetre.h"
#include "Edition.h"
#include "Igsopt.h"
#include "Rigsopt.h"
#include "diaopt.h"
#include "s_valeur.h"
#include "configure.h"
#include "aproposde.h"
#include "cface.h"
#include "tool.h"
#include "session.h"
#include "infopiece.h"
#include "debug.h"

extern void trirea(float *a,int *la,int *ir);

//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TFenp *Fenp;
//---------------------------------------------------------------------------
__fastcall TFenp::TFenp(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Fermer1Click(TObject *Sender)
{
Fenp->Close();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Ouvre(char *mess)
{
char messtmp[255],messf[255];
char *p,arg1[255],arg2[255],arg3[255],arg4[255];
FILE *out;
TObject *Sender=NULL;

strcpy(Fichier,mess);
strcpy(messtmp,"Mesh2000 ");
strcat(messtmp,mess);
Fenp->Caption=messtmp;
if (existetool==1)
        {
    Toolbar->Caption="Outil pour "+Fenp->Caption;
    Toolbar->Invalidate();
    }
Mailleur1->Enabled=True;
Remailleur1->Enabled=True;
Vue1->Enabled=True;
Geometrie1->Checked=false;
Maillage1D1->Checked=false;
Maillage2D1->Checked=false;
Maillage3D1->Checked=false;
Maillage3D2->Checked=false;
Remaillage2D1->Checked=false;
Remaillage3D1->Checked=false;
Aucun1->Checked=true;
Acismesh1->Enabled=True;
Acismesh2->Enabled=True;
Paramesh1->Enabled=True;
p=strstr(Fichier,".");
strcpy(messf,Fichier);
messf[strlen(messf)-4]=0;
strcat(messf,".geo");
out=fopen(messf,"rt");
if (strcmp(p,".igs")==0)
        {
        Acismesh1->Enabled=False;
        Acismesh2->Enabled=False;
    }
if (strcmp(p,".sat")==0)
        {
        if (out==NULL)
                {
        sprintf(arg1,"%s\\acismesh.exe",home);
        strcpy(arg2,"-fich");
        sprintf(arg3,"%s",Fichier);
                strcpy(arg4,"-geo");
        spawnl(P_WAIT,arg1,arg1,arg2,arg3,arg4,NULL);
        }
    Geometrie1->Checked=true;
    Aucun1->Checked=false;
    Geometrie1Click(Sender) ;
        }
if (out!=NULL) fclose(out);
passe_norme=0;
}
        //---------------------------------------------------------------------------
void __fastcall TFenp::wininit()
        {
    char mess[255];
        int i;
        FILE *out;

        sprintf(mess,"%s\\mesh.ini",home);
    out=fopen(mess,"wt");
    fprintf(out,"[Apparence]\n");
    fprintf(out,"%d %d %d %d\n",Fenp->Top,Fenp->Left,Fenp->Height,Fenp->Width);
    if (existetool==1)
        {
        Fenp->toolx=Toolbar->Left;
                Fenp->tooly=Toolbar->Top;
                }
    fprintf(out,"%d %d %d %d\n\n",existetool,toolx,tooly,horizon);
    fprintf(out,"[Directory]\n");
    fprintf(out,"%s\n",dir_defaut);
        fprintf(out,"\n");
        fprintf(out,"[History]\n");
        fprintf(out,"%d\n",nb_fichier);
    for (i=0;i<nb_fichier;i++)
        fprintf(out,"%s\n",ancien_fichier[i]);
    fprintf(out,"\n");
    fprintf(out,"[Color]\n");
    for (i=0;i<12;i++)
                fprintf(out,"%X\n",Cshade[i]);
    fprintf(out,"%d\n",uni);
        fclose(out);
    }
    //---------------------------------------------------------------------------
void __fastcall TFenp::Ouvrir1Click(TObject *Sender)
{
char mess[255],*p;
int i;
TMenuItem *active;

OpenDialog1->InitialDir=dir_defaut;
if (OpenDialog1->Execute()==true)
        {
        strcpy(mess,OpenDialog1->FileName.c_str());
    Ouvre(mess);
        nb_fichier++;
    if (nb_fichier>4) nb_fichier=4;
    for (i=nb_fichier-1;i>=0;i--)
                strcpy(ancien_fichier[i+1],ancien_fichier[i]);
    strcpy(ancien_fichier[0],Fichier);
    strcpy(dir_defaut,Fichier);
    p=strrchr(dir_defaut,'\\');
    dir_defaut[p-dir_defaut]=0;
    wininit();
    for (i=0;i<nb_fichier;i++)
        {
        if (i==0) active=ancien1;
                if (i==1) active=ancien2;
                if (i==2) active=ancien3;
                if (i==3) active=ancien4;
        active->Visible=true;
        active->Caption=ancien_fichier[i];
        }
    if (i>0) N5->Visible=true;
    Invalidate();
        }
}

//---------------------------------------------------------------------------
void __fastcall TFenp::Igsmesh1Click(TObject *Sender)
{
char mess[255];
char arg1[255];
char arg2[255];
char arg3[255];
char arg4[255];
char arg5[255];
char arg6[255];
char arg7[255];
char arg8[255];
float dens;
int opt=5;


Igsoption->Edit2->Text="5";
Igsoption->GroupBox1->Caption=Fichier;
Igsoption->Label3->Enabled=false;
Igsoption->Edit3->Enabled=false;
Igsoption->RadioButton1->Enabled=false;
Igsoption->RadioButton2->Enabled=false;
Igsoption->ShowModal();
if (Igsoption->ok==1)
        {
    dens=0.;
    strcpy(mess,Igsoption->Edit1->Text.c_str());
    sscanf(mess,"%f",&dens);
        strcpy(mess,Igsoption->Edit2->Text.c_str());
    sscanf(mess,"%d",&opt);
    if (Igsoption->CheckBox1->Checked==true) strcpy(arg8,"-analyse"); else strcpy(arg6,"");
    sprintf(arg1,"%s\\igsmesh.exe",home);
    strcpy(arg2,"-fich");
    sprintf(arg3,"%s",Fichier);
    strcpy(arg4,"-dens");
    sprintf(arg5,"%f",dens);
        strcpy(arg6,"-opt");
    sprintf(arg7,"%d",opt);
        if (dens>0.) spawnl(P_NOWAIT,arg1,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,NULL);
    else MessageBox(Handle,"Mauvaise valeur de densite","Erreur",0);
        }
}
//---------------------------------------------------------------------------
void __fastcall TFenp::FormCreate(TObject *Sender)
{
FILE *out;
int i,drive;
int top,height,left,width;
char mess[255],nom[255];
TMenuItem *active;

homo=0.8;
loin=1.;
passe_norme=0;
tete=NULL;
Mailleur1->Enabled=False;
Vue1->Enabled=False;
Acismesh1->Enabled=False;
Remailleur1->Enabled=False;
Acismesh2->Enabled=False;
Paramesh1->Enabled=False;
Face1->Enabled=False;
Activerlerendu3D1->Enabled=False;
Canvas->Pen->Color=clWhite;
rot[0][0]=1.;rot[0][1]=0.;rot[0][2]=0.;
rot[1][0]=0.;rot[1][1]=1.;rot[1][2]=0.;
rot[2][0]=0.;rot[2][1]=0.;rot[2][2]=1.;
batch=false;
fc=0;
uni=0;
zoomwin=0;
toolx=0;tooly=394;
horizon=1;
numface=(-1);
numero_noeud=(-1);
numero_maille=(-1);
drive=getdisk();
getcurdir(0,mess);
for (i=0;i<11;i++) Cshade[i]=clOlive;
Cshade[11]=clBlack;
sprintf(home,"%c:\\%s",'A'+drive,mess);
sprintf(mess,"%s\\mesh.ini",home);
out=fopen(mess,"rt");
if (out!=NULL)
        {
    fgets(mess,255,out);
        fgets(mess,255,out);
    sscanf(mess,"%d %d %d %d\n",&top,&left,&height,&width);
        fgets(mess,255,out);
    sscanf(mess,"%d %d %d %d\n\n",&tool,&toolx,&tooly,&horizon);
        fgets(mess,255,out);
        fgets(mess,255,out);
    fgets(mess,255,out);
    sscanf(mess,"%s",dir_defaut);
    fgets(mess,255,out);
        fgets(mess,255,out);
    fgets(mess,255,out);
    sscanf(mess,"%d",&nb_fichier);
    if (nb_fichier!=0) N5->Visible=true;
    for (i=0;i<nb_fichier;i++)
        {
        fgets(mess,255,out);
        sscanf(mess,"%s",nom);
        if (i==0) active=ancien1;
                if (i==1) active=ancien2;
                if (i==2) active=ancien3;
                if (i==3) active=ancien4;
        active->Visible=true;
        active->Caption=nom;
        strcpy(ancien_fichier[i],nom);
                }
    fgets(mess,255,out);
    fgets(mess,255,out);
    for (i=0;i<12;i++)
        {
        fgets(mess,255,out);
        sscanf(mess,"%X",&Cshade[i]);
        }
        fclose(out);
    fgets(mess,255,out);
    sscanf(mess,"%d",&uni);
    Fenp->Top=top;
    Fenp->Left=left;
    Fenp->Height=height;
    Fenp->Width=width;
        }
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Vueisometrique1Click(TObject *Sender)
{
Vueisometrique1->Checked=true;
VueXY1->Checked=false;
VueXZ1->Checked=false;
VueYZ1->Checked=false;
rot[0][0]=1.0;rot[1][0]=0.0;rot[2][0]=0.0;
rot[0][1]=0.0;rot[1][1]=1.0;rot[2][1]=0.0;
rot[0][2]=0.0;rot[1][2]=0.0;rot[2][2]=1.0;
norme();
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::VueXY1Click(TObject *Sender)
{
Vueisometrique1->Checked=false;
VueXY1->Checked=true;
VueXZ1->Checked=false;
VueYZ1->Checked=false;
rot[0][0]=1.0;rot[1][0]=0.0;rot[2][0]=0.0;
rot[0][1]=0.0;rot[1][1]=1.0;rot[2][1]=0.0;
rot[0][2]=0.0;rot[1][2]=0.0;rot[2][2]=1.0;
norme();
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::VueXZ1Click(TObject *Sender)
{
Vueisometrique1->Checked=false;
VueXY1->Checked=false;
VueXZ1->Checked=true;
VueYZ1->Checked=false;
rot[0][0]=1.0;rot[1][0]=0.0;rot[2][0]=0.0;
rot[0][1]=0.0;rot[1][1]=1.0;rot[2][1]=0.0;
rot[0][2]=0.0;rot[1][2]=0.0;rot[2][2]=1.0;
norme();
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::VueYZ1Click(TObject *Sender)
{
Vueisometrique1->Checked=false;
VueXY1->Checked=false;
VueXZ1->Checked=false;
VueYZ1->Checked=true;
rot[0][0]=1.0;rot[1][0]=0.0;rot[2][0]=0.0;
rot[0][1]=0.0;rot[1][1]=1.0;rot[2][1]=0.0;
rot[0][2]=0.0;rot[1][2]=0.0;rot[2][2]=1.0;
norme();
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Igsmesh2Click(TObject *Sender)
{
char mess[255];
char arg1[255];
char arg2[255];
char arg3[255];
char arg4[255];
char arg5[255];
char arg6[255];
char arg7[255];
char arg8[255];
int opt=5;


Rigsoption->Edit2->Text="5";
Rigsoption->Label3->Enabled=false;
Rigsoption->Edit3->Enabled=false;
Rigsoption->GroupBox1->Caption=Fichier;
Rigsoption->ShowModal();
if (Rigsoption->ok==1)
        {
    strcpy(mess,Rigsoption->Edit2->Text.c_str());
    sscanf(mess,"%d",&opt);
    if (Rigsoption->CheckBox1->Checked==true) strcpy(arg8,"-analyse"); else strcpy(arg8,"");
    mess[0]=0;
    strcpy(mess,Rigsoption->Edit1->Text.c_str());
    sprintf(arg1,"%s\\igsmesh.exe",home);
    strcpy(arg2,"-fich");
    sprintf(arg3,"%s",Fichier);
        strcpy(arg4,"-mesh");
    strcpy(arg5,mess);
    strcpy(arg6,"-opt");
    sprintf(arg7,"%d",opt);
    if (mess[0]!=0) spawnl(P_NOWAIT,arg1,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,NULL);
    else MessageBox(Handle,"Pas de fichier modele","Erreur",0);
        }
}
//---------------------------------------------------------------------------
void __fastcall TFenp::FormPaint(TObject *Sender)
{
Fenp->Cursor=crHourGlass;
Fenp->SetFocus();
Fenp->Color=Cshade[11];
if (Geometrie1->Checked==true) affiche_geo();
if (Maillage1D1->Checked==true) affiche_1D();
if (Maillage2D1->Checked==true) affiche_2D();
if (Maillage3D1->Checked==true) affiche_3D();
if (Maillage3D2->Checked==true) affiche_3D();
if (Remaillage2D1->Checked==true) affiche_2D();
if (Front3D1->Checked==true) affiche_2D();
if (Remaillage3D1->Checked==true) affiche_3D();
affiche_axe();
Fenp->Cursor=crDefault;
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Mai1Click(TObject *Sender)
{
FILE *fic;
char mess[255];
char fich[255];

strcpy(fich,Fichier);
fich[strlen(fich)-4]=0;


strcpy(mess,fich);
strcat(mess,".geo");
fic=fopen(mess,"rt");
if (fic==NULL) Geometrie1->Enabled=false;
else
        {
     Geometrie1->Enabled=true;
     fclose(fic);
    }


strcpy(mess,fich);
strcat(mess,"_1D.mai");
fic=fopen(mess,"rt");
if (fic==NULL) Maillage1D1->Enabled=false;
else
        {
     Maillage1D1->Enabled=true;
     fclose(fic);
    }


strcpy(mess,fich);
strcat(mess,"_2D.mai");
fic=fopen(mess,"rt");
if (fic==NULL) Maillage2D1->Enabled=false;
else
        {
     Maillage2D1->Enabled=true;
     fclose(fic);
    }

strcpy(mess,fich);
strcat(mess,"r_2D.mai");
fic=fopen(mess,"rt");
if (fic==NULL) Remaillage2D1->Enabled=false;
else
        {
     Remaillage2D1->Enabled=true;
     fclose(fic);
    }
strcpy(mess,fich);
strcat(mess,"_3D.mai");
fic=fopen(mess,"rt");
if (fic==NULL) Maillage3D1->Enabled=false;
else
        {
     Maillage3D1->Enabled=true;
     fclose(fic);
    }
strcpy(mess,fich);
strcat(mess,"c_3D.mai");
fic=fopen(mess,"rt");
if (fic==NULL) Maillage3D2->Enabled=false;
else
        {
     Maillage3D2->Enabled=true;
     fclose(fic);
    }
strcpy(mess,fich);
strcat(mess,"r_3D.mai");
fic=fopen(mess,"rt");
if (fic==NULL) Remaillage3D1->Enabled=false;
else
        {
     Remaillage3D1->Enabled=true;
     fclose(fic);
    }
strcpy(mess,fich);
strcat(mess,"f_2D.mai");
fic=fopen(mess,"rt");
if (fic==NULL) Front3D1->Enabled=false;
else
        {
     Front3D1->Enabled=true;
     fclose(fic);
    }
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Geometrie1Click(TObject *Sender)
{
FILE *fic;
int i,j,k,nb,nb2;
char fich[255];
char mess[255];
int nb_arete;

Geometrie1->Checked=true;
Maillage1D1->Checked=false;
Front3D1->Checked=false;
Maillage2D1->Checked=false;
Remaillage2D1->Checked=false;
Maillage3D1->Checked=false;
Maillage3D2->Checked=false;
Remaillage3D1->Checked=false;
Face1->Enabled=false;
Activerlerendu3D1->Enabled=false;
Activerlerendu3D1->Checked=false;
Aucun1->Checked=false;
if (point!=NULL) free(point);
if (segment!=NULL) free(segment);
if (triangle!=NULL) free(triangle);
if (tetra!=NULL) free(tetra);
nb_point=0;point=NULL;
nb_segment=0;segment=NULL;
nb_triangle=0;triangle=NULL;
nb_tetra=0;tetra=NULL;
tete=NULL;
strcpy(fich,Fichier);
fich[strlen(fich)-4]=0;
strcat(fich,".geo");
fic=fopen(fich,"rt");
fgets(mess,255,fic);
sscanf(mess,"%d",&nb_arete);
for (i=0;i<nb_arete;i++)
        {
        fgets(mess,255,fic);
    sscanf(mess,"%d",&j);
    nb_point=nb_point+j;
    nb_segment=nb_segment+j-1;
    for (k=0;k<j;k++)
        fgets(mess,255,fic);
    }
fclose(fic);
fic=fopen(fich,"rt");
point=(struct s_point *)calloc(nb_point,sizeof(struct s_point));
segment=(struct s_segment *)calloc(nb_segment,sizeof(struct s_segment));
fgets(mess,255,fic);
sscanf(mess,"%d",&nb_arete);
nb=0;nb2=0;
xpiece=0.;ypiece=0.;zpiece=0.;
for (i=0;i<nb_arete;i++)
        {
    fgets(mess,255,fic);
    sscanf(mess,"%d",&j);
    for (k=0;k<j;k++)
        {
        fgets(mess,255,fic);
        sscanf(mess,"%f %f %f",&point[nb].x,&point[nb].y,&point[nb].z);
        if (nb==0)
                {
                xmin=point[nb].x;
                xmax=point[nb].x;
                ymin=point[nb].y;
                ymax=point[nb].y;
                zmin=point[nb].z;
                zmax=point[nb].z;
                }
        if (point[nb].x<xmin) xmin=point[nb].x;
        if (point[nb].x>xmax) xmax=point[nb].x;
        if (point[nb].y<ymin) ymin=point[nb].y;
        if (point[nb].y>ymax) ymax=point[nb].y;
        if (point[nb].z<zmin) zmin=point[nb].z;
        if (point[nb].z>zmax) zmax=point[nb].z;
        xpiece=xpiece+point[nb].x;
        ypiece=ypiece+point[nb].y;
        zpiece=zpiece+point[nb].z;
        if (k!=0)
                {
            segment[nb2].n1=nb-1;
            segment[nb2].n2=nb;
            nb2++;
            }
        nb++;
        }
    }
xpiece=xpiece/nb;
ypiece=ypiece/nb;
zpiece=zpiece/nb;
fclose(fic);
if (passe_norme==0)
        {
    norme();
    passe_norme=1;
    }
Invalidate();
}


//---------------------------------------------------------------------------
void __fastcall TFenp::Maillage1D1Click(TObject *Sender)
{
char fich[255];
char mess[255];
FILE *fic;
int i,j;

Geometrie1->Checked=false;
Maillage1D1->Checked=true;
Front3D1->Checked=false;
Maillage2D1->Checked=false;
Face1->Enabled=false;
Remaillage2D1->Checked=false;
Maillage3D1->Checked=false;
Maillage3D2->Checked=false;
Remaillage3D1->Checked=false;
Activerlerendu3D1->Checked=false;
Activerlerendu3D1->Enabled=false;
Aucun1->Checked=false;
if (point!=NULL) free(point);
if (segment!=NULL) free(segment);
if (triangle!=NULL) free(triangle);
if (tetra!=NULL) free(tetra);
nb_point=0;point=NULL;
nb_segment=0;segment=NULL;
nb_triangle=0;triangle=NULL;
nb_tetra=0;tetra=NULL;
tete=NULL;
strcpy(fich,Fichier);
fich[strlen(fich)-4]=0;
strcat(fich,"_1D.mai");
fic=fopen(fich,"rt");
fgets(mess,255,fic);
sscanf(mess,"%d %d",&nb_point,&nb_segment);
point=(struct s_point *)calloc(nb_point,sizeof(struct s_point));
segment=(struct s_segment *)calloc(nb_segment,sizeof(struct s_segment));
xpiece=0.;ypiece=0.;zpiece=0.;
for (i=0;i<nb_point;i++)
        {
    fgets(mess,255,fic);
    sscanf(mess,"%d %f %f %f",&j,&point[i].x,&point[i].y,&point[i].z);
    xpiece=xpiece+point[i].x;
    ypiece=ypiece+point[i].y;
    zpiece=zpiece+point[i].z;
    }
xpiece=xpiece/nb_point;
ypiece=ypiece/nb_point;
zpiece=zpiece/nb_point;
for (i=0;i<nb_segment;i++)
        {
        fgets(mess,255,fic);
        sscanf(mess,"%d %d %d",&j,&segment[i].n1,&segment[i].n2);
        segment[i].n1=segment[i].n1-1;
        segment[i].n2=segment[i].n2-1;
        segment[i].num=i;
        point[segment[i].n1].segment[point[segment[i].n1].nb_segment]=&(segment[i]);
        point[segment[i].n1].nb_segment++;
        point[segment[i].n2].segment[point[segment[i].n2].nb_segment]=&(segment[i]);
        point[segment[i].n2].nb_segment++;
        }
fclose(fic);
if (passe_norme==0)
        {
    norme();
    passe_norme=1;
    }
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Maillage2D1Click(TObject *Sender)
{
int i,j;
FILE *fic;
int *test_face,maxface;
char fich[255];
char mess[255];

Geometrie1->Checked=false;
Front3D1->Checked=false;
Maillage1D1->Checked=false;
Maillage2D1->Checked=true;
Remaillage2D1->Checked=false;
Maillage3D1->Checked=false;
Maillage3D2->Checked=false;
Remaillage3D1->Checked=false;
Activerlerendu3D1->Enabled=false;
Activerlerendu3D1->Checked=false;
Aucun1->Checked=false;
Face1->Enabled=true;
Face->ListBox1->Items->Clear();
Face->ListBox1->Items->Add("Toutes");
Face->ListBox1->ItemIndex=0;
Fenp->numface=(-1);
if (point!=NULL) free(point);
if (segment!=NULL) free(segment);
if (triangle!=NULL) free(triangle);
if (tetra!=NULL) free(tetra);
nb_point=0;point=NULL;
nb_segment=0;segment=NULL;
nb_triangle=0;triangle=NULL;
nb_tetra=0;tetra=NULL;
tete=NULL;
strcpy(fich,Fichier);
fich[strlen(fich)-4]=0;
strcat(fich,"_2D.mai");
fic=fopen(fich,"rt");
fgets(mess,255,fic);
sscanf(mess,"%d %d",&nb_point,&nb_triangle);
point=(struct s_point *)calloc(nb_point,sizeof(struct s_point));
triangle=(struct s_triangle *)calloc(nb_triangle,sizeof(struct s_triangle));
xpiece=0.;ypiece=0.;zpiece=0.;
for (i=0;i<nb_point;i++)
        {
    fgets(mess,255,fic);
    sscanf(mess,"%d %f %f %f",&j,&point[i].x,&point[i].y,&point[i].z);
    if (i==0)
        {
        xmin=point[i].x;
        xmax=point[i].x;
        ymin=point[i].y;
        ymax=point[i].y;
        zmin=point[i].z;
        zmax=point[i].z;
        maxcoord=point[i].x;
        }
    if (point[i].x<xmin) xmin=point[i].x;
    if (point[i].x>xmax) xmax=point[i].x;
    if (point[i].y<ymin) ymin=point[i].y;
    if (point[i].y>ymax) ymax=point[i].y;
    if (point[i].z<zmin) zmin=point[i].z;
    if (point[i].z>zmax) zmax=point[i].z;
    if (fabs((double)point[i].x)>maxcoord) maxcoord=(float)fabs((double)point[i].x);
    if (fabs((double)point[i].y)>maxcoord) maxcoord=(float)fabs((double)point[i].y);
    if (fabs((double)point[i].z)>maxcoord) maxcoord=(float)fabs((double)point[i].z);
    xpiece=xpiece+point[i].x;
    ypiece=ypiece+point[i].y;
    zpiece=zpiece+point[i].z;
    }
xpiece=xpiece/nb_point;
ypiece=ypiece/nb_point;
zpiece=zpiece/nb_point;
maxface=0;
for (i=0;i<nb_triangle;i++)
    {
    fgets(mess,255,fic);
    sscanf(mess,"%d %d %d %d %s %d",&j,&triangle[i].n1,&triangle[i].n2,&triangle[i].n3,&triangle[i].type,&triangle[i].num_ent);
    triangle[i].n1=triangle[i].n1-1;
    triangle[i].n2=triangle[i].n2-1;
    triangle[i].n3=triangle[i].n3-1;
    triangle[i].num=i;
    if (triangle[i].num_ent>maxface) maxface=triangle[i].num_ent;
    point[triangle[i].n1].triangle[point[triangle[i].n1].nb_triangle]=&(triangle[i]);
    point[triangle[i].n1].nb_triangle++;
    point[triangle[i].n2].triangle[point[triangle[i].n2].nb_triangle]=&(triangle[i]);
    point[triangle[i].n2].nb_triangle++;
    point[triangle[i].n3].triangle[point[triangle[i].n3].nb_triangle]=&(triangle[i]);
    point[triangle[i].n3].nb_triangle++;
    }
fclose(fic);
test_face=(int *)calloc(maxface+1,sizeof(int));
for (i=0;i<nb_triangle;i++)
    test_face[triangle[i].num_ent]=1;
for (i=0;i<maxface+1;i++)
    if (test_face[i]==1)
        {
        sprintf(mess,"%d",i);
        Face->ListBox1->Items->Add(mess);
        }
free(test_face);
if (passe_norme==0)
        {
    norme();
    passe_norme=1;
    }
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Maillage3D1Click(TObject *Sender)
{
int i,j;
FILE *fic;
char fich[255];
char mess[255];


Geometrie1->Checked=false;
Maillage1D1->Checked=false;
Maillage2D1->Checked=false;
Remaillage2D1->Checked=false;
Front3D1->Checked=false;
Maillage3D1->Checked=true;
Maillage3D2->Checked=false;
Remaillage3D1->Checked=false;
Activerlerendu3D1->Enabled=true;
Activerlerendu3D1->Checked=false;
Face1->Enabled=false;
Aucun1->Checked=false;
if (point!=NULL) free(point);
if (segment!=NULL) free(segment);
if (triangle!=NULL) free(triangle);
if (tetra!=NULL) free(tetra);
nb_point=0;point=NULL;
nb_segment=0;segment=NULL;
nb_triangle=0;triangle=NULL;
nb_tetra=0;tetra=NULL;
tete=NULL;
strcpy(fich,Fichier);
fich[strlen(fich)-4]=0;
strcat(fich,"_3D.mai");
fic=fopen(fich,"rt");
fgets(mess,255,fic);
sscanf(mess,"%d %d",&nb_point,&nb_tetra);
point=(struct s_point *)calloc(nb_point,sizeof(struct s_point));
tetra=(struct s_tetra *)calloc(nb_tetra,sizeof(struct s_tetra));
xpiece=0.;ypiece=0.;zpiece=0.;
for (i=0;i<nb_point;i++)
        {
    fgets(mess,255,fic);
    sscanf(mess,"%d %f %f %f",&j,&point[i].x,&point[i].y,&point[i].z);
    if (i==0)
        {
        xmin=point[i].x;
        xmax=point[i].x;
        ymin=point[i].y;
        ymax=point[i].y;
        zmin=point[i].z;
        zmax=point[i].z;
        maxcoord=point[i].x;
        }
    if (point[i].x<xmin) xmin=point[i].x;
    if (point[i].x>xmax) xmax=point[i].x;
    if (point[i].y<ymin) ymin=point[i].y;
    if (point[i].y>ymax) ymax=point[i].y;
    if (point[i].z<zmin) zmin=point[i].z;
    if (point[i].z>zmax) zmax=point[i].z;
    if (fabs((double)point[i].x)>maxcoord) maxcoord=(float)fabs((double)point[i].x);
    if (fabs((double)point[i].y)>maxcoord) maxcoord=(float)fabs((double)point[i].y);
    if (fabs((double)point[i].z)>maxcoord) maxcoord=(float)fabs((double)point[i].z);
    xpiece=xpiece+point[i].x;
    ypiece=ypiece+point[i].y;
    zpiece=zpiece+point[i].z;
    }
xpiece=xpiece/nb_point;
ypiece=ypiece/nb_point;
zpiece=zpiece/nb_point;
for (i=0;i<nb_tetra;i++)
    {
    fgets(mess,255,fic);
    sscanf(mess,"%d %d %d %d %d",&j,&tetra[i].n1,&tetra[i].n2,&tetra[i].n3,&tetra[i].n4);
    tetra[i].n1=tetra[i].n1-1;
    tetra[i].n2=tetra[i].n2-1;
    tetra[i].n3=tetra[i].n3-1;
    tetra[i].n4=tetra[i].n4-1;
    tetra[i].num=i;
    point[tetra[i].n1].tetra[point[tetra[i].n1].nb_tetra]=&(tetra[i]);
    point[tetra[i].n1].nb_tetra++;
    point[tetra[i].n2].tetra[point[tetra[i].n2].nb_tetra]=&(tetra[i]);
    point[tetra[i].n2].nb_tetra++;
    point[tetra[i].n3].tetra[point[tetra[i].n3].nb_tetra]=&(tetra[i]);
    point[tetra[i].n3].nb_tetra++;
    point[tetra[i].n4].tetra[point[tetra[i].n4].nb_tetra]=&(tetra[i]);
    point[tetra[i].n4].nb_tetra++;
    }
fclose(fic);
if (passe_norme==0)
        {
    norme();
    passe_norme=1;
    }
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Aucun1Click(TObject *Sender)
{
Geometrie1->Checked=false;
Maillage1D1->Checked=false;
Front3D1->Checked=false;
Maillage2D1->Checked=false;
Remaillage2D1->Checked=false;
Maillage3D1->Checked=false;
Maillage3D2->Checked=false;
Remaillage3D1->Checked=false;
Aucun1->Checked=true;
Face1->Enabled=false;
if (point!=NULL) free(point);
if (segment!=NULL) free(segment);
if (triangle!=NULL) free(triangle);
if (tetra!=NULL) free(tetra);
nb_point=0;point=NULL;
nb_segment=0;segment=NULL;
nb_triangle=0;triangle=NULL;
nb_tetra=0;tetra=NULL;
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::norme(void)
{
int i,xc,yc;
float zoomx,zoomy;
int xcmax,ycmin,ycmax,xcmin;

for (i=0;i<nb_point;i++)
        {
    projection(point[i].x,point[i].y,point[i].z,&xc,&yc,0);
    if (i==0)
        {
        xcmax=xc;
        xcmin=xc;
        ycmax=yc;
        ycmin=yc;
        }
    if (xc>xcmax) xcmax=xc;
    if (yc>ycmax) ycmax=yc;
    if (xc<xcmin) xcmin=xc;
    if (yc<ycmin) ycmin=yc;
    }
xcmax++;xcmin--;
ycmax++;ycmin--;
if (xcmax!=xcmin) zoomx=Fenp->ClientWidth*1./(xcmax-xcmin);  else zoomx=1E30;
if (ycmax!=ycmin) zoomy=Fenp->ClientHeight*1./(ycmax-ycmin); else zoomy=1E30;
if (zoomx>zoomy) zoom=zoomy; else zoom=zoomx;
zoom=zoom/1.15;
xcentre=(Fenp->ClientWidth/2.-zoom*(xcmin+xcmax)/2.);
ycentre=(Fenp->ClientHeight/2.-zoom*(ycmin+ycmax)/2.);
}
//---------------------------------------------------------------------------
void __fastcall TFenp::projection(float x,float y,float z,int *xc,int *yc,int complete)
{
float alpha,calpha,salpha,xx,yy;


if (Vueisometrique1->Checked==true)
        {
        alpha=PI/6.;
        calpha=(float)cos((double)alpha);
        salpha=(float)sin((double)alpha);
        xx=(-calpha*rot[0][0]+calpha*rot[1][0])*x
        +(-calpha*rot[0][1]+calpha*rot[1][1])*y
        +(-calpha*rot[0][2]+calpha*rot[1][2])*z;
        yy=(salpha*rot[0][0]+salpha*rot[1][0]-rot[2][0])*x
        +(salpha*rot[0][1]+salpha*rot[1][1]-rot[2][1])*y
        +(salpha*rot[0][2]+salpha*rot[1][2]-rot[2][2])*z;
        }
if (VueXY1->Checked==true)
        {
        xx=rot[0][0]*x+rot[1][0]*y+rot[2][0]*z;
        yy=(-(rot[0][1]*x+rot[1][1]*y+rot[2][1]*z));
        }
if (VueXZ1->Checked==true)
        {
        xx=rot[0][0]*x+rot[1][0]*y+rot[2][0]*z;
        yy=(-(rot[0][2]*x+rot[1][2]*y+rot[2][2]*z));
        }
if (VueYZ1->Checked==true)
        {
        xx=rot[0][1]*x+rot[1][1]*y+rot[2][1]*z;
        yy=(-(rot[0][2]*x+rot[1][2]*y+rot[2][2]*z));
        }
if (complete==1)
        {
        xx=xx*zoom+xcentre;
        yy=yy*zoom+ycentre;
        }
if (complete==2)
        {
        xx=xx*zoom_p+xcentre_p;
        yy=yy*zoom_p+ycentre_p;
        }
*xc=(int)xx;
*yc=(int)yy;
}
//---------------------------------------------------------------------------

void __fastcall TFenp::FormResize(TObject *Sender)
{
if (Aucun1->Checked==false)
        {
    norme();
    Invalidate();
        }
}
//---------------------------------------------------------------------------
void __fastcall TFenp::affiche_geo(void)
{
int i,n1,n2;
float x1,x2,y1,y2,z1,z2;
int xc1,xc2,yc1,yc2;

Fenp->Canvas->Pen->Color=clWhite;
for (i=0;i<nb_segment;i++)
        {
        n1=segment[i].n1;
        n2=segment[i].n2;
        x1=point[n1].x;
        y1=point[n1].y;
        z1=point[n1].z;
        x2=point[n2].x;
        y2=point[n2].y;
        z2=point[n2].z;
        projection(x1,y1,z1,&xc1,&yc1,1);
        projection(x2,y2,z2,&xc2,&yc2,1);
    Fenp->Canvas->MoveTo(xc1,yc1);
        Fenp->Canvas->LineTo(xc2,yc2);
        }
}
//---------------------------------------------------------------------------
void __fastcall TFenp::affiche_1D(void)
{
int i,n1,n2;
float x1,x2,y1,y2,z1,z2;
int xc1,xc2,yc1,yc2;
char mess[20];

Fenp->Canvas->Pen->Color=clRed;
Fenp->Canvas->Font->Color=clFuchsia;
for (i=0;i<nb_point;i++)
        {
    x1=point[i].x;
        y1=point[i].y;
        z1=point[i].z;
        projection(x1,y1,z1,&xc1,&yc1,1);
    Fenp->Canvas->MoveTo(xc1-2,yc1);
        Fenp->Canvas->LineTo(xc1+2,yc1);
        Fenp->Canvas->MoveTo(xc1,yc1-2);
        Fenp->Canvas->LineTo(xc1,yc1+2);
    SetBkMode(Fenp->Canvas->Handle,TRANSPARENT);
    if (Noeud1->Checked==true)
        {
        sprintf(mess,"%d",i);
        Fenp->Canvas->TextOut(xc1+2,yc1+2,mess);
        }
        }
Fenp->Canvas->Font->Color=clYellow;
for (i=0;i<nb_segment;i++)
        {
        if ((segment[i].select==0)&& (Debug1->Checked)) continue;
        n1=segment[i].n1;
        n2=segment[i].n2;
        x1=point[n1].x;
        y1=point[n1].y;
        z1=point[n1].z;
        x2=point[n2].x;
        y2=point[n2].y;
        z2=point[n2].z;
        projection(x1,y1,z1,&xc1,&yc1,1);
        projection(x2,y2,z2,&xc2,&yc2,1);
    Fenp->Canvas->MoveTo(xc1,yc1);
        Fenp->Canvas->LineTo(xc2,yc2);
        SetBkMode(Fenp->Canvas->Handle,TRANSPARENT);
    if (Maille2->Checked==true)
        {
        sprintf(mess,"%d",i);
        Fenp->Canvas->TextOut((int)((xc1+xc2)*0.5),(int)((yc1+yc2)*0.5),mess);
        }
        }
if (numero_noeud>=0)
        {
    Fenp->Canvas->Font->Color=clWhite;
        x1=point[numero_noeud].x;
        y1=point[numero_noeud].y;
        z1=point[numero_noeud].z;
        projection(x1,y1,z1,&xc1,&yc1,1);
    sprintf(mess,"%d",numero_noeud);
    Fenp->Canvas->TextOut(xc1+2,yc1+2,mess);
        }
if (numero_maille>=0)
        {
    Fenp->Canvas->Font->Color=clWhite;
        n1=segment[numero_maille].n1;
        n2=segment[numero_maille].n2;
        x1=point[n1].x;
        y1=point[n1].y;
        z1=point[n1].z;
        x2=point[n2].x;
        y2=point[n2].y;
        z2=point[n2].z;
        projection(x1,y1,z1,&xc1,&yc1,1);
        projection(x2,y2,z2,&xc2,&yc2,1);
    sprintf(mess,"%d",numero_maille);
    Fenp->Canvas->TextOut((int)((xc1+xc2)*0.5),(int)((yc1+yc2)*0.5),mess);
    }
}
//---------------------------------------------------------------------------
void __fastcall TFenp::affiche_2D(void)
{
int i,n1,n2,n3;
float x1,x2,y1,y2,z1,z2,x3,y3,z3;
float ab[3],ac[3],g[3],crit;
int xc1,xc2,yc1,yc2,xc3,yc3;
TRect r;
char mess[20];

if (fc==1)
        {
    affiche_reel();
    return;
    }
Fenp->Canvas->Pen->Color=clRed;
if (Eclatee1->Checked==true) Fenp->Canvas->Pen->Color=clOlive;
for (i=0;i<nb_triangle;i++)
        {
        if ((triangle[i].num_ent==numface) || (numface==(-1)))
        {
        if ((triangle[i].select==0) && (Debug1->Checked)) continue;
        n1=triangle[i].n1;
                n2=triangle[i].n2;
        n3=triangle[i].n3;
        x1=point[n1].x;
                y1=point[n1].y;
                z1=point[n1].z;
                x2=point[n2].x;
                y2=point[n2].y;
                z2=point[n2].z;
                x3=point[n3].x;
                y3=point[n3].y;
                z3=point[n3].z;
        if (Normal1->Checked==false)
                {
            if (Qualite1->Checked==true)
                {
                crit=crit_cal2d(n1,n2,n3);
                    if (crit>0.5) Fenp->Canvas->Pen->Color=clLime;
                    else if (crit>0.2) Fenp->Canvas->Pen->Color=clBlue;
                    else if (crit>0.1) Fenp->Canvas->Pen->Color=clRed;
                    else Fenp->Canvas->Pen->Color=clMaroon;
                    }
                        ab[0]=x2-x1;ab[1]=y2-y1;ab[2]=z2-z1;
                        ac[0]=x3-x1;ac[1]=y3-y1;ac[2]=z3-z1;
            g[0]=x1+0.33333*(ab[0]+ac[0]);
                        g[1]=y1+0.33333*(ab[1]+ac[1]);
                        g[2]=z1+0.33333*(ab[2]+ac[2]);
            x1=g[0]+homo*(x1-g[0]);y1=g[1]+homo*(y1-g[1]);z1=g[2]+homo*(z1-g[2]);
                        x2=g[0]+homo*(x2-g[0]);y2=g[1]+homo*(y2-g[1]);z2=g[2]+homo*(z2-g[2]);
                        x3=g[0]+homo*(x3-g[0]);y3=g[1]+homo*(y3-g[1]);z3=g[2]+homo*(z3-g[2]);
                        }
                projection(x1,y1,z1,&xc1,&yc1,1);
                projection(x2,y2,z2,&xc2,&yc2,1);
            projection(x3,y3,z3,&xc3,&yc3,1);
            Fenp->Canvas->MoveTo(xc1,yc1);
                Fenp->Canvas->LineTo(xc2,yc2);
                Fenp->Canvas->LineTo(xc3,yc3);
                Fenp->Canvas->LineTo(xc1,yc1);
        Fenp->Canvas->Font->Color=clFuchsia;
            SetBkMode(Fenp->Canvas->Handle,TRANSPARENT);
                if (Noeud1->Checked==true)
                {
                sprintf(mess,"%d",n1);
                projection(point[n1].x,point[n1].y,point[n1].z,&xc1,&yc1,1);
                        Fenp->Canvas->TextOut(xc1+2,yc1+2,mess);
                sprintf(mess,"%d",n2);
                projection(point[n2].x,point[n2].y,point[n2].z,&xc2,&yc2,1);
                        Fenp->Canvas->TextOut(xc2+2,yc2+2,mess);
                sprintf(mess,"%d",n3);
                projection(point[n3].x,point[n3].y,point[n3].z,&xc3,&yc3,1);
                        Fenp->Canvas->TextOut(xc3+2,yc3+2,mess);
                }
        Fenp->Canvas->Font->Color=clYellow;
                if (Maille2->Checked==true)
                        {
                sprintf(mess,"%d",i);
                Fenp->Canvas->TextOut((int)((xc1+xc2+xc3)*0.333333),(int)((yc1+yc2+yc3)*0.33333333),mess);
                }
                }
    }
if (Qualite1->Checked==true)
        {
    Fenp->Canvas->TextOut(10,95,"Qualite");
    Fenp->Canvas->Brush->Color=clLime;
    r.Left=5;r.Top=113;r.Bottom=120;r.Right=15;
    Fenp->Canvas->FillRect(r);
    Fenp->Canvas->Brush->Color=clBlue;
    r.Left=5;r.Top=125;r.Bottom=132;r.Right=15;
    Fenp->Canvas->FillRect(r);
    Fenp->Canvas->Brush->Color=clRed;
    r.Left=5;r.Top=137;r.Bottom=144;r.Right=15;
    Fenp->Canvas->FillRect(r);
    Fenp->Canvas->Brush->Color=clMaroon;
    r.Left=5;r.Top=149;r.Bottom=156;r.Right=15;
    Fenp->Canvas->FillRect(r);
    Fenp->Canvas->Brush->Color=clBlack;
    Fenp->Canvas->TextOut(20,110,"Bonne");
    Fenp->Canvas->TextOut(20,122,"Moyenne");
        Fenp->Canvas->TextOut(20,134,"Passable");
        Fenp->Canvas->TextOut(20,146,"Mediocre");
        }
if (numero_noeud>=0)
        {
    Fenp->Canvas->Font->Color=clWhite;
        x1=point[numero_noeud].x;
        y1=point[numero_noeud].y;
        z1=point[numero_noeud].z;
        projection(x1,y1,z1,&xc1,&yc1,1);
    sprintf(mess,"%d",numero_noeud);
    Fenp->Canvas->TextOut(xc1+2,yc1+2,mess);
        }
if (numero_maille>=0)
        {
    Fenp->Canvas->Font->Color=clWhite;
        n1=triangle[numero_maille].n1;
    n2=triangle[numero_maille].n2;
        n3=triangle[numero_maille].n3;
        x1=point[n1].x;
        y1=point[n1].y;
        z1=point[n1].z;
        x2=point[n2].x;
        y2=point[n2].y;
        z2=point[n2].z;
        x3=point[n3].x;
        y3=point[n3].y;
        z3=point[n3].z;
    projection(x1,y1,z1,&xc1,&yc1,1);
        projection(x2,y2,z2,&xc2,&yc2,1);
    projection(x3,y3,z3,&xc3,&yc3,1);
    sprintf(mess,"%d",numero_maille);
    Fenp->Canvas->TextOut((int)((xc1+xc2+xc3)*0.333333),(int)((yc1+yc2+yc3)*0.33333333),mess);
    }

}
//---------------------------------------------------------------------------
void __fastcall TFenp::affiche_3D(void)
{
int i,n1,n2,n3,n4;
float x1,x2,y1,y2,z1,z2,x3,y3,z3,x4,y4,z4;
float ab[3],ac[3],ad[3],g[3],crit;
int xc1,xc2,yc1,yc2,xc3,yc3,xc4,yc4;
char mess[20];
TRect r;

if ((Activerlerendu3D1->Checked==true)&&(fc==1))
        {
    affiche_reel();
    return;
    }
Fenp->Canvas->Pen->Color=clRed;
if (Eclatee1->Checked==true) Fenp->Canvas->Pen->Color=clOlive;
for (i=0;i<nb_tetra;i++)
        {
        if ((tetra[i].select==0)&& (Debug1->Checked)) continue;
        n1=tetra[i].n1;
        n2=tetra[i].n2;
    n3=tetra[i].n3;
    n4=tetra[i].n4;
    x1=point[n1].x;
        y1=point[n1].y;
        z1=point[n1].z;
        x2=point[n2].x;
        y2=point[n2].y;
        z2=point[n2].z;
        x3=point[n3].x;
        y3=point[n3].y;
        z3=point[n3].z;
    x4=point[n4].x;
    y4=point[n4].y;
    z4=point[n4].z;
    if (Normal1->Checked==false)
        {
        if (Qualite1->Checked==true)
                {
                crit=crit_cal3d(n1,n2,n3,n4);
            if (crit>0.5) Fenp->Canvas->Pen->Color=clLime;
            else if (crit>0.2) Fenp->Canvas->Pen->Color=clBlue;
            else if (crit>0.1) Fenp->Canvas->Pen->Color=clRed;
            else Fenp->Canvas->Pen->Color=clMaroon;
            }
                ab[0]=x2-x1;ab[1]=y2-y1;ab[2]=z2-z1;
                ac[0]=x3-x1;ac[1]=y3-y1;ac[2]=z3-z1;
        ad[0]=x4-x1;ad[1]=y4-y1;ad[2]=z4-z1;
        g[0]=x1+0.25*(ab[0]+ac[0]+ad[0]);
                g[1]=y1+0.25*(ab[1]+ac[1]+ad[1]);
                g[2]=z1+0.25*(ab[2]+ac[2]+ad[2]);
        x1=g[0]+homo*(x1-g[0]);y1=g[1]+homo*(y1-g[1]);z1=g[2]+homo*(z1-g[2]);
                x2=g[0]+homo*(x2-g[0]);y2=g[1]+homo*(y2-g[1]);z2=g[2]+homo*(z2-g[2]);
                x3=g[0]+homo*(x3-g[0]);y3=g[1]+homo*(y3-g[1]);z3=g[2]+homo*(z3-g[2]);
                x4=g[0]+homo*(x4-g[0]);y4=g[1]+homo*(y4-g[1]);z4=g[2]+homo*(z4-g[2]);
                }
        projection(x1,y1,z1,&xc1,&yc1,1);
        projection(x2,y2,z2,&xc2,&yc2,1);
    projection(x3,y3,z3,&xc3,&yc3,1);
    projection(x4,y4,z4,&xc4,&yc4,1);
    Fenp->Canvas->MoveTo(xc1,yc1);
        Fenp->Canvas->LineTo(xc2,yc2);
        Fenp->Canvas->LineTo(xc3,yc3);
        Fenp->Canvas->LineTo(xc1,yc1);
        Fenp->Canvas->MoveTo(xc4,yc4);
        Fenp->Canvas->LineTo(xc1,yc1);
        Fenp->Canvas->MoveTo(xc4,yc4);
        Fenp->Canvas->LineTo(xc2,yc2);
        Fenp->Canvas->MoveTo(xc4,yc4);
        Fenp->Canvas->LineTo(xc3,yc3);
        Fenp->Canvas->Font->Color=clFuchsia;
        SetBkMode(Fenp->Canvas->Handle,TRANSPARENT);
    if (Noeud1->Checked==true)
        {
        sprintf(mess,"%d",n1);
        Fenp->Canvas->TextOut(xc1+2,yc1+2,mess);
        sprintf(mess,"%d",n2);
        Fenp->Canvas->TextOut(xc2+2,yc2+2,mess);
        sprintf(mess,"%d",n3);
        Fenp->Canvas->TextOut(xc3+2,yc3+2,mess);
        sprintf(mess,"%d",n4);
        Fenp->Canvas->TextOut(xc4+2,yc4+2,mess);
        }
    Fenp->Canvas->Font->Color=clYellow;
        if (Maille2->Checked==true)
        {
        sprintf(mess,"%d",i);
        Fenp->Canvas->TextOut((int)((xc1+xc2+xc3+xc4)*0.25),(int)((yc1+yc2+yc3+yc4)*0.25),mess);
        }
        }
if (Qualite1->Checked==true)
        {
    Fenp->Canvas->TextOut(10,95,"Qualite");
    Fenp->Canvas->Brush->Color=clLime;
    r.Left=5;r.Top=113;r.Bottom=120;r.Right=15;
    Fenp->Canvas->FillRect(r);
    Fenp->Canvas->Brush->Color=clBlue;
    r.Left=5;r.Top=125;r.Bottom=132;r.Right=15;
    Fenp->Canvas->FillRect(r);
    Fenp->Canvas->Brush->Color=clRed;
    r.Left=5;r.Top=137;r.Bottom=144;r.Right=15;
    Fenp->Canvas->FillRect(r);
    Fenp->Canvas->Brush->Color=clMaroon;
    r.Left=5;r.Top=149;r.Bottom=156;r.Right=15;
    Fenp->Canvas->FillRect(r);
    Fenp->Canvas->Brush->Color=clBlack;
    Fenp->Canvas->TextOut(20,110,"Bonne");
    Fenp->Canvas->TextOut(20,122,"Moyenne");
        Fenp->Canvas->TextOut(20,134,"Passable");
        Fenp->Canvas->TextOut(20,146,"Mediocre");
        }
if (numero_noeud>=0)
        {
    Fenp->Canvas->Font->Color=clWhite;
        x1=point[numero_noeud].x;
        y1=point[numero_noeud].y;
        z1=point[numero_noeud].z;
        projection(x1,y1,z1,&xc1,&yc1,1);
    sprintf(mess,"%d",numero_noeud);
    Fenp->Canvas->TextOut(xc1+2,yc1+2,mess);
        }
if (numero_maille>=0)
        {
    Fenp->Canvas->Font->Color=clWhite;
        n1=tetra[numero_maille].n1;
        n2=tetra[numero_maille].n2;
    n3=tetra[numero_maille].n3;
    n4=tetra[numero_maille].n4;
    x1=point[n1].x;
        y1=point[n1].y;
        z1=point[n1].z;
        x2=point[n2].x;
        y2=point[n2].y;
        z2=point[n2].z;
        x3=point[n3].x;
        y3=point[n3].y;
        z3=point[n3].z;
    x4=point[n4].x;
    y4=point[n4].y;
    z4=point[n4].z;
    projection(x1,y1,z1,&xc1,&yc1,1);
        projection(x2,y2,z2,&xc2,&yc2,1);
    projection(x3,y3,z3,&xc3,&yc3,1);
    projection(x4,y4,z4,&xc4,&yc4,1);
    sprintf(mess,"%d",numero_maille);
    Fenp->Canvas->TextOut((int)((xc1+xc2+xc3+xc4)*0.25),(int)((yc1+yc2+yc3+yc4)*0.25),mess);
    }


}
//---------------------------------------------------------------------------
void __fastcall TFenp::affiche_reel(void)
{
int *iordre;
float *distance;
int xpoint[8];
TPoint ypoint[8];
float xe,ye,ze,xee,yee,zee;
float xa,ya,za;
float xb,yb,zb;
float xc,yc,zc;
float xg,yg,zg;
float nx,ny,nz;
float g[4];
char mess[20];
struct s_triangle *tri;
static float dismin,dismax;
float diff;
static float arot[3][3]={{-1.,-1.,-1.},{-1.,-1.,-1.},{-1.,-1.,-1.}};
int i;
int pareil,color;

pareil=0;
if (tete!=NULL)
if (arot[0][0]==rot[0][0])
if (arot[1][0]==rot[1][0])
if (arot[2][0]==rot[2][0])
if (arot[0][1]==rot[0][1])
if (arot[1][1]==rot[1][1])
if (arot[2][1]==rot[2][1])
if (arot[0][2]==rot[0][2])
if (arot[1][2]==rot[1][2])
if (arot[2][2]==rot[2][2]) pareil=1;

if (pareil==0)
{
        tete=NULL;
        arot[0][0]=rot[0][0];
        arot[1][0]=rot[1][0];
        arot[2][0]=rot[2][0];
        arot[0][1]=rot[0][1];
        arot[1][1]=rot[1][1];
        arot[2][1]=rot[2][1];
        arot[0][2]=rot[0][2];
        arot[1][2]=rot[1][2];
        arot[2][2]=rot[2][2];
        /* oeuil */
        xe=1000.*maxcoord-0.5*(xmin+xmax);
        ye=1000.*maxcoord-0.5*(ymin+ymax);
        ze=1000.*maxcoord-0.5*(zmin+zmax);
    /* oeuil dans le repere local */
        xee=rot[0][0]*xe+rot[1][0]*ye+rot[2][0]*ze;
        yee=rot[0][1]*xe+rot[1][1]*ye+rot[2][1]*ze;
        zee=rot[0][2]*xe+rot[1][2]*ye+rot[2][2]*ze;
        iordre=(int *)calloc(nb_triangle+1,sizeof(int));
        distance=(float *)calloc(nb_triangle+1,sizeof(float));
        for (i=0;i<nb_triangle;i++)
                {
                triangle[i].dis=0.;
                triangle[i].suivant=NULL;
                xa=point[triangle[i].n1].x;
                ya=point[triangle[i].n1].y;
                za=point[triangle[i].n1].z;
                xb=point[triangle[i].n2].x;
                yb=point[triangle[i].n2].y;
                zb=point[triangle[i].n2].z;
                xc=point[triangle[i].n3].x;
                yc=point[triangle[i].n3].y;
                zc=point[triangle[i].n3].z;
                xg=0.333333*(xa+xb+xc);
                yg=0.333333*(ya+yb+yc);
                zg=0.333333*(za+zb+zc);
        triangle[i].dis=(xee-xg)*(xee-xg)+(yee-yg)*(yee-yg)+(zee-zg)*(zee-zg);
        if (i==0)
                {
            dismin=triangle[i].dis;
                        dismax=triangle[i].dis;
                        }
        else
                {
            if (triangle[i].dis<dismin) dismin=triangle[i].dis;
                        if (triangle[i].dis>dismax) dismax=triangle[i].dis;
            }
        nx=(yb-ya)*(zc-za)-(zb-za)*(yc-ya);
        ny=(xc-xa)*(zb-za)-(xb-xa)*(zc-za);
        nz=(xb-xa)*(yc-ya)-(yb-ya)*(xc-xa);
        triangle[i].angle=(float)((nx*(xee-xg)+ny*(yee-yg)+nz*(zee-zg))/sqrt((double)((nx*nx+ny*ny+nz*nz)*((xee-xg)*(xee-xg)+(yee-yg)*(yee-yg)+(zee-zg)*(zee-zg)))));
        if (triangle[i].angle>=1.) triangle[i].angle=0.99999999;
                if (triangle[i].angle<=(-1.)) triangle[i].angle=(-0.99999999);
        distance[i]=triangle[i].dis;
        iordre[i]=i+1;
        }
trirea(distance,&(nb_triangle),iordre);
diff=dismax-dismin;
dismin=dismin-0.025*diff;
dismax=dismax+0.025*diff;
}
Fenp->Canvas->Pen->Color=Cshade[0];
if (ContourInactif1->Checked==true) Fenp->Canvas->Pen->Style=psClear;
Fenp->Canvas->Brush->Color=Cshade[1];
for (i=nb_triangle-1;i>(-1);i--)
        {
    tri=&(triangle[iordre[i]-1]);
    if ((tri->select==0)&& (Debug1->Checked)) continue;

    if (((tri->num_ent==numface) || (numface==(-1))&&(tri->dis-dismin*loin-(1.-loin)*dismax>0.)))
                {
        xa=point[tri->n1].x;
                ya=point[tri->n1].y;
                za=point[tri->n1].z;
                xb=point[tri->n2].x;
                yb=point[tri->n2].y;
                zb=point[tri->n2].z;
                xc=point[tri->n3].x;
                yc=point[tri->n3].y;
                zc=point[tri->n3].z;
        if (Normal1->Checked==false)
                {
            g[0]=0.33333*(xa+xb+xc);
                        g[1]=0.33333*(ya+yb+yc);
                        g[2]=0.33333*(za+zb+zc);
            xa=g[0]+homo*(xa-g[0]);ya=g[1]+homo*(ya-g[1]);za=g[2]+homo*(za-g[2]);
                        xb=g[0]+homo*(xb-g[0]);yb=g[1]+homo*(yb-g[1]);zb=g[2]+homo*(zb-g[2]);
                        xc=g[0]+homo*(xc-g[0]);yc=g[1]+homo*(yc-g[1]);zc=g[2]+homo*(zc-g[2]);
            }
        projection(xa,ya,za,&xpoint[0],&xpoint[1],1);
                projection(xb,yb,zb,&xpoint[2],&xpoint[3],1);
                projection(xc,yc,zc,&xpoint[4],&xpoint[5],1);
        ypoint[0].x=xpoint[0];
        ypoint[0].y=xpoint[1];
        ypoint[1].x=xpoint[2];
        ypoint[1].y=xpoint[3];
                ypoint[2].x=xpoint[4];
        ypoint[2].y=xpoint[5];
        color=(int)(-10*fabs((double)(tri->angle))+10);
        if (color>10) color=10;
        if (color<1) color=1;
                Fenp->Canvas->Brush->Color=Cshade[color];
                Fenp->Canvas->Polygon(ypoint,2);
        Fenp->Canvas->Font->Color=clFuchsia;
                SetBkMode(Fenp->Canvas->Handle,TRANSPARENT);
                if (Noeud1->Checked==true)
                {
                sprintf(mess,"%d",tri->n1);
                Fenp->Canvas->TextOut(xpoint[0]+2,xpoint[1]+2,mess);
                sprintf(mess,"%d",tri->n2);
                Fenp->Canvas->TextOut(xpoint[2]+2,xpoint[3]+2,mess);
                sprintf(mess,"%d",tri->n3);
                Fenp->Canvas->TextOut(xpoint[4]+2,xpoint[5]+2,mess);
                }
        if (tri->n1==numero_noeud)
                {
            Fenp->Canvas->Font->Color=clWhite;
                sprintf(mess,"%d",tri->n1);
                Fenp->Canvas->TextOut(xpoint[0]+2,xpoint[1]+2,mess);
                }
        if (tri->n2==numero_noeud)
                {
            Fenp->Canvas->Font->Color=clWhite;
                sprintf(mess,"%d",tri->n2);
                Fenp->Canvas->TextOut(xpoint[2]+2,xpoint[3]+2,mess);
                }
        if (tri->n3==numero_noeud)
                {
            Fenp->Canvas->Font->Color=clWhite;
                sprintf(mess,"%d",tri->n3);
                Fenp->Canvas->TextOut(xpoint[4]+2,xpoint[5]+2,mess);
                }
        if (tri->num!=numero_maille) Fenp->Canvas->Font->Color=clYellow;
        else
                {
                Fenp->Canvas->Font->Color=clWhite;
                sprintf(mess,"%d",tri->num);
                Fenp->Canvas->TextOut((int)((xpoint[0]+xpoint[2]+xpoint[4])*0.333333),(int)((xpoint[1]+xpoint[3]+xpoint[5])*0.33333333),mess);
                }
                if (Maille2->Checked==true)
                {
                sprintf(mess,"%d",tri->num);
                Fenp->Canvas->TextOut((int)((xpoint[0]+xpoint[2]+xpoint[4])*0.333333),(int)((xpoint[1]+xpoint[3]+xpoint[5])*0.33333333),mess);
                }
                }
    }
Fenp->Canvas->Pen->Style=psSolid;
free(iordre);
free(distance);
}
//---------------------------------------------------------------------------
void __fastcall TFenp::FormKeyDown(TObject *Sender, WORD &Key,TShiftState Shift)
{
char mess[100];
float val;
int nb_maille;

if (Key==112)
        {
        zoom=zoom*1.1;
    xcentre=(Fenp->ClientWidth/2.-1.1*(Fenp->ClientWidth/2.-xcentre));
    ycentre=(Fenp->ClientHeight/2.-1.1*(Fenp->ClientHeight/2.-ycentre));
    Invalidate();
    }
if (Key==113)
        {
        zoom=zoom*0.90909090;
    xcentre=(Fenp->ClientWidth/2.-0.90909090*(Fenp->ClientWidth/2.-xcentre));
    ycentre=(Fenp->ClientHeight/2.-0.90909090*(Fenp->ClientHeight/2.-ycentre));
    Invalidate();
    }
if (Key==114)
        {
    rot[0][0]=1.0;rot[1][0]=0.0;rot[2][0]=0.0;
    rot[0][1]=0.0;rot[1][1]=1.0;rot[2][1]=0.0;
    rot[0][2]=0.0;rot[1][2]=0.0;rot[2][2]=1.0;
    norme();
        Invalidate();
    }
 if (Key==115)
        {
    norme();
    Invalidate();
    }
if (Key==116)
        {
    if (fc==1) fc=0; else fc=1;
    Invalidate();
    }
if (Key==37)
        {
    xcentre=xcentre-4;
    Invalidate();
    }
 if (Key==39)
        {
    xcentre=xcentre+4;
    Invalidate();
    }
 if (Key==38)
        {
    ycentre=ycentre-4;
    Invalidate();
    }
 if (Key==40)
        {
    ycentre=ycentre+4;
    Invalidate();
    }
 if (Key==45)
        {
    rotation(0.1,1);
    Invalidate();
        }
 if (Key==46)
        {
    rotation(-0.1,1);
    Invalidate();
        }
 if (Key==36)
        {
    rotation(0.1,2);
    Invalidate();
        }
 if (Key==35)
        {
    rotation(-0.1,2);
    Invalidate();
        }
 if (Key==33)
        {
    rotation(0.1,3);
    Invalidate();
        }
 if (Key==34)
        {
    rotation(-0.1,3);
    Invalidate();
        }
 if (Key==109)
        {
    homo=homo/1.1;
    if (homo<0.0001) homo=0.0001;
    Invalidate();
        }
 if (Key==107)
        {
    homo=homo*1.1;
    if (homo>1.) homo=1.;
    Invalidate();
        }
 if (Key==105)
        {
    loin=1.;
    Toolbar->TrackBar1->Position=(int)(loin*100.);
    Invalidate();
        }
 if (Key==106)
        {
    loin=loin+0.01;
    if (loin>1.2) loin=1.2;
    else
        {
        if (existetool==1)
                {
                Toolbar->TrackBar1->Position=(int)(loin*100.);
                }
                Invalidate();
        }
        }
 if (Key==111)
        {
    loin=loin-0.01;
    if (loin<0.) loin=0.;
    else
        {
        if (existetool==1)
                {
                Toolbar->TrackBar1->Position=(int)(loin*100.);
                }
                Invalidate();
        }
        }
 if (Key==120)
        {
    strcpy(info,"Valeur du zoom ?");
    Valeur->ShowModal();
    strcpy(mess,Valeur->Edit1->Text.c_str());
    sscanf(mess,"%f",&val);
    zoom=zoom*val;
    xcentre=(Fenp->ClientWidth/2.-val*(Fenp->ClientWidth/2.-xcentre));
    ycentre=(Fenp->ClientHeight/2.-val*(Fenp->ClientHeight/2.-ycentre));
    Invalidate();
        }
if (Key==121)
        {
    strcpy(info,"Valeur de la rotation suivant x ?");
    Valeur->ShowModal();
    strcpy(mess,Valeur->Edit1->Text.c_str());
    sscanf(mess,"%f",&val);
    rotation(val/180.*PI,1);
        Invalidate();
    }
if (Key==122)
        {
    strcpy(info,"Valeur de la rotation suivant y ?");
    Valeur->ShowModal();
    strcpy(mess,Valeur->Edit1->Text.c_str());
    sscanf(mess,"%f",&val);
    rotation(val/180.*PI,2);
        Invalidate();
    }
if (Key==123)
        {
    strcpy(info,"Valeur de la rotation suivant z ?");
    Valeur->ShowModal();
    strcpy(mess,Valeur->Edit1->Text.c_str());
    sscanf(mess,"%f",&val);
    rotation(val/180.*PI,3);
    Invalidate();
        }
if (Key==117)
        {
    sprintf(info,"numero de noeud a afficher (0-%d)?",nb_point);
    Valeur->ShowModal();
    strcpy(mess,Valeur->Edit1->Text.c_str());
    sscanf(mess,"%d",&numero_noeud);
    if (numero_noeud>=nb_point) numero_noeud=nb_point;
    Invalidate();
        }
if (Key==118)
        {
    nb_maille=nb_segment+nb_triangle+nb_tetra;
    sprintf(info,"numero de maille a afficher (0-%d)?",nb_maille);
    Valeur->ShowModal();
    strcpy(mess,Valeur->Edit1->Text.c_str());
    sscanf(mess,"%d",&numero_maille);
    if (numero_maille>=nb_maille) numero_maille=nb_maille;
    Invalidate();
        }
if (Key==119)
        {
    strcpy(info,"Valeur de l'echelle ?");
    sprintf(mess,"%f",zoom);
    Valeur->Edit1->Text=mess;
    Valeur->ShowModal();
    strcpy(mess,Valeur->Edit1->Text.c_str());
    sscanf(mess,"%f",&zoom);
    Invalidate();
        }


}
//---------------------------------------------------------------------------
void __fastcall TFenp::rotation(float angle,int type)
{
float resut[3][3],mrot[3][3],cangle,sangle;
int xtmp,ytmp,xtmp2,ytmp2;

cangle=(float)cos((double)angle);
sangle=(float)sin((double)angle);

projection(xpiece,ypiece,zpiece,&xtmp,&ytmp,1);
if (type==1)
        {
    mrot[0][0]=1.;mrot[0][1]=0.;mrot[0][2]=0.;
    mrot[1][0]=0.;mrot[1][1]=cangle;mrot[1][2]=(-sangle);
    mrot[2][0]=0.;mrot[2][1]=sangle;mrot[2][2]=cangle;
    }
if (type==2)
        {
        mrot[0][0]=cangle;mrot[0][1]=0.;mrot[0][2]=sangle;
        mrot[1][0]=0.;mrot[1][1]=1.;mrot[1][2]=0.;
        mrot[2][0]=(-sangle);mrot[2][1]=0.;mrot[2][2]=cangle;
        }
if (type==3)
        {
        mrot[0][0]=cangle;mrot[0][1]=(-sangle);mrot[0][2]=0.;
        mrot[1][0]=sangle;mrot[1][1]=cangle;mrot[1][2]=0.;
        mrot[2][0]=0.;mrot[2][1]=0.;mrot[2][2]=1.;
        }
resut[0][0]=rot[0][0]*mrot[0][0]+rot[0][1]*mrot[1][0]+rot[0][2]*mrot[2][0];
resut[0][1]=rot[0][0]*mrot[0][1]+rot[0][1]*mrot[1][1]+rot[0][2]*mrot[2][1];
resut[0][2]=rot[0][0]*mrot[0][2]+rot[0][1]*mrot[1][2]+rot[0][2]*mrot[2][2];
resut[1][0]=rot[1][0]*mrot[0][0]+rot[1][1]*mrot[1][0]+rot[1][2]*mrot[2][0];
resut[1][1]=rot[1][0]*mrot[0][1]+rot[1][1]*mrot[1][1]+rot[1][2]*mrot[2][1];
resut[1][2]=rot[1][0]*mrot[0][2]+rot[1][1]*mrot[1][2]+rot[1][2]*mrot[2][2];
resut[2][0]=rot[2][0]*mrot[0][0]+rot[2][1]*mrot[1][0]+rot[2][2]*mrot[2][0];
resut[2][1]=rot[2][0]*mrot[0][1]+rot[2][1]*mrot[1][1]+rot[2][2]*mrot[2][1];
resut[2][2]=rot[2][0]*mrot[0][2]+rot[2][1]*mrot[1][2]+rot[2][2]*mrot[2][2];
rot[0][0]=resut[0][0];
rot[1][0]=resut[1][0];
rot[2][0]=resut[2][0];
rot[0][1]=resut[0][1];
rot[1][1]=resut[1][1];
rot[2][1]=resut[2][1];
rot[0][2]=resut[0][2];
rot[1][2]=resut[1][2];
rot[2][2]=resut[2][2];
projection(xpiece,ypiece,zpiece,&xtmp2,&ytmp2,1);
xcentre=xcentre+xtmp-xtmp2;
ycentre=ycentre+ytmp-ytmp2;
}

void __fastcall TFenp::Normal1Click(TObject *Sender)
{
 Normal1->Checked=true;
 Eclatee1->Checked=false;
 Qualite1->Checked=false;
 Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Eclatee1Click(TObject *Sender)
{
 Normal1->Checked=false;
 Eclatee1->Checked=true;
 Qualite1->Checked=false;
 Invalidate();

}
//---------------------------------------------------------------------------
void __fastcall TFenp::Qualite1Click(TObject *Sender)
{
 Normal1->Checked=false;
 Eclatee1->Checked=false;
 Qualite1->Checked=true;
 Invalidate();
}
//---------------------------------------------------------------------------
float __fastcall TFenp::crit_cal2d(int n1,int n2,int n3)
{
float x1,y1,z1,x2,y2,z2,x3,y3,z3,crits;
double p,ab[3],ac[3],cb[3],dac,dab,dcb,dmax,crit;

x1=point[n1].x;y1=point[n1].y;z1=point[n1].z;
x2=point[n2].x;y2=point[n2].y;z2=point[n2].z;
x3=point[n3].x;y3=point[n3].y;z3=point[n3].z;
ab[0]=x2-x1;ab[1]=y2-y1;ab[2]=z2-z1;
ac[0]=x3-x1;ac[1]=y3-y1;ac[2]=z3-z1;
cb[0]=x2-x3;cb[1]=y2-y3;cb[2]=z2-z3;
dab=sqrt(ab[0]*ab[0]+ab[1]*ab[1]+ab[2]*ab[2]);
dac=sqrt(ac[0]*ac[0]+ac[1]*ac[1]+ac[2]*ac[2]);
dcb=sqrt(cb[0]*cb[0]+cb[1]*cb[1]+cb[2]*cb[2]);
dmax=dab;
if (dac>dmax)dmax=dac;
if (dcb>dmax)dmax=dcb;
p=0.5*(dac+dab+dcb);
crit = (p-dac)*(p-dab)*(p-dcb)/p ;
crit = sqrt(crit) ;
crit = crit /dmax ;
crit = crit * 3.464101614 ;
crits=(float)crit;
return(crits);
}
//---------------------------------------------------------------------------
float __fastcall TFenp::crit_cal3d(int n1,int n2,int n3,int n4)
{
float x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4,crits;
double ab[4],ac[4],cb[4],dac,dab,dcb,dmax,crit;
double db[4],da[4],dc[4],dda,ddb,ddc,pvec[4],vol,som;

x1=point[n1].x;y1=point[n1].y;z1=point[n1].z;
x2=point[n2].x;y2=point[n2].y;z2=point[n2].z;
x3=point[n3].x;y3=point[n3].y;z3=point[n3].z;
x4=point[n4].x;y4=point[n4].y;z4=point[n4].z;
ab[0]=x2-x1;ab[1]=y2-y1;ab[2]=z2-z1;
ac[0]=x3-x1;ac[1]=y3-y1;ac[2]=z3-z1;
cb[0]=x2-x3;cb[1]=y2-y3;cb[2]=z2-z3;
db[0]=x2-x4;db[1]=y2-y4;db[2]=z2-z4;
da[0]=x1-x4;da[1]=y1-y4;da[2]=z1-z4;
dc[0]=x3-x4;dc[1]=y3-y4;dc[2]=z3-z4;
dab=sqrt(ab[0]*ab[0]+ab[1]*ab[1]+ab[2]*ab[2]);
dac=sqrt(ac[0]*ac[0]+ac[1]*ac[1]+ac[2]*ac[2]);
dcb=sqrt(cb[0]*cb[0]+cb[1]*cb[1]+cb[2]*cb[2]);
ddb=sqrt(db[0]*db[0]+db[1]*db[1]+db[2]*db[2]);
dda=sqrt(da[0]*da[0]+da[1]*da[1]+da[2]*da[2]);
ddc=sqrt(dc[0]*dc[0]+dc[1]*dc[1]+dc[2]*dc[2]);
dmax=dab;
if (dac>dmax)dmax=dac;
if (dcb>dmax)dmax=dcb;
if (ddb>dmax)dmax=ddb;
if (dda>dmax)dmax=dda;
if (ddc>dmax)dmax=ddc;
PVEC(pvec,ab,ac);
vol=pvec[0]*da[0]+pvec[1]*da[1]+pvec[2]*da[2];
if (vol>0.) return(0.);
vol=fabs(vol);
NORME(pvec);
som=pvec[3]/2.;
PVEC(pvec,ab,da);
NORME(pvec);
som=som+pvec[3]/2.;
PVEC(pvec,ac,dc);
NORME(pvec);
som=som+pvec[3]/2.;
PVEC(pvec,cb,db);
NORME(pvec);
som=som+pvec[3]/2.;
crit = vol/som ;
crit = (crit/dmax)/0.408249 ;
crits=(float)crit;
return(crits) ;
}
//---------------------------------------------------------------------------
void __fastcall TFenp::affiche_axe(void)
{
 int xc,yc;

 Fenp->Canvas->Pen->Color=clBlue;
 projection(25.,0.,0.,&xc,&yc,0);
 Fenp->Canvas->MoveTo(45,45);
 Fenp->Canvas->LineTo(45+xc,45+yc);
 Fenp->Canvas->Pen->Color=clRed;
 projection(0.,25.,0.,&xc,&yc,0);
 Fenp->Canvas->MoveTo(45,45);
 Fenp->Canvas->LineTo(45+xc,45+yc);
 Fenp->Canvas->Pen->Color=clWhite;
 projection(0.,0.,25.,&xc,&yc,0);
 Fenp->Canvas->MoveTo(45,45);
 Fenp->Canvas->LineTo(45+xc,45+yc);
 }
//---------------------------------------------------------------------------

void __fastcall TFenp::FormMouseDown(TObject *Sender, TMouseButton Button,
        TShiftState Shift, int X, int Y)
{
if (Button==mbRight)
        {
    trans=1;
    xtmp=X;
    ytmp=Y;
    }
}
//---------------------------------------------------------------------------
void __fastcall TFenp::FormMouseUp(TObject *Sender, TMouseButton Button,
        TShiftState Shift, int X, int Y)
{
 if (Button==mbRight)
        {
    if (trans==1)
        {
        xcentre=xcentre+X-xtmp;
        ycentre=ycentre+Y-ytmp;
        Invalidate();
        }
    trans=0;
        }
 }
//---------------------------------------------------------------------------
void __fastcall TFenp::Noeud1Click(TObject *Sender)
{
if (Noeud1->Checked==true) Noeud1->Checked=false; else Noeud1->Checked=true;
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Maille2Click(TObject *Sender)
{
if (Maille2->Checked==true) Maille2->Checked=false; else Maille2->Checked=true;
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::ancien1Click(TObject *Sender)
{
Ouvre(ancien_fichier[0]);
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::ancien2Click(TObject *Sender)
{
Ouvre(ancien_fichier[1]);
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::ancien3Click(TObject *Sender)
{
Ouvre(ancien_fichier[2]);
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::ancien4Click(TObject *Sender)
{
Ouvre(ancien_fichier[3]);
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Acismesh1Click(TObject *Sender)
{
char mess[255];
char arg1[255];
char arg2[255];
char arg3[255];
char arg4[255];
char arg5[255];
char arg6[255];
char arg7[255];
char arg8[255];
char arg9[255];
char arg10[255];
float dens,epsilon;
int opt=5;

epsilon=0.;
Igsoption->Edit2->Text="5";
Igsoption->GroupBox1->Caption=Fichier;
Igsoption->Label3->Enabled=true;
Igsoption->Edit3->Enabled=true;
Igsoption->RadioButton1->Enabled=true;
Igsoption->RadioButton2->Enabled=true;
Igsoption->ShowModal();
if (Igsoption->ok==1)
        {
    dens=0.;
    strcpy(mess,Igsoption->Edit1->Text.c_str());
    sscanf(mess,"%f",&dens);
        strcpy(mess,Igsoption->Edit2->Text.c_str());
    sscanf(mess,"%d",&opt);
    strcpy(mess,Igsoption->Edit3->Text.c_str());
    sscanf(mess,"%f",&epsilon);
    if (Igsoption->CheckBox1->Checked==true) strcpy(arg10,"-analyse"); else strcpy(arg10,"");
    if (Igsoption->RadioButton1->Checked==true) epsilon=(-epsilon);
    sprintf(arg1,"%s\\acismesh.exe",home);
    strcpy(arg2,"-fich");
    sprintf(arg3,"%s",Fichier);
    strcpy(arg4,"-dens");
    sprintf(arg5,"%f",dens);
        strcpy(arg6,"-opti2d");
    sprintf(arg7,"%d",opt);
        strcpy(arg8,"-epsilon");
    sprintf(arg9,"%f",epsilon);
    if ((epsilon<0.0001)&&(Igsoption->RadioButton2->Checked==true)) MessageBox(Handle,"Mauvaise valeur de epsilon","Erreur",0);
        else if ((epsilon>(-0.0001))&&(Igsoption->RadioButton1->Checked==true)) MessageBox(Handle,"Mauvaise valeur de epsilon","Erreur",0);
        else if (dens<0.0001) MessageBox(Handle,"Mauvaise valeur de densite","Erreur",0);
    else if (batch==false)  spawnl(P_NOWAIT,arg1,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,NULL);
    else fprintf(f_batch,"%s %s %s %s %s %s %s %s %s %s\n",arg1,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
        }
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Acismesh2Click(TObject *Sender)
{
char mess[255];
char arg1[255];
char arg2[255];
char arg3[255];
char arg4[255];
char arg5[255];
char arg6[255];
char arg7[255];
char arg8[255];
char arg9[255];
char arg10[255];
int opt=5;
float zone;

zone=0.;
Rigsoption->Label3->Enabled=true;
Rigsoption->Edit3->Enabled=true;
Rigsoption->CheckBox1->Enabled=true;
Rigsoption->Edit3->Text="1";
Rigsoption->Edit2->Text="5";
Rigsoption->GroupBox1->Caption=Fichier;
Rigsoption->ShowModal();
if (Rigsoption->ok==1)
        {
    strcpy(mess,Rigsoption->Edit2->Text.c_str());
    sscanf(mess,"%d",&opt);
    strcpy(mess,Rigsoption->Edit3->Text.c_str());
    sscanf(mess,"%f",&zone);
    if (Rigsoption->CheckBox1->Checked==true) strcpy(arg10,"-analyse"); else strcpy(arg10,"");
    mess[0]=0;
    strcpy(mess,Rigsoption->Edit1->Text.c_str());
    sprintf(arg1,"%s\\acismesh.exe",home);
    strcpy(arg2,"-fich");
    sprintf(arg3,"%s",Fichier);
        strcpy(arg4,"-mesh");
    strcpy(arg5,mess);
    strcpy(arg6,"-opti2d");
    sprintf(arg7,"%d",opt);
    strcpy(arg8,"-zone");
    sprintf(arg9,"%f",zone);
    chdir(home);
    if (zone<=0.0001)  MessageBox(Handle,"Mauvaise valeur de zone","Erreur",0);
    else if (mess[0]==0) MessageBox(Handle,"Pas de fichier modele","Erreur",0);
    else if (batch==false) spawnl(P_NOWAIT,arg1,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,NULL);
    else fprintf(f_batch,"%s %s %s %s %s %s %s %s %s %s \n",arg1,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    }

}
//---------------------------------------------------------------------------
void __fastcall TFenp::Face1Click(TObject *Sender)
{
Face->ShowModal();
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Mailleur1Click(TObject *Sender)
{
char fich[255],mess[255];
FILE *fic;

Diamesh1->Enabled=false;
if (batch==true) Diamesh1->Enabled=true;
if (Acismesh1->Enabled==true)
        {
    strcpy(fich,Fichier);
        fich[strlen(fich)-4]=0;
        strcpy(mess,fich);
        strcat(mess,"_2D.mai");
        fic=fopen(mess,"rt");
        if (fic!=NULL)
                {
        Diamesh1->Enabled=true;
        fclose(fic);
        }
    }
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Diamesh1Click(TObject *Sender)
{
char arg1[255];
char arg2[255];
char arg3[255];
char arg4[255];
char arg5[255];

Diaoption->GroupBox1->Caption=Fichier;
Diaoption->CheckBox1->Enabled=true;
Diaoption->ShowModal();
if (Diaoption->ok==1)
        {
    sprintf(arg1,"%s\\diamesh.exe",home);
    strcpy(arg2,"-file");
    sprintf(arg3,"%s",Fichier);
        arg3[strlen(arg3)-4]=0;
    strcat(arg3,"_2D.mai");
    if (Diaoption->CheckBox1->Checked==true) strcpy(arg4,"-skin"); else strcpy(arg4,"");
    if (Diaoption->CheckBox2->Checked==true) strcpy(arg5,"-nosmooth"); else strcpy(arg5,"");
    if (batch==false) spawnl(P_NOWAIT,arg1,arg1,arg2,arg3,arg4,arg5,NULL);
    else fprintf(f_batch,"%s %s %s %s %s\n",arg1,arg1,arg2,arg3,arg4,arg5);
    }

}
//---------------------------------------------------------------------------
void __fastcall TFenp::Aproposde2Click(TObject *Sender)
{
Application->CreateForm(__classid(Tsignature), &signature);
signature->Left=Fenp->Left+29;
signature->Top=Fenp->Top+37;
signature->ShowModal();

}
//---------------------------------------------------------------------------
void __fastcall TFenp::ConfigureShade1Click(TObject *Sender)
{
Application->CreateForm(__classid(TCcolor), &Ccolor);
Ccolor->Left=(int)((Screen->Width-Ccolor->Width)/2.);
Ccolor->Top=(int)((Screen->Height-Ccolor->Height)/2.);
Ccolor->ShowModal();
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Toolbar1Click(TObject *Sender)
{
Affichetoolbar();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Affichetoolbar(void)
{
    if (existetool==0)
        {
    Application->CreateForm(__classid(TToolbar), &Toolbar);
        Toolbar->Show();
        }
}

void __fastcall TFenp::FormShow(TObject *Sender)
{
static pass=0;
if ((tool==1) && (pass==0))
        {
    pass=1;
    Affichetoolbar();
    }
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Enregistrerconfiguration1Click(TObject *Sender)
{
wininit();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Remaillage3D1Click(TObject *Sender)
{
int i,j;
FILE *fic;
char fich[255];
char mess[255];

Geometrie1->Checked=false;
Front3D1->Checked=false;
Maillage1D1->Checked=false;
Maillage2D1->Checked=false;
Remaillage2D1->Checked=false;
Maillage3D1->Checked=false;
Maillage3D2->Checked=false;
Remaillage3D1->Checked=true;
Face1->Enabled=false;
Aucun1->Checked=false;
Activerlerendu3D1->Enabled=true;
Activerlerendu3D1->Checked=false;
if (point!=NULL) free(point);
if (segment!=NULL) free(segment);
if (triangle!=NULL) free(triangle);
if (tetra!=NULL) free(tetra);
nb_point=0;point=NULL;
nb_segment=0;segment=NULL;
nb_triangle=0;triangle=NULL;
nb_tetra=0;tetra=NULL;
tete=NULL;
strcpy(fich,Fichier);
fich[strlen(fich)-4]=0;
strcat(fich,"r_3D.mai");
fic=fopen(fich,"rt");
fgets(mess,255,fic);
sscanf(mess,"%d %d",&nb_point,&nb_tetra);
point=(struct s_point *)calloc(nb_point,sizeof(struct s_point));
tetra=(struct s_tetra *)calloc(nb_tetra,sizeof(struct s_tetra));
xpiece=0.;ypiece=0.;zpiece=0.;
for (i=0;i<nb_point;i++)
        {
    fgets(mess,255,fic);
    sscanf(mess,"%d %f %f %f",&j,&point[i].x,&point[i].y,&point[i].z);
    if (i==0)
        {
        xmin=point[i].x;
        xmax=point[i].x;
        ymin=point[i].y;
        ymax=point[i].y;
        zmin=point[i].z;
        zmax=point[i].z;
        maxcoord=point[i].x;
        }
    if (point[i].x<xmin) xmin=point[i].x;
    if (point[i].x>xmax) xmax=point[i].x;
    if (point[i].y<ymin) ymin=point[i].y;
    if (point[i].y>ymax) ymax=point[i].y;
    if (point[i].z<zmin) zmin=point[i].z;
    if (point[i].z>zmax) zmax=point[i].z;
    if (fabs((double)point[i].x)>maxcoord) maxcoord=(float)fabs((double)point[i].x);
    if (fabs((double)point[i].y)>maxcoord) maxcoord=(float)fabs((double)point[i].y);
    if (fabs((double)point[i].z)>maxcoord) maxcoord=(float)fabs((double)point[i].z);
    xpiece=xpiece+point[i].x;
    ypiece=ypiece+point[i].y;
    zpiece=zpiece+point[i].z;
    }
xpiece=xpiece/nb_point;
ypiece=ypiece/nb_point;
zpiece=zpiece/nb_point;
for (i=0;i<nb_tetra;i++)
        {
    fgets(mess,255,fic);
    sscanf(mess,"%d %d %d %d %d",&j,&tetra[i].n1,&tetra[i].n2,&tetra[i].n3,&tetra[i].n4);
    tetra[i].n1=tetra[i].n1-1;
    tetra[i].n2=tetra[i].n2-1;
    tetra[i].n3=tetra[i].n3-1;
    tetra[i].n4=tetra[i].n4-1;
    tetra[i].num=i;
    point[tetra[i].n1].tetra[point[tetra[i].n1].nb_tetra]=&(tetra[i]);
    point[tetra[i].n1].nb_tetra++;
    point[tetra[i].n2].tetra[point[tetra[i].n2].nb_tetra]=&(tetra[i]);
    point[tetra[i].n2].nb_tetra++;
    point[tetra[i].n3].tetra[point[tetra[i].n3].nb_tetra]=&(tetra[i]);
    point[tetra[i].n3].nb_tetra++;
    point[tetra[i].n4].tetra[point[tetra[i].n4].nb_tetra]=&(tetra[i]);
    point[tetra[i].n4].nb_tetra++;
    }
fclose(fic);
if (passe_norme==0)
        {
    norme();
    passe_norme=1;
    }
Invalidate();

}
//---------------------------------------------------------------------------
void __fastcall TFenp::Remaillage2D1Click(TObject *Sender)
{
int i,j;
FILE *fic;
int *test_face,maxface;
char fich[255];
char mess[255];

Geometrie1->Checked=false;
Front3D1->Checked=false;
Maillage1D1->Checked=false;
Maillage2D1->Checked=false;
Remaillage2D1->Checked=true;
Maillage3D1->Checked=false;
Maillage3D2->Checked=false;
Remaillage3D1->Checked=false;
Activerlerendu3D1->Enabled=false;
Activerlerendu3D1->Checked=false;
Aucun1->Checked=false;
Face1->Enabled=true;
Face->ListBox1->Items->Clear();
Face->ListBox1->Items->Add("Toutes");
Face->ListBox1->ItemIndex=0;
Fenp->numface=(-1);
if (point!=NULL) free(point);
if (segment!=NULL) free(segment);
if (triangle!=NULL) free(triangle);
if (tetra!=NULL) free(tetra);
nb_point=0;point=NULL;
nb_segment=0;segment=NULL;
nb_triangle=0;triangle=NULL;
nb_tetra=0;tetra=NULL;
tete=NULL;
strcpy(fich,Fichier);
fich[strlen(fich)-4]=0;
strcat(fich,"r_2D.mai");
fic=fopen(fich,"rt");
fgets(mess,255,fic);
sscanf(mess,"%d %d",&nb_point,&nb_triangle);
point=(struct s_point *)calloc(nb_point,sizeof(struct s_point));
triangle=(struct s_triangle *)calloc(nb_triangle,sizeof(struct s_triangle));
xpiece=0.;ypiece=0.;zpiece=0.;
for (i=0;i<nb_point;i++)
        {
    fgets(mess,255,fic);
    sscanf(mess,"%d %f %f %f",&j,&point[i].x,&point[i].y,&point[i].z);
    if (i==0)
        {
        xmin=point[i].x;
        xmax=point[i].x;
        ymin=point[i].y;
        ymax=point[i].y;
        zmin=point[i].z;
        zmax=point[i].z;
        maxcoord=point[i].x;
        }
    if (point[i].x<xmin) xmin=point[i].x;
    if (point[i].x>xmax) xmax=point[i].x;
    if (point[i].y<ymin) ymin=point[i].y;
    if (point[i].y>ymax) ymax=point[i].y;
    if (point[i].z<zmin) zmin=point[i].z;
    if (point[i].z>zmax) zmax=point[i].z;
    if (fabs((double)point[i].x)>maxcoord) maxcoord=(float)fabs((double)point[i].x);
    if (fabs((double)point[i].y)>maxcoord) maxcoord=(float)fabs((double)point[i].y);
    if (fabs((double)point[i].z)>maxcoord) maxcoord=(float)fabs((double)point[i].z);
    xpiece=xpiece+point[i].x;
    ypiece=ypiece+point[i].y;
    zpiece=zpiece+point[i].z;
    }
xpiece=xpiece/nb_point;
ypiece=ypiece/nb_point;
zpiece=zpiece/nb_point;
maxface=0;
for (i=0;i<nb_triangle;i++)
    {
    fgets(mess,255,fic);
    sscanf(mess,"%d %d %d %d %s %d",&j,&triangle[i].n1,&triangle[i].n2,&triangle[i].n3,&triangle[i].type,&triangle[i].num_ent);
    triangle[i].n1=triangle[i].n1-1;
    triangle[i].n2=triangle[i].n2-1;
    triangle[i].n3=triangle[i].n3-1;
    triangle[i].num=i;
    if (triangle[i].num_ent>maxface) maxface=triangle[i].num_ent;
    point[triangle[i].n1].triangle[point[triangle[i].n1].nb_triangle]=&(triangle[i]);
    point[triangle[i].n1].nb_triangle++;
    point[triangle[i].n2].triangle[point[triangle[i].n2].nb_triangle]=&(triangle[i]);
    point[triangle[i].n2].nb_triangle++;
    point[triangle[i].n3].triangle[point[triangle[i].n3].nb_triangle]=&(triangle[i]);
    point[triangle[i].n3].nb_triangle++;
    }
fclose(fic);
test_face=(int *)calloc(maxface+1,sizeof(int));
for (i=0;i<nb_triangle;i++)
    test_face[triangle[i].num_ent]=1;
for (i=0;i<maxface+1;i++)
    if (test_face[i]==1)
        {
        sprintf(mess,"%d",i);
        Face->ListBox1->Items->Add(mess);
        }
free(test_face);
if (passe_norme==0)
        {
    norme();
    passe_norme=1;
    }
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Imprimer1Click(TObject *Sender)
{
char mess[255];

strcpy(info,"Entrez la dimension du graphique en pourcentage de la feuille ?");
Valeur->Edit1->Text="100";
Valeur->ShowModal();
strcpy(mess,Valeur->Edit1->Text.c_str());
sscanf(mess,"%f",&rapport);
rapport=rapport/100.;
if (PrintDialog1->Execute()) imprime();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Configurationdelimpression1Click(TObject *Sender)
{
PrinterSetupDialog1->Execute();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Activerlerendu3D1Click(TObject *Sender)
{
int i,j,nb_tri=0,nb_tri2,gtrouve1,gtrouve2,gtrouve3,gtrouve4;
struct s_triangle *tri,*tr;

Fenp->Cursor=crHourGlass;
if (Activerlerendu3D1->Checked==false)
        {
    Activerlerendu3D1->Checked=true;
    tri=(struct s_triangle *)calloc(nb_tetra*4,sizeof(struct s_triangle));
    for (i=0;i<nb_tetra;i++)
        {
        gtrouve1=(-1);
        gtrouve2=(-1);
        gtrouve3=(-1);
        gtrouve4=(-1);
        for (j=0;j<point[tetra[i].n1].nb_triangle;j++)
                {
            tr=point[tetra[i].n1].triangle[j];
            if (((tr->n1==tetra[i].n1) && (tr->n2==tetra[i].n2) && (tr->n3==tetra[i].n3))
             || ((tr->n1==tetra[i].n1) && (tr->n3==tetra[i].n2) && (tr->n2==tetra[i].n3))
             || ((tr->n2==tetra[i].n1) && (tr->n1==tetra[i].n2) && (tr->n3==tetra[i].n3))
             || ((tr->n2==tetra[i].n1) && (tr->n3==tetra[i].n2) && (tr->n1==tetra[i].n3))
             || ((tr->n3==tetra[i].n1) && (tr->n1==tetra[i].n2) && (tr->n2==tetra[i].n3))
             || ((tr->n3==tetra[i].n1) && (tr->n2==tetra[i].n2) && (tr->n1==tetra[i].n3)))
                gtrouve1=tr->num;
            if (((tr->n1==tetra[i].n1) && (tr->n2==tetra[i].n2) && (tr->n3==tetra[i].n4))
             || ((tr->n1==tetra[i].n1) && (tr->n3==tetra[i].n2) && (tr->n2==tetra[i].n4))
             || ((tr->n2==tetra[i].n1) && (tr->n1==tetra[i].n2) && (tr->n3==tetra[i].n4))
             || ((tr->n2==tetra[i].n1) && (tr->n3==tetra[i].n2) && (tr->n1==tetra[i].n4))
             || ((tr->n3==tetra[i].n1) && (tr->n1==tetra[i].n2) && (tr->n2==tetra[i].n4))
             || ((tr->n3==tetra[i].n1) && (tr->n2==tetra[i].n2) && (tr->n1==tetra[i].n4)))
                gtrouve3=tr->num;
            if (((tr->n1==tetra[i].n1) && (tr->n2==tetra[i].n3) && (tr->n3==tetra[i].n4))
             || ((tr->n1==tetra[i].n1) && (tr->n3==tetra[i].n3) && (tr->n2==tetra[i].n4))
             || ((tr->n2==tetra[i].n1) && (tr->n1==tetra[i].n3) && (tr->n3==tetra[i].n4))
             || ((tr->n2==tetra[i].n1) && (tr->n3==tetra[i].n3) && (tr->n1==tetra[i].n4))
             || ((tr->n3==tetra[i].n1) && (tr->n1==tetra[i].n3) && (tr->n2==tetra[i].n4))
             || ((tr->n3==tetra[i].n1) && (tr->n2==tetra[i].n3) && (tr->n1==tetra[i].n4)))
                gtrouve4=tr->num;
            }
        if (gtrouve1==(-1))
                {
            tri[nb_tri].n1=tetra[i].n1;
                        tri[nb_tri].n2=tetra[i].n2;
                        tri[nb_tri].n3=tetra[i].n3;
            tri[nb_tri].num_ent=1;
            tri[nb_tri].num=nb_tri;
            point[tri[nb_tri].n1].triangle[point[tri[nb_tri].n1].nb_triangle]=&tri[nb_tri];
            (point[tri[nb_tri].n1].nb_triangle)++;
            point[tri[nb_tri].n2].triangle[point[tri[nb_tri].n2].nb_triangle]=&tri[nb_tri];
            (point[tri[nb_tri].n2].nb_triangle)++;
            point[tri[nb_tri].n3].triangle[point[tri[nb_tri].n3].nb_triangle]=&tri[nb_tri];
            (point[tri[nb_tri].n3].nb_triangle)++;
            nb_tri++;
                        }
        else tri[gtrouve1].num_ent++;
                if (gtrouve3==(-1))
                {
            tri[nb_tri].n1=tetra[i].n1;
                        tri[nb_tri].n2=tetra[i].n2;
                        tri[nb_tri].n3=tetra[i].n4;
            tri[nb_tri].num=nb_tri;
            tri[nb_tri].num_ent=1;
            point[tri[nb_tri].n1].triangle[point[tri[nb_tri].n1].nb_triangle]=&tri[nb_tri];
            (point[tri[nb_tri].n1].nb_triangle)++;
            point[tri[nb_tri].n2].triangle[point[tri[nb_tri].n2].nb_triangle]=&tri[nb_tri];
            (point[tri[nb_tri].n2].nb_triangle)++;
            point[tri[nb_tri].n3].triangle[point[tri[nb_tri].n3].nb_triangle]=&tri[nb_tri];
            (point[tri[nb_tri].n3].nb_triangle)++;
            nb_tri++;
                        }
        else tri[gtrouve3].num_ent++;
        if (gtrouve4==(-1))
                {
            tri[nb_tri].n1=tetra[i].n1;
                        tri[nb_tri].n2=tetra[i].n3;
                        tri[nb_tri].n3=tetra[i].n4;
            tri[nb_tri].num=nb_tri;
            tri[nb_tri].num_ent=1;
            point[tri[nb_tri].n1].triangle[point[tri[nb_tri].n1].nb_triangle]=&tri[nb_tri];
            (point[tri[nb_tri].n1].nb_triangle)++;
            point[tri[nb_tri].n2].triangle[point[tri[nb_tri].n2].nb_triangle]=&tri[nb_tri];
            (point[tri[nb_tri].n2].nb_triangle)++;
            point[tri[nb_tri].n3].triangle[point[tri[nb_tri].n3].nb_triangle]=&tri[nb_tri];
            (point[tri[nb_tri].n3].nb_triangle)++;
            nb_tri++;
                        }
        else tri[gtrouve4].num_ent++;
        for (j=0;j<point[tetra[i].n2].nb_triangle;j++)
                        {
            tr=point[tetra[i].n2].triangle[j];
            if (((tr->n1==tetra[i].n2) && (tr->n2==tetra[i].n3) && (tr->n3==tetra[i].n4))
                || ((tr->n1==tetra[i].n2) && (tr->n3==tetra[i].n3) && (tr->n2==tetra[i].n4))
                || ((tr->n2==tetra[i].n2) && (tr->n1==tetra[i].n3) && (tr->n3==tetra[i].n4))
                || ((tr->n2==tetra[i].n2) && (tr->n3==tetra[i].n3) && (tr->n1==tetra[i].n4))
                || ((tr->n3==tetra[i].n2) && (tr->n1==tetra[i].n3) && (tr->n2==tetra[i].n4))
                || ((tr->n3==tetra[i].n2) && (tr->n2==tetra[i].n3) && (tr->n1==tetra[i].n4)))
                gtrouve2=tr->num;
            }
        if (gtrouve2==(-1))
                {
            tri[nb_tri].n1=tetra[i].n2;
                        tri[nb_tri].n2=tetra[i].n3;
                        tri[nb_tri].n3=tetra[i].n4;
            tri[nb_tri].num=nb_tri;
            tri[nb_tri].num_ent=1;
            point[tri[nb_tri].n1].triangle[point[tri[nb_tri].n1].nb_triangle]=&tri[nb_tri];
            (point[tri[nb_tri].n1].nb_triangle)++;
            point[tri[nb_tri].n2].triangle[point[tri[nb_tri].n2].nb_triangle]=&tri[nb_tri];
            (point[tri[nb_tri].n2].nb_triangle)++;
            point[tri[nb_tri].n3].triangle[point[tri[nb_tri].n3].nb_triangle]=&tri[nb_tri];
            (point[tri[nb_tri].n3].nb_triangle)++;
                nb_tri++;
                        }
        else tri[gtrouve2].num_ent++;

                }

    nb_triangle=0;nb_tri2=0;
    for (i=0;i<nb_tri;i++)
        if (tri[i].num_ent==1) nb_triangle++;
    triangle=(struct s_triangle *)calloc(nb_triangle,sizeof(struct s_triangle));
    for (i=0;i<nb_point;i++)
        point[i].nb_triangle=0;
    for (i=0;i<nb_tri;i++)
        if (tri[i].num_ent==1)
                {
            triangle[nb_tri2].n1=tri[i].n1;
            triangle[nb_tri2].n2=tri[i].n2;
            triangle[nb_tri2].n3=tri[i].n3;
            triangle[nb_tri2].num=nb_tri2;
            point[triangle[nb_tri2].n1].triangle[point[triangle[nb_tri2].n1].nb_triangle]=&(triangle[nb_tri2]);
                        (point[triangle[nb_tri2].n1].nb_triangle)++;
            point[triangle[nb_tri2].n2].triangle[point[triangle[nb_tri2].n2].nb_triangle]=&(triangle[nb_tri2]);
                        (point[triangle[nb_tri2].n2].nb_triangle)++;
            point[triangle[nb_tri2].n3].triangle[point[triangle[nb_tri2].n3].nb_triangle]=&(triangle[nb_tri2]);
                        (point[triangle[nb_tri2].n3].nb_triangle)++;
            nb_tri2++;
            }
    free(tri);
    }
Fenp->Cursor=crDefault;
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Purgerletude1Click(TObject *Sender)
{
char fich[500],mess[500];

strcpy(fich,Fichier);
fich[strlen(fich)-4]=0;

strcpy(mess,fich);
strcat(mess,".oct");
remove(mess);
strcpy(mess,fich);
strcat(mess,".qua");
remove(mess);
strcpy(mess,fich);
strcat(mess,".geo");
remove(mess);
strcpy(mess,fich);
strcat(mess,".res");
remove(mess);
strcpy(mess,fich);
strcat(mess,"_1D.mai");
remove(mess);
strcpy(mess,fich);
strcat(mess,"_2D.mai");
remove(mess);
strcpy(mess,fich);
strcat(mess,"_3D.mai");
remove(mess);
strcpy(mess,fich);
strcat(mess,"_2D.skin");
remove(mess);
strcpy(mess,fich);
strcat(mess,"_2D.res");
remove(mess);
strcpy(mess,fich);
strcat(mess,"r_2D.mai");
remove(mess);
strcpy(mess,fich);
strcat(mess,"r_3D.mai");
remove(mess);
strcpy(mess,fich);
strcat(mess,"c_3D.mai");
remove(mess);
strcpy(mess,fich);
strcat(mess,"r_2D.skin");
remove(mess);
strcpy(mess,fich);
strcat(mess,"r_2D.res");
remove(mess);
strcpy(mess,fich);
strcat(mess,"_2D.REC");
remove(mess);
strcpy(mess,fich);
strcat(mess,"r_2D.REC");
remove(mess);
strcpy(mess,fich);
strcat(mess,"f_2D.REC");
remove(mess);
}
//---------------------------------------------------------------------------
void __fastcall TFenp::CreerunesessionClick(TObject *Sender)
{
char mess[255];

OpenDialog2->InitialDir=dir_defaut;
if (OpenDialog2->Execute()==true)
        {
    Creerunesession->Enabled=false;
        Fermerlasession1->Enabled=true;
        batch=true;
    strcpy(mess,OpenDialog2->FileName.c_str());
    strcat(mess,".ses");
    f_batch=fopen(mess,"wt");
        }
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Fermerlasession1Click(TObject *Sender)
{
Creerunesession->Enabled=true;
Fermerlasession1->Enabled=false;
batch=false;
fclose(f_batch);
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Lancerunesession1Click(TObject *Sender)
{
Application->CreateForm(__classid(Tcsession), &csession);

csession->ShowModal();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Paramesh1Click(TObject *Sender)
{
char mess[255];
char arg1[255];
char arg2[255];
char arg3[255];
char arg4[255];
char arg5[255];
char arg6[255];
char arg7[255];
char arg8[255];
char arg9[255];
char arg10[255];
int opt=5;

Rigsoption->Label3->Enabled=false;
Rigsoption->Edit3->Enabled=false;
Rigsoption->Edit2->Text="5";
Rigsoption->CheckBox1->Enabled=true;
Rigsoption->GroupBox1->Caption=Fichier;
Rigsoption->ShowModal();
if (Rigsoption->ok==1)
        {
    strcpy(mess,Rigsoption->Edit2->Text.c_str());
    sscanf(mess,"%d",&opt);
    mess[0]=0;
    strcpy(mess,Rigsoption->Edit1->Text.c_str());
    sprintf(arg1,"%s\\paramesh.exe",home);
    strcpy(arg2,"-fich");
    sprintf(arg3,"%s",Fichier);
        strcpy(arg4,"-mesh");
    strcpy(arg5,mess);
    strcpy(arg6,"-opti2d");
    sprintf(arg7,"%d",opt);
    if (Rigsoption->CheckBox1->Checked==true) strcpy(arg8,"-analyse"); else strcpy(arg8,"");
    chdir(home);
    if (mess[0]==0) MessageBox(Handle,"Pas de fichier modele","Erreur",0);
    else if (batch==false) spawnl(P_NOWAIT,arg1,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,NULL);
    else fprintf(f_batch,"%s %s %s %s %s %s %s %s %s %s \n",arg1,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    }

}
//---------------------------------------------------------------------------
void __fastcall TFenp::Maillage3D2Click(TObject *Sender)
{
int i,j;
FILE *fic;
char fich[255];
char mess[255];

Geometrie1->Checked=false;
Maillage1D1->Checked=false;
Front3D1->Checked=false;
Maillage2D1->Checked=false;
Remaillage2D1->Checked=false;
Maillage3D1->Checked=false;
Maillage3D2->Checked=true;
Remaillage3D1->Checked=false;
Activerlerendu3D1->Enabled=true;
Activerlerendu3D1->Checked=false;
Face1->Enabled=false;
Aucun1->Checked=false;
if (point!=NULL) free(point);
if (segment!=NULL) free(segment);
if (triangle!=NULL) free(triangle);
if (tetra!=NULL) free(tetra);
nb_point=0;point=NULL;
nb_segment=0;segment=NULL;
nb_triangle=0;triangle=NULL;
nb_tetra=0;tetra=NULL;
tete=NULL;
strcpy(fich,Fichier);
fich[strlen(fich)-4]=0;
strcat(fich,"c_3D.mai");
fic=fopen(fich,"rt");
fgets(mess,255,fic);
sscanf(mess,"%d %d",&nb_point,&nb_tetra);
point=(struct s_point *)calloc(nb_point,sizeof(struct s_point));
tetra=(struct s_tetra *)calloc(nb_tetra,sizeof(struct s_tetra));
xpiece=0.;ypiece=0.;zpiece=0.;
for (i=0;i<nb_point;i++)
        {
    fgets(mess,255,fic);
    sscanf(mess,"%d %f %f %f",&j,&point[i].x,&point[i].y,&point[i].z);
    if (i==0)
        {
        xmin=point[i].x;
        xmax=point[i].x;
        ymin=point[i].y;
        ymax=point[i].y;
        zmin=point[i].z;
        zmax=point[i].z;
        maxcoord=point[i].x;
        }
    if (point[i].x<xmin) xmin=point[i].x;
    if (point[i].x>xmax) xmax=point[i].x;
    if (point[i].y<ymin) ymin=point[i].y;
    if (point[i].y>ymax) ymax=point[i].y;
    if (point[i].z<zmin) zmin=point[i].z;
    if (point[i].z>zmax) zmax=point[i].z;
    if (fabs((double)point[i].x)>maxcoord) maxcoord=(float)fabs((double)point[i].x);
    if (fabs((double)point[i].y)>maxcoord) maxcoord=(float)fabs((double)point[i].y);
    if (fabs((double)point[i].z)>maxcoord) maxcoord=(float)fabs((double)point[i].z);
    xpiece=xpiece+point[i].x;
    ypiece=ypiece+point[i].y;
    zpiece=zpiece+point[i].z;
    }
xpiece=xpiece/nb_point;
ypiece=ypiece/nb_point;
zpiece=zpiece/nb_point;
for (i=0;i<nb_tetra;i++)
        {
    fgets(mess,255,fic);
    sscanf(mess,"%d %d %d %d %d",&j,&tetra[i].n1,&tetra[i].n2,&tetra[i].n3,&tetra[i].n4);
    tetra[i].n1=tetra[i].n1-1;
    tetra[i].n2=tetra[i].n2-1;
    tetra[i].n3=tetra[i].n3-1;
    tetra[i].n4=tetra[i].n4-1;
    tetra[i].num=i;
    point[tetra[i].n1].tetra[point[tetra[i].n1].nb_tetra]=&(tetra[i]);
    point[tetra[i].n1].nb_tetra++;
    point[tetra[i].n2].tetra[point[tetra[i].n2].nb_tetra]=&(tetra[i]);
    point[tetra[i].n2].nb_tetra++;
    point[tetra[i].n3].tetra[point[tetra[i].n3].nb_tetra]=&(tetra[i]);
    point[tetra[i].n3].nb_tetra++;
    point[tetra[i].n4].tetra[point[tetra[i].n4].nb_tetra]=&(tetra[i]);
    point[tetra[i].n4].nb_tetra++;
    }
fclose(fic);
if (passe_norme==0)
        {
    norme();
    passe_norme=1;
    }
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Editeur1Click(TObject *Sender)
{
Application->CreateForm(__classid(TEditeur), &Editeur);
Editeur->Show();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Transsat1Click(TObject *Sender)
{
char arg1[255];

sprintf(arg1,"%s\\transsat.exe",home);
spawnl(P_NOWAIT,arg1,arg1,NULL);
}
//---------------------------------------------------------------------------
void __fastcall TFenp::ContourInactif1Click(TObject *Sender)
{
if (ContourInactif1->Checked==true) ContourInactif1->Checked=false;
        else ContourInactif1->Checked=true;
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Barrevisible1Click(TObject *Sender)
{
if (Barrevisible1->Checked==false) Barrevisible1->Checked=true;
else Barrevisible1->Checked=false;
if (existetool!=0)
        if (Barrevisible1->Checked==false) Toolbar->FormStyle=fsNormal;
        else Toolbar->FormStyle=fsStayOnTop;
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Front3D1Click(TObject *Sender)
{
int i,j;
FILE *fic;
int *test_face,maxface;
char fich[255];
char mess[255];

Geometrie1->Checked=false;
Maillage1D1->Checked=false;
Front3D1->Checked=true;
Maillage2D1->Checked=false;
Remaillage2D1->Checked=false;
Maillage3D1->Checked=false;
Maillage3D2->Checked=false;
Remaillage3D1->Checked=false;
Activerlerendu3D1->Enabled=false;
Activerlerendu3D1->Checked=false;
Aucun1->Checked=false;
Face1->Enabled=true;
Face->ListBox1->Items->Clear();
Face->ListBox1->Items->Add("Toutes");
Face->ListBox1->ItemIndex=0;
Fenp->numface=(-1);
if (point!=NULL) free(point);
if (segment!=NULL) free(segment);
if (triangle!=NULL) free(triangle);
if (tetra!=NULL) free(tetra);
nb_point=0;point=NULL;
nb_segment=0;segment=NULL;
nb_triangle=0;triangle=NULL;
nb_tetra=0;tetra=NULL;
tete=NULL;
strcpy(fich,Fichier);
fich[strlen(fich)-4]=0;
strcat(fich,"f_2D.mai");
fic=fopen(fich,"rt");
fgets(mess,255,fic);
sscanf(mess,"%d %d",&nb_point,&nb_triangle);
point=(struct s_point *)calloc(nb_point,sizeof(struct s_point));
triangle=(struct s_triangle *)calloc(nb_triangle,sizeof(struct s_triangle));
xpiece=0.;ypiece=0.;zpiece=0.;
for (i=0;i<nb_point;i++)
        {
    fgets(mess,255,fic);
    sscanf(mess,"%d %f %f %f",&j,&point[i].x,&point[i].y,&point[i].z);
    if (i==0)
        {
        xmin=point[i].x;
        xmax=point[i].x;
        ymin=point[i].y;
        ymax=point[i].y;
        zmin=point[i].z;
        zmax=point[i].z;
        maxcoord=point[i].x;
        }
    if (point[i].x<xmin) xmin=point[i].x;
    if (point[i].x>xmax) xmax=point[i].x;
    if (point[i].y<ymin) ymin=point[i].y;
    if (point[i].y>ymax) ymax=point[i].y;
    if (point[i].z<zmin) zmin=point[i].z;
    if (point[i].z>zmax) zmax=point[i].z;
    if (fabs((double)point[i].x)>maxcoord) maxcoord=(float)fabs((double)point[i].x);
    if (fabs((double)point[i].y)>maxcoord) maxcoord=(float)fabs((double)point[i].y);
    if (fabs((double)point[i].z)>maxcoord) maxcoord=(float)fabs((double)point[i].z);
    xpiece=xpiece+point[i].x;
    ypiece=ypiece+point[i].y;
    zpiece=zpiece+point[i].z;
    }
xpiece=xpiece/nb_point;
ypiece=ypiece/nb_point;
zpiece=zpiece/nb_point;
maxface=0;
for (i=0;i<nb_triangle;i++)
        {
    fgets(mess,255,fic);
    sscanf(mess,"%d %d %d %d %s %d",&j,&triangle[i].n1,&triangle[i].n2,&triangle[i].n3,&triangle[i].type,&triangle[i].num_ent);
    triangle[i].n1=triangle[i].n1-1;
    triangle[i].n2=triangle[i].n2-1;
    triangle[i].n3=triangle[i].n3-1;
    triangle[i].num=i;
    if (triangle[i].num_ent>maxface) maxface=triangle[i].num_ent;
    point[triangle[i].n1].triangle[point[triangle[i].n1].nb_triangle]=&(triangle[i]);
    point[triangle[i].n1].nb_triangle++;
    point[triangle[i].n2].triangle[point[triangle[i].n2].nb_triangle]=&(triangle[i]);
    point[triangle[i].n2].nb_triangle++;
    point[triangle[i].n3].triangle[point[triangle[i].n3].nb_triangle]=&(triangle[i]);
    point[triangle[i].n3].nb_triangle++;
    }
fclose(fic);
test_face=(int *)calloc(maxface+1,sizeof(int));
for (i=0;i<nb_triangle;i++)
    test_face[triangle[i].num_ent]=1;
for (i=0;i<maxface+1;i++)
    if (test_face[i]==1)
        {
        sprintf(mess,"%d",i);
        Face->ListBox1->Items->Add(mess);
        }
free(test_face);
if (passe_norme==0)
        {
    norme();
    passe_norme=1;
    }
Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Enregistrerlhistoriquedesrotations1Click(TObject *Sender)
{
char mess[255];
FILE *out;

OpenDialog3->InitialDir=home;
if (OpenDialog3->Execute()==true)
        {
    strcpy(mess,OpenDialog3->FileName.c_str());
    strcat(mess,".ori");
    out=fopen(mess,"wt");
    fprintf(out,"%f\n",rot[0][0]);
    fprintf(out,"%f\n",rot[0][1]);
    fprintf(out,"%f\n",rot[0][2]);
    fprintf(out,"%f\n",rot[1][0]);
    fprintf(out,"%f\n",rot[1][1]);
    fprintf(out,"%f\n",rot[1][2]);
    fprintf(out,"%f\n",rot[2][0]);
    fprintf(out,"%f\n",rot[2][1]);
    fprintf(out,"%f\n",rot[2][2]);
    fclose(out);
    }

}
//---------------------------------------------------------------------------
void __fastcall TFenp::Chargeruneorientation1Click(TObject *Sender)
{
char mess[255];
FILE *out;

OpenDialog3->InitialDir=home;
if (OpenDialog3->Execute()==true)
        {
    strcpy(mess,OpenDialog3->FileName.c_str());
    out=fopen(mess,"rt");
    fgets(mess,255,out);
    sscanf(mess,"%f",&(rot[0][0]));
        fgets(mess,255,out);
    sscanf(mess,"%f",&(rot[0][1]));
        fgets(mess,255,out);
    sscanf(mess,"%f",&(rot[0][2]));
        fgets(mess,255,out);
    sscanf(mess,"%f",&(rot[1][0]));
        fgets(mess,255,out);
    sscanf(mess,"%f",&(rot[1][1]));
        fgets(mess,255,out);
    sscanf(mess,"%f",&(rot[1][2]));
        fgets(mess,255,out);
    sscanf(mess,"%f",&(rot[2][0]));
        fgets(mess,255,out);
    sscanf(mess,"%f",&(rot[2][1]));
        fgets(mess,255,out);
    sscanf(mess,"%f",&(rot[2][2]));
    fclose(out);
    Invalidate();
    }

}
//---------------------------------------------------------------------------
void __fastcall TFenp::InfoPice1Click(TObject *Sender)
{
Application->CreateForm(__classid(TInfo_piece), &Info_piece);
Info_piece->Left=Fenp->Left+29;
Info_piece->Top=Fenp->Top+37;
Info_piece->ShowModal();
}
//---------------------------------------------------------------------------
void __fastcall TFenp::Normal2Click(TObject *Sender)
{
int i;
if (Fenp->Normal2->Checked==false)
        {
        Fenp->Normal2->Checked=true;
        Fenp->Debug1->Checked=false;
        Fendebug->Close();
        Fenp->Left=posx;
        Fenp->Top=posy;
        Fenp->Width=posdx;
        Fenp->Height=posdy;
        Mai1->Enabled=true;
        Fichier1->Enabled=true;
        for (i=0;i<nb_segment;i++) segment[i].select=0;
        for (i=0;i<nb_triangle;i++) triangle[i].select=0;
        for (i=0;i<nb_tetra;i++) tetra[i].select=0;
        }
}
//---------------------------------------------------------------------------

void __fastcall TFenp::Debug1Click(TObject *Sender)
{
if (Geometrie1->Checked==true)
        {
        MessageBox(Handle,"Option interdite sur la geometrie","Erreur",0);
        return;
        }
if (Fenp->Debug1->Checked==false)
        {
        Fenp->Normal2->Checked=false;
        Fenp->Debug1->Checked=true;
        Application->CreateForm(__classid(TFendebug), &Fendebug);
        posx=Fenp->Left;
        posy=Fenp->Top;
        posdx=Fenp->Width;
        posdy=Fenp->Height;
        Fenp->Top=0;
        Fenp->Height=(int)(0.5*Screen->Height);
        Fendebug->Left=Fenp->Left;
        Fendebug->Top=Fenp->Height+1;
        Fendebug->Height=Screen->Height-Fendebug->Top;
        Fendebug->Width=Screen->Width-Fendebug->Left;
        Fendebug->Show();
        Mai1->Enabled=false;
        Fichier1->Enabled=false;
        }
}
//---------------------------------------------------------------------------

Revision:	3
Committed:	Tue Jun 12 12:42:51 2007 UTC (18 years, 2 months ago)
File size:	91496 byte(s)
Log Message: