WebSVN – gelsvn – Diff – /trunk/apps/MeshEdit/harmonics.cpp

 #if USE_SPARSE_MATRIX
 #include <arlgsym.h>
 #endif
-#include <CGLA/Vec3f.h>
 #include <CGLA/Vec3d.h>
 #include <CGLA/Mat2x2d.h>
 #include <LinAlg/Matrix.h>
 #include <LinAlg/Vector.h>
 #include <LinAlg/LapackFunc.h>
 #include <GL/glew.h>
 #include <GLGraphics/glsl_shader.h>
-#include <HMesh/Manifold.h>
-#include <HMesh/VertexCirculator.h>
-#include <HMesh/FaceCirculator.h>
-#include <HMesh/build_manifold.h>
 #include <HMesh/mesh_optimization.h>
+#include <HMesh/curvature.h>
 #include <HMesh/triangulate.h>
 #include <HMesh/load.h>
 #include <HMesh/x3d_save.h>
-#include <GLConsole/GLConsole.h>
+#include <GLGraphics/Console.h>
-#include "curvature.h"
-#include "CSCMatrixBuilder.h"
+//#include "CSCMatrixBuilder.h"
 using namespace CGLA;
 using namespace std;
 using namespace HMesh;
 using namespace Geometry;
 using namespace GLGraphics;
 using namespace LinAlg;
-using namespace CVarUtils;
 bool Harmonics::is_initialized=false;
 GLuint Harmonics::prog_P0;
 	//+GENERALIZED
 	CSCMatrixBuilder<double> mb_S;
 	// S has the same type as V
 	S.Resize(mani.no_vertices());
-	for(VertexIter v = mani.vertices_begin(); v != mani.vertices_end(); ++v)
+	for(VertexIter v = mani.vhandles_begin(); v != mani.vhandles_end(); ++v)
 		if(!is_boundary(v))
+		{
 			int i = v->touched;
 			double area_i = voronoi_area(v);
 			Vec3d vertex(v->pos);
 	cout << endl << "Proj" << endl;
 	for(int es=0; es<maximum_eigenvalue; ++es)  //o(n^2)
+	{
 		proj[es] = Vec3d(0.0);
-		for(VertexIter v=mani.vertices_begin(); v != mani.vertices_end(); ++v)
+		for(VertexIter v=mani.vhandles_begin(); v != mani.vhandles_end(); ++v)
+		{
 			proj[es] +=  Vec3d(v->pos) * Q[es][v->touched] * S[v->touched];
 			max_eig_values[es] = max(max_eig_values[es], static_cast<float>(abs(Q[es][v->touched])));
+		}
+	}
 #else
 void Harmonics::make_laplace_operator()
+{
 	Q.Resize(mani.no_vertices(), mani.no_vertices());
-	for(VertexIter v = mani.vertices_begin(); v != mani.vertices_end(); ++v)
+	for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v)
-		if(!is_boundary(v))
+		if(!boundary(mani, *v)){
-		{
-			int i = v->touched;
+			int i = vtouched[*v];
-			double area_i = voronoi_area(v);
+			double area_i = voronoi_area(mani, *v);
-			Vec3d vertex(v->pos);
+			Vec3d vertex(mani.pos(*v));
 			Vec3d curv_normal(0);
 			double a_sum = 0;
-			for(VertexCirculator vc(v); !vc.end(); ++vc)
+            for(Walker wv = mani.walker(*v); !wv.full_circle(); wv = wv.circulate_vertex_cw())
+			{
-				int j = vc.get_vertex()->touched;
+				int j = vtouched[wv.vertex()];
-				double area_j = voronoi_area(vc.get_vertex());
+				double area_j = voronoi_area(mani, wv.vertex());
-				HalfEdgeIter h = vc.get_halfedge();
-				Vec3d nbr(h->vert->pos);
+				Vec3d nbr(mani.pos(wv.vertex()));
-				Vec3d left(h->next->vert->pos);
+				Vec3d left(mani.pos(wv.next().vertex()));
-				Vec3d right(h->opp->prev->opp->vert->pos);
+				Vec3d right(mani.pos(wv.opp().prev().opp().vertex()));
 				double d_left = dot(normalize(nbr-left),
 									normalize(vertex-left));
 				double d_right = dot(normalize(nbr-right),
 									 normalize(vertex-right));
 			Q[i][i] = -a_sum;
+		}
 	EigenSolutionsSym(Q,V);
+}
-Harmonics::Harmonics(Manifold& _mani):mani(_mani)
+Harmonics::Harmonics(Manifold& _mani):mani(_mani), vtouched(_mani.allocated_vertices(), 0)
+{
 	assert(is_initialized);
-	triangulate(mani);
+	triangulate_by_edge_face_split(mani);
+    int i = 0;
+    for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v, ++i)
-	mani.enumerate_vertices();
+        vtouched[*v] = i;
 	maximum_eigenvalue = mani.no_vertices()-1;
 	make_laplace_operator();
 	proj.resize(maximum_eigenvalue);
 	max_eig_values.resize(maximum_eigenvalue, 1e-10f);
 	cout << "Projection magnitude" << endl;
 	for(int es=0; es<maximum_eigenvalue; ++es)
+	{
 		proj[es] = Vec3d(0.0);
-		for(VertexIter v=mani.vertices_begin(); v != mani.vertices_end(); ++v)
+		for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v)
+		{
-			proj[es] +=  Vec3d(v->pos) * Q[es][v->touched];
+			proj[es] +=  Vec3d(mani.pos(*v)) * Q[es][vtouched[*v]];
-			max_eig_values[es] = max(max_eig_values[es], static_cast<float>(abs(Q[es][v->touched])));
+			max_eig_values[es] = max(max_eig_values[es], static_cast<float>(abs(Q[es][vtouched[*v]])));
+		}
+	}
+}
 #endif
 void Harmonics::add_frequency(int es, float scale)
+{
 	if(es<maximum_eigenvalue)
-		for(VertexIter v=mani.vertices_begin(); v != mani.vertices_end(); ++v)
+		for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v){
-		{
-			Vec3f p = Vec3f(proj[es]);
+			Vec3d p = Vec3d(proj[es]);
-			double Qval = Q[es][v->touched];
+			double Qval = Q[es][vtouched[*v]];
-			v->pos += p * Qval * scale;
+			mani.pos(*v) += p * Qval * scale;
+		}
+}
 void Harmonics::reset_shape()
+{
-	for(VertexIter v=mani.vertices_begin(); v != mani.vertices_end(); ++v)
+	for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v)
-		v->pos = Vec3f(0);
+		mani.pos(*v) = Vec3d(0);
+}
 void Harmonics::partial_reconstruct(int E0, int E1, float scale)
+{
 	for(int es=E0;es<=E1;++es)
 		add_frequency(es, scale);
+}
+Console::variable<float> display_harmonics_time;
+Console::variable<int> display_harmonics_diffuse;
+Console::variable<int> display_harmonics_highlight;
 void Harmonics::parse_key(unsigned char key)
+{
-	float& display_t = GetCVarRef<float>("display.harmonics.time");
-	int& display_diffuse = GetCVarRef<int>("display.harmonics.diffuse");
-	int& display_highlight = GetCVarRef<int>("display.harmonics.highlight");
 	switch(key) {
 		case '+':
-			display_t = display_t+0.001;
+			display_harmonics_time = display_harmonics_time+0.001;
 			break;
 		case '-':
-			display_t = display_t-0.001;
+			display_harmonics_time = display_harmonics_time-0.001;
 			break;
 		case 'd':
-			display_diffuse = !display_diffuse;
+			display_harmonics_diffuse = !display_harmonics_diffuse;
 			break;
 		case 'h':
-			display_highlight = !display_highlight;
+			display_harmonics_highlight = !display_harmonics_highlight;
 			break;
+	}
+}
 void Harmonics::draw_adf()
+{
-	float& t = GetCVarRef<float>("display.harmonics.time");
-	int& do_diffuse = GetCVarRef<int>("display.harmonics.diffuse");
-	int& do_highlight = GetCVarRef<int>("display.harmonics.highlight");
 	vector<double> F(mani.no_vertices(),0);
 	double F_max = 0;
-	for(VertexIter v=mani.vertices_begin(); v != mani.vertices_end(); ++v)
+	for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v){
-	{
-		int v_idx = v->touched;
+		int v_idx = vtouched[*v];
-		for(int e=1;e<V.Length();++e)
+		for(int e = 1; e < V.Length(); ++e)
-			F[v_idx] += sqr(Q[e][v_idx])*exp(-(t)*V[e]/V[1]);
+			F[v_idx] += sqr(Q[e][v_idx]) * exp(-(display_harmonics_time)*V[e]/V[1]);
 		F_max = max(F[v_idx], F_max);
+	}
 	cout << "F max" <<  F_max << endl;
 	glUseProgram(prog_P0);
 	glUniform1f(glGetUniformLocation(prog_P0,"eig_max"),F_max);//2*M_PI);
-	glUniform1i(glGetUniformLocation(prog_P0,"do_diffuse"),do_diffuse);
+	glUniform1i(glGetUniformLocation(prog_P0,"do_diffuse"),display_harmonics_diffuse);
-   	glUniform1i(glGetUniformLocation(prog_P0,"do_highlight"),do_highlight);
+   	glUniform1i(glGetUniformLocation(prog_P0,"do_highlight"),display_harmonics_highlight);
 	GLuint attrib = glGetAttribLocationARB(prog_P0, "eigenvalue");
 	glFrontFace(GL_CW);
-	for(FaceIter f=mani.faces_begin(); f != mani.faces_end(); ++f)
+	for(FaceIDIterator f = mani.faces_begin(); f != mani.faces_end(); ++f){
-	{
-		FaceCirculator fc(f);
 		glBegin(GL_TRIANGLES);
-		while(!fc.end())
+        for(Walker w = mani.walker(*f); !w.full_circle(); w = w.circulate_face_cw()){
-		{
-			int i = fc.get_vertex()->touched;
+			int i = vtouched[w.vertex()];
 			glVertexAttrib1f(attrib,F[i]);
-			glNormal3fv(normal(fc.get_vertex()).get());
+			glNormal3dv(normal(mani, w.vertex()).get());
-			glVertex3fv(fc.get_vertex()->pos.get());
+			glVertex3dv(mani.pos(w.vertex()).get());
-			++fc;
+		}
 		glEnd();
+	}
 	glFrontFace(GL_CCW);
 	glUseProgram(0);
+}
-void Harmonics::init()
+void Harmonics::init(Console& cs)
+{
 	is_initialized = true;
 	string shader_path = "/Users/jab/GEL/apps/MeshEdit/";
 	GLuint vs = create_glsl_shader(GL_VERTEX_SHADER, vss);
 	GLuint fs = create_glsl_shader(GL_FRAGMENT_SHADER, fss);
 	print_glsl_program_log(prog_P0);
 	// Install program object as part of current state
 	glUseProgram(0);
-	CreateCVar("display.harmonics.time",0.0f);
+    display_harmonics_diffuse.reg(cs, "display.harmonics.diffuse", "");
-	CreateCVar("display.harmonics.eigenvalue2",0);
+    display_harmonics_time.reg(cs, "display.harmonics.time", "");
-	CreateCVar("display.harmonics.highlight",1);
+    display_harmonics_highlight.reg(cs, "display.harmonics.highlight", "");
-	CreateCVar("display.harmonics.diffuse",1);
-	CreateCVar("display.harmonics.diffusion_distance_init_vertex",0);
+}

Subversion Repositories gelsvn

(root)/trunk/apps/MeshEdit/harmonics.cpp – Rev 457 → 596