void CClassifyGrid::NotifyCCSClassified( int ix, int iy )
{
for ( int x = MinBound( ix ); x <= MaxBound( ix ); x++ )
for ( int y = MinBound( iy ); y <= MaxBound( iy ); y++ ) {
bool bAllClassified = true;
for ( int xx = MinBound( x ); xx <= MaxBound( x ) && bAllClassified; xx++ )
for ( int yy = MinBound( y ); yy <= MaxBound( y ) && bAllClassified; yy++ ) {
if ( InBound( xx, yy ) && CheckCCSClassified( Index( xx, yy ) ) == false ) {
bAllClassified = false;
}
}
if ( bAllClassified ) {
RefineChunk( m_vecPointer[ Index( x, y ) ] );
}
}
}
void B9SupportAttachmentData::CenterGeometry()
{
unsigned int t,v;
Triangle3D* cTri = NULL;
QVector3D MinBound(999999,999999,999999);
QVector3D MaxBound(-999999,-9999999,-999999);
QVector3D Center;
for(t = 0; t < triList.size(); t++)
{
cTri = &triList[t];
if(cTri->maxBound.x() > MaxBound.x())
MaxBound.setX(cTri->maxBound.x());
if(cTri->maxBound.y() > MaxBound.y())
MaxBound.setY(cTri->maxBound.y());
if(cTri->maxBound.z() > MaxBound.z())
MaxBound.setZ(cTri->maxBound.z());
if(cTri->minBound.x() < MinBound.x())
MinBound.setX(cTri->minBound.x());
if(cTri->minBound.y() < MinBound.y())
MinBound.setY(cTri->minBound.y());
if(cTri->minBound.z() < MinBound.z())
MinBound.setZ(cTri->minBound.z());
}
Center = (MaxBound + MinBound)*0.5;
//now we need to move all the triangles...
for(t = 0; t < triList.size(); t++)
{
for(v=0;v<3;v++)
{
triList[t].vertex[v] -= Center;
}
triList[t].UpdateBounds(); // since we are moving every triangle, we need to update their bounds too.
}
}
uint Wick::buildFDF (const FlameConfig& flameConfig, vector< LeadSkeleton * >& leadSkeletons, Field3D* const field )
{
CPoint bounds[flameConfig.skeletonsNumber + 1];
CPoint MinBound (FLT_MAX, FLT_MAX, FLT_MAX), MaxBound (-FLT_MAX, -FLT_MAX, -FLT_MAX);
CPoint midDist, cellSpan;
vector < CPoint * >pointsPartitionsArray[flameConfig.skeletonsNumber];
u_char max; /* 0 -> x, 1 -> y, 2 -> z */
/* Création du VBO */
buildVBO();
/*****************************************************************************/
/* Création des points qui vont servir d'origines pour les squelettes guides */
/*****************************************************************************/
/* Parcours des points */
/* La bounding box est délimitée par les points ptMax[flameConfig.skeletonsNumber] et ptMin[0] */
getBoundingBox (bounds[flameConfig.skeletonsNumber], bounds[0]);
/* Découpage de la bounding box en flameConfig.skeletonsNumber partitions */
midDist = (bounds[flameConfig.skeletonsNumber] - bounds[0]) / (flameConfig.skeletonsNumber);
cellSpan = bounds[flameConfig.skeletonsNumber] - bounds[0];
if(midDist.x > midDist.y)
if(midDist.x > midDist.z)
/* Découpage en x */
max=0;
else
/* Découpage en z */
max=2;
else
if(midDist.y > midDist.z)
/* Découpage en y */
max=1;
else
/* Découpage en z */
max=2;
switch(max){
case 0 :
/* Découpage en x */
for (uint i = 1; i < flameConfig.skeletonsNumber; i++){
bounds[i] = bounds[i-1];
bounds[i].x += midDist.x;
}
cellSpan.x=midDist.x;
for (vector < Vertex >::iterator vertexIterator = m_vertexArray.begin ();
vertexIterator != m_vertexArray.end (); vertexIterator++)
{
/* Calcul du max */
if (vertexIterator->x >= MaxBound.x)
MaxBound = CPoint(vertexIterator->x, vertexIterator->y, vertexIterator->z);
/* Calcul du min */
if (vertexIterator->x <= MinBound.x)
MinBound = CPoint(vertexIterator->x, vertexIterator->y, vertexIterator->z);
}
// cerr << "Découpe en x" << endl;
break;
case 1 :
/* Découpage en y */
for (uint i = 1; i < flameConfig.skeletonsNumber; i++){
bounds[i] = bounds[i-1];
bounds[i].y += midDist.y;
}
cellSpan.y=midDist.y;
for (vector < Vertex >::iterator vertexIterator = m_vertexArray.begin ();
vertexIterator != m_vertexArray.end (); vertexIterator++)
{
/* Calcul du max */
if (vertexIterator->y >= MaxBound.y)
MaxBound = CPoint(vertexIterator->x, vertexIterator->y, vertexIterator->z);
/* Calcul du min */
if (vertexIterator->y <= MinBound.y)
MinBound = CPoint(vertexIterator->x, vertexIterator->y, vertexIterator->z);
}
// cerr << "Découpe en y" << endl;
break;
case 2 :
/* Découpage en z */
for (uint i = 1; i < flameConfig.skeletonsNumber; i++){
bounds[i] = bounds[i-1];
bounds[i].z += midDist.z;
}
cellSpan.z=midDist.z;
for (vector < Vertex >::iterator vertexIterator = m_vertexArray.begin ();
vertexIterator != m_vertexArray.end (); vertexIterator++)
{
/* Calcul du max */
if (vertexIterator->z >= MaxBound.z)
MaxBound = CPoint(vertexIterator->x, vertexIterator->y, vertexIterator->z);
/* Calcul du min */
if (vertexIterator->z <= MinBound.z)
MinBound = CPoint(vertexIterator->x, vertexIterator->y, vertexIterator->z);
}
// cerr << "Découpe en z" << endl;
break;
}
// cerr << flameConfig.skeletonsNumber << endl;
// for (int i = 0; i <= flameConfig.skeletonsNumber; i++)
// cerr << bounds[i] << endl;
// cerr << "CellSpan " << cellSpan << endl;
m_boxesDisplayList=glGenLists(1);
glNewList (m_boxesDisplayList, GL_COMPILE);
for (uint i = 0; i < flameConfig.skeletonsNumber; i++){
glColor3f(0.0f,i*1.0f/(float)flameConfig.skeletonsNumber,1.0f);
CPoint bounds2 = bounds[i]+cellSpan;
glBegin(GL_LINE_LOOP);
glVertex3f(bounds[i].x,bounds[i].y,bounds[i].z);
glVertex3f(bounds[i].x,bounds[i].y,bounds2.z);
glVertex3f(bounds[i].x,bounds2.y,bounds2.z);
glVertex3f(bounds[i].x,bounds2.y,bounds[i].z);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex3f(bounds2.x,bounds[i].y,bounds[i].z);
glVertex3f(bounds2.x,bounds[i].y,bounds2.z);
glVertex3f(bounds2.x,bounds2.y,bounds2.z);
glVertex3f(bounds2.x,bounds2.y,bounds[i].z);
glEnd();
glBegin(GL_LINES);
glVertex3f(bounds[i].x,bounds[i].y,bounds[i].z);
glVertex3f(bounds2.x,bounds[i].y,bounds[i].z);
glVertex3f(bounds[i].x,bounds2.y,bounds[i].z);
glVertex3f(bounds2.x,bounds2.y,bounds[i].z);
glVertex3f(bounds[i].x,bounds[i].y,bounds2.z);
glVertex3f(bounds2.x,bounds[i].y,bounds2.z);
glVertex3f(bounds[i].x,bounds2.y,bounds2.z);
glVertex3f(bounds2.x,bounds2.y,bounds2.z);
glEnd();
}
glEndList();
/* Tri des points pour les ranger dans les partitions */
/* Il serait possible de faire un tri par dichotomie */
/* pour aller un peu plus vite */
for (vector < Vertex >::iterator vertexIterator = m_vertexArray.begin ();
vertexIterator != m_vertexArray.end (); vertexIterator++)
for (uint i = 0; i < flameConfig.skeletonsNumber; i++){
CPoint bounds2 = bounds[i]+cellSpan;
if (vertexIterator->x > bounds[i].x &&
vertexIterator->y > bounds[i].y &&
vertexIterator->z > bounds[i].z &&
vertexIterator->x < bounds2.x &&
vertexIterator->y < bounds2.y &&
vertexIterator->z < bounds2.z)
pointsPartitionsArray[i].push_back (new CPoint(vertexIterator->x, vertexIterator->y, vertexIterator->z));
}
CPoint rootMoveFactorL(2.0f,.1f,1.0f);
float noiseMin=-.1f;
float noiseMax=.1f;
float noiseInc=.5f;
/* Création des leadSkeletons */
/* On prend simplement le barycentre de chaque partition */
leadSkeletons.push_back (new LeadSkeleton(field, MinBound, rootMoveFactorL, flameConfig.leadLifeSpan, -1, noiseInc, noiseMin, noiseMax));
for (uint i = 0; i < flameConfig.skeletonsNumber; i++)
{
CPoint barycentre;
if (!pointsPartitionsArray[i].empty ())
{
barycentre.resetToNull ();
for (vector < CPoint * >::iterator pointsIterator = pointsPartitionsArray[i].begin ();
pointsIterator != pointsPartitionsArray[i].end (); pointsIterator++)
{
barycentre.x += (*pointsIterator)->x;
barycentre.y += (*pointsIterator)->y;
barycentre.z += (*pointsIterator)->z;
}
barycentre = barycentre / (float)pointsPartitionsArray[i].size();
leadSkeletons.push_back (new LeadSkeleton(field, barycentre, rootMoveFactorL, flameConfig.leadLifeSpan, 2*(i+1)/(float)(flameConfig.skeletonsNumber+1)-1, noiseInc, noiseMin, noiseMax));
}
else
cerr << "Warning ! Wick partition #" << i << " is empty" << endl;
}
leadSkeletons.push_back (new LeadSkeleton(field, MaxBound, rootMoveFactorL, flameConfig.leadLifeSpan, 1, noiseInc, noiseMin, noiseMax));
/* Suppression des points */
for (uint i = 0; i < flameConfig.skeletonsNumber; i++)
{
for (vector < CPoint * >::iterator pointsIterator = pointsPartitionsArray[i].begin ();
pointsIterator != pointsPartitionsArray[i].end (); pointsIterator++)
delete (*pointsIterator);
pointsPartitionsArray[i].clear();
}
// buildFDF(field);
return (max);
}
