// Reads a list of points and returns a list of segments corresponding to // the weighted Alpha Shape. int main() { std::list<Point> points; file_input(points); std::vector<Gt::Segment_2> segments; alpha_edges(points.begin(), points.end(), FT(10000),Alpha_shape_2::GENERAL, std::back_inserter(segments)); std::cout << segments.size() << " alpha shape edges." << std::endl; return 0; }
// Reads a list of points and returns a list of segments // corresponding to the Alpha shape. int main() { std::list<Point> points; if(! file_input(std::back_inserter(points))){ return -1; } Alpha_shape_2 A(points.begin(), points.end(), FT(10000), Alpha_shape_2::GENERAL); std::vector<Segment> segments; alpha_edges( A, std::back_inserter(segments)); std::cout << "Alpha Shape computed" << std::endl; std::cout << segments.size() << " alpha shape edges" << std::endl; std::cout << "Optimal alpha: " << *A.find_optimal_alpha(1)<<std::endl; return 0; }
int alpha_shape(vertex_t *vertices, size_t count, double alpha, vertex_t **res, size_t *res_count, char **err_msg) { try { std::list<Point> points; { std::vector<Point> pv; for (std::size_t j = 0; j < count; ++j) { Point p(vertices[j].x, vertices[j].y); pv.push_back(p); } std::sort(pv.begin(), pv.end(), [](const Point &e1, const Point &e2)->bool { return e2.y() < e1.y(); }); std::stable_sort(pv.begin(), pv.end(), [](const Point &e1, const Point &e2)->bool { return e2.x() < e1.x(); }); pv.erase(std::unique(pv.begin(), pv.end()), pv.end()); if (pv.size() != count && pv.size() < 3) { *err_msg = strdup("After eliminating duplicated points, less than 3 points remain!!. Alpha shape calculation needs at least 3 vertices."); return -1; } points.insert(points.begin(), pv.begin(), pv.end()); } Alpha_shape_2 A(points.begin(), points.end(), coord_type(10000), Alpha_shape_2::REGULARIZED); std::vector<Segment> segments; // std::vector<Segment> result; // Alpha_shape_2::Alpha_shape_vertices_iterator vit; // Alpha_shape_2::Vertex_handle vertex; // Alpha_shape_2::Alpha_shape_edges_iterator eit; // Alpha_shape_2::Edge edge; // Alpha_shape_2::Face_iterator fit; // Alpha_shape_2::Face_handle face; if (alpha <= 0.0) { alpha = *A.find_optimal_alpha(1); } A.set_alpha(alpha); alpha_edges( A, std::back_inserter(segments)); // Segment s = segments.at(0); // find_next_edge(s, segments, result); if (segments.empty()) { *res = NULL; *res_count = 0; } else { std::set<int> unusedIndexes; for (unsigned int i = 0; i < segments.size(); i++) { unusedIndexes.insert(i); } std::vector<Polygon_2> rings; Polygon_2 ring; ring.push_back(segments.at(0).source()); rings.push_back(ring); unusedIndexes.erase(0); find_next_edge(segments.at(0), segments, unusedIndexes, rings); size_t result_count = 0; for (unsigned int i = 0; i < rings.size(); i++) { Polygon_2 ring = rings.at(i); result_count += ring.size(); } result_count += rings.size() - 1; *res = (vertex_t *) malloc(sizeof(vertex_t) * result_count); *res_count = result_count; int idx = 0; for (unsigned int i = 0; i < rings.size(); i++) { if (i > 0) { (*res)[idx].x = DBL_MAX; (*res)[idx].y = DBL_MAX; idx++; } Polygon_2 ring = rings.at(i); for(unsigned int j = 0; j < ring.size(); j++) { Point point = ring.vertex(j); (*res)[idx].x = point.x(); (*res)[idx].y = point.y(); idx++; } } } *err_msg = NULL; return EXIT_SUCCESS; } catch ( ... ) { *err_msg = strdup("Caught unknown expection!"); } return -1; }
int main(int argc, char* argv[]) { //check points flag bool bpoints = false; bool bsegments = false; bool optalpha = false; char* filename; float alpha = -1; for(int i =0; i < argc; i++) { if (strcmp(argv[i],"-p")==0) { bpoints = true; } else if (strcmp(argv[i],"-s")==0) { bsegments = true; } if (strcmp(argv[i],"-a") == 0) { alpha = atof(argv[i+1]); } if (strcmp(argv[i],"--optimalalpha") == 0) { optalpha = true; } if (strcmp(argv[i],"-i") == 0) { filename = argv[i+1]; } if (strcmp(argv[i],"-h") == 0) { print_help(); return 0; } } //File Input std::list<Point> points; if(! file_input(std::back_inserter(points),filename)) { return -1; } //Alpha shape compute Alpha_shape_2 A(points.begin(), points.end()); A.set_mode(Alpha_shape_2::GENERAL); Alpha_iterator opt = A.find_optimal_alpha(1); if (alpha != -1) { A.set_alpha(alpha); } else { A.set_alpha(*opt); } std::vector<Segment> segments; std::vector<Vertex_handle> vertices; std::vector< Polygon_2 > polygons; alpha_edges( A, std::back_inserter(segments)); alpha_vertices( A, std::back_inserter(vertices)); segments_to_polygons(segments, polygons); //Fill and print result if (optalpha) { std::cout << *opt << std::endl; return 0; } if (bpoints) { toWKT_vertices(vertices); } else if (bsegments) { toWKT_segments(segments); } else { toWKT_polygons(polygons); } return 0; }