int main(int argc, char *argv[])
{
QApplication a(argc, argv);
/*MainWindow w;
w.show();*/
Vector<float, 2> A = Vector<float, 2>(0.0f);
Vector<float, 2> B = Vector<float, 2>(0.0f);
A[0] = 1.0f;
A[1] = 0.5f;
B[0] = 2.0f;
B[1] = 4.0f;
Vector<float, 2> C = Vector<float, 2>(B);
Vec3f D = Vec3f(0.0f, 5.0f, 2.0f);
Vec3f E = Vec3f(D);
E[0] = 1.0f;
Vec3f F = Vec3f(E);
Vec2f translation = Vec2f(C);
Matrix33f T = Matrix33f(D, E, F);
Matrix33f M = T;
Matrix33f R = T.applyTranslation(translation);
R.applyRotation(30.0f);
std::cout << "C :" << C << std::endl;
std::cout << "T : {" << T[0] << ", " << T[1] << ", "
<< T[2] << "}" << std::endl;
std::cout << "M : {" << M[0] << ", " << M[1] << ", "
<< M[2] << "}" << std::endl;
std::cout << "R : {" << R[0] << ", " << R[1] << ", "
<< R[2] << "}" << std::endl;
return a.exec();
}
Matrix33f toMatrix33f( const Leap::Matrix& m )
{
Matrix33f mtx;
Leap::FloatArray a = m.toArray3x3();
for ( size_t i = 0; i < 3; ++i ) {
size_t j = i * 3;
Vec3f row( a[ j + 0 ], a[ j + 1 ], a[ j + 2 ] );
mtx.setRow( i, row );
}
return mtx;
}
void set_rotate(Matrix33f &m, float radian)
{
float sina = std::sin(radian);
m.makeIdentity();
m[0][0] = m[1][1] = std::cos(radian);
m[0][1] = -sina;
m[1][0] = sina;
}
void AppRenderer::draw(Matrix33f transform, Model * model) {
if (model->getDigit() != ' ') {
std::ostringstream oss(2);
oss << "digit: " << model->getDigit() << std::ends;
std::string word;
Vec3f temp = transform.transformVec(Vec3f(0, 1.0, 1.0));
Vec2f BL = Vec2f(temp.x, temp.y);
cinder::Font textfont = Font("Courier New", 20);
gl::drawString(oss.str(), BL, ColorA(1.0, 1.0, 1.0, 1.1), textfont);
}
}
Matrix33f Matrix33f::transposed( void )
{
Matrix33f m = *this;
m.transpose();
return m;
}
// The Real Core Function doing the actual mesh processing.
bool FilterCreate::applyFilter(QAction *filter, MeshDocument &md, RichParameterSet & par, CallBackPos * /*cb*/)
{
MeshModel & currM = *md.mm();
MeshModel* m;
switch(ID(filter))
{
case CR_TETRAHEDRON :
m = md.addNewMesh("", this->filterName(ID(filter)));
tri::Tetrahedron<CMeshO>(m->cm);
break;
case CR_ICOSAHEDRON:
m = md.addNewMesh("", this->filterName(ID(filter)));
tri::Icosahedron<CMeshO>(m->cm);
break;
case CR_DODECAHEDRON:
m = md.addNewMesh("", this->filterName(ID(filter)));
tri::Dodecahedron<CMeshO>(m->cm);
m->updateDataMask(MeshModel::MM_POLYGONAL);
break;
case CR_OCTAHEDRON:
m = md.addNewMesh("", this->filterName(ID(filter)));
tri::Octahedron<CMeshO>(m->cm);
break;
case CR_ANNULUS:
m = md.addNewMesh("", this->filterName(ID(filter)));
tri::Annulus<CMeshO>(m->cm,par.getFloat("internalRadius"), par.getFloat("externalRadius"), par.getInt("sides"));
break;
case CR_TORUS:
{
m = md.addNewMesh("", this->filterName(ID(filter)));
float hRadius=par.getFloat("hRadius");
float vRadius=par.getFloat("vRadius");
int hSubdiv=par.getInt("hSubdiv");
int vSubdiv=par.getInt("vSubdiv");
tri::Torus(m->cm,hRadius,vRadius,hSubdiv,vSubdiv);
} break;
case CR_FITPLANE:
{
Box3m selBox; //boundingbox of the selected vertices
std::vector< Point3m > selected_pts; //copy of selected vertices, for plane fitting
if (&currM == NULL)
{
errorMessage = "No mesh layer selected";
return false;
}
if (currM.cm.svn == 0 && currM.cm.sfn == 0) // if no selection, fail
{
errorMessage = "No selection";
return false;
}
m = md.addNewMesh("", "Fitted Plane");
if (currM.cm.svn == 0 || currM.cm.sfn != 0)
{
tri::UpdateSelection<CMeshO>::VertexClear(currM.cm);
tri::UpdateSelection<CMeshO>::VertexFromFaceLoose(currM.cm);
}
Point3m Naccum = Point3m(0.0, 0.0, 0.0);
for (CMeshO::VertexIterator vi = currM.cm.vert.begin(); vi != currM.cm.vert.end(); ++vi)
if (!(*vi).IsD() && (*vi).IsS())
{
Point3m p = (*vi).P();
selBox.Add(p);
selected_pts.push_back(p);
Naccum = Naccum + (*vi).N();
}
Log("Using %i vertexes to build a fitting plane", int(selected_pts.size()));
Plane3m plane;
FitPlaneToPointSet(selected_pts, plane);
plane.Normalize();
// check if normal of the interpolated plane is coherent with average normal of the used points, otherwise, flip
// i do this because plane fitter does not take in account source noramls, and a fliped fit is terrible to see
Naccum = (Naccum / (CMeshO::ScalarType)selected_pts.size()).Normalize();
if ((plane.Direction() * Naccum) < 0.0)
plane.Set(-plane.Direction(), -plane.Offset());
float errorSum = 0;
for (size_t i = 0; i < selected_pts.size(); ++i)
errorSum += fabs(SignedDistancePlanePoint(plane, selected_pts[i]));
Log("Fitting Plane avg error is %f", errorSum / float(selected_pts.size()));
Log("Fitting Plane normal is [%f, %f, %f]", plane.Direction().X(), plane.Direction().Y(), plane.Direction().Z());
Log("Fitting Plane offset is %f", plane.Offset());
// find center of selection on plane
Point3m centerP;
for (size_t i = 0; i < selected_pts.size(); ++i)
{
centerP += plane.Projection(selected_pts[i]);
}
centerP /= selected_pts.size();
Log("center [%f, %f, %f]", centerP.X(), centerP.Y(), centerP.Z());
// find horizontal and vertical axis
Point3m dirH, dirV;
int orientation = par.getEnum("orientation");
if (orientation == 0)
{
if ((plane.Direction().X() <= plane.Direction().Y()) && (plane.Direction().X() <= plane.Direction().Z()))
dirH = Point3m(1.0, 0.0, 0.0) ^ plane.Direction();
else if ((plane.Direction().Y() <= plane.Direction().X()) && (plane.Direction().Y() <= plane.Direction().Z()))
dirH = Point3m(0.0, 1.0, 0.0) ^ plane.Direction();
else
dirH = Point3m(0.0, 0.0, 1.0) ^ plane.Direction();
dirH.Normalize();
dirV = dirH ^ plane.Direction();
dirV.Normalize();
}
else
{
Matrix33m cov;
vector<Point3m> PtVec;
for (size_t i = 0; i < selected_pts.size(); ++i)
PtVec.push_back(plane.Projection(selected_pts[i]));
cov.Covariance(PtVec, centerP);
Matrix33f eigenvecMatrix;
Point3f eigenvecVector;
Eigen::Matrix3d em;
cov.ToEigenMatrix(em);
Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d> eig(em);
Eigen::Vector3d c_val = eig.eigenvalues();
Eigen::Matrix3d c_vec = eig.eigenvectors();
eigenvecMatrix.FromEigenMatrix(c_vec);
eigenvecVector.FromEigenVector(c_val);
// max eigenvector is best horizontal axis, but is not guarantee is orthogonal to plane normal, so
// I use eigenvector ^ plane direction and assign it to vertical plane axis
if ((eigenvecVector[0]<=eigenvecVector[1]) && (eigenvecVector[0]<=eigenvecVector[2]))
dirV = Point3m(eigenvecMatrix[0][0], eigenvecMatrix[0][1], eigenvecMatrix[0][2]) ^ plane.Direction();
if ((eigenvecVector[1]<=eigenvecVector[0]) && (eigenvecVector[1]<=eigenvecVector[2]))
dirV = Point3m(eigenvecMatrix[1][0], eigenvecMatrix[1][1], eigenvecMatrix[1][2]) ^ plane.Direction();
else
dirV = Point3m(eigenvecMatrix[2][0], eigenvecMatrix[2][1], eigenvecMatrix[2][2]) ^ plane.Direction();
dirV.Normalize();
dirH = plane.Direction() ^ dirV;
dirH.Normalize();
}
Log("H [%f, %f, %f]", dirH.X(), dirH.Y(), dirH.Z());
Log("V [%f, %f, %f]", dirV.X(), dirV.Y(), dirV.Z());
// find extent
float dimH = -1000000;
float dimV = -1000000;
for (size_t i = 0; i < selected_pts.size(); ++i)
{
Point3m pp = plane.Projection(selected_pts[i]);
float distH = fabs(((pp - centerP) * dirH));
float distV = fabs(((pp - centerP) * dirV));
if (distH > dimH)
dimH = distH;
if (distV > dimV)
dimV = distV;
}
float exScale = par.getFloat("extent");
dimV = dimV * exScale;
dimH = dimH * exScale;
Log("extent on plane [%f, %f]", dimV, dimH);
int vertNum = par.getInt("subdiv") + 1;
if (vertNum <= 1) vertNum = 2;
int numV, numH;
numV = numH = vertNum;
// UV vector, just in case
float *UUs, *VVs;
UUs = new float[numH*numV];
VVs = new float[numH*numV];
int vind = 0;
for (int ir = 0; ir < numV; ir++)
for (int ic = 0; ic < numH; ic++)
{
Point3m newP = (centerP + (dirV * -dimV) + (dirH * -dimH));
newP = newP + (dirH * ic * (2.0 * dimH / (numH-1))) + (dirV * ir * (2.0 * dimV / (numV-1)));
tri::Allocator<CMeshO>::AddVertex(m->cm, newP, plane.Direction());
UUs[vind] = ic * (1.0 / (numH - 1));
VVs[vind] = ir * (1.0 / (numV - 1));
vind++;
}
FaceGrid(m->cm, numH, numV);
bool hasUV = par.getBool("hasuv");
if (hasUV)
{
m->updateDataMask(MeshModel::MM_WEDGTEXCOORD);
CMeshO::FaceIterator fi;
for (fi = m->cm.face.begin(); fi != m->cm.face.end(); ++fi)
{
for (int i = 0; i<3; ++i)
{
int vind = (*fi).V(i)->Index();
(*fi).WT(i).U() = UUs[vind];
(*fi).WT(i).V() = VVs[vind];
}
}
}
delete[] UUs; // delete temporary UV storage
delete[] VVs;
} break;
case CR_RANDOM_SPHERE:
{
int pointNum = par.getInt("pointNum");
int sphereGenTech = par.getEnum("sphereGenTech");
math::MarsenneTwisterRNG rng;
m = md.addNewMesh("", this->filterName(ID(filter)));
m->cm.Clear();
std::vector<Point3m> sampleVec;
switch(sphereGenTech)
{
case 0: // Montecarlo
{
for(int i=0;i<pointNum;++i)
sampleVec.push_back(math::GeneratePointOnUnitSphereUniform<CMeshO::ScalarType>(rng));
} break;
case 1: // Poisson Disk
{
int oversamplingFactor =100;
if(pointNum <= 100) oversamplingFactor = 1000;
if(pointNum >= 10000) oversamplingFactor = 50;
if(pointNum >= 100000) oversamplingFactor = 20;
CMeshO tt;
tri::Allocator<CMeshO>::AddVertices(tt,pointNum*oversamplingFactor);
for(CMeshO::VertexIterator vi=tt.vert.begin();vi!=tt.vert.end();++vi)
vi->P()=math::GeneratePointOnUnitSphereUniform<CMeshO::ScalarType>(rng);
tri::UpdateBounding<CMeshO>::Box(tt);
const float SphereArea = 4*M_PI;
float poissonRadius = 2.0*sqrt((SphereArea / float(pointNum*2))/M_PI);
std::vector<Point3m> sampleVec;
tri::TrivialSampler<CMeshO> pdSampler(sampleVec);
tri::SurfaceSampling<CMeshO, tri::TrivialSampler<CMeshO> >::PoissonDiskParam pp;
tri::SurfaceSampling<CMeshO,tri::TrivialSampler<CMeshO> >::PoissonDiskPruning(pdSampler, tt, poissonRadius, pp);
} break;
case 2: // Disco Ball
GenNormal<CMeshO::ScalarType>::DiscoBall(pointNum,sampleVec);
break;
case 3: // Recursive Oct
GenNormal<CMeshO::ScalarType>::RecursiveOctahedron(pointNum,sampleVec);
break;
case 4: // Fibonacci
GenNormal<CMeshO::ScalarType>::Fibonacci(pointNum,sampleVec);
break;
}
for(size_t i=0;i<sampleVec.size();++i)
tri::Allocator<CMeshO>::AddVertex(m->cm,sampleVec[i],sampleVec[i]);
} break;
case CR_SPHERE_CAP:
{
int rec = par.getInt("subdiv");
const float angleDeg = par.getFloat("angle");
m = md.addNewMesh("", this->filterName(ID(filter)));
m->updateDataMask(MeshModel::MM_FACEFACETOPO);
tri::UpdateTopology<CMeshO>::FaceFace(m->cm);
tri::SphericalCap(m->cm,math::ToRad(angleDeg),rec);
} break;
case CR_SPHERE:
{
int rec = par.getInt("subdiv");
float radius = par.getFloat("radius");
m = md.addNewMesh("", this->filterName(ID(filter)));
m->cm.face.EnableFFAdjacency();
m->updateDataMask(MeshModel::MM_FACEFACETOPO);
assert(tri::HasPerVertexTexCoord(m->cm) == false);
tri::Sphere<CMeshO>(m->cm,rec);
tri::UpdatePosition<CMeshO>::Scale(m->cm,radius);
} break;
case CR_BOX:
{
float sz=par.getFloat("size");
Box3m b(Point3m(1,1,1)*(-sz/2),Point3m(1,1,1)*(sz/2));
m = md.addNewMesh("", this->filterName(ID(filter)));
tri::Box<CMeshO>(m->cm,b);
m->updateDataMask(MeshModel::MM_POLYGONAL);
} break;
case CR_CONE:
{
float r0 = par.getFloat("r0");
float r1 = par.getFloat("r1");
float h = par.getFloat("h");
int subdiv = par.getInt("subdiv");
m = md.addNewMesh("", this->filterName(ID(filter)));
tri::Cone<CMeshO>(m->cm, r0, r1, h, subdiv);
} break;
}//CASE FILTER
tri::UpdateBounding<CMeshO>::Box(m->cm);
tri::UpdateNormal<CMeshO>::PerVertexNormalizedPerFaceNormalized(m->cm);
return true;
}
void TessellationSampleApp::update()
{
mNormalMatrix = mMayaCam.getCamera().getViewMatrix().subMatrix33(0,0);
mNormalMatrix.transpose();
}
void set_scale(Matrix33f &m, float sx, float sy)
{
m.makeIdentity();
m[0][0] = sx;
m[1][1] = sy;
}
void set_translate(Matrix33f &m, float dx, float dy)
{
m.makeIdentity();
m[0][2] = dx;
m[1][2] = dy;
}
