/* regrid a point in a file using the input co-ordinate and data */
void regrid_point(VIO_Volume * totals, VIO_Volume * weights,
double x, double y, double z, int v_size, double *data_buf)
{
int sizes[MAX_VAR_DIMS];
VIO_Real steps[MAX_VAR_DIMS];
VIO_Real starts[MAX_VAR_DIMS];
int start_idx[3];
int stop_idx[3];
double value, weight;
double euc_dist;
double euc[3];
double c_pos[3];
int i, j, k, v;
double coord[3]; /* target point in mm coordinates, in X, Y, Z order */
VIO_Transform dircos, invdircos;
VIO_Vector vector;
VIO_Real dir[3];
/* the coord used below has to be in mm coordinates in the dircos space of the
target volume. Hence the manipulations with the vols direction_cosines */
make_identity_transform(&dircos);
get_volume_direction_cosine(*totals, perm[0], dir);
fill_Vector(vector, dir[0], dir[1], dir[2]);
set_transform_x_axis(&dircos, &vector);
get_volume_direction_cosine(*totals, perm[1], dir);
fill_Vector(vector, dir[0], dir[1], dir[2]);
set_transform_y_axis(&dircos, &vector);
get_volume_direction_cosine(*totals, perm[2], dir);
fill_Vector(vector, dir[0], dir[1], dir[2]);
set_transform_z_axis(&dircos, &vector);
for(i = 0; i < 4; i++){
for(j = 0; j < 4; j++){
Transform_elem(invdircos, i, j) = Transform_elem(dircos, j, i);
}
}
transform_point(&invdircos, x, y, z, &coord[0], &coord[1], &coord[2]);
get_volume_sizes(*totals, sizes); /* in volume voxel order, ie z,y,x with x fastest */
get_volume_separations(*totals, steps);
get_volume_starts(*totals, starts);
/* figure out the neighbouring voxels start and stop (in voxel co-ordinates) */
for(i = 0; i < 3; i++){ /* go through x, y and z */
start_idx[i] =
(int)rint((coord[i] - starts[perm[i]] - regrid_radius[i]) / steps[perm[i]]);
stop_idx[i] = start_idx[i] + rint((regrid_radius[i] * 2) / steps[perm[i]]);
/* flip if required */
if(start_idx[i] > stop_idx[i]){
value = start_idx[i];
start_idx[i] = stop_idx[i];
stop_idx[i] = value;
}
/* check that we aren't off the edge */
if(start_idx[i] < 0){
start_idx[i] = 0;
}
if(stop_idx[i] >= sizes[perm[i]]){
stop_idx[i] = sizes[perm[i]] - 1;
}
}
/* loop over the neighbours, getting euclidian distance */
c_pos[0] = starts[perm[0]] + (start_idx[0] * steps[perm[0]]);
for(i = start_idx[0]; i <= stop_idx[0]; i++){
euc[0] = fabs(c_pos[0] - coord[0]);
c_pos[1] = starts[perm[1]] + (start_idx[1] * steps[perm[1]]);
for(j = start_idx[1]; j <= stop_idx[1]; j++){
euc[1] = fabs(c_pos[1] - coord[1]);
c_pos[2] = starts[perm[2]] + (start_idx[2] * steps[perm[2]]);
for(k = start_idx[2]; k <= stop_idx[2]; k++){
euc[2] = fabs(c_pos[2] - coord[2]);
euc_dist = sqrt(SQR2(euc[0]) + SQR2(euc[1]) + SQR2(euc[2]));
if((regrid_radius[0] == 0 || euc[0] <= regrid_radius[0]) &&
(regrid_radius[1] == 0 || euc[1] <= regrid_radius[1]) &&
(regrid_radius[2] == 0 || euc[2] <= regrid_radius[2])){
/* calculate the weighting factor */
switch (regrid_type){
default:
fprintf(stderr, "Erk! unknown regrid_type. File: %s Line: %d\n",
__FILE__, __LINE__);
exit(EXIT_FAILURE);
break;
case NEAREST_FUNC:
case LINEAR_FUNC:
weight = euc_dist;
break;
case KAISERBESSEL_FUNC:
weight =
gsl_sf_bessel_I0(regrid_sigma[0] *
sqrt(1 - SQR2(euc[0] / regrid_radius[0]))) *
gsl_sf_bessel_I0(regrid_sigma[1] *
sqrt(1 - SQR2(euc[1] / regrid_radius[1]))) *
gsl_sf_bessel_I0(regrid_sigma[2] *
sqrt(1 - SQR2(euc[2] / regrid_radius[2]))) /
SQR3((regrid_radius[0] + regrid_radius[1] + regrid_radius[2]) / 3);
break;
case GAUSSIAN_FUNC:
weight = exp(-SQR2(euc[0]) / SQR2(regrid_sigma[0])) *
exp(-SQR2(euc[1]) / SQR2(regrid_sigma[1])) *
exp(-SQR2(euc[2]) / SQR2(regrid_sigma[2]));
break;
}
/* set data values */
if(regrid_type == NEAREST_FUNC){
value = get_volume_real_value(*weights, k, j, i, 0, 0);
if(weight < value){
set_volume_real_value(*weights, k, j, i, 0, 0, weight);
for(v = 0; v < v_size; v++){
set_volume_real_value(*totals, k, j, i, v, 0,
data_buf[0 + v] * weight);
}
}
}
else{
for(v = 0; v < v_size; v++){
value = get_volume_real_value(*totals, k, j, i, v, 0);
set_volume_real_value(*totals, k, j, i, v, 0,
value + (data_buf[0 + v] * weight));
}
/* increment count value */
value = get_volume_real_value(*weights, k, j, i, 0, 0);
set_volume_real_value(*weights, k, j, i, 0, 0, value + weight);
}
}
c_pos[2] += steps[perm[2]];
}
c_pos[1] += steps[perm[1]];
}
c_pos[0] += steps[perm[0]];
}
}
static void append_new_default_deformation_field(Arg_Data *globals)
{
VIO_Volume
new_field;
VIO_Real
zero,
st[VIO_MAX_DIMENSIONS],
wst[VIO_MAX_DIMENSIONS],
step[VIO_MAX_DIMENSIONS],
XYZstart[ VIO_MAX_DIMENSIONS ],
XYZstep[ VIO_MAX_DIMENSIONS ],
voxel[VIO_MAX_DIMENSIONS],
point[VIO_N_DIMENSIONS],
dir[3][3];
int
index[VIO_MAX_DIMENSIONS],
xyzv[VIO_MAX_DIMENSIONS],
i,
count[VIO_MAX_DIMENSIONS],
XYZcount[VIO_MAX_DIMENSIONS],
count_extended[VIO_MAX_DIMENSIONS];
VIO_General_transform
*grid_trans;
VectorR
XYZdirections[ VIO_MAX_DIMENSIONS ];
/* build a vector volume to store the Grid VIO_Transform */
/* ALLOC(new_field,1); not needed since create volume allocs it
internally and returns a pointer*/
if (globals->flags.debug) { print ("In append_new_default_deformation_field...\n"); }
new_field = create_volume(4, dim_name_vector_vol, NC_DOUBLE, TRUE, 0.0, 0.0);
get_volume_XYZV_indices(new_field, xyzv);
/* get the global voxel count and voxel size */
for(i=0; i<VIO_N_DIMENSIONS; i++) {
count[xyzv[i]] = globals->count[i];
count_extended[xyzv[i]] = count[xyzv[i]];
step[xyzv[i]] = globals->step[i];
}
/* add info for the vector dimension */
count[xyzv[VIO_Z+1]] = 3;
count_extended[xyzv[VIO_Z+1]] = 3;
step[xyzv[VIO_Z+1]] = 0.0;
set_volume_sizes( new_field, count);
set_volume_separations( new_field, step);
/*
set_volume_voxel_range( new_field, -MY_MAX_VOX, MY_MAX_VOX);
set_volume_real_range( new_field, -1.0*globals->trans_info.max_def_magnitude, globals->trans_info.max_def_magnitude); no longer needed, now using floats */
for(i=0; i<VIO_N_DIMENSIONS; i++) {
dir[VIO_X][i]=globals->directions[VIO_X].coords[i];
dir[VIO_Y][i]=globals->directions[VIO_Y].coords[i];
dir[VIO_Z][i]=globals->directions[VIO_Z].coords[i];
}
set_volume_direction_cosine(new_field,xyzv[VIO_X],dir[VIO_X]);
set_volume_direction_cosine(new_field,xyzv[VIO_Y],dir[VIO_Y]);
set_volume_direction_cosine(new_field,xyzv[VIO_Z],dir[VIO_Z]);
for(i=0; i<VIO_MAX_DIMENSIONS; i++) /* set the voxel origin, used in the vol def */
voxel[i] = 0.0;
set_volume_translation( new_field, voxel, globals->start);
if (globals->flags.debug) {
print("in append new def, the start is: %8.3f %8.3f %8.3f\n", globals->start[VIO_X], globals->start[VIO_Y], globals->start[VIO_Z]);
}
/* now pad the volume along the spatial axis
to ensure good coverage of the data space
with the deformation field */
for(i=0; i<VIO_N_DIMENSIONS; i++) {
if (globals->count[i]>1) {
voxel[xyzv[i]] = -2.5;
count_extended[xyzv[i]] = globals->count[i]+5;
}
else {
voxel[xyzv[i]] = 0.0;
count_extended[xyzv[i]] = 1;
}
}
if (globals->flags.debug) {
print("in append_new_default_deformation_field:\n\tcount_extended= %d %d %d %d\n",
count_extended[0],count_extended[1],count_extended[2],count_extended[3]);
}
set_volume_sizes(new_field, count_extended);
for(i=0; i<VIO_MAX_DIMENSIONS; i++) count[i] = count_extended[i];
/* reset the first voxel position with the new origin */
convert_voxel_to_world(new_field, voxel,
&(point[VIO_X]), &(point[VIO_Y]), &(point[VIO_Z]));
for(i=0; i<VIO_MAX_DIMENSIONS; i++) voxel[i] = 0;
set_volume_translation(new_field, voxel, point);
if (globals->flags.debug) {
print (" point: %8.3f %8.3f %8.3f \n", point[VIO_X], point[VIO_Y], point[VIO_Z]);
get_volume_starts(new_field, st);
print (" start: %8.3f %8.3f %8.3f \n", st[xyzv[VIO_X]], st[xyzv[VIO_Y]], st[xyzv[VIO_Z]]);
voxel[0] = 0;
voxel[1] = 0;
voxel[2] = 0;
get_volume_translation(new_field, voxel, wst);
print (" wstrt: %8.3f %8.3f %8.3f \n", wst[VIO_X], wst[VIO_Y], wst[VIO_Z]);
print (" voxel: %8.3f %8.3f %8.3f \n", voxel[xyzv[VIO_X]], voxel[xyzv[VIO_Y]], voxel[xyzv[VIO_Z]]);
for(i=0; i<3; i++) {
get_volume_direction_cosine(new_field,xyzv[i], wst);
print (" dirs: %8.3f %8.3f %8.3f \n", wst[VIO_X], wst[VIO_Y], wst[VIO_Z]);
}
}
/* allocate space for the deformation field data */
alloc_volume_data(new_field);
/* Initilize the field to zero deformation */
/* zero = CONVERT_VALUE_TO_VOXEL(new_field, 0.0); not needed, defs are now doubles */
for(index[0]=0; index[0]<count[0]; index[0]++)
for(index[1]=0; index[1]<count[1]; index[1]++)
for(index[2]=0; index[2]<count[2]; index[2]++)
for(index[3]=0; index[3]<count[3]; index[3]++)
{
SET_VOXEL(new_field, index[0],index[1],index[2],index[3],0, 0.0); /* was set to 'zero', but now as a double,can be set to 0.0 */
}
/* build the new GRID_TRANSFORM */
ALLOC(grid_trans, 1);
create_grid_transform(grid_trans, new_field, NULL);
/* append the deforamation to the current transformation */
concat_general_transforms(globals->trans_info.transformation, grid_trans,
globals->trans_info.transformation);
delete_volume(new_field);
delete_general_transform(grid_trans);
}
