void Compute_Min_And_Max_Spread( SWIFT_Tri_Mesh* m, SWIFT_BV* p,
SWIFT_Real& min_spread,
SWIFT_Real& max_spread )
{
int i, j;
int fn = p->Num_All_Faces();
int* fs = new int[fn*3];
for( i = 0, j = 0; i < p->Num_Faces(); i++ ) {
fs[j++] = m->Vertex_Id( p->Faces()[i].Edge1().Origin() );
fs[j++] = m->Vertex_Id( p->Faces()[i].Edge2().Origin() );
fs[j++] = m->Vertex_Id( p->Faces()[i].Edge3().Origin() );
}
for( i = 0; i < p->Num_Other_Faces(); i++ ) {
fs[j++] = m->Vertex_Id( p->Other_Faces()[i]->Edge1().Origin() );
fs[j++] = m->Vertex_Id( p->Other_Faces()[i]->Edge2().Origin() );
fs[j++] = m->Vertex_Id( p->Other_Faces()[i]->Edge3().Origin() );
}
SWIFT_Triple min_dir, mid_dir, max_dir;
SWIFT_Tri_Edge* starte;
Compute_Spread( m->Vertices(), fs, fn, true, p->Center_Of_Mass(),
min_dir, mid_dir, max_dir );
starte = p->Other_Faces().Empty() ? p->Faces()[0].Edge1P()
: p->Other_Faces()[0]->Edge1P();
min_spread = p->Extremal_Vertex( min_dir, p->Level(), starte );
max_spread = p->Extremal_Vertex( max_dir, p->Level(), starte );
min_spread -= p->Extremal_Vertex( -min_dir, p->Level(), starte );
max_spread -= p->Extremal_Vertex( -max_dir, p->Level(), starte );
delete fs;
}
void Compute_Spread( SWIFT_Tri_Mesh* m,
SWIFT_Triple& min_dir, SWIFT_Real& min_spread,
SWIFT_Triple& max_dir, SWIFT_Real& max_spread )
{
int i, j;
int fn = m->Num_Faces();
int* fs = new int[fn*3];
for( i = 0, j = 0; i < m->Num_Faces(); i++ ) {
fs[j++] = m->Vertex_Id( m->Faces()[i].Edge1().Origin() );
fs[j++] = m->Vertex_Id( m->Faces()[i].Edge2().Origin() );
fs[j++] = m->Vertex_Id( m->Faces()[i].Edge3().Origin() );
}
Compute_Spread( m->Vertices(), fs, fn, m->Center_Of_Mass(),
min_dir, min_spread, max_dir, max_spread );
delete fs;
}
void Compute_Spread( SWIFT_Array<SWIFT_Tri_Vertex>& vs, SWIFT_Triple& center,
bool compute_spreads,
SWIFT_Triple& min_dir, SWIFT_Real& min_spread,
SWIFT_Triple& mid_dir, SWIFT_Real& mid_spread,
SWIFT_Triple& max_dir, SWIFT_Real& max_spread )
{
int fn;
int* fs;
if( vs.Length() == 3 ) {
fs = new int[6];
fs[0] = 0; fs[1] = 1; fs[2] = 2;
fs[3] = 0; fs[4] = 2; fs[5] = 1;
fn = 2;
} else {
Compute_Convex_Hull( vs, fs, fn );
}
Compute_Spread( vs, fs, fn, false, center, min_dir, mid_dir, max_dir );
if( compute_spreads ) {
// Now we have compute the spreads. This can be done by inserting
// convex hull vertices into an OBB or by doing hill climbing on the
// convex hull. We will go for the first option since building the
// connectivity of the convex hull is too expensive.
int i;
SWIFT_Real min_min_spread = SWIFT_INFINITY;
SWIFT_Real min_mid_spread = SWIFT_INFINITY;
SWIFT_Real min_max_spread = SWIFT_INFINITY;
min_spread = -SWIFT_INFINITY;
mid_spread = -SWIFT_INFINITY;
max_spread = -SWIFT_INFINITY;
for( i = 0; i < fn*3; ) {
const SWIFT_Triple& v1 = vs[fs[i++]].Coords();
const SWIFT_Triple& v2 = vs[fs[i++]].Coords();
const SWIFT_Triple& v3 = vs[fs[i++]].Coords();
const SWIFT_Real min_dot1 = min_dir * v1;
const SWIFT_Real min_dot2 = min_dir * v2;
const SWIFT_Real min_dot3 = min_dir * v3;
const SWIFT_Real mid_dot1 = mid_dir * v1;
const SWIFT_Real mid_dot2 = mid_dir * v2;
const SWIFT_Real mid_dot3 = mid_dir * v3;
const SWIFT_Real max_dot1 = max_dir * v1;
const SWIFT_Real max_dot2 = max_dir * v2;
const SWIFT_Real max_dot3 = max_dir * v3;
Min_And_Max( min_min_spread, min_spread, min_dot1 );
Min_And_Max( min_min_spread, min_spread, min_dot2 );
Min_And_Max( min_min_spread, min_spread, min_dot3 );
Min_And_Max( min_mid_spread, mid_spread, mid_dot1 );
Min_And_Max( min_mid_spread, mid_spread, mid_dot2 );
Min_And_Max( min_mid_spread, mid_spread, mid_dot3 );
Min_And_Max( min_max_spread, max_spread, max_dot1 );
Min_And_Max( min_max_spread, max_spread, max_dot2 );
Min_And_Max( min_max_spread, max_spread, max_dot3 );
}
// Recompute the center
center = 0.5 * (SWIFT_Triple( max_spread, mid_spread, min_spread ) +
SWIFT_Triple( min_max_spread, min_mid_spread, min_min_spread ));
min_spread -= min_min_spread;
mid_spread -= min_mid_spread;
max_spread -= min_max_spread;
}
delete fs;
}
