GSoC'22: New CGAL's design to handle basic viewers

BGL/include/CGAL/draw_face_graph.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2020 GeometryFactory (France)
+// Copyright (c) 2018-2022 GeometryFactory (France)
 // All rights reserved.
 //
 // This file is part of CGAL (www.cgal.org).
@@ -9,189 +9,151 @@
 //
 // Author(s)     : Guillaume Damiand <[email protected]>
 //                 Laurent Rineau <[email protected]>
+//                 Mostafa Ashraf <[email protected]>
 
 #ifndef CGAL_DRAW_FACE_GRAPH_H
 #define CGAL_DRAW_FACE_GRAPH_H
 
-#ifdef CGAL_USE_BASIC_VIEWER
-
+#include <CGAL/Graphic_buffer.h>
+#include <CGAL/Drawing_functor.h>
 #include <CGAL/Dynamic_property_map.h>
 #include <CGAL/Random.h>
 #include <CGAL/boost/graph/helpers.h>
 
-namespace CGAL
-{
+namespace CGAL {
 
-// Default color functor; user can change it to have its own face color
-struct DefaultColorFunctorFaceGraph
-{
-  template<typename Graph>
-  CGAL::IO::Color operator()(const Graph&,
-                         typename boost::graph_traits<Graph>::face_descriptor fh) const
-  {
-    if (fh==boost::graph_traits<Graph>::null_face()) // use to get the mono color
-      return CGAL::IO::Color(100, 125, 200); // R G B between 0-255
-
-    return get_random_color(CGAL::get_default_random());
-  }
-};
+namespace draw_function_for_FG {
 
-class SimpleFaceGraphViewerQt : public Basic_viewer_qt
+template <typename BufferType=float, typename FG, typename DrawingFunctor>
+void compute_elements(const FG &fg,
+                      CGAL::Graphic_buffer<BufferType> &graphic_buffer,
+                      const DrawingFunctor &m_drawing_functor)
 {
-  using Base = Basic_viewer_qt;
-
-public:
-  SimpleFaceGraphViewerQt(QWidget* parent) :
-    Base(parent, "", false, true, true, true, false),
-    m_compute_elements_impl([]{})
-  {
-  }
-
-  /// Construct the viewer.
-  /// @param amesh the surface mesh to view
-  /// @param title the title of the window
-  /// @param anofaces if true, do not draw faces (faces are not computed; this can be
-  ///        usefull for very big object where this time could be long)
-  template <typename SM>
-  SimpleFaceGraphViewerQt(QWidget* parent,
-                          const SM& amesh,
-                          const char* title="Basic Surface_mesh Viewer",
-                          bool anofaces=false) :
-    SimpleFaceGraphViewerQt(parent, amesh, title, anofaces, DefaultColorFunctorFaceGraph())
-  {
-  }
+  using Point=typename boost::property_map_value<FG, CGAL::vertex_point_t>::type;
+  using Kernel = typename CGAL::Kernel_traits<Point>::Kernel;
+  using Vector = typename Kernel::Vector_3;
 
-  template <typename SM, typename ColorFunctor>
-  SimpleFaceGraphViewerQt(QWidget* parent,
-                          const SM& amesh,
-                          const char* title,
-                          bool anofaces,
-                          ColorFunctor fcolor) :
-    // First draw: no vertex; edges, faces; mono-color; inverse normal
-    Base(parent, title, false, true, true, true, false),
-    m_compute_elements_impl(compute_elements_functor(amesh, anofaces, fcolor))
+  auto vnormals = get(CGAL::dynamic_vertex_property_t<Vector>(), fg);
+  auto point_pmap = get(CGAL::vertex_point, fg);
+  for (auto v : vertices(fg))
   {
-  }
-
-  void init() override {
-    compute_elements();
-    Base::init();
-  }
-
-  void compute_elements() {
-    m_compute_elements_impl();
-  }
-
-  template <typename SM, typename ColorFunctor>
-  void set_face_graph(const SM& amesh,
-                      bool anofaces,
-                      ColorFunctor fcolor) {
-    m_compute_elements_impl = compute_elements_functor(amesh, anofaces, fcolor);
-  }
-
-  template <typename SM, typename ColorFunctor>
-  void set_face_graph(const SM& amesh,
-                      bool anofaces=false) {
-    set_mesh(amesh, anofaces, DefaultColorFunctorFaceGraph());
-  }
-protected:
-  template <typename SM, typename ColorFunctor>
-  std::function<void()>
-  compute_elements_functor(const SM& sm,
-                           bool anofaces,
-                           ColorFunctor fcolor)
-  {
-    using Point =
-        typename boost::property_map_value<SM, CGAL::vertex_point_t>::type;
-    using Kernel = typename CGAL::Kernel_traits<Point>::Kernel;
-    using Vector = typename Kernel::Vector_3;
-
-    auto vnormals = get(CGAL::dynamic_vertex_property_t<Vector>(), sm);
-    auto point_pmap = get(CGAL::vertex_point, sm);
-    for (auto v : vertices(sm))
+    Vector n(NULL_VECTOR);
+    int i = 0;
+    for (auto h : halfedges_around_target(halfedge(v, fg), fg))
     {
-      Vector n(NULL_VECTOR);
-      int i=0;
-      for (auto h : halfedges_around_target(halfedge(v, sm), sm))
+      if (!is_border(h, fg))
       {
-        if (!is_border(h, sm))
+        Vector ni = CGAL::cross_product(
+            Vector(get(point_pmap, source(h, fg)),
+                    get(point_pmap, target(h, fg))),
+            Vector(get(point_pmap, target(h, fg)),
+                    get(point_pmap, target(next(h, fg), fg))));
+        if (ni != NULL_VECTOR)
         {
-          Vector ni = CGAL::cross_product(
-                        Vector(get(point_pmap, source(h, sm)), get(point_pmap, target(h, sm))),
-                        Vector(get(point_pmap, target(h, sm)), get(point_pmap, target(next(h, sm), sm))));
-          if (ni != NULL_VECTOR)
-          {
-            n+=ni;
-            ++i;
-          }
+          n += ni;
+          ++i;
         }
       }
-      put(vnormals, v, n/i);
     }
+    put(vnormals, v, n / i);
+  }
 
-    // This function return a lambda expression, type-erased in a
-    // `std::function<void()>` object.
-    return [this, &sm, vnormals, anofaces, fcolor, point_pmap]()
+  if (m_drawing_functor.are_faces_enabled())
+  {
+    for (auto fh : faces(fg))
     {
-      this->clear();
-
-      if (!anofaces)
+      if (fh != boost::graph_traits<FG>::null_face() && // face exists
+          !m_drawing_functor.face_wireframe(fg, fh) && // face is not wireframe
+          m_drawing_functor.colored_face(fg, fh)) // and face is colored
       {
-        for (auto fh: faces(sm))
+        graphic_buffer.face_begin(m_drawing_functor.face_color(fg, fh));
+        auto hd = halfedge(fh, fg);
+        const auto first_hd = hd;
+        do
         {
-          if (fh!=boost::graph_traits<SM>::null_face())
-          {
-            CGAL::IO::Color c=fcolor(sm, fh);
-            face_begin(c);
-            auto hd=halfedge(fh, sm);
-            const auto first_hd = hd;
-            do
-              {
-                auto v = source(hd, sm);
-                add_point_in_face(get(point_pmap, v), get(vnormals, v));
-                hd=next(hd, sm);
-              }
-            while(hd!=first_hd);
-            face_end();
-          }
+          auto v = source(hd, fg);
+          graphic_buffer.add_point_in_face(get(point_pmap, v), get(vnormals, v));
+          hd = next(hd, fg);
         }
+        while (hd != first_hd);
+        graphic_buffer.face_end();
       }
+    }
+  }
 
-      for (auto e: edges(sm))
-      {
-        add_segment(get(point_pmap, source(halfedge(e, sm), sm)),
-                    get(point_pmap, target(halfedge(e, sm), sm)));
+  if(m_drawing_functor.are_edges_enabled())
+  {
+    for (auto e : edges(fg))
+    {
+      if(m_drawing_functor.colored_edge(fg, e)) // edge is colored
+      { 
+        graphic_buffer.add_segment(get(point_pmap, source(halfedge(e, fg), fg)),
+                                   get(point_pmap, target(halfedge(e, fg), fg)),
+                                   m_drawing_functor.edge_color(fg, e));
       }
-
-      for (auto v: vertices(sm))
+      else
       {
-        this->add_point(get(point_pmap, v));
+        graphic_buffer.add_segment(get(point_pmap, source(halfedge(e, fg), fg)),
+                                   get(point_pmap, target(halfedge(e, fg), fg)));
       }
-    };
+    }
   }
 
-  void keyPressEvent(QKeyEvent *e) override
+  if(m_drawing_functor.are_vertices_enabled())
   {
-    // Test key pressed:
-    //    const ::Qt::KeyboardModifiers modifiers = e->modifiers();
-    //    if ((e->key()==Qt::Key_PageUp) && (modifiers==Qt::NoButton)) { ... }
-
-    // Call: * compute_elements() if the model changed, followed by
-    //       * redraw() if some viewing parameters changed that implies some
-    //                  modifications of the buffers
-    //                  (eg. type of normal, color/mono)
-    //       * update() just to update the drawing
-
-    // Call the base method to process others/classicals key
-    Base::keyPressEvent(e);
+    for (auto v : vertices(fg))
+    {
+      if(m_drawing_functor.colored_vertex(fg, v)) // vertex is colored
+      { 
+        graphic_buffer.add_point(get(point_pmap, v),
+                                 m_drawing_functor.vertex_color(fg, v));
+      }
+      else
+      { 
+        graphic_buffer.add_point(get(point_pmap, v));
+      }
+    }
   }
+}
 
-protected:
-  std::function<void()> m_compute_elements_impl;
-};
+} // draw_function_for_FG
+
+template <typename BufferType=float, class FG, class DrawingFunctor>
+void add_in_graphic_buffer_for_fg(const FG &fg,
+                                  CGAL::Graphic_buffer<BufferType> &graphic_buffer,
+                                  const DrawingFunctor &drawing_functor)
+{
+  draw_function_for_FG::compute_elements(fg, graphic_buffer, drawing_functor);
+}
+
+template <typename BufferType=float, class FG>
+void add_in_graphic_buffer_for_fg(const FG &fg,
+                                  CGAL::Graphic_buffer<BufferType> &graphic_buffer)
+{
+  Drawing_functor<FG,
+                  typename boost::graph_traits<FG>::vertex_descriptor,
+                  typename boost::graph_traits<FG>::edge_descriptor,
+                  typename boost::graph_traits<FG>::face_descriptor>
+      drawing_functor;
+
+  drawing_functor.colored_face = [](const FG&,
+             typename boost::graph_traits<FG>::face_descriptor) -> bool
+  { return true; };
 
-} // End namespace CGAL
 
-#endif // CGAL_USE_BASIC_VIEWER
+  drawing_functor.face_color =  [] (const FG&,
+             typename boost::graph_traits<FG>::face_descriptor fh) -> CGAL::IO::Color
+  {
+    if (fh==boost::graph_traits<FG>::null_face())
+    { return CGAL::IO::Color(100, 125, 200); }
+
+    // TODO (?) use a seed given fh (cannot directly cast because FG is either a polyhedron or a surface mesh)
+    return get_random_color(CGAL::get_default_random());
+  };
+
+  add_in_graphic_buffer_for_fg(fg, graphic_buffer, drawing_functor);
+}
+
+} // End namespace CGAL
 
 #endif // CGAL_DRAW_SURFACE_MESH_H

CGAL_basic_viewers/doc/CGAL_basic_viewers/CGAL_basic_viewers.txt

@@ -0,0 +1,13 @@
+namespace CGAL {
+/*!
+
+\mainpage User Manual
+\anchor Chapter_CGAL_Basic_viewers
+\anchor
+\cgalAutoToc
+\author Guillaume Damiand, Mostafa Ashraf
+
+
+*/
+
+} /* namespace CGAL */

CGAL_basic_viewers/doc/CGAL_basic_viewers/Doxyfile.in

@@ -0,0 +1,3 @@
+@INCLUDE = ${CGAL_DOC_PACKAGE_DEFAULTS}
+
+PROJECT_NAME = "CGAL ${CGAL_DOC_VERSION} - CGAL and Basic Viewers"

CGAL_basic_viewers/examples/CGAL_basic_viewers/CMakeLists.txt

@@ -0,0 +1,21 @@
+# Created by the script cgal_create_cmake_script
+# This is the CMake script for compiling a CGAL application.
+
+#/!\ /!\
+#/!\ /!\
+# Used in /CGAL/Documentation/doc/Documentation/Developer_manual/create_and_use_a_cmakelist.txt.
+# Careful when modifying
+
+cmake_minimum_required(VERSION 3.1...3.23)
+project(CGAL_basic_viewers)
+
+#CGAL_Qt5 is needed for the drawing.
+find_package(CGAL REQUIRED OPTIONAL_COMPONENTS Qt5)
+
+create_single_source_cgal_program("draw_surface_mesh_small_faces.cpp")
+if(CGAL_Qt5_FOUND)
+  #link it with the required CGAL libraries
+  target_link_libraries(draw_surface_mesh_small_faces PUBLIC CGAL::CGAL_Basic_viewer)
+endif()
+
+#end of the file

CGAL_basic_viewers/examples/CGAL_basic_viewers/draw_surface_mesh_small_faces.cpp

@@ -0,0 +1,27 @@
+#include <CGAL/license/Surface_mesh.h>
+#include <CGAL/Graphic_buffer.h>
+#include <CGAL/Drawing_functor.h>
+#include <CGAL/Qt/Basic_viewer_qt.h>
+#include <CGAL/Surface_mesh.h>
+#include <CGAL/draw_surface_mesh.h>
+#include <fstream>
+
+typedef CGAL::Simple_cartesian<double>                       Kernel;
+typedef Kernel::Point_3                                      Point;
+typedef CGAL::Surface_mesh<Point>                            Mesh;
+
+int main(int argc, char* argv[])
+{
+  const std::string filename = (argc>1) ? argv[1] : CGAL::data_file_path("meshes/elephant.off");
+
+  Mesh sm;
+  if(!CGAL::IO::read_polygon_mesh(filename, sm))
+  {
+    std::cerr << "Invalid input file." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  CGAL::draw(sm);
+
+  return EXIT_SUCCESS;
+}

Documentation/doc/Documentation/packages.txt

@@ -167,5 +167,6 @@
 
 \package_listing{GraphicsView}
 \package_listing{CGAL_ipelets}
+\package_listing{CGAL_basic_viewers}
 
 */

GraphicsView/include/CGAL/Buffer_for_vao.h

@@ -163,6 +163,7 @@ class Buffer_for_vao
     if (m_index_buffer!=nullptr)          { m_index_buffer->clear(); }
     if (m_flat_normal_buffer!=nullptr)    { m_flat_normal_buffer->clear(); }
     if (m_gouraud_normal_buffer!=nullptr) { m_gouraud_normal_buffer->clear(); }
+    if (m_bb!=nullptr)                    { (*m_bb)=CGAL::Bbox_3(); }
 
     m_zero_x=true;
     m_zero_y=true;