/*!
the radius ratio of a triangle
NB (P. Pebay 01/13/07):
CR / (2.0*IR) where CR is the circumradius and IR is the inradius
The radius ratio is also known to VERDICT, for tetrahedral elements only,
as the "aspect beta".
*/
C_FUNC_DEF double v_tri_radius_ratio( int /*num_nodes*/, double coordinates[][3] )
{
// three vectors for each side
VerdictVector a( coordinates[1][0] - coordinates[0][0],
coordinates[1][1] - coordinates[0][1],
coordinates[1][2] - coordinates[0][2] );
VerdictVector b( coordinates[2][0] - coordinates[1][0],
coordinates[2][1] - coordinates[1][1],
coordinates[2][2] - coordinates[1][2] );
VerdictVector c( coordinates[0][0] - coordinates[2][0],
coordinates[0][1] - coordinates[2][1],
coordinates[0][2] - coordinates[2][2] );
double a1 = a.length();
double b1 = b.length();
double c1 = c.length();
VerdictVector ab = a * b;
double denominator = ab.length_squared();
if( denominator < VERDICT_DBL_MIN )
return (double)VERDICT_DBL_MAX;
double radius_ratio;
radius_ratio = .25 * a1 * b1 * c1 * ( a1 + b1 + c1 ) / denominator;
if( radius_ratio > 0 )
return (double) VERDICT_MIN( radius_ratio, VERDICT_DBL_MAX );
return (double) VERDICT_MAX( radius_ratio, -VERDICT_DBL_MAX );
}
inline double normalize_jacobian( double jacobi,
VerdictVector& v1,
VerdictVector& v2,
VerdictVector& v3,
int tet_flag = 0 )
{
double return_value = 0.0;
if ( jacobi != 0.0 )
{
double l1, l2, l3, length_product;
// Note: there may be numerical problems if one is a lot shorter
// than the others this way. But scaling each vector before the
// triple product would involve 3 square roots instead of just
// one.
l1 = v1.length_squared();
l2 = v2.length_squared();
l3 = v3.length_squared();
length_product = sqrt( l1 * l2 * l3 );
// if some numerical scaling problem, or just plain roundoff,
// then push back into range [-1,1].
if ( length_product < fabs(jacobi) )
{
length_product = fabs(jacobi);
}
if( tet_flag == 1)
return_value = v_sqrt_2 * jacobi / length_product;
else
return_value = jacobi / length_product;
}
return return_value;
}
double VerdictVector::vector_angle(const VerdictVector &vector1,
const VerdictVector &vector2) const
{
// This routine does not assume that any of the input vectors are of unit
// length. This routine does not normalize the input vectors.
// Special cases:
// If the normal vector is zero length:
// If a new one can be computed from vectors 1 & 2:
// the normal is replaced with the vector cross product
// else the two vectors are colinear and zero or 2PI is returned.
// If the normal is colinear with either (or both) vectors
// a new one is computed with the cross products
// (and checked again).
// Check for zero length normal vector
VerdictVector normal = *this;
double normal_lensq = normal.length_squared();
double len_tol = 0.0000001;
if( normal_lensq <= len_tol )
{
// null normal - make it the normal to the plane defined by vector1
// and vector2. If still null, the vectors are colinear so check
// for zero or 180 angle.
normal = vector1 * vector2;
normal_lensq = normal.length_squared();
if( normal_lensq <= len_tol )
{
double cosine = vector1 % vector2;
if( cosine > 0.0 ) return 0.0;
else return VERDICT_PI;
}
}
//Trap for normal vector colinear to one of the other vectors. If so,
//use a normal defined by the two vectors.
double dot_tol = 0.985;
double dot = vector1 % normal;
if( dot * dot >= vector1.length_squared() * normal_lensq * dot_tol )
{
normal = vector1 * vector2;
normal_lensq = normal.length_squared();
//Still problems if all three vectors were colinear
if( normal_lensq <= len_tol )
{
double cosine = vector1 % vector2;
if( cosine >= 0.0 ) return 0.0;
else return VERDICT_PI;
}
}
else
{
//The normal and vector1 are not colinear, now check for vector2
dot = vector2 % normal;
if( dot * dot >= vector2.length_squared() * normal_lensq * dot_tol )
{
normal = vector1 * vector2;
}
}
// Assume a plane such that the normal vector is the plane's normal.
// Create yAxis perpendicular to both the normal and vector1. yAxis is
// now in the plane. Create xAxis as the perpendicular to both yAxis and
// the normal. xAxis is in the plane and is the projection of vector1
// into the plane.
normal.normalize();
VerdictVector yAxis = normal;
yAxis *= vector1;
double yv = vector2 % yAxis;
// yAxis memory slot will now be used for xAxis
yAxis *= normal;
double xv = vector2 % yAxis;
// assert(x != 0.0 || y != 0.0);
if( xv == 0.0 && yv == 0.0 )
{
return 0.0;
}
double angle = atan2( yv, xv );
if (angle < 0.0)
{
angle += TWO_VERDICT_PI;
}
return angle;
}
/*!
tri_quality for calculating multiple tri functions at once
using this method is generally faster than using the individual
method multiple times.
*/
C_FUNC_DEF void v_tri_quality( int num_nodes, double coordinates[][3],
unsigned int metrics_request_flag, TriMetricVals *metric_vals )
{
memset( metric_vals, 0, sizeof(TriMetricVals) );
// for starts, lets set up some basic and common information
/* node numbers and side numbers used below
2
++
/ \
2 / \ 1
/ \
/ \
0 ---------+ 1
0
*/
// vectors for each side
VerdictVector sides[3];
sides[0].set(
coordinates[1][0] - coordinates[0][0],
coordinates[1][1] - coordinates[0][1],
coordinates[1][2] - coordinates[0][2]
);
sides[1].set(
coordinates[2][0] - coordinates[1][0],
coordinates[2][1] - coordinates[1][1],
coordinates[2][2] - coordinates[1][2]
);
sides[2].set(
coordinates[2][0] - coordinates[0][0],
coordinates[2][1] - coordinates[0][1],
coordinates[2][2] - coordinates[0][2]
);
VerdictVector tri_normal = sides[0] * sides[2];
//if we have access to normal information, check to see if the
//element is inverted. If we don't have the normal information
//that we need for this, assume the element is not inverted.
//This flag will be used for condition number, jacobian, shape,
//and size and shape.
bool is_inverted = false;
if( compute_normal )
{
//center of tri
double point[3], surf_normal[3];
point[0] = (coordinates[0][0] + coordinates[1][0] + coordinates[2][0]) / 3;
point[1] = (coordinates[0][1] + coordinates[1][1] + coordinates[2][1]) / 3;
point[2] = (coordinates[0][2] + coordinates[1][2] + coordinates[2][2]) / 3;
//dot product
compute_normal( point, surf_normal );
if( (tri_normal.x()*surf_normal[0] +
tri_normal.y()*surf_normal[1] +
tri_normal.z()*surf_normal[2] ) < 0 )
is_inverted=true;
}
// lengths squared of each side
double sides_lengths_squared[3];
sides_lengths_squared[0] = sides[0].length_squared();
sides_lengths_squared[1] = sides[1].length_squared();
sides_lengths_squared[2] = sides[2].length_squared();
// if we are doing angle calcuations
if( metrics_request_flag & (V_TRI_MINIMUM_ANGLE | V_TRI_MAXIMUM_ANGLE) )
{
// which is short and long side
int short_side=0, long_side=0;
if(sides_lengths_squared[1] < sides_lengths_squared[0])
short_side = 1;
if(sides_lengths_squared[2] < sides_lengths_squared[short_side])
short_side = 2;
if(sides_lengths_squared[1] > sides_lengths_squared[0])
long_side = 1;
if(sides_lengths_squared[2] > sides_lengths_squared[long_side])
long_side = 2;
// calculate the minimum angle of the tri
if( metrics_request_flag & V_TRI_MINIMUM_ANGLE )
{
if(sides_lengths_squared[0] == 0.0 ||
sides_lengths_squared[1] == 0.0 ||
sides_lengths_squared[2] == 0.0)
{
metric_vals->minimum_angle = 0.0;
}
else if(short_side == 0)
metric_vals->minimum_angle = (double)sides[2].interior_angle(sides[1]);
else if(short_side == 1)
metric_vals->minimum_angle = (double)sides[0].interior_angle(sides[2]);
else
metric_vals->minimum_angle = (double)sides[0].interior_angle(-sides[1]);
}
// calculate the maximum angle of the tri
if( metrics_request_flag & V_TRI_MAXIMUM_ANGLE )
{
if(sides_lengths_squared[0] == 0.0 ||
sides_lengths_squared[1] == 0.0 ||
sides_lengths_squared[2] == 0.0)
{
metric_vals->maximum_angle = 0.0;
}
else if(long_side == 0)
metric_vals->maximum_angle = (double)sides[2].interior_angle(sides[1]);
else if(long_side == 1)
metric_vals->maximum_angle = (double)sides[0].interior_angle(sides[2]);
else
metric_vals->maximum_angle = (double)sides[0].interior_angle(-sides[1]);
}
}
// calculate the area of the tri
// the following functions depend on area
if( metrics_request_flag & (V_TRI_AREA | V_TRI_SCALED_JACOBIAN |
V_TRI_SHAPE | V_TRI_RELATIVE_SIZE_SQUARED | V_TRI_SHAPE_AND_SIZE ) )
{
metric_vals->area = (double)((sides[0] * sides[2]).length() * 0.5);
}
// calculate the aspect ratio
if(metrics_request_flag & V_TRI_ASPECT_FROBENIUS)
{
// sum the lengths squared
double srms =
sides_lengths_squared[0] +
sides_lengths_squared[1] +
sides_lengths_squared[2] ;
// calculate once and reuse
static const double twoTimesRootOf3 = 2*sqrt(3.0);
double div = (twoTimesRootOf3 *
( (sides[0] * sides[2]).length() ));
if(div == 0.0)
metric_vals->aspect_frobenius = (double)VERDICT_DBL_MAX;
else
metric_vals->aspect_frobenius = (double)(srms / div);
}
// calculate the radius ratio of the triangle
if( metrics_request_flag & V_TRI_RADIUS_RATIO )
{
double a1 = sqrt( sides_lengths_squared[0] );
double b1 = sqrt( sides_lengths_squared[1] );
double c1 = sqrt( sides_lengths_squared[2] );
VerdictVector ab = sides[0] * sides[1];
metric_vals->radius_ratio = (double) .25 * a1 * b1 * c1 * ( a1 + b1 + c1 ) / ab.length_squared();
}
// calculate the scaled jacobian
if(metrics_request_flag & V_TRI_SCALED_JACOBIAN)
{
// calculate once and reuse
static const double twoOverRootOf3 = 2/sqrt(3.0);
// use the area from above
double tmp = tri_normal.length() * twoOverRootOf3;
// now scale it by the lengths of the sides
double min_scaled_jac = VERDICT_DBL_MAX;
double temp_scaled_jac;
for(int i=0; i<3; i++)
{
if(sides_lengths_squared[i%3] == 0.0 || sides_lengths_squared[(i+2)%3] == 0.0)
temp_scaled_jac = 0.0;
else
temp_scaled_jac = tmp / sqrt(sides_lengths_squared[i%3]) / sqrt(sides_lengths_squared[(i+2)%3]);
if( temp_scaled_jac < min_scaled_jac )
min_scaled_jac = temp_scaled_jac;
}
//multiply by -1 if the normals are in opposite directions
if( is_inverted )
{
min_scaled_jac *= -1;
}
metric_vals->scaled_jacobian = (double)min_scaled_jac;
}
// calculate the condition number
if(metrics_request_flag & V_TRI_CONDITION)
{
// calculate once and reuse
static const double rootOf3 = sqrt(3.0);
//if it is inverted, the condition number is considered to be infinity.
if(is_inverted){
metric_vals->condition = VERDICT_DBL_MAX;
}
else{
double area2x = (sides[0] * sides[2]).length();
if(area2x == 0.0 )
metric_vals->condition = (double)(VERDICT_DBL_MAX);
else
metric_vals->condition = (double) ( (sides[0]%sides[0] +
sides[2]%sides[2] -
sides[0]%sides[2]) /
(area2x*rootOf3) );
}
}
// calculate the shape
if(metrics_request_flag & V_TRI_SHAPE || metrics_request_flag & V_TRI_SHAPE_AND_SIZE)
{
//if element is inverted, shape is zero. We don't need to
//calculate anything.
if(is_inverted ){
metric_vals->shape = 0.0;
}
else{//otherwise, we calculate the shape
// calculate once and reuse
static const double rootOf3 = sqrt(3.0);
// reuse area from before
double area2x = metric_vals->area * 2;
// dot products
double dots[3] = {
sides[0] % sides[0],
sides[2] % sides[2],
sides[0] % sides[2]
};
// add the dots
double sum_dots = dots[0] + dots[1] - dots[2];
// then the finale
if( sum_dots == 0.0 )
metric_vals->shape = 0.0;
else
metric_vals->shape = (double)(rootOf3 * area2x / sum_dots);
}
}
// calculate relative size squared
if(metrics_request_flag & V_TRI_RELATIVE_SIZE_SQUARED || metrics_request_flag & V_TRI_SHAPE_AND_SIZE)
{
// get weights
double w11, w21, w12, w22;
v_tri_get_weight(w11,w21,w12,w22);
// get the determinant
double detw = v_determinant(w11,w21,w12,w22);
// use the area from above and divide with the determinant
if( metric_vals->area == 0.0 || detw == 0.0 )
metric_vals->relative_size_squared = 0.0;
else
{
double size = metric_vals->area * 2.0 / detw;
// square the size
size *= size;
// value ranges between 0 to 1
metric_vals->relative_size_squared = (double)VERDICT_MIN(size, 1.0/size );
}
}
// calculate shape and size
if(metrics_request_flag & V_TRI_SHAPE_AND_SIZE)
{
metric_vals->shape_and_size =
metric_vals->relative_size_squared * metric_vals->shape;
}
// calculate distortion
if(metrics_request_flag & V_TRI_DISTORTION)
metric_vals->distortion = v_tri_distortion(num_nodes, coordinates);
//take care of any over-flow problems
if( metric_vals->aspect_frobenius > 0 )
metric_vals->aspect_frobenius = (double) VERDICT_MIN( metric_vals->aspect_frobenius, VERDICT_DBL_MAX );\
else
metric_vals->aspect_frobenius = (double) VERDICT_MAX( metric_vals->aspect_frobenius, -VERDICT_DBL_MAX );
if( metric_vals->area > 0 )
metric_vals->area = (double) VERDICT_MIN( metric_vals->area, VERDICT_DBL_MAX );
else
metric_vals->area = (double) VERDICT_MAX( metric_vals->area, -VERDICT_DBL_MAX );
if( metric_vals->minimum_angle > 0 )
metric_vals->minimum_angle = (double) VERDICT_MIN( metric_vals->minimum_angle, VERDICT_DBL_MAX );
else
metric_vals->minimum_angle = (double) VERDICT_MAX( metric_vals->minimum_angle, -VERDICT_DBL_MAX );
if( metric_vals->maximum_angle > 0 )
metric_vals->maximum_angle = (double) VERDICT_MIN( metric_vals->maximum_angle, VERDICT_DBL_MAX );
else
metric_vals->maximum_angle = (double) VERDICT_MAX( metric_vals->maximum_angle , -VERDICT_DBL_MAX );
if( metric_vals->condition > 0 )
metric_vals->condition = (double) VERDICT_MIN( metric_vals->condition, VERDICT_DBL_MAX );
else
metric_vals->condition = (double) VERDICT_MAX( metric_vals->condition, -VERDICT_DBL_MAX );
if( metric_vals->shape > 0 )
metric_vals->shape = (double) VERDICT_MIN( metric_vals->shape, VERDICT_DBL_MAX );
else
metric_vals->shape = (double) VERDICT_MAX( metric_vals->shape, -VERDICT_DBL_MAX );
if( metric_vals->radius_ratio > 0 )
metric_vals->radius_ratio = (double) VERDICT_MIN( metric_vals->radius_ratio, VERDICT_DBL_MAX );\
else
metric_vals->radius_ratio = (double) VERDICT_MAX( metric_vals->radius_ratio, -VERDICT_DBL_MAX );
if( metric_vals->scaled_jacobian > 0 )
metric_vals->scaled_jacobian = (double) VERDICT_MIN( metric_vals->scaled_jacobian, VERDICT_DBL_MAX );
else
metric_vals->scaled_jacobian = (double) VERDICT_MAX( metric_vals->scaled_jacobian, -VERDICT_DBL_MAX );
if( metric_vals->relative_size_squared > 0 )
metric_vals->relative_size_squared = (double) VERDICT_MIN( metric_vals->relative_size_squared, VERDICT_DBL_MAX );
else
metric_vals->relative_size_squared = (double) VERDICT_MAX( metric_vals->relative_size_squared, -VERDICT_DBL_MAX );
if( metric_vals->shape_and_size > 0 )
metric_vals->shape_and_size = (double) VERDICT_MIN( metric_vals->shape_and_size, VERDICT_DBL_MAX );
else
metric_vals->shape_and_size = (double) VERDICT_MAX( metric_vals->shape_and_size, -VERDICT_DBL_MAX );
if( metric_vals->distortion > 0 )
metric_vals->distortion = (double) VERDICT_MIN( metric_vals->distortion, VERDICT_DBL_MAX );
else
metric_vals->distortion = (double) VERDICT_MAX( metric_vals->distortion, -VERDICT_DBL_MAX );
}
/*!
multiple quality measures of a quad
*/
C_FUNC_DEF void v_quad_quality( int num_nodes, VERDICT_REAL coordinates[][3],
unsigned int metrics_request_flag, QuadMetricVals *metric_vals )
{
memset( metric_vals, 0, sizeof(QuadMetricVals) );
// for starts, lets set up some basic and common information
/* node numbers and side numbers used below
2
3 +--------- 2
/ +
/ |
3 / | 1
/ |
+ |
0 -------------+ 1
0
*/
// vectors for each side
VerdictVector edges[4];
make_quad_edges( edges, coordinates );
double areas[4];
signed_corner_areas( areas, coordinates );
double lengths[4];
lengths[0] = edges[0].length();
lengths[1] = edges[1].length();
lengths[2] = edges[2].length();
lengths[3] = edges[3].length();
VerdictBoolean is_collapsed = is_collapsed_quad(coordinates);
// handle collapsed quads metrics here
if(is_collapsed == VERDICT_TRUE && metrics_request_flag &
( V_QUAD_MINIMUM_ANGLE | V_QUAD_MAXIMUM_ANGLE | V_QUAD_JACOBIAN |
V_QUAD_SCALED_JACOBIAN ))
{
if(metrics_request_flag & V_QUAD_MINIMUM_ANGLE)
metric_vals->minimum_angle = v_tri_minimum_angle(3, coordinates);
if(metrics_request_flag & V_QUAD_MAXIMUM_ANGLE)
metric_vals->maximum_angle = v_tri_maximum_angle(3, coordinates);
if(metrics_request_flag & V_QUAD_JACOBIAN)
metric_vals->jacobian = (VERDICT_REAL)(v_tri_area(3, coordinates) * 2.0);
if(metrics_request_flag & V_QUAD_SCALED_JACOBIAN)
metric_vals->jacobian = (VERDICT_REAL)(v_tri_scaled_jacobian(3, coordinates) * 2.0);
}
// calculate both largest and smallest angles
if(metrics_request_flag & (V_QUAD_MINIMUM_ANGLE | V_QUAD_MAXIMUM_ANGLE)
&& is_collapsed == VERDICT_FALSE )
{
// gather the angles
double angles[4];
angles[0] = acos( -(edges[0] % edges[1])/(lengths[0]*lengths[1]) );
angles[1] = acos( -(edges[1] % edges[2])/(lengths[1]*lengths[2]) );
angles[2] = acos( -(edges[2] % edges[3])/(lengths[2]*lengths[3]) );
angles[3] = acos( -(edges[3] % edges[0])/(lengths[3]*lengths[0]) );
if( lengths[0] <= VERDICT_DBL_MIN ||
lengths[1] <= VERDICT_DBL_MIN ||
lengths[2] <= VERDICT_DBL_MIN ||
lengths[3] <= VERDICT_DBL_MIN )
{
metric_vals->minimum_angle = 360.0;
metric_vals->maximum_angle = 0.0;
}
else
{
// if smallest angle, find the smallest angle
if(metrics_request_flag & V_QUAD_MINIMUM_ANGLE)
{
metric_vals->minimum_angle = VERDICT_DBL_MAX;
for(int i = 0; i<4; i++)
metric_vals->minimum_angle = VERDICT_MIN(angles[i], metric_vals->minimum_angle);
metric_vals->minimum_angle *= 180.0 / VERDICT_PI;
}
// if largest angle, find the largest angle
if(metrics_request_flag & V_QUAD_MAXIMUM_ANGLE)
{
metric_vals->maximum_angle = 0.0;
for(int i = 0; i<4; i++)
metric_vals->maximum_angle = VERDICT_MAX(angles[i], metric_vals->maximum_angle);
metric_vals->maximum_angle *= 180.0 / VERDICT_PI;
if( areas[0] < 0 || areas[1] < 0 ||
areas[2] < 0 || areas[3] < 0 )
metric_vals->maximum_angle = 360 - metric_vals->maximum_angle;
}
}
}
// handle aspect, skew, taper, and area together
if( metrics_request_flag & ( V_QUAD_ASPECT | V_QUAD_SKEW | V_QUAD_TAPER ) )
{
//get principle axes
VerdictVector principal_axes[2];
principal_axes[0] = edges[0] - edges[2];
principal_axes[1] = edges[1] - edges[3];
if(metrics_request_flag & (V_QUAD_ASPECT | V_QUAD_SKEW | V_QUAD_TAPER))
{
double len1 = principal_axes[0].length();
double len2 = principal_axes[1].length();
// calculate the aspect ratio
if(metrics_request_flag & V_QUAD_ASPECT)
{
if( len1 < VERDICT_DBL_MIN || len2 < VERDICT_DBL_MIN )
metric_vals->aspect = VERDICT_DBL_MAX;
else
metric_vals->aspect = VERDICT_MAX( len1 / len2, len2 / len1 );
}
// calculate the taper
if(metrics_request_flag & V_QUAD_TAPER)
{
double min_length = VERDICT_MIN( len1, len2 );
VerdictVector cross_derivative = edges[1] + edges[3];
if( min_length < VERDICT_DBL_MIN )
metric_vals->taper = VERDICT_DBL_MAX;
else
metric_vals->taper = cross_derivative.length()/ min_length;
}
// calculate the skew
if(metrics_request_flag & V_QUAD_SKEW)
{
if( principal_axes[0].normalize() < VERDICT_DBL_MIN ||
principal_axes[1].normalize() < VERDICT_DBL_MIN )
metric_vals->skew = 0.0;
else
metric_vals->skew = fabs( principal_axes[0] % principal_axes[1] );
}
}
}
// calculate the area
if(metrics_request_flag & (V_QUAD_AREA | V_QUAD_RELATIVE_SIZE_SQUARED) )
{
metric_vals->area = 0.25 * (areas[0] + areas[1] + areas[2] + areas[3]);
}
// calculate the relative size
if(metrics_request_flag & (V_QUAD_RELATIVE_SIZE_SQUARED | V_QUAD_SHAPE_AND_SIZE |
V_QUAD_SHEAR_AND_SIZE ) )
{
double quad_area = v_quad_area (4, coordinates);
v_set_quad_size( quad_area );
double w11,w21,w12,w22;
get_weight(w11,w21,w12,w22);
double avg_area = determinant(w11,w21,w12,w22);
if( avg_area < VERDICT_DBL_MIN )
metric_vals->relative_size_squared = 0.0;
else
metric_vals->relative_size_squared = pow( VERDICT_MIN(
metric_vals->area/avg_area,
avg_area/metric_vals->area ), 2 );
}
// calculate the jacobian
if(metrics_request_flag & V_QUAD_JACOBIAN)
{
metric_vals->jacobian = VERDICT_MIN(
VERDICT_MIN( areas[0], areas[1] ),
VERDICT_MIN( areas[2], areas[3] ) );
}
if( metrics_request_flag & ( V_QUAD_SCALED_JACOBIAN | V_QUAD_SHEAR | V_QUAD_SHEAR_AND_SIZE ) )
{
double scaled_jac, min_scaled_jac = VERDICT_DBL_MAX;
if( lengths[0] < VERDICT_DBL_MIN ||
lengths[1] < VERDICT_DBL_MIN ||
lengths[2] < VERDICT_DBL_MIN ||
lengths[3] < VERDICT_DBL_MIN )
{
metric_vals->scaled_jacobian = 0.0;
metric_vals->shear = 0.0;
}
else
{
scaled_jac = areas[0] / (lengths[0] * lengths[3]);
min_scaled_jac = VERDICT_MIN( scaled_jac, min_scaled_jac );
scaled_jac = areas[1] / (lengths[1] * lengths[0]);
min_scaled_jac = VERDICT_MIN( scaled_jac, min_scaled_jac );
scaled_jac = areas[2] / (lengths[2] * lengths[1]);
min_scaled_jac = VERDICT_MIN( scaled_jac, min_scaled_jac );
scaled_jac = areas[3] / (lengths[3] * lengths[2]);
min_scaled_jac = VERDICT_MIN( scaled_jac, min_scaled_jac );
metric_vals->scaled_jacobian = min_scaled_jac;
//what the heck...set shear as well
if( min_scaled_jac <= VERDICT_DBL_MIN )
metric_vals->shear = 0.0;
else
metric_vals->shear = min_scaled_jac;
}
}
if( metrics_request_flag & (V_QUAD_WARPAGE | V_QUAD_ODDY) )
{
VerdictVector corner_normals[4];
corner_normals[0] = edges[3] * edges[0];
corner_normals[1] = edges[0] * edges[1];
corner_normals[2] = edges[1] * edges[2];
corner_normals[3] = edges[2] * edges[3];
if( metrics_request_flag & V_QUAD_ODDY )
{
double oddy, max_oddy = 0.0;
double diff, dot_prod;
double length_squared[4];
length_squared[0] = corner_normals[0].length_squared();
length_squared[1] = corner_normals[1].length_squared();
length_squared[2] = corner_normals[2].length_squared();
length_squared[3] = corner_normals[3].length_squared();
if( length_squared[0] < VERDICT_DBL_MIN ||
length_squared[1] < VERDICT_DBL_MIN ||
length_squared[2] < VERDICT_DBL_MIN ||
length_squared[3] < VERDICT_DBL_MIN )
metric_vals->oddy = VERDICT_DBL_MAX;
else
{
diff = (lengths[0]*lengths[0]) - (lengths[1]*lengths[1]);
dot_prod = edges[0]%edges[1];
oddy = ((diff*diff) + 4*dot_prod*dot_prod ) / (2*length_squared[1]);
max_oddy = VERDICT_MAX( oddy, max_oddy );
diff = (lengths[1]*lengths[1]) - (lengths[2]*lengths[2]);
dot_prod = edges[1]%edges[2];
oddy = ((diff*diff) + 4*dot_prod*dot_prod ) / (2*length_squared[2]);
max_oddy = VERDICT_MAX( oddy, max_oddy );
diff = (lengths[2]*lengths[2]) - (lengths[3]*lengths[3]);
dot_prod = edges[2]%edges[3];
oddy = ((diff*diff) + 4*dot_prod*dot_prod ) / (2*length_squared[3]);
max_oddy = VERDICT_MAX( oddy, max_oddy );
diff = (lengths[3]*lengths[3]) - (lengths[0]*lengths[0]);
dot_prod = edges[3]%edges[0];
oddy = ((diff*diff) + 4*dot_prod*dot_prod ) / (2*length_squared[0]);
max_oddy = VERDICT_MAX( oddy, max_oddy );
metric_vals->oddy = max_oddy;
}
}
if( metrics_request_flag & V_QUAD_WARPAGE )
{
if( corner_normals[0].normalize() < VERDICT_DBL_MIN ||
corner_normals[1].normalize() < VERDICT_DBL_MIN ||
corner_normals[2].normalize() < VERDICT_DBL_MIN ||
corner_normals[3].normalize() < VERDICT_DBL_MIN )
metric_vals->warpage = VERDICT_DBL_MAX;
else
{
metric_vals->warpage = pow(
VERDICT_MIN( corner_normals[0]%corner_normals[2],
corner_normals[1]%corner_normals[3]), 3 );
}
}
}
if( metrics_request_flag & V_QUAD_STRETCH )
{
VerdictVector temp;
temp.set( coordinates[2][0] - coordinates[0][0],
coordinates[2][1] - coordinates[0][1],
coordinates[2][2] - coordinates[0][2]);
double diag02 = temp.length_squared();
temp.set( coordinates[3][0] - coordinates[1][0],
coordinates[3][1] - coordinates[1][1],
coordinates[3][2] - coordinates[1][2]);
double diag13 = temp.length_squared();
static const double QUAD_STRETCH_FACTOR = sqrt(2.0);
// 'diag02' is now the max diagonal of the quad
diag02 = VERDICT_MAX( diag02, diag13 );
if( diag02 < VERDICT_DBL_MIN )
metric_vals->stretch = VERDICT_DBL_MAX;
else
metric_vals->stretch = QUAD_STRETCH_FACTOR *
VERDICT_MIN(
VERDICT_MIN( lengths[0], lengths[1] ),
VERDICT_MIN( lengths[2], lengths[3] ) ) /
sqrt(diag02);
}
if(metrics_request_flag & (V_QUAD_CONDITION | V_QUAD_SHAPE | V_QUAD_SHAPE_AND_SIZE ) )
{
double lengths_squared[4];
lengths_squared[0] = edges[0].length_squared();
lengths_squared[1] = edges[1].length_squared();
lengths_squared[2] = edges[2].length_squared();
lengths_squared[3] = edges[3].length_squared();
if( areas[0] < VERDICT_DBL_MIN ||
areas[1] < VERDICT_DBL_MIN ||
areas[2] < VERDICT_DBL_MIN ||
areas[3] < VERDICT_DBL_MIN )
{
metric_vals->condition = VERDICT_DBL_MAX;
metric_vals->shape= VERDICT_DBL_MAX;
}
else
{
double max_condition = 0.0, condition;
condition = (lengths_squared[0] + lengths_squared[3])/areas[0];
max_condition = VERDICT_MAX( max_condition, condition );
condition = (lengths_squared[1] + lengths_squared[0])/areas[1];
max_condition = VERDICT_MAX( max_condition, condition );
condition = (lengths_squared[2] + lengths_squared[1])/areas[2];
max_condition = VERDICT_MAX( max_condition, condition );
condition = (lengths_squared[3] + lengths_squared[2])/areas[3];
max_condition = VERDICT_MAX( max_condition, condition );
metric_vals->condition = 0.5*max_condition;
metric_vals->shape = 2/max_condition;
}
}
if(metrics_request_flag & V_QUAD_AREA )
{
if( metric_vals->area > 0 )
metric_vals->area = (VERDICT_REAL) VERDICT_MIN( metric_vals->area, VERDICT_DBL_MAX );
metric_vals->area = (VERDICT_REAL) VERDICT_MAX( metric_vals->area, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_ASPECT )
{
if( metric_vals->aspect > 0 )
metric_vals->aspect = (VERDICT_REAL) VERDICT_MIN( metric_vals->aspect, VERDICT_DBL_MAX );
metric_vals->aspect = (VERDICT_REAL) VERDICT_MAX( metric_vals->aspect, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_CONDITION )
{
if( metric_vals->condition > 0 )
metric_vals->condition = (VERDICT_REAL) VERDICT_MIN( metric_vals->condition, VERDICT_DBL_MAX );
metric_vals->condition = (VERDICT_REAL) VERDICT_MAX( metric_vals->condition, -VERDICT_DBL_MAX );
}
// calculate distortion
if(metrics_request_flag & V_QUAD_DISTORTION)
{
metric_vals->distortion = v_quad_distortion(num_nodes, coordinates);
if( metric_vals->distortion > 0 )
metric_vals->distortion = (VERDICT_REAL) VERDICT_MIN( metric_vals->distortion, VERDICT_DBL_MAX );
metric_vals->distortion = (VERDICT_REAL) VERDICT_MAX( metric_vals->distortion, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_JACOBIAN )
{
if( metric_vals->jacobian > 0 )
metric_vals->jacobian = (VERDICT_REAL) VERDICT_MIN( metric_vals->jacobian, VERDICT_DBL_MAX );
metric_vals->jacobian = (VERDICT_REAL) VERDICT_MAX( metric_vals->jacobian, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_MAXIMUM_ANGLE )
{
if( metric_vals->maximum_angle > 0 )
metric_vals->maximum_angle = (VERDICT_REAL) VERDICT_MIN( metric_vals->maximum_angle, VERDICT_DBL_MAX );
metric_vals->maximum_angle = (VERDICT_REAL) VERDICT_MAX( metric_vals->maximum_angle, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_MINIMUM_ANGLE )
{
if( metric_vals->minimum_angle > 0 )
metric_vals->minimum_angle = (VERDICT_REAL) VERDICT_MIN( metric_vals->minimum_angle, VERDICT_DBL_MAX );
metric_vals->minimum_angle = (VERDICT_REAL) VERDICT_MAX( metric_vals->minimum_angle, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_ODDY )
{
if( metric_vals->oddy > 0 )
metric_vals->oddy = (VERDICT_REAL) VERDICT_MIN( metric_vals->oddy, VERDICT_DBL_MAX );
metric_vals->oddy = (VERDICT_REAL) VERDICT_MAX( metric_vals->oddy, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_RELATIVE_SIZE_SQUARED )
{
if( metric_vals->relative_size_squared> 0 )
metric_vals->relative_size_squared = (VERDICT_REAL) VERDICT_MIN( metric_vals->relative_size_squared, VERDICT_DBL_MAX );
metric_vals->relative_size_squared = (VERDICT_REAL) VERDICT_MAX( metric_vals->relative_size_squared, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_SCALED_JACOBIAN )
{
if( metric_vals->scaled_jacobian> 0 )
metric_vals->scaled_jacobian = (VERDICT_REAL) VERDICT_MIN( metric_vals->scaled_jacobian, VERDICT_DBL_MAX );
metric_vals->scaled_jacobian = (VERDICT_REAL) VERDICT_MAX( metric_vals->scaled_jacobian, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_SHEAR )
{
if( metric_vals->shear > 0 )
metric_vals->shear = (VERDICT_REAL) VERDICT_MIN( metric_vals->shear, VERDICT_DBL_MAX );
metric_vals->shear = (VERDICT_REAL) VERDICT_MAX( metric_vals->shear, -VERDICT_DBL_MAX );
}
// calculate shear and size
// reuse values from above
if(metrics_request_flag & V_QUAD_SHEAR_AND_SIZE)
{
metric_vals->shear_and_size = metric_vals->shear * metric_vals->relative_size_squared;
if( metric_vals->shear_and_size > 0 )
metric_vals->shear_and_size = (VERDICT_REAL) VERDICT_MIN( metric_vals->shear_and_size, VERDICT_DBL_MAX );
metric_vals->shear_and_size = (VERDICT_REAL) VERDICT_MAX( metric_vals->shear_and_size, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_SHAPE )
{
if( metric_vals->shape > 0 )
metric_vals->shape = (VERDICT_REAL) VERDICT_MIN( metric_vals->shape, VERDICT_DBL_MAX );
metric_vals->shape = (VERDICT_REAL) VERDICT_MAX( metric_vals->shape, -VERDICT_DBL_MAX );
}
// calculate shape and size
// reuse values from above
if(metrics_request_flag & V_QUAD_SHAPE_AND_SIZE)
{
metric_vals->shape_and_size = metric_vals->shape * metric_vals->relative_size_squared;
if( metric_vals->shape_and_size > 0 )
metric_vals->shape_and_size = (VERDICT_REAL) VERDICT_MIN( metric_vals->shape_and_size, VERDICT_DBL_MAX );
metric_vals->shape_and_size = (VERDICT_REAL) VERDICT_MAX( metric_vals->shape_and_size, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_SKEW )
{
if( metric_vals->skew > 0 )
metric_vals->skew = (VERDICT_REAL) VERDICT_MIN( metric_vals->skew, VERDICT_DBL_MAX );
metric_vals->skew = (VERDICT_REAL) VERDICT_MAX( metric_vals->skew, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_STRETCH )
{
if( metric_vals->stretch > 0 )
metric_vals->stretch = (VERDICT_REAL) VERDICT_MIN( metric_vals->stretch, VERDICT_DBL_MAX );
metric_vals->stretch = (VERDICT_REAL) VERDICT_MAX( metric_vals->stretch, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_TAPER )
{
if( metric_vals->taper > 0 )
metric_vals->taper = (VERDICT_REAL) VERDICT_MIN( metric_vals->taper, VERDICT_DBL_MAX );
metric_vals->taper = (VERDICT_REAL) VERDICT_MAX( metric_vals->taper, -VERDICT_DBL_MAX );
}
if(metrics_request_flag & V_QUAD_WARPAGE )
{
if( metric_vals->warpage > 0 )
metric_vals->warpage = (VERDICT_REAL) VERDICT_MIN( metric_vals->warpage, VERDICT_DBL_MAX );
metric_vals->warpage = (VERDICT_REAL) VERDICT_MAX( metric_vals->warpage, -VERDICT_DBL_MAX );
}
}