Initial Release
This commit is contained in:
parent
782b814293
commit
24d13d59e6
|
|
@ -0,0 +1,363 @@
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <time.h>
|
||||||
|
#include <GL/glew.h>
|
||||||
|
#include <GL/glut.h>
|
||||||
|
#include <wrap/gl/space.h>
|
||||||
|
|
||||||
|
|
||||||
|
#include <wrap/callback.h>
|
||||||
|
#include <wrap/gui/trackball.h>
|
||||||
|
#include <vcg/simplex/vertex/with/vcvn.h>
|
||||||
|
#include <vcg/simplex/vertex/with/vcvn.h>
|
||||||
|
#include <vcg/simplex/face/with/fcfn.h>
|
||||||
|
#include <vcg/space/index/grid_static_ptr.h>
|
||||||
|
#include <vcg/complex/trimesh/base.h>
|
||||||
|
#include<wrap/io_trimesh/export_ply.h>
|
||||||
|
#include<wrap/io_trimesh/import_ply.h>
|
||||||
|
#include<vcg/complex/trimesh/update/normal.h>
|
||||||
|
#include<vcg/complex/trimesh/update/bounding.h>
|
||||||
|
|
||||||
|
#include "visshader.h"
|
||||||
|
using namespace vcg;
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
// Vertex, Face, Mesh and Grid definitions.
|
||||||
|
class MyEdge;
|
||||||
|
class AFace;
|
||||||
|
class AVertex : public VertexVCVN< float ,MyEdge,AFace > {};
|
||||||
|
class AFace : public FaceFCFN< AVertex,MyEdge,AFace > {};
|
||||||
|
class AMesh : public tri::TriMesh< vector<AVertex>, vector<AFace> > {};
|
||||||
|
|
||||||
|
///////// Global ////////
|
||||||
|
|
||||||
|
int SampleNum=32;
|
||||||
|
int WindowRes=800;
|
||||||
|
|
||||||
|
bool SwapFlag=false;
|
||||||
|
|
||||||
|
float lopass=0,hipass=1,gamma=1;
|
||||||
|
bool LightFlag=true;
|
||||||
|
bool ColorFlag=true;
|
||||||
|
|
||||||
|
Trackball Q;
|
||||||
|
|
||||||
|
int ScreenH,ScreenW;
|
||||||
|
float ViewAngle=45;
|
||||||
|
|
||||||
|
class TimeOracle
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
time_t start;
|
||||||
|
time_t cur;
|
||||||
|
|
||||||
|
char buf[128];
|
||||||
|
|
||||||
|
char const *TimeToEndStr(double perc)
|
||||||
|
{
|
||||||
|
time(&cur);
|
||||||
|
double diff=difftime(cur,start);
|
||||||
|
diff= diff/perc - diff;
|
||||||
|
|
||||||
|
int hh=diff/3600;
|
||||||
|
int mm=(diff-hh*3600)/60;
|
||||||
|
int ss=diff-hh*3600-mm*60;
|
||||||
|
sprintf(buf,"%02i:%02i:%02i",hh,mm,ss);
|
||||||
|
return buf;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Start(){time(&start);};
|
||||||
|
};
|
||||||
|
|
||||||
|
bool cb(const char *buf)
|
||||||
|
{
|
||||||
|
printf(buf);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// prototypes
|
||||||
|
void SaveTexturedGround();
|
||||||
|
|
||||||
|
void Draw(AMesh &mm)
|
||||||
|
{
|
||||||
|
AMesh::FaceIterator fi;
|
||||||
|
glBegin(GL_TRIANGLES);
|
||||||
|
for(fi=mm.face.begin();fi!=mm.face.end();++fi)
|
||||||
|
{
|
||||||
|
|
||||||
|
glNormal((*fi).V(0)->N()); glColor((*fi).V(0)->C()); glVertex((*fi).V(0)->P());
|
||||||
|
glNormal((*fi).V(1)->N()); glColor((*fi).V(1)->C()); glVertex((*fi).V(1)->P());
|
||||||
|
glNormal((*fi).V(2)->N()); glColor((*fi).V(2)->C()); glVertex((*fi).V(2)->P());
|
||||||
|
}
|
||||||
|
glEnd();
|
||||||
|
}
|
||||||
|
|
||||||
|
AMesh m;
|
||||||
|
VertexVisShader<AMesh> Vis(m);
|
||||||
|
|
||||||
|
string OutNameMsh;
|
||||||
|
|
||||||
|
|
||||||
|
/* Called when the window is first opened and whenever
|
||||||
|
* the window is reconfigured (moved or resized).
|
||||||
|
*/
|
||||||
|
void ViewReshape(GLsizei w, GLsizei h)
|
||||||
|
{
|
||||||
|
ScreenW=w; ScreenH=h;
|
||||||
|
glMatrixMode (GL_PROJECTION);
|
||||||
|
glLoadIdentity ();
|
||||||
|
gluPerspective(ViewAngle,(float)w/(float)h,.1,10000);
|
||||||
|
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ViewDisplay (void)
|
||||||
|
{
|
||||||
|
glMatrixMode (GL_PROJECTION);
|
||||||
|
glLoadIdentity ();
|
||||||
|
gluPerspective(ViewAngle,1,.1,10);
|
||||||
|
glMatrixMode (GL_MODELVIEW);
|
||||||
|
glLoadIdentity ();
|
||||||
|
glTranslatef(0,0,-4);
|
||||||
|
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||||
|
Q.GetView();
|
||||||
|
Q.Apply();
|
||||||
|
Q.Draw();
|
||||||
|
float d = 2.0/m.bbox.Diag();
|
||||||
|
glScalef(d, d, d);
|
||||||
|
glTranslate(-m.bbox.Center());
|
||||||
|
if(LightFlag) glEnable(GL_LIGHTING);
|
||||||
|
else glDisable(GL_LIGHTING);
|
||||||
|
if(ColorFlag) glEnable(GL_COLOR_MATERIAL);
|
||||||
|
else glDisable(GL_COLOR_MATERIAL);
|
||||||
|
Draw(m);
|
||||||
|
glutSwapBuffers();
|
||||||
|
}
|
||||||
|
|
||||||
|
void ViewSpecialKey(int , int , int )
|
||||||
|
{
|
||||||
|
glutPostRedisplay();
|
||||||
|
}
|
||||||
|
void Toggle(bool &flag) {flag = !flag;}
|
||||||
|
/*********************************************************************/
|
||||||
|
/*********************************************************************/
|
||||||
|
/*********************************************************************/
|
||||||
|
void ViewKey(unsigned char key, int , int )
|
||||||
|
{
|
||||||
|
Point3f dir;
|
||||||
|
switch (key) {
|
||||||
|
case 27: exit(0); break;
|
||||||
|
case 'l' :
|
||||||
|
lopass=lopass+.05; printf("Lo %f, Hi %f Gamma %f\n",lopass,hipass,gamma);
|
||||||
|
Vis.MapVisibility(gamma,lopass,hipass);
|
||||||
|
break;
|
||||||
|
case 'L' :
|
||||||
|
lopass=lopass-.05; printf("Lo %f, Hi %f Gamma %f\n",lopass,hipass,gamma);
|
||||||
|
Vis.MapVisibility(gamma,lopass,hipass);
|
||||||
|
break;
|
||||||
|
case 'h' :
|
||||||
|
hipass=hipass-.05; printf("Lo %f, Hi %f Gamma %f\n",lopass,hipass,gamma);
|
||||||
|
Vis.MapVisibility(gamma,lopass,hipass);
|
||||||
|
break;
|
||||||
|
case 'H' :
|
||||||
|
hipass=hipass+.05; printf("Lo %f, Hi %f Gamma %f\n",lopass,hipass,gamma);
|
||||||
|
Vis.MapVisibility(gamma,lopass,hipass);
|
||||||
|
break;
|
||||||
|
case 'g' :
|
||||||
|
gamma=gamma-.05; printf("Lo %f, Hi %f Gamma %f\n",lopass,hipass,gamma);
|
||||||
|
Vis.MapVisibility(gamma,lopass,hipass);
|
||||||
|
break;
|
||||||
|
case 'G' :
|
||||||
|
gamma=gamma+.05; printf("Lo %f, Hi %f Gamma %f\n",lopass,hipass,gamma);
|
||||||
|
Vis.MapVisibility(gamma,lopass,hipass);
|
||||||
|
break;
|
||||||
|
case 'c' :
|
||||||
|
Vis.ComputeUniform(SampleNum,cb);
|
||||||
|
Vis.MapVisibility(gamma,lopass,hipass);
|
||||||
|
break;
|
||||||
|
case ' ' : {
|
||||||
|
Point3f dir = Q.camera.ViewPoint();
|
||||||
|
printf("ViewPoint %f %f %f\n",dir[0],dir[1],dir[2]);
|
||||||
|
dir.Normalize();
|
||||||
|
dir=Inverse(Q.track.Matrix())*dir;
|
||||||
|
printf("ViewPoint %f %f %f\n",dir[0],dir[1],dir[2]);
|
||||||
|
dir.Normalize();
|
||||||
|
Vis.ComputeSingle(dir,cb);
|
||||||
|
Vis.MapVisibility(gamma,lopass,hipass); }
|
||||||
|
break;
|
||||||
|
case 's' :
|
||||||
|
Vis.SmoothVisibility();
|
||||||
|
Vis.MapVisibility(gamma,lopass,hipass);
|
||||||
|
break;
|
||||||
|
case 'S' :
|
||||||
|
{
|
||||||
|
vcg::tri::io::PlyInfo p;
|
||||||
|
p.mask|=vcg::ply::PLYMask::PM_VERTCOLOR /* | vcg::ply::PLYMask::PM_VERTQUALITY*/ ;
|
||||||
|
tri::io::ExporterPLY<AMesh>::Save(m,OutNameMsh.c_str(),false,p);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 'a' : LightFlag = !LightFlag; printf("Toggled Light\n"); break;
|
||||||
|
case 'A' : ColorFlag = !ColorFlag; printf("Toggled Color\n"); break;
|
||||||
|
}
|
||||||
|
glutPostRedisplay(); ;
|
||||||
|
}
|
||||||
|
void ViewMenu(int val)
|
||||||
|
{
|
||||||
|
ViewKey(val, 0, 0);
|
||||||
|
}
|
||||||
|
/*********************************************************************/
|
||||||
|
// TrackBall Functions
|
||||||
|
/*********************************************************************/
|
||||||
|
|
||||||
|
int PressedButton; // What is the button actually pressed?
|
||||||
|
int KeyMod;
|
||||||
|
int GW,GH; // Grandezza della finestra
|
||||||
|
int B[3]={0,0,0}; // Variabile globale che tiene lo stato dei tre bottoni;
|
||||||
|
|
||||||
|
|
||||||
|
void ViewMouse(int button, int state, int x, int y)
|
||||||
|
{
|
||||||
|
static int glut_buttons=0;
|
||||||
|
|
||||||
|
int m_mask = 0;
|
||||||
|
KeyMod=glutGetModifiers();
|
||||||
|
if(GLUT_ACTIVE_SHIFT & KeyMod) m_mask |= Trackball::KEY_SHIFT;
|
||||||
|
if(GLUT_ACTIVE_ALT & KeyMod) m_mask |= Trackball::KEY_ALT;
|
||||||
|
if(GLUT_ACTIVE_CTRL & KeyMod) m_mask |= Trackball::KEY_CTRL;
|
||||||
|
|
||||||
|
if(state == GLUT_DOWN) {
|
||||||
|
glut_buttons |= (1<<button);
|
||||||
|
Q.MouseDown(x, ScreenH-y, glut_buttons | m_mask);
|
||||||
|
} else {
|
||||||
|
//glut_buttons &= ~(1<<button);
|
||||||
|
glut_buttons = 0;
|
||||||
|
m_mask = 0;
|
||||||
|
Q.MouseUp(x, ScreenH-y, glut_buttons);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void ViewMouseMotion(int x, int y)
|
||||||
|
{
|
||||||
|
Q.MouseMove(x,ScreenH-y);
|
||||||
|
glutPostRedisplay();
|
||||||
|
}
|
||||||
|
|
||||||
|
void SetLight()
|
||||||
|
{
|
||||||
|
GLfloat light_ambient0[] = {0.0, 0.0, 0.0, 1.0};
|
||||||
|
GLfloat light_diffuse0[] = {1.0, 1.0, 1.0, 1.0};
|
||||||
|
GLfloat light_position0[] = {0.0, 10.0, 300.0, 0.0};
|
||||||
|
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient0);
|
||||||
|
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse0);
|
||||||
|
glLightfv(GL_LIGHT0, GL_POSITION, light_position0);
|
||||||
|
glEnable(GL_LIGHT0);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ViewInit (void) {
|
||||||
|
SetLight();
|
||||||
|
Q.Reset();
|
||||||
|
Q.radius= 1;
|
||||||
|
glEnable(GL_DEPTH_TEST);
|
||||||
|
glDepthFunc(GL_LEQUAL);
|
||||||
|
glClearColor (0.8, 0.8, 0.8, 0.0);
|
||||||
|
glEnable(GL_NORMALIZE);
|
||||||
|
glEnable(GL_LIGHTING);
|
||||||
|
|
||||||
|
// glEnable(GL_BLEND);
|
||||||
|
glShadeModel(GL_SMOOTH);
|
||||||
|
// glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
|
||||||
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||||
|
glEnable(GL_COLOR_MATERIAL);
|
||||||
|
glColorMaterial(GL_FRONT,GL_DIFFUSE);
|
||||||
|
//glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);
|
||||||
|
//glColorMaterial(GL_FRONT,GL_AMBIENT);
|
||||||
|
glMateriali(GL_FRONT,GL_SHININESS,0);
|
||||||
|
float spec[4]={0,0,0,1};
|
||||||
|
glMaterialfv(GL_FRONT,GL_SPECULAR,spec);
|
||||||
|
glEnable(GL_CULL_FACE);
|
||||||
|
glCullFace(GL_BACK);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
int main(int argc, char** argv)
|
||||||
|
{
|
||||||
|
if(argc<2) {
|
||||||
|
printf(
|
||||||
|
"shadevis 1.0 \n"__DATE__"\n"
|
||||||
|
"Copyright 2003-2004 Visual Computing Lab I.S.T.I. C.N.R.\n"
|
||||||
|
"Paolo Cignoni (cignoni@isti.cnr.it)\n\n"
|
||||||
|
"Usage: shadevis file.ply [options]\n"
|
||||||
|
"Options:\n"
|
||||||
|
" -w# WindowResolution (default 600)\n"
|
||||||
|
" -n# Sample Directions (default 32)\n"
|
||||||
|
" -z# z offset (default 1e-4)\n"
|
||||||
|
" -da # Cone Direction Angle in degree (default 45)\n"
|
||||||
|
" -dv # # # Cone Direction vector (default 0 0 1)\n"
|
||||||
|
" -c Set IsClosed Flag\n"
|
||||||
|
" -f Flip normal of the model\n"
|
||||||
|
);
|
||||||
|
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
int i=1;
|
||||||
|
while(i<argc && (argv[i][0]=='-'))
|
||||||
|
{
|
||||||
|
switch(argv[i][1])
|
||||||
|
{
|
||||||
|
case 'n' : SampleNum = atoi(argv[i]+2); break;
|
||||||
|
case 'f' : SwapFlag=false; break;
|
||||||
|
case 'w' : WindowRes= atoi(argv[i]+2); printf("Set WindowRes to %i\n",WindowRes ); break;
|
||||||
|
case 's' : Vis.SplitNum= atoi(argv[i]+2); printf("Set SplitNum to %i\n",Vis.SplitNum ); break;
|
||||||
|
case 'z' : Vis.ZTWIST = atof(argv[i]+2); printf("Set ZTWIST to %f\n",Vis.ZTWIST ); break;
|
||||||
|
default: {printf("Error unable to parse option '%s'\n",argv[i]); exit(0);}
|
||||||
|
}
|
||||||
|
|
||||||
|
++i;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
string basename = argv[i];
|
||||||
|
if(!(basename.substr(basename.length()-4)==".ply")) {
|
||||||
|
printf("Error: Unknown file extension %s\n",basename.c_str());
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
// loading original mesh
|
||||||
|
int ret=tri::io::ImporterPLY<AMesh>::Open(m,argv[i]);
|
||||||
|
if(ret) {printf("Error unable to open mesh %s\n",argv[i]);exit(-1);}
|
||||||
|
tri::UpdateNormals<AMesh>::PerVertexNormalized(m);
|
||||||
|
tri::UpdateBounding<AMesh>::Box(m);
|
||||||
|
|
||||||
|
printf("Mesh bbox (%f %f %f)-(%f %f %f)\n\n",m.bbox.min[0],m.bbox.min[1],m.bbox.min[2],m.bbox.max[0],m.bbox.max[1],m.bbox.max[2]);
|
||||||
|
OutNameMsh=(string(argv[i]).substr(0,strlen(argv[i])-4));
|
||||||
|
OutNameMsh+="_vis.ply";
|
||||||
|
|
||||||
|
printf("Mesh Output filename %s\n",OutNameMsh.c_str());
|
||||||
|
|
||||||
|
printf("Mesh %iv %if bbox Diag %g\n",m.vn,m.fn,m.bbox.Diag());
|
||||||
|
|
||||||
|
glutInit(&argc, argv);
|
||||||
|
|
||||||
|
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
|
||||||
|
glutInitWindowSize(WindowRes, WindowRes);
|
||||||
|
glutInitWindowPosition (10,10);
|
||||||
|
glutCreateWindow ("shadevis - Visual Computing Lab - vcg.isti.cnr.it ");
|
||||||
|
glutDisplayFunc(ViewDisplay);
|
||||||
|
glutReshapeFunc(ViewReshape);
|
||||||
|
glutKeyboardFunc(ViewKey);
|
||||||
|
glutSpecialFunc(ViewSpecialKey);
|
||||||
|
glutMouseFunc(ViewMouse);
|
||||||
|
glutMotionFunc(ViewMouseMotion);
|
||||||
|
|
||||||
|
ViewInit();
|
||||||
|
glewInit();
|
||||||
|
glutMainLoop();
|
||||||
|
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,85 @@
|
||||||
|
/*#***************************************************************************
|
||||||
|
* Visibility.h o o *
|
||||||
|
* o o *
|
||||||
|
* Visual Computing Group _ O _ *
|
||||||
|
* IEI Institute, CNUCE Institute, CNR Pisa \/)\/ *
|
||||||
|
* /\/| *
|
||||||
|
* Copyright(C) 1999 by Paolo Cignoni, Paolo Pingi, Claudio Rocchini | *
|
||||||
|
* All rights reserved. \ *
|
||||||
|
* *
|
||||||
|
* Permission to use, copy, modify, distribute and sell this software and *
|
||||||
|
* its documentation for any purpose is hereby granted without fee, provided *
|
||||||
|
* that the above copyright notice appear in all copies and that both that *
|
||||||
|
* copyright notice and this permission notice appear in supporting *
|
||||||
|
* documentation. the author makes no representations about the suitability *
|
||||||
|
* of this software for any purpose. It is provided "as is" without express *
|
||||||
|
* or implied warranty. *
|
||||||
|
* *
|
||||||
|
*****************************************************************************/
|
||||||
|
/*#**************************************************************************
|
||||||
|
History
|
||||||
|
|
||||||
|
2003 Aug 26 First Working version
|
||||||
|
|
||||||
|
****************************************************************************/
|
||||||
|
#ifndef __VCG_SIMPLE_PIC
|
||||||
|
#define __VCG_SIMPLE_PIC
|
||||||
|
#include <vcg/math/matrix44.h>
|
||||||
|
|
||||||
|
namespace vcg {
|
||||||
|
template <class PixType>
|
||||||
|
class SimplePic
|
||||||
|
{public:
|
||||||
|
std::vector<PixType> img;
|
||||||
|
int sx,sy;
|
||||||
|
void Create(int tx,int ty)
|
||||||
|
{
|
||||||
|
sx=tx;sy=ty;
|
||||||
|
img.resize(sx*sy);
|
||||||
|
}
|
||||||
|
PixType &Pix(int x, int y) {return img[sx*y+x];}
|
||||||
|
|
||||||
|
void OpenGLSnap(GLenum format=0)
|
||||||
|
{
|
||||||
|
int vp[4];
|
||||||
|
glGetIntegerv( GL_VIEWPORT,vp ); // Lettura viewport
|
||||||
|
glPixelStorei( GL_PACK_ROW_LENGTH, 0);
|
||||||
|
glPixelStorei( GL_PACK_ALIGNMENT, 1);
|
||||||
|
int tx = vp[2];
|
||||||
|
int ty = vp[3];
|
||||||
|
|
||||||
|
Create(tx,ty);
|
||||||
|
|
||||||
|
GLenum mtype = 0;
|
||||||
|
|
||||||
|
if(format==0) {
|
||||||
|
format = GL_RGBA;
|
||||||
|
mtype = GL_UNSIGNED_BYTE;
|
||||||
|
}
|
||||||
|
if(format==GL_DEPTH_COMPONENT) {
|
||||||
|
format = GL_DEPTH_COMPONENT;
|
||||||
|
mtype = GL_FLOAT;
|
||||||
|
}
|
||||||
|
glReadPixels(vp[0],vp[1],vp[2],vp[3],format,mtype,(GLvoid *)&img[0]);
|
||||||
|
}
|
||||||
|
bool SavePPM( const char * filename )
|
||||||
|
{
|
||||||
|
FILE * fp = fopen(filename,"wb");
|
||||||
|
if(fp==0) return false;
|
||||||
|
|
||||||
|
|
||||||
|
fprintf(fp,"P6\n%d %d\n255\n",sx,sy);
|
||||||
|
|
||||||
|
for(int i=0;i<sx*sy;++i)
|
||||||
|
{
|
||||||
|
fwrite(&(img[i]),3,1,fp);
|
||||||
|
}
|
||||||
|
|
||||||
|
fclose(fp);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
}
|
||||||
|
#endif // __VCG_MESH_VISIBILITY
|
||||||
|
|
@ -0,0 +1,516 @@
|
||||||
|
/*#***************************************************************************
|
||||||
|
* Visibility.h o o *
|
||||||
|
* o o *
|
||||||
|
* Visual Computing Group _ O _ *
|
||||||
|
* IEI Institute, CNUCE Institute, CNR Pisa \/)\/ *
|
||||||
|
* /\/| *
|
||||||
|
* Copyright(C) 1999 by Paolo Cignoni, Paolo Pingi, Claudio Rocchini | *
|
||||||
|
* All rights reserved. \ *
|
||||||
|
* *
|
||||||
|
* Permission to use, copy, modify, distribute and sell this software and *
|
||||||
|
* its documentation for any purpose is hereby granted without fee, provided *
|
||||||
|
* that the above copyright notice appear in all copies and that both that *
|
||||||
|
* copyright notice and this permission notice appear in supporting *
|
||||||
|
* documentation. the author makes no representations about the suitability *
|
||||||
|
* of this software for any purpose. It is provided "as is" without express *
|
||||||
|
* or implied warranty. *
|
||||||
|
* *
|
||||||
|
*****************************************************************************/
|
||||||
|
/*#**************************************************************************
|
||||||
|
History
|
||||||
|
|
||||||
|
2003 Aug 26 First Working version
|
||||||
|
|
||||||
|
****************************************************************************/
|
||||||
|
#ifndef __VCG_MESH_VISIBILITY
|
||||||
|
#define __VCG_MESH_VISIBILITY
|
||||||
|
#include <bitset>
|
||||||
|
#include <vcg/math/matrix44.h>
|
||||||
|
#include "simplepic.h"
|
||||||
|
namespace vcg {
|
||||||
|
|
||||||
|
template <class ScalarType>
|
||||||
|
void GenNormal(int vn, std::vector<Point3<ScalarType > > &NN)
|
||||||
|
{
|
||||||
|
typedef Point3<ScalarType> Point3x;
|
||||||
|
NN.clear();
|
||||||
|
while(NN.size()<vn)
|
||||||
|
{
|
||||||
|
Point3x pp(float(rand())/RAND_MAX,float(rand())/RAND_MAX,float(rand())/RAND_MAX);
|
||||||
|
pp=pp*2.0-Point3x(1,1,1);
|
||||||
|
if(pp.SquaredNorm()<1)
|
||||||
|
{
|
||||||
|
Normalize(pp);
|
||||||
|
NN.push_back(pp);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Base Class che definisce le varie interfaccie;
|
||||||
|
template <class MESH_TYPE, int MAXVIS=2048> class VisShader
|
||||||
|
{
|
||||||
|
public :
|
||||||
|
enum {VisMax=MAXVIS};
|
||||||
|
VisShader(MESH_TYPE &me):m(me)
|
||||||
|
{
|
||||||
|
CullFlag= false;
|
||||||
|
IsClosed = false;
|
||||||
|
ZTWIST=1e-3;
|
||||||
|
SplitNum=1;
|
||||||
|
|
||||||
|
CameraViewing=false;
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef Point3<typename MESH_TYPE::ScalarType> Point3x;
|
||||||
|
|
||||||
|
typedef typename MESH_TYPE::CoordType CoordType;
|
||||||
|
typedef typename MESH_TYPE::ScalarType ScalarType;
|
||||||
|
typedef typename MESH_TYPE::VertexType VertexType;
|
||||||
|
typedef typename MESH_TYPE::VertexPointer VertexPointer;
|
||||||
|
typedef typename MESH_TYPE::VertexIterator VertexIterator;
|
||||||
|
typedef typename MESH_TYPE::FaceIterator FaceIterator;
|
||||||
|
typedef typename MESH_TYPE::FaceType FaceType;
|
||||||
|
typedef Matrix44<ScalarType> Matrix44x;
|
||||||
|
typedef Box3<ScalarType> Box3x;
|
||||||
|
|
||||||
|
// The Basic Data the mesh and its wrapper;
|
||||||
|
MESH_TYPE &m;
|
||||||
|
|
||||||
|
std::vector<MESH_TYPE *> OMV; // Occluder Mesh Vector;
|
||||||
|
|
||||||
|
// la visibilita' e' in float, per ogni entita'
|
||||||
|
// 1 significa che e' totalmente visibile per una data direzione.
|
||||||
|
|
||||||
|
std::vector<float> VV;
|
||||||
|
std::vector< Point3x > VN; // Vettore delle normali che ho usato per calcolare la mask e i float in W;
|
||||||
|
|
||||||
|
// User defined parameters and flags
|
||||||
|
bool IsClosed;
|
||||||
|
float ZTWIST;
|
||||||
|
bool CullFlag; // Enable the frustum culling. Useful when the splitting value is larger than 2
|
||||||
|
int SplitNum;
|
||||||
|
protected:
|
||||||
|
bool CameraViewing;
|
||||||
|
//Camera<ScalarType> Cam;
|
||||||
|
public:
|
||||||
|
|
||||||
|
/********************************************************/
|
||||||
|
// Generic functions with Specialized code for every subclass
|
||||||
|
virtual void MapVisibility(float Gamma=1, float LowPass=0, float HighPass=1,bool FalseColor=false)=0;
|
||||||
|
//virtual void ApplyLightingEnvironment(std::vector<float> &W, float Gamma);
|
||||||
|
|
||||||
|
virtual int GLAccumPixel( std::vector<int> &PixSeen)=0;
|
||||||
|
|
||||||
|
virtual bool ReadVisibility(const char * /*filename*/){assert( 0); return false;}
|
||||||
|
virtual bool WriteVisibility(const char * /*filename*/){assert( 0); return false;}
|
||||||
|
|
||||||
|
/********************************************************/
|
||||||
|
// Generic functions with same code for every subclass
|
||||||
|
|
||||||
|
void Clear() { fill(VV.begin(),VV.end(),0); }
|
||||||
|
|
||||||
|
void InitGL()
|
||||||
|
{
|
||||||
|
glPushAttrib(GL_COLOR_BUFFER_BIT );
|
||||||
|
::glClearColor (1.0, 1.0, 1.0, 0.0);
|
||||||
|
glMatrixMode (GL_PROJECTION);
|
||||||
|
glPushMatrix();
|
||||||
|
glMatrixMode (GL_MODELVIEW);
|
||||||
|
glPushMatrix();
|
||||||
|
}
|
||||||
|
|
||||||
|
void RestoreGL()
|
||||||
|
{
|
||||||
|
glMatrixMode (GL_PROJECTION);
|
||||||
|
glPopMatrix();
|
||||||
|
glMatrixMode (GL_MODELVIEW);
|
||||||
|
glPopMatrix();
|
||||||
|
glPopAttrib();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
Funzione principale di conversione in visibilita'
|
||||||
|
Dati i due vettori PixSeen e PixNotSeen che indicano per ogni entita' (vertice o faccia)
|
||||||
|
quanti sono, rispettivamente, i pixel visibili e occlusi,
|
||||||
|
questa funzione calcola un valore float per ogni entita' che indica quanto e' visibile lungo una data direzione camera
|
||||||
|
== 1 significa completamente visibile
|
||||||
|
== 0 significa completamente occluso.
|
||||||
|
|
||||||
|
*/
|
||||||
|
void AddPixelCount(std::vector<float> &_VV, const std::vector<int> &PixSeen)
|
||||||
|
{
|
||||||
|
assert(_VV.size()==PixSeen.size());
|
||||||
|
for(int i=0;i<PixSeen.size();++i)
|
||||||
|
if(PixSeen[i]>0) _VV[i]+= 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//void SetVisibilityMask(std::vector< std::bitset<MAXVIS> > &_VM, const std::vector<int> &PixSeen, const int dir)
|
||||||
|
// {
|
||||||
|
// assert(_VM.size()==PixSeen.size());
|
||||||
|
// for(int i=0;i<PixSeen.size();++i)
|
||||||
|
// if(PixSeen[i]>0) _VM[i][dir]=true;
|
||||||
|
// }
|
||||||
|
|
||||||
|
/*******************************
|
||||||
|
Funzioni ad alto livello che computano le Visibility Mask per varie distribuzioni di direzioni
|
||||||
|
|
||||||
|
|
||||||
|
*******************************/
|
||||||
|
|
||||||
|
// Funzione Generica chiamata da tutte le seguenti
|
||||||
|
void Compute( CallBack *cb)
|
||||||
|
{
|
||||||
|
//cb(buf.format("Start to compute %i dir\n",VN.size()));
|
||||||
|
InitGL();
|
||||||
|
VV.resize(m.vert.size());
|
||||||
|
vector<int> PixSeen(VV.size(),0);
|
||||||
|
|
||||||
|
for(int i=0;i<VN.size();++i)
|
||||||
|
{
|
||||||
|
int t0=clock();
|
||||||
|
fill(PixSeen.begin(),PixSeen.end(),0);
|
||||||
|
int added=SplittedRendering(VN[i], PixSeen,cb);
|
||||||
|
AddPixelCount(VV,PixSeen);
|
||||||
|
int t1=clock();
|
||||||
|
printf("ComputeSingleDir %i on %i : %i msec\n",i,VN.size(),t1-t0);
|
||||||
|
}
|
||||||
|
|
||||||
|
RestoreGL();
|
||||||
|
}
|
||||||
|
|
||||||
|
void ComputeCone(int nn, Point3x &dir, ScalarType ConeAngleDeg, CallBack *cb)
|
||||||
|
{
|
||||||
|
string buf;
|
||||||
|
ScalarType ConeAngleRad=ToRad(ConeAngleDeg);
|
||||||
|
ScalarType SolidAngleSter = (1.0 - Cos(ConeAngleRad))*2*M_PI;
|
||||||
|
int Frac=(4.0*M_PI)/SolidAngleSter;
|
||||||
|
printf("ComputeCone for an angle of %f , solidAngle =%f pi asked %i normals, forecasted we need to ask %i normals\n",
|
||||||
|
ConeAngleDeg,SolidAngleSter/M_PI,nn,nn*Frac);
|
||||||
|
|
||||||
|
VN.clear();
|
||||||
|
vector<Point3x> nvt;
|
||||||
|
GenNormal(nn*Frac,nvt);
|
||||||
|
ScalarType CosConeAngle=Cos(ConeAngleRad);
|
||||||
|
for(int i=0;i<nvt.size();++i)
|
||||||
|
if(dir*nvt[i]>=CosConeAngle) VN.push_back(nvt[i]);
|
||||||
|
|
||||||
|
printf("Asked %i normal, got %i normals\n",nn,VN.size());
|
||||||
|
Compute(cb);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ComputeHalf(int nn, Point3x &dir, CallBack *cb)
|
||||||
|
{
|
||||||
|
string buf;
|
||||||
|
|
||||||
|
VN.clear();
|
||||||
|
vector<Point3x> nvt;
|
||||||
|
GenNormal(nn*2,nvt);
|
||||||
|
for(int i=0;i<nvt.size();++i)
|
||||||
|
if(dir*nvt[i]>0) VN.push_back(nvt[i]);
|
||||||
|
|
||||||
|
printf("Asked %i normal, got %i normals\n",nn,VN.size());
|
||||||
|
Compute(cb);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ComputeUniform(int nn, CallBack *cb)
|
||||||
|
{
|
||||||
|
VN.clear();
|
||||||
|
GenNormal(nn,VN);
|
||||||
|
char buf[256];
|
||||||
|
sprintf(buf,"Asked %i normal, got %i normals\n",nn,VN.size());
|
||||||
|
cb(buf);
|
||||||
|
Compute(cb);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ComputeSingle(Point3x &dir, CallBack *cb)
|
||||||
|
{
|
||||||
|
VN.clear();
|
||||||
|
VN.push_back(dir);
|
||||||
|
printf("Computing one direction (%f %f %f)\n",dir[0],dir[1],dir[2]);
|
||||||
|
Compute(cb);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**********************************************************/
|
||||||
|
|
||||||
|
int SplittedRendering(Point3x &ViewDir, std::vector<int> &PixSeen, CallBack *cb=DummyCallBack)
|
||||||
|
{
|
||||||
|
int tt=0;
|
||||||
|
int i,j;
|
||||||
|
for(i=0;i<SplitNum;++i)
|
||||||
|
for(j=0;j<SplitNum;++j){
|
||||||
|
SetupOrthoViewMatrix(ViewDir, i,j,SplitNum);
|
||||||
|
tt+=GLAccumPixel(PixSeen);
|
||||||
|
}
|
||||||
|
return tt;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Compute a rotation matrix that bring Axis parallel to Z.
|
||||||
|
void GenMatrix(Matrix44d &a, Point3d Axis, double angle)
|
||||||
|
{
|
||||||
|
const double eps=1e-5;
|
||||||
|
Point3d RotAx = Axis ^ Point3d(0,0,1);
|
||||||
|
double RotAngle = Angle(Axis,Point3d(0,0,1));
|
||||||
|
|
||||||
|
if(math::Abs(RotAx.Norm())<eps) { // in questo caso Axis e' collineare con l'asse z
|
||||||
|
RotAx=Point3d(0,1,0);
|
||||||
|
double RotAngle = Angle(Axis,Point3d(0,1,0));
|
||||||
|
}
|
||||||
|
//printf("Rotating around (%5.3f %5.3f %5.3f) %5.3f\n",RotAx[0],RotAx[1],RotAx[2],RotAngle);
|
||||||
|
a.SetRotate(-RotAngle,RotAx);
|
||||||
|
//Matrix44d rr;
|
||||||
|
//rr.SetRotate(-angle, Point3d(0,0,1));
|
||||||
|
//a=rr*a;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Genera la matrice di proj e model nel caso di un rendering ortogonale.
|
||||||
|
// subx e suby indicano la sottoparte che si vuole
|
||||||
|
void SetupOrthoViewMatrix(Point3x &ViewDir, int subx, int suby,int LocSplit)
|
||||||
|
{
|
||||||
|
glMatrixMode (GL_PROJECTION);
|
||||||
|
glLoadIdentity ();
|
||||||
|
float dlt=2.0f/LocSplit;
|
||||||
|
|
||||||
|
glOrtho(-1+subx*dlt, -1+(subx+1)*dlt, -1+suby*dlt, -1+(suby+1)*dlt,-2,2);
|
||||||
|
glMatrixMode (GL_MODELVIEW);
|
||||||
|
glLoadIdentity ();
|
||||||
|
Matrix44d rot;
|
||||||
|
Point3d qq; qq.Import(ViewDir);
|
||||||
|
GenMatrix(rot,qq,0);
|
||||||
|
glMultMatrixd((const double *)&rot);
|
||||||
|
double d=2.0/m.bbox.Diag();
|
||||||
|
glScalef(d,d,d);
|
||||||
|
glTranslate(-m.bbox.Center());
|
||||||
|
}
|
||||||
|
|
||||||
|
void ComputeSingleDirection(Point3x BaseDir, std::vector<int> &PixSeen, CallBack *cb=DummyCallBack)
|
||||||
|
{
|
||||||
|
int t0=clock();
|
||||||
|
string buf;
|
||||||
|
|
||||||
|
int added=SplittedRendering(BaseDir, PixSeen,cb);
|
||||||
|
int t1=clock();
|
||||||
|
printf("ComputeSingleDir %i msec\n",t1-t0);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ComputeAverageVisibilityDirection()
|
||||||
|
{
|
||||||
|
int i,j;
|
||||||
|
VD.resize(VM.size());
|
||||||
|
for(j=0;j<VM.size();++j)
|
||||||
|
{
|
||||||
|
Point3x &nn=VD[j];
|
||||||
|
nn=Point3x(0,0,0);
|
||||||
|
bitset<VisMax> &msk=VM[j];
|
||||||
|
for(i=0;i<VN.size();++i)
|
||||||
|
if(msk[i]) nn+=VN[i];
|
||||||
|
}
|
||||||
|
for(j=0;j<VM.size();++j)
|
||||||
|
VD[j].Normalize();
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
// calcola un LightingEnvironment direzionale, cioe'un vettore di pesi per l'insieme di normali
|
||||||
|
// corrente tale che
|
||||||
|
// mette a 1 tutti i vettori che sono entro un angolo DegAngle1
|
||||||
|
// a 0 tutti quelli oltre DegAngle2 e
|
||||||
|
// sfuma linearmente nel mezzo.
|
||||||
|
void DirectionalLightingEnvironment(std::vector<float> &LE, Point3x dir, ScalarType DegAngle1, ScalarType DegAngle2)
|
||||||
|
{
|
||||||
|
LE.clear();
|
||||||
|
LE.resize(VN.size(),0);
|
||||||
|
int i;
|
||||||
|
for(i=0;i<VN.size();++i)
|
||||||
|
{
|
||||||
|
ScalarType a=ToDeg(Angle(dir,VN[i]));
|
||||||
|
if(a<DegAngle1) { LE[i]=1; continue; }
|
||||||
|
if(a>DegAngle2) { LE[i]=0; continue; }
|
||||||
|
LE[i] = 1.0-(a-DegAngle1)/(DegAngle2-DegAngle1);
|
||||||
|
|
||||||
|
}
|
||||||
|
// last step normalize the weights;
|
||||||
|
ScalarType sum=0;
|
||||||
|
for(i=0;i<VN.size();++i)
|
||||||
|
sum+=LE[i];
|
||||||
|
for(i=0;i<VN.size();++i)
|
||||||
|
LE[i]/=sum;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
};
|
||||||
|
/***************************************************************************/
|
||||||
|
/***************************************************************************/
|
||||||
|
/***************************************************************************/
|
||||||
|
|
||||||
|
template <class MESH_TYPE> class VertexVisShader : public VisShader<MESH_TYPE>
|
||||||
|
{
|
||||||
|
public :
|
||||||
|
|
||||||
|
// Function Members
|
||||||
|
VertexVisShader(MESH_TYPE &me):VisShader<MESH_TYPE>(me)
|
||||||
|
{
|
||||||
|
// la mesh DEVE avere colore per vertice
|
||||||
|
if(! m.HasPerVertexColor()) assert(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Init() { VV.resize(m.vert.size()); AssignColorId(); }
|
||||||
|
// Vis::VisMode Id() {return Vis::VMPerVert;};
|
||||||
|
void Compute(int nn);
|
||||||
|
|
||||||
|
void AddPixelCount(std::vector<float> &_VV, std::vector<int> &PixSeen, std::vector<int> &PixNotSeen )
|
||||||
|
{
|
||||||
|
for(int i=0;i<m.vert.size();++i)
|
||||||
|
_VV[i]+= float(PixSeen[i])/float(PixSeen[i]-PixNotSeen[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
void DrawFill(MESH_TYPE &mm)
|
||||||
|
{
|
||||||
|
glBegin(GL_TRIANGLES);
|
||||||
|
MESH_TYPE::FaceIterator fi;
|
||||||
|
for(fi=mm.face.begin();fi!=mm.face.end();++fi)
|
||||||
|
{
|
||||||
|
glVertex((*fi).V(0)->P());
|
||||||
|
glVertex((*fi).V(1)->P());
|
||||||
|
glVertex((*fi).V(2)->P());
|
||||||
|
}
|
||||||
|
glEnd();
|
||||||
|
}
|
||||||
|
|
||||||
|
/***************************************************************************/
|
||||||
|
|
||||||
|
//VertexVisibility
|
||||||
|
// Funzione Principale restituisce per ogni entita' quanti px si vedono o no.
|
||||||
|
int GLAccumPixel( std::vector<int> &PixSeen)
|
||||||
|
{
|
||||||
|
SimplePic<float> snapZ;
|
||||||
|
SimplePic<Color4b> snapC;
|
||||||
|
|
||||||
|
glClearColor(Color4b::White);
|
||||||
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||||
|
glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT | GL_LIGHTING_BIT | GL_POLYGON_BIT );
|
||||||
|
glDisable(GL_LIGHTING);
|
||||||
|
glDepthRange(0.0f,1.0f);
|
||||||
|
glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
|
||||||
|
glDepthMask(GL_TRUE);
|
||||||
|
glDrawBuffer(GL_BACK);
|
||||||
|
glReadBuffer(GL_BACK);
|
||||||
|
|
||||||
|
/////** Si disegnano le front face **/////
|
||||||
|
glDepthRange(2.0*ZTWIST,1.0f);
|
||||||
|
// glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
|
||||||
|
glEnable(GL_CULL_FACE);
|
||||||
|
glCullFace(GL_BACK);
|
||||||
|
glColor(Color4b::Red);
|
||||||
|
DrawFill(m);
|
||||||
|
snapC.OpenGLSnap();
|
||||||
|
|
||||||
|
// if(!IsClosed) // sono necessarie due passate in piu!
|
||||||
|
//{
|
||||||
|
// /////** Si disegnano le back face shiftate in avanti di 2 epsilon **/////
|
||||||
|
// glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
|
||||||
|
// glColor(Color4b::Black);
|
||||||
|
// glCullFace(GL_FRONT);
|
||||||
|
// glDepthRange(0.0f,1.0f-2.0*ZTWIST);
|
||||||
|
// DrawFill(m);
|
||||||
|
// //glw.DrawFill<GLW::NMNone, GLW::CMNone,GLW::TMNone>();
|
||||||
|
//}
|
||||||
|
//if(OMV.size()>0)
|
||||||
|
//{
|
||||||
|
// /////** Si disegnano le back face shiftate in avanti di 2 epsilon **/////
|
||||||
|
// glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
|
||||||
|
// glColor(Color4b::Black);
|
||||||
|
// glDisable(GL_CULL_FACE);
|
||||||
|
// glDepthRange(0.0f,1.0f-2.0*ZTWIST);
|
||||||
|
// for(unsigned int i=0;i<OMV.size();++i)
|
||||||
|
// DrawFill(*(OMV[i]));
|
||||||
|
// //OGV[i]->DrawFill<GLW::NMNone, GLW::CMNone,GLW::TMNone>();
|
||||||
|
//}
|
||||||
|
int cnt=0;
|
||||||
|
snapZ.OpenGLSnap(GL_DEPTH_COMPONENT);
|
||||||
|
snapC.OpenGLSnap();
|
||||||
|
double MM[16];
|
||||||
|
glGetDoublev(GL_MODELVIEW_MATRIX,MM);
|
||||||
|
double MP[16];
|
||||||
|
glGetDoublev(GL_PROJECTION_MATRIX,MP);
|
||||||
|
int VP[4];
|
||||||
|
glGetIntegerv(GL_VIEWPORT,VP);
|
||||||
|
double tx,ty,tz;
|
||||||
|
for(int i=0;i<m.vert.size();++i)
|
||||||
|
{
|
||||||
|
gluProject(m.vert[i].P()[0],m.vert[i].P()[1],m.vert[i].P()[2],
|
||||||
|
MM,MP,VP,
|
||||||
|
&tx,&ty,&tz);
|
||||||
|
if(tx>=0 && tx<snapZ.sx && ty>=0 && ty<snapZ.sy)
|
||||||
|
{
|
||||||
|
int txi=floor(tx),tyi=floor(ty);
|
||||||
|
float sd=snapZ.Pix(tx,ty);
|
||||||
|
|
||||||
|
int col = min( min(snapC.Pix(txi+0,tyi+0)[0],snapC.Pix(txi+1,tyi+0)[0]),
|
||||||
|
min(snapC.Pix(txi+0,tyi+1)[0],snapC.Pix(txi+1,tyi+1)[0]));
|
||||||
|
if(col!=0)
|
||||||
|
if(tz<sd+ZTWIST) {
|
||||||
|
PixSeen[i]++;
|
||||||
|
cnt++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
glPopAttrib();
|
||||||
|
printf("Seen %i vertexes on %i\n",cnt,m.vert.size());
|
||||||
|
return cnt;
|
||||||
|
}
|
||||||
|
|
||||||
|
void SmoothVisibility()
|
||||||
|
{
|
||||||
|
MESH_TYPE::FaceIterator fi;
|
||||||
|
vector<float> VV2;
|
||||||
|
vector<int> VC(VV.size(),1);
|
||||||
|
VV2=VV;
|
||||||
|
for(fi=m.face.begin();fi!=m.face.end();++fi)
|
||||||
|
for(int i=0;i<3;++i)
|
||||||
|
{
|
||||||
|
VV2[(*fi).V(i)-&*m.vert.begin()] += VV[(*fi).V1(i)-&*m.vert.begin()];
|
||||||
|
++VC[(*fi).V(i)-&*m.vert.begin()];
|
||||||
|
}
|
||||||
|
|
||||||
|
for(unsigned int i=0;i<VV2.size();++i)
|
||||||
|
VV[i]=VV2[i]/VC[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
void MapVisibility(float Gamma=1, float LowPass=0, float HighPass=1, bool FalseColor = false)
|
||||||
|
{
|
||||||
|
float minv=*min_element(VV.begin(),VV.end());
|
||||||
|
float maxv=*max_element(VV.begin(),VV.end());
|
||||||
|
printf("Visibility Range %f %f\n", minv,maxv);
|
||||||
|
|
||||||
|
MESH_TYPE::VertexIterator vi;
|
||||||
|
for(vi=m.vert.begin();vi!=m.vert.end();++vi){
|
||||||
|
float gval=(VV[vi-m.vert.begin()]-minv)/(maxv-minv);
|
||||||
|
if(gval<LowPass) gval=LowPass;
|
||||||
|
if(gval>HighPass) gval=HighPass;
|
||||||
|
(*vi).C().SetGrayShade(pow((gval-LowPass)/(HighPass-LowPass),Gamma));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
//void ApplyLightingEnvironment(std::vector<float> &W, float Gamma=1)
|
||||||
|
// {
|
||||||
|
// assert(W.size()==VN.size());
|
||||||
|
// MESH_TYPE::VertexIterator vi;
|
||||||
|
//
|
||||||
|
// for(vi=m.vert.begin();vi!=m.vert.end();++vi)
|
||||||
|
// {
|
||||||
|
// float gray=0;
|
||||||
|
// bitset<VisMax> &msk=VM[vi-m.vert.begin()];
|
||||||
|
// for(int i=0;i<VN.size();++i)
|
||||||
|
// if(msk[i]) gray+=W[i];
|
||||||
|
//
|
||||||
|
// (*vi).C().SetGrayShade(gray);
|
||||||
|
// }
|
||||||
|
// }
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
#endif // __VCG_MESH_VISIBILITY
|
||||||
Loading…
Reference in New Issue