Simplest way to use `CGAL::simplify` on a 2D Arrangement?

Question

I have a CGAL 2D Arrangement, and I would like to simplify each sequence of egdes separated by degree-2 vertices using CGAL::simplify. Is there a simple way to do that, or do I have to do something like the following:

1. extract such sequences,
2. simplify each sequence,
3. modify the sequences in the arrangement?

Note that I would like to end up with a simplified 2D arrangement, not just a list of polylines, so using CGAL::split_graph_into_polylines does not seem to be the best option.

I had a look at CGAL manual and examples, but could not find an answer.

Answer 1

The function that you describe does not exist in the 2D Arrangements package. I'll consider adding it, but it only requires few lines of code. I changed the edge_manipulation example a bit to do what you describe. In particular, look for the loop over the vertices in the code below.

#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
#include <CGAL/Arr_segment_traits_2.h>
#include <CGAL/Arrangement_2.h>
#include <CGAL/draw_arrangement_2.h>

using Kernel = CGAL::Exact_predicates_exact_constructions_kernel;
using Traits = CGAL::Arr_segment_traits_2<Kernel>;
using Point = Traits::Point_2;
using Segment = Traits::X_monotone_curve_2;
using Arrangement = CGAL::Arrangement_2<Traits>;
using Halfedge_handle = Arrangement::Halfedge_handle;

int main() {
  // Step (a)---construct a rectangular face.
  Point q1(1, 3), q2(3, 5), q3(5, 3), q4(3, 1);
  Segment s4(q1, q2), s1(q2, q3), s3(q3, q4), s2(q4, q1);

  Traits traits;
  Arrangement arr(&traits);
  Halfedge_handle e1 = arr.insert_in_face_interior(s1, arr.unbounded_face());
  Halfedge_handle e2 = arr.insert_in_face_interior(s2, arr.unbounded_face());

  e2 = e2->twin();     // as we wish e2 to be directed from right to left
  arr.insert_at_vertices(s3, e1->target(), e2->source());
  arr.insert_at_vertices(s4, e2->target(), e1->source());
  std::cout << "After step (a):\n";
  std::cout << arr.number_of_vertices() << ","
            << arr.number_of_edges() << ","
            << arr.number_of_faces() << std::endl;

  // Step (b)---split e1 and e2 and connect the split points with a segment.
  Point p1(4,4), p2(2,2);
  Segment s1_1(q2, p1), s1_2(p1, q3), s2_1(q4, p2), s2_2(p2, q1), s(p1, p2);

  e1 = arr.split_edge(e1, s1_1, s1_2);
  e2 = arr.split_edge(e2, s2_1, s2_2);
  Halfedge_handle e = arr.insert_at_vertices(s, e1->target(), e2->target());
  std::cout << std::endl << "After step (b):" << std::endl;
  std::cout << arr.number_of_vertices() << ","
            << arr.number_of_edges() << ","
            << arr.number_of_faces() << std::endl;

  // Step (c)---remove the edge e and merge e1 and e2 with their successors.
  arr.remove_edge(e);
  CGAL::draw(arr, "example", true);
#if 1
  auto is_mergeable = traits.are_mergeable_2_object();
  auto merge = traits.merge_2_object();
  for (auto v = arr.vertices_begin(); v != arr.vertices_end(); ++v) {
    if (v->degree() > 2) continue;
    auto e = v->incident_halfedges();
    if (! is_mergeable(e->curve(), e->next()->curve())) continue;
    Segment c;
    merge(e->curve(), e->next()->curve(), c);
    arr.merge_edge(e, e->next(), c);
  }
#else
  arr.merge_edge(e1, e1->next(), s1);
  arr.merge_edge(e2, e2->next(), s2);
#endif
  CGAL::draw(arr, "example", true);
  std::cout << std::endl << "After step (c):\n";
  std::cout << arr.number_of_vertices() << ","
            << arr.number_of_edges() << ","
            << arr.number_of_faces() << std::endl;

  return 0;
}