int main() { std::cerr << "### There should be three errors following this line...\n"; assert(! read("data/read_test/bug_1.xyz")); assert(! read("data/read_test/bug_2.xyz")); assert(! read("data/read_test/bug_3.xyz")); std::cerr << "### ... Done. Now, there should not be any error.\n"; assert(read("data/read_test/ok_1.xyz")); assert(read("data/read_test/ok_2.xyz")); assert(read("data/read_test/ok_3.xyz")); std::vector<PointVectorPair> pv_pairs; read("data/read_test/ok_2.xyz", pv_pairs); assert(pv_pairs.size() == 4); assert(pv_pairs[0] == std::make_pair(Point_3(2,3,4), Vector_3(4,4,2))); assert(pv_pairs[1] == std::make_pair(Point_3(3,4,6), Vector_3(0,0,0))); assert(pv_pairs[2] == std::make_pair(Point_3(3,6,7), Vector_3(3,5,6))); assert(pv_pairs[3] == std::make_pair(Point_3(1,3,4), Vector_3(4,6,8))); pv_pairs.clear(); assert(read_off("data/read_test/ok_1.off", pv_pairs)); assert(pv_pairs.size() == 4); assert(pv_pairs[0] == std::make_pair(Point_3(3,2,0), Vector_3(1,2,3))); assert(pv_pairs[1] == std::make_pair(Point_3(1,2,3), Vector_3(0,0,0))); assert(pv_pairs[2] == std::make_pair(Point_3(4,5,6), Vector_3(0,0,0))); assert(pv_pairs[3] == std::make_pair(Point_3(7,8,9), Vector_3(0,0,0))); return 0; }
bool read_mesh(Surface_mesh& mesh, const std::string& filename) { // extract file extension std::string::size_type dot(filename.rfind(".")); if (dot == std::string::npos) return false; std::string ext = filename.substr(dot+1, filename.length()-dot-1); std::transform(ext.begin(), ext.end(), ext.begin(), tolower); // extension determines reader if (ext == "off") { return read_off(mesh, filename); } else if (ext == "obj") { return read_obj(mesh, filename); } else if (ext == "stl") { return read_stl(mesh, filename); } // we didn't find a reader module return false; }
/* Open dmg image */ int dmg_open(int fd, bdev_desc_t *bdev) { u32 count; u32 max_compressed_size=1,max_sectors_per_chunk=1,i; bdev->priv = malloc(sizeof(BDRVDMGState)); if(bdev->priv == NULL) goto fail; BDRVDMGState *s = DMG_PRIV(bdev); CLEAR(*s); off_t info_begin,info_end,last_in_offset,last_out_offset; /* Init the bdev struct */ bdev->fd = fd; bdev->read = &wrap_read; bdev->real_read = &dmg_read; bdev->write = NULL; bdev->seek = &dmg_seek; bdev->close = &dmg_close; s->fd = fd; /* RO */ bdev->flags &= ~BF_ENABLE_WRITE; s->n_chunks = 0; s->offsets = s->lengths = s->sectors = s->sectorcounts = 0; /* read offset of info blocks */ if(lseek(s->fd,-0x1d8,SEEK_END)<0) goto fail; info_begin=read_off(s->fd); if(info_begin==0) goto fail; if(lseek(s->fd,info_begin,SEEK_SET)<0) goto fail; if(read_uint32(s->fd)!=0x100) goto fail; if((count = read_uint32(s->fd))==0) goto fail; info_end = info_begin+count; if(lseek(s->fd,0xf8,SEEK_CUR)<0) goto fail; /* read offsets */ last_in_offset = last_out_offset = 0; while(lseek(s->fd,0,SEEK_CUR)<info_end) { u32 type; count = read_uint32(s->fd); if(count==0) goto fail; type = read_uint32(s->fd); if(type!=0x6d697368 || count<244) lseek(s->fd,count-4,SEEK_CUR); else { int new_size, chunk_count; if(lseek(s->fd,200,SEEK_CUR)<0) goto fail; chunk_count = (count-204)/40; new_size = sizeof(u64) * (s->n_chunks + chunk_count); s->types = realloc(s->types, new_size/2); s->offsets = realloc(s->offsets, new_size); s->lengths = realloc(s->lengths, new_size); s->sectors = realloc(s->sectors, new_size); s->sectorcounts = realloc(s->sectorcounts, new_size); for(i=s->n_chunks;i<s->n_chunks+chunk_count;i++) { s->types[i] = read_uint32(s->fd); if(s->types[i]!=0x80000005 && s->types[i]!=1 && s->types[i]!=2) { if(s->types[i]==0xffffffff) { last_in_offset = s->offsets[i-1]+s->lengths[i-1]; last_out_offset = s->sectors[i-1]+s->sectorcounts[i-1]; } chunk_count--; i--; if(lseek(s->fd,36,SEEK_CUR)<0) goto fail; continue; } read_uint32(s->fd); s->sectors[i] = last_out_offset+read_off(s->fd); s->sectorcounts[i] = read_off(s->fd); s->offsets[i] = last_in_offset+read_off(s->fd); s->lengths[i] = read_off(s->fd); if(s->lengths[i]>max_compressed_size) max_compressed_size = s->lengths[i]; if(s->sectorcounts[i]>max_sectors_per_chunk) max_sectors_per_chunk = s->sectorcounts[i]; } s->n_chunks+=chunk_count; } } bdev->size = s->n_chunks * 512; /* initialize zlib engine */ if(!(s->compressed_chunk=(char*)malloc(max_compressed_size+1))) goto fail; if(!(s->uncompressed_chunk=(char*)malloc(512*max_sectors_per_chunk))) goto fail; if(inflateInit(&s->zstream) != Z_OK) goto fail; s->current_chunk = s->n_chunks; return 0; fail: return -1; }
static int dmg_open(BlockDriverState *bs, const char *filename, int flags) { BDRVDMGState *s = bs->opaque; off_t info_begin,info_end,last_in_offset,last_out_offset; uint32_t count; uint32_t max_compressed_size=1,max_sectors_per_chunk=1,i; s->fd = open(filename, O_RDONLY | O_BINARY); if (s->fd < 0) return -errno; bs->read_only = 1; s->n_chunks = 0; s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL; /* read offset of info blocks */ if(lseek(s->fd,-0x1d8,SEEK_END)<0) { dmg_close: close(s->fd); /* open raw instead */ bs->drv=bdrv_find_format("raw"); return bs->drv->bdrv_open(bs, filename, flags); } info_begin=read_off(s->fd); if(info_begin==0) goto dmg_close; if(lseek(s->fd,info_begin,SEEK_SET)<0) goto dmg_close; if(read_uint32(s->fd)!=0x100) goto dmg_close; if((count = read_uint32(s->fd))==0) goto dmg_close; info_end = info_begin+count; if(lseek(s->fd,0xf8,SEEK_CUR)<0) goto dmg_close; /* read offsets */ last_in_offset = last_out_offset = 0; while(lseek(s->fd,0,SEEK_CUR)<info_end) { uint32_t type; count = read_uint32(s->fd); if(count==0) goto dmg_close; type = read_uint32(s->fd); if(type!=0x6d697368 || count<244) lseek(s->fd,count-4,SEEK_CUR); else { int new_size, chunk_count; if(lseek(s->fd,200,SEEK_CUR)<0) goto dmg_close; chunk_count = (count-204)/40; new_size = sizeof(uint64_t) * (s->n_chunks + chunk_count); s->types = qemu_realloc(s->types, new_size/2); s->offsets = qemu_realloc(s->offsets, new_size); s->lengths = qemu_realloc(s->lengths, new_size); s->sectors = qemu_realloc(s->sectors, new_size); s->sectorcounts = qemu_realloc(s->sectorcounts, new_size); for(i=s->n_chunks;i<s->n_chunks+chunk_count;i++) { s->types[i] = read_uint32(s->fd); if(s->types[i]!=0x80000005 && s->types[i]!=1 && s->types[i]!=2) { if(s->types[i]==0xffffffff) { last_in_offset = s->offsets[i-1]+s->lengths[i-1]; last_out_offset = s->sectors[i-1]+s->sectorcounts[i-1]; } chunk_count--; i--; if(lseek(s->fd,36,SEEK_CUR)<0) goto dmg_close; continue; } read_uint32(s->fd); s->sectors[i] = last_out_offset+read_off(s->fd); s->sectorcounts[i] = read_off(s->fd); s->offsets[i] = last_in_offset+read_off(s->fd); s->lengths[i] = read_off(s->fd); if(s->lengths[i]>max_compressed_size) max_compressed_size = s->lengths[i]; if(s->sectorcounts[i]>max_sectors_per_chunk) max_sectors_per_chunk = s->sectorcounts[i]; } s->n_chunks+=chunk_count; } } /* initialize zlib engine */ s->compressed_chunk = qemu_malloc(max_compressed_size+1); s->uncompressed_chunk = qemu_malloc(512*max_sectors_per_chunk); if(inflateInit(&s->zstream) != Z_OK) goto dmg_close; s->current_chunk = s->n_chunks; return 0; }
int main() { Triangulation triangulation; boost::filesystem::path input_pathname = "C:/Carleton/CGAL-4.4/demo/Polyhedron/data/elephant.off"; // create_cubes(triangulation, 2, 2, 1 ); read_off( triangulation, input_pathname.string() ); // read_off(triangulation, "C:/Carleton/Meshes/holmes_off/geometry/octahedron.off"); // read_off(triangulation, "C:/Carleton/CGAL-4.4/demo/Polyhedron/data/cube.off"); // read_off(triangulation, "C:/Carleton/CGAL-4.4/demo/Polyhedron/data/ellipsoid.off"); #if 0 for (auto cell = triangulation.finite_cells_begin(); cell != triangulation.finite_cells_end(); ++cell) { for (int i = 0; i < 4; ++i) { Point p = cell->vertex(i)->point(); assert(-10.0 < p.x() && p.x() < +10.0); assert(-10.0 < p.y() && p.y() < +10.0); assert(-10.0 < p.z() && p.z() < +10.0); } } #endif set_cell_and_vertex_ids(triangulation); set_random_weights(triangulation); propagate_weights(triangulation); std::cout << "Number of finite vertices : " << triangulation.number_of_vertices() << std::endl; std::cout << "Number of finite edges : " << triangulation.number_of_finite_edges() << std::endl; std::cout << "Number of finite facets : " << triangulation.number_of_finite_facets() << std::endl; std::cout << "Number of finite cells : " << triangulation.number_of_finite_cells() << std::endl; std::string filename = input_pathname.filename().stem().string() + "_tet.vtk"; write_vtk( triangulation, filename ); if (triangulation.number_of_finite_cells() < 100) { dump_triangulation(triangulation); } Graph graph; create_steiner_points(graph,triangulation); // the distances are temporary, so we choose an external property for that std::vector<double> distances(num_vertices(graph)); std::vector<GraphNode_descriptor> predecessors(num_vertices(graph)); boost::dijkstra_shortest_paths( graph, *vertices(graph).first, boost::weight_map(get(&GraphEdge::weight, graph)). distance_map(boost::make_iterator_property_map(distances.begin(), get(boost::vertex_index, graph))). predecessor_map(boost::make_iterator_property_map(predecessors.begin(), get(boost::vertex_index, graph))) ); filename = input_pathname.filename().stem().string() + "_wsp.vtk"; write_shortest_path_vtk( graph, predecessors, distances, filename ); // write_graph_dot("graph.dot", graph); std::cout << "This is the end..." << std::endl; return EXIT_SUCCESS; }
static int dmg_open(BlockDriverState *bs, int flags) { BDRVDMGState *s = bs->opaque; off_t info_begin,info_end,last_in_offset,last_out_offset; uint32_t count; uint32_t max_compressed_size=1,max_sectors_per_chunk=1,i; int64_t offset; bs->read_only = 1; s->n_chunks = 0; s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL; /* read offset of info blocks */ offset = bdrv_getlength(bs->file); if (offset < 0) { goto fail; } offset -= 0x1d8; info_begin = read_off(bs, offset); if (info_begin == 0) { goto fail; } if (read_uint32(bs, info_begin) != 0x100) { goto fail; } count = read_uint32(bs, info_begin + 4); if (count == 0) { goto fail; } info_end = info_begin + count; offset = info_begin + 0x100; /* read offsets */ last_in_offset = last_out_offset = 0; while (offset < info_end) { uint32_t type; count = read_uint32(bs, offset); if(count==0) goto fail; offset += 4; type = read_uint32(bs, offset); if (type == 0x6d697368 && count >= 244) { int new_size, chunk_count; offset += 4; offset += 200; chunk_count = (count-204)/40; new_size = sizeof(uint64_t) * (s->n_chunks + chunk_count); s->types = g_realloc(s->types, new_size/2); s->offsets = g_realloc(s->offsets, new_size); s->lengths = g_realloc(s->lengths, new_size); s->sectors = g_realloc(s->sectors, new_size); s->sectorcounts = g_realloc(s->sectorcounts, new_size); for(i=s->n_chunks;i<s->n_chunks+chunk_count;i++) { s->types[i] = read_uint32(bs, offset); offset += 4; if(s->types[i]!=0x80000005 && s->types[i]!=1 && s->types[i]!=2) { if(s->types[i]==0xffffffff) { last_in_offset = s->offsets[i-1]+s->lengths[i-1]; last_out_offset = s->sectors[i-1]+s->sectorcounts[i-1]; } chunk_count--; i--; offset += 36; continue; } offset += 4; s->sectors[i] = last_out_offset+read_off(bs, offset); offset += 8; s->sectorcounts[i] = read_off(bs, offset); offset += 8; s->offsets[i] = last_in_offset+read_off(bs, offset); offset += 8; s->lengths[i] = read_off(bs, offset); offset += 8; if(s->lengths[i]>max_compressed_size) max_compressed_size = s->lengths[i]; if(s->sectorcounts[i]>max_sectors_per_chunk) max_sectors_per_chunk = s->sectorcounts[i]; } s->n_chunks+=chunk_count; } } /* initialize zlib engine */ s->compressed_chunk = g_malloc(max_compressed_size+1); s->uncompressed_chunk = g_malloc(512*max_sectors_per_chunk); if(inflateInit(&s->zstream) != Z_OK) goto fail; s->current_chunk = s->n_chunks; return 0; fail: return -1; }