mirror of https://github.com/CGAL/cgal
243 lines
7.8 KiB
C++
243 lines
7.8 KiB
C++
// Copyright (c) 1997
|
|
// Utrecht University (The Netherlands),
|
|
// ETH Zurich (Switzerland),
|
|
// INRIA Sophia-Antipolis (France),
|
|
// Max-Planck-Institute Saarbruecken (Germany),
|
|
// and Tel-Aviv University (Israel). All rights reserved.
|
|
//
|
|
// This file is part of CGAL (www.cgal.org)
|
|
//
|
|
// $URL$
|
|
// $Id$
|
|
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
|
|
//
|
|
//
|
|
// Author(s) : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
|
|
// Mostafa Ashraf <mostaphaashraf1996@gmail.com>
|
|
|
|
#ifndef CGAL_DRAW_POLYGON_WITH_HOLES_2_H
|
|
#define CGAL_DRAW_POLYGON_WITH_HOLES_2_H
|
|
|
|
#include <CGAL/Qt/Basic_viewer.h>
|
|
#include <CGAL/Graphics_scene.h>
|
|
#include <CGAL/Graphics_scene_options.h>
|
|
#include <CGAL/Polygon_with_holes_2.h>
|
|
|
|
#ifdef DOXYGEN_RUNNING
|
|
namespace CGAL {
|
|
|
|
/*!
|
|
\ingroup PkgDrawPolygonWithHoles2
|
|
|
|
opens a new window and draws a 2D polygon with holes. Parameters of the drawing are taken from the optional graphics scene options parameter.
|
|
|
|
A call to this function blocks the execution of the program until the drawing window is closed. This function requires `CGAL_Qt6`, and is only available if the macro `CGAL_USE_BASIC_VIEWER` is defined.
|
|
Linking with the cmake target `CGAL::CGAL_Basic_viewer` will link with `CGAL_Qt6` and add the definition `CGAL_USE_BASIC_VIEWER`.
|
|
|
|
\cgalAdvancedBegin
|
|
The real declaration of this function template is:
|
|
|
|
<code>
|
|
template<class T, class C, class GSOptions>
|
|
|
|
void CGAL::draw(const CGAL::Polygon_with_holes_2<T, C>& ph, const GSOptions& gso);
|
|
</code>
|
|
\cgalAdvancedEnd
|
|
|
|
\tparam PH which must be an instanciation of a `CGAL::Polygon_with_holes_2<...>`.
|
|
\tparam GSOptions a model of `GraphicsSceneOptions` concept.
|
|
|
|
\param ph the polygon with holes to draw.
|
|
\param gso the graphics scene options parameter.
|
|
*/
|
|
template <typename PH, class GSOptions>
|
|
void draw(const PH& ph, const GSOptions& gso);
|
|
|
|
/*!
|
|
\ingroup PkgDrawPolygonWithHoles2
|
|
|
|
A shortcut to `CGAL::draw(ph, Graphics_scene_options{})`.
|
|
*/
|
|
template<class PH>
|
|
void draw(const PH& ph);
|
|
|
|
/*!
|
|
\ingroup PkgDrawPolygonWithHoles2
|
|
|
|
adds the vertices, edges and faces of `ph` into the given graphic scene `gs`. Parameters of the cells are taken from the optional graphics scene options parameter `gso` . Note that `gs` is not cleared before being filled (to enable to draw several data structures in the same basic viewer).
|
|
|
|
\cgalAdvancedBegin
|
|
The real declaration of this function template is:
|
|
|
|
<code>
|
|
template<class T, class C, class GSOptions>
|
|
|
|
void CGAL::add_to_graphics_scene(const CGAL::Polygon_with_holes_2<T, C>& ph, CGAL::Graphics_scene& gs, const GSOptions& gso);
|
|
</code>
|
|
\cgalAdvancedEnd
|
|
|
|
\tparam PH which must be an instanciation of a `CGAL::Polygon_with_holes_2<...>`.
|
|
\tparam GSOptions a model of `GraphicsSceneOptions` concept.
|
|
|
|
\param ph the polygon with holes to draw.
|
|
\param gs the graphic scene to fill.
|
|
\param gso the graphics scene options parameter.
|
|
*/
|
|
template<class PH, class GSOptions>
|
|
void add_to_graphics_scene(const PH& ph,
|
|
CGAL::Graphics_scene& gs,
|
|
const GSOptions& gso);
|
|
|
|
/*!
|
|
\ingroup PkgDrawPolygonWithHoles2
|
|
|
|
A shortcut to `CGAL::add_to_graphics_scene(ph, gs, Graphics_scene_options{})`.
|
|
*/
|
|
template<class PH>
|
|
void add_to_graphics_scene(const PH& ph,
|
|
CGAL::Graphics_scene& gs);
|
|
|
|
} /* namespace CGAL */
|
|
|
|
#endif
|
|
|
|
namespace CGAL
|
|
{
|
|
|
|
namespace draw_function_for_ph2_with_holes {
|
|
|
|
template <class P2, class GSOptions>
|
|
void compute_one_loop_elements(const P2& ap2,
|
|
const typename P2::General_polygon_2& aloop,
|
|
Graphics_scene &graphics_scene,
|
|
bool hole,
|
|
const GSOptions& gs_options)
|
|
{
|
|
if (hole && gs_options.are_faces_enabled())
|
|
{ graphics_scene.add_point_in_face(aloop.vertex(aloop.size()-1)); }
|
|
|
|
typename P2::General_polygon_2::Vertex_const_iterator prev;
|
|
for(typename P2::General_polygon_2::Vertex_const_iterator i=aloop.vertices_begin();
|
|
i!=aloop.vertices_end(); ++i)
|
|
{
|
|
if(gs_options.are_vertices_enabled() &&
|
|
gs_options.draw_vertex(ap2, i))
|
|
{ // Add vertex
|
|
if(gs_options.colored_vertex(ap2, i))
|
|
{ graphics_scene.add_point(*i, gs_options.vertex_color(ap2, i)); }
|
|
else
|
|
{ graphics_scene.add_point(*i); }
|
|
}
|
|
|
|
if(i!=aloop.vertices_begin() &&
|
|
gs_options.are_edges_enabled() && gs_options.draw_edge(ap2, prev))
|
|
{ // Add segment with previous point
|
|
if(gs_options.colored_edge(ap2, prev))
|
|
{ graphics_scene.add_segment(*prev, *i, gs_options.edge_color(ap2, prev)); }
|
|
else
|
|
{ graphics_scene.add_segment(*prev, *i); }
|
|
}
|
|
|
|
if(gs_options.are_faces_enabled())
|
|
{ graphics_scene.add_point_in_face(*i); } // Add point in face
|
|
|
|
prev=i;
|
|
}
|
|
|
|
// Add the last segment between the last point and the first one
|
|
if(gs_options.are_edges_enabled() &&
|
|
gs_options.draw_edge(ap2, aloop.vertices_begin()))
|
|
{
|
|
if(gs_options.colored_edge(ap2, prev))
|
|
{ graphics_scene.add_segment(*prev, *(aloop.vertices_begin()),
|
|
gs_options.edge_color(ap2, prev)); }
|
|
else
|
|
{ graphics_scene.add_segment(*prev, *(aloop.vertices_begin())); }
|
|
}
|
|
}
|
|
|
|
template <class P2, class GSOptions>
|
|
void compute_elements(const P2& p2, Graphics_scene &graphics_scene,
|
|
const GSOptions& gs_options)
|
|
{
|
|
if (p2.outer_boundary().is_empty()) return;
|
|
|
|
if (gs_options.are_faces_enabled())
|
|
{
|
|
if(gs_options.colored_face(p2, nullptr))
|
|
{ graphics_scene.face_begin(gs_options.face_color(p2, nullptr)); }
|
|
else
|
|
{ graphics_scene.face_begin(); }
|
|
}
|
|
|
|
compute_one_loop_elements<P2>(p2, p2.outer_boundary(), graphics_scene,
|
|
false, gs_options);
|
|
|
|
for (typename P2::Hole_const_iterator it=p2.holes_begin(); it!=p2.holes_end(); ++it)
|
|
{
|
|
compute_one_loop_elements<P2>(p2, *it, graphics_scene,
|
|
true, gs_options);
|
|
if (gs_options.are_faces_enabled())
|
|
{ graphics_scene.add_point_in_face(p2.outer_boundary().vertex
|
|
(p2.outer_boundary().size()-1));
|
|
}
|
|
}
|
|
|
|
if (gs_options.are_faces_enabled())
|
|
{ graphics_scene.face_end(); }
|
|
}
|
|
|
|
} // draw_function_for_ph2
|
|
|
|
#define CGAL_P2_WITH_HOLES_TYPE CGAL::Polygon_with_holes_2<T, C>
|
|
|
|
template <class T, class C, class GSOptions>
|
|
void add_to_graphics_scene(const CGAL_P2_WITH_HOLES_TYPE& p2,
|
|
CGAL::Graphics_scene& graphics_scene,
|
|
const GSOptions &gs_options)
|
|
{
|
|
draw_function_for_ph2_with_holes::compute_elements(p2, graphics_scene,
|
|
gs_options);
|
|
}
|
|
|
|
template <class T, class C>
|
|
void add_to_graphics_scene(const CGAL_P2_WITH_HOLES_TYPE& p2,
|
|
CGAL::Graphics_scene& graphics_scene)
|
|
{
|
|
Graphics_scene_options<CGAL_P2_WITH_HOLES_TYPE,
|
|
typename CGAL_P2_WITH_HOLES_TYPE::General_polygon_2::Vertex_const_iterator,
|
|
typename CGAL_P2_WITH_HOLES_TYPE::General_polygon_2::Vertex_const_iterator,
|
|
void*> gs_options;
|
|
|
|
add_to_graphics_scene(p2, graphics_scene, gs_options);
|
|
}
|
|
|
|
#ifdef CGAL_USE_BASIC_VIEWER
|
|
|
|
// Specialization of draw function.
|
|
template<class T, class C, class GSOptions>
|
|
void draw(const CGAL_P2_WITH_HOLES_TYPE& ap2, const GSOptions &gs_options,
|
|
const char* title="Polygon with Holes Basic Viewer")
|
|
{
|
|
CGAL::Graphics_scene buffer;
|
|
add_to_graphics_scene(ap2, buffer, gs_options);
|
|
draw_graphics_scene(buffer, title);
|
|
}
|
|
|
|
template<class T, class C>
|
|
void draw(const CGAL_P2_WITH_HOLES_TYPE& ap2,
|
|
const char* title="Polygon with Holes Basic Viewer")
|
|
{
|
|
CGAL::Graphics_scene buffer;
|
|
add_to_graphics_scene(ap2, buffer);
|
|
draw_graphics_scene(buffer, title);
|
|
}
|
|
|
|
#endif // CGAL_USE_BASIC_VIEWER
|
|
|
|
#undef CGAL_P2_WITH_HOLES_TYPE
|
|
|
|
} // End namespace CGAL
|
|
|
|
#endif // CGAL_DRAW_POLYGON_WITH_HOLES_2_H
|