int main(int argc, char *argv[]) {
char **av;
char *fslfn, *ltafn;
MRI *mri_src, *mri_tgt;
int ac, nargs;
LTA *mylta = 0;
FILE *fo;
VOL_GEOM srcG, dstG;
MATRIX *invTgt, *Dsrc, *V_to_V;
Progname = argv[0];
nargs = handle_version_option (argc, argv, "$Id: mri_fslmat_to_lta.c,v 1.3 2011/03/02 00:04:15 nicks Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc != 5)
usage(1);
printf("Read source volume file %s\n", argv[1]);
mri_src = MRIread(argv[1]) ;
if (!mri_src)
ErrorExit(ERROR_BADPARM, "%s: could not read source volume %s",
Progname, argv[1]) ;
printf("Read destination volume file %s\n", argv[2]);
mri_tgt = MRIread(argv[2]) ;
if (!mri_tgt)
ErrorExit(ERROR_BADPARM, "%s: could not read label volume %s",
Progname, argv[2]) ;
fslfn = argv[3];
ltafn = argv[4];
printf("Read fsl transformation from file %s\n", fslfn);
mylta = ltaFSLread(fslfn);
getVolGeom(mri_src, &srcG);
getVolGeom(mri_tgt, &dstG);
if (invert_flag) {
mylta->xforms[0].src = dstG;
mylta->xforms[0].dst = srcG;
} else {
mylta->xforms[0].src = srcG;
mylta->xforms[0].dst = dstG;
}
invTgt = MatrixAlloc(4,4,MATRIX_REAL);
invTgt->rptr[1][1] = 1.0/dstG.xsize;
invTgt->rptr[2][2] = 1.0/dstG.ysize;
invTgt->rptr[3][3] = 1.0/dstG.zsize;
invTgt->rptr[4][4] = 1.0;
Dsrc = MatrixAlloc(4,4,MATRIX_REAL);
Dsrc->rptr[1][1] = srcG.xsize;
Dsrc->rptr[2][2] = srcG.ysize;
Dsrc->rptr[3][3] = srcG.zsize;
Dsrc->rptr[4][4] = 1.0;
V_to_V = MatrixMultiply(invTgt, mylta->xforms[0].m_L, NULL);
V_to_V = MatrixMultiply(V_to_V, Dsrc, V_to_V);
if (invert_flag) {
mylta->xforms[0].m_L = MatrixInverse(V_to_V, mylta->xforms[0].m_L);
} else {
mylta->xforms[0].m_L = MatrixCopy(V_to_V, mylta->xforms[0].m_L);
}
if (!mylta) {
MRIfree(&mri_src);
MRIfree(&mri_tgt);
ErrorExit(ERROR_BADFILE, "%s: can't read in transformation",Progname);
}
printf("Write transformation to lta file %s\n", ltafn);
fo = fopen(ltafn,"w");
if (fo==NULL)
ErrorExit(ERROR_BADFILE, "%s: can't create file %s",Progname, ltafn);
LTAprint(fo, mylta);
fclose(fo);
MRIfree(&mri_src);
MRIfree(&mri_tgt);
LTAfree(&mylta);
MatrixFree(&invTgt);
MatrixFree(&Dsrc);
MatrixFree(&V_to_V);
return(0);
} /* end main() */
int
main(int argc, char *argv[])
{
char **av, *in_vol, *out_vol;
int ac, nargs;
MRI *mri_in, *mri_out, *mri_tmp ;
LTA *lta = 0;
MATRIX *i_to_r_src = 0; /* src geometry of the input LTA */
MATRIX *V_to_V = 0; /* Final voxel-to-voxel transform */
MATRIX *r_to_i_dst = 0; /* dst geometry of the input LTA */
MATRIX *m_tmp = 0;
MATRIX *i_to_r_reg = 0; /* i_to_r of the volume after registration */
MATRIX *r_to_i_out = 0; /* r_to_i of the final output volume */
VOL_GEOM vgm_in;
int x, y, z;
double maxV, minV, value;
// MATRIX *i_to_r, *r_to_i;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_transform_to_COR.c,v 1.8 2011/03/02 00:04:55 nicks Exp $", "$Name: stable5 $");
if (nargs && argc - nargs == 1)
usage_exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
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(0) ;
in_vol = argv[1] ;
out_vol = argv[2] ;
printf("reading volume from %s...\n", in_vol) ;
mri_in = MRIread(in_vol) ;
if (!mri_in)
ErrorExit(ERROR_NOFILE, "%s: could not read MRI volume %s", Progname,
in_vol) ;
/* Convert mri_in to float type */
/* double would be more accurate */
if (mri_in->type != MRI_FLOAT)
{
printf("Input volume type is %d\n", mri_in->type);
printf("Change input volume to float type for convenience and accuracy");
mri_tmp = MRIchangeType(mri_in, MRI_FLOAT, 0, 1.0, 1);
MRIfree(&mri_in);
mri_in = mri_tmp; //swap
}
/* Get input volume geometry, which is needed to compute i_to_r
* and r_to_i of input volume. Note that i_to_r and r_to_i assumed
* a certain prespecified c_r, c_a, c_s
*/
getVolGeom(mri_in, &vgm_in);
maxV = -10000.0;
minV = 10000.0;
for (z=0; z < mri_in->depth; z++)
for (y=0; y< mri_in->height; y++)
for (x=0; x < mri_in->width; x++)
{
if (MRIFvox(mri_in, x, y, z) > maxV )
maxV = MRIFvox(mri_in, x, y,z) ;
if (MRIFvox(mri_in, x, y, z) < minV )
minV = MRIFvox(mri_in, x, y,z) ;
}
printf("Input volume has max = %g, min =%g\n", maxV, minV);
printf("Scale input volume by %g \n", scale);
maxV = -10000.0;
minV = 10000.0;
for (z=0; z < mri_in->depth; z++)
for (y=0; y< mri_in->height; y++)
for (x=0; x < mri_in->width; x++)
{
MRIFvox(mri_in, x, y, z) *= scale;
if (MRIFvox(mri_in, x, y, z) > maxV )
maxV = MRIFvox(mri_in, x, y,z) ;
if (MRIFvox(mri_in, x, y, z) < minV )
minV = MRIFvox(mri_in, x, y,z) ;
}
printf("Input volume after scaling has max = %g, min =%g\n", maxV, minV);
/* Try to compute the Voxel_to_Voxel transform from the input volume
* and the registration target/reference volume!
* If no registration is involved, vox_to_vox is simply identity
*/
/* Things become more complicated when allowing inverse transform */
if (transform_flag)
{
int transform_type;
printf("INFO: Applying transformation from file %s...\n",
transform_fname);
transform_type = TransformFileNameType(transform_fname);
/* Read in LTA transform file name */
if (transform_type == MNI_TRANSFORM_TYPE ||
transform_type == TRANSFORM_ARRAY_TYPE ||
transform_type == REGISTER_DAT ||
transform_type == FSLREG_TYPE
)
{
printf("Reading transform ...\n");
lta = LTAreadEx(transform_fname) ;
if (!lta)
ErrorExit(ERROR_NOFILE, "%s: could not read transform file %s",
Progname, transform_fname) ;
if (transform_type == FSLREG_TYPE)
{
if (lta_src == 0 || lta_dst == 0)
{
fprintf(stderr, "ERROR: fslmat does not have information on the src and dst volumes\n");
fprintf(stderr, "ERROR: you must give options '-src' and '-dst' to specify the src and dst volume infos for the registration\n");
}
LTAmodifySrcDstGeom(lta, lta_src, lta_dst); // add src and dst information
//The following is necessary to interpret FSLMAT correctly!!!
LTAchangeType(lta, LINEAR_VOX_TO_VOX);
}
if (lta->xforms[0].src.valid == 0)
{
if (lta_src == 0)
{
fprintf(stderr, "The transform does not have the valid src volume info.\n");
fprintf(stderr, "Either you give src volume info by option -src or\n");
fprintf(stderr, "make the transform to have the valid src info.\n");
ErrorExit(ERROR_BAD_PARM, "Bailing out...\n");
}
else
{
LTAmodifySrcDstGeom(lta, lta_src, NULL); // add src information
}
}
if (lta->xforms[0].dst.valid == 0)
{
if (lta_dst == 0)
{
fprintf(stderr, "The transform does not have the valid dst volume info.\n");
fprintf(stderr, "Either you give src volume info by option -dst or\n");
fprintf(stderr, "make the transform to have the valid dst info.\n");
fprintf(stderr, "If the dst was average_305, then you can set\n");
fprintf(stderr, "environmental variable USE_AVERAGE305 true\n");
fprintf(stderr, "instead.\n");
ErrorExit(ERROR_BAD_PARM, "Bailing out...\n");
}
else
{
LTAmodifySrcDstGeom(lta, NULL, lta_dst); // add dst information
}
}
// The following procedure aims to apply an LTA computed from COR format to a volume in non-COR format, or vice versa, as long as they share the same RAS
// first change to LINEAR RAS_TO_RAS using old info
if (lta->type != LINEAR_RAS_TO_RAS)
{
LTAchangeType(lta, LINEAR_RAS_TO_RAS);
}
// now possiblly reset the src and dst
if (lta_src != NULL)
{
//always trust the user
LTAmodifySrcDstGeom(lta, lta_src, NULL);
}
if (lta_dst != NULL)
{
//always trust the user
LTAmodifySrcDstGeom(lta, NULL, lta_dst);
}
if (lta->type == LINEAR_RAS_TO_RAS)
{
/* Convert it to VOX_TO_VOX */
/* VOXELsrc_to_VOXELdst = R2Vdst*R2Rlta*V2Rsrc */
/* Note whether the input should be identical to src or dst here depends
* on whether the LTA here is the direct or inverse transform
*/
i_to_r_src = vg_i_to_r(<a->xforms[0].src);
r_to_i_dst = vg_r_to_i(<a->xforms[0].dst);
if (!r_to_i_dst || !i_to_r_src)
ErrorExit(ERROR_BADFILE, "%s: failed to extract volume geometries from input LTA file",Progname);
m_tmp = MatrixMultiply(lta->xforms[0].m_L, i_to_r_src, NULL);
V_to_V = MatrixMultiply(r_to_i_dst, m_tmp, NULL);
MatrixFree(&m_tmp);
MatrixFree(&i_to_r_src);
MatrixFree(&r_to_i_dst);
}
}
else
{
fprintf(stderr, "unknown transform type in file %s\n",
transform_fname);
exit(1);
}
if (invert_flag)
{
/* Geometry of input volume should match that of the dst of the LTA */
if (MYvg_isEqual(<a->xforms[0].dst, &vgm_in) == 0)
{
ErrorExit(ERROR_BADFILE, "%s: dst volume of lta doesn't match that of input volume",Progname);
}
i_to_r_reg = vg_i_to_r(<a->xforms[0].src);
if (!i_to_r_reg)
ErrorExit(ERROR_BADFILE, "%s: failed to extract i_to_r of registered volume from LTA",Progname);
m_tmp = MatrixInverse(V_to_V, NULL);
if (!m_tmp)
ErrorExit(ERROR_BADPARM, "%s: transform is singular!", Progname);
MatrixFree(&V_to_V);
V_to_V = m_tmp;
}
else
{
/* Geometry of input volume should match that of the src of the LTA */
if (MYvg_isEqual(<a->xforms[0].src, &vgm_in) == 0)
{
ErrorExit(ERROR_BADFILE, "%s: src volume of lta doesn't match that of input volume",Progname);
}
i_to_r_reg = vg_i_to_r(<a->xforms[0].dst);
if (!i_to_r_reg)
ErrorExit(ERROR_BADFILE, "%s: failed to extract i_to_r of registered volume from LTA",Progname);
}
}
else
{
/* No registration transform need be applied */
V_to_V = MatrixIdentity(4, NULL);
i_to_r_reg = extract_i_to_r(mri_in);
if (!i_to_r_reg)
ErrorExit(ERROR_BADFILE, "%s: failed to extract i_to_r from input volume",Progname);
}
/* Now need to find the vox-to-vox transformation between registered volume
* (or input volume itself if no registration involved) and the output
* volume, either in COR format or as the out-like volume
*/
/* Given a volume with a certain i_to_r, we need to compute the necessary
* vox-to-voxel transform to change its i_to_r to like another volume.
* The vox-to-vox is equal to R2V(r_to_i)_likevol*i_to_r_current_vol.
*/
if (out_like_fname)
{
mri_tmp = MRIread(out_like_fname) ;
if (!mri_tmp)
ErrorExit(ERROR_NOFILE, "%s: could not read template volume from %s",out_like_fname) ;
/* out_type = mri_tmp->type; */
/* specify the out-type to float initially so as not to lose accuracy
* during reslicing, will change type to correct type later.
*/
mri_out = MRIalloc(mri_tmp->width, mri_tmp->height, mri_tmp->depth, MRI_FLOAT) ;
MRIcopyHeader(mri_tmp, mri_out) ;
MRIfree(&mri_tmp);
}
else /* assume output is in COR format */
{
mri_out = MRIalloc(256, 256, 256, MRI_FLOAT) ;
/* out_type = MRI_UCHAR; */
/* Who says MRIlinearTransformInterp will change the header??
* I don't think so!
*/
//E/ set xyzc_ras to coronal ones.. - these'll get zorched
//by MRIlinearTransformInterp() - copy again later - is there
//any use in having them here now? yes, so we can pass mri_out
//to the ras2vox fns.
mri_out->imnr0 = 1; /* what's this? */
mri_out->imnr1 = 256; /* what's this? */
mri_out->thick = 1.0;
mri_out->ps = 1.0; /* what's this? */
mri_out->xsize = mri_out->ysize = mri_out->zsize = 1.0;
mri_out->xstart = mri_out->ystart = mri_out->zstart = -128.0;
mri_out->xend = mri_out->yend = mri_out->zend = 128.0;
mri_out->x_r =-1;
mri_out->y_r = 0;
mri_out->z_r = 0;
mri_out->x_a = 0;
mri_out->y_a = 0;
mri_out->z_a = 1;
mri_out->x_s = 0;
mri_out->y_s =-1;
mri_out->z_s = 0;
/* In this case, the RAS itself is not fully determined, i.e., c_ras.
* It's quite arbitrary, different values just change the final
* sitting of the volume inside the RAS system.
*/
/* NO! The C_RAS has to be set correctly, depending which target
* volume the previous Vox_to_Vox transformation assumes!
* When a registration is involved, the target volume is either
* the src of LTA (direct) or the dst (inverse transform). When
* just change format, the target volume is the input itself!!
*/
if (transform_flag)
{
if (invert_flag)
{
mri_out->c_r = lta->xforms[0].src.c_r;
mri_out->c_a = lta->xforms[0].src.c_a;
mri_out->c_s = lta->xforms[0].src.c_s;
}
else
{
mri_out->c_r = lta->xforms[0].dst.c_r;
mri_out->c_a = lta->xforms[0].dst.c_a;
mri_out->c_s = lta->xforms[0].dst.c_s;
}
}
else
{
mri_out->c_r = mri_in->c_r;
mri_out->c_a = mri_in->c_a;
mri_out->c_s = mri_in->c_s;
}
mri_out->ras_good_flag=1; /* What does this flag mean ? */
/* since output is just transformed input */
MRIcopyPulseParameters(mri_in, mri_out) ;
}
/* Compute the final input-to-output VOX_to_VOX transformation matrix */
r_to_i_out = extract_r_to_i(mri_out);
m_tmp = MatrixMultiply(r_to_i_out, i_to_r_reg, NULL);
V_to_V = MatrixMultiply(m_tmp, V_to_V, V_to_V);
MatrixFree(&m_tmp);
printf("InterpMethod = %d\n", InterpMethod);
/* Modify the MyMRIlinearTr... if I want to implement my cubic-B-spline
* interpolation method. Otherwise, unnecessary
*/
/* mri_out = MyMRIlinearTransformInterp(mri_in, mri_out, V_to_V, InterpMethod); */
if (InterpMethod == SAMPLE_BSPLINE)
mri_out = MRIlinearTransformInterpBSpline(mri_in, mri_out, V_to_V,
SplineDegree);
else
mri_out = MRIlinearTransformInterp(mri_in, mri_out, V_to_V, InterpMethod);
maxV = -10000.0;
minV = 10000.0;
for (z=0; z < mri_out->depth; z++)
for (y=0; y< mri_out->height; y++)
for (x=0; x < mri_out->width; x++)
{
if (MRIFvox(mri_out, x, y, z) > maxV )
maxV = MRIFvox(mri_out, x, y,z) ;
if (MRIFvox(mri_out, x, y, z) < minV )
minV = MRIFvox(mri_out, x, y,z) ;
}
if (autoscale)
{
noscale = 1;
/* compute histogram of output volume */
HISTOGRAM *h, *hsmooth ;
float fmin, fmax, val, peak, smooth_peak;
int i, nbins, bin;
fmin = minV;
fmax = maxV;
if (fmin < 0) fmin = 0;
nbins = 256 ;
h = HISTOalloc(nbins) ;
hsmooth = HISTOcopy(h, NULL) ;
HISTOclear(h, h) ;
h->bin_size = (fmax-fmin)/255.0 ;
for (i = 0 ; i < nbins ; i++)
h->bins[i] = (i+1)*h->bin_size ;
for (z=0; z < mri_out->depth; z++)
for (y=0; y< mri_out->height; y++)
for (x=0; x < mri_out->width; x++)
{
val = MRIFvox(mri_out, x, y, z);
if (val <= 0) continue;
bin = nint((val - fmin)/h->bin_size);
if (bin >= h->nbins)
bin = h->nbins-1;
else if (bin < 0)
bin = 0;
h->counts[bin] += 1.0;
}
HISTOfillHoles(h) ;
HISTOsmooth(h, hsmooth, 5) ;
peak =
hsmooth->bins[HISTOfindHighestPeakInRegion(h, 1, h->nbins)] ;
// smooth_peak =
// hsmooth->bins[HISTOfindHighestPeakInRegion(hsmooth, 1, hsmooth->nbins)] ;
smooth_peak =
hsmooth->bins[HISTOfindLastPeak(hsmooth, 5, 0.8)] ;
/*
bin = nint((smooth_peak - fmin)/hsmooth->bin_size) ;
printf("Highest peak has count = %d\n", (int)hsmooth->counts[bin]);
bin = nint((420 - fmin)/hsmooth->bin_size) ;
printf("bin at 420 has count = %d\n", (int)hsmooth->counts[bin]);
*/
scale = 110.0/smooth_peak;
printf("peak of output volume is %g, smooth-peak is %g, multiply by %g to scale it to 110\n", peak, smooth_peak, scale);
for (z=0; z < mri_out->depth; z++)
for (y=0; y< mri_out->height; y++)
for (x=0; x < mri_out->width; x++)
{
val = MRIFvox(mri_out, x, y, z);
MRIFvox(mri_out, x, y, z) = val*scale;
}
}
printf("Output volume (before type-conversion) has max = %g, min =%g\n", maxV, minV);
/* Finally change type to desired */
if (mri_out->type != out_type)
{
printf("Change output volume to type %d\n", out_type);
/* I need to modify the MIRchangeType function to make sure
* it does roundoff instead of simple truncation!
*/
/* Note if the last flag is set to 1, then it won't do scaling
and small float numbers will become zero after convert to
BYTE
*/
if (out_type == 0 && noscale == 1)
{
//convert data to UCHAR
mri_tmp = MRIalloc(mri_out->width, mri_out->height, mri_out->depth, out_type) ;
MRIcopyHeader(mri_out, mri_tmp);
for (z=0; z < mri_out->depth; z++)
for (y=0; y< mri_out->height; y++)
for (x=0; x < mri_out->width; x++)
{
value = floor(MRIgetVoxVal(mri_out, x, y, z, 0) + 0.5);
if (value < 0 ) value = 0;
if (value > 255) value = 255;
MRIvox(mri_tmp,x,y,z) = (unsigned char)value;
}
}
else
mri_tmp = MRIchangeType(mri_out, out_type, thred_low, thred_high, noscale);
MRIfree(&mri_out);
mri_out = mri_tmp; //swap
}
MRIwrite(mri_out, out_vol) ;
MRIfree(&mri_in);
MRIfree(&mri_out);
if (lta_src)
MRIfree(<a_src);
if (lta_dst)
MRIfree(<a_dst);
MatrixFree(&V_to_V);
if (!r_to_i_out)
MatrixFree(&r_to_i_out);
if (!i_to_r_reg)
MatrixFree(&i_to_r_reg);
return(0) ; /* for ansi */
}
int
main(int argc, char *argv[]) {
char *ref_fname, *in_fname, *out_fname, fname[STRLEN], **av ;
MRI *mri_ref, *mri_in, *mri_orig, *mri_in_red, *mri_ref_red,
*mri_in_tmp, *mri_ref_tmp, *mri_ref_orig, *mri_in_orig ;
int ac, nargs, i, msec, minutes, seconds ;
struct timeb start ;
MATRIX *m_L ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_linear_register.c,v 1.13 2011/03/02 00:04:22 nicks Exp $", "$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
parms.mri_crop = NULL ;
parms.l_intensity = 1.0f ;
parms.niterations = 100 ;
parms.levels = -1 ; /* use default */
parms.dt = 1e-6 ; /* was 5e-6 */
parms.tol = INTEGRATION_TOL*5 ;
parms.dt = 5e-6 ; /* was 5e-6 */
parms.tol = 1e-3 ;
parms.momentum = 0.8 ;
parms.max_levels = MAX_LEVELS ;
parms.factor = 1.0 ;
parms.niterations = 25 ;
Progname = argv[0] ;
DiagInit(NULL, NULL, NULL) ;
ErrorInit(NULL, NULL, NULL) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 4)
ErrorExit(ERROR_BADPARM,
"usage: %s <in brain> <template> <output file name>\n",
Progname) ;
in_fname = argv[1] ;
ref_fname = argv[2] ;
if (xform_mean_fname) {
int sno, nsubjects ;
FILE *fp ;
parms.m_xform_mean = MatrixAsciiRead(xform_mean_fname, NULL) ;
if (!parms.m_xform_mean)
ErrorExit(Gerror, "%s: could not read parameter means from %s",
Progname, xform_mean_fname) ;
fp = fopen(xform_covariance_fname, "r") ;
if (!fp)
ErrorExit(ERROR_NOFILE, "%s: could not read covariances from %s",
Progname, xform_covariance_fname) ;
fscanf(fp, "nsubjects=%d", &nsubjects) ;
printf("reading %d transforms...\n", nsubjects) ;
parms.m_xforms = (MATRIX **)calloc(nsubjects, sizeof(MATRIX *)) ;
if (!parms.m_xforms)
ErrorExit(ERROR_NOMEMORY, "%s: could not allocate array of %d xforms",
Progname, nsubjects) ;
for (sno = 0 ; sno < nsubjects ; sno++) {
parms.m_xforms[sno] = MatrixAsciiReadFrom(fp, NULL) ;
if (!parms.m_xforms[sno])
ErrorExit(ERROR_NOMEMORY, "%s: could not allocate %dth xform",
Progname, sno) ;
}
parms.m_xform_covariance = MatrixAsciiReadFrom(fp, NULL) ;
if (!parms.m_xform_covariance)
ErrorExit(Gerror, "%s: could not read parameter covariance from %s",
Progname, xform_covariance_fname) ;
fclose(fp) ;
parms.l_priors = l_priors ;
parms.nxforms = nsubjects ;
}
out_fname = argv[3] ;
FileNameOnly(out_fname, fname) ;
FileNameRemoveExtension(fname, fname) ;
strcpy(parms.base_name, fname) ;
fprintf(stderr, "logging results to %s.log\n", parms.base_name) ;
TimerStart(&start) ;
fprintf(stderr, "reading '%s'...\n", ref_fname) ;
fflush(stderr) ;
mri_ref = MRIread(ref_fname) ;
if (!mri_ref)
ErrorExit(ERROR_NOFILE, "%s: could not open reference volume %s.\n",
Progname, ref_fname) ;
if (mri_ref->type != MRI_UCHAR) {
MRI *mri_tmp ;
mri_tmp = MRIchangeType(mri_ref, MRI_UCHAR, 0.0, 0.999, FALSE) ;
MRIfree(&mri_ref) ;
mri_ref = mri_tmp ;
}
if (var_fname) /* read in a volume of standard deviations */
{
MRI *mri_var, *mri_tmp ;
fprintf(stderr, "reading '%s'...\n", var_fname) ;
mri_var = MRIread(var_fname) ;
if (!mri_var)
ErrorExit(ERROR_NOFILE, "%s: could not open variance volume %s.\n",
Progname, var_fname) ;
mri_tmp = MRIconcatenateFrames(mri_ref, mri_var, NULL) ;
MRIfree(&mri_var) ;
MRIfree(&mri_ref) ;
mri_ref = mri_tmp ;
}
fprintf(stderr, "reading '%s'...\n", in_fname) ;
fflush(stderr) ;
mri_orig = mri_in = MRIread(in_fname) ;
if (!mri_in)
ErrorExit(ERROR_NOFILE, "%s: could not open input volume %s.\n",
Progname, in_fname) ;
if (mri_in->type != MRI_UCHAR) {
MRI *mri_tmp ;
mri_orig = mri_tmp = MRIchangeType(mri_in, MRI_UCHAR, 0.0, 0.999, FALSE) ;
MRIfree(&mri_in) ;
mri_in = mri_tmp ;
}
/* make sure they are the same size */
if (mri_in->width != mri_ref->width ||
mri_in->height != mri_ref->height ||
mri_in->depth != mri_ref->depth) {
int width, height, depth ;
MRI *mri_tmp ;
width = MAX(mri_in->width, mri_ref->width) ;
height = MAX(mri_in->height, mri_ref->height) ;
depth = MAX(mri_in->depth, mri_ref->depth) ;
mri_tmp = MRIalloc(width, height, depth, MRI_UCHAR) ;
MRIextractInto(mri_in, mri_tmp, 0, 0, 0,
mri_in->width, mri_in->height, mri_in->depth, 0, 0, 0) ;
#if 0
MRIfree(&mri_in) ;
#else
parms.mri_in = mri_in ;
#endif
mri_in = mri_orig = mri_tmp ;
mri_tmp = MRIallocSequence(width, height,depth,MRI_UCHAR,mri_ref->nframes);
MRIextractInto(mri_ref, mri_tmp, 0, 0, 0,
mri_ref->width, mri_ref->height, mri_ref->depth, 0, 0, 0) ;
#if 0
MRIfree(&mri_ref) ;
#else
parms.mri_in = mri_in ;
#endif
mri_ref = mri_tmp ;
}
if (!FZERO(tx) || !FZERO(ty) || !FZERO(tz)) {
MRI *mri_tmp ;
fprintf(stderr, "translating second volume by (%2.1f, %2.1f, %2.1f)\n",
tx, ty, tz) ;
mri_tmp = MRItranslate(mri_in, NULL, tx, ty, tz) ;
MRIfree(&mri_in) ;
mri_in = mri_tmp ;
}
if (!FZERO(rzrot)) {
MRI *mri_tmp ;
fprintf(stderr,
"rotating second volume by %2.1f degrees around Z axis\n",
(float)DEGREES(rzrot)) ;
mri_tmp = MRIrotateZ_I(mri_in, NULL, rzrot) ;
MRIfree(&mri_in) ;
mri_in = mri_tmp ;
}
if (!FZERO(rxrot)) {
MRI *mri_tmp ;
fprintf(stderr,
"rotating second volume by %2.1f degrees around X axis\n",
(float)DEGREES(rxrot)) ;
mri_tmp = MRIrotateX_I(mri_in, NULL, rxrot) ;
MRIfree(&mri_in) ;
mri_in = mri_tmp ;
}
if (!FZERO(ryrot)) {
MRI *mri_tmp ;
fprintf(stderr,
"rotating second volume by %2.1f degrees around Y axis\n",
(float)DEGREES(ryrot)) ;
mri_tmp = MRIrotateY_I(mri_in, NULL, ryrot) ;
MRIfree(&mri_in) ;
mri_in = mri_tmp ;
}
if (!transform_loaded) /* wasn't preloaded */
parms.lta = LTAalloc(1, mri_in) ;
if (!FZERO(blur_sigma)) {
MRI *mri_kernel, *mri_tmp ;
mri_kernel = MRIgaussian1d(blur_sigma, 100) ;
mri_tmp = MRIconvolveGaussian(mri_in, NULL, mri_kernel) ;
mri_in = mri_tmp ;
MRIfree(&mri_kernel) ;
}
MRIscaleMeanIntensities(mri_in, mri_ref, mri_in);
mri_ref_orig = mri_ref ;
mri_in_orig = mri_in ;
if (nreductions > 0) {
mri_in_red = mri_in_tmp = MRIcopy(mri_in, NULL) ;
mri_ref_red = mri_ref_tmp = MRIcopy(mri_ref, NULL) ;
for (i = 0 ; i < nreductions ; i++) {
mri_in_red = MRIreduceByte(mri_in_tmp, NULL) ;
mri_ref_red = MRIreduceMeanAndStdByte(mri_ref_tmp,NULL);
MRIfree(&mri_in_tmp);
MRIfree(&mri_ref_tmp) ;
mri_in_tmp = mri_in_red ;
mri_ref_tmp = mri_ref_red ;
}
mri_in = mri_in_red ;
mri_ref = mri_ref_red ;
}
/* for diagnostics */
if (full_res) {
parms.mri_ref = mri_ref ;
parms.mri_in = mri_in ;
} else {
parms.mri_ref = mri_ref_orig ;
parms.mri_in = mri_in_orig ;
}
m_L = initialize_transform(mri_in, mri_ref, &parms) ;
if (use_gradient) {
MRI *mri_in_mag, *mri_ref_mag, *mri_grad, *mri_mag ;
printf("computing gradient magnitude of input image...\n") ;
mri_mag = MRIalloc(mri_in->width, mri_in->height, mri_in->depth,MRI_FLOAT);
MRIcopyHeader(mri_in, mri_mag) ;
mri_grad = MRIsobel(mri_in, NULL, mri_mag) ;
MRIfree(&mri_grad) ;
/* convert it to ubytes */
MRIvalScale(mri_mag, mri_mag, 0.0f, 255.0f) ;
mri_in_mag = MRIclone(mri_in, NULL) ;
MRIcopy(mri_mag, mri_in_mag) ;
MRIfree(&mri_mag) ;
/* now compute gradient of ref image */
printf("computing gradient magnitude of reference image...\n") ;
mri_mag = MRIalloc(mri_ref->width, mri_ref->height, mri_ref->depth,MRI_FLOAT);
MRIcopyHeader(mri_ref, mri_mag) ;
mri_grad = MRIsobel(mri_ref, NULL, mri_mag) ;
MRIfree(&mri_grad) ;
/* convert it to ubytes */
MRIvalScale(mri_mag, mri_mag, 0.0f, 255.0f) ;
mri_ref_mag = MRIclone(mri_ref, NULL) ;
MRIcopy(mri_mag, mri_ref_mag) ;
MRIfree(&mri_mag) ;
register_mri(mri_in_mag, mri_ref_mag, &parms, m_L) ;
MRIfree(&mri_in_mag) ;
MRIfree(&mri_ref_mag) ;
}
register_mri(mri_in, mri_ref, &parms, m_L) ;
if (check_crop_flag) /* not working yet! */
{
printf("searching for cropped regions in the input image...\n") ;
parms.mri_crop = find_cropping(mri_orig, mri_ref, &parms) ;
MRIwrite(parms.mri_crop, "crop.mgh") ;
register_mri(mri_in, mri_ref, &parms, m_L) ;
}
if (voxel_coords) {
printf("transforming xform to voxel coordinates...\n") ;
MRIrasXformToVoxelXform(mri_in_orig, mri_ref_orig,
parms.lta->xforms[0].m_L,
parms.lta->xforms[0].m_L);
if (Gdiag & DIAG_WRITE) {
MRI *mri_tmp ;
mri_tmp = MRIlinearTransform(mri_in_orig, NULL,parms.lta->xforms[0].m_L);
MRIwriteImageViews(mri_tmp, "morphed", IMAGE_SIZE) ;
MRIfree(&mri_tmp) ;
}
}
// save src and target info in lta
getVolGeom(mri_in_orig, &parms.lta->xforms[0].src);
getVolGeom(mri_ref_orig, &parms.lta->xforms[0].dst);
fprintf(stderr, "writing output transformation to %s...\n", out_fname) ;
if (invert_flag) {
MATRIX *m_tmp ;
m_tmp = MatrixInverse(parms.lta->xforms[0].m_L, NULL) ;
MatrixFree(&parms.lta->xforms[0].m_L) ;
// change src and dst
getVolGeom(mri_in_orig, &parms.lta->xforms[0].dst);
getVolGeom(mri_ref_orig, &parms.lta->xforms[0].src);
parms.lta->xforms[0].m_L = m_tmp ;
}
//
LTAwriteEx(parms.lta, out_fname) ;
//
if (mri_ref)
MRIfree(&mri_ref) ;
if (mri_in)
MRIfree(&mri_in) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
fprintf(stderr, "registration took %d minutes and %d seconds.\n",
minutes, seconds) ;
exit(0) ;
return(0) ;
}
