/************************************************************************
Yutaka Ohtake 

CMeshEditorView.cpp
Window 

Copyright (c) 1999-2001 
The University of Aizu. All Rights Reserved.
************************************************************************/

#include "stdafx.h"
#include "MeshEditor.h"

#include "MeshEditorDoc.h"
#include "MeshEditorView.h"
#include "MeshData.h"

#include <gl\gl.h>
#include <gl\glu.h>
#include <math.h>


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CMeshEditorView

IMPLEMENT_DYNCREATE(CMeshEditorView, CView)

BEGIN_MESSAGE_MAP(CMeshEditorView, CView)
	//{{AFX_MSG_MAP(CMeshEditorView)
	ON_WM_SIZE()
	ON_WM_DESTROY()
	ON_WM_CREATE()
	ON_WM_RBUTTONUP()
	ON_WM_RBUTTONDOWN()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_KEYDOWN()
	ON_WM_MOUSEWHEEL()
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONDBLCLK()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMeshEditorView クラスの構築/消滅

CMeshEditorView::CMeshEditorView()
{
	eye[0] = 26;
	eye[1] = -48;
	eye[2] = 40;

	center[0] = 0.0;
	center[1] = 0.0;
	center[2] = 0.0; //5.0;

	Rx = 0;
	Ry = 0;
	Rz = 0;

	//bunny
	//Ry = -462;
	//Rz = 209;

	//venus
	//Ry = -564;
	//Rz = -57;
	//Ry = -573;
	//Rz = 692;

	//2tori
	//Ry = -433;
	//Rz = 15;
	//Ry = -797;
	//Rz = 209;
	//Ry = -433;
	//Rz = 79;


	//teeth
	//Ry = -807;
	//Rz = 337;

	//dino
	//Ry = -572 - 180 - 40;
	//Rz = 129;

	//buuny2
	//Ry = -515.000000;
	//Rz = 708.000000;

	vx[0] = 0;
	vx[1] = 0;
	vx[2] = 1;

	vy[0] = -(float)(eye[1]/sqrt(eye[0]*eye[0]+eye[1]*eye[1]));
	vy[1] = (float)(eye[0]/sqrt(eye[0]*eye[0]+eye[1]*eye[1]));
	vy[2] = 0;

	vz[0] = -vy[1];
	vz[1] = vy[0];
	vz[2] = 0;

	//bunny
	//view_angle = 25.0f;
	//venus
	//view_angle = 8.65;
	view_angle = 22.5;
	//2tori
	//view_angle = 21.3;
	//view_angle = 9.9;
	//dino
	//view_angle = 7.35;
	//view_angle = 16.85;

	isLPressed = FALSE;
	isRPressed = FALSE;

	shift_x = 0;
	shift_y = 0;
	shift_z = 0;

	vertex_count = 0;
	face_count = 0;

	color_type = 0;
}

CMeshEditorView::~CMeshEditorView()
{
	//glDeleteLists(1,1);
}

BOOL CMeshEditorView::PreCreateWindow(CREATESTRUCT& cs)
{
	cs.style |= WS_CLIPCHILDREN | WS_CLIPSIBLINGS/* | WS_MAXIMIZE*/;
	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CMeshEditorView クラスの描画

void CMeshEditorView::OnDraw(CDC* pDC)
{
	CMeshEditorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	wglMakeCurrent(pDC->m_hDC, m_hRC);

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

//TRACE("%f, %f\n", Ry, Rz);
//TRACE("%f\n", view_angle);
	glPushMatrix();
	//glCallList(2);

	glTranslatef(shift_x,shift_y,shift_z);
	glRotatef(Rx,vz[0],vz[1],vz[2]);
	glRotatef(Ry,vy[0],vy[1],vy[2]);
	glRotatef(Rz,vx[0],vx[1],vx[2]);

	//glCallList(1);
	pDoc->drawMesh();
	//drawPickedPoint();
	glPopMatrix();

	glFlush();
	SwapBuffers(wglGetCurrentDC());
	wglMakeCurrent(pDC->m_hDC, NULL);

	pDC->SetBkColor(RGB(255,255,255));
	pDC->SetTextColor(RGB(0,0,0));
	
	int v = vertex_count;
	if(v == 0)
		return;
	CString str = "";
	for(int i=v; i!= 0; i = i/10)
		str = (char)((int)'0'+i%10) + str;
	pDC->TextOut(8,8,"Vertex:" +  str);
	v = face_count;
	str = "";
	for(i=v; i!= 0; i = i/10)
		str = (char)((int)'0'+i%10) + str;
	pDC->TextOut(8,25,"Face  :" +  str);

	//TRACE("%f,%f\n", Ry, Rz); 
}

/////////////////////////////////////////////////////////////////////////////
// CMeshEditorView クラスの診断

#ifdef _DEBUG
void CMeshEditorView::AssertValid() const
{
	CView::AssertValid();
}

void CMeshEditorView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CMeshEditorDoc* CMeshEditorView::GetDocument() // 非デバッグ バージョンはインラインです。
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMeshEditorDoc)));
	return (CMeshEditorDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CMeshEditorView クラスのメッセージ ハンドラ

void CMeshEditorView::flatShade(MeshData *mesh)
{
	//CClientDC clientDC(this);
	//wglMakeCurrent(clientDC.m_hDC, m_hRC);

	//glDeleteLists(1,1);
	//glNewList(1, GL_COMPILE);
	glShadeModel(GL_SMOOTH);

	int face_N = mesh->face_N;
	int (*face)[3] = mesh->face;
	float (*normal_f)[3] = mesh->normal_f;
	float (*vertex)[3] = mesh->vertex;
	for(int i=0; i<face_N; i++){
		if(face[i][0] < 0)
			continue;
		glBegin(GL_POLYGON);
			glNormal3fv(normal_f[i]);
			glVertex3fv(vertex[face[i][0]]);
			glVertex3fv(vertex[face[i][1]]);
			glVertex3fv(vertex[face[i][2]]);
		glEnd();
	}

	if(mesh->selected_triangle != NULL){
		glDisable(GL_LIGHTING);
		int f = mesh->selected_triangle->f;
		glBegin(GL_POINTS);
			glColor3f(1,0,0);
			glVertex3fv(vertex[face[f][0]]);
			glVertex3fv(vertex[face[f][1]]);
			glVertex3fv(vertex[face[f][2]]);
		glEnd();
		glEnable(GL_LIGHTING);
	}

	//glEndList();

	//wglMakeCurrent(clientDC.m_hDC, NULL);

	//CClientDC* dc = new CClientDC(this); 
	//OnDraw(dc);
	//delete dc;
}

void CMeshEditorView::OnSize(UINT nType, int cx, int cy) 
{
	CView::OnSize(nType, cx, cy);
	
	// TODO: この位置にメッセージ ハンドラ用のコードを追加してください
	int i;
	GLdouble up[3];
	GLdouble vector[3];
	GLdouble norm;

	CClientDC clientDC(this);

	wglMakeCurrent(clientDC.m_hDC, m_hRC);

	glViewport(0, 0, cx, cy);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	//gluPerspective(3, (GLfloat)cx/(GLfloat)cy, 10.0, 4000.0);
	gluPerspective(view_angle, (GLfloat)cx/(GLfloat)cy, 10.0, 4000.0);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	for(i=0; i<3; i++)
		vector[i] = center[i] - eye[i];

	up[0] =  -vector[0] * vector[2];
	up[1] =  -vector[1] * vector[2];
	up[2] =  vector[0] * vector[0] + vector[1] * vector[1];

	norm = up[0] * up[0] + up[1] * up[1] + up[2] * up[2];
	norm = sqrt(norm);
	for(i=0; i<3; i++)
		up[i] = up[i] / norm;
	
	gluLookAt(eye[0], eye[1], eye[2], center[0], center[1], center[2],
		up[0], up[1], up[2]);

	wglMakeCurrent(clientDC.m_hDC, NULL);
	//TRACE("(%d, %d), %f\n", cx, cy, 2.0*MeshData::DIST(eye, center)*tan(0.5*view_angle*PI/180));
}

void CMeshEditorView::OnDestroy() 
{
	CView::OnDestroy();
	
	// TODO: この位置にメッセージ ハンドラ用のコードを追加してください
	wglDeleteContext(m_hRC);
}

int CMeshEditorView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CView::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	// TODO: この位置に固有の作成用コードを追加してください
	PIXELFORMATDESCRIPTOR pfd =
	{
		sizeof(PIXELFORMATDESCRIPTOR),
		1,
		PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
		PFD_TYPE_RGBA,
		16,
		0,0,0,0,0,0,
		0,0,0,0,0,0,0,
		32,
		0,0,
		PFD_MAIN_PLANE,
		0,
		0,0,0
	};

	CClientDC  clientDC(this);

	int pixelFormat = ChoosePixelFormat(clientDC.m_hDC, &pfd);
	if(!SetPixelFormat(clientDC.m_hDC, pixelFormat, &pfd))
		return -1;

	m_hRC = wglCreateContext(clientDC.m_hDC);

	//wglMakeCurrent(clientDC.m_hDC,m_hRC);
	initGL();
	/***************************
	glDeleteLists(2,1);
	glNewList(2, GL_COMPILE);
	glShadeModel(GL_SMOOTH);

	glDisable(GL_LIGHTING);
	
	glColor3f(0,0,0);

	glBegin(GL_LINES);
		glVertex3f(0,0,0);
		glVertex3f(20*vx[0],20*vx[1],20*vx[2]);
	glEnd();

	glBegin(GL_LINES);
		glVertex3f(0,0,0);
		glVertex3f(20*vy[0],20*vy[1],20*vy[2]);
	glEnd();

	glBegin(GL_LINES);
		glVertex3f(0,0,0);
		glVertex3f(20*vz[0],20*vz[1],20*vz[2]);
	glEnd();

	glEndList();

	glEnable(GL_LIGHTING);
	*******************************/

	//wglMakeCurrent(clientDC.m_hDC,NULL);

	return 0;
}

void CMeshEditorView::initGL()
{
	CClientDC clientDC(this);
	wglMakeCurrent(clientDC.m_hDC, m_hRC);

	GLfloat light_position1[4] = {-52, -16, -50, 0};
	GLfloat light_position2[4] = {-26, -48, -50, 0};
	GLfloat light_position3[4] = { 16, -52, -50, 0};

	GLfloat direction1[3] = {52,16,50};
	GLfloat direction2[3] = {26,48,50};
	GLfloat direction3[3] = {-16,52,50};

	GLfloat light_position4[4] = {52, 16, 50, 0};
	GLfloat light_position5[4] = {26, 48, 50, 0};
	GLfloat light_position6[4] = {-16, 52, 50, 0};

	GLfloat direction4[3] = {-52,-16,-50};
	GLfloat direction5[3] = {-26,-48,-50};
	GLfloat direction6[3] = {16,-52,-50};

	GLfloat color1[4], color2[4], color3[4], color4[4], color5[4], color6[4];

	//color_type = 5;

	if(color_type == 0){
		color1[0] = 1; color1[1] = 0; color1[2] = 0; color1[3] = 1;
		color2[0] = 0; color2[1] = 1; color2[2] = 0; color2[3] = 1;
		color3[0] = 0; color3[1] = 0; color3[2] = 1; color3[3] = 1;

		color4[0] = 1; color4[1] = 0; color4[2] = 0; color4[3] = 1;
		color5[0] = 0; color5[1] = 1; color5[2] = 0; color5[3] = 1;
		color6[0] = 0; color6[1] = 0; color6[2] = 1; color6[3] = 1;
	}
	else if(color_type == 2){
		color1[0] = 0; color1[1] = 1; color1[2] = 0; color1[3] = 1;
		color2[0] = 0.4f; color2[1] = 0.4f; color2[2] = 0.4f; color2[3] = 1;
		color3[0] = 0.4f; color3[1] = 0.4f; color3[2] = 0.4f; color3[3] = 1;

		color4[0] = 0; color4[1] = 1; color4[2] = 0; color4[3] = 1;
		color5[0] = 0.4f; color5[1] = 0.4f; color5[2] = 0.4f; color5[3] = 1;
		color6[0] = 0.4f; color6[1] = 0.4f; color6[2] = 0.4f; color6[3] = 1;
	}
	else if(color_type == 1){
		color1[0] =	1; color1[1] = 0; color1[2] = 0; color1[3] = 1;
		color2[0] = 0.4f; color2[1] = 0.4f; color2[2] = 0.4f; color2[3] = 1;
		color3[0] = 0.4f; color3[1] = 0.4f; color3[2] = 0.4f; color3[3] = 1;

		color4[0] = 1; color4[1] = 0; color4[2] = 0; color4[3] = 1;
		color5[0] = 0.4f; color5[1] = 0.4f; color5[2] = 0.4f; color5[3] = 1;
		color6[0] = 0.4f; color6[1] = 0.4f; color6[2] = 0.4f; color6[3] = 1;
	}
	else if(color_type == 4){
		color1[0] = 0; color1[1] = 0; color1[2] = 1; color1[3] = 1;
		color2[0] = 0.4f; color2[1] = 0.4f; color2[2] = 0.4f; color2[3] = 1;
		color3[0] = 0.4f; color3[1] = 0.4f; color3[2] = 0.4f; color3[3] = 1;

		color4[0] = 0; color4[1] = 0; color4[2] = 1; color4[3] = 1;
		color5[0] = 0.4f; color5[1] = 0.4f; color5[2] = 0.4f; color5[3] = 1;
		color6[0] = 0.4f; color6[1] = 0.4f; color6[2] = 0.4f; color6[3] = 1;
	}
	else{
		color1[0] = 0.7f; color1[1] = 0.7f; color1[2] = 0.7f; color1[3] = 1;
		color2[0] = 0.7f; color2[1] = 0.7f; color2[2] = 0.7f; color2[3] = 1;
		color3[0] = 0.7f; color3[1] = 0.7f; color3[2] = 0.7f; color3[3] = 1;

		color4[0] = 0.7f; color4[1] = 0.7f; color4[2] = 0.7f; color4[3] = 1;
		color5[0] = 0.7f; color5[1] = 0.7f; color5[2] = 0.7f; color5[3] = 1;
		color6[0] = 0.7f; color6[1] = 0.7f; color6[2] = 0.7f; color6[3] = 1;
	}

	GLfloat ambient[4] = {0.3f,0.3f,0.3f,1.0f};

	GLfloat material_color[4] = {1,1,1,0.5f};
	GLfloat material_specular[4] = {0.5f,0.5f,0.5f,0.5f};
	GLfloat material_ambient[4] = {0.0,0.0,0.0,0.0};

	glClearColor(1,1,1,0);
	//glClearColor(0.7,0.7,0.7,0);

	glLightfv(GL_LIGHT0, GL_POSITION, light_position1);
	glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, direction1);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, color1);
	glLightfv(GL_LIGHT0, GL_SPECULAR, color1);

	glLightfv(GL_LIGHT1, GL_POSITION, light_position2);
	glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, direction2);
	glLightfv(GL_LIGHT1, GL_DIFFUSE, color2);
	glLightfv(GL_LIGHT1, GL_SPECULAR, color2);

	glLightfv(GL_LIGHT2, GL_POSITION, light_position3);
	glLightfv(GL_LIGHT2, GL_SPOT_DIRECTION, direction3);
	glLightfv(GL_LIGHT2, GL_DIFFUSE, color3);
	glLightfv(GL_LIGHT2, GL_SPECULAR, color3);

	glLightfv(GL_LIGHT3, GL_POSITION, light_position4);
	glLightfv(GL_LIGHT3, GL_SPOT_DIRECTION, direction4);
	glLightfv(GL_LIGHT3, GL_DIFFUSE, color4);
	glLightfv(GL_LIGHT3, GL_SPECULAR, color4);

	glLightfv(GL_LIGHT4, GL_POSITION, light_position5);
	glLightfv(GL_LIGHT4, GL_SPOT_DIRECTION, direction5);
	glLightfv(GL_LIGHT4, GL_DIFFUSE, color5);
	glLightfv(GL_LIGHT4, GL_SPECULAR, color5);

	glLightfv(GL_LIGHT5, GL_POSITION, light_position6);
	glLightfv(GL_LIGHT5, GL_SPOT_DIRECTION, direction6);
	glLightfv(GL_LIGHT5, GL_DIFFUSE, color6);
	glLightfv(GL_LIGHT5, GL_SPECULAR, color6);

	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);

	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material_specular);
	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material_color);
	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material_ambient);
	glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 128);

	glEnable(GL_LIGHTING);

	
	glEnable(GL_LIGHT0);
	glEnable(GL_LIGHT1);
	glEnable(GL_LIGHT2);
	
	glEnable(GL_LIGHT3);
	glEnable(GL_LIGHT4);
	glEnable(GL_LIGHT5);

	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LESS);

	glEnable(GL_POINT_SMOOTH);
	glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);

	//glEnable(GL_LINE_SMOOTH);
	//glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);

	glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);

	glLineWidth(1.0);
	glPointSize(3.0);

	wglMakeCurrent(clientDC.m_hDC, NULL);

	//glEnable(GL_BLEND);
	//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
}

void CMeshEditorView::smoothShade(MeshData *mesh)
{
	//CClientDC clientDC(this);
	//wglMakeCurrent(clientDC.m_hDC, m_hRC);

	//glDeleteLists(1,1);
	//glNewList(1, GL_COMPILE);
	glShadeModel(GL_SMOOTH);
	int face_N = mesh->getFaceCount();
	for(int i=0; i<face_N; i++){
		int *f = mesh->face[i];
		if(f[0] < 0)
			continue;
		glBegin(GL_POLYGON);
			glNormal3fv(mesh->normal[f[0]]);
			glVertex3fv(mesh->vertex[f[0]]);

			glNormal3fv(mesh->normal[f[1]]);
			glVertex3fv(mesh->vertex[f[1]]);

			glNormal3fv(mesh->normal[f[2]]);
			glVertex3fv(mesh->vertex[f[2]]);
		glEnd();
	}
	//glEndList();

	//wglMakeCurrent(clientDC.m_hDC, NULL);

	//CClientDC* dc = new CClientDC(this); 
	//OnDraw(dc);
	//delete dc;
}

void CMeshEditorView::OnRButtonUp(UINT nFlags, CPoint point) 
{
	// TODO: この位置にメッセージ ハンドラ用のコードを追加するかまたはデフォルトの処理を呼び出してください
	isRPressed = false;
	CView::OnRButtonUp(nFlags, point);
}

void CMeshEditorView::OnRButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: この位置にメッセージ ハンドラ用のコードを追加するかまたはデフォルトの処理を呼び出してください
	isRPressed = true;
	px = point.x;
	py = point.y;
	CView::OnRButtonDown(nFlags, point);
}

void CMeshEditorView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: この位置にメッセージ ハンドラ用のコードを追加するかまたはデフォルトの処理を呼び出してください
	isLPressed = TRUE;
	px = point.x;
	py = point.y;
	CView::OnLButtonDown(nFlags, point);
}

void CMeshEditorView::OnLButtonUp(UINT nFlags, CPoint point) 
{
	// TODO: この位置にメッセージ ハンドラ用のコードを追加するかまたはデフォルトの処理を呼び出してください
	isLPressed = FALSE;
	CView::OnLButtonUp(nFlags, point);
}

void CMeshEditorView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	// TODO: この位置にメッセージ ハンドラ用のコードを追加するかまたはデフォルトの処理を呼び出してください
	float ex[3], ey[3], v[3];
	for(int i=0; i<3; i++)
		v[i] = (float)(center[i] - eye[i]);
	ey[0] =  -v[0] * v[2];
	ey[1] =  -v[1] * v[2];
	ey[2] =  v[0] * v[0] + v[1] * v[1];

	double norm = ey[0] * ey[0] + ey[1] * ey[1] + ey[2] * ey[2];
	norm = 5*sqrt(norm);
	for(i=0; i<3; i++)
		ey[i] = (float)(ey[i] / norm);

	MeshData::CROSS(ex, v, ey);
	norm = 5*MeshData::LENGTH(ex);
	ex[0] = (float)(ex[0]/norm);
	ex[1] = (float)(ex[1]/norm);
	ex[2] = (float)(ex[2]/norm);

	switch(nChar){
	case VK_UP:
		shift_x += ey[0];
		shift_y += ey[1];
		shift_z += ey[2];
		break;
	case VK_DOWN:
		shift_x -= ey[0];
		shift_y -= ey[1];
		shift_z -= ey[2];
		break;
	case VK_RIGHT:
		shift_x += ex[0];
		shift_y += ex[1];
		shift_z += ex[2];
		break;
	case VK_LEFT:
		shift_x -= ex[0];
		shift_y -= ex[1];
		shift_z -= ex[2];
		break;
	}

	/*
	switch(nChar){
	case VK_UP:
		shift_z += 1;
		break;
	case VK_DOWN:
		shift_z -= 1;
		break;
	case VK_RIGHT:
		shift_x += 1;
		break;
	case VK_LEFT:
		shift_x -= 1;
		break;
	}
	*/
	CClientDC* dc = new CClientDC(this); 
	OnDraw(dc);
	delete dc;

	CView::OnKeyDown(nChar, nRepCnt, nFlags);
}

BOOL CMeshEditorView::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt) 
{
	// TODO: この位置にメッセージ ハンドラ用のコードを追加するかまたはデフォルトの処理を呼び出してください
	Rx += zDelta/20;
	CClientDC* dc = new CClientDC(this); 
	OnDraw(dc);
	delete dc;
	

	return CView::OnMouseWheel(nFlags, zDelta, pt);
}

void CMeshEditorView::OnMouseMove(UINT nFlags, CPoint point) 
{
	// TODO: この位置にメッセージ ハンドラ用のコードを追加するかまたはデフォルトの処理を呼び出してください
	if(isLPressed){
		int nx = point.x;
		int ny = point.y;
		int aZ, aY;

		Rz += aZ = (nx - px)/3;
		Ry += aY = (ny - py)/3;
		px = nx;
		py = ny;
		CClientDC* dc = new CClientDC(this); 
		OnDraw(dc);
		delete dc;

		/*
		float tmp2[3];
		tmp2[0] = 0;
		tmp2[1] = 0;
		tmp2[2] = 1;

		//vx[0] = cos(aZ)*tmp2[0] - sin(aZ)*tmp2[1];
		//vx[1] = sin(aZ)*tmp2[0] + cos(aZ)*tmp2[1];

		float tmp1[3];
		tmp1[0] = -(float)(eye[1]/sqrt(eye[0]*eye[0]+eye[1]*eye[1]));
		tmp1[1] = (float)(eye[0]/sqrt(eye[0]*eye[0]+eye[1]*eye[1]));
		tmp1[2] = 0;

		vy[0] = cos(aZ)*tmp1[0] - sin(aZ)*tmp1[1];
		vy[1] = sin(aZ)*tmp1[0] + cos(aZ)*tmp1[1];

		vx[0] = cos(aZ)*tmp2[0] - sin(aZ)*tmp2[1];
		vx[1] = sin(aZ)*tmp2[0] + cos(aZ)*tmp2[1];
		*/
	}
	else if(isRPressed){
		int nx = point.x;
		int ny = point.y;

		view_angle += (ny - py)/20.0f;
		px = nx;
		py = ny;
		CClientDC* dc = new CClientDC(this);

		RECT* rect = new RECT;
		GetClientRect(rect);
		OnSize(SIZE_RESTORED, rect->right, rect->bottom);
		delete rect;
		OnDraw(dc);
		delete dc;
	}
	CView::OnMouseMove(nFlags, point);
}

void CMeshEditorView::drawRidgeVertexAsSegmet(MeshData *mesh, BOOL transparent, BOOL gray_scale, BOOL principal_dir)
{
	//CClientDC clientDC(this);
	//wglMakeCurrent(clientDC.m_hDC, m_hRC);

	//glDeleteLists(1,1);
	//glNewList(1, GL_COMPILE);
	glShadeModel(GL_SMOOTH);

	glDisable(GL_LIGHTING);

	int vertex_N = mesh->vertex_N;

	float (*vertex)[3] = mesh->vertex;
	double (*ridge_dir)[3], (*ravine_dir)[3];
	if(!principal_dir){
		ridge_dir = mesh->ridge_dir;
		ravine_dir = mesh->ravine_dir;
	}
	BOOL *isRidge = mesh->isRidge;
	BOOL *isRavine = mesh->isRavine;

	mesh->computeNormal();
	float (*normal)[3] = mesh->normal;

	if(gray_scale)
		glColor3f(1,1,1);
	else
		glColor3f(1,0,0);

	float r[] = {0.1f, 0.03f, 0.01f};
	float d[3][3];

	//glPointSize(10.0);

	glBegin(GL_POINTS);
	for(int i=0; i<vertex_N; i++){
		if(isRidge[i]){
			if(principal_dir){
				glVertex3fv(vertex[i]);
				//sphere(0.05f, vertex[i], 10);
			}
			else{
				d[0][0] = (float)ridge_dir[i][0];
				d[0][1] = (float)ridge_dir[i][1];
				d[0][2] = (float)ridge_dir[i][2];

				d[2][0] = normal[i][0];
				d[2][1] = normal[i][1];
				d[2][2] = normal[i][2];

				MeshData::CROSS(d[1], d[0], d[2]);
				float len = (float)MeshData::LENGTH(d[1]);
				d[1][0] /= len;
				d[1][1] /= len;
				d[1][2] /= len;

				MeshData::CROSS(d[2], d[0], d[1]);

				sphere2(r, vertex[i], d, 5);

				/*
				float v1[3];
				v1[0] = vertex[i][0] + 0.1f*ridge_dir[i][0];
				v1[1] = vertex[i][1] + 0.1f*ridge_dir[i][1];
				v1[2] = vertex[i][2] + 0.1f*ridge_dir[i][2];

				float v2[3];
				v2[0] = vertex[i][0] - 0.1f*ridge_dir[i][0];
				v2[1] = vertex[i][1] - 0.1f*ridge_dir[i][1];
				v2[2] = vertex[i][2] - 0.1f*ridge_dir[i][2];

				glBegin(GL_LINES);
					glVertex3fv(v1);
					glVertex3fv(v2);
				glEnd();
				*/
			}
		}
	}
	glEnd();

	if(gray_scale)
		glColor3f(0,0,0);
	else
		glColor3f(0,0,1);
	glBegin(GL_POINTS);
	for(i=0; i<vertex_N; i++){
		if(isRavine[i]){
			if(principal_dir){
				glVertex3fv(vertex[i]);
				//sphere(0.05f, vertex[i], 10);
			}
			else{
				d[0][0] = (float)ravine_dir[i][0];
				d[0][1] = (float)ravine_dir[i][1];
				d[0][2] = (float)ravine_dir[i][2];

				d[2][0] = normal[i][0];
				d[2][1] = normal[i][1];
				d[2][2] = normal[i][2];

				MeshData::CROSS(d[1], d[0], d[2]);
				float len = (float)MeshData::LENGTH(d[1]);
				d[1][0] /= len;
				d[1][1] /= len;
				d[1][2] /= len;

				MeshData::CROSS(d[2], d[0], d[1]);

				sphere2(r, vertex[i], d, 5);
				/*
				float v1[3];
				v1[0] = vertex[i][0] + 0.1f*ravine_dir[i][0];
				v1[1] = vertex[i][1] + 0.1f*ravine_dir[i][1];
				v1[2] = vertex[i][2] + 0.1f*ravine_dir[i][2];

				float v2[3];
				v2[0] = vertex[i][0] - 0.1f*ravine_dir[i][0];
				v2[1] = vertex[i][1] - 0.1f*ravine_dir[i][1];
				v2[2] = vertex[i][2] - 0.1f*ravine_dir[i][2];

				glBegin(GL_LINES);
					glVertex3fv(v1);
					glVertex3fv(v2);
				glEnd();
				*/
			}
		}
	}
	glEnd();

	float d1 = (float)(0.05*view_angle/22.5);
	if(!transparent){
		glEnable(GL_LIGHTING);
		int face_N = mesh->face_N;
		int (*face)[3] = mesh->face;

		/*
		if(gray_scale)
			glColor3f(0.7f, 0.7f, 0.7f);
		else
			glColor3f(0.9f,0.9f,0.9f);
			*/
		
		for(i=0; i<face_N; i++){
			float p1[3], p2[3], p3[3];

			int i1 = face[i][0];
			int i2 = face[i][1];
			int i3 = face[i][2];

			p1[0] = vertex[i1][0] - d1*normal[i1][0];
			p1[1] = vertex[i1][1] - d1*normal[i1][1];
			p1[2] = vertex[i1][2] - d1*normal[i1][2];

			p2[0] = vertex[i2][0] - d1*normal[i2][0];
			p2[1] = vertex[i2][1] - d1*normal[i2][1];
			p2[2] = vertex[i2][2] - d1*normal[i2][2];

			p3[0] = vertex[i3][0] - d1*normal[i3][0];
			p3[1] = vertex[i3][1] - d1*normal[i3][1];
			p3[2] = vertex[i3][2] - d1*normal[i3][2];

			glBegin(GL_POLYGON);
				glNormal3fv(mesh->normal_f[i]);
				//glNormal3fv(normal[i1]);
				glVertex3fv(p1);
				//glNormal3fv(normal[i2]);
				glVertex3fv(p2);
				//glNormal3fv(normal[i3]);
				glVertex3fv(p3);
			glEnd();
		}
	}

	glEnable(GL_LIGHTING);
	//glEndList();

	//wglMakeCurrent(clientDC.m_hDC, NULL);

	//CClientDC* dc = new CClientDC(this); 
	//OnDraw(dc);
	//delete dc;
}

void CMeshEditorView::drawPrincipalDir(MeshData *mesh, BOOL max, BOOL min, BOOL transparent, BOOL gray_scale)
{
	//CClientDC clientDC(this);
	//wglMakeCurrent(clientDC.m_hDC, m_hRC);

	//glDeleteLists(1,1);
	//glNewList(1, GL_COMPILE);
	glShadeModel(GL_SMOOTH);

	glDisable(GL_LIGHTING);

	int vertex_N = mesh->vertex_N;

	float (*vertex)[3] = mesh->vertex;
	double (*t_max)[3] = mesh->t_max;
	double (*t_min)[3] = mesh->t_min;
	double* k_max = mesh->k_max;
	double* k_min = mesh->k_min;

	float len = 0.2f;

	if(max){
		if(gray_scale)
			glColor3f(0,0,0);
		else
			glColor3f(1,0,0);
		for(int i=0; i<vertex_N; i++){
			float l = len*sqrt(fabs(k_max[i]));

			float v1[3];
			v1[0] = vertex[i][0] + l*(float)t_max[i][0];
			v1[1] = vertex[i][1] + l*(float)t_max[i][1];
			v1[2] = vertex[i][2] + l*(float)t_max[i][2];

			float v2[3];
			v2[0] = vertex[i][0] - l*(float)t_max[i][0];
			v2[1] = vertex[i][1] - l*(float)t_max[i][1];
			v2[2] = vertex[i][2] - l*(float)t_max[i][2];

			glBegin(GL_LINES);
				glVertex3fv(v1);
				glVertex3fv(v2);
			glEnd();
		}
	}

	if(min){
		if(gray_scale)
			glColor3f(1,1,1);
		else
			glColor3f(0,0,1);
		for(int i=0; i<vertex_N; i++){
			float l = len*sqrt(fabs(k_min[i]));

			float v1[3];
			v1[0] = vertex[i][0] + l*(float)t_min[i][0];
			v1[1] = vertex[i][1] + l*(float)t_min[i][1];
			v1[2] = vertex[i][2] + l*(float)t_min[i][2];

			float v2[3];
			v2[0] = vertex[i][0] - l*(float)t_min[i][0];
			v2[1] = vertex[i][1] - l*(float)t_min[i][1];
			v2[2] = vertex[i][2] - l*(float)t_min[i][2];

			glBegin(GL_LINES);
				glVertex3fv(v1);
				glVertex3fv(v2);
			glEnd();
		}
	}

	if(!transparent){
		int face_N = mesh->face_N;
		int (*face)[3] = mesh->face;
		float (*normal)[3] = mesh->normal;

		if(gray_scale)
			glColor3f(0.85f, 0.85f, 0.85f);
		else
			glColor3f(0.9f,0.9f,0.9f);

		for(int i=0; i<face_N; i++){
			float p1[3], p2[3], p3[3];

			int i1 = face[i][0];
			int i2 = face[i][1];
			int i3 = face[i][2];

			p1[0] = vertex[i1][0] - 0.05f*normal[i1][0];
			p1[1] = vertex[i1][1] - 0.05f*normal[i1][1];
			p1[2] = vertex[i1][2] - 0.05f*normal[i1][2];

			p2[0] = vertex[i2][0] - 0.05f*normal[i2][0];
			p2[1] = vertex[i2][1] - 0.05f*normal[i2][1];
			p2[2] = vertex[i2][2] - 0.05f*normal[i2][2];

			p3[0] = vertex[i3][0] - 0.05f*normal[i3][0];
			p3[1] = vertex[i3][1] - 0.05f*normal[i3][1];
			p3[2] = vertex[i3][2] - 0.05f*normal[i3][2];

			glBegin(GL_POLYGON);
				glVertex3fv(p1);
				glVertex3fv(p2);
				glVertex3fv(p3);
			glEnd();
		}
	}

	glEnable(GL_LIGHTING);
	//glEndList();

	//wglMakeCurrent(clientDC.m_hDC, NULL);

	//CClientDC* dc = new CClientDC(this); 
	//OnDraw(dc);
	//delete dc;
}

void CMeshEditorView::drawRidgeEdge(MeshData *mesh, BOOL transparent, BOOL grey_scale)
{
	//CClientDC clientDC(this);
	//wglMakeCurrent(clientDC.m_hDC, m_hRC);

	//glDeleteLists(1,1);
	//glNewList(1, GL_COMPILE);
	glShadeModel(GL_SMOOTH);

	glDisable(GL_LIGHTING);

	int vertex_N = mesh->vertex_N;

	float (*vertex)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	int face_N = mesh->face_N;

	BOOL *isRidge = mesh->isRidge;
	BOOL *isRavine = mesh->isRavine;

	if(grey_scale)
		glColor3f(0,0,0);
	else
		glColor3f(1,0,0);
	for(int i=0; i<face_N; i++){
		for(int j=0; j<3; j++){
			int i1 = face[i][j];
			int i2 = face[i][(j+1)%3];
			if(i1 > i2 && isRidge[i1] && isRidge[i2]){
				glBegin(GL_LINES);
					glVertex3fv(vertex[i1]);
					glVertex3fv(vertex[i2]);
				glEnd();
			}
		}
	}

	if(grey_scale)
		glColor3f(1,1,1);
	else
		glColor3f(0,0,1);
	for(i=0; i<face_N; i++){
		for(int j=0; j<3; j++){
			int i1 = face[i][j];
			int i2 = face[i][(j+1)%3];
			if(i1 > i2 && isRavine[i1] && isRavine[i2]){
				glBegin(GL_LINES);
					glVertex3fv(vertex[i1]);
					glVertex3fv(vertex[i2]);
				glEnd();
			}
		}
	}

	
	if(!transparent){
		glEnable(GL_LIGHTING);
		int face_N = mesh->face_N;
		int (*face)[3] = mesh->face;

		float (*normal)[3] = mesh->normal;

		/*
		if(gray_scale)
			glColor3f(0.7f, 0.7f, 0.7f);
		else
			glColor3f(0.9f,0.9f,0.9f);
		*/
		for(i=0; i<face_N; i++){
			float p1[3], p2[3], p3[3];

			int i1 = face[i][0];
			int i2 = face[i][1];
			int i3 = face[i][2];

			p1[0] = vertex[i1][0] - 0.05f*normal[i1][0];
			p1[1] = vertex[i1][1] - 0.05f*normal[i1][1];
			p1[2] = vertex[i1][2] - 0.05f*normal[i1][2];

			p2[0] = vertex[i2][0] - 0.05f*normal[i2][0];
			p2[1] = vertex[i2][1] - 0.05f*normal[i2][1];
			p2[2] = vertex[i2][2] - 0.05f*normal[i2][2];

			p3[0] = vertex[i3][0] - 0.05f*normal[i3][0];
			p3[1] = vertex[i3][1] - 0.05f*normal[i3][1];
			p3[2] = vertex[i3][2] - 0.05f*normal[i3][2];

			glBegin(GL_POLYGON);
				glNormal3fv(mesh->normal_f[i]);
				//glNormal3fv(normal[i1]);
				glVertex3fv(p1);
				//glNormal3fv(normal[i2]);
				glVertex3fv(p2);
				//glNormal3fv(normal[i3]);
				glVertex3fv(p3);
			glEnd();
		}
		
		/*
		if(grey_scale)
			glColor3f(0.7f, 0.7f, 0.7f);
		else
			glColor3f(0.9f,0.9f,0.9f);

		for(int i=0; i<face_N; i++){
			float p1[3], p2[3], p3[3];

			int i1 = face[i][0];
			int i2 = face[i][1];
			int i3 = face[i][2];

			p1[0] = vertex[i1][0] - 0.05f*normal[i1][0];
			p1[1] = vertex[i1][1] - 0.05f*normal[i1][1];
			p1[2] = vertex[i1][2] - 0.05f*normal[i1][2];

			p2[0] = vertex[i2][0] - 0.05f*normal[i2][0];
			p2[1] = vertex[i2][1] - 0.05f*normal[i2][1];
			p2[2] = vertex[i2][2] - 0.05f*normal[i2][2];

			p3[0] = vertex[i3][0] - 0.05f*normal[i3][0];
			p3[1] = vertex[i3][1] - 0.05f*normal[i3][1];
			p3[2] = vertex[i3][2] - 0.05f*normal[i3][2];

			glBegin(GL_POLYGON);
				glVertex3fv(p1);
				glVertex3fv(p2);
				glVertex3fv(p3);
			glEnd();
		}*/
	}

	glEnable(GL_LIGHTING);
	//glEndList();

	//wglMakeCurrent(clientDC.m_hDC, NULL);

	//CClientDC* dc = new CClientDC(this); 
	//OnDraw(dc);
	//delete dc;
}

void CMeshEditorView::drawColoredVertex(MeshData *mesh, float (*v)[3], BOOL gray)
{
	float (*vertex)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	int face_N = mesh->face_N;
	int vertex_N = mesh->vertex_N;

	float (*color)[3] = new float[vertex_N][3];
	if(gray)
		convertToColorG(vertex_N, v, color);
	else
		convertToColor(vertex_N, v, color);

	//CClientDC clientDC(this);
	//wglMakeCurrent(clientDC.m_hDC, m_hRC);

	//glDeleteLists(1,1);
	//glNewList(1, GL_COMPILE);
	glShadeModel(GL_SMOOTH);
	glDisable(GL_LIGHTING);
	
	for(int i=0; i<face_N; i++){

		glBegin(GL_POLYGON);
			glColor3fv(color[ face[i][0] ]);
			glVertex3fv(vertex[ face[i][0] ]);

			glColor3fv(color[ face[i][1] ]);
			glVertex3fv(vertex[ face[i][1] ]);

			glColor3fv(color[ face[i][2] ]);
			glVertex3fv(vertex[ face[i][2] ]);	
		glEnd();
	} 
	glEnable(GL_LIGHTING);
	//glEndList();

	//wglMakeCurrent(clientDC.m_hDC, NULL);

	//CClientDC* dc = new CClientDC(this); 
	//OnDraw(dc);
	//delete dc;

	delete[] color;
}

void CMeshEditorView::convertToColor(int n, float (*v)[3], float (*color)[3])
{
	float *len = new float[n];

	for(int i=0; i<n; i++)
		len[i] = v[i][0]; //MeshData::LENGTH(v[i]);

	float mid, vari;
	float S = 0;
	for(i=0; i<n; i++)
		S += len[i];
	mid = S/(float)n;

	S = 0;
	for(i = 0; i<n; i++)
		S += (len[i]-mid)*(len[i]-mid);
	vari = (float)sqrt(S/(float)n);

	for(i = 0; i<n; i++){
		float s = (len[i]-mid)/vari*1.5f;
		if(s < -2.1f){
			color[i][0] = 0;
			color[i][1] = 0;
			color[i][2] = 0;
		}
		else if(s < -1.5f){
			color[i][0] = 0;
			color[i][1] = 0;
			color[i][2] = (s + 2.1f)/0.6f;
		}
		else if(s < -0.9f){
			color[i][0] = 0;
			color[i][1] = (s + 1.5f)/0.6f;
			color[i][2] = 1;
		}
		else if(s < -0.3f){
			color[i][0] = 0;
			color[i][1] = 1;
			color[i][2] = -(s + 0.3f)/0.6f;
		}
		else if(s < 0.3f){
			color[i][0] = (s + 0.3f)/0.6f;
			color[i][1] = 1;
			color[i][2] = 0;
		}
		else if(s < 0.9f){
			color[i][0] = 1;
			color[i][1] = -(s - 0.9f)/0.6f;
			color[i][2] = 0;
		}
		else if(s < 1.5f){
			color[i][0] = 1;
			color[i][1] = 0;
			color[i][2] = (s - 0.9f)/0.6f;
		}
		else if(s < 2.1f){
			color[i][0] = 1;
			color[i][1] = (s - 1.5f)/0.8f;
			color[i][2] = 1;
		}
		else{
			color[i][0] = 1;
			color[i][1] = 0.75;
			color[i][2] = 1;
		}
	}

	delete[] len;
}

void CMeshEditorView::drawRidgePath(MeshData *mesh, 
									Node ***normal_path, int *normal_path_N, 
									Node ***ridge_path, int *ridge_path_N, 
									Node ***ravine_path, int *ravine_path_N, 
									BOOL grey_scale)
{
	//CClientDC clientDC(this);
	//wglMakeCurrent(clientDC.m_hDC, m_hRC);

	//glDeleteLists(1,1);
	//glNewList(1, GL_COMPILE);
	glShadeModel(GL_SMOOTH);

	glDisable(GL_LIGHTING);

	int vertex_N = mesh->vertex_N;

	float (*vertex)[3] = mesh->vertex;
	float (*normal)[3] = mesh->normal;
	
	if(grey_scale)
		glColor3f(0,0,0);
	else
		glColor3f(1,0,0);
	for(int i=0; i<vertex_N; i++){
		for(int j=0; j<ridge_path_N[i]; j++){
			if(ridge_path[i][j]->v > i)
				continue;
			//sphere(0.15f, vertex[ridge_path[i][j]->v], 6);
			for(Node* current=ridge_path[i][j]; current->next!=NULL && current->v != i; current=current->next){
				glBegin(GL_LINES);
					glVertex3f(vertex[current->v][0] + 0.02f*normal[current->v][0],
								vertex[current->v][1] + 0.02f*normal[current->v][1],
								vertex[current->v][2] + 0.02f*normal[current->v][2]);
					glVertex3f(vertex[current->next->v][0] + 0.02f*normal[current->next->v][0],
								vertex[current->next->v][1] + 0.02f*normal[current->next->v][1],
								vertex[current->next->v][2] + 0.02f*normal[current->next->v][2]);
				glEnd();
			}
			//sphere(0.15f, vertex[i], 6);
		}
	}

	if(grey_scale)
		glColor3f(1,1,1);
	else
		glColor3f(0,0,1);
	for(i=0; i<vertex_N; i++){
		for(int j=0; j<ravine_path_N[i]; j++){
			if(ravine_path[i][j]->v > i)
				continue;
			//sphere(0.15f, vertex[ravine_path[i][j]->v], 6);
			for(Node* current=ravine_path[i][j]; current->next!=NULL && current->v != i; current=current->next){
				glBegin(GL_LINES);
					glVertex3fv(vertex[current->v]);
					glVertex3fv(vertex[current->next->v]);
				glEnd();
			}
			//sphere(0.15f, vertex[i], 6);
		}
	}

	if(grey_scale)
		glColor3f(0.5,0.5,0.5);
	else
		glColor3f(0,1,0);
	for(i=0; i<vertex_N; i++){
		for(int j=0; j<normal_path_N[i]; j++){
			if(normal_path[i][j]->v > i || normal_path[i][j]->next == NULL)
				continue;
			//sphere(0.1f, vertex[normal_path[i][j]->v], 6);
				//glBegin(GL_LINES);
					//glVertex3fv(vertex[normal_path[i][j]->v]);
					//glVertex3fv(vertex[i]);
				//glEnd();
			
			for(Node* current=normal_path[i][j]; current->v != i; current=current->next){
				glBegin(GL_LINES);
					glVertex3fv(vertex[current->v]);
					glVertex3fv(vertex[current->next->v]);
				glEnd();
			}
			
			//sphere(0.1f, vertex[i], 6);
		}
	}

	if(true){
		int face_N = mesh->face_N;
		int (*face)[3] = mesh->face;

		if(grey_scale)
			glColor3f(0.7f, 0.7f, 0.7f);
		else
			glColor3f(0.9f,0.9f,0.9f);

		for(int i=0; i<face_N; i++){
			float p1[3], p2[3], p3[3];

			int i1 = face[i][0];
			int i2 = face[i][1];
			int i3 = face[i][2];

			p1[0] = vertex[i1][0] - 0.05f*normal[i1][0];
			p1[1] = vertex[i1][1] - 0.05f*normal[i1][1];
			p1[2] = vertex[i1][2] - 0.05f*normal[i1][2];

			p2[0] = vertex[i2][0] - 0.05f*normal[i2][0];
			p2[1] = vertex[i2][1] - 0.05f*normal[i2][1];
			p2[2] = vertex[i2][2] - 0.05f*normal[i2][2];

			p3[0] = vertex[i3][0] - 0.05f*normal[i3][0];
			p3[1] = vertex[i3][1] - 0.05f*normal[i3][1];
			p3[2] = vertex[i3][2] - 0.05f*normal[i3][2];

			glBegin(GL_POLYGON);
				glVertex3fv(p1);
				glVertex3fv(p2);
				glVertex3fv(p3);
			glEnd();
		}
	}

	glEnable(GL_LIGHTING);
	//glEndList();

	//wglMakeCurrent(clientDC.m_hDC, NULL);

	//CClientDC* dc = new CClientDC(this); 
	//OnDraw(dc);
	//delete dc;
}

void CMeshEditorView::sphere(float r, float p[], int n)
{
	float (**vertex)[3] = (float(**)[3])new float[n];
	float (**normal)[3] = (float(**)[3])new float[n];
	for(int i=0; i<n; i++){
		vertex[i] = (float (*)[3])new float[n][3];
		normal[i] = (float (*)[3])new float[n][3];
	}

	for(i=0; i<n; i++){
		float u = (float)(PI*i/(n-1) - 0.5f*PI);
		for(int j=0; j<n; j++){
			float v = (float)(2*PI*j/(n-1));
			normal[i][j][0] = (float)(cos(v)*cos(u));
			normal[i][j][1] = (float)(sin(v)*cos(u));
			normal[i][j][2] = (float)sin(u);

			vertex[i][j][0] = (float)(r*normal[i][j][0] + p[0]);
			vertex[i][j][1] = (float)(r*normal[i][j][1] + p[1]);
			vertex[i][j][2] = (float)(r*normal[i][j][2] + p[2]);
		}
	}

	for(i=0; i<n-1; i++){
		for(int j=0; j<n-1; j++){
			glBegin(GL_POLYGON);

				glNormal3fv(normal[i][j]);
				glVertex3fv(vertex[i][j]);

				glNormal3fv(normal[i][j+1]);
				glVertex3fv(vertex[i][j+1]);

				glNormal3fv(normal[i+1][j+1]);
				glVertex3fv(vertex[i+1][j+1]);

				glNormal3fv(normal[i+1][j]);
				glVertex3fv(vertex[i+1][j]);

			glEnd();
		}
	}

	for(i=0; i<n; i++){
		delete[] vertex[i];
		delete[] normal[i];
	}
	delete[] vertex;
	delete[] normal;
}

void CMeshEditorView::drawTagEdges(MeshData *mesh, Node **ridge_pair, Node **ravine_pair, 
								   BOOL transparent, BOOL grey_scale, BOOL shaded)
{
	//CClientDC clientDC(this);
	//wglMakeCurrent(clientDC.m_hDC, m_hRC);

	//glDeleteLists(1,1);
	//glNewList(1, GL_COMPILE);
	glShadeModel(GL_SMOOTH);

	glDisable(GL_LIGHTING);

	int vertex_N = mesh->vertex_N;

	float (*vertex)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	int face_N = mesh->face_N;

	mesh->computeFaceNormal();
	mesh->computeNormal();
	float (*normal)[3] = mesh->normal;

	int i;

	if(grey_scale)
		glColor3f(1,1,1);
	else
		glColor3f(1,0,0);
	//glLineWidth(3.0);
	for(i=0; i<vertex_N; i++)
		for(Node* current = ridge_pair[i]; current->next != NULL; current = current->next){
			if(current->v > i){
				//cylinder(vertex[i], vertex[current->v], normal[i], normal[current->v], 0.025, 7);
				
				glBegin(GL_LINES);
					glVertex3fv(vertex[i]);
					glVertex3fv(vertex[current->v]);
				glEnd();
				
			}
		}
	
	if(grey_scale)
		glColor3f(0,0,0);
	else
		glColor3f(0,0,1);
	
	//glLineWidth(3.0);
	for(i=0; i<vertex_N; i++)
		for(Node* current = ravine_pair[i]; current->next != NULL; current = current->next){
			if(current->v > i){
				//cylinder(vertex[i], vertex[current->v], normal[i], normal[current->v], 0.025, 7);
				glBegin(GL_LINES);
					glVertex3fv(vertex[i]);
					glVertex3fv(vertex[current->v]);
				glEnd();
				
			}
		}

	float d = (float)(0.05*view_angle/22.5);
	if(!transparent && shaded){
		glEnable(GL_LIGHTING);
		int face_N = mesh->face_N;
		int (*face)[3] = mesh->face;

		//if(gray_scale)
			//glColor3f(0.7f, 0.7f, 0.7f);
		//else
			//glColor3f(0.9f,0.9f,0.9f);
		
		for(i=0; i<face_N; i++){
			float p1[3], p2[3], p3[3];

			int i1 = face[i][0];
			int i2 = face[i][1];
			int i3 = face[i][2];

			p1[0] = vertex[i1][0] - d*normal[i1][0];
			p1[1] = vertex[i1][1] - d*normal[i1][1];
			p1[2] = vertex[i1][2] - d*normal[i1][2];

			p2[0] = vertex[i2][0] - d*normal[i2][0];
			p2[1] = vertex[i2][1] - d*normal[i2][1];
			p2[2] = vertex[i2][2] - d*normal[i2][2];

			p3[0] = vertex[i3][0] - d*normal[i3][0];
			p3[1] = vertex[i3][1] - d*normal[i3][1];
			p3[2] = vertex[i3][2] - d*normal[i3][2];

			glBegin(GL_POLYGON);
				glNormal3fv(mesh->normal_f[i]);
				//glNormal3fv(normal[i1]);
				glVertex3fv(p1);
				//glNormal3fv(normal[i2]);
				glVertex3fv(p2);
				//glNormal3fv(normal[i3]);
				glVertex3fv(p3);
			glEnd();
		}
	}
	else if(!transparent && !shaded){
		if(grey_scale)
			glColor3f(0.7f, 0.7f, 0.7f);
		else
			glColor3f(0.9f,0.9f,0.9f);

		for(int i=0; i<face_N; i++){
			if(face[i][0] < 0)
				continue;

			float p1[3], p2[3], p3[3];

			int i1 = face[i][0];
			int i2 = face[i][1];
			int i3 = face[i][2];

			p1[0] = vertex[i1][0] - d*normal[i1][0];
			p1[1] = vertex[i1][1] - d*normal[i1][1];
			p1[2] = vertex[i1][2] - d*normal[i1][2];

			p2[0] = vertex[i2][0] - d*normal[i2][0];
			p2[1] = vertex[i2][1] - d*normal[i2][1];
			p2[2] = vertex[i2][2] - d*normal[i2][2];

			p3[0] = vertex[i3][0] - d*normal[i3][0];
			p3[1] = vertex[i3][1] - d*normal[i3][1];
			p3[2] = vertex[i3][2] - d*normal[i3][2];

			glBegin(GL_POLYGON);
				glVertex3fv(p1);
				glVertex3fv(p2);
				glVertex3fv(p3);
			glEnd();
		}
		glEnable(GL_LIGHTING);
	}

	//glEndList();

	//wglMakeCurrent(clientDC.m_hDC, NULL);

	//CClientDC* dc = new CClientDC(this); 
	//OnDraw(dc);
	//delete dc;
}

void CMeshEditorView::wireFrame(MeshData *mesh)
{
		int vertex_N = mesh->vertex_N;
	int face_N = mesh->face_N;
	int (*face)[3] = mesh->face;
	float (*normal_f)[3] = mesh->normal_f;
	float (*normal)[3] = mesh->normal;
	float (*vertex)[3] = mesh->vertex;

	//glNewList(1, GL_COMPILE);
	glShadeModel(GL_SMOOTH);
	glDisable(GL_LIGHTING);
		
	//glColor3f(0.4f, 0.2f, 0.2f);
	glColor3f(0.0f, 0.0f, 0.0f);
	for(int i=0; i<face_N; i++){
		if(face[i][0] < 0)
			continue;

		if(face[i][0] > face[i][1]){
			glBegin(GL_LINES);
				glVertex3fv(vertex[face[i][0]]);
				glVertex3fv(vertex[face[i][1]]);
			glEnd();
		}
	
		if(face[i][1] > face[i][2]){
			glBegin(GL_LINES);
				glVertex3fv(vertex[face[i][1]]);
				glVertex3fv(vertex[face[i][2]]);
			glEnd();
		}

		if(face[i][2] > face[i][0]){
			glBegin(GL_LINES);
				glVertex3fv(vertex[face[i][2]]);
				glVertex3fv(vertex[face[i][0]]);
			glEnd();
		}
	}
	glEnable(GL_LIGHTING);
	//glColor3f(1.0f, 1.0f, 1.0f);
	float d = (float)(0.05*view_angle/22.5);
		/*0.05*sqrt((eye[0] - shift_x)*(eye[0] - shift_x) 
		            + (eye[1] - shift_y)*(eye[1] - shift_y) 
					+ (eye[2] - shift_z)*(eye[2] - shift_z))/sqrt(eye[0]*eye[0] + eye[1]*eye[1] + eye[2]*eye[2]);*/
	for(i=0; i<face_N; i++){
		if(face[i][0] < 0)
			continue;
	
		float p1[3], p2[3], p3[3];

		p1[0] = vertex[face[i][0]][0] - d*normal[face[i][0]][0];
		p1[1] = vertex[face[i][0]][1] - d*normal[face[i][0]][1];
		p1[2] = vertex[face[i][0]][2] - d*normal[face[i][0]][2];

		p2[0] = vertex[face[i][1]][0] - d*normal[face[i][1]][0];
		p2[1] = vertex[face[i][1]][1] - d*normal[face[i][1]][1];
		p2[2] = vertex[face[i][1]][2] - d*normal[face[i][1]][2];

		p3[0] = vertex[face[i][2]][0] - d*normal[face[i][2]][0];
		p3[1] = vertex[face[i][2]][1] - d*normal[face[i][2]][1];
		p3[2] = vertex[face[i][2]][2] - d*normal[face[i][2]][2];

		glBegin(GL_POLYGON);
			glNormal3fv(normal_f[i]);
			glVertex3fv(p1);
			glVertex3fv(p2);
			glVertex3fv(p3);
		glEnd();
	}

	/*
	glPointSize(10);
	glColor3f(1.0f, 0.0f, 0.0f);
	glBegin(GL_POINTS);
	for(i=0; i<vertex_N; i++)
		if(mesh->isFixed[i])
			glVertex3fv(vertex[i]);
	glEnd();
	*/

	//glEnable(GL_LIGHTING);

	/*
	//CClientDC clientDC(this);
	//wglMakeCurrent(clientDC.m_hDC, m_hRC);

	int face_N = mesh->face_N;
	int (*face)[3] = mesh->face;
	float (*normal_f)[3] = mesh->normal_f;
	float (*normal)[3] = mesh->normal;
	float (*vertex)[3] = mesh->vertex;

	//glDeleteLists(1,1);
	//glNewList(1, GL_COMPILE);
	glShadeModel(GL_SMOOTH);
	glDisable(GL_LIGHTING);
		
	glColor3f(0.0f, 0.0f, 0.0f);
	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	for(int i=0; i<face_N; i++){
		if(face[i][0] < 0)
			continue;
		glBegin(GL_POLYGON);
			glVertex3fv(vertex[face[i][0]]);
			glVertex3fv(vertex[face[i][1]]);
			glVertex3fv(vertex[face[i][2]]);
		glEnd();
	}
	
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	glColor3f(1.0f, 1.0f, 1.0f);
	if(normal != NULL){
	for(i=0; i<face_N; i++){
		if(face[i][0] < 0)
			continue;
		glBegin(GL_POLYGON);
			//glNormal3fv(normal_f[i]);
			float v[3];
			v[0] = vertex[face[i][0]][0] - 0.02f*normal[face[i][0]][0];
			v[1] = vertex[face[i][0]][1] - 0.02f*normal[face[i][0]][1];
			v[2] = vertex[face[i][0]][2] - 0.02f*normal[face[i][0]][2];
			glVertex3fv(v);

			v[0] = vertex[face[i][1]][0] - 0.02f*normal[face[i][1]][0];
			v[1] = vertex[face[i][1]][1] - 0.02f*normal[face[i][1]][1];
			v[2] = vertex[face[i][1]][2] - 0.02f*normal[face[i][1]][2];
			glVertex3fv(v);

			v[0] = vertex[face[i][2]][0] - 0.02f*normal[face[i][2]][0];
			v[1] = vertex[face[i][2]][1] - 0.02f*normal[face[i][2]][1];
			v[2] = vertex[face[i][2]][2] - 0.02f*normal[face[i][2]][2];
			glVertex3fv(v);
		glEnd();
	}
	}
	glEnable(GL_LIGHTING);
	//glEndList();

	//wglMakeCurrent(clientDC.m_hDC, NULL);

	//CClientDC* dc = new CClientDC(this); 
	//OnDraw(dc);
	//delete dc;*/
}

void CMeshEditorView::drawVertexCluster(MeshData *mesh, Node **cluster, BOOL gray_scale)
{
	//CClientDC clientDC(this);
	//wglMakeCurrent(clientDC.m_hDC, m_hRC);

	//glDeleteLists(1,1);
	//glNewList(1, GL_COMPILE);
	glShadeModel(GL_SMOOTH);

	glDisable(GL_LIGHTING);

	int vertex_N = mesh->vertex_N;
	float (*vertex)[3] = mesh->vertex;

	int face_N = mesh->face_N;
	int (*face)[3] = mesh->face;

	float (*normal)[3] = mesh->normal;

	float (*color)[3] = new float[vertex_N][3];
	int *id = new int[vertex_N];
	BOOL *valid = new BOOL[vertex_N];
	
	int cluster_id = 0;
	for(int i=0; i<vertex_N; i++){
		valid[i] = false;
		for(Node* current=cluster[i]; current->next!=NULL; current=current->next){
			valid[i] = true;
			id[current->v] = cluster_id;
		}
		if(valid[i])
			cluster_id++;
	}

	if(gray_scale){
		int gray_level = 0;
		for(int i=0; i<vertex_N; i++){
			for(Node* current=cluster[i]; current->next!=NULL; current=current->next){
				int v = current->v;
				color[v][0] = 0.0125f*gray_level+0.7f;
				color[v][1] = 0.0125f*gray_level+0.7f;
				color[v][2] = 0.0125f*gray_level+0.7f;
			}
			if(valid[i])
				gray_level = (gray_level+3)%20;
		}
	}
	else{
		int C[3] = {1,0,0};
		int index = 0;
		for(int i=0; i<vertex_N; i++){
			for(Node* current=cluster[i]; current->next!=NULL; current=current->next){
				int v = current->v;
				color[v][0] = 0.1f*C[0];
				color[v][1] = 0.1f*C[1];
				color[v][2] = 0.1f*C[2];
			}
			if(valid[i]){
				C[index] = (C[index]+2)%11;
				index = (index+1)%3;
			}
		}
	}

	glBegin(GL_POINTS);
	for(i=0; i<vertex_N; i++)
		if(valid[i]){
			//glColor3fv(color[i]);
			glColor3f(0,0,0);
			glVertex3fv(vertex[i]);
			//sphere(0.1f, vertex[i], 6);
		}
	glEnd();

	for(i=0; i<face_N; i++){
		if(face[i][0] < 0)
			continue;

		if(id[face[i][0]] == id[face[i][1]] && id[face[i][0]] == id[face[i][2]]){
			glBegin(GL_POLYGON);
				glColor3fv(color[face[i][0]]);
				glVertex3fv(vertex[face[i][0]]);
				glVertex3fv(vertex[face[i][1]]);
				glVertex3fv(vertex[face[i][2]]);
			glEnd();
		}
		else{
			float v1[3], v2[3], n[3];
			MeshData::VEC(v1, vertex[face[i][0]], vertex[face[i][1]]);
			MeshData::VEC(v2, vertex[face[i][0]], vertex[face[i][2]]);
			MeshData::CROSS(n, v1, v2);
			float len = (float)MeshData::LENGTH(n);
			n[0] /= len;
			n[1] /= len;
			n[2] /= len;

			float cf[3];
			cf[0] = (vertex[face[i][0]][0] + vertex[face[i][1]][0] + vertex[face[i][2]][0])/3.0f;
			cf[1] = (vertex[face[i][0]][1] + vertex[face[i][1]][1] + vertex[face[i][2]][1])/3.0f;
			cf[2] = (vertex[face[i][0]][2] + vertex[face[i][1]][2] + vertex[face[i][2]][2])/3.0f;

			float ce[3][3];
			for(int j=0; j<3; j++){
				ce[j][0] = 0.5f*(vertex[face[i][j]][0] + vertex[face[i][(j+1)%3]][0]);
				ce[j][1] = 0.5f*(vertex[face[i][j]][1] + vertex[face[i][(j+1)%3]][1]);
				ce[j][2] = 0.5f*(vertex[face[i][j]][2] + vertex[face[i][(j+1)%3]][2]);
			}

			for(j=0; j<3; j++){
				glBegin(GL_POLYGON);
					glColor3fv(color[face[i][j]]);
					glVertex3fv(vertex[face[i][j]]);
					glVertex3fv(ce[j]);
					glVertex3fv(cf);
					glVertex3fv(ce[(j+2)%3]);
				glEnd();

				if(id[face[i][j]] != id[face[i][(j+1)%3]]){
					float n1[3];
					n1[0] = normal[face[i][j]][0] + normal[face[i][(j+1)%3]][0];
					n1[1] = normal[face[i][j]][1] + normal[face[i][(j+1)%3]][1];
					n1[2] = normal[face[i][j]][2] + normal[face[i][(j+1)%3]][2];
					len = (float)MeshData::LENGTH(n1);
					n1[0] /= len;
					n1[1] /= len;
					n1[2] /= len;
					
					glBegin(GL_LINES);
						glColor3f(0,0,0);
						glVertex3f(ce[j][0] + 0.02f*n[0], 
								   ce[j][1] + 0.02f*n[1], 
								   ce[j][2] + 0.02f*n[2]);
						glVertex3f(cf[0] + 0.02f*n1[0], 
								   cf[1] + 0.02f*n1[1], 
								   cf[2] + 0.02f*n1[2]);
					glEnd();
				}
			}
		}
	}

	glEnable(GL_LIGHTING);
	//glEndList();

	//wglMakeCurrent(clientDC.m_hDC, NULL);

	//CClientDC* dc = new CClientDC(this); 
	//OnDraw(dc);
	//delete dc;
}

/*
void CMeshEditorView::line(float p1[], float p2[], float r, float n1[], float n2[])
{
	float d[3];
	MeshData::VEC(d, p1, p2);
	float len = MeshData::LENGTH(d);
	d[0] /= len;
	d[1] /= len;
	d[2] /= len;

	float w1[3];
	MeshData::CROSS(w1, d, n1);

	float w2[3];
	MeshData::CROSS(w2, d, n2);

	glBegin(GL_POLYGON);
		glVertex3f(p1[0] + r*w[0], p1[1] + r*w[1], p1[2] + r*w[2]);
		glVertex3f(p1[0] - r*w[0], p1[1] - r*w[1], p2[2] - r*w[2]);
		glVertex3f(p2[0] - r*w[0], p2[1] - r*w[1], p2[2] - r*w[2]);
		glVertex3f(p2[0] + r*w[0], p2[1] + r*w[1], p2[2] + r*w[2]);
	glEnd();
}*/

void CMeshEditorView::drawTensor(MeshData *mesh, BOOL max, BOOL min, BOOL transparent, BOOL gray_scale)
{
	//CClientDC clientDC(this);
	//wglMakeCurrent(clientDC.m_hDC, m_hRC);

	//glDeleteLists(1,1);
	//glNewList(1, GL_COMPILE);
	glShadeModel(GL_SMOOTH);

	glDisable(GL_LIGHTING);

	int vertex_N = mesh->vertex_N;

	float (*vertex)[3] = mesh->vertex;

	if(max){
		double *k_max = mesh->k_max;
		double (*t_max)[3] = mesh->t_max;

		float (*color)[3] = new float[vertex_N][3];
		float (*v)[3] = new float[vertex_N][3];
		for(int i=0; i<vertex_N; i++){
			v[i][0] = (float)k_max[i];
			v[i][1] = 0;
			v[i][2] = 0;
		}
		convertToColor(vertex_N, v, color);

		for(i=0; i<vertex_N; i++){
			float v1[3];
			v1[0] = vertex[i][0] + 0.1f*(float)t_max[i][0];
			v1[1] = vertex[i][1] + 0.1f*(float)t_max[i][1];
			v1[2] = vertex[i][2] + 0.1f*(float)t_max[i][2];

			float v2[3];
			v2[0] = vertex[i][0] - 0.1f*(float)t_max[i][0];
			v2[1] = vertex[i][1] - 0.1f*(float)t_max[i][1];
			v2[2] = vertex[i][2] - 0.1f*(float)t_max[i][2];

			glColor3fv(color[i]);
			glBegin(GL_LINES);
				glVertex3fv(v1);
				glVertex3fv(v2);
			glEnd();
		}
		delete[] color;
		delete[] v;
	}

	if(min){
		double *k_min = mesh->k_min;
		double (*t_min)[3] = mesh->t_min;

		float (*color)[3] = new float[vertex_N][3];
		float (*v)[3] = new float[vertex_N][3];
		for(int i=0; i<vertex_N; i++){
			v[i][0] = (float)k_min[i];
			v[i][1] = 0;
			v[i][2] = 0;
		}
		convertToColor(vertex_N, v, color);

		for(i=0; i<vertex_N; i++){
			float v1[3];
			v1[0] = vertex[i][0] + 0.1f*(float)t_min[i][0];
			v1[1] = vertex[i][1] + 0.1f*(float)t_min[i][1];
			v1[2] = vertex[i][2] + 0.1f*(float)t_min[i][2];

			float v2[3];
			v2[0] = vertex[i][0] - 0.1f*(float)t_min[i][0];
			v2[1] = vertex[i][1] - 0.1f*(float)t_min[i][1];
			v2[2] = vertex[i][2] - 0.1f*(float)t_min[i][2];

			glColor3fv(color[i]);
			glBegin(GL_LINES);
				glVertex3fv(v1);
				glVertex3fv(v2);
			glEnd();
		}
		delete[] color;
		delete[] v;
	}

	if(!transparent){
		int face_N = mesh->face_N;
		int (*face)[3] = mesh->face;
		float (*normal)[3] = mesh->normal;

		if(gray_scale)
			glColor3f(1.0f, 1.0f, 1.0f);
		else
			glColor3f(0.9f,0.9f,0.9f);

		for(int i=0; i<face_N; i++){
			float p1[3], p2[3], p3[3];

			int i1 = face[i][0];
			int i2 = face[i][1];
			int i3 = face[i][2];

			p1[0] = vertex[i1][0] - 0.2f*normal[i1][0];
			p1[1] = vertex[i1][1] - 0.2f*normal[i1][1];
			p1[2] = vertex[i1][2] - 0.2f*normal[i1][2];

			p2[0] = vertex[i2][0] - 0.2f*normal[i2][0];
			p2[1] = vertex[i2][1] - 0.2f*normal[i2][1];
			p2[2] = vertex[i2][2] - 0.2f*normal[i2][2];

			p3[0] = vertex[i3][0] - 0.2f*normal[i3][0];
			p3[1] = vertex[i3][1] - 0.2f*normal[i3][1];
			p3[2] = vertex[i3][2] - 0.2f*normal[i3][2];

			glBegin(GL_POLYGON);
				glVertex3fv(p1);
				glVertex3fv(p2);
				glVertex3fv(p3);
			glEnd();
		}
	}

	glEnable(GL_LIGHTING);
	//glEndList();

	//wglMakeCurrent(clientDC.m_hDC, NULL);

	//CClientDC* dc = new CClientDC(this); 
	//OnDraw(dc);
	//delete dc;
}

void CMeshEditorView::sphere2(float r[], float p[], float d[3][3], int n)
{
	float (**vertex)[3] = (float(**)[3])new float[n];
	float (**normal)[3] = (float(**)[3])new float[n];
	for(int i=0; i<n; i++){
		vertex[i] = (float (*)[3])new float[n][3];
		normal[i] = (float (*)[3])new float[n][3];
	}

	for(i=0; i<n; i++){
		float u = (float)(PI*i/(n-1) - 0.5f*PI);
		for(int j=0; j<n; j++){
			float v = (float)(2*PI*j/(n-1));
			float x = (float)(r[0]*cos(v)*cos(u));
			float y = (float)(r[1]*sin(v)*cos(u));
			float z = (float)(r[2]*sin(u));

			normal[i][j][0] = d[0][0]*x + d[1][0]*y + d[2][0]*z;
			normal[i][j][1] = d[0][1]*x + d[1][1]*y + d[2][1]*z;
			normal[i][j][2] = d[0][2]*x + d[1][2]*y + d[2][2]*z;

			vertex[i][j][0] = (float)(normal[i][j][0] + p[0]);
			vertex[i][j][1] = (float)(normal[i][j][1] + p[1]);
			vertex[i][j][2] = (float)(normal[i][j][2] + p[2]);
		}
	}

	for(i=0; i<n-1; i++){
		for(int j=0; j<n-1; j++){
			glBegin(GL_POLYGON);

				glNormal3fv(normal[i][j]);
				glVertex3fv(vertex[i][j]);

				glNormal3fv(normal[i][j+1]);
				glVertex3fv(vertex[i][j+1]);

				glNormal3fv(normal[i+1][j+1]);
				glVertex3fv(vertex[i+1][j+1]);

				glNormal3fv(normal[i+1][j]);
				glVertex3fv(vertex[i+1][j]);

			glEnd();
		}
	}

	for(i=0; i<n; i++){
		delete[] vertex[i];
		delete[] normal[i];
	}
	delete[] vertex;
	delete[] normal;
}

void CMeshEditorView::cylinder(float p1[], float p2[], float n1[], float n2[], float r, int n)
{
	float t[3];
	MeshData::VEC(t, p1, p2);
	float len = (float)MeshData::LENGTH(t);
	t[0] /= len;
	t[1] /= len;
	t[2] /= len;

	float b1[3];
	MeshData::CROSS(b1, t, n1);

	float b2[3];
	MeshData::CROSS(b2, t, n2);

	float (*p)[2] = new float[n][2];
	for(int i=0; i<n; i++){
		float u = (float)(2*PI*i/(n-1));
		p[i][0] = (float)(r*cos(u));
		p[i][1] = (float)(r*sin(u));
	}

	for(i=0; i<n-1; i++){
		float v[4][3];
		glBegin(GL_POLYGON);
			v[0][0] = p1[0] + p[i][0]*n1[0] + p[i][1]*b1[0];
			v[0][1] = p1[1] + p[i][0]*n1[1] + p[i][1]*b1[1];
			v[0][2] = p1[2] + p[i][0]*n1[2] + p[i][1]*b1[2];
			glVertex3fv(v[0]);

			v[1][0] = p1[0] + p[i+1][0]*n1[0] + p[i+1][1]*b1[0];
			v[1][1] = p1[1] + p[i+1][0]*n1[1] + p[i+1][1]*b1[1];
			v[1][2] = p1[2] + p[i+1][0]*n1[2] + p[i+1][1]*b1[2];
			glVertex3fv(v[1]);

			v[2][0] = p2[0] + p[i+1][0]*n2[0] + p[i+1][1]*b2[0];
			v[2][1] = p2[1] + p[i+1][0]*n2[1] + p[i+1][1]*b2[1];
			v[2][2] = p2[2] + p[i+1][0]*n2[2] + p[i+1][1]*b2[2];
			glVertex3fv(v[2]);

			v[3][0] = p2[0] + p[i][0]*n2[0] + p[i][1]*b2[0];
			v[3][1] = p2[1] + p[i][0]*n2[1] + p[i][1]*b2[1];
			v[3][2] = p2[2] + p[i][0]*n2[2] + p[i][1]*b2[2];
			glVertex3fv(v[3]);
		glEnd();
	}
	delete[] p;
}

void CMeshEditorView::setSize(float line, float point)
{
	CClientDC clientDC(this);
	wglMakeCurrent(clientDC.m_hDC, m_hRC);

	glLineWidth(line);
	glPointSize(point);

	wglMakeCurrent(clientDC.m_hDC, NULL);

	CClientDC* dc = new CClientDC(this); 
	OnDraw(dc);
	delete dc;
}

void CMeshEditorView::freeList()
{
	CClientDC clientDC(this);
	wglMakeCurrent(clientDC.m_hDC, m_hRC);

	glDeleteLists(1,1);
	
	wglMakeCurrent(clientDC.m_hDC, NULL);

	CClientDC* dc = new CClientDC(this); 
	OnDraw(dc);
	delete dc;
}

void CMeshEditorView::draw()
{
	CClientDC* dc = new CClientDC(this); 
	OnDraw(dc);
	delete dc;
}

void CMeshEditorView::drawNonManifold(MeshData *mesh)
{
	BOOL* isBound = mesh->isBound;
	float (*vertex)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	int (*link)[3] = mesh->face_link_E;
	int vertex_N = mesh->vertex_N;
	int face_N = mesh->face_N;
	float (*normal)[3] = mesh->normal;

	glShadeModel(GL_SMOOTH);

	glDisable(GL_LIGHTING);
	
	glColor3f(1.0f, 0.0f, 0.0f);
	glBegin(GL_POINTS);
	for(int i=0; i<vertex_N; i++)
		if(isBound[i] == NON_MANIFOLD)
			glVertex3fv(vertex[i]);
	glEnd();

	glColor3f(0.0f, 1.0f, 1.0f);
	glBegin(GL_POINTS);
	for(i=0; i<vertex_N; i++)
		if(isBound[i] == BOUNDARY)
			glVertex3fv(vertex[i]);
	glEnd();


	glColor3f(0.0f, 0.0f, 1.0f);
	for(i=0; i<face_N; i++){
		for(int j=0; j<3; j++){
			if(link[i][j] < 0){
				glBegin(GL_LINES);
					glVertex3fv(vertex[face[i][j]]);
					glVertex3fv(vertex[face[i][(j+1)%3]]);
				glEnd();
			}
		}
	}

	/*
	glColor3f(0.8f, 0.8f, 0.8f);
	if(normal != NULL){
	for(i=0; i<face_N; i++){
		if(face[i][0] < 0)
			continue;
		glBegin(GL_POLYGON);
			//glNormal3fv(normal_f[i]);
			float v[3];
			v[0] = vertex[face[i][0]][0] - 0.05f*normal[face[i][0]][0];
			v[1] = vertex[face[i][0]][1] - 0.05f*normal[face[i][0]][1];
			v[2] = vertex[face[i][0]][2] - 0.05f*normal[face[i][0]][2];
			glVertex3fv(v);

			v[0] = vertex[face[i][1]][0] - 0.05f*normal[face[i][1]][0];
			v[1] = vertex[face[i][1]][1] - 0.05f*normal[face[i][1]][1];
			v[2] = vertex[face[i][1]][2] - 0.05f*normal[face[i][1]][2];
			glVertex3fv(v);

			v[0] = vertex[face[i][2]][0] - 0.05f*normal[face[i][2]][0];
			v[1] = vertex[face[i][2]][1] - 0.05f*normal[face[i][2]][1];
			v[2] = vertex[face[i][2]][2] - 0.05f*normal[face[i][2]][2];
			glVertex3fv(v);
		glEnd();
	}
	}*/
	glEnable(GL_LIGHTING);

}

void CMeshEditorView::convertToEdgeColor(int n, double (*v)[3], float (*color)[3][3])
{
	double mid, vari;
	double S = 0;
	for(int i=0; i<n; i++)
		for(int j=0; j<3; j++) 
			S += v[i][j];
	mid = S/(double)(3*n);

	S = 0;
	for(i=0; i<n; i++)
		for(int j=0; j<3; j++) 
			S += (v[i][j]-mid)*(v[i][j]-mid);
	vari = sqrt(S/(double)(3*n));

	for(i = 0; i<n; i++){
		for(int j=0; j<3; j++){
			double s = 1.5*(v[i][j]-mid)/vari;
			if(s < -2.1){
				color[i][j][0] = 0;
				color[i][j][1] = 0;
				color[i][j][2] = 0;
			}
			else if(s < -1.5){
				color[i][j][0] = 0;
				color[i][j][1] = 0;
				color[i][j][2] = (float)((s + 2.1)/0.6);
			}
			else if(s < -0.9){
				color[i][j][0] = 0;
				color[i][j][1] = (float)((s + 1.5)/0.6);
				color[i][j][2] = 1;
			}
			else if(s < -0.3){
				color[i][j][0] = 0;
				color[i][j][1] = 1;
				color[i][j][2] = (float)(-(s + 0.3)/0.6);
			}
			else if(s < 0.3){
				color[i][j][0] = (float)((s + 0.3)/0.6);
				color[i][j][1] = 1;
				color[i][j][2] = 0;
			}
			else if(s < 0.9){
				color[i][j][0] = 1;
				color[i][j][1] = (float)(-(s - 0.9)/0.6);
				color[i][j][2] = 0;
			}
			else if(s < 1.5){
				color[i][j][0] = 1;
				color[i][j][1] = 0;
				color[i][j][2] = (float)((s - 0.9)/0.6);
			}
			else if(s < 2.1){
				color[i][j][0] = 1;
				color[i][j][1] = (float)((s - 1.5)/0.8);
				color[i][j][2] = 1;
			}
			else{
				color[i][j][0] = 1;
				color[i][j][1] = 0.75f;
				color[i][j][2] = 1;
			}
		}
	}
}

void CMeshEditorView::drawKEdge(MeshData *mesh)
{
	float (*vertex)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	int face_N = mesh->face_N;
	int vertex_N = mesh->vertex_N;
	float (*normal)[3] = mesh->normal;

	float (*color)[3][3] = new float[face_N][3][3];
	convertToEdgeColor(face_N, mesh->k_edge, color);

	glShadeModel(GL_SMOOTH);
	glDisable(GL_LIGHTING);
	
	for(int i=0; i<face_N; i++){
		for(int j=0; j<3; j++){
			if(face[i][j] > face[i][(j+1)%3])
				continue;
			glBegin(GL_LINES);
				glColor3fv(color[i][j]);
				glVertex3fv(vertex[ face[i][j] ]);
				glVertex3fv(vertex[ face[i][(j+1)%3] ]);	
			glEnd();
		}
	}
	delete[] color;
		
	glColor3f(1.0f, 1.0f, 1.0f);
	for(i=0; i<face_N; i++){
		if(face[i][0] < 0)
			continue;
		glBegin(GL_POLYGON);
			//glNormal3fv(normal_f[i]);
			float v[3];
			v[0] = vertex[face[i][0]][0] - 0.05f*normal[face[i][0]][0];
			v[1] = vertex[face[i][0]][1] - 0.05f*normal[face[i][0]][1];
			v[2] = vertex[face[i][0]][2] - 0.05f*normal[face[i][0]][2];
			glVertex3fv(v);

			v[0] = vertex[face[i][1]][0] - 0.05f*normal[face[i][1]][0];
			v[1] = vertex[face[i][1]][1] - 0.05f*normal[face[i][1]][1];
			v[2] = vertex[face[i][1]][2] - 0.05f*normal[face[i][1]][2];
			glVertex3fv(v);

			v[0] = vertex[face[i][2]][0] - 0.05f*normal[face[i][2]][0];
			v[1] = vertex[face[i][2]][1] - 0.05f*normal[face[i][2]][1];
			v[2] = vertex[face[i][2]][2] - 0.05f*normal[face[i][2]][2];
			glVertex3fv(v);
		glEnd();
	}

	glEnable(GL_LIGHTING);
}

void CMeshEditorView::convertToColorG(int n, float (*v)[3], float (*color)[3])
{
		float *len = new float[n];

	for(int i=0; i<n; i++)
		len[i] = v[i][0]; //MeshData::LENGTH(v[i]);

	float mid, vari;
	float S = 0;
	for(i=0; i<n; i++)
		S += len[i];
	mid = S/(float)n;

	S = 0;
	for(i = 0; i<n; i++)
		S += (len[i]-mid)*(len[i]-mid);
	vari = (float)sqrt(S/(float)n);

	for(i = 0; i<n; i++){
		float s = (len[i]-mid)/vari*1.5f;
		float v = (s+2.1f)/4.2f;
		if(v > 1)
			v = 1;
		else if(v < 0)
			v = 0;
		color[i][0] = v;
		color[i][1] = v;
		color[i][2] = v;
	}

	delete[] len;
}

void CMeshEditorView::drawRidgeTriangle(MeshData *mesh)
{
	glShadeModel(GL_SMOOTH);

	glDisable(GL_LIGHTING);

	float (*vertex)[3] = mesh->vertex;
	int face_N = mesh->face_N;
	int (*face)[3] = mesh->face;
	double (*ridge_T)[3] = mesh->ridge_T;
	double (*ravine_T)[3] = mesh->ravine_T;
	BOOL *isRidge_T = mesh->isRidge_T;
	BOOL *isRavine_T = mesh->isRavine_T;

	glColor3f(1.0, 0, 0);
	for(int i=0; i<face_N; i++){
		if(!isRidge_T[i])
			continue;
		float p1[3], p2[3];
		bool flag = true;
		for(int j=0; j<3; j++){
			if(ridge_T[i][j] < 0)
				continue;
			int i1 = face[i][j];
			int i2 = face[i][(j+1)%3];
			if(flag){
				p1[0] = (float)(ridge_T[i][j]*vertex[i1][0] + (1.0-ridge_T[i][j])*vertex[i2][0]);
				p1[1] = (float)(ridge_T[i][j]*vertex[i1][1] + (1.0-ridge_T[i][j])*vertex[i2][1]);
				p1[2] = (float)(ridge_T[i][j]*vertex[i1][2] + (1.0-ridge_T[i][j])*vertex[i2][2]);
				flag = false;
			}
			else{
				p2[0] = (float)(ridge_T[i][j]*vertex[i1][0] + (1.0-ridge_T[i][j])*vertex[i2][0]);
				p2[1] = (float)(ridge_T[i][j]*vertex[i1][1] + (1.0-ridge_T[i][j])*vertex[i2][1]);
				p2[2] = (float)(ridge_T[i][j]*vertex[i1][2] + (1.0-ridge_T[i][j])*vertex[i2][2]);
			}
		}
		glBegin(GL_LINES);
			glVertex3fv(p1);
			glVertex3fv(p2);
		glEnd();
	}

	glColor3f(0.0, 0, 1.0);
	for(i=0; i<face_N; i++){
		if(!isRavine_T[i])
			continue;
		float p1[3], p2[3];
		bool flag = true;
		for(int j=0; j<3; j++){
			if(ravine_T[i][j] < 0)
				continue;
			int i1 = face[i][j];
			int i2 = face[i][(j+1)%3];
			if(flag){
				p1[0] = (float)(ravine_T[i][j]*vertex[i1][0] + (1.0-ravine_T[i][j])*vertex[i2][0]);
				p1[1] = (float)(ravine_T[i][j]*vertex[i1][1] + (1.0-ravine_T[i][j])*vertex[i2][1]);
				p1[2] = (float)(ravine_T[i][j]*vertex[i1][2] + (1.0-ravine_T[i][j])*vertex[i2][2]);
				flag = false;
			}
			else{
				p2[0] = (float)(ravine_T[i][j]*vertex[i1][0] + (1.0-ravine_T[i][j])*vertex[i2][0]);
				p2[1] = (float)(ravine_T[i][j]*vertex[i1][1] + (1.0-ravine_T[i][j])*vertex[i2][1]);
				p2[2] = (float)(ravine_T[i][j]*vertex[i1][2] + (1.0-ravine_T[i][j])*vertex[i2][2]);
			}
		}
		glBegin(GL_LINES);
			glVertex3fv(p1);
			glVertex3fv(p2);
		glEnd();
	}
	glEnable(GL_LIGHTING);
}

void CMeshEditorView::drawSilhouette(MeshData *mesh)
{
	int vertex_N = mesh->vertex_N;
	float (*normal)[3] = mesh->normal;
	double (*t_max)[3] = mesh->t_max;
	double (*t_min)[3] = mesh->t_min;
	double *k_max = mesh->k_max;
	double *k_min = mesh->k_min;
	float (*x)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	int face_N = mesh->face_N;
	BOOL *isRidge = mesh->isRidge;
	BOOL *isRavine = mesh->isRavine;
	double (*ridge_dir)[3] = mesh->ridge_dir;
	double (*ravine_dir)[3] = mesh->ravine_dir;
	
	float *d = new float[vertex_N];

	glColor3f(0, 0, 0);
	glDisable(GL_LIGHTING);

	float R[3][3], R1[3][3], R2[3][3], R3[3][3], tmp[3][3], view[3];
	GENERATE_MAT(R1, -(float)(PI*Rz/180.0f), vx);
	MAT_VEC(view, R1, vy);
	GENERATE_MAT(R2, -(float)(PI*Ry/180.0f), view);
	MAT_TIMES(tmp, R2, R1);
	MAT_VEC(view, tmp, vz);
	GENERATE_MAT(R3, -(float)(PI*Rx/180.0f), view);

	MAT_TIMES(R, R3, tmp);

	float eyei[3], eyef[3];
	eyei[0] = (float)eye[0];
	eyei[1] = (float)eye[1];
	eyei[2] = (float)eye[2];
	MAT_VEC(eyef, R, eyei);
	for(int i=0; i<vertex_N; i++){
		float v[3];
		MeshData::VEC(v,eyef,x[i]);
		d[i] = (float)(MeshData::DOT(normal[i],v)/MeshData::LENGTH(v));
	}

	float (*seg_dir)[3] = new float[vertex_N][3];
	float *spe = new float[vertex_N];
	float Li[3], L[3];  
	Li[0] = (float)eye[0];
	Li[1] = (float)eye[1];
	Li[2] = (float)eye[2];
	MAT_VEC(L, R, Li);
	for(i=0; i<vertex_N; i++){
		/*
		float v[3], v1[3];
		MeshData::VEC(v,L,x[i]);
		spe[i] = (float)(MeshData::DOT(v, normal[i])/MeshData::LENGTH(v));
		MeshData::CROSS(v1, v, normal[i]);
		double l = MeshData::LENGTH(v1);
		seg_dir[i][0] = (float)(v1[0]/l);
		seg_dir[i][1] = (float)(v1[1]/l);
		seg_dir[i][2] = (float)(v1[2]/l);
		*/
		float v[3];
		MeshData::VEC(v,L,x[i]);
		spe[i] = (float)(MeshData::DOT(v, normal[i])/MeshData::LENGTH(v));

		/*
		if(fabs(k_max[i]) > fabs(k_min[i])){
			seg_dir[i][0] = (float)t_max[i][0];
			seg_dir[i][1] = (float)t_max[i][1];
			seg_dir[i][2] = (float)t_max[i][2];
		}
		else{
			seg_dir[i][0] = (float)t_min[i][0];
			seg_dir[i][1] = (float)t_min[i][1];
			seg_dir[i][2] = (float)t_min[i][2];
		}*/
	}

	for(int j=0; j<face_N; j++){
		bool b=true;
		float P1[3];
		float P2[3];
		for(int k=0; k<3; k++){
			int i1 = face[j][k];
			int i2 = face[j][(k+1)%3];
			if(d[i1]*d[i2]<=0){
				double total = fabs(d[i1]) + fabs(d[i2]);
				if(b){
					P1[0] = (float)((fabs(d[i2]) * x[i1][0] + fabs(d[i1]) * x[i2][0]) / total);
					P1[1] = (float)((fabs(d[i2]) * x[i1][1] + fabs(d[i1]) * x[i2][1]) / total);
					P1[2] = (float)((fabs(d[i2]) * x[i1][2] + fabs(d[i1]) * x[i2][2]) / total);
					b = false;
				}
				else{
					P2[0] = (float)((fabs(d[i2]) * x[i1][0] + fabs(d[i1]) * x[i2][0]) / total);
					P2[1] = (float)((fabs(d[i2]) * x[i1][1] + fabs(d[i1]) * x[i2][1]) / total);
					P2[2] = (float)((fabs(d[i2]) * x[i1][2] + fabs(d[i1]) * x[i2][2]) / total);
				}
			}
		}
		if(!b){
			glBegin(GL_LINES);
				glVertex3fv(P1);
				glVertex3fv(P2);
			glEnd();
		}
	}
	/*
	srand(100);	
	int sample_N = mesh->sample_N;
	struct MeshData::TRI_POINT* sample_point = mesh->sample_point;
	int* t_max_line_N = mesh->t_max_line_N;
	int* t_min_line_N = mesh->t_min_line_N;
	struct MeshData::TRI_POINT** t_max_line = mesh->t_max_line;
	struct MeshData::TRI_POINT** t_min_line = mesh->t_min_line;
	for(i=0; i<sample_N; i++){
		int* f = face[sample_point[i].id];
		double t1 = sample_point[i].u;
		double t2 = sample_point[i].v;
		double t0 = 1.0 - t1 - t2;

		//double s = t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]];

		double k1 = fabs(t0*k_max[f[0]] + t1*k_max[f[1]] + t2*k_max[f[2]]);
		double k2 = fabs(t0*k_min[f[0]] + t1*k_min[f[1]] + t2*k_min[f[2]]);
		//if(both || k1 > k2){
			glBegin(GL_LINES);
			f = face[t_max_line[i][0].id];
			t1 = t_max_line[i][0].u;
			t2 = t_max_line[i][0].v;
			t0 = 1.0 - t1 - t2;
			float last_p[3];
			last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
			for(int j=1; j<t_max_line_N[i]-2; j++){
				f = face[t_max_line[i][j].id];
				t1 = t_max_line[i][j].u;
				t2 = t_max_line[i][j].v;
				t0 = 1.0 - t1 - t2;
			
				//if(t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]] < -0.8){
					//glEnd();
					//break;
				//}

				float p[3];
				p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
				p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
				p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

				glVertex3fv(last_p);
				glVertex3fv(p);

				last_p[0] = p[0];
				last_p[1] = p[1];
				last_p[2] = p[2];
			}
			glEnd();
		//}
			
		if(both || k1 < k2){
			glBegin(GL_LINES);
			int *f = face[t_min_line[i][0].id];
			t1 = t_min_line[i][0].u;
			t2 = t_min_line[i][0].v;
			t0 = 1.0 - t1 - t2;
			float last_p[3];
			last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
			for(int j=1; j<t_min_line_N[i]-2; j++){
				f = face[t_min_line[i][j].id];
				t1 = t_min_line[i][j].u;
				t2 = t_min_line[i][j].v;
				t0 = 1.0 - t1 - t2;

				if(t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]] < -0.8){
					glEnd();
					break;
				}

				float p[3];
				p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
				p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
				p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

				glVertex3fv(last_p);
				glVertex3fv(p);

				last_p[0] = p[0];
				last_p[1] = p[1];
				last_p[2] = p[2];
			}
			glEnd();
		}
	}*/

	/*
	for(i=0; i<vertex_N; i++){
		if(spe[i] < 0)
			continue;
		
		float P1[3], P2[3];
		P1[0] = x[i][0] + 0.05f*seg_dir[i][0];
		P1[1] = x[i][1] + 0.05f*seg_dir[i][1];
		P1[2] = x[i][2] + 0.05f*seg_dir[i][2];

		P2[0] = x[i][0] - 0.05f*seg_dir[i][0];
		P2[1] = x[i][1] - 0.05f*seg_dir[i][1];
		P2[2] = x[i][2] - 0.05f*seg_dir[i][2];

		glBegin(GL_LINES);
			glVertex3fv(P1);
			glVertex3fv(P2);
		glEnd();
	}*/

	/*
	for(i=0; i<vertex_N; i++){
		if(isRidge[i]){
			float P1[3], P2[3];
			P1[0] = x[i][0] + 0.1f*(float)ridge_dir[i][0];
			P1[1] = x[i][1] + 0.1f*(float)ridge_dir[i][1];
			P1[2] = x[i][2] + 0.1f*(float)ridge_dir[i][2];

			P2[0] = x[i][0] - 0.1f*(float)ridge_dir[i][0];
			P2[1] = x[i][1] - 0.1f*(float)ridge_dir[i][1];
			P2[2] = x[i][2] - 0.1f*(float)ridge_dir[i][2];

			glBegin(GL_LINES);
				glVertex3fv(P1);
				glVertex3fv(P2);
			glEnd();
		}

		if(isRavine[i]){
			float P1[3], P2[3];
			P1[0] = x[i][0] + 0.1f*(float)ravine_dir[i][0];
			P1[1] = x[i][1] + 0.1f*(float)ravine_dir[i][1];
			P1[2] = x[i][2] + 0.1f*(float)ravine_dir[i][2];

			P2[0] = x[i][0] - 0.1f*(float)ravine_dir[i][0];
			P2[1] = x[i][1] - 0.1f*(float)ravine_dir[i][1];
			P2[2] = x[i][2] - 0.1f*(float)ravine_dir[i][2];

			glBegin(GL_LINES);
				glVertex3fv(P1);
				glVertex3fv(P2);
			glEnd();
		}
	}*/


	/*
	glColor3f(1.0f, 1.0f, 1.0f);
	//glColor3f(0.0f, 0.0f, 0.0f);
	MeshData::tri_point **ridge_line = mesh->ridge_line;
	int *ridge_line_N = mesh->ridge_line_N;
	int ridge_point_N  = mesh->ridge_point_N;
	for(i=0; i<ridge_point_N; i++){*/
		/*
		int *f = face[mesh->ridge_point[i].id];
		double t1 = mesh->ridge_point[i].u;
		double t2 = mesh->ridge_point[i].v;
		double t0 = 1.0 - t1 - t2;
		float last_p[3];
		last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
		last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
		last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
		glBegin(GL_POINTS);
			glVertex3fv(last_p);
		glEnd();*/
/*
		glBegin(GL_LINES);
		int *f = face[ridge_line[i][0].id];
		double t1 = ridge_line[i][0].u;
		double t2 = ridge_line[i][0].v;
		double t0 = 1.0 - t1 - t2;
		float last_p[3];
		last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
		last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
		last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
		for(int j=1; j<ridge_line_N[i]-2; j++){
			f = face[ridge_line[i][j].id];
			t1 = ridge_line[i][j].u;
			t2 = ridge_line[i][j].v;
			t0 = 1.0 - t1 - t2;
			float p[3];
			p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

			glVertex3fv(last_p);
			glVertex3fv(p);

			last_p[0] = p[0];
			last_p[1] = p[1];
			last_p[2] = p[2];
		}
		glEnd();
	}

	glColor3f(0, 0, 0);
	MeshData::tri_point **ravine_line = mesh->ravine_line;
	int *ravine_line_N = mesh->ravine_line_N;
	int ravine_point_N  = mesh->ravine_point_N;
	for(i=0; i<ravine_point_N; i++){*/
		/*
		int *f = face[mesh->ravine_point[i].id];
		double t1 = mesh->ravine_point[i].u;
		double t2 = mesh->ravine_point[i].v;
		double t0 = 1.0 - t1 - t2;
		float last_p[3];
		last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
		last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
		last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
		glBegin(GL_POINTS);
			glVertex3fv(last_p);
		glEnd();*/
		/*
		glBegin(GL_LINES);
		int *f = face[ravine_line[i][0].id];
		double t1 = ravine_line[i][0].u;
		double t2 = ravine_line[i][0].v;
		double t0 = 1.0 - t1 - t2;
		float last_p[3];
		last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
		last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
		last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
		for(int j=1; j<ravine_line_N[i]-2; j++){
			f = face[ravine_line[i][j].id];
			t1 = ravine_line[i][j].u;
			t2 = ravine_line[i][j].v;
			t0 = 1.0 - t1 - t2;
			float p[3];
			p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

			glVertex3fv(last_p);
			glVertex3fv(p);

			last_p[0] = p[0];
			last_p[1] = p[1];
			last_p[2] = p[2];
		}
		glEnd();
	}*/
	
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	//glColor3f(0.8f,0.8f,0.8f);
	glColor3f(1.0f,1.0f,1.0f);
	for(i=0; i<face_N; i++){
		float p1[3], p2[3], p3[3];

		int i1 = face[i][0];
		int i2 = face[i][1];
		int i3 = face[i][2];

		p1[0] = x[i1][0] - 0.02f*normal[i1][0];
		p1[1] = x[i1][1] - 0.02f*normal[i1][1];
		p1[2] = x[i1][2] - 0.02f*normal[i1][2];

		p2[0] = x[i2][0] - 0.02f*normal[i2][0];
		p2[1] = x[i2][1] - 0.02f*normal[i2][1];
		p2[2] = x[i2][2] - 0.02f*normal[i2][2];

		p3[0] = x[i3][0] - 0.02f*normal[i3][0];
		p3[1] = x[i3][1] - 0.02f*normal[i3][1];
		p3[2] = x[i3][2] - 0.02f*normal[i3][2];

		glBegin(GL_POLYGON);
			glVertex3fv(p1);
			glVertex3fv(p2);
			glVertex3fv(p3);
		glEnd();
	}

	/*
	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	glColor3f(0.0f, 0.0f, 1.0f);

	for(i=0; i<face_N; i++){
		float p1[3], p2[3], p3[3];

		int i1 = face[i][0];
		int i2 = face[i][1];
		int i3 = face[i][2];

		p1[0] = x[i1][0] - 0.025f*normal[i1][0];
		p1[1] = x[i1][1] - 0.025f*normal[i1][1];
		p1[2] = x[i1][2] - 0.025f*normal[i1][2];

		p2[0] = x[i2][0] - 0.025f*normal[i2][0];
		p2[1] = x[i2][1] - 0.025f*normal[i2][1];
		p2[2] = x[i2][2] - 0.025f*normal[i2][2];

		p3[0] = x[i3][0] - 0.025f*normal[i3][0];
		p3[1] = x[i3][1] - 0.025f*normal[i3][1];
		p3[2] = x[i3][2] - 0.025f*normal[i3][2];

		glBegin(GL_POLYGON);
			glVertex3fv(p1);
			glVertex3fv(p2);
			glVertex3fv(p3);
		glEnd();
	}*/

	glEnable(GL_LIGHTING);
	delete[] d;
	delete[] spe;
	delete[] seg_dir;
}

void CMeshEditorView::drawDisconK(MeshData *mesh, BOOL grey_scale, float T)
{
	int vertex_N = mesh->vertex_N;
	double *k_max = mesh->k_max;
	double *k_min = mesh->k_min;
	float (*vertex)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	float (*normal)[3] = mesh->normal;
	int face_N = mesh->face_N;

	glDisable(GL_LIGHTING);

	for(int i=0; i<face_N; i++){
		int *f = face[i];
		for(int j=0; j<3; j++){
			int i1 = f[j];
			int i2 = f[(j+1)%3];
			double dist = MeshData::DIST(vertex[i1], vertex[i2]);
			if(fabs(k_max[i1]-k_max[i2]) > T*dist){
				if(grey_scale)
					glColor3f(1.0f, 1.0f, 1.0f);
				else
					glColor3f(1.0f, 0.0f, 0.0f);
				float p1[3], p2[3];
				p1[0] = (vertex[f[0]][0] + vertex[f[1]][0] + vertex[f[2]][0])/3.0f;
				p1[1] = (vertex[f[0]][1] + vertex[f[1]][1] + vertex[f[2]][1])/3.0f;
				p1[2] = (vertex[f[0]][2] + vertex[f[1]][2] + vertex[f[2]][2])/3.0f;

				p2[0] = (vertex[i1][0] + vertex[i2][0])*0.5f;
				p2[1] = (vertex[i1][1] + vertex[i2][1])*0.5f;
				p2[2] = (vertex[i1][2] + vertex[i2][2])*0.5f;

				glBegin(GL_LINES);
					glVertex3fv(p1);
					glVertex3fv(p2);
				glEnd();
			}
			if(fabs(k_min[i1]-k_min[i2]) > T*dist){
				if(grey_scale)
					glColor3f(0.0f, 0.0f, 0.0f);
				else
					glColor3f(0.0f, 0.0f, 1.0f);
				float p1[3], p2[3];
				p1[0] = (vertex[f[0]][0] + vertex[f[1]][0] + vertex[f[2]][0])/3.0f;
				p1[1] = (vertex[f[0]][1] + vertex[f[1]][1] + vertex[f[2]][1])/3.0f;
				p1[2] = (vertex[f[0]][2] + vertex[f[1]][2] + vertex[f[2]][2])/3.0f;

				p2[0] = (vertex[i1][0] + vertex[i2][0])*0.5f;
				p2[1] = (vertex[i1][1] + vertex[i2][1])*0.5f;
				p2[2] = (vertex[i1][2] + vertex[i2][2])*0.5f;

				glBegin(GL_LINES);
					glVertex3fv(p1);
					glVertex3fv(p2);
				glEnd();
			}
		}
	}
	
	glColor3f(0.8f,0.8f,0.8f);
	for(i=0; i<face_N; i++){
		float p1[3], p2[3], p3[3];

		int i1 = face[i][0];
		int i2 = face[i][1];
		int i3 = face[i][2];

		p1[0] = vertex[i1][0] - 0.02f*normal[i1][0];
		p1[1] = vertex[i1][1] - 0.02f*normal[i1][1];
		p1[2] = vertex[i1][2] - 0.02f*normal[i1][2];

		p2[0] = vertex[i2][0] - 0.02f*normal[i2][0];
		p2[1] = vertex[i2][1] - 0.02f*normal[i2][1];
		p2[2] = vertex[i2][2] - 0.02f*normal[i2][2];

		p3[0] = vertex[i3][0] - 0.02f*normal[i3][0];
		p3[1] = vertex[i3][1] - 0.02f*normal[i3][1];
		p3[2] = vertex[i3][2] - 0.02f*normal[i3][2];

		glBegin(GL_POLYGON);
			glVertex3fv(p1);
			glVertex3fv(p2);
			glVertex3fv(p3);
		glEnd();
	}

	glEnable(GL_LIGHTING);
}

void CMeshEditorView::drawDisconT(MeshData *mesh, BOOL grey_scale, float T)
{
	int vertex_N = mesh->vertex_N;
	double (*t_max)[3] = mesh->t_max;
	double (*t_min)[3] = mesh->t_min;
	float (*vertex)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	float (*normal)[3] = mesh->normal;
	int face_N = mesh->face_N;

	glDisable(GL_LIGHTING);

	for(int i=0; i<face_N; i++){
		int *f = face[i];
		glColor3f(0.8f, 0.8f, 0.8f);
		for(int j=0; j<3; j++){
			int i1 = f[j];
			int i2 = f[(j+1)%3];
			double dist = MeshData::DIST(vertex[i1], vertex[i2]);
			double v[3];
			mesh->paralellTrans(v, t_max[i2], i2, i1);
			double dot = MeshData::DOT(t_max[i1], v);
			if(dot > 1)
				dot = 1;
			else if(dot < -1)
				dot = -1;
			if(acos(fabs(dot)) > T*dist){
				//if(grey_scale)
					glColor3f(0.0f, 0.0f, 0.0f);
				//else
					//glColor3f(1.0f, 0.0f, 0.0f);
				break;
				/*
				float p1[3], p2[3];
				p1[0] = (vertex[f[0]][0] + vertex[f[1]][0] + vertex[f[2]][0])/3.0f;
				p1[1] = (vertex[f[0]][1] + vertex[f[1]][1] + vertex[f[2]][1])/3.0f;
				p1[2] = (vertex[f[0]][2] + vertex[f[1]][2] + vertex[f[2]][2])/3.0f;

				p2[0] = (vertex[i1][0] + vertex[i2][0])*0.5f;
				p2[1] = (vertex[i1][1] + vertex[i2][1])*0.5f;
				p2[2] = (vertex[i1][2] + vertex[i2][2])*0.5f;

				glBegin(GL_LINES);
					glVertex3fv(p1);
					glVertex3fv(p2);
				glEnd();
				*/
			}
			/*
			mesh->paralellTrans(v, t_min[i2], i2, i1);
			if(acos(fabs(MeshData::DOT(t_min[i1], v))) > T*dist){
				if(grey_scale)
					glColor3f(0.0f, 0.0f, 0.0f);
				else
					glColor3f(0.0f, 0.0f, 1.0f);
				float p1[3], p2[3];
				p1[0] = (vertex[f[0]][0] + vertex[f[1]][0] + vertex[f[2]][0])/3.0f;
				p1[1] = (vertex[f[0]][1] + vertex[f[1]][1] + vertex[f[2]][1])/3.0f;
				p1[2] = (vertex[f[0]][2] + vertex[f[1]][2] + vertex[f[2]][2])/3.0f;

				p2[0] = (vertex[i1][0] + vertex[i2][0])*0.5f;
				p2[1] = (vertex[i1][1] + vertex[i2][1])*0.5f;
				p2[2] = (vertex[i1][2] + vertex[i2][2])*0.5f;

				glBegin(GL_LINES);
					glVertex3fv(p1);
					glVertex3fv(p2);
				glEnd();
			}*/
		}
		glBegin(GL_POLYGON);
			glVertex3fv(vertex[f[0]]);
			glVertex3fv(vertex[f[1]]);
			glVertex3fv(vertex[f[2]]);
		glEnd();
	}
	
	/*
	glColor3f(0.8f,0.8f,0.8f);
	for(i=0; i<face_N; i++){
		float p1[3], p2[3], p3[3];

		int i1 = face[i][0];
		int i2 = face[i][1];
		int i3 = face[i][2];

		p1[0] = vertex[i1][0] - 0.02f*normal[i1][0];
		p1[1] = vertex[i1][1] - 0.02f*normal[i1][1];
		p1[2] = vertex[i1][2] - 0.02f*normal[i1][2];

		p2[0] = vertex[i2][0] - 0.02f*normal[i2][0];
		p2[1] = vertex[i2][1] - 0.02f*normal[i2][1];
		p2[2] = vertex[i2][2] - 0.02f*normal[i2][2];

		p3[0] = vertex[i3][0] - 0.02f*normal[i3][0];
		p3[1] = vertex[i3][1] - 0.02f*normal[i3][1];
		p3[2] = vertex[i3][2] - 0.02f*normal[i3][2];

		glBegin(GL_POLYGON);
			glVertex3fv(p1);
			glVertex3fv(p2);
			glVertex3fv(p3);
		glEnd();
	}*/

	glEnable(GL_LIGHTING);
}

void CMeshEditorView::drawTmaxAsLong(MeshData *mesh)
{
	int vertex_N = mesh->vertex_N;
	float (*normal)[3] = mesh->normal;
	float (*x)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	int face_N = mesh->face_N;
	
	float *d = new float[vertex_N];

	glColor3f(0, 0, 0);
	glDisable(GL_LIGHTING);

	float R[3][3], R1[3][3], R2[3][3], R3[3][3], tmp[3][3], view[3];
	GENERATE_MAT(R1, -(float)(PI*Rz/180.0f), vx);
	MAT_VEC(view, R1, vy);
	GENERATE_MAT(R2, -(float)(PI*Ry/180.0f), view);
	MAT_TIMES(tmp, R2, R1);
	MAT_VEC(view, tmp, vz);
	GENERATE_MAT(R3, -(float)(PI*Rx/180.0f), view);

	MAT_TIMES(R, R3, tmp);

	float eyei[3], eyef[3];
	eyei[0] = (float)eye[0];
	eyei[1] = (float)eye[1];
	eyei[2] = (float)eye[2];
	MAT_VEC(eyef, R, eyei);
	for(int i=0; i<vertex_N; i++){
		float v[3];
		MeshData::VEC(v,eyef,x[i]);
		d[i] = (float)(MeshData::DOT(normal[i],v)/MeshData::LENGTH(v));
	}

	for(int j=0; j<face_N; j++){
		bool b=true;
		float P1[3];
		float P2[3];
		for(int k=0; k<3; k++){
			int i1 = face[j][k];
			int i2 = face[j][(k+1)%3];
			if(d[i1]*d[i2]<=0){
				double total = fabs(d[i1]) + fabs(d[i2]);
				if(b){
					P1[0] = (float)((fabs(d[i2]) * x[i1][0] + fabs(d[i1]) * x[i2][0]) / total);
					P1[1] = (float)((fabs(d[i2]) * x[i1][1] + fabs(d[i1]) * x[i2][1]) / total);
					P1[2] = (float)((fabs(d[i2]) * x[i1][2] + fabs(d[i1]) * x[i2][2]) / total);
					b = false;
				}
				else{
					P2[0] = (float)((fabs(d[i2]) * x[i1][0] + fabs(d[i1]) * x[i2][0]) / total);
					P2[1] = (float)((fabs(d[i2]) * x[i1][1] + fabs(d[i1]) * x[i2][1]) / total);
					P2[2] = (float)((fabs(d[i2]) * x[i1][2] + fabs(d[i1]) * x[i2][2]) / total);
				}
			}
		}
		if(!b){
			glBegin(GL_LINES);
				glVertex3fv(P1);
				glVertex3fv(P2);
			glEnd();
		}
	}

	int sample_N = mesh->sample_N;
	int* t_max_line_N = mesh->t_max_line_N;
	struct MeshData::TRI_POINT** t_max_line = mesh->t_max_line;
	for(i=0; i<sample_N; i++){
		glBegin(GL_LINES);
		int *f = face[t_max_line[i][0].id];
		double t1 = t_max_line[i][0].u;
		double t2 = t_max_line[i][0].v;
		double t0 = 1.0 - t1 - t2;
		float last_p[3];
		last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
		last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
		last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
		for(int j=1; j<t_max_line_N[i]-2; j++){
			f = face[t_max_line[i][j].id];
			t1 = t_max_line[i][j].u;
			t2 = t_max_line[i][j].v;
			t0 = 1.0 - t1 - t2;

			float p[3];
			p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

			glVertex3fv(last_p);
			glVertex3fv(p);

			last_p[0] = p[0];
			last_p[1] = p[1];
			last_p[2] = p[2];
		}
		glEnd();
	}

	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	glColor3f(1.0f,1.0f,1.0f);
	for(i=0; i<face_N; i++){
		float p1[3], p2[3], p3[3];

		int i1 = face[i][0];
		int i2 = face[i][1];
		int i3 = face[i][2];

		p1[0] = x[i1][0] - 0.02f*normal[i1][0];
		p1[1] = x[i1][1] - 0.02f*normal[i1][1];
		p1[2] = x[i1][2] - 0.02f*normal[i1][2];

		p2[0] = x[i2][0] - 0.02f*normal[i2][0];
		p2[1] = x[i2][1] - 0.02f*normal[i2][1];
		p2[2] = x[i2][2] - 0.02f*normal[i2][2];

		p3[0] = x[i3][0] - 0.02f*normal[i3][0];
		p3[1] = x[i3][1] - 0.02f*normal[i3][1];
		p3[2] = x[i3][2] - 0.02f*normal[i3][2];

		glBegin(GL_POLYGON);
			glVertex3fv(p1);
			glVertex3fv(p2);
			glVertex3fv(p3);
		glEnd();
	}

	glEnable(GL_LIGHTING);
	delete[] d;
}

void CMeshEditorView::drawTminAsLong(MeshData *mesh)
{
	int vertex_N = mesh->vertex_N;
	float (*normal)[3] = mesh->normal;
	float (*x)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	int face_N = mesh->face_N;
	
	float *d = new float[vertex_N];

	glColor3f(0, 0, 0);
	glDisable(GL_LIGHTING);

	float R[3][3], R1[3][3], R2[3][3], R3[3][3], tmp[3][3], view[3];
	GENERATE_MAT(R1, -(float)(PI*Rz/180.0f), vx);
	MAT_VEC(view, R1, vy);
	GENERATE_MAT(R2, -(float)(PI*Ry/180.0f), view);
	MAT_TIMES(tmp, R2, R1);
	MAT_VEC(view, tmp, vz);
	GENERATE_MAT(R3, -(float)(PI*Rx/180.0f), view);

	MAT_TIMES(R, R3, tmp);

	float eyei[3], eyef[3];
	eyei[0] = (float)eye[0];
	eyei[1] = (float)eye[1];
	eyei[2] = (float)eye[2];
	MAT_VEC(eyef, R, eyei);
	for(int i=0; i<vertex_N; i++){
		float v[3];
		MeshData::VEC(v,eyef,x[i]);
		d[i] = (float)(MeshData::DOT(normal[i],v)/MeshData::LENGTH(v));
	}

	for(int j=0; j<face_N; j++){
		bool b=true;
		float P1[3];
		float P2[3];
		for(int k=0; k<3; k++){
			int i1 = face[j][k];
			int i2 = face[j][(k+1)%3];
			if(d[i1]*d[i2]<=0){
				double total = fabs(d[i1]) + fabs(d[i2]);
				if(b){
					P1[0] = (float)((fabs(d[i2]) * x[i1][0] + fabs(d[i1]) * x[i2][0]) / total);
					P1[1] = (float)((fabs(d[i2]) * x[i1][1] + fabs(d[i1]) * x[i2][1]) / total);
					P1[2] = (float)((fabs(d[i2]) * x[i1][2] + fabs(d[i1]) * x[i2][2]) / total);
					b = false;
				}
				else{
					P2[0] = (float)((fabs(d[i2]) * x[i1][0] + fabs(d[i1]) * x[i2][0]) / total);
					P2[1] = (float)((fabs(d[i2]) * x[i1][1] + fabs(d[i1]) * x[i2][1]) / total);
					P2[2] = (float)((fabs(d[i2]) * x[i1][2] + fabs(d[i1]) * x[i2][2]) / total);
				}
			}
		}
		if(!b){
			glBegin(GL_LINES);
				glVertex3fv(P1);
				glVertex3fv(P2);
			glEnd();
		}
	}

	int sample_N = mesh->sample_N;
	int* t_min_line_N = mesh->t_min_line_N;
	struct MeshData::TRI_POINT** t_min_line = mesh->t_min_line;
	for(i=0; i<sample_N; i++){	
		glBegin(GL_LINES);
		int *f = face[t_min_line[i][0].id];
		double t1 = t_min_line[i][0].u;
		double t2 = t_min_line[i][0].v;
		double t0 = 1.0 - t1 - t2;
		float last_p[3];
		last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
		last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
		last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
		for(int j=1; j<t_min_line_N[i]-2; j++){
			f = face[t_min_line[i][j].id];
			t1 = t_min_line[i][j].u;
			t2 = t_min_line[i][j].v;
			t0 = 1.0 - t1 - t2;

			float p[3];
			p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

			glVertex3fv(last_p);
			glVertex3fv(p);

			last_p[0] = p[0];
			last_p[1] = p[1];
			last_p[2] = p[2];
		}
		glEnd();
	}

	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	glColor3f(1.0f,1.0f,1.0f);
	for(i=0; i<face_N; i++){
		float p1[3], p2[3], p3[3];

		int i1 = face[i][0];
		int i2 = face[i][1];
		int i3 = face[i][2];

		p1[0] = x[i1][0] - 0.02f*normal[i1][0];
		p1[1] = x[i1][1] - 0.02f*normal[i1][1];
		p1[2] = x[i1][2] - 0.02f*normal[i1][2];

		p2[0] = x[i2][0] - 0.02f*normal[i2][0];
		p2[1] = x[i2][1] - 0.02f*normal[i2][1];
		p2[2] = x[i2][2] - 0.02f*normal[i2][2];

		p3[0] = x[i3][0] - 0.02f*normal[i3][0];
		p3[1] = x[i3][1] - 0.02f*normal[i3][1];
		p3[2] = x[i3][2] - 0.02f*normal[i3][2];

		glBegin(GL_POLYGON);
			glVertex3fv(p1);
			glVertex3fv(p2);
			glVertex3fv(p3);
		glEnd();
	}

	glEnable(GL_LIGHTING);
	delete[] d;
}

void CMeshEditorView::drawHatch(MeshData *mesh, float Li[], float T1, float T2)
{
	int vertex_N = mesh->vertex_N;
	float (*normal)[3] = mesh->normal;
	double (*t_max)[3] = mesh->t_max;
	double (*t_min)[3] = mesh->t_min;
	double *k_max = mesh->k_max;
	double *k_min = mesh->k_min;
	float (*x)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	int face_N = mesh->face_N;
	
	float *d = new float[vertex_N];

	glColor3f(0, 0, 0);
	glDisable(GL_LIGHTING);

	float R[3][3], R1[3][3], R2[3][3], R3[3][3], tmp[3][3], view[3];
	GENERATE_MAT(R1, -(float)(PI*Rz/180.0f), vx);
	MAT_VEC(view, R1, vy);
	GENERATE_MAT(R2, -(float)(PI*Ry/180.0f), view);
	MAT_TIMES(tmp, R2, R1);
	MAT_VEC(view, tmp, vz);
	GENERATE_MAT(R3, -(float)(PI*Rx/180.0f), view);

	MAT_TIMES(R, R3, tmp);

	float eyei[3], eyef[3];
	eyei[0] = (float)eye[0];
	eyei[1] = (float)eye[1];
	eyei[2] = (float)eye[2];
	MAT_VEC(eyef, R, eyei);
	for(int i=0; i<vertex_N; i++){
		float v[3];
		MeshData::VEC(v,eyef,x[i]);
		d[i] = (float)(MeshData::DOT(normal[i],v)/MeshData::LENGTH(v));
	}

	float (*seg_dir)[3] = new float[vertex_N][3];
	float *spe = new float[vertex_N];
	float L[3];
	MAT_VEC(L, R, Li);
	for(i=0; i<vertex_N; i++){
		float v[3];
		MeshData::VEC(v,L,x[i]);
		spe[i] = (float)(MeshData::DOT(v, normal[i])/MeshData::LENGTH(v));
	}

	for(int j=0; j<face_N; j++){
		bool b=true;
		float P1[3];
		float P2[3];
		for(int k=0; k<3; k++){
			int i1 = face[j][k];
			int i2 = face[j][(k+1)%3];
			if(d[i1]*d[i2]<=0){
				double total = fabs(d[i1]) + fabs(d[i2]);
				if(b){
					P1[0] = (float)((fabs(d[i2]) * x[i1][0] + fabs(d[i1]) * x[i2][0]) / total);
					P1[1] = (float)((fabs(d[i2]) * x[i1][1] + fabs(d[i1]) * x[i2][1]) / total);
					P1[2] = (float)((fabs(d[i2]) * x[i1][2] + fabs(d[i1]) * x[i2][2]) / total);
					b = false;
				}
				else{
					P2[0] = (float)((fabs(d[i2]) * x[i1][0] + fabs(d[i1]) * x[i2][0]) / total);
					P2[1] = (float)((fabs(d[i2]) * x[i1][1] + fabs(d[i1]) * x[i2][1]) / total);
					P2[2] = (float)((fabs(d[i2]) * x[i1][2] + fabs(d[i1]) * x[i2][2]) / total);
				}
			}
		}
		if(!b){
			glBegin(GL_LINES);
				glVertex3fv(P1);
				glVertex3fv(P2);
			glEnd();
		}
	}

	int sample_N = mesh->sample_N;
	struct MeshData::TRI_POINT* sample_point = mesh->sample_point;
	int* t_max_line_N = mesh->t_max_line_N;
	int* t_min_line_N = mesh->t_min_line_N;
	struct MeshData::TRI_POINT** t_max_line = mesh->t_max_line;
	struct MeshData::TRI_POINT** t_min_line = mesh->t_min_line;
	for(i=0; i<sample_N; i++){
		int* f = face[sample_point[i].id];
		double t1 = sample_point[i].u;
		double t2 = sample_point[i].v;
		double t0 = 1.0 - t1 - t2;

		double s = t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]];
		bool both = false;
		//if(s < T1)
			//continue;
		if(s > T2)
			both = true;

		double k1 = fabs(t0*k_max[f[0]] + t1*k_max[f[1]] + t2*k_max[f[2]]);
		double k2 = fabs(t0*k_min[f[0]] + t1*k_min[f[1]] + t2*k_min[f[2]]);
		if(both || k1 > k2){
			f = face[t_max_line[i][0].id];
			t1 = t_max_line[i][0].u;
			t2 = t_max_line[i][0].v;
			t0 = 1.0 - t1 - t2;
			float last_p[3];
			last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
			for(int j=1; j<t_max_line_N[i]-2; j++){
				f = face[t_max_line[i][j].id];
				t1 = t_max_line[i][j].u;
				t2 = t_max_line[i][j].v;
				t0 = 1.0 - t1 - t2;

				float p[3];
				p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
				p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
				p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

				bool draw = true;

				if(both){
					if(k1 > k2){
						if(t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]] < T1){
							draw = false;
						}
					}
					else{
						if(t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]] < T2)
							draw = false;
					}
				}
				else{
					if(t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]] < T1)
						draw = false;
					else if(fabs(t0*k_max[f[0]] + t1*k_max[f[1]] + t2*k_max[f[2]]) < fabs(t0*k_min[f[0]] + t1*k_min[f[1]] + t2*k_min[f[2]]))
						draw = false;
				}
			
				if(draw){
					glBegin(GL_LINES);
						glVertex3fv(last_p);
						glVertex3fv(p);
					glEnd();
				}

				last_p[0] = p[0];
				last_p[1] = p[1];
				last_p[2] = p[2];
			}
		}
		if(both || k1 < k2){
			f = face[t_min_line[i][0].id];
			t1 = t_min_line[i][0].u;
			t2 = t_min_line[i][0].v;
			t0 = 1.0 - t1 - t2;
			float last_p[3];
			last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
			for(int j=1; j<t_min_line_N[i]-2; j++){
				f = face[t_min_line[i][j].id];
				t1 = t_min_line[i][j].u;
				t2 = t_min_line[i][j].v;
				t0 = 1.0 - t1 - t2;

				float p[3];
				p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
				p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
				p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

				bool draw = true;

				if(both){
					if(k1 < k2){
						if(t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]] < T1){
							draw = false;
						}
					}
					else{
						if(t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]] < T2)
							draw = false;
					}
				}
				else{
					if(t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]] < T1)
						draw = false;
					else if(fabs(t0*k_max[f[0]] + t1*k_max[f[1]] + t2*k_max[f[2]]) > fabs(t0*k_min[f[0]] + t1*k_min[f[1]] + t2*k_min[f[2]]))
						draw = false;
				}
			
				if(draw){
					glBegin(GL_LINES);
						glVertex3fv(last_p);
						glVertex3fv(p);
					glEnd();
				}

				last_p[0] = p[0];
				last_p[1] = p[1];
				last_p[2] = p[2];
			}
		}
	}

	//glColor3f(1.0f, 1.0f, 1.0f);
	/*
	glColor3f(0.0f, 0.0f, 0.0f);
	MeshData::tri_point **ridge_line = mesh->ridge_line;
	int *ridge_line_N = mesh->ridge_line_N;
	int ridge_point_N  = mesh->ridge_point_N;
	for(i=0; i<ridge_point_N; i++){
		glBegin(GL_LINES);
		int *f = face[ridge_line[i][0].id];
		double t1 = ridge_line[i][0].u;
		double t2 = ridge_line[i][0].v;
		double t0 = 1.0 - t1 - t2;
		float last_p[3];
		last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
		last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
		last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
		for(int j=1; j<ridge_line_N[i]-2; j++){
			f = face[ridge_line[i][j].id];
			t1 = ridge_line[i][j].u;
			t2 = ridge_line[i][j].v;
			t0 = 1.0 - t1 - t2;
			float p[3];
			p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

			glVertex3fv(last_p);
			glVertex3fv(p);

			last_p[0] = p[0];
			last_p[1] = p[1];
			last_p[2] = p[2];
		}
		glEnd();
	}

	glColor3f(0, 0, 0);
	MeshData::tri_point **ravine_line = mesh->ravine_line;
	int *ravine_line_N = mesh->ravine_line_N;
	int ravine_point_N  = mesh->ravine_point_N;
	for(i=0; i<ravine_point_N; i++){
		glBegin(GL_LINES);
		int *f = face[ravine_line[i][0].id];
		double t1 = ravine_line[i][0].u;
		double t2 = ravine_line[i][0].v;
		double t0 = 1.0 - t1 - t2;
		float last_p[3];
		last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
		last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
		last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
		for(int j=1; j<ravine_line_N[i]-2; j++){
			f = face[ravine_line[i][j].id];
			t1 = ravine_line[i][j].u;
			t2 = ravine_line[i][j].v;
			t0 = 1.0 - t1 - t2;
			float p[3];
			p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

			glVertex3fv(last_p);
			glVertex3fv(p);

			last_p[0] = p[0];
			last_p[1] = p[1];
			last_p[2] = p[2];
		}
		glEnd();
	}*/

	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	glColor3f(1.0f,1.0f,1.0f);
	for(i=0; i<face_N; i++){
		float p1[3], p2[3], p3[3];

		int i1 = face[i][0];
		int i2 = face[i][1];
		int i3 = face[i][2];

		p1[0] = x[i1][0] - 0.02f*normal[i1][0];
		p1[1] = x[i1][1] - 0.02f*normal[i1][1];
		p1[2] = x[i1][2] - 0.02f*normal[i1][2];

		p2[0] = x[i2][0] - 0.02f*normal[i2][0];
		p2[1] = x[i2][1] - 0.02f*normal[i2][1];
		p2[2] = x[i2][2] - 0.02f*normal[i2][2];

		p3[0] = x[i3][0] - 0.02f*normal[i3][0];
		p3[1] = x[i3][1] - 0.02f*normal[i3][1];
		p3[2] = x[i3][2] - 0.02f*normal[i3][2];

		glBegin(GL_POLYGON);
			glVertex3fv(p1);
			glVertex3fv(p2);
			glVertex3fv(p3);
		glEnd();
	}

	glEnable(GL_LIGHTING);
	delete[] d;
	delete[] spe;
}

void CMeshEditorView::drawHatch2(MeshData *mesh, float Li[], float T1, float T2)
{
	int vertex_N = mesh->vertex_N;
	float (*normal)[3] = mesh->normal;
	double (*t_max)[3] = mesh->t_max;
	double (*t_min)[3] = mesh->t_min;
	double *k_max = mesh->k_max;
	double *k_min = mesh->k_min;
	float (*x)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	int face_N = mesh->face_N;
	
	float *d = new float[vertex_N];

	BOOL* is_hatch = mesh->is_hatch;

	glColor3f(0, 0, 0);
	glDisable(GL_LIGHTING);

	float R[3][3], R1[3][3], R2[3][3], R3[3][3], tmp[3][3], view[3];
	GENERATE_MAT(R1, -(float)(PI*Rz/180.0f), vx);
	MAT_VEC(view, R1, vy);
	GENERATE_MAT(R2, -(float)(PI*Ry/180.0f), view);
	MAT_TIMES(tmp, R2, R1);
	MAT_VEC(view, tmp, vz);
	GENERATE_MAT(R3, -(float)(PI*Rx/180.0f), view);

	MAT_TIMES(R, R3, tmp);

	float eyei[3], eyef[3];
	eyei[0] = (float)eye[0];
	eyei[1] = (float)eye[1];
	eyei[2] = (float)eye[2];
	MAT_VEC(eyef, R, eyei);
	for(int i=0; i<vertex_N; i++){
		float v[3];
		MeshData::VEC(v,eyef,x[i]);
		d[i] = (float)(MeshData::DOT(normal[i],v)/MeshData::LENGTH(v));
	}

	float (*seg_dir)[3] = new float[vertex_N][3];
	float *spe = new float[vertex_N];
	float L[3];
	MAT_VEC(L, R, Li);
	for(i=0; i<vertex_N; i++){
		float v[3];
		MeshData::VEC(v,L,x[i]);
		spe[i] = (float)(MeshData::DOT(v, normal[i])/MeshData::LENGTH(v));
	}

	for(int j=0; j<face_N; j++){
		bool b=true;
		float P1[3];
		float P2[3];
		for(int k=0; k<3; k++){
			int i1 = face[j][k];
			int i2 = face[j][(k+1)%3];
			if(d[i1]*d[i2]<=0){
				double total = fabs(d[i1]) + fabs(d[i2]);
				if(b){
					P1[0] = (float)((fabs(d[i2]) * x[i1][0] + fabs(d[i1]) * x[i2][0]) / total);
					P1[1] = (float)((fabs(d[i2]) * x[i1][1] + fabs(d[i1]) * x[i2][1]) / total);
					P1[2] = (float)((fabs(d[i2]) * x[i1][2] + fabs(d[i1]) * x[i2][2]) / total);
					b = false;
				}
				else{
					P2[0] = (float)((fabs(d[i2]) * x[i1][0] + fabs(d[i1]) * x[i2][0]) / total);
					P2[1] = (float)((fabs(d[i2]) * x[i1][1] + fabs(d[i1]) * x[i2][1]) / total);
					P2[2] = (float)((fabs(d[i2]) * x[i1][2] + fabs(d[i1]) * x[i2][2]) / total);
				}
			}
		}
		if(!b){
			glBegin(GL_LINES);
				glVertex3fv(P1);
				glVertex3fv(P2);
			glEnd();
		}
	}

	int sample_N = mesh->sample_N;
	struct MeshData::TRI_POINT* sample_point = mesh->sample_point;
	int* t_max_line_N = mesh->t_max_line_N;
	int* t_min_line_N = mesh->t_min_line_N;
	struct MeshData::TRI_POINT** t_max_line = mesh->t_max_line;
	struct MeshData::TRI_POINT** t_min_line = mesh->t_min_line;
	for(i=0; i<sample_N; i++){
		int* f = face[sample_point[i].id];
		double t1 = sample_point[i].u;
		double t2 = sample_point[i].v;
		double t0 = 1.0 - t1 - t2;

		double s = t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]];
		double k1 = fabs(t0*k_max[f[0]] + t1*k_max[f[1]] + t2*k_max[f[2]]);
		double k2 = fabs(t0*k_min[f[0]] + t1*k_min[f[1]] + t2*k_min[f[2]]);
	
		if(s < T1)
			continue;

		bool is_cross = false;
		if(s > T2)
			is_cross = true;

		f = face[t_max_line[i][0].id];
		t1 = t_max_line[i][0].u;
		t2 = t_max_line[i][0].v;
		t0 = 1.0 - t1 - t2;
		float last_p[3];
		last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
		last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
		last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
		for(int j=1; j<t_max_line_N[i]-2; j++){
			f = face[t_max_line[i][j].id];
			t1 = t_max_line[i][j].u;
			t2 = t_max_line[i][j].v;
			t0 = 1.0 - t1 - t2;

			float p[3];
			p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

			bool draw = true;
		
			double s1 = t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]];
			if(!is_hatch[t_max_line[i][j].id]){
				draw = false;
			}
			/*if(!is_cross){
				if(fabs(t0*k_max[f[0]] + t1*k_max[f[1]] + t2*k_max[f[2]]) 
					< fabs(t0*k_min[f[0]] + t1*k_min[f[1]] + t2*k_min[f[2]]))
					draw = false;
			}*/
			else if(s1 < T1)
				//draw = false;
			if(s1 <= T2){
				if(fabs(t0*k_max[f[0]] + t1*k_max[f[1]] + t2*k_max[f[2]]) 
					< fabs(t0*k_min[f[0]] + t1*k_min[f[1]] + t2*k_min[f[2]]))
					draw = false;
			}
	
			if(draw){
				glBegin(GL_LINES);
					glVertex3fv(last_p);
					glVertex3fv(p);
				glEnd();
			}

			last_p[0] = p[0];
			last_p[1] = p[1];
			last_p[2] = p[2];
		}
		
		f = face[t_min_line[i][0].id];
		t1 = t_min_line[i][0].u;
		t2 = t_min_line[i][0].v;
		t0 = 1.0 - t1 - t2;
		last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
		last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
		last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
		for(j=1; j<t_min_line_N[i]-2; j++){
			f = face[t_min_line[i][j].id];
			t1 = t_min_line[i][j].u;
			t2 = t_min_line[i][j].v;
			t0 = 1.0 - t1 - t2;

			float p[3];
			p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

			bool draw = true;

			double s1 = t0*spe[f[0]] + t1*spe[f[1]] + t2*spe[f[2]];
			
			if(!is_hatch[t_min_line[i][j].id]){
				draw = false;
			}
			/*
			if(!is_cross){
				if(fabs(t0*k_max[f[0]] + t1*k_max[f[1]] + t2*k_max[f[2]]) 
					> fabs(t0*k_min[f[0]] + t1*k_min[f[1]] + t2*k_min[f[2]]))
					draw = false;
			}*/
			//else if(s1 < T1)
				//draw = false;
			if(s1 <= T2){
				if(fabs(t0*k_max[f[0]] + t1*k_max[f[1]] + t2*k_max[f[2]]) 
					> fabs(t0*k_min[f[0]] + t1*k_min[f[1]] + t2*k_min[f[2]]))
					draw = false;
			}
			
			if(draw){
				glBegin(GL_LINES);
					glVertex3fv(last_p);
					glVertex3fv(p);
				glEnd();
			}

			last_p[0] = p[0];
			last_p[1] = p[1];
			last_p[2] = p[2];
		}
	}

	//glColor3f(1.0f, 1.0f, 1.0f);
	/*
	glColor3f(0.0f, 0.0f, 0.0f);
	MeshData::tri_point **ridge_line = mesh->ridge_line;
	int *ridge_line_N = mesh->ridge_line_N;
	int ridge_point_N  = mesh->ridge_point_N;
	for(i=0; i<ridge_point_N; i++){
		glBegin(GL_LINES);
		int *f = face[ridge_line[i][0].id];
		double t1 = ridge_line[i][0].u;
		double t2 = ridge_line[i][0].v;
		double t0 = 1.0 - t1 - t2;
		float last_p[3];
		last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
		last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
		last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
		for(int j=1; j<ridge_line_N[i]-2; j++){
			f = face[ridge_line[i][j].id];
			t1 = ridge_line[i][j].u;
			t2 = ridge_line[i][j].v;
			t0 = 1.0 - t1 - t2;
			float p[3];
			p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

			glVertex3fv(last_p);
			glVertex3fv(p);

			last_p[0] = p[0];
			last_p[1] = p[1];
			last_p[2] = p[2];
		}
		glEnd();
	}
*/
/*
	glColor3f(0, 0, 0);
	MeshData::tri_point **ravine_line = mesh->ravine_line;
	int *ravine_line_N = mesh->ravine_line_N;
	int ravine_point_N  = mesh->ravine_point_N;
	for(i=0; i<ravine_point_N; i++){
		glBegin(GL_LINES);
		int *f = face[ravine_line[i][0].id];
		double t1 = ravine_line[i][0].u;
		double t2 = ravine_line[i][0].v;
		double t0 = 1.0 - t1 - t2;
		float last_p[3];
		last_p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
		last_p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
		last_p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);
		for(int j=1; j<ravine_line_N[i]-2; j++){
			f = face[ravine_line[i][j].id];
			t1 = ravine_line[i][j].u;
			t2 = ravine_line[i][j].v;
			t0 = 1.0 - t1 - t2;
			float p[3];
			p[0] = (float)(t0*x[f[0]][0] + t1*x[f[1]][0] + t2*x[f[2]][0]);
			p[1] = (float)(t0*x[f[0]][1] + t1*x[f[1]][1] + t2*x[f[2]][1]);
			p[2] = (float)(t0*x[f[0]][2] + t1*x[f[1]][2] + t2*x[f[2]][2]);

			glVertex3fv(last_p);
			glVertex3fv(p);

			last_p[0] = p[0];
			last_p[1] = p[1];
			last_p[2] = p[2];
		}
		glEnd();
	}*/

	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	glColor3f(1.0f,1.0f,1.0f);
	for(i=0; i<face_N; i++){
		float p1[3], p2[3], p3[3];

		int i1 = face[i][0];
		int i2 = face[i][1];
		int i3 = face[i][2];

		p1[0] = x[i1][0] - 0.02f*normal[i1][0];
		p1[1] = x[i1][1] - 0.02f*normal[i1][1];
		p1[2] = x[i1][2] - 0.02f*normal[i1][2];

		p2[0] = x[i2][0] - 0.02f*normal[i2][0];
		p2[1] = x[i2][1] - 0.02f*normal[i2][1];
		p2[2] = x[i2][2] - 0.02f*normal[i2][2];

		p3[0] = x[i3][0] - 0.02f*normal[i3][0];
		p3[1] = x[i3][1] - 0.02f*normal[i3][1];
		p3[2] = x[i3][2] - 0.02f*normal[i3][2];

		glBegin(GL_POLYGON);
			glVertex3fv(p1);
			glVertex3fv(p2);
			glVertex3fv(p3);
		glEnd();
	}

	glEnable(GL_LIGHTING);
	delete[] d;
	delete[] spe;
}

void CMeshEditorView::drawPoints(MeshData *mesh)
{
	int vertex_N = mesh->vertex_N;
	float (*vertex)[3] = mesh->vertex;
	float (*normal)[3] = mesh->normal;
	int (*face)[3] = mesh->face;
	int face_N = mesh->face_N;

	glDisable(GL_LIGHTING);
	glColor3f(0,0,0); //(0.4f, 0.2f, 0.2f);
	glBegin(GL_POINTS);
	for(int i=0; i<vertex_N; i++)
		glVertex3fv(vertex[i]);
	glEnd();

	glColor3f(1,1,1);
	float d = (float)(0.05*view_angle/22.5);
	for(i=0; i<face_N; i++){
		if(face[i][0] < 0)
			continue;
	
		float p1[3], p2[3], p3[3];

		p1[0] = vertex[face[i][0]][0] - d*normal[face[i][0]][0];
		p1[1] = vertex[face[i][0]][1] - d*normal[face[i][0]][1];
		p1[2] = vertex[face[i][0]][2] - d*normal[face[i][0]][2];

		p2[0] = vertex[face[i][1]][0] - d*normal[face[i][1]][0];
		p2[1] = vertex[face[i][1]][1] - d*normal[face[i][1]][1];
		p2[2] = vertex[face[i][1]][2] - d*normal[face[i][1]][2];

		p3[0] = vertex[face[i][2]][0] - d*normal[face[i][2]][0];
		p3[1] = vertex[face[i][2]][1] - d*normal[face[i][2]][1];
		p3[2] = vertex[face[i][2]][2] - d*normal[face[i][2]][2];

		glBegin(GL_POLYGON);
			glVertex3fv(p1);
			glVertex3fv(p2);
			glVertex3fv(p3);
		glEnd();
	}
	glEnable(GL_LIGHTING);
}

void CMeshEditorView::convertToEdgeColorG(int n, double (*v)[3], float (*color)[3][3])
{
	double mid, vari;
	double S = 0;
	for(int i=0; i<n; i++)
		for(int j=0; j<3; j++) 
			S += v[i][j];
	mid = S/(double)(3*n);

	S = 0;
	for(i=0; i<n; i++)
		for(int j=0; j<3; j++) 
			S += (v[i][j]-mid)*(v[i][j]-mid);
	vari = sqrt(S/(double)(3*n));

	for(i = 0; i<n; i++){
		for(int j=0; j<3; j++){
			float s = (float)((v[i][j]-mid)/vari*1.5);
			float vv = (s+2.1f)/4.2f;
			if(vv > 1)
				vv = 1;
			else if(v < 0)
				vv = 0;
			color[i][j][0] = vv;
			color[i][j][1] = vv;
			color[i][j][2] = vv;
		}
	}
}

void CMeshEditorView::drawColoredTriangle(MeshData *mesh, float (*v)[3], BOOL gray)
{
	float (*vertex)[3] = mesh->vertex;
	int (*face)[3] = mesh->face;
	int face_N = mesh->face_N;
	int vertex_N = mesh->vertex_N;

	float (*color)[3] = new float[face_N][3];
	if(gray)
		convertToColorG(face_N, v, color);
	else
		convertToColor(face_N, v, color);

	glShadeModel(GL_SMOOTH);
	glDisable(GL_LIGHTING);
	
	for(int i=0; i<face_N; i++){
		glColor3fv(color[i]);

		glBegin(GL_POLYGON);
			glVertex3fv(vertex[ face[i][0] ]);
			glVertex3fv(vertex[ face[i][1] ]);
			glVertex3fv(vertex[ face[i][2] ]);	
		glEnd();
	} 
	glEnable(GL_LIGHTING);

	delete[] color;
}

void CMeshEditorView::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	// TODO: この位置にメッセージ ハンドラ用のコードを追加するかまたはデフォルトの処理を呼び出してください
	int x = point.x;
	int y = point.y;

	RECT* rect = new RECT;
	GetClientRect(rect);
	int sx = rect->right;
	int sy = rect->bottom;
	delete rect;

	float oy = 2.0f*(float)(MeshData::DIST(eye, center)*PI*tan(view_angle/360.0));
	float ox = oy*sx/sy;

	float lx = (x - sx/2)*ox/sx;
	float ly = (sy/2 - y)*oy/sy;

	float ex[3], ey[3], v[3];
	for(int i=0; i<3; i++)
		v[i] = (float)(center[i] - eye[i]);
	ey[0] =  -v[0] * v[2];
	ey[1] =  -v[1] * v[2];
	ey[2] =  v[0] * v[0] + v[1] * v[1];

	double norm = ey[0] * ey[0] + ey[1] * ey[1] + ey[2] * ey[2];
	norm = sqrt(norm);
	for(i=0; i<3; i++)
		ey[i] = (float)(ey[i] / norm);

	MeshData::CROSS(ex, v, ey);
	norm = MeshData::LENGTH(ex);
	ex[0] = (float)(ex[0]/norm);
	ex[1] = (float)(ex[1]/norm);
	ex[2] = (float)(ex[2]/norm);
	
	float ray_o[3];
	ray_o[0] = lx*ex[0] + ly*ey[0];
	ray_o[1] = lx*ex[1] + ly*ey[1];
	ray_o[2] = lx*ex[2] + ly*ey[2];

	float R[3][3], R1[3][3], R2[3][3], R3[3][3], tmp[3][3], view[3];
	GENERATE_MAT(R1, -(float)(PI*Rz/180.0f), vx);
	MAT_VEC(view, R1, vy);
	GENERATE_MAT(R2, -(float)(PI*Ry/180.0f), view);
	MAT_TIMES(tmp, R2, R1);
	MAT_VEC(view, tmp, vz);
	GENERATE_MAT(R3, -(float)(PI*Rx/180.0f), view);

	MAT_TIMES(R, R3, tmp);

	MAT_VEC(ray, R, ray_o);

	float shift_o[] = {shift_x, shift_y, shift_z};
	float shift[3];
	MAT_VEC(shift, R, shift_o);
	ray[0] -= shift[0];
	ray[1] -= shift[1];
	ray[2] -= shift[2];

	float start_o[3];
	start_o[0] = (float)eye[0];
	start_o[1] = (float)eye[1];
	start_o[2] = (float)eye[2];
	MAT_VEC(start, R, start_o);
	start[0] -= shift[0];
	start[1] -= shift[1];
	start[2] -= shift[2];

	ray[0] = ray[0] - start[0];
	ray[1] = ray[1] - start[1];
	ray[2] = ray[2] - start[2];
	double len = MeshData::LENGTH(ray);
	ray[0] = (float)(ray[0]/len);
	ray[1] = (float)(ray[1]/len);
	ray[2] = (float)(ray[2]/len);

	CMeshEditorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	pDoc->selectTriangle(start, ray);

	/*
	CClientDC* dc = new CClientDC(this);
	OnDraw(dc);
	delete dc;
	*/

	CView::OnLButtonDblClk(nFlags, point);
}

void CMeshEditorView::drawPickedPoint()
{
	glDisable(GL_LIGHTING);
	glColor3f(1.0f, 0.0f, 0.0f);
	glBegin(GL_POINTS);
	glVertex3fv(ray);
	glEnd();

	glBegin(GL_LINES);
	glColor3f(1.0f, 0.0f, 0.0f);
	glVertex3fv(ray);
	glVertex3fv(start);
	glEnd();

	glEnable(GL_LIGHTING);
}

void CMeshEditorView::drawGaussianSupport(MeshData *mesh)
{
	glShadeModel(GL_SMOOTH);

	int face_N = mesh->face_N;
	int (*face)[3] = mesh->face;
	float (*normal_f)[3] = mesh->normal_f;
	float (*vertex)[3] = mesh->vertex;
	int *id = mesh->triangle_id;
	int (*link)[3] = mesh->face_link_E;
	float (*normal)[3] = mesh->normal;

	for(int i=0; i<face_N; i++){
		if(face[i][0] < 0 || id[i] >= 0)
			continue;
		glBegin(GL_POLYGON);
			glNormal3fv(normal_f[i]);
			glVertex3fv(vertex[face[i][0]]);
			glVertex3fv(vertex[face[i][1]]);
			glVertex3fv(vertex[face[i][2]]);
		glEnd();
	}

	float d = (float)(0.05*view_angle/22.5);

	glDisable(GL_LIGHTING);
	for(i=0; i<face_N; i++){
		if(face[i][0] < 0 || id[i] < 0)
			continue;
		glBegin(GL_POLYGON);
		/*
			if(id[i] == 0)
				glColor3f(1,0,0);
			else if(id[i] == 1)
				glColor3f(0,1,0);
			else
				glColor3f(0,0,1);
				*/
			float c = 1.0f - id[i]/255.0f;
			glColor3f(c, c, c);
			glVertex3fv(vertex[face[i][0]]);
			glVertex3fv(vertex[face[i][1]]);
			glVertex3fv(vertex[face[i][2]]);
		glEnd();
		
		if(id[i] >= 255.0f){
			glEnable(GL_LIGHTING);
			glColor3f(0.5f, 0.5f, 0.5f);
			sphere(0.2f, mesh->center[i], 10);
			glDisable(GL_LIGHTING);
			//glBegin(GL_POINTS);
				//glVertex3fv(mesh->center[i]);
			//glEnd();
		}

		int *l = link[i];
		for(int j=0; j<3; j++){
			if(l[j] < 0)
				continue;
			if(id[l[j]] >= 0)
				continue;
			float p1[3], p2[3];
			int i1 = face[i][j];
			int i2 = face[i][(j+1)%3];
			p1[0] = vertex[i1][0] + d*normal[i1][0];
			p1[1] = vertex[i1][1] + d*normal[i1][1];
			p1[2] = vertex[i1][2] + d*normal[i1][2];
			p2[0] = vertex[i2][0] + d*normal[i2][0];
			p2[1] = vertex[i2][1] + d*normal[i2][1];
			p2[2] = vertex[i2][2] + d*normal[i2][2];
			glBegin(GL_LINES);
				glColor3f(0,0,0);
				glVertex3fv(p1);
				glVertex3fv(p2);
			glEnd();
		}
	}
	glEnable(GL_LIGHTING);
	
}

void CMeshEditorView::drawScaleMap(MeshData *mesh, float *sigma)
{
	glShadeModel(GL_SMOOTH);

	int face_N = mesh->face_N;
	int (*face)[3] = mesh->face;
	float (*vertex)[3] = mesh->vertex;

	glDisable(GL_LIGHTING);
	for(int i=0; i<face_N; i++){
		if(face[i][0] < 0)
			continue;
		glBegin(GL_POLYGON);
			float c = sigma[i];
			glColor3f(c, c, c);
			glVertex3fv(vertex[face[i][0]]);
			glVertex3fv(vertex[face[i][1]]);
			glVertex3fv(vertex[face[i][2]]);
		glEnd();
	}
	glEnable(GL_LIGHTING);
}

void CMeshEditorView::drawDualGraph(MeshData *mesh)
{
	glShadeModel(GL_SMOOTH);

	int face_N = mesh->face_N;
	int (*face)[3] = mesh->face;
	float (*vertex)[3] = mesh->vertex;
	float (*normal)[3] = mesh->normal;
	float d = (float)(0.05*view_angle/22.5);
	float (*center)[3] = mesh->center;
	float (*normal_f)[3] = mesh->normal_f;

	glDisable(GL_LIGHTING);
	
	glColor3f(0,0,0);
	for(int i=0; i<face_N; i++){
		if(face[i][0] < 0)
			continue;
		float *c = center[i];
		for(int j=0; j<3; j++){
			float m[3];
			float *p1 = vertex[face[i][j]];
			float *p2 = vertex[face[i][(j+1)%3]];
			m[0] = 0.5f*(p1[0] + p2[0]);
			m[1] = 0.5f*(p1[1] + p2[1]);
			m[2] = 0.5f*(p1[2] + p2[2]);
			glBegin(GL_LINES);
				glVertex3fv(c);
				glVertex3fv(m);
			glEnd();
		}
	}
	glEnable(GL_LIGHTING);
	for(i=0; i<face_N; i++){
		if(face[i][0] < 0)
			continue;
		float p1[3], p2[3], p3[3];
		int i1 = face[i][0];
		int i2 = face[i][1];
		int i3 = face[i][2];
		p1[0] = vertex[i1][0] - d*normal[i1][0];
		p1[1] = vertex[i1][1] - d*normal[i1][1];
		p1[2] = vertex[i1][2] - d*normal[i1][2];
		p2[0] = vertex[i2][0] - d*normal[i2][0];
		p2[1] = vertex[i2][1] - d*normal[i2][1];
		p2[2] = vertex[i2][2] - d*normal[i2][2];
		p3[0] = vertex[i3][0] - d*normal[i3][0];
		p3[1] = vertex[i3][1] - d*normal[i3][1];
		p3[2] = vertex[i3][2] - d*normal[i3][2];

		glBegin(GL_POLYGON);
			glNormal3fv(normal_f[i]);
			glVertex3fv(p1);
			glVertex3fv(p2);
			glVertex3fv(p3);
		glEnd();
	}
}

void CMeshEditorView::drawRidgeL(MeshData *mesh, BOOL transparent, BOOL gray_scale)
{
	glShadeModel(GL_SMOOTH);

	glDisable(GL_LIGHTING);

	RList* ridge = mesh->ridge_L;
	RList* ravine = mesh->ravine_L;

	
	if(gray_scale)
		glColor3f(0,0,0);
	else
		glColor3f(1,0,0);
	for(RList* l=ridge; l->next!= NULL; l=l->next){
		if(!l->vis)
			continue;
		glLineWidth(sqrt(l->k1*l->k2));
		glBegin(GL_LINES);
			glVertex3fv(l->p1);
			glVertex3fv(l->p2);
		glEnd();
	}

	if(gray_scale)
		glColor3f(1,1,1);
	else
		glColor3f(0,0,1);
	for(l=ravine; l->next!= NULL; l=l->next){
		if(!l->vis)
			continue;
		glLineWidth(sqrt(l->k1*l->k2));
		glBegin(GL_LINES);
			glVertex3fv(l->p1);
			glVertex3fv(l->p2);
		glEnd();
	}
	
	if(!transparent){
		glEnable(GL_LIGHTING);
		int vertex_N = mesh->vertex_N;
		float (*vertex)[3] = mesh->vertex;

		int face_N = mesh->face_N;
		int (*face)[3] = mesh->face;

		float (*normal)[3] = mesh->normal;

		/*
		if(gray_scale)
			glColor3f(0.7f, 0.7f, 0.7f);
		else
			glColor3f(0.9f,0.9f,0.9f);
		*/
		for(int i=0; i<face_N; i++){
			float p1[3], p2[3], p3[3];

			int i1 = face[i][0];
			int i2 = face[i][1];
			int i3 = face[i][2];

			p1[0] = vertex[i1][0] - 0.05f*normal[i1][0];
			p1[1] = vertex[i1][1] - 0.05f*normal[i1][1];
			p1[2] = vertex[i1][2] - 0.05f*normal[i1][2];

			p2[0] = vertex[i2][0] - 0.05f*normal[i2][0];
			p2[1] = vertex[i2][1] - 0.05f*normal[i2][1];
			p2[2] = vertex[i2][2] - 0.05f*normal[i2][2];

			p3[0] = vertex[i3][0] - 0.05f*normal[i3][0];
			p3[1] = vertex[i3][1] - 0.05f*normal[i3][1];
			p3[2] = vertex[i3][2] - 0.05f*normal[i3][2];

			glBegin(GL_POLYGON);
				glNormal3fv(mesh->normal_f[i]);
				//glNormal3fv(normal[i1]);
				glVertex3fv(p1);
				//glNormal3fv(normal[i2]);
				glVertex3fv(p2);
				//glNormal3fv(normal[i3]);
				glVertex3fv(p3);
			glEnd();
		}	
	}
}

void CMeshEditorView::drawRidgeS(MeshData *mesh, BOOL transparent, BOOL gray_scale,
								 float T_ridge, float T_ravine, float width)
{
	glShadeModel(GL_SMOOTH);

	glDisable(GL_LIGHTING);

	RHead* ridge = mesh->ridge_S;
	RHead* ravine = mesh->ravine_S;

	
	if(gray_scale)
		glColor3f(1,1,1);
	else
		glColor3f(1,0,0);
	//glColor3f(0,0,0);
	for(RHead* l=ridge; l->next!= NULL; l=l->next){
		if(l->strength < T_ridge)
			continue;

		for(REdge* e=l->head; e->next!=NULL; e=e->next){
			float w = width*e->k;
			//if(w > 20.0f)
			//	w = 20.0f;
			glLineWidth(w);
			//glLineWidth(width*e->k);
			//glBegin(GL_POINTS);
			glBegin(GL_LINES);
			  glVertex3fv(e->p1);
			  glVertex3fv(e->p2);
			glEnd();
		}
		/*
		RPoint* p=l->head;
		do{
			glLineWidth(0.5*sqrt(p->k*p->next->k));
			glBegin(GL_LINES);
			  glVertex3fv(p->p);
			  glVertex3fv(p->next->p);
			glEnd();
			p = p->next;
		}while(p->next != NULL && p != l->head);*/
	}

	if(gray_scale)
		glColor3f(0,0,0);
		//glColor3f(0.5,0.5,0.5);
		//glColor3f(0.7,0.7,0.7);
	else
		glColor3f(0,0,1);
	//glColor3f(0,0,0);
	for(l=ravine; l->next!= NULL; l=l->next){
		if(l->strength < T_ravine)
			continue;

		for(REdge* e=l->head; e->next!=NULL; e=e->next){
			float w = -width*e->k;
			//if(w > 20.0f)
			//	w = 20.0f;
			glLineWidth(w);
			//glBegin(GL_POINTS);
			glBegin(GL_LINES);
			  glVertex3fv(e->p1);
			  glVertex3fv(e->p2);
			glEnd();
		}

		/*
		RPoint* p=l->head;
		do{
			glLineWidth(0.5*sqrt(p->k*p->next->k));
			glBegin(GL_LINES);
			  glVertex3fv(p->p);
			  glVertex3fv(p->next->p);
			glEnd();
			p = p->next;
		}while(p->next != NULL && p != l->head);*/
	}
	
	if(!transparent){
		glEnable(GL_LIGHTING);
		int vertex_N = mesh->vertex_N;
		float (*vertex)[3] = mesh->vertex;

		int face_N = mesh->face_N;
		int (*face)[3] = mesh->face;

		float (*normal)[3] = mesh->normal;

		
		if(gray_scale)
			glColor3f(0.7f, 0.7f, 0.7f);
		else
			glColor3f(0.9f,0.9f,0.9f);

		//glColor3f(1,1,1);
		float d = (float)(0.05*view_angle/22.5);
		for(int i=0; i<face_N; i++){
			float p1[3], p2[3], p3[3];

			int i1 = face[i][0];
			int i2 = face[i][1];
			int i3 = face[i][2];

			p1[0] = vertex[i1][0] - d*normal[i1][0];
			p1[1] = vertex[i1][1] - d*normal[i1][1];
			p1[2] = vertex[i1][2] - d*normal[i1][2];

			p2[0] = vertex[i2][0] - d*normal[i2][0];
			p2[1] = vertex[i2][1] - d*normal[i2][1];
			p2[2] = vertex[i2][2] - d*normal[i2][2];

			p3[0] = vertex[i3][0] - d*normal[i3][0];
			p3[1] = vertex[i3][1] - d*normal[i3][1];
			p3[2] = vertex[i3][2] - d*normal[i3][2];

			glBegin(GL_POLYGON);
				glNormal3fv(mesh->normal_f[i]);
				//glNormal3fv(normal[i1]);
				glVertex3fv(p1);
				//glNormal3fv(normal[i2]);
				glVertex3fv(p2);
				//glNormal3fv(normal[i3]);
				glVertex3fv(p3);
			glEnd();
		}	
		glEnable(GL_LIGHTING);
	}
}