void GetRandPlane(Box3f &bb, Plane3f &plane)
{
Point3f planeCenter = bb.Center();
Point3f planeDir = Point3f(-0.5f+float(rand())/RAND_MAX,-0.5f+float(rand())/RAND_MAX,-0.5f+float(rand())/RAND_MAX);
planeDir.Normalize();
plane.Init(planeCenter+planeDir*0.3f*bb.Diag()*float(rand())/RAND_MAX,planeDir);
}
double GlobalFun::computeRealAngleOfTwoVertor(Point3f v0, Point3f v1)
{
v0.Normalize();
v1.Normalize();
if (isTwoPoint3fTheSame(v0, v1))
{
return 0;
}
if (isTwoPoint3fOpposite(v0, v1))
{
return 180;
}
double angle_cos = v0 * v1;
if (angle_cos > 1)
{
angle_cos = 0.99;
}
if (angle_cos < -1)
{
angle_cos = -0.99;
}
if (angle_cos > 0 && angle_cos < 1e-8)
{
return 90;
}
double angle = acos(angle_cos) * 180. / 3.1415926 ;
if (angle < 0 || angle > 180)
{
cout << "compute angle wrong!!" << endl;
//system("Pause");
return -1;
}
return angle;
}
Point3f RandomUnitVec(){
Point3f k;
do {
k=Point3f(
(random(200)-100)*0.01,
(random(200)-100)*0.01,
(random(200)-100)*0.01
);
} while (k.SquaredNorm()>1.0);
return k.Normalize();
}
//---------------------------------------------------------
void FSMAIControl::UpdatePerceptions(float dt)
{
if(m_willCollide)
m_safetyRadius = 30.0f;
else
m_safetyRadius = 15.0f;
//store closest asteroid and powerup
m_nearestAsteroid = Game.GetClosestGameObj(m_ship,GameObj::OBJ_ASTEROID);
m_nearestPowerup = Game.GetClosestGameObj(m_ship,GameObj::OBJ_POWERUP);
//asteroid collision determination
m_willCollide = false;
if(m_nearestAsteroid)
{
float speed = m_ship->m_velocity.Length();
m_nearestAsteroidDist = m_nearestAsteroid->m_position.Distance(m_ship->m_position);
Point3f normDelta = m_nearestAsteroid->m_position - m_ship->m_position;
normDelta.Normalize();
float astSpeed = m_nearestAsteroid->m_velocity.Length();
float shpSpeedAdj = DOT(m_ship->UnitVectorVelocity(),normDelta)*speed;
float astSpeedAdj = DOT(m_nearestAsteroid->UnitVectorVelocity(),-normDelta)*astSpeed;
speed = shpSpeedAdj+astSpeedAdj;
// if(speed > astSpeed)
// dotVel = DOT(m_ship->UnitVectorVelocity(),normDelta);
// else
// {
// speed = astSpeed;
// dotVel = DOT(m_nearestAsteroid->UnitVectorVelocity(),-normDelta);
// }
float spdAdj = LERP(speed/m_maxSpeed,0.0f,90.0f);
float adjSafetyRadius = m_safetyRadius+spdAdj+m_nearestAsteroid->m_size;
//if you're too close, and I'm heading somewhat towards you,
//flag a collision
if(m_nearestAsteroidDist <= adjSafetyRadius && speed > 0)
m_willCollide = true;
}
//powerup near determination
m_powerupNear = false;
if(m_nearestPowerup)
{
m_nearestPowerupDist = m_nearestPowerup->m_position.Distance(m_ship->m_position);
if(m_nearestPowerupDist <= POWERUP_SCAN_DIST)
{
m_powerupNear = true;
}
}
}
int main( int argc, char **argv )
{
if(argc<2)
{
printf("Usage trimesh_base <meshfilename.ply>\n");
return -1;
}
MyMesh m,em,cm,full;
if(tri::io::ImporterPLY<MyMesh>::Open(m,argv[1])!=0)
{
printf("Error reading file %s\n",argv[1]);
exit(0);
}
tri::UpdateFlags<MyMesh>::FaceBorderFromFF(m);
tri::UpdateNormals<MyMesh>::PerVertexNormalized(m);
tri::UpdateBounding<MyMesh>::Box(m);
printf("Input mesh vn:%i fn:%i\n",m.vn,m.fn);
printf( "Mesh has %i vert and %i faces\n", m.vn, m.fn );
srand(time(0));
Plane3f slicingPlane;
Point3f planeCenter = m.bbox.Center();
for(int i=0;i<10;++i)
{
cm.Clear();
em.Clear();
Point3f planeDir = Point3f(-0.5f+float(rand())/RAND_MAX,-0.5f+float(rand())/RAND_MAX,-0.5f+float(rand())/RAND_MAX);
planeDir.Normalize();
printf("slicing dir %5.2f %5.2f %5.2f\n",planeDir[0],planeDir[1],planeDir[2]);
slicingPlane.Init(planeCenter+planeDir*0.3f*m.bbox.Diag()*float(rand())/RAND_MAX,planeDir);
vcg::IntersectionPlaneMesh<MyMesh, MyMesh, float>(m, slicingPlane, em );
tri::Clean<MyMesh>::RemoveDuplicateVertex(em);
vcg::tri::CapEdgeMesh(em,cm);
printf(" edge mesh vn %5i en %5i fn %5i\n",em.vn,em.en,em.fn);
printf("sliced mesh vn %5i en %5i fn %5i\n",cm.vn,cm.en,cm.fn);
tri::Append<MyMesh,MyMesh>::Mesh(full,cm);
}
tri::io::ExporterPLY<MyMesh>::Save(full,"out.ply",false);
return 0;
}
double GlobalFun::computeProjPlusPerpenDist(Point3f& p1, Point3f& p2, Point3f& normal_of_p1)
{
normal_of_p1.Normalize();
double proj_dist = GlobalFun::computeProjDist(p1, p2, normal_of_p1);
if (proj_dist <= 0)
{
return -1.;
}
Point3f proj_p = p1 + normal_of_p1 * proj_dist;
double perpend_dist = sqrt((proj_p - p2).SquaredNorm());
double eular_dist = GlobalFun::computeEulerDist(p1, p2);
return eular_dist + perpend_dist;
/*return proj_dist * 0.5 + perpend_dist;*/
}
// Core Function doing the actual mesh processing.
bool RangeMapPlugin::applyFilter(QAction *filter, MeshDocument &m, FilterParameterSet & par, vcg::CallBackPos *cb)
{
CMeshO::FaceIterator fi;
switch(ID(filter))
{
case FP_SELECTBYANGLE :
{
bool usecam = par.getBool("usecamera");
Point3f viewpoint = par.getPoint3f("viewpoint");
// if usecamera but mesh does not have one
if( usecam && !m.mm()->hasDataMask(MeshModel::MM_CAMERA) )
{
errorMessage = "Mesh has not a camera that can be used to compute view direction. Please set a view direction."; // text
return false;
}
if(usecam)
{
viewpoint = m.mm()->cm.shot.GetViewPoint();
}
// angle threshold in radians
float limit = cos( math::ToRad(par.getDynamicFloat("anglelimit")) );
Point3f viewray;
for(fi=m.mm()->cm.face.begin();fi!=m.mm()->cm.face.end();++fi)
if(!(*fi).IsD())
{
viewray = viewpoint - Barycenter(*fi);
viewray.Normalize();
if((viewray.dot((*fi).N().Normalize())) < limit)
fi->SetS();
}
}
break;
}
return true;
}
AO::AO( Point3f _dir, Mol &m) {
dir=_dir.Normalize();
// orthonormal basis
Point3f ax,ay,az=dir;
ax=az^Point3f(1,0,0);
if (ax.SquaredNorm()<0.1) ax=az^Point3f(0,1,0);
ax=ax.Normalize();
ay=(az^ax).Normalize();
// project...
m.Transform(ax,ay,az);
int target=32; //
bufx=bufy=target;
float bufscalex=target/(m.tx1-m.tx0);
float bufscaley=target/(m.ty1-m.ty0);
bufscale=(bufscalex<bufscaley)?bufscalex:bufscaley;
m.ScaleTransl(bufscale);
CubeMapSamp::Transform(ax,ay,az);
printf("Scale=%f\n",bufscale);
buf.resize(target*target,infty);
for (int i=0; i<m.atom.size()-1; i++) {
QAtom &a=m.atom[i];
CheckAtom(a);
RenderSphere( a.trp[0], a.trp[1], a.trp[2], a.trr );
PrintBuffer();
}
}
int main(int argc,char ** argv)
{
if (argc<2)
{
printf("\n");
printf(" Compute an approximation of the shape diameter function\n");
printf(" Usage: trimesh_intersection <filename> [angle samplenum]\n\n");
printf(" <filename> Mesh model for which to compute the sdf (PLY format).\n");
printf(" angle the wideness (degree) of the cone of ray that must be shot from each vertex (default 45)\n");
printf(" samplenum the oversampling factor (0 -> one ray, 1, 9 ray, 2-> 25 rays (default 2)\n");
return 0;
}
MyMesh m;
int t0=clock();
// open a mesh
int err = tri::io::Importer<MyMesh>::Open(m,argv[1]);
if(err) {
printf("Error in reading %s: '%s'\n",argv[1],tri::io::Importer<MyMesh>::ErrorMsg(err));
exit(-1);
}
// the other parameters
float widenessRad = math::ToRad(20.0);
if(argc>2) {
widenessRad = math::ToRad(atof(argv[2]));
printf("Setting wideness to %f degree\n",atof(argv[2]));
}
int n_samples=2;
if(argc>3) n_samples = atoi(argv[3]);
int samplePerVert = (n_samples*2+ 1)*(n_samples*2+ 1);
printf("Using oversampling to %i (%i sample per vertex)\n",n_samples,samplePerVert);
// some cleaning to get rid of bad stuff
int dup = tri::Clean<MyMesh>::RemoveDuplicateVertex(m);
int unref = tri::Clean<MyMesh>::RemoveUnreferencedVertex(m);
if (dup > 0 || unref > 0)
printf("Removed %i duplicate and %i unreferenced vertices from mesh %s\n",dup,unref,argv[1]);
// updating
tri::UpdateBounding<MyMesh>::Box(m);
tri::UpdateNormals<MyMesh>::PerFaceNormalized(m);
tri::UpdateNormals<MyMesh>::PerVertexAngleWeighted(m);
tri::UpdateNormals<MyMesh>::NormalizeVertex(m);
tri::UpdateFlags<MyMesh>::FaceProjection(m);
// Create a static grid (for fast indexing) and fill it
TriMeshGrid static_grid;
static_grid.Set(m.face.begin(), m.face.end());
typedef MyMesh::ScalarType ScalarType;
int t1=clock();
float t;
MyMesh::FaceType *rf;
MyMesh::VertexIterator vi;
float maxDist=m.bbox.Diag();
float offset= maxDist / 10000.0;
int totRay=0;
ScalarType deltaRad=widenessRad/(ScalarType)(n_samples*2);
if(n_samples==0) deltaRad=0;
tri::UpdateQuality<MyMesh>::VertexConstant(m,0);
for(vi=m.vert.begin();vi!=m.vert.end();++vi)
{
vcg::Ray3f ray;
ray.SetOrigin((*vi).cP()-((*vi).cN()*offset));
Point3f dir0 = -(*vi).cN();
int cnt=0;
ScalarType theta_init,phi_init,ro;
dir0.ToPolarRad(ro,theta_init,phi_init);
for (int x=-n_samples;x<=n_samples;x++)
for (int y=-n_samples;y<=n_samples;y++)
{
ScalarType theta=theta_init+x*deltaRad;
ScalarType phi=phi_init+y*deltaRad;
if (theta<0) theta=2.0*M_PI+theta;
Point3f dir;
dir.FromPolarRad(ro,theta,phi);
dir.Normalize();
ray.SetDirection(dir);
rf = tri::DoRay<MyMesh,TriMeshGrid>(m,static_grid,ray,maxDist,t);
if(rf)
{
(*vi).Q()+=t;
cnt++;
}
}
if(cnt>0){
(*vi).Q()/=cnt;
totRay+=cnt;
}
}
int t2 = clock();
tri::UpdateColor<MyMesh>::VertexQualityRamp(m);
tri::io::ExporterPLY<MyMesh>::Save(m,"SDF.ply",tri::io::Mask::IOM_VERTCOLOR+tri::io::Mask::IOM_VERTQUALITY);
printf("Initializated in %i msec\n",t1-t0);
printf("Completed in %i msec\n",t2-t1);
printf("Shoot %i rays and found %i intersections\n",m.vn*samplePerVert,totRay);
return 0;
}
double GlobalFun::computeProjDist(Point3f& p1, Point3f& p2, Point3f& normal_of_p1)
{
return (p2-p1) * normal_of_p1.Normalize();
}
//---------------------------------------------------------
void Ship::AGThrustOn(Point3f &offset)
{
m_agThrust = true;
m_agNorm = offset.Normalize();
m_agNorm;
}
//---------------------------------------------------------
Point3f GameObj::UnitVectorVelocity()
{
Point3f temp = m_velocity;
temp.Normalize();
return temp;
};