tikzgeom_scene.H

Go to the documentation of this file.

/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
# ifndef TIKZGEOM_SCENE_H
# define TIKZGEOM_SCENE_H
 
# include <cmath>
# include <iomanip>
# include <ostream>
# include <sstream>
# include <string>
# include <type_traits>
# include <utility>
# include <vector>
 
# include "tikzgeom_algorithms.H"
 
namespace Aleph
{
 
struct Tikz_Standalone_Document_Options
{
  std::string document_class = "standalone";
  std::string class_options = "tikz,border=8pt";
  std::string extra_preamble;
};
 
struct Tikz_Beamer_Document_Options
{
  std::string class_options = "aspectratio=169";
  std::string frame_options = "t";
  std::string frame_title = "TikZ Scene";
  bool hide_navigation_symbols = true;
  std::string extra_preamble;
  double max_picture_width_mm = 105.0;
  double max_picture_height_mm = 60.0;
};
 
class Tikz_Scene
{
  static void append_unique_libraries(Array<std::string> & destination,
                                      const Array<std::string> & source)
  {
    for (size_t i = 0; i < source.size(); ++i)
      append_unique_tikz_library(destination, source(i));
  }
 
  [[nodiscard]] static Array<std::string> collect_required_libraries(
      const std::vector<Tikz_Scene> & steps)
  {
    Array<std::string> libraries;
    for (const Tikz_Scene & step : steps)
      append_unique_libraries(libraries,
                              step.plane_.required_tikz_libraries());
    return libraries;
  }
 
  static void draw_tikz_libraries(
      std::ostream & output,
      const Array<std::string> & libraries)
  {
    if (libraries.is_empty())
      return;
 
    output << "\\usetikzlibrary{";
    for (size_t i = 0; i < libraries.size(); ++i)
      output << (i == 0 ? "" : ",") << libraries(i);
    output << "}\n";
  }
 
  [[nodiscard]] static double beamer_picture_scale(
      const Tikz_Scene & scene,
      const Tikz_Beamer_Document_Options & options)
  {
    ah_domain_error_if(not std::isfinite(options.max_picture_width_mm) or
                       not std::isfinite(options.max_picture_height_mm) or
                       options.max_picture_width_mm <= 0.0 or
                       options.max_picture_height_mm <= 0.0)
      << "Beamer picture bounds must be positive and finite";
 
    double scale = 1.0;
    if (scene.plane_.get_wide() * scale > options.max_picture_width_mm)
      scale = options.max_picture_width_mm / scene.plane_.get_wide();
    if (scene.plane_.get_height() * scale > options.max_picture_height_mm)
      scale = options.max_picture_height_mm / scene.plane_.get_height();
    return scale;
  }
 
  static void draw_fitted_beamer_picture(
      std::ostream & output,
      const Tikz_Scene & scene,
      const Tikz_Beamer_Document_Options & options)
  {
    const double scale = beamer_picture_scale(scene, options);
    std::ostringstream formatted_scale;
    formatted_scale << std::fixed << std::setprecision(6) << scale;
 
    output << "\\centering\n"
           << "\\scalebox{" << formatted_scale.str() << "}{%\n";
    scene.draw(output);
    output << "}\n";
  }
 
  [[nodiscard]] static std::string compose_beamer_class_options(
      const bool handout_mode,
      const std::string & class_options)
  {
    if (not handout_mode)
      return class_options;
 
    if (class_options.empty())
      return "handout";
 
    if (class_options.find("handout") != std::string::npos)
      return class_options;
 
    return "handout," + class_options;
  }
 
  static void draw_beamer_document_preamble(
      std::ostream & output,
      const Tikz_Beamer_Document_Options & options,
      const bool handout_mode,
      const Array<std::string> & libraries)
  {
    output << "\\documentclass";
 
    const std::string class_options =
        compose_beamer_class_options(handout_mode, options.class_options);
    if (not class_options.empty())
      output << "[" << class_options << "]";
 
    output << "{beamer}\n"
           << "\\usepackage{tikz}\n"
           << "\\usepackage{graphicx}\n";
    draw_tikz_libraries(output, libraries);
 
    if (options.hide_navigation_symbols)
      output << "\\setbeamertemplate{navigation symbols}{}\n";
 
    if (not options.extra_preamble.empty())
      output << options.extra_preamble << '\n';
 
    output << "\\begin{document}\n\n";
  }
 
  static void draw_beamer_document_epilogue(std::ostream & output)
  {
    output << "\n\\end{document}\n";
  }
 
  static void draw_beamer_frame_begin(
      std::ostream & output,
      const std::string & frame_title,
      const std::string & frame_options)
  {
    output << "\\begin{frame}";
    if (not frame_options.empty())
      output << "[" << frame_options << "]";
    output << "{" << frame_title << "}\n";
  }
 
  static void draw_beamer_overlays_document(
      std::ostream & output,
      const std::vector<Tikz_Scene> & steps,
      const Tikz_Beamer_Document_Options & options,
      const bool handout_mode)
  {
    const Array<std::string> libraries = collect_required_libraries(steps);
    draw_beamer_document_preamble(output, options, handout_mode, libraries);
    draw_beamer_frame_begin(output, options.frame_title, options.frame_options);
 
    if (steps.empty())
      output << "\\centering\\small No overlays provided.\n";
    else if (handout_mode)
      draw_fitted_beamer_picture(output, steps.back(), options);
    else
      for (size_t i = 0; i < steps.size(); ++i)
        {
          output << "\\only<" << (i + 1) << ">{\n";
          draw_fitted_beamer_picture(output, steps[i], options);
          output << "}\n";
        }
 
    output << "\\end{frame}\n";
    draw_beamer_document_epilogue(output);
  }
 
  void draw_beamer_document(
      std::ostream & output,
      const Tikz_Beamer_Document_Options & options,
      const bool handout_mode) const
  {
    draw_beamer_document_preamble(output, options, handout_mode,
                                  plane_.required_tikz_libraries());
    draw_beamer_frame_begin(output, options.frame_title, options.frame_options);
    draw_fitted_beamer_picture(output, *this, options);
    output << "\\end{frame}\n";
    draw_beamer_document_epilogue(output);
  }
 
  Tikz_Plane plane_;
  bool squarize_ = true;
 
public:
  Tikz_Scene(const double width_mm,
             const double height_mm,
             const double xoffset_mm = 0.0,
             const double yoffset_mm = 0.0,
             const bool squarize = true)
    : plane_(width_mm, height_mm, xoffset_mm, yoffset_mm),
      squarize_(squarize)
  {
  }
 
  [[nodiscard]] Tikz_Plane & plane() { return plane_; }
  [[nodiscard]] const Tikz_Plane & plane() const { return plane_; }
 
  [[nodiscard]] Array<std::string> required_tikz_libraries() const
  {
    return plane_.required_tikz_libraries();
  }
 
  [[nodiscard]] bool squarize() const { return squarize_; }
  void set_squarize(const bool value) { squarize_ = value; }
 
  Tikz_Scene & clear()
  {
    plane_.clear();
    return *this;
  }
 
  Tikz_Scene & put_cartesian_axis()
  {
    plane_.put_cartesian_axis();
    return *this;
  }
 
  Tikz_Scene & remove_cartesian_axis()
  {
    plane_.remove_cartesian_axis();
    return *this;
  }
 
  Tikz_Scene & put_coordinate_grid(const double step_x = 1.0,
                                   const double step_y = 1.0,
                                   const bool draw_ticks = true)
  {
    plane_.put_coordinate_grid(step_x, step_y, draw_ticks);
    return *this;
  }
 
  Tikz_Scene & remove_coordinate_grid()
  {
    plane_.remove_coordinate_grid();
    return *this;
  }
 
  Tikz_Scene & set_default_style(const Tikz_Style & style)
  {
    plane_.set_default_style(style);
    return *this;
  }
 
  Tikz_Scene & set_axis_style(const Tikz_Style & style)
  {
    plane_.set_axis_style(style);
    return *this;
  }
 
  Tikz_Scene & set_grid_style(const Tikz_Style & style)
  {
    plane_.set_grid_style(style);
    return *this;
  }
 
  Tikz_Scene & set_point_radius_mm(const double radius_mm)
  {
    plane_.set_point_radius_mm(radius_mm);
    return *this;
  }
 
  Tikz_Scene & enable_native_tikz_layers(const bool enabled = true)
  {
    plane_.enable_native_tikz_layers(enabled);
    return *this;
  }
 
  Tikz_Scene & enable_auto_legend(const bool enabled = true)
  {
    plane_.enable_auto_legend(enabled);
    return *this;
  }
 
  Tikz_Scene & add_legend_entry(const std::string & label,
                                const Tikz_Style & style)
  {
    plane_.add_legend_entry(label, style);
    return *this;
  }
 
  Tikz_Scene & clear_legend()
  {
    plane_.clear_legend();
    return *this;
  }
 
  Tikz_Scene & register_tikz_style(const std::string & name,
                                   const Tikz_Style & style)
  {
    plane_.register_tikz_style(name, style);
    return *this;
  }
 
  template <typename Geom>
  Tikz_Scene & add(const Geom & object)
  {
    put_in_plane(plane_, object);
    return *this;
  }
 
  template <typename Geom>
  Tikz_Scene & add(const Geom & object,
                   const Tikz_Style & style,
                   const int layer = Tikz_Plane::Layer_Default)
  {
    put_in_plane(plane_, object, style, layer);
    return *this;
  }
 
  Tikz_Scene & add_points(
      const Array<Point> & points,
      const Tikz_Style & style = tikz_points_style("black"),
      const int layer = Tikz_Plane::Layer_Default)
  {
    Aleph::put_points(plane_, points, style, layer);
    return *this;
  }
 
  Tikz_Scene & add_points(
      const DynList<Point> & points,
      const Tikz_Style & style = tikz_points_style("black"),
      const int layer = Tikz_Plane::Layer_Default)
  {
    Aleph::put_points(plane_, points, style, layer);
    return *this;
  }
 
  Tikz_Scene & add_polygons(
      const Array<Polygon> & polys,
      const Tikz_Style & style = tikz_wire_style("black", true),
      const int layer = Tikz_Plane::Layer_Default)
  {
    Aleph::put_polygons(plane_, polys, style, layer);
    return *this;
  }
 
  template <typename Points, typename HullAlgorithm, typename... Args>
  Polygon visualize_convex_hull(const Points & points,
                                HullAlgorithm && algorithm,
                                Args &&... args)
  {
    if constexpr (std::is_same_v<std::decay_t<Points>, Array<Point>>)
      {
        DynList<Point> converted;
        for (size_t i = 0; i < points.size(); ++i)
          converted.append(points(i));
 
        return Aleph::visualize_convex_hull(
            plane_,
            converted,
            std::forward<HullAlgorithm>(algorithm),
            std::forward<Args>(args)...);
      }
    else
      {
        return Aleph::visualize_convex_hull(
            plane_,
            points,
            std::forward<HullAlgorithm>(algorithm),
            std::forward<Args>(args)...);
      }
  }
 
  template <typename... Args>
  Polygon visualize_convex_intersection(Args &&... args)
  {
    return Aleph::visualize_convex_intersection(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  Array<Polygon> visualize_boolean_operation(Args &&... args)
  {
    return Aleph::visualize_boolean_operation(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_voronoi(Args &&... args)
  {
    return Aleph::visualize_voronoi(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_power_diagram(Args &&... args)
  {
    return Aleph::visualize_power_diagram(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_segment_arrangement(Args &&... args)
  {
    return Aleph::visualize_segment_arrangement(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  DynList<Point> visualize_shortest_path_in_polygon(Args &&... args)
  {
    return Aleph::visualize_shortest_path_in_polygon(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  ShortestPathDebugResult visualize_shortest_path_with_portals(Args &&... args)
  {
    return Aleph::visualize_shortest_path_with_portals(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  Array<Polygon> visualize_convex_decomposition(Args &&... args)
  {
    return Aleph::visualize_convex_decomposition(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  AlphaShape::Result visualize_alpha_shape(Args &&... args)
  {
    return Aleph::visualize_alpha_shape(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_delaunay(Args &&... args)
  {
    return Aleph::visualize_delaunay(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_regular_triangulation(Args &&... args)
  {
    return Aleph::visualize_regular_triangulation(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_closest_pair(Args &&... args)
  {
    return Aleph::visualize_closest_pair(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_rotating_calipers(Args &&... args)
  {
    return Aleph::visualize_rotating_calipers(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_half_plane_intersection(Args &&... args)
  {
    return Aleph::visualize_half_plane_intersection(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_minkowski_sum(Args &&... args)
  {
    return Aleph::visualize_minkowski_sum(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_monotone_triangulation(Args &&... args)
  {
    return Aleph::visualize_monotone_triangulation(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_visibility_polygon(Args &&... args)
  {
    return Aleph::visualize_visibility_polygon(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_line_sweep(Args &&... args)
  {
    return Aleph::visualize_line_sweep(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_kdtree_partitions(Args &&... args)
  {
    return Aleph::visualize_kdtree_partitions(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_range_tree(Args &&... args)
  {
    return Aleph::visualize_range_tree(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_range_tree_query(Args &&... args)
  {
    return Aleph::visualize_range_tree_query(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_aabb_tree(Args &&... args)
  {
    return Aleph::visualize_aabb_tree(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  auto visualize_aabb_tree_query(Args &&... args)
  {
    return Aleph::visualize_aabb_tree_query(
        plane_, std::forward<Args>(args)...);
  }
 
  template <typename... Args>
  void put_funnel_trace_step(Args &&... args)
  {
    Aleph::put_funnel_trace_step(plane_, std::forward<Args>(args)...);
  }
 
  template <typename Callable>
  decltype(auto) run(Callable && callable)
  {
    return std::forward<Callable>(callable)(plane_);
  }
 
  template <typename Callable>
  decltype(auto) run(Callable && callable) const
  {
    return std::forward<Callable>(callable)(plane_);
  }
 
  void draw(std::ostream & output) const
  {
    plane_.draw(output, squarize_);
  }
 
  [[nodiscard]] std::string to_tikz() const
  {
    std::ostringstream out;
    draw(out);
    return out.str();
  }
 
  void draw_beamer_frame(
      std::ostream & output,
      const std::string & frame_title = "TikZ Scene",
      const std::string & frame_options = "t") const
  {
    draw_beamer_frame_begin(output, frame_title, frame_options);
    draw_fitted_beamer_picture(output, *this,
                               Tikz_Beamer_Document_Options{});
    output << "\\end{frame}\n";
  }
 
  void draw_standalone(
      std::ostream & output,
      const Tikz_Standalone_Document_Options & options = {}) const
  {
    output << "\\documentclass";
    if (not options.class_options.empty())
      output << "[" << options.class_options << "]";
 
    output << "{";
    if (options.document_class.empty())
      output << "standalone";
    else
      output << options.document_class;
    output << "}\n"
           << "\\usepackage{tikz}\n";
    draw_tikz_libraries(output, plane_.required_tikz_libraries());
 
    if (not options.extra_preamble.empty())
      output << options.extra_preamble << '\n';
 
    output << "\\begin{document}\n\n";
    draw(output);
    output << "\n\\end{document}\n";
  }
 
  [[nodiscard]] std::string to_standalone(
      const Tikz_Standalone_Document_Options & options = {}) const
  {
    std::ostringstream out;
    draw_standalone(out, options);
    return out.str();
  }
 
  void draw_beamer(
      std::ostream & output,
      const Tikz_Beamer_Document_Options & options = {}) const
  {
    draw_beamer_document(output, options, false);
  }
 
  [[nodiscard]] std::string to_beamer(
      const Tikz_Beamer_Document_Options & options = {}) const
  {
    std::ostringstream out;
    draw_beamer(out, options);
    return out.str();
  }
 
  void draw_handout(
      std::ostream & output,
      const Tikz_Beamer_Document_Options & options = {}) const
  {
    draw_beamer_document(output, options, true);
  }
 
  [[nodiscard]] std::string to_handout(
      const Tikz_Beamer_Document_Options & options = {}) const
  {
    std::ostringstream out;
    draw_handout(out, options);
    return out.str();
  }
 
  static void draw_beamer_overlays(
      std::ostream & output,
      const std::vector<Tikz_Scene> & steps,
      const Tikz_Beamer_Document_Options & options = {})
  {
    draw_beamer_overlays_document(output, steps, options, false);
  }
 
  [[nodiscard]] static std::string to_beamer_overlays(
      const std::vector<Tikz_Scene> & steps,
      const Tikz_Beamer_Document_Options & options = {})
  {
    std::ostringstream out;
    draw_beamer_overlays(out, steps, options);
    return out.str();
  }
 
  static void draw_handout_overlays(
      std::ostream & output,
      const std::vector<Tikz_Scene> & steps,
      const Tikz_Beamer_Document_Options & options = {})
  {
    draw_beamer_overlays_document(output, steps, options, true);
  }
 
  [[nodiscard]] static std::string to_handout_overlays(
      const std::vector<Tikz_Scene> & steps,
      const Tikz_Beamer_Document_Options & options = {})
  {
    std::ostringstream out;
    draw_handout_overlays(out, steps, options);
    return out.str();
  }
};
 
} // namespace Aleph
 
# endif // TIKZGEOM_SCENE_H