WebSVN – gelsvn – Diff – /branches/cpp11-devel/apps/MeshEdit/harmonics.cpp

 	"		normal = normalize(gl_NormalMatrix * gl_Normal);\n"
 	"		eig = eigenvalue;\n"
 	"		eig2 = eigenvalue2;\n"
 	"	}\n";
 	string fss =
 	"#version 120\n"
 	"#extension GL_EXT_gpu_shader4 : enable\n"
 	"	\n"
 	"	varying vec3 normal;\n"
 	"	varying float eig;\n"
 	"	uniform float eig_max2;\n"
 	"	uniform bool do_highlight;\n"
 	"	uniform bool do_diffuse;\n"
 	"	const vec3 light_dir = vec3(0,0,1);\n"
 	"	\n"
 	" float basef(float x) {return max(0.0,min(1.0,2.0-4.0*abs(x)));\n}"
 	"	void main()\n"
 	"	{\n"
 	"		float dot_ln = max(0.0,dot(light_dir, normal));\n"
 	"		\n"
 	"		float eig_norm = eig/eig_max;\n"
 			if(!is_generalized)
 				area_i = 1; // if standard S is an identity matrix;
 			mb_S.insert_entry(i,area_i);
 			mb_S.next_column_nonsort();
 			S[i] = area_i;
 		}
 	cout << "solving generalized problem... i = " << mani.no_vertices()<< endl;
 	//+STANDARD
+	{
 		proj[es] = Vec3d(0.0);
 		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])));
 		}
+	}
 	cout << endl;
+}
 #else
 				double a_left  = acos(min(1.0, max(-1.0, d_left)));
 				double a_right = acos(min(1.0, max(-1.0, d_right)));
 				double w = 1.0/tan(a_left) + 1.0/tan(a_right);
 				Q[i][j] = -w/sqrt(area_i*area_j);
 				//Q[i][j] = -1;
 				a_sum += Q[i][j];
+			}
 			Q[i][i] = -a_sum;
+		}
 	EigenSolutionsSym(Q,V);
+}
-Harmonics::Harmonics(HMesh::Manifold& _mani, GLGraphics::Console& cs):mani(_mani), vtouched(_mani.allocated_vertices(), 0)
+Harmonics::Harmonics(HMesh::Manifold& _mani):mani(_mani), vtouched(_mani.allocated_vertices(), 0)
+{
-    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);
-	// Create the program
-	prog_P0 = glCreateProgram();
-	// Attach all shaders
-	if(vs) glAttachShader(prog_P0, vs);
-	if(fs) glAttachShader(prog_P0, fs);
-	// Link the program object and print out the info log
-	glLinkProgram(prog_P0);
-	print_glsl_program_log(prog_P0);
-	// Install program object as part of current state
-	glUseProgram(0);
-    display_harmonics_diffuse.reg(cs, "display.harmonics.diffuse", "");
-    display_harmonics_time.reg(cs, "display.harmonics.time", "");
-    display_harmonics_highlight.reg(cs, "display.harmonics.highlight", "");
-	triangulate_by_edge_face_split(mani);
     int i = 0;
     for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v, ++i)
         vtouched[*v] = i;
 	maximum_eigenvalue = mani.no_vertices()-1;
 	make_laplace_operator();
 	if(es<maximum_eigenvalue)
 		for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v){
 			Vec3d p = Vec3d(proj[es]);
 			double Qval = Q[es][vtouched[*v]];
 			mani.pos(*v) += p * Qval * scale;
+		}
+}
 void Harmonics::reset_shape()
+{
 	for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v)
 		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);
+}
+double Harmonics::compute_adf(HMesh::VertexAttributeVector<double>& F, double t)
+{
+	double F_max = 0;
+	for(VertexID vid : mani.vertices()){
+		for(int e = 1; e < V.Length(); ++e)
+			F[vid] += sqr(Q[e][vtouched[vid]]) * exp(-t*V[e]/V[1]);
+		F_max = max(F[vid], F_max);
+	}
+    return F_max;
+}
+GLuint HarmonicsRenderer::prog_P0 = 0;
+GLGraphics::Console::variable<float> HarmonicsRenderer::display_harmonics_time;
+GLGraphics::Console::variable<int> HarmonicsRenderer::display_harmonics_diffuse;
+GLGraphics::Console::variable<int> HarmonicsRenderer::display_harmonics_highlight;
+HarmonicsRenderer::HarmonicsRenderer(HMesh::Manifold& _m, Harmonics& _h, GLGraphics::Console& cs): m(&_m), h(&_h)
+{
+    if (prog_P0 == 0) {
+        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);
+        // Create the program
+        prog_P0 = glCreateProgram();
+        // Attach all shaders
+        if(vs) glAttachShader(prog_P0, vs);
+        if(fs) glAttachShader(prog_P0, fs);
+        // Link the program object and print out the info log
+        glLinkProgram(prog_P0);
+        print_glsl_program_log(prog_P0);
+        // Install program object as part of current state
+        glUseProgram(0);
+        display_harmonics_diffuse.reg(cs, "display.harmonics.diffuse", "");
+        display_harmonics_time.reg(cs, "display.harmonics.time", "");
+        display_harmonics_highlight.reg(cs, "display.harmonics.highlight", "");
+    }
+    draw_adf();
+}
-void Harmonics::parse_key(unsigned char key)
+void HarmonicsRenderer::parse_key(unsigned char key)
+{
 	switch(key) {
 		case '+':
 			display_harmonics_time = display_harmonics_time+0.001;
 			break;
 		case '-':
 			display_harmonics_time = display_harmonics_time-0.001;
 			break;
 		case 'd':
 			display_harmonics_diffuse = !display_harmonics_diffuse;
 			break;
 		case 'h':
 			display_harmonics_highlight = !display_harmonics_highlight;
 			break;
+	}
+}
-void Harmonics::draw_adf()
+void HarmonicsRenderer::draw_adf()
+{
-	vector<double> F(mani.no_vertices(),0);
+    VertexAttributeVector<double> F;
-	double F_max = 0;
-	for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v){
-		int v_idx = vtouched[*v];
-		for(int e = 1; e < V.Length(); ++e)
-			F[v_idx] += sqr(Q[e][v_idx]) * exp(-(display_harmonics_time)*V[e]/V[1]);
+    double F_max = h->compute_adf(F, display_harmonics_time);
-		F_max = max(F[v_idx], F_max);
-	}
 	cout << "F max" <<  F_max << endl;
+    glNewList(display_list, GL_COMPILE);
 	glUseProgram(prog_P0);
 	glUniform1f(glGetUniformLocation(prog_P0,"eig_max"),F_max);//2*M_PI);
 	glUniform1i(glGetUniformLocation(prog_P0,"do_diffuse"),display_harmonics_diffuse);
    	glUniform1i(glGetUniformLocation(prog_P0,"do_highlight"),display_harmonics_highlight);
 	GLuint attrib = glGetAttribLocationARB(prog_P0, "eigenvalue");
 	glFrontFace(GL_CW);
-	for(FaceIDIterator f = mani.faces_begin(); f != mani.faces_end(); ++f){
+	for(FaceIDIterator f = m->faces_begin(); f != m->faces_end(); ++f){
 		glBegin(GL_TRIANGLES);
-        for(Walker w = mani.walker(*f); !w.full_circle(); w = w.circulate_face_cw()){
+        for(Walker w = m->walker(*f); !w.full_circle(); w = w.circulate_face_cw()){
-			int i = vtouched[w.vertex()];
-			glVertexAttrib1f(attrib,F[i]);
+			glVertexAttrib1f(attrib,F[w.vertex()]);
-			glNormal3dv(normal(mani, w.vertex()).get());
+			glNormal3dv(normal(*m, w.vertex()).get());
-			glVertex3dv(mani.pos(w.vertex()).get());
+			glVertex3dv(m->pos(w.vertex()).get());
+		}
 		glEnd();
+	}
 	glFrontFace(GL_CCW);
 	glUseProgram(0);
+    glEndList();
+}

Subversion Repositories gelsvn

(root)/branches/cpp11-devel/apps/MeshEdit/harmonics.cpp – Rev 630 → 641