void ModelContainer::fillContainer(const AABSPTree<SubModel *>::Node& pNode, int &pSubModelPos, int &pTreeNodePos, int &pTrianglePos, Vector3& pLo, Vector3& pHi, Vector3& pFinalLo, Vector3& pFinalHi)
{
// TreeNode for the SubModel
TreeNode treeNode = TreeNode(pNode.valueArray.size(), pSubModelPos);
treeNode.setSplitAxis(pNode.splitAxis);
treeNode.setSplitLocation(pNode.splitLocation);
int currentTreeNodePos = pTreeNodePos++;
Vector3 lo = Vector3(inf(),inf(),inf());
Vector3 hi = Vector3(-inf(),-inf(),-inf());
for (int i=0; i<pNode.valueArray.size(); i++)
{
G3D::_AABSPTree::Handle<SubModel*>* h= pNode.valueArray[i];
SubModel *m = h->value;
memcpy(&getTreeNodes()[pTreeNodePos], &m->getTreeNode(0), sizeof(TreeNode) * m->getNNodes());
memcpy(&getTriangles()[pTrianglePos], &m->getTriangle(0), sizeof(TriangleBox) * m->getNTriangles());
SubModel newModel = SubModel(m->getNTriangles(), getTriangles(), pTrianglePos, m->getNNodes(), getTreeNodes(), pTreeNodePos);
newModel.setReletiveBounds(m->getReletiveBounds().getLo(), m->getReletiveBounds().getHi());
newModel.setBasePosition(m->getBasePosition());
iSubModel[pSubModelPos++] = newModel;
pTreeNodePos += m->getNNodes();
pTrianglePos += m->getNTriangles();
AABox box = m->getAABoxBounds();
lo = lo.min(box.low());
hi = hi.max(box.high());
pFinalLo = pFinalLo.min(lo);
pFinalHi = pFinalHi.max(hi);
}
/*
if(pNode.valueArray.size() == 0) {
int xxx = 0; // just for the breakpoint
}
*/
// get absolute bounds
if(pNode.child[0] != 0)
{
treeNode.setChildPos(0, pTreeNodePos);
fillContainer(*pNode.child[0], pSubModelPos, pTreeNodePos, pTrianglePos, lo, hi,pFinalLo,pFinalHi);
}
if(pNode.child[1] != 0)
{
treeNode.setChildPos(1, pTreeNodePos);
fillContainer(*pNode.child[1], pSubModelPos, pTreeNodePos, pTrianglePos, lo, hi,pFinalLo,pFinalHi);
}
pLo = pLo.min(lo);
pHi = pHi.max(hi);
treeNode.setBounds(lo,hi);
setTreeNode(treeNode, currentTreeNodePos);
}
void
LinearGeometry::renderFaces(float alpha, Appearance& appearance)
{
glBegin(GL_TRIANGLES);
_register = appearance.getFaceColor();
glColor4f(_register[0], _register[1], _register[2],
_register[3] * alpha * appearance.getModifierAlpha());
int number = getNumberTriangles();
float*** triangles = getTriangles();
for (int i = 0; i < number; i++) {
_register = triangles[i][0];
glVertex3f(_register[0], _register[1], _register[2]);
_register = triangles[i][1];
glVertex3f(_register[0], _register[1], _register[2]);
_register = triangles[i][2];
glVertex3f(_register[0], _register[1], _register[2]);
}
glEnd();
glBegin(GL_QUADS);
number = getNumberQuads();
float*** quads = getQuads();
for (int i = 0; i < number; i++) {
_register = quads[i][0];
glVertex3f(_register[0], _register[1], _register[2]);
_register = quads[i][1];
glVertex3f(_register[0], _register[1], _register[2]);
_register = quads[i][2];
glVertex3f(_register[0], _register[1], _register[2]);
_register = quads[i][3];
glVertex3f(_register[0], _register[1], _register[2]);
}
glEnd();
}
void Mesh
::buildTree(void)
{
TriangleBounder bounder;
bounder.mMesh = this;
std::vector<const Triangle*> trianglePointers;
for(TriangleList::const_iterator t = getTriangles().begin();
t != getTriangles().end();
++t)
{
trianglePointers.push_back(&(*t));
} // end for t
mTree.buildTree(trianglePointers.begin(), trianglePointers.end(), bounder);
} // end Mesh::buildTree()
void CTriangleBBSelector::getTriangles(core::triangle3df* triangles,
s32 arraySize, s32& outTriangleCount,
const core::line3d<f32>& line,
const core::matrix4* transform) const
{
return getTriangles(triangles, arraySize, outTriangleCount, transform);
}
//! Gets all triangles which lie within a specific bounding box.
void CTriangleSelector::getTriangles(core::triangle3df* triangles,
s32 arraySize, s32& outTriangleCount,
const core::aabbox3d<f32>& box,
const core::matrix4* transform) const
{
// return all triangles
getTriangles(triangles, arraySize, outTriangleCount, transform);
}
bool ClipMesh::convert( Model* outModel ) {
// get visible vertices
const size_t numVertices = _vertices.size();
std::vector<Vertex> points;
int* vMap = new int[numVertices];
memset(vMap, 0xFF, numVertices * sizeof(int));
for( unsigned int currVtx = 0; currVtx < numVertices; ++currVtx ) {
const CVertex& vtx = _vertices[currVtx];
if( !vtx.visible ) {
continue;
}
vMap[currVtx] = static_cast<int>(points.size());
points.push_back(Vertex(vtx.point));
}
// check for all culled
if( points.empty() || points.size() < 3) {
return false;
}
// get the triangles
std::vector<int> indices;
if( !getTriangles(indices) ) {
//printf("Failed to get triangles.\n");
return false;
}
// reorder the indices
bool hadError = false;
for( unsigned int currIdx = 0; currIdx < indices.size(); ++currIdx ) {
const int oldIdx = indices[currIdx];
//assert(0 <= oldIdx && oldIdx < static_cast<int>(numVertices)); // index out of range
if( oldIdx < 0 || oldIdx >= static_cast<int>(numVertices) ) {
printf("Index out of range: oldIdx:numVertices (%d:%d)\n", oldIdx, numVertices);
delete[] vMap;
return false;
}
const int newIdx = vMap[oldIdx];
//assert(0 <= newIdx && newIdx < points.size()); // index out of range
if( newIdx < 0 || newIdx >= points.size() ) {
printf("Index out of range: newIdx:points.size (%d:%zd)\n", newIdx, points.size());
delete[] vMap;
return false;
}
indices[currIdx] = newIdx;
}
delete[] vMap;
for( unsigned int i = 0; i < points.size(); ++i ) {
outModel->addVertex(points[i]);
}
for( unsigned int i = 0; i < indices.size(); ++i ) {
outModel->addIndex(indices[i]);
}
return true;
}
bool ModelContainer::writeFile(const char *filename)
{
bool result = false;
unsigned int flags=0;
unsigned int size;
FILE *wf =fopen(filename,"wb");
if(wf)
{
fwrite(VMAP_MAGIC,1,8,wf);
result = true;
if(result && fwrite("CTREE01",8,1,wf) != 1) result = false;
if(result && fwrite(&flags,sizeof(unsigned int),1,wf) != 1) result = false;
if(result && fwrite("POS ",4,1,wf) != 1) result = false;
size = sizeof(float)*3;
if(result && fwrite(&size,4,1,wf) != 1) result = false;
Vector3 basePos = getBasePosition();
if(result && fwrite(&basePos,sizeof(float),3,wf) != 3) result = false;
if(result && fwrite("BOX ",4,1,wf) != 1) result = false;
size = sizeof(float)*6;
if(result && fwrite(&size,4,1,wf) != 1) result = false;
Vector3 low = iBox.low();
if(result && fwrite(&low,sizeof(float),3,wf) != 3) result = false;
Vector3 high = iBox.high();
if(result && fwrite(&high,sizeof(float),3,wf) != 3) result = false;
if(result && fwrite("NODE",4,1,wf) != 1) result = false;
size = sizeof(unsigned int)+ sizeof(TreeNode)*getNNodes();
if(result && fwrite(&size,4,1,wf) != 1) result = false;
unsigned int val = getNNodes();
if(result && fwrite(&val,sizeof(unsigned int),1,wf) != 1) result = false;
if(result && fwrite(getTreeNodes(),sizeof(TreeNode),getNNodes(),wf) != getNNodes()) result = false;
if(result && fwrite("TRIB",4,1,wf) != 1) result = false;
size = sizeof(unsigned int)+ sizeof(TriangleBox)*getNTriangles();
if(result && fwrite(&size,4,1,wf) != 1) result = false;
val = getNTriangles();
if(result && fwrite(&val,sizeof(unsigned int),1,wf) != 1) result = false;
if(result && fwrite(getTriangles(),sizeof(TriangleBox),getNTriangles(),wf) != getNTriangles()) result = false;
if(result && fwrite("SUBM",4,1,wf) != 1) result = false;
size = sizeof(unsigned int)+ sizeof(SubModel)*iNSubModel;
if(result && fwrite(&size,4,1,wf) != 1) result = false;
if(result && fwrite(&iNSubModel,sizeof(unsigned int),1,wf) != 1) result = false;
if(result && fwrite(iSubModel,sizeof(SubModel),iNSubModel,wf) != iNSubModel) result = false;
fclose(wf);
}
return(result);
}
void DrawableStatsAttachment::operator -=(DrawableStatsAttachment *arg)
{
setVertices (getVertices() - arg->getVertices());
setPoints (getPoints() - arg->getPoints());
setLines (getLines() - arg->getLines());
setTriangles (getTriangles() - arg->getTriangles());
setPatches (getPatches () - arg->getPatches ());
setProcessedAttributeBytes(getProcessedAttributeBytes() -
arg->getProcessedAttributeBytes());
setStoredAttributeBytes (getStoredAttributeBytes() -
arg->getStoredAttributeBytes());
setValid(true);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
IGeometry::Pointer TriangleGeom::deepCopy()
{
TriangleGeom::Pointer triCopy = TriangleGeom::CreateGeometry(getTriangles(), getVertices(), getName());
triCopy->setEdges(getEdges());
triCopy->setUnsharedEdges(getUnsharedEdges());
triCopy->setElementsContainingVert(getElementsContainingVert());
triCopy->setElementNeighbors(getElementNeighbors());
triCopy->setElementCentroids(getElementCentroids());
triCopy->setSpatialDimensionality(getSpatialDimensionality());
return triCopy;
}
//! Gets all triangles which have or may have contact with a 3d line.
void CTriangleSelector::getTriangles(core::triangle3df* triangles,
s32 arraySize, s32& outTriangleCount,
const core::line3d<f32>& line,
const core::matrix4* transform) const
{
// Update my triangles if necessary
update();
core::aabbox3d<f32> box(line.start);
box.addInternalPoint(line.end);
// TODO: Could be optimized for line a little bit more.
getTriangles(triangles, arraySize, outTriangleCount,
box, transform);
}
int triangulate(const vector<Poly> &polys, vector< vector<Triangle> > &triangles,
double z)
{
vector<ExPoly> expolys = Clipping::getExPolys(polys, 0, 0);
cerr << expolys.size() << endl;
for (uint i = 0; i<expolys.size(); i++) {
vector<p2t::Point*> outerpoints = getP2Tpoints(expolys[i].outer);
p2t::CDT cdt(outerpoints);
for (uint h = 0; h < expolys[i].holes.size(); h++) {
vector<p2t::Point*> holespoints = getP2Tpoints(expolys[i].holes[h]);
cdt.AddHole(holespoints);
}
cdt.Triangulate();
triangles.push_back(getTriangles(cdt, z));
}
return triangles.size();
}
const float* Mesh::getVertices()
{
_vertices = new float[_countTriangles*3*3];
unsigned int index(0);
for(unsigned int i(0); i < _countTriangles; i++)
{
_vertices[index] = getTriangles()[i].getVertex1().getVertexCoords().getX();
_vertices[index+1] = getTriangles()[i].getVertex1().getVertexCoords().getY();
_vertices[index+2] = getTriangles()[i].getVertex1().getVertexCoords().getZ();
_vertices[index+3] = getTriangles()[i].getVertex2().getVertexCoords().getX();
_vertices[index+4] = getTriangles()[i].getVertex2().getVertexCoords().getY();
_vertices[index+5] = getTriangles()[i].getVertex2().getVertexCoords().getZ();
_vertices[index+6] = getTriangles()[i].getVertex3().getVertexCoords().getX();
_vertices[index+7] = getTriangles()[i].getVertex3().getVertexCoords().getY();
_vertices[index+8] = getTriangles()[i].getVertex3().getVertexCoords().getZ();
index+=9;
}
return _vertices;
}
void SubModel::fillContainer(const AABSPTree<Triangle>::Node& pNode, int &pTreeNodePos, int &pTrianglePos, Vector3& pLo, Vector3& pHi)
{
TreeNode treeNode = TreeNode(pNode.valueArray.size(), pTrianglePos);
treeNode.setSplitAxis(pNode.splitAxis);
treeNode.setSplitLocation(pNode.splitLocation);
int currentTreeNodePos = pTreeNodePos++;
Vector3 lo = Vector3(inf(),inf(),inf());
Vector3 hi = Vector3(-inf(),-inf(),-inf());
for(int i=0;i<pNode.valueArray.size(); i++)
{
G3D::_AABSPTree::Handle<Triangle>* h= pNode.valueArray[i];
Triangle t = h->value;
TriangleBox triangleBox = TriangleBox(t.vertex(0),t.vertex(1), t.vertex(2));
lo = lo.min(triangleBox.getBounds().getLo().getVector3());
hi = hi.max(triangleBox.getBounds().getHi().getVector3());
getTriangles()[pTrianglePos++] = triangleBox;
}
if(pNode.child[0] != 0)
{
treeNode.setChildPos(0, pTreeNodePos);
fillContainer(*pNode.child[0], pTreeNodePos, pTrianglePos, lo, hi);
}
if(pNode.child[1] != 0)
{
treeNode.setChildPos(1, pTreeNodePos);
fillContainer(*pNode.child[1], pTreeNodePos, pTrianglePos, lo, hi);
}
treeNode.setBounds(lo,hi);
// get absolute bounds
pLo = pLo.min(lo);
pHi = pHi.max(hi);
getTreeNodes()[currentTreeNodePos] = treeNode;
}
int main (int argc, char ** argv)
{
int seg = 100,
sgg = 0,
arg;
struct option longopts[] =
{
{ "seg", required_argument, NULL, 's' },
{ "sgg", no_argument, NULL, 'p' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
while ((arg = getopt_long (argc, argv, "s:hp", longopts, NULL)) != -1)
{
switch (arg)
{
case 's':
seg = atoi (optarg);
break;
case 'p':
sgg = 1;
break;
case 'h':
printf ("List of commands:\n");
printf ("--seg=<Int>, -s<Int>\n");
printf ("\t No. of initialsegments for triangulation.\n");
printf ("--sgg\n");
printf ("\t Create files for processing with the \"Triangle\" program\n");
printf ("--help\n\t Printf this list\n");
exit (EXIT_SUCCESS);
default:
printf ("Unknown command!\nTry %s --help, for list of commands\n", argv[0]);
exit (EXIT_FAILURE);
}
}
if (sgg)
{
PolyFile (seg);
exit (EXIT_SUCCESS);
}
printf ("Initializing triangulator\n");
tr * u = (tr *) malloc (sizeof (tr));
printf ("Getting triangles\n");
getTriangles (seg, u);
printf ("Calculating A and scal\n");
calculateAscal (u);
printf ("Writing it into gS\n");
calc_gS (u);
printf ("Computing LU and c\n");
c_solver (u);
printf ("Calculating the flux\n");
poiseuille (seg, u);
destroy_tr (u);
exit (EXIT_SUCCESS);
}
bool ModelContainer::readFile(const char *filename)
{
bool result = false;
unsigned int flags;
unsigned int size;
char ident[8];
char chunk[4];
unsigned int ival;
FILE *rf = fopen(filename, "rb");
if(rf)
{
free();
result = true;
char magic[8]; // Ignore the added magic header
fread(magic,1,8,rf);
if(strncmp(VMAP_MAGIC,magic,8)) result = false;
if(result && fread(ident,8,1,rf) != 1) result = false;
if(result && fread(&flags,sizeof(unsigned int),1,rf) != 1) result = false;
//POS
if(result && fread(chunk,4,1,rf) != 1) result = false;
if(result && fread(&size,4,1,rf) != 1) result = false;
Vector3 basePos;
if(result && fread(&basePos,sizeof(float),3,rf) != 3) result = false;
setBasePosition(basePos);
//---- Box
if(result && fread(chunk,4,1,rf) != 1) result = false;
if(result && fread(&size,4,1,rf) != 1) result = false;
Vector3 low,high;
if(result && fread(&low,sizeof(float),3,rf) != 3) result = false;
if(result && fread(&high,sizeof(float),3,rf) != 3) result = false;
setBounds(low, high);
//---- TreeNodes
if(result && fread(chunk,4,1,rf) != 1) result = false;
if(result && fread(&size,4,1,rf) != 1) result = false;
if(result && fread(&ival,sizeof(unsigned int),1,rf) != 1) result = false;
if(result) setNNodes(ival);
if(result) setTreeNodeArray(new TreeNode[getNNodes()]);
if(result && fread(getTreeNodes(),sizeof(TreeNode),getNNodes(),rf) != getNNodes()) result = false;
//---- TriangleBoxes
if(result && fread(chunk,4,1,rf) != 1) result = false;
if(result && fread(&size,4,1,rf) != 1) result = false;
if(result && fread(&ival,sizeof(unsigned int),1,rf) != 1) result = false;
setNTriangles(ival);
if(result) setTriangleArray(new TriangleBox[getNTriangles()]);
if(result && fread(getTriangles(),sizeof(TriangleBox),getNTriangles(),rf) != getNTriangles()) result = false;
//---- SubModel
if(result && fread(chunk,4,1,rf) != 1) result = false;
if(result && fread(&size,4,1,rf) != 1) result = false;
if(result && fread(&iNSubModel,sizeof(unsigned int),1,rf) != 1) result = false;
if(result) iSubModel = new SubModel[iNSubModel];
if(result)
{
for (unsigned int i=0; i<iNSubModel && result; ++i)
{
unsigned char readBuffer[52]; // this is the size of SubModel on 32 bit systems
if(fread(readBuffer,sizeof(readBuffer),1,rf) != 1) result = false;
iSubModel[i].initFromBinBlock(readBuffer);
iSubModel[i].setTriangleArray(getTriangles());
iSubModel[i].setTreeNodeArray(getTreeNodes());
}
}
fclose(rf);
}
return result;
}
RayIntersectionIterator<TreeNode, TriangleBox> SubModel::beginRayIntersection(const Ray& ray, double pMaxTime, bool skipAABoxTests) const
{
NodeValueAccess<TreeNode, TriangleBox> vna = NodeValueAccess<TreeNode, TriangleBox>(getTreeNodes(), getTriangles());
return RayIntersectionIterator<TreeNode, TriangleBox>(vna, ray, &getTreeNode(0), pMaxTime, skipAABoxTests);
}
void Geometry::write(IResource* resource)
{
ChunkHeader geometryHeader( BA_GEOMETRY, sizeof( Chunk ) );
geometryHeader.write( resource );
Chunk chunk;
chunk.id = (auid)( this );
memset( chunk.name, 0, engine::maxNameLength );
if( _name.length() > engine::maxNameLength )
{
strncpy( chunk.name, _name.c_str(), engine::maxNameLength - 1 );
}
else
{
strcpy( chunk.name, _name.c_str() );
}
chunk.numShaders = getNumShaders();
chunk.numVertices = getNumVertices();
chunk.numUVSets = getNumUVSets();
chunk.numPrelights = getNumPrelights();
chunk.numTriangles = getNumTriangles();
chunk.sharedShaders = _sharedShaders;
if( _ocTreeRoot )
{
chunk.numOcTreeSectors = _ocTreeRoot->getOcTreeSize();
}
else
{
chunk.numOcTreeSectors = 0;
}
chunk.hasEffect = ( _effect != NULL );
fwrite( &chunk, sizeof( Chunk ), 1, resource->getFile() );
// write shaders
if( !_sharedShaders ) for( int i=0; i<getNumShaders(); i++ )
{
_shaders[i]->write( resource );
}
// write vertices
ChunkHeader verticesHeader( BA_BINARY, sizeof(Vector) * getNumVertices() );
verticesHeader.write( resource );
fwrite( getVertices(), verticesHeader.size, 1, resource->getFile() );
// write normals
ChunkHeader normalsHeader( BA_BINARY, sizeof(Vector) * getNumVertices() );
normalsHeader.write( resource );
fwrite( getNormals(), normalsHeader.size, 1, resource->getFile() );
// write UV-sets
int i;
for( i=0; i<getNumUVSets(); i++ )
{
ChunkHeader uvsHeader( BA_BINARY, sizeof(Flector) * getNumVertices() );
uvsHeader.write( resource );
fwrite( getUVSet(i), uvsHeader.size, 1, resource->getFile() );
}
// write prelights
for( i=0; i< getNumPrelights(); i++ )
{
ChunkHeader prelightsHeader( BA_BINARY, sizeof(Color) * getNumVertices() );
prelightsHeader.write( resource );
fwrite( getPrelights(i), prelightsHeader.size, 1, resource->getFile() );
}
// write triangles
ChunkHeader trianglesHeader( BA_BINARY, sizeof(Triangle) * getNumTriangles() );
trianglesHeader.write( resource );
fwrite( getTriangles(), trianglesHeader.size, 1, resource->getFile() );
// write shaders
if( !_sharedShaders )
{
ChunkHeader shadersHeader( BA_BINARY, sizeof(auid) * getNumShaders() );
shadersHeader.write( resource );
fwrite( _shaders, shadersHeader.size, 1, resource->getFile() );
}
// write octree
if( _ocTreeRoot )
{
_ocTreeRoot->write( resource );
}
// write effect
if( chunk.hasEffect )
{
reinterpret_cast<Effect*>( _effect )->write( resource );
}
}
//==========================================================
void SubModel::intersect(const G3D::Ray& pRay, float& pMaxDist, bool pStopAtFirstHit, G3D::Vector3& /*pOutLocation*/, G3D::Vector3& /*pOutNormal*/) const
{
NodeValueAccess<TreeNode, TriangleBox> vna = NodeValueAccess<TreeNode, TriangleBox>(getTreeNodes(), getTriangles());
IntersectionCallBack<TriangleBox> intersectCallback;
Ray relativeRay = Ray::fromOriginAndDirection(pRay.origin - getBasePosition(), pRay.direction);
#ifdef _DEBUG_VMAPS
//p6=getBasePosition();
//gBoxArray.push_back(getAABoxBounds());
#endif
getTreeNode(0).intersectRay(relativeRay, intersectCallback, pMaxDist, vna, pStopAtFirstHit, false);
}
void BaseModel::free()
{
if(getTriangles() != 0) delete [] getTriangles(); setNTriangles(0);
if(getTreeNodes() != 0) delete [] getTreeNodes(); setNNodes(0);
}
void SubModel::intersectRay(const Ray& pRay, RayCallback& pIntersectCallback, float& pMaxDist, bool pStopAtFirstHit, bool intersectCallbackIsFast)
{
if(intersect(pRay, pMaxDist))
{
NodeValueAccess<TreeNode, TriangleBox> vna = NodeValueAccess<TreeNode, TriangleBox>(getTreeNodes(), getTriangles());
IntersectionCallBack<TriangleBox> intersectCallback;
getTreeNode(0).intersectRay(pRay, intersectCallback, pMaxDist, vna, pStopAtFirstHit, false);
}
}
unsigned GfxBody::getTrianglesWithChildren (void) const
{
return getTriangles() + GfxFertileNode::getTrianglesWithChildren();
}
std::auto_ptr< TriangulatedSurface > ConstraintDelaunayTriangulation::getTriangulatedSurface() const
{
std::auto_ptr< TriangulatedSurface > result( new TriangulatedSurface );
getTriangles( *result, false );
return result ;
}
void SurfaceMeshShape::computeVolumeIntegrals()
{
// Considering a surface mesh with thickness, the goal is to compute the following properties:
// 1) volume = integral(over volume) dx dy dz
// 2) center = integral(over volume) (x y z)^T dx dy dz / volume
// 3) the inertia matrix without the mass density:
// I = (Ixx Ixy Ixz) = integral(over volume) (y^2+z^2 -xy -xz ) dx dy dz
// (Iyx Iyy Iyz) ( -yx x^2+z^2 -yz )
// (Izx Izy Izz) ( -zx -zy x^2+y^2)
// Each term of the matrix I can be evaluated independently and each monome can also be evaluated
// independently and summed up after: integral(V) y^2+z^2 dV = integral(V) y^2 dV + integral(V) z^2 dV
//
// Therefore, we simply need to compute 10 different volume integral:
// {1, x, y, z, x^2, y^2, z^2, xy, yz, zx}
//
// Example for the monome 'xy':
// = integral(over volume) x.y dx dy dz = integral(over volume) x.y dV
// = integral(over area) x.y dS * thickness
// = [sum(over all triangles) integral(over triangle) x.y dS] * thickness
//
// Change the integration variables from cartesian coordinates to a parametrization of the
// triangle ABC = {P | P = A + a.u + b.v}
// with
// { u=AB the 1st triangle edge supporting the parametrization
// { v=AC the 2nd triangle edge supporting the parametrization
// { 0<=a<=1 the triangle 1st coordinate in the new coordinate system (parametrized)
// { 0<=b<=1-a the triangle 2nd coordinate in the new coordinate system (parametrized)
// => dS = |dP/db x dP/da|.db.da = |vxu|.db.da = |uxv|.db.da
// => x = Px
// => y = Py
//
// integral(over volume) x.y dx dy dz =
// [sum(over all triangles) integral(over triangle) x.y dS] * thickness =
// [sum(over all triangles) integral(from 0 to 1) integral(from 0 to 1-a) Px.Py db.da |uxv|] * thickness
//
// From here, the various integral terms can be found related to A, u and v using any formal integration tool.
// Order: 1, x, y, z, x^2, y^2, z^2, xy, yz, zx
Eigen::VectorXd integral(10);
integral.setZero();
for (auto const& triangle : getTriangles())
{
if (!triangle.isValid)
{
continue;
}
auto A = getVertexPosition(triangle.verticesId[0]);
auto B = getVertexPosition(triangle.verticesId[1]);
auto C = getVertexPosition(triangle.verticesId[2]);
// Triangle parametrization P(a, b) = A + u.a + v.b with u=AB and v=AC
const Vector3d u = B - A;
const Vector3d v = C - A;
const double area = u.cross(v).norm() / 2.0; // Triangle area
integral[0] += area;
integral[1] += (A[0] + (u[0] + v[0]) / 3.0) * area;
integral[2] += (A[1] + (u[1] + v[1]) / 3.0) * area;
integral[3] += (A[2] + (u[2] + v[2]) / 3.0) * area;
integral[4] +=
(A[0] * (A[0] + 2.0 * (u[0] + v[0]) / 3.0) + (u[0] * v[0] + v[0] * v[0] + u[0] * u[0]) / 6.0) * area;
integral[5] +=
(A[1] * (A[1] + 2.0 * (u[1] + v[1]) / 3.0) + (u[1] * v[1] + v[1] * v[1] + u[1] * u[1]) / 6.0) * area;
integral[6] +=
(A[2] * (A[2] + 2.0 * (u[2] + v[2]) / 3.0) + (u[2] * v[2] + v[2] * v[2] + u[2] * u[2]) / 6.0) * area;
integral[7] += (A[0] * A[1] + (A[0] * (u[1] + v[1]) + A[1] * (u[0] + v[0])) / 3.0) * area;
integral[7] += ((u[0] * u[1] + v[0] * v[1]) / 6.0 + (u[0] * v[1] + u[1] * v[0]) / 12.0) * area;
integral[8] += (A[1] * A[2] + (A[1] * (u[2] + v[2]) + A[2] * (u[1] + v[1])) / 3.0) * area;
integral[8] += ((u[1] * u[2] + v[1] * v[2]) / 6.0 + (u[1] * v[2] + u[2] * v[1]) / 12.0) * area;
integral[9] += (A[2] * A[0] + (A[2] * (u[0] + v[0]) + A[0] * (u[2] + v[2])) / 3.0) * area;
integral[9] += ((u[2] * u[0] + v[2] * v[0]) / 6.0 + (u[2] * v[0] + u[0] * v[2]) / 12.0) * area;
}
// integral[0] is the sum of all triangle's area
double area = integral[0];
// Center of mass
m_center = integral.segment(1, 3);
if (area > epsilon)
{
m_center /= area;
}
// second moment of volume relative to center
Vector3d centerSquared = m_center.cwiseProduct(m_center);
m_secondMomentOfVolume(0, 0) = integral[5] + integral[6] - area * (centerSquared.y() + centerSquared.z());
m_secondMomentOfVolume(1, 1) = integral[4] + integral[6] - area * (centerSquared.z() + centerSquared.x());
m_secondMomentOfVolume(2, 2) = integral[4] + integral[5] - area * (centerSquared.x() + centerSquared.y());
m_secondMomentOfVolume(0, 1) = -(integral[7] - area * m_center.x() * m_center.y());
m_secondMomentOfVolume(1, 0) = m_secondMomentOfVolume(0, 1);
m_secondMomentOfVolume(1, 2) = -(integral[8] - area * m_center.y() * m_center.z());
m_secondMomentOfVolume(2, 1) = m_secondMomentOfVolume(1, 2);
m_secondMomentOfVolume(0, 2) = -(integral[9] - area * m_center.z() * m_center.x());
m_secondMomentOfVolume(2, 0) = m_secondMomentOfVolume(0, 2);
m_secondMomentOfVolume *= m_thickness;
m_volume = (area * m_thickness);
}
