// Entry Point int main(int argc, char* argv[]) { bool verbose = false; bool have_sizing_field = false; std::vector<std::string> material_fields; std::string output_path = kDefaultOutputName; double alpha = kDefaultAlpha; double alpha_long = kDefaultAlphaLong; double alpha_short = kDefaultAlphaShort; std::string sizing_field; enum cleaver::MeshType mesh_mode = cleaver::Structured; double background_time = 0; //------------------------------- // Parse Command Line Params //------------------------------- try{ po::options_description description("Command line flags"); description.add_options() ("help,h", "display help message") ("verbose,v", "enable verbose output") ("version,V", "display version information") ("material_fields,i", po::value<std::vector<std::string> >()->multitoken(), "material field paths") ("alpha,a", po::value<double>(), "initial alpha value") ("alpha_short,s", po::value<double>(), "alpha short value for regular mesh_mode") ("alpha_long,l", po::value<double>(), "alpha long value for regular mesh_mode") ("mesh_mode,m", po::value<std::string>(), "background mesh mode (structured [default], regular)") ("sizing_field,z", po::value<std::string>(), "sizing field path") ("output", po::value<std::string>()->default_value(kDefaultOutputName, "bgmesh"), "output path") ; boost::program_options::variables_map variables_map; boost::program_options::store(boost::program_options::parse_command_line(argc, argv, description), variables_map); boost::program_options::notify(variables_map); // print version info if (variables_map.count("version")) { std::cout << cleaver::Version << std::endl; return 0; } // print help else if (variables_map.count("help") || (argc ==1)) { std::cout << description << std::endl; return 0; } // enable verbose mode if (variables_map.count("verbose")) { verbose = true; } //alphas if (variables_map.count("alpha")) { alpha = variables_map["alpha"].as<double>(); } if (variables_map.count("alpha_short")) { alpha_short = variables_map["alpha_short"].as<double>(); } if (variables_map.count("alpha_long")) { alpha_long = variables_map["alpha_long"].as<double>(); } // parse the background mesh mode if (variables_map.count("mesh_mode")) { std::string mesh_mode_string = variables_map["mesh_mode"].as<std::string>(); if(mesh_mode_string.compare("regular") == 0) { mesh_mode = cleaver::Regular; } else if(mesh_mode_string.compare("structured") == 0) { mesh_mode = cleaver::Structured; } else { std::cerr << "Error: invalid background mesh mode: " << mesh_mode_string << std::endl; std::cerr << "Valid Modes: [regular] [structured] " << std::endl; return 6; } } // parse the material field input file names if (variables_map.count("material_fields")) { material_fields = variables_map["material_fields"].as<std::vector<std::string> >(); int file_count = material_fields.size(); } else{ std::cout << "Error: At least one material field file must be specified." << std::endl; return 0; } //----------------------------------------- // parse the sizing field input file name // and NOT check for conflicting parameters //---------------------------------------- if (variables_map.count("sizing_field")) { have_sizing_field = true; sizing_field = variables_map["sizing_field"].as<std::string>(); } // set output path if (variables_map.count("output")) { output_path = variables_map["output"].as<std::string>(); } } catch (std::exception& e) { std::cerr << "Error: " << e.what() << std::endl; return 0; } catch(...) { std::cerr << "Unhandled exception caught. Terminating." << std::endl; return 0; } //----------------------------------- // Load Data & Construct Volume //----------------------------------- std::cout << " Loading input fields:" << std::endl; for (size_t i=0; i < material_fields.size(); i++) { std::cout << " - " << material_fields[i] << std::endl; } std::vector<cleaver::AbstractScalarField*> fields = loadNRRDFiles(material_fields, verbose); if(fields.empty()){ std::cerr << "Failed to load image data. Terminating." << std::endl; return 0; } else if(fields.size() == 1) { fields.push_back(new cleaver::InverseScalarField(fields[0])); } cleaver::Volume *volume = new cleaver::Volume(fields); cleaver::CleaverMesher mesher(volume); mesher.setAlphaInit(alpha); //------------------------------------------------------------ // Load Sizing Field //------------------------------------------------------------ cleaver::AbstractScalarField *sizingField = NULL; if (have_sizing_field) { std::cout << "Loading sizing field: " << sizing_field << std::endl; sizingField = loadNRRDFile(sizing_field, verbose); } else { std::cerr << "Sizing Field file required !" << '\n'; return 2; } //------------------------------------------------------------ // Set Sizing Field on Volume //------------------------------------------------------------ volume->setSizingField(sizingField); //----------------------------------------------------------- // Construct Background Mesh //----------------------------------------------------------- cleaver::Timer background_timer; background_timer.start(); cleaver::TetMesh *bgMesh = NULL; if(verbose) std::cout << "Creating Octree Mesh..." << std::endl; switch(mesh_mode) { case cleaver::Regular: mesher.setAlphas(alpha_long,alpha_short); mesher.setRegular(true); bgMesh = mesher.createBackgroundMesh(verbose); break; default: case cleaver::Structured: mesher.setRegular(false); bgMesh = mesher.createBackgroundMesh(verbose); break; } background_timer.stop(); background_time = background_timer.time(); mesher.setBackgroundTime(background_time); //----------------------------------------------------------- // Write Background Mesh //----------------------------------------------------------- if (bgMesh ) { bgMesh->writeNodeEle(output_path, false, false, false); } //----------------------------------------------------------- // THE END //----------------------------------------------------------- std::cout << " Done." << std::endl; return 0; }
// Entry Point int main(int argc, char* argv[]) { bool verbose = false; std::vector<std::string> material_fields; std::string output_path = kDefaultOutputName; double scale = kDefaultScale; double lipschitz = kDefaultLipschitz; double multiplier = kDefaultMultiplier; int padding = kDefaultPadding; //------------------------------- // Parse Command Line Params //------------------------------- try{ po::options_description description("Command line flags"); description.add_options() ("help,h", "display help message") ("verbose,v", "enable verbose output") ("version", "display version information") ("material_fields", po::value<std::vector<std::string> >()->multitoken(), "material field paths") ("grading", po::value<double>(&lipschitz)->default_value(kDefaultLipschitz, kDefaultLipschitzString), "sizing field grading") ("multiplier", po::value<double>(&multiplier)->default_value(kDefaultMultiplier), "sizing field multiplier") ("scale", po::value<double>(&scale)->default_value(kDefaultScale), "sizing field scale") ("output", po::value<std::string>()->default_value(kDefaultOutputName, "sizingfield"), "output path") ("padding", po::value<int>()->default_value(kDefaultPadding), "padding") ; boost::program_options::variables_map variables_map; boost::program_options::store(boost::program_options::parse_command_line(argc, argv, description), variables_map); boost::program_options::notify(variables_map); // print version info if (variables_map.count("version")) { std::cout << cleaver::Version << std::endl; return 0; } // print help else if (variables_map.count("help") || (argc ==1)) { std::cout << description << std::endl; return 0; } // enable verbose mode if (variables_map.count("verbose")) { verbose = true; } // parse the material field input file names if (variables_map.count("material_fields")) { material_fields = variables_map["material_fields"].as<std::vector<std::string> >(); int file_count = material_fields.size(); } else{ std::cout << "Error: At least one material field file must be specified." << std::endl; return 0; } // set output path if (variables_map.count("output")) { output_path = variables_map["output"].as<std::string>(); } } catch (std::exception& e) { std::cerr << "Error: " << e.what() << std::endl; return 0; } catch(...) { std::cerr << "Unhandled exception caught. Terminating." << std::endl; return 0; } //----------------------------------- // Load Data & Construct Volume //----------------------------------- std::cout << " Loading input fields:" << std::endl; for (size_t i=0; i < material_fields.size(); i++) { std::cout << " - " << material_fields[i] << std::endl; } std::vector<cleaver::AbstractScalarField*> fields = loadNRRDFiles(material_fields, verbose); if(fields.empty()){ std::cerr << "Failed to load image data. Terminating." << std::endl; return 0; } else if(fields.size() == 1) { fields.push_back(new cleaver::InverseScalarField(fields[0])); } cleaver::Volume *volume = new cleaver::Volume(fields); //------------------------------------------------------------ // Construct Sizing Field //------------------------------------------------------------ cleaver::FloatField *sizingField = cleaver::SizingFieldCreator::createSizingFieldFromVolume( volume, (float)(1.0/lipschitz), (float)scale, (float)multiplier, (int)padding, false); //------------------------------------------------------------ // Write Field to File //------------------------------------------------------------ std::cout << " Writing sizing field to file: " << output_path << ".nrrd" << std::endl; // todo(jrb) strip path saveNRRDFile(sizingField, output_path); // done std::cout << " Done." << std::endl; return 0; }
int main(int argc, char *argv[]) { //------------------------------- // Parse Inputs //------------------------------- parse_input(argc, argv); //------------------------------- // Load Data & Create Lattice //------------------------------- std::vector<Cleaver::ScalarField*> fields = loadNRRDFiles(inputs, verbose); if(fields.empty()){ std::cerr << "Failed to load image data. Terminating." << std::endl; return 0; } else if(fields.size() == 1) fields.push_back(new Cleaver::InverseField(fields[0])); Cleaver::AbstractVolume *volume = new Cleaver::Volume(fields); if(absolute_resolution) ((Cleaver::Volume*)volume)->setSize(rx,ry,rz); if(scaled_resolution) ((Cleaver::Volume*)volume)->setSize(sx*volume->size().x, sy*volume->size().y, sz*volume->size().z); if(padding) volume = new Cleaver::PaddedVolume(volume); std::cout << "Creating Mesh with Volume Size " << volume->size().toString() << std::endl; //-------------------------------- // Create Mesher & TetMesh //-------------------------------- Cleaver::TetMesh *mesh = Cleaver::createMeshFromVolume(volume, verbose); //------------------ // Compute Angles //------------------ mesh->computeAngles(); if(verbose){ std::cout.precision(12); std::cout << "Worst Angles:" << std::endl; std::cout << "min: " << mesh->min_angle << std::endl; std::cout << "max: " << mesh->max_angle << std::endl; } //---------------------- // Write Info File //---------------------- mesh->writeInfo(output, verbose); //---------------------- // Write Tet Mesh Files //---------------------- if(format == tetgen) mesh->writeNodeEle(output, verbose); else if(format == scirun) mesh->writePtsEle(output, verbose); else if(format == matlab) mesh->writeMatlab(output, verbose); //---------------------- // Write Surface Files //---------------------- mesh->constructFaces(); mesh->writePly(output, verbose); //mesh->writeMultiplePly(inputs, output, verbose); //----------- // Cleanup //----------- if(verbose) std::cout << "Cleaning up." << std::endl; delete mesh; for(unsigned int f=0; f < fields.size(); f++) delete fields[f]; delete volume; //----------- // Done //----------- if(verbose) std::cout << "Done." << std::endl; return 0; }