CLION中CGAL顶点迭代器无补全及多边形顶点整数坐标获取问题

Let's tackle your two CGAL + CLion issues one by one:

1. Fixing Point Type & Vertex Iterator Recognition/Autocompletion in CLion #

CLion (and most IDEs) often struggles with CGAL's heavily templated codebase—especially nested types like Point_2 from the kernel and iterator types typedef'd inside template classes like Polygon_2. Here's how to resolve this:

• Use explicit top-level typedefs to simplify type resolution for the IDE:

  #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
  #include <CGAL/Polygon_2.h>
  
  // Explicit typedefs make it easier for CLion to parse and autocomplete
  typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel;
  typedef Kernel::Point_2 Point;
  typedef CGAL::Polygon_2<Kernel> Polygon;
  

  By defining these typedefs, you eliminate the nested template hierarchy that confuses CLion's code parser, making Point and Polygon::Vertex_iterator visible for autocompletion.

• Enable compile commands export in your CMakeLists.txt:
  Add this line to generate a compile_commands.json file, which CLion uses to accurately index your project's dependencies and types:

  set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
  

  After updating CMake, regenerate your project and trigger a reindex via File > Invalidate Caches... > Invalidate and Restart if autocompletion still doesn't work.

• Verify CGAL is properly indexed:
  Check that CLion recognizes your CGAL installation path. Go to File > Settings > Build, Execution, Deployment > CMake and ensure CGAL's include directories are listed in the project's include paths. If not, explicitly add them in your CMakeLists.txt with include_directories().

2. Iterating Over Polygon Vertices & Getting Integer Coordinates #

The Exact_predicates_exact_constructions_kernel uses exact number types (like CGAL::Exact_rational) instead of int or double to avoid floating-point errors—that's why p.x() returns an unfamiliar type. Here's how to handle this:

Step 1: Iterate over vertices #

You can use a range-based for loop (C++11+) or explicit iterators to traverse the polygon's vertices:

Polygon poly;
// Assume poly is populated with vertices...

// Simplest approach: range-based for loop
for (const Point& p : poly) {
  // Process vertex p here
}

// Using Vertex_iterator explicitly
for (Polygon::Vertex_iterator it = poly.vertices_begin(); it != poly.vertices_end(); ++it) {
  const Point& p = *it;
  // Process vertex p here
}

Step 2: Convert exact coordinates to integers #

Exact rational types store values as fractions. If your vertices have integer coordinates, the denominator will always be 1. You can safely convert them to integers with these methods:

#include <CGAL/number_utils.h> // For CGAL::to_double() if needed

for (const Point& p : poly) {
  const Kernel::FT x = p.x();
  const Kernel::FT y = p.y();

  // Safe conversion if you know coordinates are integers
  int x_int = static_cast<int>(CGAL::to_double(x));
  int y_int = static_cast<int>(CGAL::to_double(y));

  // For extra safety, verify the denominator is 1 first
  if (x.denominator() == 1 && y.denominator() == 1) {
    x_int = static_cast<int>(x.numerator());
    y_int = static_cast<int>(y.numerator());
    // Use x_int and y_int here
  } else {
    // Handle non-integer coordinates (e.g., convert to double)
    double x_double = CGAL::to_double(x);
    double y_double = CGAL::to_double(y);
  }
}

Optional: Switch to a simpler kernel #

If you don't need exact arithmetic, use CGAL::Simple_cartesian<double> instead—this kernel uses double for coordinates, so p.x() will return a double directly, which you can cast to int if needed. Just note this introduces floating-point precision risks.

内容的提问来源于stack exchange，提问作者Yannic