LSst *LS_init(int dim,int ver,char typ,char mfree) {
LSst *lsst;
/* default values */
lsst = (LSst*)calloc(1,sizeof(LSst));
memset(&lsst->mesh,0,sizeof(Mesh));
/* solution structure */
memset(&lsst->sol,0,sizeof(Sol));
lsst->sol.cl = (Cl*)calloc(LS_CL,sizeof(Cl));
lsst->sol.mat = (Mat*)calloc(LS_MAT,sizeof(Mat));
lsst->sol.res = LS_RES;
lsst->sol.nit = LS_MAXIT;
lsst->sol.nbcl = 0;
lsst->sol.nmat = 0;
/* global parameters */
lsst->info.dim = dim;
lsst->info.ver = ver;
lsst->info.verb = '1';
lsst->info.zip = 0;
lsst->info.typ = typ;
lsst->info.mfree = mfree;
/* init timer */
tminit(lsst->info.ctim,TIMEMAX);
chrono(ON,&lsst->info.ctim[0]);
return(lsst);
}
VLst *VL_init(int dim,int ver,char typ,char mfree) {
VLst *vlst;
/* default values */
vlst = (VLst*)calloc(1,sizeof(VLst));
memset(&vlst->mesh,0,sizeof(Mesh));
/* solution structure */
memset(&vlst->sol,0,sizeof(Sol));
vlst->sol.cl = (Cl*)calloc(VL_CL,sizeof(Cl));
vlst->sol.mat = (Mat*)calloc(VL_MAT,sizeof(Mat));
vlst->sol.res = VL_RES;
vlst->sol.nit = VL_MAXIT;
vlst->sol.nbcl = 0;
vlst->sol.nmat = 0;
/* global parameters */
vlst->info.dim = dim;
vlst->info.ver = ver;
vlst->info.verb = '1';
vlst->info.zip = 0;
vlst->info.ls = 0;
vlst->info.mfree = mfree;
/* init timer */
tminit(vlst->info.ctim,TIMEMAX);
chrono(ON,&vlst->info.ctim[0]);
return(vlst);
}
int main(int argc,char *argv[]) {
int type;
char pwd[1024];
#ifdef ppc
if ( !getwd(pwd) ) exit(2);
#endif
fprintf(stdout," -- Medit, Release %s (%s)\n",ME_VER,ME_REL);
fprintf(stdout," %s.\n",ME_CPY);
fprintf(stdout," compiled: %s.\n\n",COMPIL);
/* trap exceptions */
signal(SIGABRT,excfun);
signal(SIGFPE,excfun);
signal(SIGILL,excfun);
signal(SIGSEGV,excfun);
signal(SIGTERM,excfun);
signal(SIGINT,excfun);
atexit(endcod);
tminit(ctim,TIMEMAX);
chrono(ON,&ctim[0]);
/* default values */
option = STANDARD;
saveimg = GL_FALSE;
imgtype = P6;
animate = FALSE;
morphing = FALSE;
fullscreen = FALSE;
animdep = 0;
animfin = 0;
ddebug = FALSE;
quiet = TRUE;//FALSE;
stereoMode = 0;
cv.nbm = cv.nbs = 0;
/* default value for popen */
dpopen = FALSE;
dpopenbin = FALSE;
dpopensol = FALSE;
/* init grafix */
parsar(argc,argv);
//printf("fin de parsar");
if ( option == ISOSURF ) {
fprintf(stdout,"ISOSURF");
if ( !medit0() ) exit(1);
if ( !medit1() ) exit(1);
return(0);
}
glutInit(&argc,argv);
//printf("fin de glutInit");
#ifdef ppc
chdir(pwd);
#endif
chrono(ON,&ctim[0]);
if ( stereoMode == MONO )
type = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH;
else
type = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STEREO;
glutInitDisplayMode(type);
if ( infogl ) grInfo();
/* call animate or normal mode */
if( dpopen == FALSE ){
switch (option) {
case STANDARD:
case SCHNAUZER:
if ( !medit0() ) exit(1);
if ( !medit1() ) exit(1);
break;
case SEQUENCE:
if ( !animat() ) exit(1);
break;
case SEQUENCE+PARTICLE:
if ( !animat() ) exit(1);
break;
case MORPHING:
if ( !medit0() ) exit(1);
if ( !modeMorphing() ) exit(1);
morphing = GL_FALSE;
break;
default:
fprintf(stderr," ## Unrecognized option %d\n",option);
exit(1);
break;
}
}
else{
switch (option) {
case STANDARD:
case SCHNAUZER:
if ( !medit0_popen() ) exit(1);
if ( !medit1() ) exit(1);
break;
case SEQUENCE:
if ( !animat() ) exit(1);
break;
case SEQUENCE+PARTICLE:
if ( !animat() ) exit(1);
break;
case MORPHING:
if ( !medit0_popen() ) exit(1);
if ( !modeMorphing() ) exit(1);
morphing = GL_FALSE;
break;
default:
fprintf(stderr," ## Unrecognized option %d\n",option);
exit(1);
break;
}
}
/* main grafix loop */
fprintf(stdout,"\n Rendering scene(s)\n");
glGetBooleanv(GL_STEREO,&hasStereo);
glutMainLoop();
return(0);
}
int MSHMET_mshmet(int intopt[7], double fopt[4], pMesh mesh, pSol sol){
Info *info;
fprintf(stdout," -- MSHMET, Release %s (%s) \n",MS_VER,MS_REL);
fprintf(stdout," %s\n",MS_CPY);
fprintf(stdout," %s\n",COMPIL);
/* trap exceptions */
signal(SIGABRT,mshmet_excfun);
signal(SIGFPE,mshmet_excfun);
signal(SIGILL,mshmet_excfun);
signal(SIGSEGV,mshmet_excfun);
signal(SIGTERM,mshmet_excfun);
signal(SIGINT,mshmet_excfun);
//atexit(mshmet_endcod);
tminit(mshmet_ctim,TIMEMAX);
chrono(ON,&mshmet_ctim[0]);
chrono(ON,&mshmet_ctim[1]);
/* default */
info = &mesh->info;
info->hmin = (float) fopt[0]; // 0.01;
info->hmax = (float) fopt[1]; // 1.0;
info->eps = (float) fopt[2]; // 0.01;
info->width = (float) fopt[3]; // 0.05;
info->nnu = intopt[0]; // 0;
info->iso = intopt[1]; // 0;
info->ls = intopt[2]; // 0;
info->ddebug = intopt[3]; // 0;
info->imprim = intopt[4]; // 10;
info->nlis = intopt[5]; // 0;
info->bin = 1; // pas besoin c'est pour le fichier
info->nsol = -1; //-1; // pas besoin ==> on peut prendre plusieurs solutions en meme temps ???
info->metric = intopt[6]; // 0; // metric given besoin ???
MSHMET_setfunc(mesh);
chrono(OFF,&mshmet_ctim[1]);
if ( mesh->info.imprim ) mshmet_stats(mesh,sol);
fprintf(stdout," -- DATA READING COMPLETED. %.2f sec.\n",gttime(mshmet_ctim[1]));
fprintf(stdout,"\n %s\n MODULE MSHMET-LJLL : %s (%s)\n %s\n",
MS_STR,MS_VER,MS_REL,MS_STR);
/* analysis */
chrono(ON,&mshmet_ctim[2]);
if ( mesh->info.imprim ) fprintf(stdout,"\n -- PHASE 1 : ANALYSIS\n");
if ( abs(mesh->info.imprim) > 4 ) {
fprintf(stdout," ** SETTING ADJACENCIES\n");
fflush(stdout);
}
if ( !scaleMesh(mesh,sol) ) return(1);
if ( !hashel(mesh) ) exit(1);
chrono(OFF,&mshmet_ctim[2]);
if ( mesh->info.imprim )
fprintf(stdout," -- PHASE 1 COMPLETED. %.2f sec.\n",gttime(mshmet_ctim[2]));
/* metric */
chrono(ON,&mshmet_ctim[3]);
if ( mesh->info.imprim ) fprintf(stdout,"\n -- PHASE 2 : METRIC\n");
if ( !mshme1(mesh,sol) ) exit(1);
chrono(OFF,&mshmet_ctim[3]);
if ( mesh->info.imprim )
fprintf(stdout," -- PHASE 2 COMPLETED. %.2f sec.\n",gttime(mshmet_ctim[3]));
fprintf(stdout,"\n %s\n END OF MODULE MSHMET \n %s\n",MS_STR,MS_STR);
/*
sol->outn="zzzz";
if ( !saveMet(sol,&mesh->info,sol->outn) ) exit(1);
*/
if ( mesh->info.imprim )
mshmet_endcod();
fprintf(stdout,"\n %s\n END OF MODULE MSHMET \n %s\n",MS_STR,MS_STR);
if ( mesh->info.imprim < -4 || mesh->info.ddebug ) M_memDump();
return(0);
}
int main(int argc,char *argv[]) {
MMG5_pMesh mesh;
MMG5_pSol met;
int ier;
char stim[32];
atexit(endcod);
tminit(ctim,TIMEMAX);
chrono(ON,&ctim[0]);
/* assign default values */
mesh = NULL;
met = NULL;
MMG5_Init_mesh(&mesh,&met);
/* reset default values for file names */
MMG5_Free_names(mesh,met);
/* command line */
if ( !MMG5_parsar(argc,argv,mesh,met) ) return(1);
/* load data */
fprintf(stdout,"\n -- INPUT DATA\n");
chrono(ON,&ctim[1]);
/* read mesh file */
if ( !MMG5_loadMesh(mesh) ) {
MMG5_Free_all(mesh,met );
return(MMG5_STRONGFAILURE);
}
if ( !MMG5_Set_solSize(mesh,met,MMG5_Vertex,0,MMG5_Scalar) ) {
MMG5_Free_all(mesh,met);
return(MMG5_STRONGFAILURE);
}
/* read metric if any */
ier = MMG5_loadMet(mesh,met);
if ( !ier ) {
MMG5_Free_all(mesh,met);
return(MMG5_STRONGFAILURE);
}
if ( !MMG5_parsop(mesh,met) )
RETURN_AND_FREE(mesh,met,MMG5_LOWFAILURE);
chrono(OFF,&ctim[1]);
printim(ctim[1].gdif,stim);
fprintf(stdout," -- DATA READING COMPLETED. %s\n",stim);
ier = MMG5_mmg3dlib(mesh,met );
if ( ier != MMG5_STRONGFAILURE ) {
chrono(ON,&ctim[1]);
if ( mesh->info.imprim )
fprintf(stdout,"\n -- WRITING DATA FILE %s\n",mesh->nameout);
if ( !MMG5_saveMesh(mesh) ) {
MMG5_Free_all(mesh,met );
return(EXIT_FAILURE);
}
if ( !MMG5_saveMet(mesh,met) ) {
MMG5_Free_all(mesh,met);
return(EXIT_FAILURE);
}
chrono(OFF,&ctim[1]);
if ( mesh->info.imprim )
fprintf(stdout," -- WRITING COMPLETED\n");
}
/* free mem */
chrono(OFF,&ctim[0]);
printim(ctim[0].gdif,stim);
fprintf(stdout,"\n MMG3D: ELAPSED TIME %s\n",stim);
MMG5_Free_all(mesh,met);
return(ier);
}
/**
* \param argc number of command line arguments.
* \param argv command line arguments.
* \return \ref MMG5_SUCCESS if success.
* \return \ref MMG5_LOWFAILURE if failed but a conform mesh is saved.
* \return \ref MMG5_STRONGFAILURE if failed and we can't save the mesh.
*
* Main program for MMG3D executable: perform mesh adaptation.
*
*/
int main(int argc,char *argv[]) {
MMG5_Mesh mesh;
MMG5_Sol met;
int ier;
char stim[32];
fprintf(stdout," -- MMG3d, Release %s (%s) \n",MG_VER,MG_REL);
fprintf(stdout," %s\n",MG_CPY);
fprintf(stdout," %s %s\n",__DATE__,__TIME__);
signal(SIGABRT,_MMG5_excfun);
signal(SIGFPE,_MMG5_excfun);
signal(SIGILL,_MMG5_excfun);
signal(SIGSEGV,_MMG5_excfun);
signal(SIGTERM,_MMG5_excfun);
signal(SIGINT,_MMG5_excfun);
atexit(_MMG5_endcod);
tminit(MMG5_ctim,TIMEMAX);
chrono(ON,&MMG5_ctim[0]);
/* assign default values */
memset(&mesh,0,sizeof(MMG5_Mesh));
memset(&met,0,sizeof(MMG5_Sol));
MMG5_Init_parameters(&mesh);
met.size = 1;
/* command line */
if ( !MMG5_parsar(argc,argv,&mesh,&met) ) return(MMG5_STRONGFAILURE);
#ifdef USE_SCOTCH
_MMG5_warnScotch(&mesh);
#endif
/* load data */
fprintf(stdout,"\n -- INPUT DATA\n");
chrono(ON,&MMG5_ctim[1]);
_MMG5_warnOrientation(&mesh);
/* read mesh file */
if ( !MMG5_loadMesh(&mesh) ) _MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
/* read metric if any */
ier = MMG5_loadMet(&mesh,&met);
if ( !ier )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
else if ( ier > 0 && met.np != mesh.np ) {
fprintf(stdout," ## WARNING: WRONG SOLUTION NUMBER. IGNORED\n");
_MMG5_DEL_MEM(&mesh,met.m,(met.size*met.npmax+1)*sizeof(double));
met.np = 0;
} else if ( met.size!=1 ) {
fprintf(stdout," ## ERROR: ANISOTROPIC METRIC NOT IMPLEMENTED.\n");
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
}
if ( !MMG5_parsop(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_LOWFAILURE);
chrono(OFF,&MMG5_ctim[1]);
printim(MMG5_ctim[1].gdif,stim);
fprintf(stdout," -- DATA READING COMPLETED. %s\n",stim);
/* analysis */
chrono(ON,&MMG5_ctim[2]);
_MMG5_setfunc(&mesh,&met);
MMG5_Set_saveFunc(&mesh);
if ( abs(mesh.info.imprim) > 0 ) _MMG5_outqua(&mesh,&met);
fprintf(stdout,"\n %s\n MODULE MMG3D: IMB-LJLL : %s (%s)\n %s\n",
MG_STR,MG_VER,MG_REL,MG_STR);
if ( mesh.info.imprim ) fprintf(stdout,"\n -- PHASE 1 : ANALYSIS\n");
if ( !_MMG5_scaleMesh(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
if ( mesh.info.iso ) {
if ( !met.np ) {
fprintf(stdout,"\n ## ERROR: A VALID SOLUTION FILE IS NEEDED \n");
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
}
if ( !_MMG5_mmg3d2(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
}
if ( !mesh.info.iso && !met.np && !_MMG5_DoSol(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_LOWFAILURE);
if ( !_MMG5_analys(&mesh) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_LOWFAILURE);
if ( mesh.info.imprim > 3 && !mesh.info.iso && met.m ) _MMG5_prilen(&mesh,&met);
chrono(OFF,&MMG5_ctim[2]);
printim(MMG5_ctim[2].gdif,stim);
if ( mesh.info.imprim )
fprintf(stdout," -- PHASE 1 COMPLETED. %s\n",stim);
/* mesh adaptation */
chrono(ON,&MMG5_ctim[3]);
if ( mesh.info.imprim )
fprintf(stdout,"\n -- PHASE 2 : %s MESHING\n",met.size < 6 ? "ISOTROPIC" : "ANISOTROPIC");
/* renumerotation if available */
if ( !_MMG5_scotchCall(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
#ifdef PATTERN
if ( !_MMG5_mmg3d1_pattern(&mesh,&met) ) {
if ( !(mesh.adja) && !_MMG5_hashTetra(&mesh,1) ) {
fprintf(stdout," ## Hashing problem. Unable to save mesh.\n");
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
}
if ( !_MMG5_unscaleMesh(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
if ( !MMG5_saveMesh(&mesh) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
if ( met.m && !MMG5_saveMet(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_LOWFAILURE);
}
#else
/* Pattern in iso mode, delauney otherwise */
if ( !mesh.info.iso ) {
if( !_MMG5_mmg3d1_delone(&mesh,&met) ) {
if ( !(mesh.adja) && !_MMG5_hashTetra(&mesh,1) ) {
fprintf(stdout," ## Hashing problem. Unable to save mesh.\n");
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
}
if ( !_MMG5_unscaleMesh(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
if ( !MMG5_saveMesh(&mesh) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
if ( met.m && !MMG5_saveMet(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_LOWFAILURE);
}
}
else {
if( !_MMG5_mmg3d1_pattern(&mesh,&met) ) {
if ( !(mesh.adja) && !_MMG5_hashTetra(&mesh,1) ) {
fprintf(stdout," ## Hashing problem. Unable to save mesh.\n");
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
}
if ( !_MMG5_unscaleMesh(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
if ( !MMG5_saveMesh(&mesh) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
if ( met.m && !MMG5_saveMet(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_LOWFAILURE);
}
}
#endif
chrono(OFF,&MMG5_ctim[3]);
printim(MMG5_ctim[3].gdif,stim);
if ( mesh.info.imprim )
fprintf(stdout," -- PHASE 2 COMPLETED. %s\n",stim);
fprintf(stdout,"\n %s\n END OF MODULE MMG3d: IMB-LJLL \n %s\n",MG_STR,MG_STR);
/* save file */
_MMG5_outqua(&mesh,&met);
if ( mesh.info.imprim > 3 && !mesh.info.iso )
_MMG5_prilen(&mesh,&met);
chrono(ON,&MMG5_ctim[1]);
if ( mesh.info.imprim ) fprintf(stdout,"\n -- WRITING DATA FILE %s\n",mesh.nameout);
if ( !_MMG5_unscaleMesh(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
if ( !MMG5_saveMesh(&mesh) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
if ( !MMG5_saveMet(&mesh,&met) )
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_STRONGFAILURE);
chrono(OFF,&MMG5_ctim[1]);
if ( mesh.info.imprim ) fprintf(stdout," -- WRITING COMPLETED\n");
/* free mem */
_MMG5_RETURN_AND_FREE(&mesh,&met,MMG5_SUCCESS);
}
