text: // 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/.
  
  #include "ViewerData.h"
  
  #include <iostream>
  
  #include <igl/per_face_normals.h>
  #include <igl/material_colors.h>
  #include <igl/parula.h>
  #include <igl/per_vertex_normals.h>
  
  IGL_INLINE igl::viewer::ViewerData::ViewerData()
  : dirty(DIRTY_ALL)
  {
    clear();
  };
  
  IGL_INLINE void igl::viewer::ViewerData::set_face_based(bool newvalue)
  {
    if (face_based != newvalue)
    {
      face_based = newvalue;
      dirty = DIRTY_ALL;
    }
  }
  
  // Helpers that draws the most common meshes
  IGL_INLINE void igl::viewer::ViewerData::set_mesh(const Eigen::MatrixXd& _V, const Eigen::MatrixXi& _F)
  {
    using namespace std;
  
    Eigen::MatrixXd V_temp;
  
    // If V only has two columns, pad with a column of zeros
    if (_V.cols() == 2)
    {
      V_temp = Eigen::MatrixXd::Zero(_V.rows(),3);
      V_temp.block(0,0,_V.rows(),2) = _V;
    }
    else
      V_temp = _V;
  
    if (V.rows() == 0 && F.rows() == 0)
    {
      V = V_temp;
      F = _F;
  
      compute_normals();
      uniform_colors(
        Eigen::Vector3d(GOLD_AMBIENT[0], GOLD_AMBIENT[1], GOLD_AMBIENT[2]),
        Eigen::Vector3d(GOLD_DIFFUSE[0], GOLD_DIFFUSE[1], GOLD_DIFFUSE[2]),
        Eigen::Vector3d(GOLD_SPECULAR[0], GOLD_SPECULAR[1], GOLD_SPECULAR[2]));
  
      grid_texture();
    }
    else
    {
      if (_V.rows() == V.rows() && _F.rows() == F.rows())
      {
        V = V_temp;
        F = _F;
      }
      else
        cerr << "ERROR (set_mesh): The new mesh has a different number of vertices/faces. Please clear the mesh before plotting."<<endl;
    }
    dirty |= DIRTY_FACE | DIRTY_POSITION;
  }
  
  IGL_INLINE void igl::viewer::ViewerData::set_vertices(const Eigen::MatrixXd& _V)
  {
    V = _V;
    assert(F.size() == 0 || F.maxCoeff() < V.rows());
    dirty |= DIRTY_POSITION;
  }
  
  IGL_INLINE void igl::viewer::ViewerData::set_normals(const Eigen::MatrixXd& N)
  {
    using namespace std;
    if (N.rows() == V.rows())
    {
      set_face_based(false);
      V_normals = N;
    }
    else if (N.rows() == F.rows() || N.rows() == F.rows()*3)
    {
      set_face_based(true);
      F_normals = N;
    }
    else
      cerr << "ERROR (set_normals): Please provide a normal per face, per corner or per vertex."<<endl;
    dirty |= DIRTY_NORMAL;
  }
  
  IGL_INLINE void igl::viewer::ViewerData::set_colors(const Eigen::MatrixXd &C)
  {
    using namespace std;
    using namespace Eigen;
    if(C.rows()>0 && C.cols() == 1)
    {
      Eigen::MatrixXd C3;
      igl::parula(C,true,C3);
      return set_colors(C3);
    }
    // Ambient color should be darker color
    const auto ambient = [](const MatrixXd & C)->MatrixXd
    {
      MatrixXd T = 0.1*C;
      T.col(3) = C.col(3);
      return T;
    };
    // Specular color should be a less saturated and darker color: dampened
    // highlights
    const auto specular = [](const MatrixXd & C)->MatrixXd
    {
      const double grey = 0.3;
      MatrixXd T = grey+0.1*(C.array()-grey);
      T.col(3) = C.col(3);
      return T;
    };
    if (C.rows() == 1)
    {
      for (unsigned i=0;i<V_material_diffuse.rows();++i)
      {
        V_material_diffuse.row(i) << C.row(0),1;
      }
      V_material_ambient = ambient(V_material_diffuse);
      V_material_specular = specular(V_material_diffuse);
  
      for (unsigned i=0;i<F_material_diffuse.rows();++i)
      {
        F_material_diffuse.row(i) << C.row(0),1;
      }
      F_material_ambient = ambient(F_material_diffuse);
      F_material_specular = specular(F_material_diffuse);
    }
    else if (C.rows() == V.rows())
    {
      set_face_based(false);
      for (unsigned i=0;i<V_material_diffuse.rows();++i)
      {
        V_material_diffuse.row(i) << C.row(i),1;
      }
      V_material_ambient = ambient(V_material_diffuse);
      V_material_specular = specular(V_material_diffuse);
    }
    else if (C.rows() == F.rows())
    {
      set_face_based(true);
      for (unsigned i=0;i<F_material_diffuse.rows();++i)
      {
        if(C.cols() == 3)
          F_material_diffuse.row(i) << C.row(i),1;
        else
          F_material_diffuse.row(i) << C.row(i);
      }
      F_material_ambient = ambient(F_material_diffuse);
      F_material_specular = specular(F_material_diffuse);
    }
    else
      cerr << "ERROR (set_colors): Please provide a single color, or a color per face or per vertex."<<endl;;
    dirty |= DIRTY_DIFFUSE;
  
  }
  
  IGL_INLINE void igl::viewer::ViewerData::set_uv(const Eigen::MatrixXd& UV)
  {
    using namespace std;
    if (UV.rows() == V.rows())
    {
      set_face_based(false);
      V_uv = UV;
    }
    else
      cerr << "ERROR (set_UV): Please provide uv per vertex."<<endl;;
    dirty |= DIRTY_UV;
  }
  
  IGL_INLINE void igl::viewer::ViewerData::set_uv(const Eigen::MatrixXd& UV_V, const Eigen::MatrixXi& UV_F)
  {
    set_face_based(true);
    V_uv = UV_V.block(0,0,UV_V.rows(),2);
    F_uv = UV_F;
    dirty |= DIRTY_UV;
  }
  
  
  IGL_INLINE void igl::viewer::ViewerData::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)
  {
    texture_R = R;
    texture_G = G;
    texture_B = B;
    texture_A = Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>::Constant(R.rows(),R.cols(),255);
    dirty |= DIRTY_TEXTURE;
  }
  
  IGL_INLINE void igl::viewer::ViewerData::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)
  {
    texture_R = R;
    texture_G = G;
    texture_B = B;
    texture_A = A;
    dirty |= DIRTY_TEXTURE;
  }
  
  IGL_INLINE void igl::viewer::ViewerData::set_points(
    const Eigen::MatrixXd& P,
    const Eigen::MatrixXd& C)
  {
    // clear existing points
    points.resize(0,0);
    add_points(P,C);
  }
  
  IGL_INLINE void igl::viewer::ViewerData::add_points(const Eigen::MatrixXd& P,  const Eigen::MatrixXd& C)
  {
    Eigen::MatrixXd P_temp;
  
    // If P only has two columns, pad with a column of zeros
    if (P.cols() == 2)
    {
      P_temp = Eigen::MatrixXd::Zero(P.rows(),3);
      P_temp.block(0,0,P.rows(),2) = P;
    }
    else
      P_temp = P;
  
    int lastid = points.rows();
    points.conservativeResize(points.rows() + P_temp.rows(),6);
    for (unsigned i=0; i<P_temp.rows(); ++i)
      points.row(lastid+i) << P_temp.row(i), i<C.rows() ? C.row(i) : C.row(C.rows()-1);
  
    dirty |= DIRTY_OVERLAY_POINTS;
  }
  
  IGL_INLINE void igl::viewer::ViewerData::set_edges(
    const Eigen::MatrixXd& P,
    const Eigen::MatrixXi& E,
    const Eigen::MatrixXd& C)
  {
    using namespace Eigen;
    lines.resize(E.rows(),9);
    assert(C.cols() == 3);
    for(int e = 0;e<E.rows();e++)
    {
      RowVector3d color;
      if(C.size() == 3)
      {
        color<<C;
      }else if(C.rows() == E.rows())
      {
        color<<C.row(e);
      }
      lines.row(e)<< P.row(E(e,0)), P.row(E(e,1)), color;
    }
    dirty |= DIRTY_OVERLAY_LINES;
  }
  
  IGL_INLINE void igl::viewer::ViewerData::add_edges(const Eigen::MatrixXd& P1, const Eigen::MatrixXd& P2, const Eigen::MatrixXd& C)
  {
    Eigen::MatrixXd P1_temp,P2_temp;
  
    // If P1 only has two columns, pad with a column of zeros
    if (P1.cols() == 2)
    {
      P1_temp = Eigen::MatrixXd::Zero(P1.rows(),3);
      P1_temp.block(0,0,P1.rows(),2) = P1;
      P2_temp = Eigen::MatrixXd::Zero(P2.rows(),3);
      P2_temp.block(0,0,P2.rows(),2) = P2;
    }
    else
    {
      P1_temp = P1;
      P2_temp = P2;
    }
  
    int lastid = lines.rows();
    lines.conservativeResize(lines.rows() + P1_temp.rows(),9);
    for (unsigned i=0; i<P1_temp.rows(); ++i)
      lines.row(lastid+i) << P1_temp.row(i), P2_temp.row(i), i<C.rows() ? C.row(i) : C.row(C.rows()-1);
  
    dirty |= DIRTY_OVERLAY_LINES;
  }
  
  IGL_INLINE void igl::viewer::ViewerData::add_label(const Eigen::VectorXd& P,  const std::string& str)
  {
    Eigen::RowVectorXd P_temp;
  
    // If P only has two columns, pad with a column of zeros
    if (P.size() == 2)
    {
      P_temp = Eigen::RowVectorXd::Zero(3);
      P_temp << P.transpose(), 0;
    }
    else
      P_temp = P;
  
    int lastid = labels_positions.rows();
    labels_positions.conservativeResize(lastid+1, 3);
    labels_positions.row(lastid) = P_temp;
    labels_strings.push_back(str);
  }
  
  IGL_INLINE void igl::viewer::ViewerData::clear()
  {
    V                       = Eigen::MatrixXd (0,3);
    F                       = Eigen::MatrixXi (0,3);
  
    F_material_ambient      = Eigen::MatrixXd (0,4);
    F_material_diffuse      = Eigen::MatrixXd (0,4);
    F_material_specular     = Eigen::MatrixXd (0,4);
  
    V_material_ambient      = Eigen::MatrixXd (0,4);
    V_material_diffuse      = Eigen::MatrixXd (0,4);
    V_material_specular     = Eigen::MatrixXd (0,4);
  
    F_normals               = Eigen::MatrixXd (0,3);
    V_normals               = Eigen::MatrixXd (0,3);
  
    V_uv                    = Eigen::MatrixXd (0,2);
    F_uv                    = Eigen::MatrixXi (0,3);
  
    lines                   = Eigen::MatrixXd (0,9);
    points                  = Eigen::MatrixXd (0,6);
    labels_positions        = Eigen::MatrixXd (0,3);
    labels_strings.clear();
  
    face_based = false;
  }
  
  IGL_INLINE void igl::viewer::ViewerData::compute_normals()
  {
    igl::per_face_normals(V, F, F_normals);
    igl::per_vertex_normals(V, F, F_normals, V_normals);
    dirty |= DIRTY_NORMAL;
  }
  
  IGL_INLINE void igl::viewer::ViewerData::uniform_colors(const Eigen::Vector3d& ambient, const Eigen::Vector3d& diffuse, const Eigen::Vector3d& specular)
  {
    Eigen::Vector4d ambient4;
    Eigen::Vector4d diffuse4;
    Eigen::Vector4d specular4;
  
    ambient4 << ambient, 1;
    diffuse4 << diffuse, 1;
    specular4 << specular, 1;
  
    uniform_colors(ambient4,diffuse4,specular4);
  }
  
  IGL_INLINE void igl::viewer::ViewerData::uniform_colors(const Eigen::Vector4d& ambient, const Eigen::Vector4d& diffuse, const Eigen::Vector4d& specular)
  {
    V_material_ambient.resize(V.rows(),4);
    V_material_diffuse.resize(V.rows(),4);
    V_material_specular.resize(V.rows(),4);
  
    for (unsigned i=0; i<V.rows();++i)
    {
      V_material_ambient.row(i) = ambient;
      V_material_diffuse.row(i) = diffuse;
      V_material_specular.row(i) = specular;
    }
  
    F_material_ambient.resize(F.rows(),4);
    F_material_diffuse.resize(F.rows(),4);
    F_material_specular.resize(F.rows(),4);
  
    for (unsigned i=0; i<F.rows();++i)
    {
      F_material_ambient.row(i) = ambient;
      F_material_diffuse.row(i) = diffuse;
      F_material_specular.row(i) = specular;
    }
    dirty |= DIRTY_SPECULAR | DIRTY_DIFFUSE | DIRTY_AMBIENT;
  }
  
  IGL_INLINE void igl::viewer::ViewerData::grid_texture()
  {
    // Don't do anything for an empty mesh
    if(V.rows() == 0)
    {
      V_uv.resize(V.rows(),2);
      return;
    }
    if (V_uv.rows() == 0)
    {
      V_uv = V.block(0, 0, V.rows(), 2);
      V_uv.col(0) = V_uv.col(0).array() - V_uv.col(0).minCoeff();
      V_uv.col(0) = V_uv.col(0).array() / V_uv.col(0).maxCoeff();
      V_uv.col(1) = V_uv.col(1).array() - V_uv.col(1).minCoeff();
      V_uv.col(1) = V_uv.col(1).array() / V_uv.col(1).maxCoeff();
      V_uv = V_uv.array() * 10;
      dirty |= DIRTY_TEXTURE;
    }
  
    unsigned size = 128;
    unsigned size2 = size/2;
    texture_R.resize(size, size);
    for (unsigned i=0; i<size; ++i)
    {
      for (unsigned j=0; j<size; ++j)
      {
        texture_R(i,j) = 0;
        if ((i<size2 && j<size2) || (i>=size2 && j>=size2))
          texture_R(i,j) = 255;
      }
    }
  
    texture_G = texture_R;
    texture_B = texture_R;
    texture_A = Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>::Constant(texture_R.rows(),texture_R.cols(),255);
    dirty |= DIRTY_TEXTURE;
  }
  