int
regio_write_surfacexform_to_register_dat(MATRIX *B, char *fname,
MRI_SURFACE *mris, MRI *mri,
char *subject, int float2int)
{
MATRIX *Ta, *Sa, *invTa, *A, *R, *S, *invS, *T, *m1, *m2 ;
MRI *mri_surf = MRIallocHeader(mris->vg.width, mris->vg.height,
mris->vg.depth, MRI_UCHAR,1) ;
MRIcopyVolGeomToMRI(mri_surf, &mris->vg) ;
T = MRIxfmCRS2XYZtkreg(mri) ;
S = MRIgetVoxelToRasXform(mri) ;
invS = MatrixInverse(S, NULL) ;
Ta = MRIxfmCRS2XYZtkreg(mri_surf);
Sa = MRIgetVoxelToRasXform(mri_surf);
invTa = MatrixInverse(Ta,NULL);
A = MatrixMultiply(Sa,invTa, NULL);
m1 = MatrixMultiply(A, B, NULL) ;
m2 = MatrixMultiply(invS, m1, NULL) ;
R = MatrixMultiply(T, m2, NULL) ;
regio_write_register(fname,subject,mri->xsize, mri->zsize,1,R,float2int);
MatrixFree(&A) ; MatrixFree(&Ta) ; MatrixFree(&Sa) ; MatrixFree(&invTa) ;
MatrixFree(&R) ; MatrixFree(&m1) ; MatrixFree(&m2) ; MatrixFree(&S) ;
MatrixFree(&invS);
MatrixFree(&T) ;
MRIfree(&mri_surf) ;
return(NO_ERROR) ;
}
MATRIX *
regio_read_surfacexform_from_register_dat(char *fname, MRI_SURFACE *mris,
MRI *mri, char **subject)
{
MATRIX *Ta, *Sa, *invT, *A, *R, *S, *invSa, *T, *m1, *m2, *B ;
float pres, bres, intensity ;
int float2int ;
MRI *mri_surf = MRIallocHeader(mris->vg.width, mris->vg.height,
mris->vg.depth, MRI_UCHAR,1) ;
if (regio_read_register(fname, subject, &pres, &bres, &intensity,&B,&float2int) != 0)
ErrorReturn(NULL, (ERROR_NOFILE,
"regio_read_surfacexform_from_register_dat(%s) failed",
fname)) ;
MRIcopyVolGeomToMRI(mri_surf, &mris->vg) ;
T = MRIxfmCRS2XYZtkreg(mri) ;
S = MRIgetVoxelToRasXform(mri) ;
Ta = MRIxfmCRS2XYZtkreg(mri_surf);
Sa = MRIgetVoxelToRasXform(mri_surf);
invSa = MatrixInverse(Sa, NULL) ;
invT = MatrixInverse(T,NULL);
A = MatrixMultiply(S,invT, NULL);
m1 = MatrixMultiply(A, B, NULL) ;
m2 = MatrixMultiply(invSa, m1, NULL) ;
R = MatrixMultiply(Ta, m2, NULL) ;
MatrixFree(&A) ; MatrixFree(&Ta) ; MatrixFree(&Sa) ; MatrixFree(&invT) ;
MatrixFree(&B) ; MatrixFree(&m1) ; MatrixFree(&m2) ; MatrixFree(&S) ;
MatrixFree(&invSa);
MatrixFree(&T) ;
MRIfree(&mri_surf) ;
return(R) ;
}
int
main(int argc, char *argv[])
{
char **av, *out_name ;
int ac, nargs ;
int msec, minutes, seconds ;
struct timeb start ;
MRI_SURFACE *mris ;
GCA_MORPH *gcam ;
MRI *mri = NULL ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mris_interpolate_warp.c,v 1.5 2011/10/07 12:07:26 fischl Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
{
exit (0);
}
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 3)
{
usage_exit(1) ;
}
/*
note that a "forward" morph means a retraction, so we reverse the order of the argvs here.
This means that for every voxel in the inflated image we have a vector that points to where in
the original image it came from, and *NOT* the reverse.
*/
mris = MRISread(argv[2]) ;
if (mris == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read source surface %s\n", Progname,argv[2]) ;
MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ;
if (MRISreadVertexPositions(mris, argv[1]) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read target surface %s\n", Progname,argv[1]) ;
if (like_vol_name == NULL)
{
mri = MRIallocSequence(mris->vg.width, mris->vg.height, mris->vg.depth, MRI_FLOAT, 3) ;
MRIcopyVolGeomToMRI(mri, &mris->vg) ;
}
else
{
MRI *mri_tmp ;
mri_tmp = MRIread(like_vol_name) ;
if (mri_tmp == NULL)
{
ErrorExit(ERROR_NOFILE, "%s: could not like volume %s\n", like_vol_name) ;
}
mri = MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth, MRI_FLOAT, 3) ;
MRIcopyHeader(mri_tmp, mri) ;
MRIfree(&mri_tmp) ;
}
if (Gdiag & DIAG_SHOW && DIAG_VERBOSE_ON)
{
double xv, yv, zv ;
VERTEX *v = &mris->vertices[0] ;
MRISsurfaceRASToVoxel(mris, mri, v->x, v->y, v->z, &xv, &yv, &zv) ;
printf("v 0: sras (%f, %f, %f) --> vox (%f, %f, %f)\n", v->x,v->y,v->z,xv,yv,zv);
MRISsurfaceRASToVoxelCached(mris, mri, v->x, v->y, v->z, &xv, &yv, &zv) ;
printf("v 0: sras (%f, %f, %f) --> vox (%f, %f, %f)\n", v->x,v->y,v->z,xv,yv,zv);
DiagBreak() ;
}
{
MRI *mri_tmp ;
mri_tmp = expand_mri_to_fit_surface(mris, mri) ;
MRIfree(&mri) ; mri = mri_tmp ;
}
write_surface_warp_into_volume(mris, mri, niter) ;
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
MRIwrite(mri, "warp.mgz") ;
gcam = GCAMalloc(mri->width, mri->height, mri->depth) ;
GCAMinitVolGeom(gcam, mri, mri) ;
GCAMremoveSingularitiesAndReadWarpFromMRI(gcam, mri) ;
// GCAMreadWarpFromMRI(gcam, mri) ;
// GCAsetVolGeom(gca, &gcam->atlas);
#if 0
gcam->gca = gcaAllocMax(1, 1, 1,
mri->width, mri->height,
mri->depth,
0, 0) ;
GCAMinit(gcam, mri, NULL, NULL, 0) ;
#endif
#if 0
GCAMinvert(gcam, mri) ;
GCAMwriteInverseWarpToMRI(gcam, mri) ;
GCAMremoveSingularitiesAndReadWarpFromMRI(gcam, mri) ; // should be inverse now
#endif
if (mri_in)
{
MRI *mri_warped, *mri_tmp ;
printf("applying warp to %s and writing to %s\n", mri_in->fname, out_fname) ;
mri_tmp = MRIextractRegionAndPad(mri_in, NULL, NULL, pad) ; MRIfree(&mri_in) ; mri_in = mri_tmp ;
mri_warped = GCAMmorphToAtlas(mri_in, gcam, NULL, -1, SAMPLE_TRILINEAR) ;
MRIwrite(mri_warped, out_fname) ;
if (Gdiag_no >= 0)
{
double xi, yi, zi, xo, yo, zo, val;
int xp, yp, zp ;
GCA_MORPH_NODE *gcamn ;
VERTEX *v = &mris->vertices[Gdiag_no] ;
MRISsurfaceRASToVoxelCached(mris, mri, v->origx, v->origy, v->origz, &xi, &yi, &zi) ;
MRISsurfaceRASToVoxelCached(mris, mri, v->x, v->y, v->z, &xo, &yo, &zo) ;
printf("surface vertex %d: inflated (%2.0f, %2.0f, %2.0f), orig (%2.0f, %2.0f, %2.0f)\n", Gdiag_no, xi, yi, zi, xo, yo, zo) ;
MRIsampleVolume(mri_in, xo, yo, zo, &val) ;
xp = nint(xi) ; yp = nint(yi) ; zp = nint(zi) ;
gcamn = &gcam->nodes[xp][yp][zp] ;
printf("warp = (%2.1f, %2.1f, %2.1f), orig (%2.1f %2.1f %2.1f) = %2.1f \n",
gcamn->x, gcamn->y, gcamn->z,
gcamn->origx, gcamn->origy, gcamn->origz,val) ;
DiagBreak() ;
}
}
if (no_write == 0)
{
out_name = argv[3] ;
GCAMwrite(gcam, out_name) ;
}
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
fprintf(stderr, "warp field calculation took %d minutes and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
