+ bool p_h = ( hyp && hyp->myTextOption.find("-h") != std::string::npos );
+ bool p_v = ( hyp && hyp->myTextOption.find("-v") != std::string::npos );
+ bool p_i = ( hyp && hyp->myTextOption.find("-i") != std::string::npos );
+ bool p_o = ( hyp && hyp->myTextOption.find("-o") != std::string::npos );
+ bool p_mnot = ( hyp && hyp->myTextOption.find("--max_number_of_threads ") != std::string::npos );
+ bool p_blsi = ( hyp && hyp->myTextOption.find("--boundary_layer_surface_tags ") != std::string::npos );
+ bool p_blii = ( hyp && hyp->myTextOption.find("--boundary_layer_imprint_tags ") != std::string::npos );
+ bool p_blsd = ( hyp && hyp->myTextOption.find("--normal_direction ") != std::string::npos );
+ bool p_hotfl = ( hyp && hyp->myTextOption.find("--boundary_layer_global_initial_height ") != std::string::npos );
+ bool p_nobl = ( hyp && hyp->myTextOption.find("--number_of_boundary_layers ") != std::string::npos );
+ bool p_blgp = ( hyp && hyp->myTextOption.find("--boundary_layer_geometric_progression ") != std::string::npos );
+ bool p_eg = ( hyp && hyp->myTextOption.find("--element_generation ") != std::string::npos );
+ bool p_cm = ( hyp && hyp->myTextOption.find("--collision_mode ") != std::string::npos );
+ bool p_am = ( hyp && hyp->myTextOption.find("--add_multinormals ") != std::string::npos );
+ bool p_cs = ( hyp && hyp->myTextOption.find("--global_physical_size ") != std::string::npos );
+ bool p_mat = ( hyp && hyp->myTextOption.find("--multinormal_angle_threshold ") != std::string::npos );
+ bool p_sn = ( hyp && hyp->myTextOption.find("--smooth_normals ") != std::string::npos );
+
+ //missing options :
+ //- boundary_layer_max_element_angle
+
+ bool nolayers = false;
+ bool layersOnAllWrap = hyp ? hyp->myLayersOnAllWrap : DefaultLayersOnAllWrap();
+
+ //help mode
+ if ( p_h ) {
+ cmd << " --help ";
+#ifdef WIN32
+ cmd << " < NUL";
+#endif
+ std::cout << "!!!!! CommandToRun help only !!!! " << cmd << std::endl;
+ return cmd;
+ }
+
+ if ( !p_v && hyp )
+ cmd << " --verbose " << hyp->myVerboseLevel;
+
+ if ( !p_mnot && hyp )
+ cmd << " --max_number_of_threads " << 8; //TODO getenv NB CPU
+
+ //no layers?
+ if ( !p_nobl && hyp ) {
+ if ( hyp->myNbOfBoundaryLayers < 1 ) nolayers = true;
+ }
+ if ( !p_hotfl && hyp ) {
+ if ( hyp->myHeightFirstLayer < 1e-50 ) nolayers = true;
+ }
+
+ if ( !p_blsd && hyp ) {
+ if ( hyp->myBoundaryLayersGrowth >= 0 && hyp->myBoundaryLayersGrowth <= 1 ) {
+ const char* value[] = { "-1" , "1" }; // -1 == inside
+ cmd << " --normal_direction " << value[ hyp->myBoundaryLayersGrowth ];
+ }
+ }
+
+ if ( !p_hotfl && hyp ) {
+ cmd << " --boundary_layer_global_initial_height " << hyp->myHeightFirstLayer;
+ }
+
+ if ( !p_nobl && hyp ) {
+ cmd << " --number_of_boundary_layers " << ( nolayers ? 0 : hyp->myNbOfBoundaryLayers );
+ }
+
+ if ( !p_blgp && hyp ) {
+ cmd << " --boundary_layer_geometric_progression " << hyp->myBoundaryLayersProgression;
+ }
+
+ if ( !nolayers && hyp )
+ {
+ cmd << " --boundary_layer_size_mode " << ( layersOnAllWrap ? "global" : "local" );
+
+ if ( !layersOnAllWrap )
+ {
+ // faces with layers
+ const std::vector<int>& faceLayersIDs = hyp->GetFacesWithLayers();
+ if ( !faceLayersIDs.empty() )
+ cmd << " --boundary_layer_surface_tags ";
+ for ( size_t i = 0; i < faceLayersIDs.size(); ++i )
+ cmd << faceLayersIDs[i] << ",";
+ if ( !faceLayersIDs.empty() )
+ cmd << " --boundary_layer_initial_height_on_surface_tags ";
+ for ( size_t i = 0; i < faceLayersIDs.size(); ++i )
+ cmd << hyp->myHeightFirstLayer << ",";
+
+ // faces with imprinting
+ const std::vector<int>& faceImprintingIDs = hyp->GetFacesWithImprinting();
+ if ( !faceImprintingIDs.empty() )
+ cmd << " --boundary_layer_imprinting yes --boundary_layer_imprinting_tags ";
+ for ( size_t i = 0; i < faceImprintingIDs.size(); ++i )
+ cmd << faceImprintingIDs[i] << ",";
+
+ // faces with snapping
+ const std::vector<int>& faceSnappingIDs = hyp->GetFacesWithSnapping();
+ if ( !faceSnappingIDs.empty() )
+ cmd << " --boundary_layer_snapping yes --boundary_layer_snapping_tags ";
+ for ( size_t i = 0; i < faceSnappingIDs.size(); ++i )
+ cmd << faceSnappingIDs[i] << ",";
+ }
+ }
+
+ if ( !p_eg && hyp ) {
+ if ( hyp->myElementGeneration >= 0 && hyp->myElementGeneration <= 2 ) {
+ const char* value[] = { "tetra-dominant" , "hexa-dominant", "cartesian_core" };
+ cmd << " --element_generation " << value[ hyp->myElementGeneration ];
+ }
+ }
+
+ if ( !p_cs && hyp ) {
+ if ( hyp->myCoreSize >= 0 ) {
+ cmd << " --global_physical_size " << hyp->myCoreSize;
+ }
+ }
+
+ if ( !p_cm && hyp ) {
+ if ( hyp->myCollisionMode >= 0 && hyp->myCollisionMode <= 1 ) {
+ const char* value[] = { "decrease" , "stop" };
+ cmd << " --collision_mode " << value[ hyp->myCollisionMode ];
+ }
+ }
+
+ if ( !p_am && hyp ) {
+ int res = hyp->myAddMultinormals ? 0 : 1 ;
+ const char* value[] = { "yes" , "no" };
+ cmd << " --add_multinormals " << value[ res ];
+ }
+
+ if ( !p_mat && hyp ) {
+ cmd << " --multinormal_angle_threshold " << hyp->myMultinormalsAngle;
+ }
+
+ if ( !p_sn && hyp ) {
+ int res = hyp->mySmoothNormals ? 0 : 1 ;
+ const char* value[] = { "yes" , "no" };
+ cmd << " --smooth_normals " << value[ res ];