int main() { // Domain CGAL::Image_3 image; image.read("data/liver.inr.gz"); Mesh_domain domain(image); // Mesh criteria Mesh_criteria criteria(facet_angle=30, facet_distance=1.2, cell_radius_edge_ratio=2); // Mesh generation and optimization in one call C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria, lloyd(time_limit=30), no_perturb(), exude(time_limit=10, sliver_bound=10)); // Mesh generation and optimization in several call C3t3 c3t3_bis = CGAL::make_mesh_3<C3t3>(domain, criteria, no_perturb(), no_exude()); CGAL::lloyd_optimize_mesh_3(c3t3_bis, domain, time_limit=30); CGAL::exude_mesh_3(c3t3_bis, sliver_bound=10, time_limit=10); // Output std::ofstream medit_file("out.mesh"); c3t3.output_to_medit(medit_file); std::ofstream medit_file_bis("out_bis.mesh"); c3t3_bis.output_to_medit(medit_file_bis); return 0; }
int main() { // Domain CGAL::Image_3 image; image.read("data/liver.inr.gz"); Mesh_domain domain(image); // Mesh criteria Mesh_criteria criteria(facet_angle=30, facet_size=5, facet_distance=1.5, cell_radius_edge_ratio=2, cell_size=7); // Mesh generation and optimization in one call (sliver_bound is the // targeted dihedral angle in degree) C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria, no_exude(), perturb(sliver_bound=10, time_limit=15)); // Mesh generation and optimization in several call C3t3 c3t3_bis = CGAL::make_mesh_3<C3t3>(domain, criteria, no_perturb(), no_exude()); CGAL::perturb_mesh_3(c3t3_bis, domain, time_limit=15); // Output std::ofstream medit_file("out.mesh"); c3t3.output_to_medit(medit_file); std::ofstream medit_file_bis("out_bis.mesh"); c3t3_bis.output_to_medit(medit_file_bis); return 0; }
int main() { // Loads image CGAL::Image_3 image; image.read("data/liver.inr.gz"); // Domain Mesh_domain domain(image); // Sizing field: set global size to 8 and kidney size (label 127) to 3 double kidney_size = 3.; int volume_dimension = 3; Sizing_field size(8); size.set_size(kidney_size, volume_dimension, domain.index_from_subdomain_index(127)); // Mesh criteria Mesh_criteria criteria(facet_angle=30, facet_size=6, facet_distance=2, cell_radius_edge_ratio=3, cell_size=size); // Meshing C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria); // Output std::ofstream medit_file("out.mesh"); c3t3.output_to_medit(medit_file); return 0; }
int main(int argc, char* argv[]) { const char* fname = (argc>1)?argv[1]:"data/liver.inr.gz"; // Loads image CGAL::Image_3 image; if(!image.read(fname)){ std::cerr << "Error: Cannot read file " << fname << std::endl; return EXIT_FAILURE; } // Domain Mesh_domain domain = Mesh_domain::create_labeled_image_mesh_domain(image); // Sizing field: set global size to 8 and kidney size (label 127) to 3 double kidney_size = 3.; int volume_dimension = 3; Sizing_field size(8); size.set_size(kidney_size, volume_dimension, domain.index_from_subdomain_index(127)); // Mesh criteria Mesh_criteria criteria(facet_angle=30, facet_size=6, facet_distance=2, cell_radius_edge_ratio=3, cell_size=size); // Meshing C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria); // Output std::ofstream medit_file("out.mesh"); c3t3.output_to_medit(medit_file); return 0; }
int main(int argc, char* argv[]) { /// [Loads image] const char* fname = (argc>1)?argv[1]:"data/liver.inr.gz"; CGAL::Image_3 image; if(!image.read(fname)){ std::cerr << "Error: Cannot read file " << fname << std::endl; return EXIT_FAILURE; } /// [Loads image] // Domain Mesh_domain domain(image); // Mesh criteria Mesh_criteria criteria(facet_angle=30, facet_size=6, facet_distance=4, cell_radius_edge_ratio=3, cell_size=8); /// [Meshing] C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria); /// [Meshing] // Output std::ofstream medit_file("out.mesh"); c3t3.output_to_medit(medit_file); return 0; }
int main(int argc, char* argv[]) { const char* fname = argv[1]; const unsigned int sx = atoi(argv[2]); const unsigned int sy = atoi(argv[3]); const unsigned int sz = atoi(argv[4]); // Loads image CGAL::Image_3 image; if(!image.read_raw(fname,sx,sy,sz)){ std::cerr << "Error: Cannot read file " << fname << std::endl; return EXIT_FAILURE; } // Domain Mesh_domain domain(image); // Mesh criteria Mesh_criteria criteria(facet_angle=20, facet_size=4, facet_distance=4, cell_radius_edge_ratio=2, cell_size=2); // Meshing // C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria); // Mesh generation and optimization in one call C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria, no_perturb(), no_exude()); std::cout<<" Lloyd..."<<std::endl; CGAL::lloyd_optimize_mesh_3(c3t3, domain, time_limit=120); std::cout<<" Exude..."<<std::endl; CGAL::exude_mesh_3(c3t3, sliver_bound=5, time_limit=60); std::cout << " Exporting.."<<std::endl; //Labels std::set<C3t3::Subdomain_index> labelset; for(unsigned int i = 0; i< sx*sy*sz; i++) labelset.insert( ((unsigned char*)image.data() )[ i ] ); std::cout << "Found "<< labelset.size()<< " labels."<<std::endl; // Output for(std::set<C3t3::Subdomain_index>::const_iterator it=labelset.begin(); it != labelset.end(); ++it ) { std::string name= "out_"; name += std::to_string( *it ); name += ".off"; std::ofstream off_file(name); c3t3.output_boundary_to_off(off_file, *it ); } return 0; }
int main() { // Loads image CGAL::Image_3 image; image.read ( "p.bmp" ); // Domain Mesh_domain domain ( image ); // Mesh criteria Mesh_criteria criteria ( facet_angle=30, facet_size=6, facet_distance=4, cell_radius_edge_ratio=3, cell_size=8 ); // Meshing C3t3 c3t3 = CGAL::make_mesh_3<C3t3> ( domain, criteria ); // Output std::ofstream medit_file ( "out.mesh" ); c3t3.output_to_medit ( medit_file ); return 0; }
int main() { // Loads image CGAL::Image_3 image; if(!image.read("data/skull_2.9.inr")) return 1; // Domain Mesh_domain domain(image, std::bind1st(std::less<Image_word_type>(), 2.9f), 0.f); // Mesh criteria Mesh_criteria criteria(facet_angle=30, facet_size=6, facet_distance=2, cell_radius_edge_ratio=3, cell_size=8); // Meshing C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria); // Output std::ofstream medit_file("out.mesh"); c3t3.output_to_medit(medit_file); return 0; }
int main(int argc, char*argv[]) { const char* fname = (argc>1)?argv[1]:"data/liver.inr.gz"; // Domain CGAL::Image_3 image; if(!image.read(fname)){ std::cerr << "Error: Cannot read file " << fname << std::endl; return EXIT_FAILURE; } Mesh_domain domain = Mesh_domain::create_labeled_image_mesh_domain(image); // Mesh criteria Mesh_criteria criteria(facet_angle=30, facet_distance=1.2, cell_radius_edge_ratio=2); // Mesh generation and optimization in one call C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria, lloyd(time_limit=30), no_perturb(), exude(time_limit=10, sliver_bound=10)); // Mesh generation and optimization in several call C3t3 c3t3_bis = CGAL::make_mesh_3<C3t3>(domain, criteria, no_perturb(), no_exude()); CGAL::lloyd_optimize_mesh_3(c3t3_bis, domain, time_limit=30); CGAL::exude_mesh_3(c3t3_bis, sliver_bound=10, time_limit=10); // Output std::ofstream medit_file("out.mesh"); c3t3.output_to_medit(medit_file); std::ofstream medit_file_bis("out_bis.mesh"); c3t3_bis.output_to_medit(medit_file_bis); return 0; }
int main(int argc, char* argv[]) { const char* fname = (argc>1)?argv[1]:"data/420.inr"; // Loads image CGAL::Image_3 image; if(!image.read(fname)){ std::cerr << "Error: Cannot read file " << fname << std::endl; return EXIT_FAILURE; } // Domain Mesh_domain domain(image); /// Declare 1D-features, see above [Call add_1D_features] const char* lines_fname = (argc>2)?argv[2]:"data/420.polylines.txt"; if(!add_1D_features(image, domain, lines_fname)) { return EXIT_FAILURE; } /// [Call add_1D_features] /// Note that `edge_size` is needed with 1D-features [Mesh criteria] Mesh_criteria criteria(edge_size=6, facet_angle=30, facet_size=6, facet_distance=4, cell_radius_edge_ratio=3, cell_size=8); /// [Mesh criteria] // Meshing C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria); // Output std::ofstream medit_file("out.mesh"); c3t3.output_to_medit(medit_file); return 0; }
int main(int argc, char** argv) { QApplication app(argc, argv); if(argc != 3) usage_and_exit(argv[0]); QVTKWidget widget; widget.resize(256,256); #if QT_VERSION < 0x040000 app.setMainWidget(&widget); #endif CGAL::Image_3 image; if(!image.read(argv[1])) { std::cerr << "Cannot read image file \"" << argv[1] << "\"!\n"; usage_and_exit(argv[0]); } std::stringstream argv2; argv2 << argv[2]; double isovalue; if(!(argv2 >> isovalue)) { std::cerr << "Invalid iso-value \"" << argv[2] << "\"!\n"; usage_and_exit(argv[0]); } vtkImageData* vtk_image = CGAL::vtk_image_sharing_same_data_pointer(image); vtkRenderer *aRenderer = vtkRenderer::New(); vtkRenderWindow *renWin = vtkRenderWindow::New(); renWin->AddRenderer(aRenderer); widget.SetRenderWindow(renWin); vtkContourFilter *skinExtractor = vtkContourFilter::New(); skinExtractor->SetInputData(vtk_image); skinExtractor->SetValue(0, isovalue); // skinExtractor->SetComputeNormals(0); vtkPolyDataNormals *skinNormals = vtkPolyDataNormals::New(); skinNormals->SetInputConnection(skinExtractor->GetOutputPort()); skinNormals->SetFeatureAngle(60.0); vtkPolyDataMapper *skinMapper = vtkPolyDataMapper::New(); skinMapper->SetInputConnection(skinExtractor->GetOutputPort()); skinMapper->ScalarVisibilityOff(); vtkActor *skin = vtkActor::New(); skin->SetMapper(skinMapper); // An outline provides context around the data. // vtkOutlineFilter *outlineData = vtkOutlineFilter::New(); outlineData->SetInputData(vtk_image); vtkPolyDataMapper *mapOutline = vtkPolyDataMapper::New(); mapOutline->SetInputConnection(outlineData->GetOutputPort()); vtkActor *outline = vtkActor::New(); outline->SetMapper(mapOutline); outline->GetProperty()->SetColor(0,0,0); // It is convenient to create an initial view of the data. The FocalPoint // and Position form a vector direction. Later on (ResetCamera() method) // this vector is used to position the camera to look at the data in // this direction. vtkCamera *aCamera = vtkCamera::New(); aCamera->SetViewUp (0, 0, -1); aCamera->SetPosition (0, 1, 0); aCamera->SetFocalPoint (0, 0, 0); aCamera->ComputeViewPlaneNormal(); // Actors are added to the renderer. An initial camera view is created. // The Dolly() method moves the camera towards the FocalPoint, // thereby enlarging the image. aRenderer->AddActor(outline); aRenderer->AddActor(skin); aRenderer->SetActiveCamera(aCamera); aRenderer->ResetCamera (); aCamera->Dolly(1.5); // Set a background color for the renderer and set the size of the // render window (expressed in pixels). aRenderer->SetBackground(1,1,1); renWin->SetSize(640, 480); // Note that when camera movement occurs (as it does in the Dolly() // method), the clipping planes often need adjusting. Clipping planes // consist of two planes: near and far along the view direction. The // near plane clips out objects in front of the plane; the far plane // clips out objects behind the plane. This way only what is drawn // between the planes is actually rendered. aRenderer->ResetCameraClippingRange (); // Initialize the event loop and then start it. // iren->Initialize(); // iren->Start(); // It is important to delete all objects created previously to prevent // memory leaks. In this case, since the program is on its way to // exiting, it is not so important. But in applications it is // essential. vtk_image->Delete(); skinExtractor->Delete(); skinNormals->Delete(); skinMapper->Delete(); skin->Delete(); outlineData->Delete(); mapOutline->Delete(); outline->Delete(); aCamera->Delete(); // iren->Delete(); renWin->Delete(); aRenderer->Delete(); widget.show(); app.exec(); return 0; }
int main() { // Loads image CGAL::Image_3 image; // Read input file with parameters Input p; p.load_file_elliptic_electrodes(); // Reading image file std::cout<<"\n Reading the Image file... "; image.read("input.inr"); // Domain Mesh_domain domain(image); //Define Sizing field Point or(image.vx () * image.xdim ()/2, image.vy () * image.ydim ()/2, image.vz () * image.zdim ()/2); //origin FILE *F; try { F=fopen("electrodes_human.txt","r");} catch (exception& e) { cout << e.what() << endl;} sizing_field_elliptic_electrodes size_e (or,F,image.vx(),image.vy(),image.vz()); if (F!=NULL) fclose(F); size_e.coarse_size=p.ccs; size_e.fine_size=p.cs; size_e.preserve=p.pres; //Elliptic size_e.e_R=p.e_R; //2* to secure fit of the electrode size_e.electrode_size=p.e_size;//Planar gradient with electrodes -- size of the mesh near electrodes // Mesh criteria: faces and cells Mesh_criteria criteria(facet_angle=p.fa, facet_size=size_e, facet_distance=p.fd, cell_radius_edge_ratio=p.cre, cell_size=size_e); // Meshing std::cout<<"\n Meshing with initial mesh..."; C3t3 c3t3= CGAL::make_mesh_3<C3t3>(domain, criteria, CGAL::parameters::features(domain), CGAL::parameters::no_lloyd(), CGAL::parameters::no_odt(), CGAL::parameters::no_perturb(),CGAL::parameters::no_exude()); //Optimisation std::cout<<"\n Optimising: "; if (p.if_perturb==1) {std::cout<<"\n Perturb... "; CGAL::perturb_mesh_3(c3t3, domain,sliver_bound=10, time_limit=p.time_lim);} if (p.if_lloyd==1) {std::cout<<"\n Lloyd... ";CGAL::lloyd_optimize_mesh_3(c3t3, domain, time_limit=p.time_lim);} if (p.if_odt==1) {std::cout<<"\n ODT... "; CGAL::odt_optimize_mesh_3(c3t3, domain, time_limit=p.time_lim);} if (p.if_exude==1) {std::cout<<"\n Exude... "; CGAL::exude_mesh_3(c3t3, sliver_bound=10, time_limit=p.time_lim);} // Output, you can use CGAL text format for that /*std::cout<<"\n Saving the mesh... "; std::ofstream medit_file("out.mesh"); c3t3.output_to_medit(medit_file); medit_file.close();*/ //matlab output std::cout<<"\n Saving the mesh into matlab file... "; int save=save_matlab(c3t3); std::cout<<"\n ALL DONE, press any key! :)"; getchar(); return 0; }