ViewerData.h

Go to the documentation of this file.

// This file is part of libigl, a simple c++ geometry processing library.
//
// Copyright (C) 2014 Daniele Panozzo <daniele.panozzo@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla Public License
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
// obtain one at http://mozilla.org/MPL/2.0/.
#ifndef IGL_VIEWERDATA_H
#define IGL_VIEWERDATA_H
 
#include "MeshGL.h"
#include "../igl_inline.h"
#include "../colormap.h"
#include <cassert>
#include <cstdint>
#include <Eigen/Core>
#include <memory>
#include <vector>
 
namespace igl
{
 
namespace opengl
{
 
class ViewerCore;
 
class ViewerData
{
public:
  ViewerData();
 
  IGL_INLINE void clear();
 
  IGL_INLINE void set_face_based(bool newvalue);
 
  IGL_INLINE void set_mesh(const Eigen::MatrixXd& V, const Eigen::MatrixXi& F);
  IGL_INLINE void set_vertices(const Eigen::MatrixXd& V);
  IGL_INLINE void set_normals(const Eigen::MatrixXd& N);
  IGL_INLINE void set_visible(bool value, unsigned int core_id = 1);
 
  IGL_INLINE void set_colors(const Eigen::MatrixXd &C);
 
  IGL_INLINE void set_uv(const Eigen::MatrixXd& UV);
 
  IGL_INLINE void set_uv(const Eigen::MatrixXd& UV_V, const Eigen::MatrixXi& UV_F);
 
  IGL_INLINE void set_texture(
    const Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>& R,
    const Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>& G,
    const Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>& B,
    const Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>& A);
  IGL_INLINE void set_texture(
    const Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>& R,
    const Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>& G,
    const Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>& B);
 
  IGL_INLINE void set_data(
    const Eigen::VectorXd & D,
    double caxis_min,
    double caxis_max,
    igl::ColorMapType cmap = igl::COLOR_MAP_TYPE_VIRIDIS,
    int num_steps = 21);
 
  IGL_INLINE void set_data(const Eigen::VectorXd & D,
    igl::ColorMapType cmap = igl::COLOR_MAP_TYPE_VIRIDIS,
    int num_steps = 21);
 
  IGL_INLINE void set_colormap(const Eigen::MatrixXd & CM);
 
  IGL_INLINE void set_points(
    const Eigen::MatrixXd& P,
    const Eigen::MatrixXd& C);
 
  IGL_INLINE void add_points(const Eigen::MatrixXd& P,  const Eigen::MatrixXd& C);
 
  IGL_INLINE void clear_points();
 
  IGL_INLINE void set_edges (const Eigen::MatrixXd& P, const Eigen::MatrixXi& E, const Eigen::MatrixXd& C);
  IGL_INLINE void add_edges (const Eigen::MatrixXd& P1, const Eigen::MatrixXd& P2, const Eigen::MatrixXd& C);
  IGL_INLINE void set_edges_from_vector_field(
    const Eigen::MatrixXd& P, 
    const Eigen::MatrixXd& V, 
    const Eigen::MatrixXd& C);
 
  IGL_INLINE void clear_edges();
 
  IGL_INLINE void set_labels (const Eigen::MatrixXd& P,  const std::vector<std::string>& str);
  IGL_INLINE void add_label (const Eigen::VectorXd& P,  const std::string& str);
 
  IGL_INLINE void clear_labels ();
 
  IGL_INLINE void compute_normals();
 
  IGL_INLINE void uniform_colors(
    const Eigen::Vector3d& ambient,
    const Eigen::Vector3d& diffuse,
    const Eigen::Vector3d& specular);
  IGL_INLINE void uniform_colors(
    const Eigen::Vector4d& ambient,
    const Eigen::Vector4d& diffuse,
    const Eigen::Vector4d& specular);
 
  IGL_INLINE void normal_matcap();
 
  IGL_INLINE void grid_texture();
 
  IGL_INLINE void copy_options(const ViewerCore &from, const ViewerCore &to);
 
  Eigen::MatrixXd V;
  Eigen::MatrixXi F;
 
  // Per face attributes
  Eigen::MatrixXd F_normals;
 
  Eigen::MatrixXd F_material_ambient;
  Eigen::MatrixXd F_material_diffuse;
  Eigen::MatrixXd F_material_specular;
 
  // Per vertex attributes
  Eigen::MatrixXd V_normals;
 
  Eigen::MatrixXd V_material_ambient;
  Eigen::MatrixXd V_material_diffuse;
  Eigen::MatrixXd V_material_specular;
 
  // UV parametrization
  Eigen::MatrixXd V_uv;
  Eigen::MatrixXi F_uv;
 
  // Texture
  Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic> texture_R;
  Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic> texture_G;
  Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic> texture_B;
  Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic> texture_A;
 
  // Overlays
 
  // with S and T the coordinates of the two vertices of the line in global coordinates, and C the color in floating point rgb format
  Eigen::MatrixXd lines;
 
  Eigen::MatrixXd points;
 
  // Text labels plotted over the scene
  // Textp contains, in the i-th row, the position in global coordinates where the i-th label should be anchored
  // Texts contains in the i-th position the text of the i-th label
  Eigen::MatrixXd           vertex_labels_positions;
  Eigen::MatrixXd           face_labels_positions;
  Eigen::MatrixXd           labels_positions;
  std::vector<std::string>  vertex_labels_strings;
  std::vector<std::string>  face_labels_strings;
  std::vector<std::string>  labels_strings;
 
  uint32_t dirty;
 
  bool face_based;
 
  bool double_sided;
 
  bool invert_normals;
 
  unsigned int is_visible;
  unsigned int show_custom_labels;
  unsigned int show_face_labels;
  unsigned int show_faces;
  unsigned int show_lines;
  unsigned int show_overlay;
  unsigned int show_overlay_depth;
  unsigned int show_texture;
  unsigned int show_vertex_labels;
  unsigned int use_matcap;
 
  float point_size;
  float line_width;
  float label_size;
  Eigen::Matrix<float, 4, 1, Eigen::DontAlign> line_color;
  Eigen::Matrix<float, 4, 1, Eigen::DontAlign> label_color;
 
  float shininess;
 
  int id;
 
  igl::opengl::MeshGL meshgl;
 
  IGL_INLINE void update_labels(
    igl::opengl::MeshGL::TextGL& GL_labels,
    const Eigen::MatrixXd& positions,
    const std::vector<std::string>& strings
  );
  IGL_INLINE void updateGL(
    const igl::opengl::ViewerData& data,
    const bool invert_normals,
    igl::opengl::MeshGL& meshgl);
  };
 
} // namespace opengl
} // namespace igl
 
 
#include "../serialize.h"
namespace igl
{
  namespace serialization
  {
    inline void serialization(bool s, igl::opengl::ViewerData& obj, std::vector<char>& buffer)
    {
      SERIALIZE_MEMBER(V);
      SERIALIZE_MEMBER(F);
      SERIALIZE_MEMBER(F_normals);
      SERIALIZE_MEMBER(F_material_ambient);
      SERIALIZE_MEMBER(F_material_diffuse);
      SERIALIZE_MEMBER(F_material_specular);
      SERIALIZE_MEMBER(V_normals);
      SERIALIZE_MEMBER(V_material_ambient);
      SERIALIZE_MEMBER(V_material_diffuse);
      SERIALIZE_MEMBER(V_material_specular);
      SERIALIZE_MEMBER(V_uv);
      SERIALIZE_MEMBER(F_uv);
      SERIALIZE_MEMBER(texture_R);
      SERIALIZE_MEMBER(texture_G);
      SERIALIZE_MEMBER(texture_B);
      SERIALIZE_MEMBER(texture_A);
      SERIALIZE_MEMBER(lines);
      SERIALIZE_MEMBER(points);
      SERIALIZE_MEMBER(labels_positions);
      SERIALIZE_MEMBER(labels_strings);
      SERIALIZE_MEMBER(dirty);
      SERIALIZE_MEMBER(face_based);
      SERIALIZE_MEMBER(show_faces);
      SERIALIZE_MEMBER(show_lines);
      SERIALIZE_MEMBER(invert_normals);
      SERIALIZE_MEMBER(show_overlay);
      SERIALIZE_MEMBER(show_overlay_depth);
      SERIALIZE_MEMBER(show_vertex_labels);
      SERIALIZE_MEMBER(show_face_labels);
      SERIALIZE_MEMBER(show_custom_labels);
      SERIALIZE_MEMBER(show_texture);
      SERIALIZE_MEMBER(double_sided);
      SERIALIZE_MEMBER(point_size);
      SERIALIZE_MEMBER(line_width);
      SERIALIZE_MEMBER(line_color);
      SERIALIZE_MEMBER(shininess);
      SERIALIZE_MEMBER(id);
    }
    template<>
    inline void serialize(const igl::opengl::ViewerData& obj, std::vector<char>& buffer)
    {
      serialization(true, const_cast<igl::opengl::ViewerData&>(obj), buffer);
    }
    template<>
    inline void deserialize(igl::opengl::ViewerData& obj, const std::vector<char>& buffer)
    {
      serialization(false, obj, const_cast<std::vector<char>&>(buffer));
      obj.dirty = igl::opengl::MeshGL::DIRTY_ALL;
    }
  }
}
 
#ifndef IGL_STATIC_LIBRARY
#  include "ViewerData.cpp"
#endif
 
#endif