Deal with -1

Kinetic_space_partition/include/CGAL/KSP_3/Data_structure.h

@@ -391,8 +391,9 @@ public:
     Direction_2 to_source(s - centroid);
     Direction_2 to_target(t - centroid);
 
-    std::size_t source_idx = -1;
+    const std::size_t uninitialized = static_cast<std::size_t>(-1);
-    std::size_t target_idx = -1;
+    std::size_t source_idx = uninitialized;
+    std::size_t target_idx = uninitialized;
 
     event.crossed_edge = edge;
     event.support_plane = sp_idx;
@@ -406,15 +407,15 @@ public:
       event.face = faces.first;
 
     for (std::size_t i = 0; i < sp.data().original_directions.size(); i++) {
-      if (source_idx == -1 && sp.data().original_directions[i] > to_source)
+      if (source_idx == uninitialized && sp.data().original_directions[i] > to_source)
         source_idx = i;
 
-      if (target_idx == -1 && sp.data().original_directions[i] > to_target)
+      if (target_idx == uninitialized && sp.data().original_directions[i] > to_target)
         target_idx = i;
     }
 
-    source_idx = (source_idx == -1) ? 0 : source_idx;
+    source_idx = (source_idx == uninitialized) ? 0 : source_idx;
-    target_idx = (target_idx == -1) ? 0 : target_idx;
+    target_idx = (target_idx == uninitialized) ? 0 : target_idx;
 
     std::size_t num;
 
@@ -608,7 +609,8 @@ public:
   template<typename PointRange>
   std::pair<std::size_t, bool> add_support_plane(const PointRange& polygon, const bool is_bbox, const typename Intersection_kernel::Plane_3& plane) {
     const Support_plane new_support_plane(polygon, is_bbox, plane);
-    std::size_t support_plane_idx = std::size_t(-1);
+    const std::size_t uninitialized = static_cast<std::size_t>(-1);
+    std::size_t support_plane_idx = uninitialized;
 
     for (std::size_t i = 0; i < number_of_support_planes(); ++i) {
       if (new_support_plane == support_plane(i)) {
@@ -617,7 +619,7 @@ public:
       }
     }
 
-    if (support_plane_idx == std::size_t(-1)) {
+    if (support_plane_idx == uninitialized) {
       support_plane_idx = number_of_support_planes();
       m_support_planes.push_back(new_support_plane);
     }
@@ -633,7 +635,8 @@ public:
   template<typename PointRange>
   std::pair<std::size_t, bool> add_support_plane(const PointRange& polygon, const bool is_bbox) {
     const Support_plane new_support_plane(polygon, is_bbox);
-    std::size_t support_plane_idx = std::size_t(-1);
+    const std::size_t uninitialized = static_cast<std::size_t>(- 1);
+    std::size_t support_plane_idx = uninitialized;
 
     for (std::size_t i = 0; i < number_of_support_planes(); ++i) {
       if (new_support_plane == support_plane(i)) {
@@ -642,7 +645,7 @@ public:
       }
     }
 
-    if (support_plane_idx == std::size_t(-1)) {
+    if (support_plane_idx == uninitialized) {
       support_plane_idx = number_of_support_planes();
       m_support_planes.push_back(new_support_plane);
     }
@@ -778,13 +781,14 @@ public:
       const auto& iplanes0 = all_iplanes[i];
       const auto& iplanes1 = all_iplanes[ip];
 
-      std::size_t common_bbox_plane_idx = std::size_t(-1);
+      const std::size_t uninitialized = static_cast<std::size_t>(-1);
+      std::size_t common_bbox_plane_idx = uninitialized;
       bool dump = false;
       const std::function<void(const std::size_t& idx)> lambda =
         [&](const std::size_t& idx) {
         if (idx < 6) {
 
-          if (common_bbox_plane_idx != std::size_t(-1))
+          if (common_bbox_plane_idx != uninitialized)
             dump = true;
           common_bbox_plane_idx = idx;
         }
@@ -808,11 +812,11 @@ public:
         vout.close();
       }
 
-      CGAL_assertion(common_bbox_plane_idx != std::size_t(-1));
+      CGAL_assertion(common_bbox_plane_idx != uninitialized);
       common_bbox_planes_idx.push_back(common_bbox_plane_idx);
 
       const auto pair = map_lines_idx.insert(
-        std::make_pair(common_bbox_plane_idx, std::size_t(-1)));
+        std::make_pair(common_bbox_plane_idx, uninitialized));
       const bool is_inserted = pair.second;
       if (is_inserted) {
         typename Intersection_kernel::Line_3 line;
@@ -874,10 +878,11 @@ public:
   template<typename PointRange>
   void add_bbox_polygon(const PointRange& polygon) {
     bool is_added = true;
-    std::size_t support_plane_idx = std::size_t(-1);
+    const std::size_t uninitialized = static_cast<std::size_t>(-1);
+    std::size_t support_plane_idx = uninitialized;
     std::tie(support_plane_idx, is_added) = add_support_plane(polygon, true);
     CGAL_assertion(is_added);
-    CGAL_assertion(support_plane_idx != std::size_t(-1));
+    CGAL_assertion(support_plane_idx != uninitialized);
 
     std::array<IVertex, 4> ivertices;
     std::array<Point_2, 4> points;

Kinetic_space_partition/include/CGAL/KSP_3/Finalizer.h

@@ -88,8 +88,8 @@ private:
     std::size_t index;
     std::size_t input;
     Face_info() :
-      index(-1),
+      index(static_cast<std::size_t>(-1)),
-      input(-1)
+      input(static_cast<std::size_t>(-1))
     { }
   };
 
@@ -254,7 +254,8 @@ private:
     auto& pair = map_volumes.at(pface);
     if (pair.first != -1 && pair.second != -1) return;
 
-    std::size_t volume_indices[] = { static_cast<std::size_t>(-1), static_cast<std::size_t>(-1) };
+    const std::size_t uninitialized = static_cast<std::size_t>(-1);
+    std::size_t volume_indices[] = { uninitialized, uninitialized };
     //std::size_t other[] = { static_cast<std::size_t>(-1), static_cast<std::size_t>(-1) };
 
     // Start new volume cell
@@ -300,11 +301,11 @@ private:
         Oriented_side inverse_side = oriented_side(neighbor, pface);
         CGAL_assertion(side != COPLANAR && inverse_side != COPLANAR);
 
-        if (side == ON_POSITIVE_SIDE && volume_indices[0] != static_cast<std::size_t>(-1)) {
+        if (side == ON_POSITIVE_SIDE && volume_indices[0] != uninitialized) {
           if (associate(neighbor, volume_indices[0], inverse_side, volumes, map_volumes))
             queue[0].push(std::make_pair(neighbor, inverse_side));
         }
-        else if (side == ON_NEGATIVE_SIDE && volume_indices[1] != static_cast<std::size_t>(-1))
+        else if (side == ON_NEGATIVE_SIDE && volume_indices[1] != uninitialized)
           if (associate(neighbor, volume_indices[1], inverse_side, volumes, map_volumes))
             queue[1].push(std::make_pair(neighbor, inverse_side));
 
@@ -316,13 +317,13 @@ private:
       find_adjacent_faces(pface, pedge, neighbor_faces, positive_side, negative_side);
       CGAL_assertion(positive_side != negative_side);
 
-      if (volume_indices[0] != -1) {
+      if (volume_indices[0] != uninitialized) {
         Oriented_side inverse_side = (positive_side.first == pface.first) ? ON_POSITIVE_SIDE : oriented_side(positive_side, pface);
         if (associate(positive_side, volume_indices[0], inverse_side, volumes, map_volumes))
           queue[0].push(std::make_pair(positive_side, inverse_side));
       }
 
-      if (volume_indices[1] != -1) {
+      if (volume_indices[1] != uninitialized) {
         Oriented_side inverse_side = (negative_side.first == pface.first) ? ON_NEGATIVE_SIDE : oriented_side(negative_side, pface);
         if (associate(negative_side, volume_indices[1], inverse_side, volumes, map_volumes))
           queue[1].push(std::make_pair(negative_side, inverse_side));
@@ -331,7 +332,7 @@ private:
 
     // Propagate both queues if volumes on either side of the pface are not segmented.
     for (std::size_t i = 0; i < 2; i++) {
-      if (volume_indices[i] != -1) {
+      if (volume_indices[i] != uninitialized) {
         while (!queue[i].empty()) {
           propagate_volume(queue[i], volume_indices[i], volumes, map_volumes);
         }

Kinetic_space_partition/include/CGAL/KSP_3/Initializer.h

@@ -162,7 +162,7 @@ private:
     std::size_t iterations = 0;
 
     int dir = (cw) ? -1 : 1;
-
+    const std::size_t uninitialized = static_cast<std::size_t>(-1);
     std::size_t inext;
     while (s != m_data.target(next) && iterations < 10000) {
       face.vertices.push_back(m_data.target(next));
@@ -173,14 +173,14 @@ private:
 
       std::vector<std::pair<IEdge, Direction_2> > connected;
       m_data.get_and_sort_all_connected_iedges(sp_idx, m_data.target(next), connected);
-      inext = -1;
+      inext = uninitialized;
       for (std::size_t idx = 0; idx < connected.size(); idx++) {
         if (connected[idx].first == next) {
           inext = (idx + dir + connected.size()) % connected.size();
           break;
         }
       }
-      CGAL_assertion(inext != static_cast<std::size_t>(-1));
+      CGAL_assertion(inext != uninitialized);
 
       next = connected[inext].first;
       face.edges.push_back(next);

Kinetic_space_partition/include/CGAL/KSP_3/Intersection_graph.h

@@ -109,7 +109,7 @@ public:
   using IEdge_set = std::set<Edge_descriptor, lex>;
 
   struct Face_property {
-    Face_property() : support_plane(-1), part_of_partition(false) {}
+    Face_property() : support_plane(static_cast<std::size_t>(-1)), part_of_partition(false) {}
     Face_property(std::size_t support_plane_idx) : support_plane(support_plane_idx), part_of_partition(false) {}
     std::size_t support_plane;
     bool part_of_partition;

Kinetic_space_partition/include/CGAL/KSP_3/Support_plane.h

@@ -160,7 +160,7 @@ public:
     m_data->is_bbox = is_bbox;
     m_data->distance_tolerance = 0;
     m_data->angle_tolerance = 0;
-    m_data->actual_input_polygon = -1;
+    m_data->actual_input_polygon = static_cast<std::size_t>(- 1);
 
     std::vector<Triangle_2> tris(points.size() - 2);
     for (std::size_t i = 2; i < points.size(); i++) {
@@ -241,7 +241,7 @@ public:
     m_data->is_bbox = is_bbox;
     m_data->distance_tolerance = 0;
     m_data->angle_tolerance = 0;
-    m_data->actual_input_polygon = -1;
+    m_data->actual_input_polygon = static_cast<std::size_t>(- 1);
 
     std::vector<Triangle_2> tris(points.size() - 2);
     for (std::size_t i = 2; i < points.size(); i++) {

Kinetic_space_partition/include/CGAL/Kinetic_space_partition_3.h

@@ -205,7 +205,7 @@ private:
 
 private:
   struct Sub_partition {
-    Sub_partition() : parent(-1) {}
+    Sub_partition() : parent(static_cast<std::size_t>(- 1)) {}
     std::shared_ptr<Data_structure> m_data;
     std::array<typename Intersection_kernel::Point_3, 8> bbox;
     std::vector<typename Intersection_kernel::Plane_3> m_bbox_planes;