// FileManager.cpp: FileManager クラスのインプリメンテーション
//
//////////////////////////////////////////////////////////////////////

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

#include "MeshData.h"

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

//////////////////////////////////////////////////////////////////////
// 構築/消滅
//////////////////////////////////////////////////////////////////////

FileManager::FileManager()
{

}

FileManager::~FileManager()
{

}

void FileManager::open(MeshData *mesh)
{
	//read cloud data file and perform trianlization.
	if(file_ext == "data"){
		this->openCloud(mesh);
	}
	//read vertex data from ply file
	else if(file_ext == "ply"){
		this->openPly(mesh);
	}
	//read vertex data from ply2 file(my original format)
	else if(file_ext == "ply2"){
		this->openOriginal(mesh);
	}
	//read vertex data from obj file(may be wave-front file)
	else if(file_ext == "obj"){
		this->openWaveFront(mesh);
	}
	else if(file_ext == "plyR"){
		this->openRidge(mesh);
	}
	else if(file_ext == "plyHK"){
		this->openOriginalHK(mesh);
	}
	else if(file_ext == "plyTN"){
		this->openOriginalTN(mesh);
	}
	else if(file_ext == "plyRD"){
		this->openOriginalRD(mesh);
	}
	else if(file_ext == "mwnB"){
		this->openMwnB(mesh);
	}
	mesh->normalizeScale();
	mesh->generateVertexLink();
	mesh->generateFaceLink();
}

void FileManager::setFile(FILE *file, CString file_name, CString file_ext)
{
	this->file =  file;
	this->file_name = file_name;
	this->file_ext = file_ext;
}

void FileManager::openCloud(MeshData *mesh)
{
	int vertex_N;
	fscanf(file, "%d", &vertex_N);

	mesh->setVertexCount(vertex_N);
	float p[3];
	for(int i=0; i<vertex_N; i++){
		fscanf(file, "%f", &p[0]);
		fscanf(file, "%f", &p[1]);
		fscanf(file, "%f", &p[2]);
		mesh->setVertex(i, p);
	}
	//generateFaceFromPoints();
}

void FileManager::openPly(MeshData *mesh)
{
	int vertex_N, face_N;

	fscanf(file, "%d", &vertex_N);
	mesh->setVertexCount(vertex_N);

	fscanf(file, "%d", &face_N);
	mesh->setFaceCount(face_N);

	float p[3];
	float dummy;
	for(int i=0; i<vertex_N; i++){
		fscanf(file, "%f", &p[0]);
		fscanf(file, "%f", &p[2]);
		fscanf(file, "%f", &p[1]);
		mesh->setVertex(i, p);

		//skip extra data
		fscanf(file, "%f", &dummy);
		fscanf(file, "%f", &dummy);
	}

	int f[3];
	for(i=0; i<face_N; i++){
		fscanf(file, "%f", &dummy);
		fscanf(file, "%d", &f[0]);
		fscanf(file, "%d", &f[1]);
		fscanf(file, "%d", &f[2]);
		mesh->setFace(i, f);
	}
}

void FileManager::openOriginal(MeshData *mesh)
{
	int vertex_N, face_N;

	fscanf(file, "%d", &vertex_N);
	mesh->setVertexCount(vertex_N);

	fscanf(file, "%d", &face_N);
	mesh->setFaceCount(face_N);

	float p[3];
	float dummy;
	for(int i=0; i<vertex_N; i++){
		fscanf(file, "%f", &p[0]);
		fscanf(file, "%f", &p[1]);
		fscanf(file, "%f", &p[2]);
		//p[0] *= -1;
		mesh->setVertex(i, p);
	}

	int f[3];
	for(i=0; i<face_N; i++){
		fscanf(file, "%f", &dummy);
		fscanf(file, "%d", &f[0]);
		fscanf(file, "%d", &f[1]);
		fscanf(file, "%d", &f[2]);
		mesh->setFace(i, f);
	}
}

void FileManager::openWaveFront(MeshData *mesh)
{
	/*
	char dummyS[10];
		fscanf(file, "%s", dummyS);
		fscanf(file, "%s", dummyS);
		fscanf(file, "%d", &(mesh->vertex_N));
		fscanf(file, "%s", dummyS);

		fscanf(file, "%s", dummyS);
		fscanf(file, "%s", dummyS);
		fscanf(file, "%s", dummyS);
		fscanf(file, "%d", &(mesh->face_N));
		fscanf(file, "%s", dummyS);

		mesh->vertex = new float[mesh->vertex_N][3];
		*/
}

void FileManager::openRidge(MeshData *mesh)
{
	int vertex_N, face_N;

	fscanf(file, "%d", &vertex_N);
	mesh->setVertexCount(vertex_N);

	fscanf(file, "%d", &face_N);
	mesh->setFaceCount(face_N);

	float p[3];
	float dummy;
	for(int i=0; i<vertex_N; i++){
		fscanf(file, "%f", &p[0]);
		fscanf(file, "%f", &p[1]);
		fscanf(file, "%f", &p[2]);
		//p[0] *= -1;
		mesh->setVertex(i, p);
	}

	int f[3];
	for(i=0; i<face_N; i++){
		fscanf(file, "%f", &dummy);
		fscanf(file, "%d", &f[0]);
		fscanf(file, "%d", &f[1]);
		fscanf(file, "%d", &f[2]);
		mesh->setFace(i, f);
	}

	BOOL* isRidge = mesh->isRidge = new BOOL[vertex_N];
	BOOL* isRavine = mesh->isRavine = new BOOL[vertex_N];
	for(i=0; i<vertex_N ; i++){
		isRidge[i] = false;
		isRavine[i] = false;
	}

	int ridge_N;
	fscanf(file, "%d", &ridge_N);
	int ravine_N;
	fscanf(file, "%d", &ravine_N);
	for(i=0; i<ridge_N; i++){
		int index;
		fscanf(file, "%d", &index);
		isRidge[index] = true;
	}
	for(i=0; i<ravine_N; i++){
		int index;
		fscanf(file, "%d", &index);
		isRavine[index] = true;
	}
}

void FileManager::save(MeshData *mesh)
{
	if(file_ext == "ply2"){
		this->saveOriginal(mesh);
	}
	else if(file_ext == "plyR"){
		this->saveRidge(mesh);
	}
	else if(file_ext == "pwn"){
		if(mesh->ridge_tri == NULL)
			savePointWithNormal(mesh);
			//savePointWithNormalV(mesh);
		else
			saveRidgePointWithNormal(mesh);
	}
}

void FileManager::saveOriginal(MeshData *mesh)
{
	int f_N = mesh->countValidFace();
	int v_N = mesh->countValidVertex();
	int* vertex_table = new int[mesh->vertex_N];
	int counter = 0;

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

	fprintf(file, "%d\n", v_N);
	fprintf(file, "%d\n", f_N);
	for(int i=0; i<vertex_N; i++){
		if(mesh->degree_v[i] != 0){
			fprintf(file, "%f ", vertex[i][0]);
			fprintf(file, "%f ", vertex[i][1]);
			fprintf(file, "%f\n", vertex[i][2]);
			vertex_table[i] = counter;
			counter++;
		}
		else
			vertex_table[i] = -1;
	}
	for(i=0; i<face_N; i++){
		if(mesh->face[i][0] >= 0){
			fprintf(file, "3 ");
			fprintf(file, "%d ", vertex_table[face[i][0]]);
			fprintf(file, "%d ", vertex_table[face[i][1]]);
			fprintf(file, "%d\n", vertex_table[face[i][2]]);
		}
	}
	delete[] vertex_table;
}

void FileManager::saveRidge(MeshData *mesh)
{
	int f_N = mesh->countValidFace();
	int v_N = mesh->countValidVertex();
	int* vertex_table = new int[mesh->vertex_N];
	int counter = 0;

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

	fprintf(file, "%d\n", v_N);
	fprintf(file, "%d\n", f_N);
	for(int i=0; i<vertex_N; i++){
		if(mesh->degree_v[i] != 0){
			fprintf(file, "%f ", vertex[i][0]);
			fprintf(file, "%f ", vertex[i][1]);
			fprintf(file, "%f\n", vertex[i][2]);
			vertex_table[i] = counter;
			counter++;
		}
		else
			vertex_table[i] = -1;
	}
	for(i=0; i<face_N; i++){
		if(mesh->face[i][0] >= 0){
			fprintf(file, "3 ");
			fprintf(file, "%d ", vertex_table[face[i][0]]);
			fprintf(file, "%d ", vertex_table[face[i][1]]);
			fprintf(file, "%d\n", vertex_table[face[i][2]]);
		}
	}

	int ridge_N = 0;
	int ravine_N = 0;
	for(i=0; i<vertex_N; i++){
		if(mesh->isRidge[i])
			ridge_N++;
		if(mesh->isRavine[i])
			ravine_N++;
	}
	fprintf(file, "%d\n", ridge_N);
	fprintf(file, "%d\n", ravine_N);
	for(i=0; i<vertex_N; i++)
		if(mesh->isRidge[i])
			fprintf(file, "%d\n", vertex_table[i]);
	for(i=0; i<vertex_N; i++)
		if(mesh->isRavine[i])
			fprintf(file, "%d\n", vertex_table[i]);

	delete[] vertex_table;
}

void FileManager::savePointWithNormal(MeshData *mesh)
{
	int f_N = mesh->countValidFace();

	mesh->computeCenter();
	float (*vertex)[3] = mesh->vertex;
	float (*point)[3] = mesh->center;
	float (*normal)[3] = mesh->normal_f;
	int (*face)[3] = mesh->face;
	bool *isOK = new bool[f_N];
	int valid = 0;
	BOOL *isBound = mesh->isBound;
	int face_N = mesh->face_N;

	for(int i=0; i<face_N; i++){
		if(face[i][0] < 0)// || SHAPE(vertex[face[i][0]], vertex[face[i][1]], vertex[face[i][2]]) < 0.5 ||
			//isBound[face[i][0]] || isBound[face[i][1]] || isBound[face[i][2]])
			isOK[i] = false;
		else{
			isOK[i] = true;
			valid++;
		}
	}

	fprintf(file, "%d\n", valid);
	for(i=0; i<face_N; i++){
		if(face[i][0] >= 0 && isOK[i]){
			fprintf(file, "%f %f %f\n", point[i][0], point[i][1], point[i][2]);
		}
	}
	for(i=0; i<face_N; i++){
		if(face[i][0] >= 0 && isOK[i]){
			fprintf(file, "%f %f %f\n", normal[i][0], normal[i][1], normal[i][2]);
		}
	}
	delete[] isOK;
}

void FileManager::saveRidgePointWithNormal(MeshData *mesh)
{
	int f_N = mesh->countValidFace();

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

	int c = 0;
	for(int i=0; i<face_N; i++){
		if(face[i][0] >= 0 && (mesh->ridge_tri[i] || mesh->ravine_tri[i]))
			c++;
	}
	fprintf(file, "%d\n", c);
	for(i=0; i<face_N; i++){
		if(face[i][0] >= 0 && (mesh->ridge_tri[i] || mesh->ravine_tri[i])){
			fprintf(file, "%f %f %f\n", point[i][0], point[i][1], point[i][2]);
		}
	}
	for(i=0; i<face_N; i++){
		if(face[i][0] >= 0 && (mesh->ridge_tri[i] || mesh->ravine_tri[i])){
			fprintf(file, "%f %f %f\n", normal[i][0], normal[i][1], normal[i][2]);
		}
	}
}

void FileManager::savePointWithNormalV(MeshData *mesh)
{
	int v_N = mesh->countValidVertex();

	int i;
	int bv_N = 0;
	/*
	for(i=0; i<mesh->vertex_N; i++){
		if(mesh->isBound[i] != INNER && mesh->isBound[i] != BOUNDARY)
			bv_N++;
	}*/

	mesh->computeNormal();
	float (*point)[3] = mesh->vertex;
	float (*normal)[3] = mesh->normal;
	int *degree = mesh->degree_v;
	
	int vertex_N = mesh->vertex_N;

	
	float n[3] = {0, 0, 0};
	for(i=0; i<vertex_N; i++){
		n[0] += normal[i][0];
		n[1] += normal[i][1];
		n[2] += normal[i][2];
	}
	double len = sqrt(n[0]*n[0] + n[1]*n[1] + n[2]*n[2]);
	n[0] = (float)(n[0]/len);
	n[1] = (float)(n[1]/len);
	n[2] = (float)(n[2]/len);

	fprintf(file, "%d\n", vertex_N-bv_N);
	for(i=0; i<vertex_N; i++){
		if(true){//mesh->isBound[i] == INNER || mesh->isBound[i] == BOUNDARY){ // && mesh->isBound[i] == INNER){
			fprintf(file, "%f %f %f\n", point[i][0], point[i][1], point[i][2]);
		}
	}

	int *B = new int[vertex_N];
	int *B_tmp = new int[vertex_N];
	int BN = 100;
	for(i=0; i<vertex_N; i++){
	  if(mesh->isBound[i] != INNER)
		  B[i] = 1;
	  else
		  B[i] = BN;
	}
	for(i=0; i<BN-2; i++){
        for(int j=0; j<vertex_N; j++){
			B_tmp[j] = B[j];
			int* nei = mesh->vertex_link_v[j];
			int neiN = mesh->degree_v[j];
			for(int k=0; k<neiN; k++){
				if(B[nei[k]] < B[j]){
					B_tmp[j] = B[j]-1;
					break;
				}
			}
		}
		for(j=0; j<vertex_N; j++)
			B[j] = B_tmp[j];
	}
    for(i=0; i<vertex_N; i++){
		if(true){//mesh->isBound[i] == INNER || mesh->isBound[i] == BOUNDARY){ // && mesh->isBound[i] == INNER){
			float dot = normal[i][1];//n[0]*normal[i][0] + n[1]*normal[i][1] + n[2]*normal[i][2];
			if(dot < 0)
				dot = -dot;
			dot *= dot;
			fprintf(file, "%f\n", dot*B[i]/(float)BN);
		}
	}
	delete[] B;
	delete[] B_tmp;

    //srand(100);
	for(i=0; i<vertex_N; i++){
		if(true){//mesh->isBound[i] == INNER || mesh->isBound[i] == BOUNDARY){ // && mesh->isBound[i] == INNER){
			/*
			if(i%5 == 0){
				normal[i][0] = normal[i][1] = normal[i][2] = 0;
			}
			else if((i+1)%5 == 0){
				normal[i][0] = -normal[i][0];
				normal[i][1] = -normal[i][1];
				normal[i][2] = -normal[i][2];
			}*/
			//double L[3];
			//mesh->meanCurvatureNormal(i, L);
            //fprintf(file, "%f %f %f\n", L[0], L[1], L[2]);
			fprintf(file, "%f %f %f\n", normal[i][0], normal[i][1], normal[i][2]);
            /*
			float nx = normal[i][0] + 0.5f*(2.0f*rand()/RAND_MAX - 1.0f);
			float ny = normal[i][1] + 0.5f*(2.0f*rand()/RAND_MAX - 1.0f);
			float nz = normal[i][2] + 0.5f*(2.0f*rand()/RAND_MAX - 1.0f);
			double len = sqrt(nx*nx + ny*ny + nz*nz);
			if(len != 0){
				nx /= len;
				ny /= len;
				nz /= len;
			}
			else
				nx = ny = nz = 0;
            fprintf(file, "%f %f %f\n", nx, ny, nz);*/

		}
	}
}

void FileManager::openOriginalHK(MeshData *mesh)
{
	int vertex_N, face_N;

	fscanf(file, "%d", &vertex_N);
	mesh->setVertexCount(vertex_N);

	fscanf(file, "%d", &face_N);
	mesh->setFaceCount(face_N);

	float p[3];
	float dummy;
	for(int i=0; i<vertex_N; i++){
		fscanf(file, "%f", &p[0]);
		fscanf(file, "%f", &p[1]);
		fscanf(file, "%f", &p[2]);
		//p[0] *= -1;
		mesh->setVertex(i, p);
	}

	int f[3];
	for(i=0; i<face_N; i++){
		fscanf(file, "%f", &dummy);
		fscanf(file, "%d", &f[0]);
		fscanf(file, "%d", &f[1]);
		fscanf(file, "%d", &f[2]);
		mesh->setFace(i, f);
	}

	mesh->k_max = new double[vertex_N];
	mesh->k_min = new double[vertex_N];
	for(i=0; i<vertex_N; i++){
		fscanf(file, "%lf", &mesh->k_max[i]);
		fscanf(file, "%lf", &mesh->k_min[i]);
		mesh->k_max[i] = -mesh->k_max[i];
	}
}

void FileManager::openOriginalTN(MeshData *mesh)
{
	int vertex_N, face_N;

	fscanf(file, "%d", &vertex_N);
	mesh->setVertexCount(vertex_N);

	fscanf(file, "%d", &face_N);
	mesh->setFaceCount(face_N);

	float p[3];
	float dummy;
	for(int i=0; i<vertex_N; i++){
		fscanf(file, "%f", &p[0]);
		fscanf(file, "%f", &p[1]);
		fscanf(file, "%f", &p[2]);
		//p[0] *= -1;
		mesh->setVertex(i, p);
	}

	int f[3];
	for(i=0; i<face_N; i++){
		fscanf(file, "%f", &dummy);
		fscanf(file, "%d", &f[0]);
		fscanf(file, "%d", &f[1]);
		fscanf(file, "%d", &f[2]);
		mesh->setFace(i, f);
	}

	mesh->k_max = new double[vertex_N];
	mesh->k_min = new double[vertex_N];
	double (*t_max)[3] = mesh->t_max = new double[vertex_N][3];
	double (*t_min)[3] = mesh->t_min = new double[vertex_N][3];
	for(i=0; i<vertex_N; i++){
		fscanf(file, "%lf", &mesh->k_max[i]);
		fscanf(file, "%lf", &mesh->k_min[i]);
	    
		
		//mesh->k_min[i] = -mesh->k_min[i];
		//mesh->k_max[i] = -mesh->k_max[i];
		
		fscanf(file, "%lf %lf %lf", &mesh->t_max[i][0], &mesh->t_max[i][1], &mesh->t_max[i][2]);
		fscanf(file, "%lf %lf %lf", &mesh->t_min[i][0], &mesh->t_min[i][1], &mesh->t_min[i][2]);
			
	}

	mesh->computeNormal();
	float (*normal)[3] = mesh->normal;
	for(i=0; i<vertex_N; i++){
		double n[3];
		MeshData::CROSS(n, normal[i], t_max[i]);
		if(MeshData::DOT(n, t_min[i])< 0){
			t_min[i][0] = -t_min[i][0];
			t_min[i][1] = -t_min[i][1];
			t_min[i][2] = -t_min[i][2];
		}	
	}
}

void FileManager::openOriginalRD(MeshData *mesh)
{
	int vertex_N, face_N;

	fscanf(file, "%d", &vertex_N);
	mesh->setVertexCount(vertex_N);

	fscanf(file, "%d", &face_N);
	mesh->setFaceCount(face_N);

	float p[3];
	float dummy;
	for(int i=0; i<vertex_N; i++){
		fscanf(file, "%f", &p[0]);
		fscanf(file, "%f", &p[1]);
		fscanf(file, "%f", &p[2]);
		//p[0] *= -1;
		mesh->setVertex(i, p);
	}

	int f[3];
	for(i=0; i<face_N; i++){
		fscanf(file, "%f", &dummy);
		fscanf(file, "%d", &f[0]);
		fscanf(file, "%d", &f[1]);
		fscanf(file, "%d", &f[2]);
		mesh->setFace(i, f);
	}

	mesh->k_max = new double[vertex_N];
	mesh->k_min = new double[vertex_N];
	mesh->r_max = new double[vertex_N];
	mesh->r_min = new double[vertex_N];
	double dummyD;

	mesh->d_max = new double[vertex_N];
	mesh->d_min = new double[vertex_N];

	double (*t_max)[3] = mesh->t_max = new double[vertex_N][3];
	double (*t_min)[3] = mesh->t_min = new double[vertex_N][3];
	for(i=0; i<vertex_N; i++){
		fscanf(file, "%lf", &mesh->k_max[i]);
		fscanf(file, "%lf", &mesh->k_min[i]);
	    
		fscanf(file, "%lf", &mesh->r_max[i]);
		fscanf(file, "%lf", &mesh->r_min[i]);

		//fscanf(file, "%lf", &dummyD);
		//fscanf(file, "%lf", &dummyD);

		fscanf(file, "%lf", &mesh->d_max[i]);
		fscanf(file, "%lf", &mesh->d_min[i]);

		fscanf(file, "%lf %lf %lf", &mesh->t_max[i][0], &mesh->t_max[i][1], &mesh->t_max[i][2]);
		fscanf(file, "%lf %lf %lf", &mesh->t_min[i][0], &mesh->t_min[i][1], &mesh->t_min[i][2]);
		
		//mesh->k_min[i] = -mesh->k_min[i];
		//mesh->k_max[i] = -mesh->k_max[i];
	}
}

void FileManager::saveDualMesh(MeshData* mesh){
	int vertexN = mesh->vertex_N;
	int faceN = mesh->face_N;
	int **link = mesh->vertex_link_f;
	int *degree = mesh->degree_f;

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

	fprintf(file, "%d\n%d\n", faceN, vertexN);
	for(int i=0; i<faceN; i++){
		fprintf(file, "%f %f %f\n", center[i][0], center[i][1], center[i][2]);
	}

	for(i=0; i<vertexN; i++){
		int deg = degree[i];
		fprintf(file, "%d", deg);
		for(int j=0; j<deg; j++){
			fprintf(file, " %d", link[i][j]);
		}
		fprintf(file, "\n");
	}
}

void FileManager::openMwnB(MeshData *mesh)
{
	fclose(file);
	file = fopen(file_name, "r+b");

	int vertex_N, face_N;
	int N[2];
	fread(N, sizeof(int), 2, file);
	vertex_N = N[0];
	face_N = N[1];
	mesh->setVertexCount(vertex_N);
	mesh->setFaceCount(face_N);

	float *tmp_v = new float[3*vertex_N];
	fread(tmp_v, sizeof(float), vertex_N*3, file);

	float p[3];
	for(int i=0; i<vertex_N; i++){
		int j = 3*i;
		p[0] = tmp_v[j++];
		p[1] = tmp_v[j++];
		p[2] = tmp_v[j  ];
		mesh->setVertex(i, p);
	}

	int *tmp_f = new int[3*face_N];
	fread(tmp_f, sizeof(int), face_N*3, file);

	int f[3];
	for(i=0; i<face_N; i++){
		int j = 3*i;
		f[0] = tmp_f[j++];
		f[1] = tmp_f[j++];
		f[2] = tmp_f[j  ];
		mesh->setFace(i, f);
	}

	delete[] tmp_f;

	fread(tmp_v, sizeof(float), vertex_N*3, file);
	mesh->computeNormal();
	for(i=0; i<vertex_N; i++){
		float* n = mesh->normal[i];
		int j = 3*i;
		n[0] = tmp_v[j++];
		n[1] = tmp_v[j++];
		n[2] = tmp_v[j  ];
	}
}

void FileManager::saveRR(MeshData *mesh)
{
	RHead* ridge = mesh->ridge_S;
	RHead* ravine = mesh->ravine_S;

	float T = 2;
	int count = 0;
	for(RHead* l=ridge; l->next!= NULL; l=l->next){
		if(l->strength < 2)
			continue;
		for(REdge* e=l->head; e->next!=NULL; e=e->next){
			count++;
		}
	}

	for(l=ravine; l->next!= NULL; l=l->next){
		if(l->strength < 2)
			continue;
		for(REdge* e=l->head; e->next!=NULL; e=e->next){
			count++;
		}
	}

    fprintf(file, "%d\n", count);

	for(l=ridge; l->next!= NULL; l=l->next){
		if(l->strength < 2)
			continue;
		for(REdge* e=l->head; e->next!=NULL; e=e->next){
			fprintf(file, "%f %f %f\n", e->p1[0], e->p1[1], e->p1[2]);
		}
	}

	for(l=ravine; l->next!= NULL; l=l->next){
		if(l->strength < 2)
			continue;
		for(REdge* e=l->head; e->next!=NULL; e=e->next){
			fprintf(file, "%f %f %f\n", e->p1[0], e->p1[1], e->p1[2]);
		}
	}

	for(l=ridge; l->next!= NULL; l=l->next){
		if(l->strength < 2)
			continue;
		for(REdge* e=l->head; e->next!=NULL; e=e->next){
			fprintf(file, "%f %f %f\n", e->n[0], e->n[1], e->n[2]);
		}
	}

	for(l=ravine; l->next!= NULL; l=l->next){
		if(l->strength < 2)
			continue;
		for(REdge* e=l->head; e->next!=NULL; e=e->next){
			fprintf(file, "%f %f %f\n", e->n[0], e->n[1], e->n[2]);
		}
	}
}