demo improvement and various clean-ups

Basic_viewer/doc/Basic_viewer/dependencies

@@ -14,3 +14,4 @@ Triangulation_3
 Voronoi_diagram_2
 Kernel_23
 Arrangement_on_surface_2
+Stream_support

GraphicsView/include/CGAL/Qt/GraphicsViewPolygonWithHolesInput.h

@@ -59,6 +59,11 @@ class GraphicsViewPolygonWithHolesInput : public GraphicsViewInput
 public Q_SLOTS:
   void processInput(CGAL::Object o);
 
+  void setZValue(int z)
+  {
+    pi->setZValue(z);
+  }
+
 typedef CGAL::Polygon_2<K> Polygon;
 typedef CGAL::Polygon_with_holes_2<K> Polygon_with_holes;
 
@@ -89,6 +94,7 @@ GraphicsViewPolygonWithHolesInput<K>::GraphicsViewPolygonWithHolesInput(QObject
 {
   pwhItem = new CGAL::Qt::PolygonWithHolesGraphicsItem<Polygon_with_holes>(&pwh);
   pwhItem->setBrush(::Qt::yellow);
+  pwhItem->setZValue(8);
   scene_->addItem(pwhItem);
   pwhItem->hide();
 

GraphicsView/include/CGAL/Qt/GraphicsViewPolylineInput.h

@@ -50,6 +50,11 @@ class CGAL_QT_EXPORT GraphicsViewPolylineInput_non_templated_base : public Graph
 
   bool eventFilter(QObject *obj, QEvent *event);
 
+  void setZValue(int v)
+    {
+      z = v;
+    }
+
 protected:
   // protected constructor
   GraphicsViewPolylineInput_non_templated_base(QObject* parent,
@@ -80,6 +85,7 @@ class CGAL_QT_EXPORT GraphicsViewPolylineInput_non_templated_base : public Graph
   int n_;
   QPointF sp;
   QGraphicsScene *scene_;
+  int z;
 }; // end class GraphicsViewPolylineInput_non_templated_base
 
 template <typename K>

GraphicsView/include/CGAL/Qt/GraphicsViewPolylineInput_impl.h

@@ -82,6 +82,7 @@ GraphicsViewPolylineInput_non_templated_base::mousePressEvent(QGraphicsSceneMous
     qpp.addPolygon(polygon);
     path_item = new QGraphicsPathItem(qpp);
     path_item->setPen(QPen(::Qt::red, 0, ::Qt::SolidLine, ::Qt::RoundCap, ::Qt::RoundJoin));
+    path_item->setZValue(z);
     scene_->addItem(path_item);
     return true;
   }
@@ -98,11 +99,13 @@ GraphicsViewPolylineInput_non_templated_base::rubberbands(const QPointF& p)
   }
   if(!b && closed_ ){
     b = new QGraphicsLineItem();
+    b->setZValue(z);
     b->setPen(QPen(::Qt::red, 0, ::Qt::SolidLine, ::Qt::RoundCap, ::Qt::RoundJoin));
     scene_->addItem(b);
   }
   if( !e){
     e = new QGraphicsLineItem();
+    e->setZValue(z);
     e->setPen(QPen(::Qt::red, 0, ::Qt::SolidLine, ::Qt::RoundCap, ::Qt::RoundJoin));
     scene_->addItem(e);
   }
@@ -165,6 +168,7 @@ GraphicsViewPolylineInput_non_templated_base::keyPressEvent ( QKeyEvent * event
   QPainterPath qpp;
   qpp.addPolygon(polygon);
   path_item = new QGraphicsPathItem(qpp);
+  path_item->setZValue(z);
   path_item->setPen(QPen(::Qt::red, 0, ::Qt::SolidLine, ::Qt::RoundCap, ::Qt::RoundJoin));
   scene_->addItem(path_item);
   rubberbands(sp);

GraphicsView/include/CGAL/Qt/MultipolygonWithHolesGraphicsItem.h

@@ -0,0 +1,235 @@
+// Copyright (c) 2024  GeometryFactory Sarl (France).
+// All rights reserved.
+//
+// This file is part of CGAL (www.cgal.org).
+//
+// $URL$
+// $Id$
+// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
+//
+//
+// Author(s)     : Andreas Fabri <[email protected]>
+//                 Laurent Rineau <[email protected]>
+
+#ifndef CGAL_QT_MULTIPOLYGON_WITH_HOLES_GRAPHICS_ITEM_H
+#define CGAL_QT_MULTIPOLYGON_WITH_HOLES_GRAPHICS_ITEM_H
+
+#include <CGAL/license/GraphicsView.h>
+
+
+#include <CGAL/Bbox_2.h>
+#include <CGAL/Multipolygon_with_holes_2.h>
+#include <CGAL/Qt/PainterOstream.h>
+#include <CGAL/Qt/GraphicsItem.h>
+#include <CGAL/Qt/Converter.h>
+#include <QGraphicsScene>
+#include <QPainter>
+#include <QStyleOption>
+
+namespace CGAL {
+namespace Qt {
+
+template <typename P>
+class MultipolygonWithHolesGraphicsItem : public GraphicsItem
+{
+  typedef typename P::Traits Traits;
+public:
+  MultipolygonWithHolesGraphicsItem(P* p_);
+
+  void modelChanged();
+
+public:
+  QRectF boundingRect() const;
+
+  void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
+
+
+  const QBrush& brush() const
+  {
+    return brush_;
+  }
+
+
+  void setBrush(const QBrush& b)
+  {
+    brush_ = b;
+  }
+
+  const QPen& verticesPen() const
+  {
+    return vertices_pen;
+  }
+
+  const QPen& edgesPen() const
+  {
+    return edges_pen;
+  }
+
+  void setVerticesPen(const QPen& pen)
+  {
+    vertices_pen = pen;
+  }
+
+  void setEdgesPen(const QPen& pen)
+  {
+    edges_pen = pen;
+  }
+
+  bool drawVertices() const
+  {
+    return draw_vertices;
+  }
+
+  void setDrawVertices(const bool b)
+  {
+    draw_vertices = b;
+    update();
+  }
+
+
+protected:
+  void updateBoundingBox();
+
+  P * poly;
+  QPainter* m_painter;
+  PainterOstream<Traits> painterostream;
+
+  typename Traits::Point_2 p;
+  QRectF bounding_rect;
+
+  QBrush brush_;
+  QPen vertices_pen;
+  QPen edges_pen;
+  bool draw_vertices;
+};
+
+
+template <typename P>
+MultipolygonWithHolesGraphicsItem<P>::MultipolygonWithHolesGraphicsItem(P * p_)
+  :  poly(p_), painterostream(0),
+     draw_vertices(true)
+{
+  setVerticesPen(QPen(::Qt::red, 3.));
+  if(poly->number_of_polygons_with_holes() == 0){
+    this->hide();
+  }
+  updateBoundingBox();
+  setZValue(0);
+}
+
+template <typename P>
+QRectF
+MultipolygonWithHolesGraphicsItem<P>::boundingRect() const
+{
+  return bounding_rect;
+}
+
+
+
+
+template <typename P>
+void
+MultipolygonWithHolesGraphicsItem<P>::paint(QPainter *painter,
+                                            const QStyleOptionGraphicsItem * /*option*/,
+                                            QWidget * /*widget*/)
+{
+  using Polygon_with_holes_2 = typename P::Polygon_with_holes_2;
+  using General_polygon_2 = typename Polygon_with_holes_2::General_polygon_2;
+  Converter<Traits> convert;
+
+  for(const auto& pwh : poly->polygons_with_holes()){
+    QPainterPath border;
+    General_polygon_2 boundary =  pwh.outer_boundary();
+    painter->setPen(this->edgesPen());
+
+    typename General_polygon_2::Vertex_iterator it = pwh.outer_boundary().vertices_begin();
+    QPointF firstPoint = convert(*it);
+    border.moveTo(firstPoint);
+    painterostream = PainterOstream<Traits>(painter);
+
+    for(++it;
+        it != pwh.outer_boundary().vertices_end();
+        ++it){
+      border.lineTo(convert(*it));
+    }
+    border.lineTo(firstPoint);
+
+
+    for(typename Polygon_with_holes_2::Hole_const_iterator hit = pwh.holes_begin();
+        hit != pwh.holes_end();
+        ++hit){
+      typename General_polygon_2::Vertex_iterator it = hit->vertices_begin();
+      QPointF firstPoint = convert(*it);
+      border.moveTo(firstPoint);
+      for(++it;
+          it != hit->vertices_end();
+          ++it){
+        border.lineTo(convert(*it));
+      }
+      border.lineTo(firstPoint);
+    }
+
+    painter->setBrush(this->brush());
+    painter->drawPath(border);
+  }
+
+
+  if(drawVertices()) {
+    painter->setPen(verticesPen());
+    QTransform matrix = painter->worldTransform();
+    painter->resetTransform();
+
+    for(const auto& pwh : poly->polygons_with_holes()){
+      for(typename General_polygon_2::Vertex_iterator it = pwh.outer_boundary().vertices_begin();
+          it != pwh.outer_boundary().vertices_end();
+          it++){
+        QPointF point = matrix.map(convert(*it));
+        painter->drawPoint(point);
+      }
+      for(typename Polygon_with_holes_2::Hole_const_iterator hit = pwh.holes_begin();
+          hit != pwh.holes_end();
+          ++hit){
+        for(typename General_polygon_2::Vertex_iterator it = hit->vertices_begin();
+          it != hit->vertices_end();
+          it++){
+        QPointF point = matrix.map(convert(*it));
+        painter->drawPoint(point);
+      }
+      }
+    }
+  }
+}
+
+// We let the bounding box only grow, so that when vertices get removed
+// the maximal bbox gets refreshed in the GraphicsView
+template <typename P>
+void
+MultipolygonWithHolesGraphicsItem<P>::updateBoundingBox()
+{
+  Converter<Traits> convert;
+  prepareGeometryChange();
+  if(poly->number_of_polygons_with_holes() == 0){
+    return;
+  }
+  bounding_rect = convert(poly->bbox());
+}
+
+
+template <typename P>
+void
+MultipolygonWithHolesGraphicsItem<P>::modelChanged()
+{
+  if((poly->number_of_polygons_with_holes() == 0) ){
+    this->hide();
+  } else if((poly->number_of_polygons_with_holes() > 0) && (! this->isVisible())){
+    this->show();
+  }
+  updateBoundingBox();
+  update();
+}
+
+
+} // namespace Qt
+} // namespace CGAL
+
+#endif // CGAL_QT_MYLTIPOLYGON_WITH_HOLES_GRAPHICS_ITEM_H

Polygon/doc/Polygon/Concepts/GeneralPolygonWithHoles_2.h

@@ -85,6 +85,7 @@ Hole_const_iterator holes_end() const;
 
 /*! returns the range of holes.
  */
+
 const Holes_container& holes() const;
 
 /// @}

Polygon/include/CGAL/Multipolygon_with_holes_2.h

@@ -46,6 +46,7 @@ class Multipolygon_with_holes_2 {
 
   /// @}
 
+  using Traits = Kernel;
   using value_type = Polygon_with_holes_2;
   using Polygon_with_holes_container = std::deque<Polygon_with_holes_2>;
 

Polygon_repair/examples/Polygon_repair/repair_polygon_2.cpp

@@ -1,5 +1,6 @@
 #include <iostream>
 #include <fstream>
+#include <string>
 
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 #include <CGAL/Polygon_repair/repair.h>
@@ -11,8 +12,11 @@ using Polygon_2 = CGAL::Polygon_2<Kernel>;
 using Polygon_with_holes_2 = CGAL::Polygon_with_holes_2<Kernel>;
 using Multipolygon_with_holes_2 = CGAL::Multipolygon_with_holes_2<Kernel>;
 
-int main() {
-  std::ifstream in("data/bridge-edge.wkt");
+int main(int argc, char* argv[]) {
+
+  char* filename = (argc > 1) ? argv[1] : "data/bridge-edge.wkt";
+
+  std::ifstream in(filename);
   Polygon_with_holes_2 pin;
   CGAL::IO::read_polygon_WKT(in, pin);