//基本的なデータタイプ
#include <vcg/complex/complex.h>
// PLYファイルの入出力
#include <wrap/io_trimesh/import_ply.h>
#include <wrap/io_trimesh/export_ply.h>

class MyFace;
class MyVertex;
class MyEdge;

struct MyUsedTypes : public vcg::UsedTypes<
   vcg::Use<MyVertex>::AsVertexType,
   vcg::Use<MyFace>::AsFaceType,
   vcg::Use<MyEdge>::AsEdgeType> {};

//頂点型
class MyVertex : public vcg::Vertex< 
	MyUsedTypes, 
	vcg::vertex::Coord3f, 
	vcg::vertex::Color4b, 
	vcg::vertex::Normal3f, 
	vcg::vertex::VFAdj, 
	vcg::vertex::VEAdj, 
	vcg::vertex::Qualityf, 
	vcg::vertex::BitFlags, 
	vcg::vertex::Mark> {
//ここにメンバ変数を追加できる
};
//面型
class MyFace : public vcg::Face  < 
	MyUsedTypes, 
	vcg::face::VertexRef, 
	vcg::face::Normal3f, 
	vcg::face::FFAdj, 
	vcg::face::EFAdj, 
	vcg::face::Mark, 
	vcg::face::VFAdj, 
	vcg::face::BitFlags > {
};
//エッジ型
class MyEdge : public vcg::Edge< 
	MyUsedTypes, 
	vcg::edge::VertexRef, 
	vcg::edge::BitFlags, 
	vcg::edge::EVAdj, 
	vcg::edge::EFAdj> {
};
//3Dモデル型
class MyMesh : public vcg::tri::TriMesh< 
	std::vector<MyVertex>, 
	std::vector<MyFace>, 
	std::vector<MyEdge> > {
};

//メッシュデータオブジェクト
MyMesh mesh;
int main(int argc, char **argv)
{

  //plyファイル読み込み
  vcg::tri::io::ImporterPLY<MyMesh>::Open(mesh, "data.ply");

  //面法線計算
  vcg::tri::UpdateNormal<MyMesh>::PerFace(mesh);

  //Triangleのエッジ情報を作成
  vcg::tri::UpdateTopology<MyMesh>::AllocateEdge(mesh);

  //縮尺
　// meshオブジェクトがbboxメンバ(Bounding Box)を持っているので、
  // モデルの最大・最小の座標がわかる
  double scalex = 1.0 / (mesh.bbox.max.X() - mesh.bbox.min.X());
  double scaley = 1.0 / (mesh.bbox.max.Y() - mesh.bbox.min.Y());
  double scalez = 1.0 / (mesh.bbox.max.Z() - mesh.bbox.min.Z());

  double scale = (std::min)((std::min)(scalex, scaley), scalez);

  //センタリング
  double offsx = mesh.bbox.min.X() + (mesh.bbox.max.X() - mesh.bbox.min.X()) / 2;
  double offsy = mesh.bbox.min.Y() + (mesh.bbox.max.Y() - mesh.bbox.min.Y()) / 2;
  double offsz = mesh.bbox.min.Z() + (mesh.bbox.max.Z() - mesh.bbox.min.Z()) / 2;

//三角形で表示
void disp_triangles() {

  //マテリアルの設定
  glMaterialfv(GL_FRONT, GL_AMBIENT, material_ambient);
  glMaterialfv(GL_FRONT, GL_SPECULAR, material_specular);

  glEnable(GL_LIGHTING);

  glMaterialfv(GL_FRONT, GL_DIFFUSE, material_diffuse_w);
  //描画処理本体
  // mesh.face[0].N で面法線
  // mesh.face[0].V(0)->C.X() で三角形の第一頂点のR
  // mesh.face[0].V(0)->P().X() で三角形の第一頂点のx座標
　// * cがついているのはconstの意味
  glBegin(GL_TRIANGLES);
  for (const auto& f : mesh.face) {
    glNormal3d(f.cN().X(), f.cN().Y(), f.cN().Z());
    for (size_t i = 0; i < 3; i++) {
      glColor3ub(f.cV(i)->cC().X(), f.cV(i)->cC().Y(), f.cV(i)->cC().Z());
      glVertex3d(f.cV(i)->cP().X(), f.cV(i)->cP().Y(), f.cV(i)->cP().Z());
    }

  }
  glEnd();
}
//三角形のエッジを表示
void disp_edge() {

  glDisable(GL_LIGHTING);

  glColor3d(1, 0, 0);
  glBegin(GL_LINES);
  for (const auto& e : mesh.edge) {
    glVertex3d(e.cV(0)->cP().X(), e.cV(0)->cP().Y(), e.cV(0)->cP().Z());
    glVertex3d(e.cV(1)->cP().X(), e.cV(1)->cP().Y(), e.cV(1)->cP().Z());
  }
  glEnd();
}

//! @brief 三次元ベクトルの外積を求める
//! @param [out] dvec 求めたベクトル
//! @param [in] svec1 一つ目の三次元ベクトル
//! @param [in] svec2 二つ目の三次元ベクトル
//! @return なし
void outer(double * const dvec, double const * const svec1, double const * const svec2) {

  const double& xa = svec1[0];
  const double& ya = svec1[1];
  const double& za = svec1[2];
  const double& xb = svec2[0];
  const double& yb = svec2[1];
  const double& zb = svec2[2];

  dvec[0] = ya * zb - za * yb;
  dvec[1] = za * xb - xa * zb;
  dvec[2] = xa * yb - ya * xb;
}

//! @brief ベクトルの内積を求める
//! @param [in] vec1 一つ目の三次元ベクトル
//! @param [in] vec2 二つ目の三次元ベクトル
//! @return 内積
double inner(double const * const vec1, double const * const vec2) {
  const double& xa = vec1[0];
  const double& ya = vec1[1];
  const double& za = vec1[2];
  const double& xb = vec2[0];
  const double& yb = vec2[1];
  const double& zb = vec2[2];

  return (xa*xb + ya*yb + za*zb);
}

//! @brief ベクトルの長さを求める関数
//! @param [in] vec 三次元ベクトル
//! @return 長さ
double vlen(double const * const vec) {
  const double& x = vec[0];
  const double& y = vec[1];
  const double& z = vec[2];

  return sqrt(x * x + y * y + z * z);
}

//! @brief 二つのベクトルの角度をラジアンで求める関数
//! @param [in] vec1 一つ目の三次元ベクトル
//! @param [in] vec2 二つ目の三次元ベクトル
//! @return 二つのベクトルのなす角（ラジアン）
double vangle(double const * const vec1, double const * const vec2) {
  return acos(inner(vec1, vec2) / (vlen(vec1) * vlen(vec2)));
}

//! @brief ある三次元ベクトルに垂直な三次元ベクトルを求める
//! @param [out] dst3 結果の格納先
//! @param [in] src3 三次元ベクトル
void rightvec(double* dst3, double* src3) {

  double tmp[3] = { 1,0,0 };

  //tmpとsrc3の角度０またはそれに近いなら、別なベクトルを用意
  if (vangle(tmp, src3) < 0.00174533) { //0.00174533rad=1degree
    tmp[0] = 0;
    tmp[1] = 1;
    tmp[2] = 0;
  }
  //外積を求める
  outer(dst3, tmp, src3);
}

#include <Windows.h>
#include <gl/GL.h>
#include <gl/freeglut.h>
#include <math.h>
#pragma comment(lib,"opengl32.lib")
#pragma comment(lib,"freeglut.lib")

void display(void)
{
  glClear(GL_COLOR_BUFFER_BIT);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  glTranslated(0.0, 0.0, -5.0);

  glPushMatrix();
  static double deg = 0;
  deg = deg + 1;
  glRotated(deg, 0, 1, 0);

  glColor3d(1, 0, 0);
  //一本目のベクトルを表示
  double src3[3] = { 2,-3,4 };
  glBegin(GL_LINES);
  glVertex3d(0, 0, 0);
  glVertex3dv(src3);
  glEnd();

  glColor3d(0, 1, 0);
  double dst3[3];
  rightvec(dst3, src3);
  //二本目のベクトルを表示
  glBegin(GL_LINES);
  glVertex3d(0, 0, 0);
  glVertex3dv(dst3);
  glEnd();


  glPopMatrix();


  glFlush();
}
void timer(int value) {
  glutPostRedisplay();
  glutTimerFunc(50, timer, 0);
}
void init(void)
{
  glClearColor(0.0, 0.0, 1.0, 1.0);
}
void resize(int w, int h)
{
  glViewport(0, 0, w, h);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(30.0, (double)w / (double)h, 1.0, 100.0);
}
int main(int argc, char *argv[])
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGBA);
  glutCreateWindow(argv[0]);
  glutDisplayFunc(display);
  glutReshapeFunc(resize);
  glutTimerFunc(100, timer, 0);
  init();
  glutMainLoop();
  return 0;
}

#include <string>
#include <unordered_map>
#include <iostream>

////////////////////////////////////////////////////////////////
//ハッシュ値を統合する ( 汎用的に使用できる関数 )
// seed  in:既存のハッシュ値  out:元のseedとvから作成したハッシュ値を統合した値
// v     新たにハッシュ値を作成する値
template<typename T>
void hash_combine(size_t & seed, T const& v) {
  //基本型に関するハッシュ生成は標準ライブラリが提供している
  std::hash<T> primitive_type_hash;

  //生成したハッシュを合成する。このコードはboostものを使用する
  seed ^= primitive_type_hash(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

////////////////////////////////////////////////////////////////
// 自作データ
class MyData {
public:
  std::string m_v_str;
  int m_v_int;
  double m_v_double;
};
////////////////////////////////////////////////////////////////
// 自作データの比較演算子
bool operator==(const MyData& v1, const MyData& v2) {

  return
    v1.m_v_str == v2.m_v_str &&
    v1.m_v_int == v2.m_v_int &&
    v1.m_v_double == v2.m_v_double;//本当はdoubleを==比較してはいけません
}

////////////////////////////////////////////////////////////////
//自作データのハッシュを作成
namespace std {

  // 標準ライブラリは struct hash<>というデータをハッシュ化する関数オブジェクトのテンプレートを提供している
  // これは最初から基本型に対しては特殊化されているのでそのまま使える(上記hash_combine内で使用)
  // 自作クラスの場合は自分で特殊化し、operator()を定義してやる。

  template<>
  struct hash<MyData> {
  public:
    size_t operator()(const MyData& data)const {

      //クラスのメンバの値それぞれについてハッシュ生成して、それらを結合して一つのハッシュ値にする
      std::size_t seed = 0;
      hash_combine(seed, data.m_v_str);
      hash_combine(seed, data.m_v_int);
      hash_combine(seed, data.m_v_double);

      return seed;

    }
  };
}

////////////////////////////////////////////////////////////////
// エントリポイント
int main()
{
  std::unordered_map<MyData, int> map;

  map[ { "hello"   , 111 , 6.0e3 } ] = 0;
  map[ { "goodbye" , 111 , 6.0e3 } ] = 0;
  map[ { "hello"   , 222 , 6.0e3 } ] = 0;
  map[ { "goodbye" , 222 , 6.0e3 } ] = 0;
  map[ { "hello"   , 222 , 2.0e4 } ] = 0;
  map[ { "goodbye" , 222 , 3.0e4 } ] = 0;

  for (int i = 0; i < 3; i++) {
    map[{"hello"  , 111, 6.0e3 }]++;
    map[{"goodbye", 111, 6.0e3 }]++;
  }

  using namespace std;

  //結果出力
  for (auto& data : map) {
    cout 
      << "( " 
      << data.first.m_v_str << " , " 
      << data.first.m_v_int << " , " 
      << data.first.m_v_double << " ) = " 
      << data.second 
      << std::endl;
  }

  int i;
  cin >> i;

  return 0;
}