int main( int ac, char* av[] )
{
int N;
VIO_General_transform xfm;
if ( ac != 3 && ac != 4 ) {
fprintf( stderr, "usage: %s N transform.xfm [tolerance]\n", av[0] );
return 1;
}
N = atoi( av[1] );
if ( input_transform_file( av[2], &xfm ) != VIO_OK ) {
fprintf( stderr, "Failed to load transform '%s'\n", av[2] );
return 2;
}
if ( ac == 4 ) {
tolerance = atof( av[3] );
printf( "Setting tolerance to %f.\n", tolerance );
}
while (N-- > 0) {
VIO_Real x = 500.0 * ( drand48() - 0.5 );
VIO_Real y = 500.0 * ( drand48() - 0.5 );
VIO_Real z = 500.0 * ( drand48() - 0.5 );
VIO_Real tx,ty,tz;
VIO_Real a,b,c;
general_transform_point( &xfm, x,y,z, &tx,&ty,&tz );
/* Check that general_inverse_transform_point() and
invert_general_transform() behave sensibly.
*/
general_inverse_transform_point( &xfm, tx,ty,tz, &a,&b,&c );
assert_equal_point( x,y,z, a,b,c,
"general_inverse_transform_point()" );
invert_general_transform( &xfm );
general_transform_point( &xfm, tx,ty,tz, &a,&b,&c );
assert_equal_point( x,y,z, a,b,c,
"general_transform_point() / inverted xfm" );
general_inverse_transform_point( &xfm, x,y,z, &a,&b,&c );
assert_equal_point( tx,ty,tz, a,b,c,
"general_inverse_transform_point() / inverted xfm" );
}
return 0;
}
int main(int argc, char *argv[])
{
VIO_General_transform gt;
char *xfmfile;
int i;
static ArgvInfo argTable[] = {
{"-center", ARGV_FLOAT, (char *) 3, (char *)cent,
"Force center of rotation and scale."},
{"-version", ARGV_FUNC, (char *) print_version_info, (char *)MNI_AUTOREG_LONG_VERSION,
"Print out version info and exit."},
{NULL, ARGV_END, NULL, NULL, NULL}
};
for(i=0; i<3; i++) {
cent[i] = 0.0;
}
if (ParseArgv(&argc, argv, argTable, 0) || (argc<2)) {
(void) fprintf(stderr, "Usage: %s file.xfm [file.mnc] [options] \n",
argv[0]);
exit(EXIT_FAILURE);
}
prog_name = argv[0];
xfmfile = argv[1];
if (argc>2) {
print ("mnc = %s\n",argv[2]);
if (! get_cog(argv[2], cent) ) {
print("Cannot calculate the COG of volume %s\n.", argv[2] );
exit(EXIT_FAILURE);
}
}
if (input_transform_file(xfmfile, >)!=VIO_OK) {
(void)fprintf(stderr, "Error reading transformation file.\n");
exit(EXIT_FAILURE);
}
process_general_transform( > );
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[]) {
int v1, v2, v3, v4;
int sizes[VIO_MAX_DIMENSIONS], grid_sizes[4];
int n_concat_transforms, i;
VIO_STR arg_string;
char *input_volume_name;
char *input_xfm;
VIO_STR outfile;
VIO_Real w1, w2, w3;
VIO_Real nw1, nw2, nw3;
VIO_Real original[3], transformed[3];
VIO_Real value;
VIO_Real cosine[3];
VIO_Real original_separation[3], grid_separation[4];
VIO_Real original_starts[3], grid_starts[4];
VIO_Volume eval_volume, new_grid;
VIO_General_transform xfm, *voxel_to_world;
VIO_STR *dimnames, dimnames_grid[4];
VIO_progress_struct progress;
arg_string = time_stamp(argc, argv);
/* Check arguments */
if(ParseArgv(&argc, argv, argTable, 0) || (argc != 4)){
fprintf(stderr, "\nUsage: %s [options] input.mnc input.xfm output_grid.mnc\n", argv[0]);
fprintf(stderr, " %s -help\n\n", argv[0]);
exit(EXIT_FAILURE);
}
input_volume_name = argv[1];
input_xfm = argv[2];
outfile = argv[3];
/* check for the infile and outfile */
if(access(input_volume_name, F_OK) != 0){
fprintf(stderr, "%s: Couldn't find %s\n\n", argv[0], input_volume_name);
exit(EXIT_FAILURE);
}
if(access(input_xfm, F_OK) != 0) {
fprintf(stderr, "%s: Couldn't find %s\n\n", argv[0], input_xfm);
exit(EXIT_FAILURE);
}
if(access(outfile, F_OK) == 0 && !clobber){
fprintf(stderr, "%s: %s exists! (use -clobber to overwrite)\n\n", argv[0], outfile);
exit(EXIT_FAILURE);
}
/*--- input the volume */
/*
if( input_volume( input_volume_name, 3, NULL, MI_ORIGINAL_TYPE,
FALSE, 0.0, 0.0, TRUE, &eval_volume,(minc_input_options *) NULL ) != OK )
return( 1 );
*/
if (input_volume_header_only( input_volume_name, 3, NULL, &eval_volume,(minc_input_options *) NULL ) != VIO_OK ) {
return( 1 );
}
/* get information about the volume */
get_volume_sizes( eval_volume, sizes );
voxel_to_world = get_voxel_to_world_transform(eval_volume);
dimnames = get_volume_dimension_names(eval_volume);
get_volume_separations(eval_volume, original_separation);
get_volume_starts(eval_volume, original_starts);
/* create new 4D volume, last three dims same as other volume,
first dimension being the vector dimension. */
for(i=1; i < 4; i++) {
dimnames_grid[i] = dimnames[i-1];
grid_separation[i] = original_separation[i-1];
grid_sizes[i] = sizes[i-1];
grid_starts[i] = original_starts[i-1];
}
dimnames_grid[0] = "vector_dimension";
grid_sizes[0] = 3;
grid_separation[0] = 1;
grid_starts[0] = 0;
new_grid = create_volume(4, dimnames_grid, NC_SHORT, FALSE, 0.0, 0.0);
//set_voxel_to_world_transform(new_grid, voxel_to_world);
// initialize the new grid volume, otherwise the output will be
// garbage...
set_volume_real_range(new_grid, -100, 100);
set_volume_sizes(new_grid, grid_sizes);
set_volume_separations(new_grid, grid_separation);
set_volume_starts(new_grid, grid_starts);
/*
for (i=0; i < 3; i++) {
get_volume_direction_cosine(eval_volume, i, cosine);
set_volume_direction_cosine(new_grid, i+1, cosine);
}
*/
alloc_volume_data(new_grid);
/* get the transforms */
if( input_transform_file( input_xfm, &xfm ) != VIO_OK )
return( 1 );
/* see how many transforms will be applied */
n_concat_transforms = get_n_concated_transforms( &xfm );
printf("Number of transforms to be applied: %d\n", n_concat_transforms);
initialize_progress_report(&progress, FALSE, sizes[0], "Processing");
/* evaluate the transform at every voxel, keep the displacement
in the three cardinal directions */
for( v1 = 0; v1 < sizes[0]; ++v1 ) {
update_progress_report(&progress, v1 + 1);
for( v2 = 0; v2 < sizes[1]; ++v2 ) {
for( v3 = 0; v3 < sizes[2]; ++v3 ) {
convert_3D_voxel_to_world(eval_volume,
v1, v2, v3,
&original[0], &original[1], &original[2]);
general_transform_point(&xfm,
original[0], original[1], original[2],
&transformed[0], &transformed[1], &transformed[2]);
for(i=0; i < 3; i++) {
value = transformed[i] - original[i];
set_volume_real_value(new_grid, i, v1, v2, v3, 0, value);
}
}
}
}
terminate_progress_report(&progress);
printf("Outputting volume.\n");
output_volume(outfile, MI_ORIGINAL_TYPE, TRUE, 0.0, 0.0, new_grid, arg_string, NULL);
return(0);
}
int
main(int argc, char *argv[])
{
char **av ;
int ac, nargs ;
MRI *mri=NULL ;
char *xform_fname=NULL, *in_fname=NULL, *out_fname=NULL ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_add_xform_to_header.c,v 1.12 2011/03/02 00:04:13 nicks Exp $",
"$Name: $");
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 1)
{
usage_exit();
}
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 2)
{
ErrorExit(ERROR_BADPARM, "%s: no transform name specified", Progname) ;
}
xform_fname = argv[1] ;
if (argc < 3)
{
ErrorExit(ERROR_BADPARM, "%s: no input name specified", Progname) ;
}
in_fname = argv[2] ;
if (argc < 4)
{
out_fname = in_fname ;
}
else
{
out_fname = argv[3] ;
}
if (verbose)
{
fprintf(stderr, "reading from %s...", in_fname) ;
}
// we have two cases, in_fname is just a directory name or .mgz
if (fio_IsDirectory(in_fname))
{
mri = MRIreadInfo(in_fname) ; // must be old COR volume
}
else if (fio_FileExistsReadable(in_fname))
{
char *ext = fio_extension(in_fname);
if (ext==0)
{
ErrorExit(ERROR_BADPARM, "%s: no extension found", Progname) ;
}
printf("INFO: extension is %s\n", ext);
if (strcmp(ext, "mgz")==0 || strcmp(ext, "mgh")==0)
{
mri = MRIread(in_fname); // mgh or mgz
}
else
{
ErrorExit(ERROR_BADPARM,
"%s: currently only .mgz or .mgh saves transform name",
Progname) ;
}
}
if (!mri)
ErrorExit(ERROR_NO_FILE, "%s: could not open source file %s",
Progname, in_fname) ;
if (! CopyNameOnly)
{
// why do we need to load the transform at this time
// mri is removed anyway???? -- good point, added -s for noload
if (input_transform_file(xform_fname, &mri->transform) != OK)
ErrorPrintf(ERROR_NO_MEMORY,
"%s: could not read xform file '%s'\n",
Progname, xform_fname);
// my guess is just to verify the validity of the transform?
mri->linear_transform = get_linear_transform_ptr(&mri->transform) ;
mri->inverse_linear_transform =
get_inverse_linear_transform_ptr(&mri->transform) ;
mri->free_transform = 1 ;
}
strcpy(mri->transform_fname, xform_fname) ;
if (verbose)
{
fprintf(stderr, "done.\nwriting to %s...", out_fname) ;
}
// this writes COR-.info only
if (fio_IsDirectory(out_fname))
{
MRIwriteInfo(mri, out_fname) ;
}
else
{
MRIwrite(mri, out_fname); // currently only mgh format write xform info
}
if (verbose)
{
fprintf(stderr, "done.\n") ;
}
MRIfree(&mri) ;
exit(0) ;
return(0) ;
}
int main(int argc, char *argv[])
{
VIO_General_transform
transform,
*grid_transform_ptr,
forward_transform;
VIO_Volume
target_vol,
volume;
volume_input_struct
input_info;
VIO_Real
voxel[VIO_MAX_DIMENSIONS],
steps[VIO_MAX_DIMENSIONS],
start[VIO_N_DIMENSIONS],
target_steps[VIO_MAX_DIMENSIONS],
wx,wy,wz, inv_x, inv_y, inv_z,
def_values[VIO_MAX_DIMENSIONS];
static int
clobber_flag = FALSE,
verbose = TRUE,
debug = FALSE;
static char
*target_file;
int
parse_flag,
prog_count,
sizes[VIO_MAX_DIMENSIONS],
target_sizes[VIO_MAX_DIMENSIONS],
xyzv[VIO_MAX_DIMENSIONS],
target_xyzv[VIO_MAX_DIMENSIONS],
index[VIO_MAX_DIMENSIONS],
i,
trans_count;
VIO_progress_struct
progress;
static ArgvInfo argTable[] = {
{"-like", ARGV_STRING, (char *) 0, (char *) &target_file,
"Specify target volume sampling information."},
{"-no_clobber", ARGV_CONSTANT, (char *) FALSE, (char *) &clobber_flag,
"Do not overwrite output file (default)."},
{"-clobber", ARGV_CONSTANT, (char *) TRUE, (char *) &clobber_flag,
"Overwrite output file."},
{"-verbose", ARGV_CONSTANT, (char *) TRUE, (char *) &verbose,
"Write messages indicating progress (default)"},
{"-quiet", ARGV_CONSTANT, (char *) FALSE, (char *) &verbose,
"Do not write log messages"},
{"-debug", ARGV_CONSTANT, (char *) TRUE, (char *) &debug,
"Print out debug info."},
{NULL, ARGV_END, NULL, NULL, NULL}
};
prog_name = argv[0];
target_file = malloc(1024);
strcpy(target_file,"");
/* Call ParseArgv to interpret all command line args (returns TRUE if error) */
parse_flag = ParseArgv(&argc, argv, argTable, 0);
/* Check remaining arguments */
if (parse_flag || argc != 3) print_usage_and_exit(prog_name);
/* Read in file that has a def field to invert */
if (input_transform_file(argv[1], &transform) != OK) {
(void) fprintf(stderr, "%s: Error reading transform file %s\n",
argv[0], argv[1]);
exit(EXIT_FAILURE);
}
for(trans_count=0; trans_count<get_n_concated_transforms(&transform); trans_count++ ) {
grid_transform_ptr = get_nth_general_transform(&transform, trans_count );
if (grid_transform_ptr->type == GRID_TRANSFORM) {
copy_general_transform(grid_transform_ptr,
&forward_transform);
/*
this is the call that should be made
with the latest version of internal_libvolume_io
invert_general_transform(&forward_transform); */
forward_transform.inverse_flag = !(forward_transform.inverse_flag);
volume = grid_transform_ptr->displacement_volume;
if (strlen(target_file)!=0) {
if (debug) print ("Def field will be resampled like %s\n",target_file);
if (!file_exists( target_file ) ) {
(void) fprintf(stderr, "%s: Target file '%s' does not exist\n",
prog_name,target_file);
exit(EXIT_FAILURE);
}
start_volume_input(target_file, 3, (char **)NULL,
NC_UNSPECIFIED, FALSE, 0.0, 0.0,
TRUE, &target_vol,
(minc_input_options *)NULL,
&input_info);
get_volume_XYZV_indices(volume, xyzv);
get_volume_separations (volume, steps);
get_volume_sizes (volume, sizes);
get_volume_XYZV_indices(target_vol, target_xyzv);
get_volume_separations (target_vol, target_steps);
get_volume_sizes (target_vol, target_sizes);
for(i=0; i<VIO_MAX_DIMENSIONS; i++) {
index[i] = 0;
voxel[i] = 0.0;
}
convert_voxel_to_world(target_vol, voxel, &start[VIO_X], &start[VIO_Y], &start[VIO_Z]);
if( volume != (void *) NULL ){
free_volume_data( volume );
}
for(i=VIO_X; i<=VIO_Z; i++) {
steps[ xyzv[i] ] = target_steps[ target_xyzv[i] ] ;
sizes[ xyzv[i] ] = target_sizes[ target_xyzv[i] ] ;
}
set_volume_separations(volume, steps);
set_volume_sizes( volume, sizes);
set_volume_starts(volume, start);
alloc_volume_data( volume );
}
get_volume_sizes(volume, sizes);
get_volume_XYZV_indices(volume,xyzv);
for(i=0; i<VIO_MAX_DIMENSIONS; i++){
index[i] = 0;
}
if (verbose){
initialize_progress_report(&progress, FALSE,
sizes[xyzv[VIO_X]]*sizes[xyzv[VIO_Y]]*sizes[xyzv[VIO_Z]]+1,
"Inverting def field");
}
prog_count = 0;
for(index[xyzv[VIO_X]]=0; index[xyzv[VIO_X]]<sizes[xyzv[VIO_X]]; index[xyzv[VIO_X]]++)
for(index[xyzv[VIO_Y]]=0; index[xyzv[VIO_Y]]<sizes[xyzv[VIO_Y]]; index[xyzv[VIO_Y]]++)
for(index[xyzv[VIO_Z]]=0; index[xyzv[VIO_Z]]<sizes[xyzv[VIO_Z]]; index[xyzv[VIO_Z]]++) {
index[ xyzv[VIO_Z+1] ] = 0;
for(i=0; i<VIO_MAX_DIMENSIONS; i++) voxel[i] = (VIO_Real)index[i];
convert_voxel_to_world(volume, voxel, &wx, &wy, &wz);
if (sizes[ xyzv[VIO_Z] ] ==1)
general_inverse_transform_point_in_trans_plane(&forward_transform,
wx, wy, wz,
&inv_x, &inv_y, &inv_z);
else
grid_inverse_transform_point(&forward_transform,
wx, wy, wz,
&inv_x, &inv_y, &inv_z);
def_values[VIO_X] = inv_x - wx;
def_values[VIO_Y] = inv_y - wy;
def_values[VIO_Z] = inv_z - wz;
for(index[xyzv[VIO_Z+1]]=0; index[xyzv[VIO_Z+1]]<3; index[xyzv[VIO_Z+1]]++)
set_volume_real_value(volume,
index[0],index[1],index[2],index[3],index[4],
def_values[ index[ xyzv[VIO_Z+1] ]]);
prog_count++;
if (verbose)
update_progress_report(&progress, prog_count);
}
if (verbose)
terminate_progress_report(&progress);
delete_general_transform(&forward_transform);
grid_transform_ptr->inverse_flag = !(grid_transform_ptr->inverse_flag);
}
}
/* Write out the transform */
if (output_transform_file(argv[2], NULL, &transform) != OK) {
(void) fprintf(stderr, "%s: Error writing transform file %s\n",
argv[0], argv[2]);
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
int main( int ac, char* av[] )
{
VIO_General_transform xfm;
FILE *in;
int line=1;
if ( ac != 4 ) {
fprintf( stderr, "usage: %s transform.xfm control_table.txt tolerance\n", av[0] );
return 1;
}
if ( input_transform_file( av[1], &xfm ) != VIO_OK ) {
fprintf( stderr, "Failed to load transform '%s'\n", av[1] );
return 2;
}
tolerance = atof( av[3] );
if(!(in=fopen(av[2],"r")))
{
fprintf( stderr, "Failed to load table '%s'\n", av[2] );
return 2;
}
/*Set the same seed number*/
while (!feof(in)) {
VIO_Real x,y,z;
VIO_Real tx,ty,tz;
VIO_Real ttx,tty,ttz;
VIO_Real a,b,c;
VIO_Real ta,tb,tc;
int check=1;
char line_c[1024];
check=fscanf(in,"%lg,%lg,%lg,%lg,%lg,%lg,%lg,%lg,%lg",&x,&y,&z,&a,&b,&c,&ta,&tb,&tc);
if(check<=0) break;
if(check!=3 && check!=9)
{
fprintf( stderr,"Unexpected input file format at line %d , read %d values!\n",line,check);
return 3;
}
if(general_transform_point( &xfm, x,y,z, &tx,&ty,&tz ) != VIO_OK)
{
fprintf( stderr, "Failed to transform point %f,%f,%f \n", x,y,z );
return 3;
}
if(general_inverse_transform_point( &xfm, x,y,z, &ttx,&tty,&ttz ) != VIO_OK)
{
fprintf( stderr, "Failed to invert transform point %f,%f,%f \n", tx,ty,tz );
return 3;
}
if(check==3)
{
fprintf( stdout,"%.20lg,%.20lg,%.20lg,%.20lg,%.20lg,%.20lg,%.20lg,%.20lg,%.20lg\n",x,y,z,tx,ty,tz,ttx,tty,ttz);
} else {
sprintf(line_c,"Line:%d Fwd ",line);
assert_equal_point( tx,ty,tz, a,b,c, line_c );
sprintf(line_c,"Line:%d Inv ",line);
assert_equal_point( ttx,tty,ttz, ta,tb,tc, line_c );
}
line++;
fgetc(in);
}
fclose(in);
delete_general_transform(&xfm);
return 0;
}
