// 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;
}
