grid_out.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2016 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii__grid_out_h
#define dealii__grid_out_h



#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/point.h>
#include <deal.II/base/data_out_base.h>

#include <string>

DEAL_II_NAMESPACE_OPEN

class ParameterHandler;
template <int dim, int spacedim> class Triangulation;
template <int dim, int spacedim> class Mapping;


namespace GridOutFlags
{
  struct DX
  {
    bool write_cells;

    bool write_faces;

    bool write_diameter;

    bool write_measure;

    bool write_all_faces;

    DX (const bool write_cells = true,
        const bool write_faces = false,
        const bool write_diameter = false,
        const bool write_measure = false,
        const bool write_all_faces = true);

    static void declare_parameters (ParameterHandler &param);

    void parse_parameters (ParameterHandler &param);
  };

  struct Msh
  {
    bool write_faces;
    bool write_lines;

    Msh (const bool write_faces    = false,
         const bool write_lines    = false);
    static void declare_parameters (ParameterHandler &param);

    void parse_parameters (ParameterHandler &param);
  };


  struct Ucd
  {
    bool write_preamble;

    bool write_faces;

    bool write_lines;

    Ucd (const bool write_preamble = false,
         const bool write_faces    = false,
         const bool write_lines    = false);

    static void declare_parameters (ParameterHandler &param);

    void parse_parameters (ParameterHandler &param);
  };


  struct Gnuplot
  {
    bool write_cell_numbers;

    unsigned int n_boundary_face_points;

    bool curved_inner_cells;

    Gnuplot (const bool         write_cell_number = false,
             const unsigned int n_boundary_face_points = 2,
             const bool         curved_inner_cells = false);
    static void declare_parameters (ParameterHandler &param);

    void parse_parameters (ParameterHandler &param);
  };

  struct EpsFlagsBase
  {
    enum SizeType
    {
      width,
      height
    };

    SizeType size_type;

    unsigned int size;

    double line_width;

    bool color_lines_on_user_flag;

    unsigned int n_boundary_face_points;

    bool color_lines_level;

    EpsFlagsBase (const SizeType     size_type  = width,
                  const unsigned int size       = 300,
                  const double       line_width = 0.5,
                  const bool color_lines_on_user_flag = false,
                  const unsigned int n_boundary_face_points = 2,
                  const bool color_lines_level = false);
    static void declare_parameters (ParameterHandler &param);

    void parse_parameters (ParameterHandler &param);
  };


  template <int dim>
  struct Eps
  {};

  template <>
  struct Eps<1> : public EpsFlagsBase
  {
    Eps (const SizeType     size_type  = width,
         const unsigned int size       = 300,
         const double       line_width = 0.5,
         const bool         color_lines_on_user_flag = false,
         const unsigned int n_boundary_face_points = 2);
    static void declare_parameters (ParameterHandler &param);

    void parse_parameters (ParameterHandler &param);
  };


  template <>
  struct Eps<2> : public EpsFlagsBase
  {
    bool write_cell_numbers;
    bool write_cell_number_level;

    bool write_vertex_numbers;

    Eps (const SizeType     size_type  = width,
         const unsigned int size       = 300,
         const double       line_width = 0.5,
         const bool         color_lines_on_user_flag = false,
         const unsigned int n_boundary_face_points = 2,
         const bool         write_cell_numbers = false,
         const bool         write_cell_number_level = true,
         const bool         write_vertex_numbers = false,
         const bool         color_lines_level = false);
    static void declare_parameters (ParameterHandler &param);

    void parse_parameters (ParameterHandler &param);
  };

  template <>
  struct Eps<3> : public EpsFlagsBase
  {
    double azimut_angle;

    double turn_angle;

    Eps (const SizeType     size_type  = width,
         const unsigned int size       = 300,
         const double       line_width = 0.5,
         const bool         color_lines_on_user_flag = false,
         const unsigned int n_boundary_face_points = 2,
         const double       azimut_angle    = 60,
         const double       turn_angle      = 30);
    static void declare_parameters (ParameterHandler &param);

    void parse_parameters (ParameterHandler &param);
  };

  struct XFig
  {
    bool draw_boundary;

    enum Coloring
    {
      material_id,
      level_number,
      subdomain_id,
      level_subdomain_id
    } color_by;

    bool level_depth;

    unsigned int n_boundary_face_points;

    Point<2> scaling;

    Point<2> offset;

    int fill_style;

    int line_style;

    int line_thickness;

    int boundary_style;

    int boundary_thickness;

    XFig();
    static void declare_parameters (ParameterHandler &param);

    void parse_parameters (ParameterHandler &param);
  };


  struct Svg
  {
    unsigned int height;
    unsigned int width;
    unsigned int line_thickness;
    unsigned int boundary_line_thickness;

    bool margin;

    enum Background
    {
      transparent,
      white,
      dealii
    };

    Background background;

    // View angles for the perspective view of the grid; Default is 0, 0 (top view).
    int azimuth_angle;
    int polar_angle;

    enum Coloring
    {
      none,
      material_id,
      level_number,
      subdomain_id,
      level_subdomain_id
    };

    Coloring coloring;

    bool convert_level_number_to_height;

    float level_height_factor;

    float cell_font_scaling;
    bool label_level_number;
    bool label_cell_index;
    bool label_material_id;
    bool label_subdomain_id;
    bool label_level_subdomain_id;

    bool draw_colorbar;
    bool draw_legend;

    Svg(const unsigned int line_thickness = 2,
        const unsigned int boundary_line_thickness = 4,
        bool margin = true,
        const Background background = white,
        const int azimuth_angle = 0,
        const int polar_angle = 0,
        const Coloring coloring = level_number,
        const bool convert_level_number_to_height = false,
        const bool label_level_number = true,
        const bool label_cell_index = true,
        const bool label_material_id = false,
        const bool label_subdomain_id = false,
        const bool draw_colorbar = true,
        const bool draw_legend = true);
  };

  struct MathGL
  {
    MathGL ();

    bool draw_bounding_box;

    static void declare_parameters (ParameterHandler &param);

    void parse_parameters (ParameterHandler &param);
  };


  struct Vtk : public DataOutBase::VtkFlags
  {};


  struct Vtu : public DataOutBase::VtkFlags
  {};
}



class GridOut
{
public:
  enum OutputFormat
  {
    none,
    dx,
    gnuplot,
    eps,
    ucd,
    xfig,
    msh,
    svg,
    mathgl,
    vtk,
    vtu
  };

  GridOut ();

  template <int dim, int spacedim>
  void write_dx (const Triangulation<dim,spacedim> &tria,
                 std::ostream             &out) const;

  template <int dim, int spacedim>
  void write_gnuplot (const Triangulation<dim,spacedim> &tria,
                      std::ostream           &out,
                      const Mapping<dim,spacedim> *mapping=0) const;

  template <int dim, int spacedim>
  void write_msh (const Triangulation<dim,spacedim> &tria,
                  std::ostream             &out) const;

  template <int dim, int spacedim>
  void write_ucd (const Triangulation<dim,spacedim> &tria,
                  std::ostream             &out) const;

  template <int dim, int spacedim>
  void write_eps (const Triangulation<dim, spacedim> &tria,
                  std::ostream             &out,
                  const Mapping<dim, spacedim>       *mapping=0) const;

  template <int dim, int spacedim>
  void write_xfig (const Triangulation<dim, spacedim> &tria,
                   std::ostream              &out,
                   const Mapping<dim, spacedim>        *mapping=0) const;

  void write_svg (const Triangulation<2,2> &tria,
                  std::ostream             &out) const;

  template <int dim, int spacedim>
  void write_svg (const Triangulation<dim,spacedim> &tria,
                  std::ostream                      &out) const;


  template <int dim, int spacedim>
  void write_mathgl (const Triangulation<dim, spacedim> &tria,
                     std::ostream             &out) const;

  template <int dim, int spacedim>
  void write_vtk (const Triangulation<dim,spacedim> &tria,
                  std::ostream                      &out) const;

  template <int dim, int spacedim>
  void write_vtu (const Triangulation<dim,spacedim> &tria,
                  std::ostream                      &out) const;

  template <int dim, int spacedim>
  void write_mesh_per_processor_as_vtu (const Triangulation<dim,spacedim> &tria,
                                        const std::string                 &filename_without_extension,
                                        const bool                        view_levels=false,
                                        const bool                        include_artificial=false) const;

  template <int dim, int spacedim>
  void write (const Triangulation<dim,spacedim> &tria,
              std::ostream                      &out,
              const OutputFormat                 output_format,
              const Mapping<dim,spacedim>       *mapping=0) const;

  template <int dim, int spacedim>
  void write (const Triangulation<dim,spacedim> &tria,
              std::ostream                      &out,
              const Mapping<dim,spacedim>       *mapping=0) const;

  void set_flags (const GridOutFlags::DX &flags);

  void set_flags (const GridOutFlags::Msh &flags);

  void set_flags (const GridOutFlags::Ucd &flags);

  void set_flags (const GridOutFlags::Gnuplot &flags);

  void set_flags (const GridOutFlags::Eps<1> &flags);

  void set_flags (const GridOutFlags::Eps<2> &flags);

  void set_flags (const GridOutFlags::Eps<3> &flags);

  void set_flags (const GridOutFlags::XFig &flags);

  void set_flags (const GridOutFlags::Svg &flags);

  void set_flags (const GridOutFlags::MathGL &flags);

  void set_flags (const GridOutFlags::Vtk &flags);

  void set_flags (const GridOutFlags::Vtu &flags);

  static std::string default_suffix (const OutputFormat output_format);

  std::string default_suffix () const;

  static OutputFormat parse_output_format (const std::string &format_name);

  static std::string get_output_format_names ();

  static void declare_parameters (ParameterHandler &param);

  void parse_parameters (ParameterHandler &param);

  std::size_t memory_consumption () const;

  DeclException0 (ExcInvalidState);

private:
  OutputFormat default_format;

  GridOutFlags::DX dx_flags;

  GridOutFlags::Msh     msh_flags;

  GridOutFlags::Ucd     ucd_flags;

  GridOutFlags::Gnuplot gnuplot_flags;

  GridOutFlags::Eps<1>  eps_flags_1;

  GridOutFlags::Eps<2>  eps_flags_2;

  GridOutFlags::Eps<3>  eps_flags_3;

  GridOutFlags::XFig xfig_flags;

  GridOutFlags::Svg svg_flags;

  GridOutFlags::MathGL mathgl_flags;

  GridOutFlags::Vtk vtk_flags;

  GridOutFlags::Vtu vtu_flags;

  template <int dim, int spacedim>
  unsigned int
  write_msh_faces (const Triangulation<dim,spacedim> &tria,
                   const unsigned int                 next_element_index,
                   std::ostream                      &out) const;

  unsigned int
  write_msh_faces (const Triangulation<1,1>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;
  unsigned int
  write_msh_faces (const Triangulation<1,2>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;
  unsigned int
  write_msh_faces (const Triangulation<1,3>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;



  template <int dim, int spacedim>
  unsigned int
  write_msh_lines (const Triangulation<dim,spacedim> &tria,
                   const unsigned int                 next_element_index,
                   std::ostream                      &out) const;

  unsigned int
  write_msh_lines (const Triangulation<1,1>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;

  unsigned int
  write_msh_lines (const Triangulation<1,2>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;
  unsigned int
  write_msh_lines (const Triangulation<1,3>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;
  unsigned int
  write_msh_lines (const Triangulation<2,2>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;
  unsigned int
  write_msh_lines (const Triangulation<2,3>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;

  template <int dim, int spacedim>
  unsigned int
  write_ucd_faces (const Triangulation<dim,spacedim> &tria,
                   const unsigned int                 next_element_index,
                   std::ostream                      &out) const;

  unsigned int
  write_ucd_faces (const Triangulation<1,1>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;

  unsigned int
  write_ucd_faces (const Triangulation<1,2>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;
  unsigned int
  write_ucd_faces (const Triangulation<1,3>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;


  template <int dim, int spacedim>
  unsigned int
  write_ucd_lines (const Triangulation<dim,spacedim> &tria,
                   const unsigned int                 next_element_index,
                   std::ostream                      &out) const;

  unsigned int
  write_ucd_lines (const Triangulation<1,1>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;
  unsigned int
  write_ucd_lines (const Triangulation<1,2>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;
  unsigned int
  write_ucd_lines (const Triangulation<1,3>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;


  unsigned int
  write_ucd_lines (const Triangulation<2,2>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;
  unsigned int
  write_ucd_lines (const Triangulation<2,3>      &tria,
                   const unsigned int             next_element_index,
                   std::ostream                  &out) const;


  static Point<2> svg_project_point(Point<3> point,
                                    Point<3> camera_position,
                                    Point<3> camera_direction,
                                    Point<3> camera_horizontal,
                                    float camera_focus);

  template <int dim, int spacedim>
  unsigned int n_boundary_faces (const Triangulation<dim,spacedim> &tria) const;

  unsigned int n_boundary_faces (const Triangulation<1,1> &tria) const;

  unsigned int n_boundary_faces (const Triangulation<1,2> &tria) const;
  unsigned int n_boundary_faces (const Triangulation<1,3> &tria) const;

  template <int dim, int spacedim>
  unsigned int n_boundary_lines (const Triangulation<dim,spacedim> &tria) const;

  unsigned int n_boundary_lines (const Triangulation<1,1> &tria) const;

  unsigned int n_boundary_lines (const Triangulation<1,2> &tria) const;
  unsigned int n_boundary_lines (const Triangulation<1,3> &tria) const;

  unsigned int n_boundary_lines (const Triangulation<2,2> &tria) const;
  unsigned int n_boundary_lines (const Triangulation<2,3> &tria) const;
};



DEAL_II_NAMESPACE_CLOSE

#endif