scalar_view.h

Go to the documentation of this file.

// This file is part of Hermes2D.
//
// Hermes2D is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// Hermes2D is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Hermes2D.  If not, see <http://www.gnu.org/licenses/>.
#ifndef __H2D_SCALAR_VIEW_H
#define __H2D_SCALAR_VIEW_H

#include "view.h"
#include "linearizer.h"

namespace Hermes
{
  namespace Hermes2D
  {
    namespace Views
    {
      // you can define NOGLUT to turn off all OpenGL stuff in Hermes2D
#ifndef NOGLUT

      class HERMES_API ScalarView : public View
      {
      public:

        void init();
#ifndef _MSC_VER
        ScalarView(const char* title = "ScalarView", WinGeom* wg = nullptr);
#else
        ScalarView(WinGeom* wg = nullptr);
#endif
        ScalarView(char* title, WinGeom* wg = nullptr);
        ~ScalarView();

        void show(MeshFunctionSharedPtr<double> sln, int item = H2D_FN_VAL_0,
          MeshFunctionSharedPtr<double> xdisp = nullptr, MeshFunctionSharedPtr<double> ydisp = nullptr, double dmult = 1.0);

        void show(MeshFunctionSharedPtr<std::complex<double> > sln, int item = H2D_FN_VAL_0,
          MeshFunctionSharedPtr<double> xdisp = nullptr, MeshFunctionSharedPtr<double> ydisp = nullptr, double dmult = 1.0)
        {
          throw Exceptions::Exception("Visualization of complex 2D solution is not possible, please use a filter that converts the solution into a real function, then display that one.");
        }

        void show_linearizer_data(double eps, int item = H2D_FN_VAL_0);

        inline void show_mesh(bool show = true) { show_edges = show; refresh(); }
        inline void show_bounding_box(bool show = true) { show_aabb = show; refresh(); }
        void show_contours(double step, double orig = 0.0);
        inline void hide_contours() { contours = false; refresh(); }
        void set_3d_mode(bool enable = true);
        void set_vertical_scaling(double sc);
        void set_min_max_range(double min, double max);

        virtual void reset_view(bool force_reset);

        Linearizer* get_linearizer();

        void set_linearizer_criterion(LinearizerCriterion criterion);

      protected:
        Linearizer* lin;

      protected:
        struct ElementInfo 
        {
          float x, y;
          float width, height;
          int id;
          ElementInfo() : x(0), y(0), width(0), height(0), id(-1) {};
          ElementInfo(int id, float x, float y, float width, float height) : x(x), y(y), width(width), height(height), id(id) {};
        };
        std::vector<ElementInfo> element_infos;

        unsigned int element_id_widget;

        bool show_element_info;

        void init_element_info(MeshSharedPtr mesh);
        void create_element_info_widgets();
        void draw_element_infos_2d();

      protected: //values
#define H2DV_GL_MAX_EDGE_BUFFER 128 
#pragma pack(push)
#pragma pack(1)
        struct GLVertex2 
        {
          float x, y;
          float coord;
          GLVertex2() {};
          GLVertex2(float x, float y, float coord) : x(x), y(y), coord(coord) {};
          static const size_t H2D_OFFSETOF_COORD = 2 * sizeof(float);
        };
#pragma pack(pop)

        bool lin_updated;

        int max_gl_verts;
        int max_gl_tris;
        int gl_tri_cnt;

        bool show_values;

        void prepare_gl_geometry();
        void draw_values_2d();
        void draw_edges_2d();

      protected: //edges
        bool show_edges;
        bool show_aabb;
        float edges_color[3];

        typedef void(*DrawSingleEdgeCallback)(int inx_vert_a, int inx_vert_b, ScalarView* viewer, void* param);

        void calculate_mesh_aabb(double* x_min, double* x_max, double* y_min, double* y_max);

        void draw_aabb();

      protected:
        bool contours;
        double cont_orig, cont_step;
        float cont_color[3];
        bool do_zoom_to_fit;
        bool is_constant;

        // Perspective projection parameters.
        static const int fovy;
        static const double znear;
        static const double zfar;

        bool pmode, mode3d, panning;
        double xrot, yrot, xtrans, ytrans, ztrans;
        double xzscale, yscale, xctr, yctr, zctr;

        double value_irange, value_range_avg;

        double calculate_ztrans_to_fit_view();
        virtual void update_layout();

        void draw_tri_contours(ScalarLinearizerDataDimensions<LINEARIZER_DATA_TYPE>::triangle_t&);
        void init_lighting();
        void update_mesh_info();

        virtual void on_display();
        void on_display_2d();
        void on_display_3d();

        virtual void on_key_down(unsigned char key, int x, int y);
        virtual void on_mouse_move(int x, int y);
        virtual void on_right_mouse_down(int x, int y);
        virtual void on_middle_mouse_down(int x, int y);
        virtual void on_middle_mouse_up(int x, int y);
        virtual const char* get_help_text() const;
        virtual void on_close();
      };
#else
      class HERMES_API ScalarView : public View
      {
      public:
        void init() { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        ScalarView(const char* title = "ScalarView", WinGeom* wg = nullptr) {}
        ScalarView(char* title, WinGeom* wg = nullptr) {}

        void show(MeshFunctionSharedPtr<double> sln, int item = H2D_FN_VAL_0,
          MeshFunctionSharedPtr<double> xdisp = nullptr, MeshFunctionSharedPtr<double> ydisp = nullptr, double dmult = 1.0) {
          throw Hermes::Exceptions::Exception("GLUT disabled.");
        }

        void show(MeshFunctionSharedPtr<std::complex<double> > sln, int item = H2D_FN_VAL_0,
          MeshFunctionSharedPtr<double> xdisp = nullptr, MeshFunctionSharedPtr<double> ydisp = nullptr, double dmult = 1.0)
        {
          throw Exceptions::Exception("Visualization of complex 2D solution is not possible, please use a filter that converts the solution into a real function, then display that one.");
        }

        void show_linearizer_data(double eps, int item = H2D_FN_VAL_0) { throw Hermes::Exceptions::Exception("GLUT disabled."); }

        inline void show_mesh(bool show = true) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        inline void show_bounding_box(bool show = true) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void show_contours(double step, double orig = 0.0) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        inline void hide_contours() { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        inline void set_3d_mode(bool enable = true) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void set_vertical_scaling(double sc) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void set_min_max_range(double min, double max) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        Linearizer* get_linearizer()  { throw Hermes::Exceptions::Exception("GLUT disabled."); return nullptr; }
        void set_linearizer_criterion(LinearizerCriterion criterion) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
      };
#endif
    }
  }
}
#endif