visual_pose_estimation::PoseEstimator createCheckerboardEstimator(int width, int height, float square_size)
{
cv::Mat_<cv::Vec3f> grid_points(width*height, 1);
int j = 0;
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
grid_points(j, 0) = cv::Vec3f(x*square_size, y*square_size, 0.0f);
++j;
}
}
return visual_pose_estimation::PoseEstimator(grid_points);
}
void create_circle( std::vector<Vec3d>& verts,
std::vector<Vec3st>& tris,
std::vector<double>& masses,
const Vec3d& centre,
double radius,
size_t nx )
{
Vec3d low = centre - Vec3d( radius, 0.0, radius );
double dx = 2.0 * radius / (double)nx;
Array2<Vec3d> grid_points;
grid_points.resize(nx, nx);
for ( size_t i = 0; i < nx; ++i )
{
for ( size_t j = 0; j < nx; ++j )
{
grid_points(i,j) = low + dx * Vec3d( i, 0, j );
verts.push_back( low + dx * Vec3d( i, 0, j ) );
}
}
// cells
for ( size_t i = 0; i < nx-1; ++i )
{
for ( size_t j = 0; j < nx-1; ++j )
{
size_t a = i + nx*j;
size_t b = i+1 + nx*j;
size_t c = i+1 + nx*(j+1);
size_t d = i + nx*(j+1);
if ( ( dist( verts[a], centre ) < radius ) &&
( dist( verts[b], centre ) < radius ) &&
( dist( verts[d], centre ) < radius ) )
{
tris.push_back( Vec3st( a, b, d ) );
}
if ( ( dist( verts[b], centre ) < radius ) &&
( dist( verts[c], centre ) < radius ) &&
( dist( verts[d], centre ) < radius ) )
{
tris.push_back( Vec3st( b, c, d ) );
}
}
}
masses.clear();
masses.resize( verts.size(), 1.0 );
NonDestructiveTriMesh temp_tri_mesh;
temp_tri_mesh.set_num_vertices( verts.size() );
for ( size_t i = 0; i < tris.size(); ++i )
{
temp_tri_mesh.add_triangle( tris[i] );
}
}
void error_norm(double rms[]) {
//---------------------------------------------------------------------
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// this function computes the norm of the difference between the
// computed solution and the exact solution
//---------------------------------------------------------------------
int c, i, j, k, m, ii, jj, kk, d, error;
double xi, eta, zeta, u_exact[5], rms_work[5],
add;
for (m = 1; m <= 5; m++) {
rms_work(m) = 0.0e0;
}
for (c = 1; c <= ncells; c++) {
kk = 0;
for (k = cell_low(3,c); k <= cell_high(3,c); k++) {
zeta = (double)(k) * dnzm1;
jj = 0;
for (j = cell_low(2,c); j <= cell_high(2,c); j++) {
eta = (double)(j) * dnym1;
ii = 0;
for (i = cell_low(1,c); i <= cell_high(1,c); i++) {
xi = (double)(i) * dnxm1;
exact_solution(xi, eta, zeta, u_exact);
for (m = 1; m <= 5; m++) {
add = u(m,ii,jj,kk,c)-u_exact(m);
rms_work(m) = rms_work(m) + add*add;
}
ii = ii + 1;
}
jj = jj + 1;
}
kk = kk + 1;
}
}
RCCE_allreduce((char*)rms_work, (char*)rms, 5, RCCE_DOUBLE, RCCE_SUM, RCCE_COMM_WORLD);
for (m = 1; m <= 5; m++) {
for (d = 1; d <= 3; d++) {
rms(m) = rms(m) / (double)(grid_points(d)-2);
}
rms(m) = sqrt(rms(m));
}
return;
}
void rhs_norm(double rms[]) {
//---------------------------------------------------------------------
//---------------------------------------------------------------------
int c, i, j, k, d, m, error;
double rms_work[5], add;
for (m = 1; m <= 5; m++) {
rms_work(m) = 0.0e0;
}
for (c = 1; c <= ncells; c++) {
for (k = start(3,c); k <= cell_size(3,c)-end(3,c)-1; k++) {
for (j = start(2,c); j <= cell_size(2,c)-end(2,c)-1; j++) {
for (i = start(1,c); i <= cell_size(1,c)-end(1,c)-1; i++) {
for (m = 1; m <= 5; m++) {
add = rhs(m,i,j,k,c);
rms_work(m) = rms_work(m) + add*add;
}
}
}
}
}
RCCE_allreduce((char*)rms_work, (char*)rms, 5, RCCE_DOUBLE, RCCE_SUM, RCCE_COMM_WORLD);
for (m = 1; m <= 5; m++) {
for (d = 1; d <= 3; d++) {
rms(m) = rms(m) / (double)(grid_points(d)-2);
}
rms(m) = sqrt(rms(m));
}
return;
}
void verify(int no_time_steps, char *class_r, int *verified_r) {
//---------------------------------------------------------------------
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// verification routine
//---------------------------------------------------------------------
double xcrref[5],xceref[5],xcrdif[5],xcedif[5],
epsilon, xce[5], xcr[5], dtref;
int m;
char class;
int verified;
#define xcrref(m) xcrref[m-1]
#define xceref(m) xceref[m-1]
#define xcrdif(m) xcrdif[m-1]
#define xcedif(m) xcedif[m-1]
#define xce(m) xce[m-1]
#define xcr(m) xcr[m-1]
//---------------------------------------------------------------------
// tolerance level
//---------------------------------------------------------------------
epsilon = 1.0e-08;
verified = 1;
//---------------------------------------------------------------------
// compute the error norm and the residual norm, and exit if not printing
//---------------------------------------------------------------------
error_norm(xce);
copy_faces();
rhs_norm(xcr);
for (m = 1; m <= 5; m++) {
xcr(m) = xcr(m) / dt;
}
if (node != root) return;
class = 'U';
for (m = 1; m <= 5; m++) {
xcrref(m) = 1.0;
xceref(m) = 1.0;
}
//---------------------------------------------------------------------
// reference data for 12X12X12 grids after 60 time steps, with DT = 1.0e-02
//---------------------------------------------------------------------
if ( (grid_points(1) == 12 ) &&
(grid_points(2) == 12 ) &&
(grid_points(3) == 12 ) &&
(no_time_steps == 60 )) {
class = 'S';
dtref = 1.0e-2;
//---------------------------------------------------------------------
// Reference values of RMS-norms of residual.
//---------------------------------------------------------------------
xcrref(1) = 1.7034283709541311e-01;
xcrref(2) = 1.2975252070034097e-02;
xcrref(3) = 3.2527926989486055e-02;
xcrref(4) = 2.6436421275166801e-02;
xcrref(5) = 1.9211784131744430e-01;
//---------------------------------------------------------------------
// Reference values of RMS-norms of solution error.
//---------------------------------------------------------------------
xceref(1) = 4.9976913345811579e-04;
xceref(2) = 4.5195666782961927e-05;
xceref(3) = 7.3973765172921357e-05;
xceref(4) = 7.3821238632439731e-05;
xceref(5) = 8.9269630987491446e-04;
//---------------------------------------------------------------------
// reference data for 24X24X24 grids after 200 time steps, with DT = 0.8e-3
//---------------------------------------------------------------------
} else if ( (grid_points(1) == 24) &&