csShaderVariable::csShaderVariable (const csShaderVariable& other)
: csRefCount (), nameAndType (other.nameAndType)
{
if (other.accessor)
AllocAccessor (*other.accessor);
else
accessor = 0;
// Handle payload
switch (GetTypeI())
{
case UNKNOWN:
break;
case INT:
Int = other.Int;
break;
case FLOAT:
case VECTOR2:
case VECTOR3:
case VECTOR4:
memcpy (&Vector, &other.Vector, sizeof (Vector));
break;
case TEXTURE:
texture = other.texture;
if (texture.HandValue)
texture.HandValue->IncRef ();
if (texture.WrapValue)
texture.WrapValue->IncRef ();
break;
case RENDERBUFFER:
RenderBuffer = other.RenderBuffer;
if (RenderBuffer)
RenderBuffer->IncRef ();
break;
case MATRIX3X3:
MatrixValuePtr = MatrixAlloc()->Alloc (*other.MatrixValuePtr);
break;
case MATRIX4X4:
Matrix4ValuePtr = Matrix4Alloc()->Alloc ();
break;
case TRANSFORM:
TransformPtr = TransformAlloc()->Alloc (*other.TransformPtr);
break;
case ARRAY:
ShaderVarArray = ShaderVarArrayAlloc()->Alloc ();
*ShaderVarArray = *other.ShaderVarArray;
break;
default:
;
}
}
csShaderVariable::~csShaderVariable ()
{
switch (GetTypeI())
{
case UNKNOWN:
case INT:
case FLOAT:
break; //Nothing to deallocate
case TEXTURE:
if (texture.HandValue)
texture.HandValue->DecRef ();
if (texture.WrapValue)
texture.WrapValue->DecRef ();
break;
case RENDERBUFFER:
if (RenderBuffer)
RenderBuffer->DecRef ();
break;
case VECTOR2:
case VECTOR3:
case VECTOR4:
break; //Nothing to deallocate
case MATRIX3X3:
MatrixAlloc()->Free (MatrixValuePtr);
break;
case MATRIX4X4:
Matrix4Alloc()->Free (Matrix4ValuePtr);
break;
case TRANSFORM:
TransformAlloc()->Free (TransformPtr);
break;
case ARRAY:
ShaderVarArrayAlloc()->Free (ShaderVarArray);
break;
default:
;
}
if (accessor != 0)
{
AccessorValuesAlloc()->Free (accessor);
}
}
double local_GCAcomputeLogSampleProbability( GCA *gca,
GCA_SAMPLE *gcas,
MRI *mri,
MATRIX *m_L,
int nsamples,
int exvivo,
double clamp)
{
static TRANSFORM *transform = NULL ;
if (!transform)
{
transform = TransformAlloc(LINEAR_VOX_TO_VOX, NULL) ;
}
((LTA *)transform->xform)->xforms[0].m_L = m_L ;
if (exvivo)
{
double gm, wm, fluid ;
compute_tissue_modes(mri, gca, gcas, transform, nsamples,
&wm, &gm, &fluid ) ;
return( (SQR(gm - wm) +
SQR(gm-fluid) +
SQR(fluid - wm) +
SQR(gm) -
SQR(fluid))) ;
}
double result;
if (robust)
{
// Defined 0 at the top of the file
result = GCAcomputeNumberOfGoodFittingSamples( gca, gcas, mri,
transform, nsamples );
}
else
{
result = GCAcomputeLogSampleProbability( gca, gcas, mri,
transform, nsamples, clamp );
}
return( result );
}
int
main(int argc, char *argv[])
{
char **av, *source_fname, *target_fname, *out_fname, fname[STRLEN] ;
int ac, nargs, new_transform = 0, pad ;
MRI *mri_target, *mri_source, *mri_orig_source ;
MRI_REGION box ;
struct timeb start ;
int msec, minutes, seconds ;
GCA_MORPH *gcam ;
MATRIX *m_L/*, *m_I*/ ;
LTA *lta ;
/* initialize the morph params */
memset(&mp, 0, sizeof(GCA_MORPH_PARMS));
/* for nonlinear morph */
mp.l_jacobian = 1 ;
mp.min_sigma = 0.4 ;
mp.l_distance = 0 ;
mp.l_log_likelihood = .025 ;
mp.dt = 0.005 ;
mp.noneg = True ;
mp.exp_k = 20 ;
mp.diag_write_snapshots = 1 ;
mp.momentum = 0.9 ;
if (FZERO(mp.l_smoothness))
mp.l_smoothness = 2 ;
mp.sigma = 8 ;
mp.relabel_avgs = -1 ;
mp.navgs = 256 ;
mp.levels = 6 ;
mp.integration_type = GCAM_INTEGRATE_BOTH ;
mp.nsmall = 1 ;
mp.reset_avgs = -1 ;
mp.npasses = 3 ;
mp.regrid = regrid? True : False ;
mp.tol = 0.1 ;
mp.niterations = 1000 ;
TimerStart(&start) ;
setRandomSeed(-1L) ;
DiagInit(NULL, NULL, NULL) ;
ErrorInit(NULL, NULL, NULL) ;
Progname = argv[0] ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 4)
usage_exit(1) ;
source_fname = argv[1] ;
target_fname = argv[2] ;
out_fname = argv[3] ;
FileNameOnly(out_fname, fname) ;
FileNameRemoveExtension(fname, fname) ;
strcpy(mp.base_name, fname) ;
mri_source = MRIread(source_fname) ;
if (!mri_source)
ErrorExit(ERROR_NOFILE, "%s: could not read source label volume %s",
Progname, source_fname) ;
if (mri_source->type == MRI_INT)
{
MRI *mri_tmp = MRIchangeType(mri_source, MRI_FLOAT, 0, 1, 1) ;
MRIfree(&mri_source); mri_source = mri_tmp ;
}
mri_target = MRIread(target_fname) ;
if (!mri_target)
ErrorExit(ERROR_NOFILE, "%s: could not read target label volume %s",
Progname, target_fname) ;
if (mri_target->type == MRI_INT)
{
MRI *mri_tmp = MRIchangeType(mri_target, MRI_FLOAT, 0, 1, 1) ;
MRIfree(&mri_target); mri_target = mri_tmp ;
}
if (erosions > 0)
{
int n ;
for (n = 0 ; n < erosions ; n++)
{
MRIerodeZero(mri_target, mri_target) ;
MRIerodeZero(mri_source, mri_source) ;
}
}
if (scale_values > 0)
{
MRIscalarMul(mri_source, mri_source, scale_values) ;
MRIscalarMul(mri_target, mri_target, scale_values) ;
}
if (transform && transform->type == MORPH_3D_TYPE)
TransformRas2Vox(transform, mri_source,NULL) ;
if (use_aseg == 0)
{
if (match_peak_intensity_ratio)
MRImatchIntensityRatio(mri_source, mri_target, mri_source, .8, 1.2,
100, 125) ;
else if (match_mean_intensity)
MRImatchMeanIntensity(mri_source, mri_target, mri_source) ;
MRIboundingBox(mri_source, 0, &box) ;
pad = (int)ceil(PADVOX *
MAX(mri_target->xsize,MAX(mri_target->ysize,mri_target->zsize)) /
MIN(mri_source->xsize,MIN(mri_source->ysize,mri_source->zsize)));
#if 0
{ MRI *mri_tmp ;
if (pad < 1)
pad = 1 ;
printf("padding source with %d voxels...\n", pad) ;
mri_tmp = MRIextractRegionAndPad(mri_source, NULL, &box, pad) ;
if ((Gdiag & DIAG_WRITE) && DIAG_VERBOSE_ON)
MRIwrite(mri_tmp, "t.mgz") ;
MRIfree(&mri_source) ;
mri_source = mri_tmp ;
}
#endif
}
mri_orig_source = MRIcopy(mri_source, NULL) ;
mp.max_grad = 0.3*mri_source->xsize ;
if (transform == NULL)
transform = TransformAlloc(LINEAR_VOXEL_TO_VOXEL, NULL) ;
if (transform->type != MORPH_3D_TYPE) // initializing m3d from a linear transform
{
new_transform = 1 ;
lta = ((LTA *)(transform->xform)) ;
if (lta->type != LINEAR_VOX_TO_VOX)
{
printf("converting ras xform to voxel xform\n") ;
m_L = MRIrasXformToVoxelXform(mri_source, mri_target, lta->xforms[0].m_L, NULL) ;
MatrixFree(<a->xforms[0].m_L) ;
lta->type = LINEAR_VOX_TO_VOX ;
}
else
{
printf("using voxel xform\n") ;
m_L = lta->xforms[0].m_L ;
}
#if 0
if (Gsx >= 0) // update debugging coords
{
VECTOR *v1, *v2 ;
v1 = VectorAlloc(4, MATRIX_REAL) ;
Gsx -= (box.x-pad) ;
Gsy -= (box.y-pad) ;
Gsz -= (box.z-pad) ;
V3_X(v1) = Gsx ; V3_Y(v1) = Gsy ; V3_Z(v1) = Gsz ;
VECTOR_ELT(v1,4) = 1.0 ;
v2 = MatrixMultiply(m_L, v1, NULL) ;
Gsx = nint(V3_X(v2)) ; Gsy = nint(V3_Y(v2)) ; Gsz = nint(V3_Z(v2)) ;
MatrixFree(&v2) ; MatrixFree(&v1) ;
printf("mapping by transform (%d, %d, %d) --> (%d, %d, %d) for rgb writing\n",
Gx, Gy, Gz, Gsx, Gsy, Gsz) ;
}
#endif
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
write_snapshot(mri_target, mri_source, m_L, &mp, 0, 1, "linear_init");
lta->xforms[0].m_L = m_L ;
printf("initializing GCAM with vox->vox matrix:\n") ;
MatrixPrint(stdout, m_L) ;
gcam = GCAMcreateFromIntensityImage(mri_source, mri_target, transform) ;
#if 0
gcam->gca = gcaAllocMax(1, 1, 1,
mri_target->width, mri_target->height,
mri_target->depth,
0, 0) ;
#endif
GCAMinitVolGeom(gcam, mri_source, mri_target) ;
if (use_aseg)
{
if (ribbon_name)
{
char fname[STRLEN], path[STRLEN], *str, *hemi ;
int h, s, label ;
MRI_SURFACE *mris_white, *mris_pial ;
MRI *mri ;
for (s = 0 ; s <= 1 ; s++) // source and target
{
if (s == 0)
{
str = source_surf ;
mri = mri_source ;
FileNamePath(mri->fname, path) ;
strcat(path, "/../surf") ;
}
else
{
mri = mri_target ;
FileNamePath(mri->fname, path) ;
strcat(path, "/../elastic") ;
str = target_surf ;
}
// sorry - these values come from FreeSurferColorLUT.txt
MRIreplaceValueRange(mri, mri, 1000, 1034, Left_Cerebral_Cortex) ;
MRIreplaceValueRange(mri, mri, 1100, 1180, Left_Cerebral_Cortex) ;
MRIreplaceValueRange(mri, mri, 2000, 2034, Right_Cerebral_Cortex) ;
MRIreplaceValueRange(mri, mri, 2100, 2180, Right_Cerebral_Cortex) ;
for (h = LEFT_HEMISPHERE ; h <= RIGHT_HEMISPHERE ; h++)
{
if (h == LEFT_HEMISPHERE)
{
hemi = "lh" ;
label = Left_Cerebral_Cortex ;
}
else
{
label = Right_Cerebral_Cortex ;
hemi = "rh" ;
}
sprintf(fname, "%s/%s%s.white", path, hemi, str) ;
mris_white = MRISread(fname) ;
if (mris_white == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read surface %s", Progname, fname) ;
MRISsaveVertexPositions(mris_white, WHITE_VERTICES) ;
sprintf(fname, "%s/%s%s.pial", path, hemi, str) ;
mris_pial = MRISread(fname) ;
if (mris_pial == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read surface %s", Progname, fname) ;
MRISsaveVertexPositions(mris_pial, PIAL_VERTICES) ;
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
{
sprintf(fname, "sb.mgz") ;
MRIwrite(mri_source, fname) ;
sprintf(fname, "tb.mgz") ;
MRIwrite(mri_target, fname) ;
}
insert_ribbon_into_aseg(mri, mri, mris_white, mris_pial, h) ;
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
{
sprintf(fname, "sa.mgz") ;
MRIwrite(mri_source, fname) ;
sprintf(fname, "ta.mgz") ;
MRIwrite(mri_target, fname) ;
}
MRISfree(&mris_white) ; MRISfree(&mris_pial) ;
}
}
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
{
sprintf(fname, "s.mgz") ;
MRIwrite(mri_source, fname) ;
sprintf(fname, "t.mgz") ;
MRIwrite(mri_target, fname) ;
}
}
GCAMinitLabels(gcam, mri_target) ;
GCAMsetVariances(gcam, 1.0) ;
mp.mri_dist_map = create_distance_transforms(mri_source, mri_target, NULL, 40.0, gcam) ;
}
}
else /* use a previously create morph and integrate it some more */
{
printf("using previously create gcam...\n") ;
gcam = (GCA_MORPH *)(transform->xform) ;
GCAMrasToVox(gcam, mri_source) ;
if (use_aseg)
{
GCAMinitLabels(gcam, mri_target) ;
GCAMsetVariances(gcam, 1.0) ;
mp.mri_dist_map = create_distance_transforms(mri_source, mri_target, NULL, 40.0, gcam) ;
}
else
GCAMaddIntensitiesFromImage(gcam, mri_target) ;
}
if (gcam->width != mri_source->width ||
gcam->height != mri_source->height ||
gcam->depth != mri_source->depth)
ErrorExit(ERROR_BADPARM, "%s: warning gcam (%d, %d, %d), doesn't match source vol (%d, %d, %d)",
Progname, gcam->width, gcam->height, gcam->depth,
mri_source->width, mri_source->height, mri_source->depth) ;
mp.mri_diag = mri_source ;
mp.diag_morph_from_atlas = 0 ;
mp.diag_write_snapshots = 1 ;
mp.diag_sample_type = use_aseg ? SAMPLE_NEAREST : SAMPLE_TRILINEAR ;
mp.diag_volume = use_aseg ? GCAM_LABEL : GCAM_MEANS ;
if (renormalize)
GCAMnormalizeIntensities(gcam, mri_target) ;
if (mp.write_iterations != 0)
{
char fname[STRLEN] ;
MRI *mri_gca ;
if (getenv("DONT_COMPRESS"))
sprintf(fname, "%s_target.mgh", mp.base_name) ;
else
sprintf(fname, "%s_target.mgz", mp.base_name) ;
if (mp.diag_morph_from_atlas == 0)
{
printf("writing target volume to %s...\n", fname) ;
MRIwrite(mri_target, fname) ;
sprintf(fname, "%s_target", mp.base_name) ;
MRIwriteImageViews(mri_target, fname, IMAGE_SIZE) ;
}
else
{
if (use_aseg)
mri_gca = GCAMwriteMRI(gcam, NULL, GCAM_LABEL) ;
else
{
mri_gca = MRIclone(mri_source, NULL) ;
GCAMbuildMostLikelyVolume(gcam, mri_gca) ;
}
printf("writing target volume to %s...\n", fname) ;
MRIwrite(mri_gca, fname) ;
sprintf(fname, "%s_target", mp.base_name) ;
MRIwriteImageViews(mri_gca, fname, IMAGE_SIZE) ;
MRIfree(&mri_gca) ;
}
}
if (nozero)
{
printf("disabling zero nodes\n") ;
GCAMignoreZero(gcam, mri_target) ;
}
mp.mri = mri_target ;
if (mp.regrid == True && new_transform == 0)
GCAMregrid(gcam, mri_target, PAD, &mp, &mri_source) ;
mp.write_fname = out_fname ;
GCAMregister(gcam, mri_source, &mp) ; // atlas is target, morph target into register with it
if (apply_transform)
{
MRI *mri_aligned ;
char fname[STRLEN] ;
FileNameRemoveExtension(out_fname, fname) ;
strcat(fname, ".mgz") ;
mri_aligned = GCAMmorphToAtlas(mp.mri, gcam, NULL, -1, mp.diag_sample_type) ;
printf("writing transformed output volume to %s...\n", fname) ;
MRIwrite(mri_aligned, fname) ;
MRIfree(&mri_aligned) ;
}
printf("writing warp vector field to %s\n", out_fname) ;
GCAMvoxToRas(gcam) ;
GCAMwrite(gcam, out_fname) ;
GCAMrasToVox(gcam, mri_source) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
printf("registration took %d minutes and %d seconds.\n",
minutes, seconds) ;
exit(0) ;
return(0) ;
}
int
main(int argc, char *argv[]) {
char **av, fname[STRLEN], *out_fname, *subject_name, *cp ;
int ac, nargs, i, n, noint = 0, options ;
int msec, minutes, seconds, nsubjects, input ;
struct timeb start ;
GCA *gca ;
MRI *mri_seg, *mri_tmp, *mri_inputs ;
TRANSFORM *transform ;
LTA *lta;
GCA_BOUNDARY *gcab ;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
parms.use_gradient = 0 ;
spacing = 8 ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_gcab_train.c,v 1.4 2011/03/16 20:23:33 fischl Exp $",
"$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
// parse command line args
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
printf("reading gca from %s\n", argv[1]) ;
gca = GCAread(argv[1]) ;
if (!gca)
exit(Gerror) ;
if (!strlen(subjects_dir)) /* hasn't been set on command line */
{
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM, "%s: SUBJECTS_DIR not defined in environment",
Progname);
strcpy(subjects_dir, cp) ;
if (argc < 4)
usage_exit(1) ;
}
// options parsed. subjects and gca name remaining
out_fname = argv[argc-1] ;
nsubjects = argc-3 ;
for (options = i = 0 ; i < nsubjects ; i++) {
if (argv[i+1][0] == '-') {
nsubjects-- ;
options++ ;
}
}
printf("training on %d subject and writing results to %s\n",
nsubjects, out_fname) ;
n = 0 ;
gcab = GCABalloc(gca, 8, 0, 30, 10, target_label);
strcpy(gcab->gca_fname, argv[1]) ;
// going through the subject one at a time
for (nargs = i = 0 ; i < nsubjects+options ; i++) {
subject_name = argv[i+2] ;
//////////////////////////////////////////////////////////////
printf("***************************************"
"************************************\n");
printf("processing subject %s, %d of %d...\n", subject_name,i+1-nargs,
nsubjects);
if (stricmp(subject_name, "-NOINT") == 0) {
printf("not using intensity information for subsequent subjects...\n");
noint = 1 ;
nargs++ ;
continue ;
} else if (stricmp(subject_name, "-INT") == 0) {
printf("using intensity information for subsequent subjects...\n");
noint = 0 ;
nargs++ ;
continue ;
}
// reading this subject segmentation
sprintf(fname, "%s/%s/mri/%s", subjects_dir, subject_name, seg_dir) ;
if (Gdiag & DIAG_SHOW && DIAG_VERBOSE_ON)
fprintf(stderr, "Reading segmentation from %s...\n", fname) ;
mri_seg = MRIread(fname) ;
if (!mri_seg)
ErrorExit(ERROR_NOFILE, "%s: could not read segmentation file %s",
Progname, fname) ;
if ((mri_seg->type != MRI_UCHAR) && (mri_seg->type != MRI_FLOAT)) {
ErrorExit
(ERROR_NOFILE,
"%s: segmentation file %s is not type UCHAR or FLOAT",
Progname, fname) ;
}
if (binarize) {
int j ;
for (j = 0 ; j < 256 ; j++) {
if (j == binarize_in)
MRIreplaceValues(mri_seg, mri_seg, j, binarize_out) ;
else
MRIreplaceValues(mri_seg, mri_seg, j, 0) ;
}
}
if (insert_fname) {
MRI *mri_insert ;
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name, insert_fname) ;
mri_insert = MRIread(fname) ;
if (mri_insert == NULL)
ErrorExit(ERROR_NOFILE,
"%s: could not read volume from %s for insertion",
Progname, insert_fname) ;
MRIbinarize(mri_insert, mri_insert, 1, 0, insert_label) ;
MRIcopyLabel(mri_insert, mri_seg, insert_label) ;
MRIfree(&mri_insert) ;
}
replaceLabels(mri_seg) ;
MRIeraseBorderPlanes(mri_seg, 1) ;
for (input = 0 ; input < gca->ninputs ; input++) {
//////////// set the gca type //////////////////////////////
// is this T1/PD training?
// how can we allow flash data training ???????
// currently checks the TE, TR, FA to be the same for all inputs
// thus we cannot allow flash data training.
////////////////////////////////////////////////////////////
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name,input_names[input]);
if (DIAG_VERBOSE_ON)
printf("reading co-registered input from %s...\n", fname) ;
fprintf(stderr, " reading input %d: %s\n", input, fname);
mri_tmp = MRIread(fname) ;
if (!mri_tmp)
ErrorExit
(ERROR_NOFILE,
"%s: could not read image from file %s", Progname, fname) ;
// input check 1
if (getSliceDirection(mri_tmp) != MRI_CORONAL) {
ErrorExit
(ERROR_BADPARM,
"%s: must be in coronal direction, but it is not\n",
fname);
}
// input check 2
if (mri_tmp->xsize != 1 || mri_tmp->ysize != 1 || mri_tmp->zsize != 1) {
ErrorExit
(ERROR_BADPARM,
"%s: must have 1mm voxel size, but have (%f, %f, %f)\n",
fname, mri_tmp->xsize, mri_tmp->ysize, mri_tmp->ysize);
}
// input check 3 is removed. now we can handle c_(ras) != 0 case
// input check 4
if (i == 0) {
TRs[input] = mri_tmp->tr ;
FAs[input] = mri_tmp->flip_angle ;
TEs[input] = mri_tmp->te ;
} else if (!FEQUAL(TRs[input],mri_tmp->tr) ||
!FEQUAL(FAs[input],mri_tmp->flip_angle) ||
!FEQUAL(TEs[input], mri_tmp->te))
ErrorExit
(ERROR_BADPARM,
"%s: subject %s input volume %s: sequence parameters "
"(%2.1f, %2.1f, %2.1f)"
"don't match other inputs (%2.1f, %2.1f, %2.1f)",
Progname, subject_name, fname,
mri_tmp->tr, DEGREES(mri_tmp->flip_angle), mri_tmp->te,
TRs[input], DEGREES(FAs[input]), TEs[input]) ;
// first time do the following
if (input == 0) {
int nframes = gca->ninputs ;
///////////////////////////////////////////////////////////
mri_inputs =
MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth,
mri_tmp->type, nframes) ;
if (!mri_inputs)
ErrorExit
(ERROR_NOMEMORY,
"%s: could not allocate input volume %dx%dx%dx%d",
mri_tmp->width, mri_tmp->height, mri_tmp->depth,nframes) ;
MRIcopyHeader(mri_tmp, mri_inputs) ;
}
// -mask option ////////////////////////////////////////////
if (mask_fname)
{
MRI *mri_mask ;
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name, mask_fname);
printf("reading volume %s for masking...\n", fname) ;
mri_mask = MRIread(fname) ;
if (!mri_mask)
ErrorExit(ERROR_NOFILE, "%s: could not open mask volume %s.\n",
Progname, fname) ;
MRImask(mri_tmp, mri_mask, mri_tmp, 0, 0) ;
MRIfree(&mri_mask) ;
}
MRIcopyFrame(mri_tmp, mri_inputs, 0, input) ;
MRIfree(&mri_tmp) ;
}// end of inputs per subject
/////////////////////////////////////////////////////////
// xform_name is given, then we can use the consistent c_(r,a,s) for gca
/////////////////////////////////////////////////////////
if (xform_name)
{
// we read talairach.xfm which is a RAS-to-RAS
sprintf(fname, "%s/%s/mri/transforms/%s",
subjects_dir, subject_name, xform_name) ;
if (Gdiag & DIAG_SHOW && DIAG_VERBOSE_ON)
printf("INFO: reading transform file %s...\n", fname);
if (!FileExists(fname))
{
fprintf(stderr,"ERROR: cannot find transform file %s\n",fname);
exit(1);
}
transform = TransformRead(fname);
if (!transform)
ErrorExit(ERROR_NOFILE, "%s: could not read transform from file %s",
Progname, fname);
modify_transform(transform, mri_inputs, gca);
// Here we do 2 things
// 1. modify gca direction cosines to
// that of the transform destination (both linear and non-linear)
// 2. if ras-to-ras transform,
// then change it to vox-to-vox transform (linear case)
// modify transform to store inverse also
TransformInvert(transform, mri_inputs) ;
// verify inverse
lta = (LTA *) transform->xform;
}
else
{
GCAreinit(mri_inputs, gca);
// just use the input value, since dst = src volume
transform = TransformAlloc(LINEAR_VOXEL_TO_VOXEL, NULL) ;
}
////////////////////////////////////////////////////////////////////
// train gca
////////////////////////////////////////////////////////////////////
// segmentation is seg volume
// inputs is the volumes of all inputs
// transform is for this subject
// noint is whether to use intensity information or not
GCABtrain(gcab, mri_inputs, mri_seg, transform, target_label) ;
MRIfree(&mri_seg) ;
MRIfree(&mri_inputs) ;
TransformFree(&transform) ;
}
GCABcompleteTraining(gcab) ;
if (smooth > 0) {
printf("regularizing conditional densities with smooth=%2.2f\n", smooth) ;
GCAregularizeConditionalDensities(gca, smooth) ;
}
if (navgs) {
printf("applying mean filter %d times to conditional densities\n", navgs) ;
GCAmeanFilterConditionalDensities(gca, navgs) ;
}
printf("writing trained GCAB to %s...\n", out_fname) ;
if (GCABwrite(gcab, out_fname) != NO_ERROR)
ErrorExit
(ERROR_BADFILE, "%s: could not write gca to %s", Progname, out_fname) ;
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
{
MRI *mri ;
mri = GCAbuildMostLikelyVolume(gca, NULL) ;
MRIwrite(mri, "m.mgz") ;
MRIfree(&mri) ;
}
if (histo_fname) {
FILE *fp ;
int histo_counts[10000], xn, yn, zn, max_count ;
GCA_NODE *gcan ;
memset(histo_counts, 0, sizeof(histo_counts)) ;
fp = fopen(histo_fname, "w") ;
if (!fp)
ErrorExit(ERROR_BADFILE, "%s: could not open histo file %s",
Progname, histo_fname) ;
max_count = 0 ;
for (xn = 0 ; xn < gca->node_width; xn++) {
for (yn = 0 ; yn < gca->node_height ; yn++) {
for (zn = 0 ; zn < gca->node_depth ; zn++) {
gcan = &gca->nodes[xn][yn][zn] ;
if (gcan->nlabels < 1)
continue ;
if (gcan->nlabels == 1 && IS_UNKNOWN(gcan->labels[0]))
continue ;
histo_counts[gcan->nlabels]++ ;
if (gcan->nlabels > max_count)
max_count = gcan->nlabels ;
}
}
}
max_count = 20 ;
for (xn = 1 ; xn < max_count ; xn++)
fprintf(fp, "%d %d\n", xn, histo_counts[xn]) ;
fclose(fp) ;
}
GCAfree(&gca) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
printf("classifier array training took %d minutes"
" and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
void csShaderVariable::NewType (VariableType nt)
{
if (GetTypeI() == nt)
return;
switch (GetTypeI())
{
case UNKNOWN:
case INT:
case FLOAT:
break; //Nothing to deallocate
case TEXTURE:
if (texture.HandValue)
texture.HandValue->DecRef ();
if (texture.WrapValue)
texture.WrapValue->DecRef ();
break;
case RENDERBUFFER:
if (RenderBuffer)
RenderBuffer->DecRef ();
break;
case VECTOR2:
case VECTOR3:
case VECTOR4:
break; //Nothing to deallocate
case MATRIX3X3:
MatrixAlloc()->Free (MatrixValuePtr);
break;
case MATRIX4X4:
Matrix4Alloc()->Free (Matrix4ValuePtr);
break;
case TRANSFORM:
TransformAlloc()->Free (TransformPtr);
break;
case ARRAY:
ShaderVarArrayAlloc()->Free (ShaderVarArray);
break;
default:
;
}
switch (nt)
{
case INT:
case TEXTURE:
case RENDERBUFFER:
case UNKNOWN:
case FLOAT:
case VECTOR2:
case VECTOR3:
case VECTOR4:
break; //Nothing to allocate
case MATRIX3X3:
MatrixValuePtr = MatrixAlloc()->Alloc ();
break;
case MATRIX4X4:
Matrix4ValuePtr = Matrix4Alloc()->Alloc ();
break;
case TRANSFORM:
TransformPtr = TransformAlloc()->Alloc ();
break;
case ARRAY:
ShaderVarArray = ShaderVarArrayAlloc()->Alloc ();
break;
default:
;
}
nameAndType &= nameMask;
nameAndType |= nt << typeShift;
}
int
main(int argc, char *argv[])
{
char **av, fname[STRLEN], *out_fname, *subject_name, *cp, *tp1_name, *tp2_name ;
char s1_name[STRLEN], s2_name[STRLEN], *sname ;
int ac, nargs, i, n, options, max_index ;
int msec, minutes, seconds, nsubjects, input ;
struct timeb start ;
MRI *mri_seg, *mri_tmp, *mri_in ;
TRANSFORM *transform ;
// int counts ;
int t;
RANDOM_FOREST *rf = NULL ;
GCA *gca = NULL ;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
parms.width = parms.height = parms.depth = DEFAULT_VOLUME_SIZE ;
parms.ntrees = 10 ;
parms.max_depth = 10 ;
parms.wsize = 1 ;
parms.training_size = 100 ;
parms.training_fraction = .5 ;
parms.feature_fraction = 1 ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_rf_long_train.c,v 1.5 2012/06/15 12:22:28 fischl Exp $",
"$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
// parse command line args
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (!strlen(subjects_dir)) /* hasn't been set on command line */
{
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM, "%s: SUBJECTS_DIR not defined in environment",
Progname);
strcpy(subjects_dir, cp) ;
}
if (argc < 3)
usage_exit(1) ;
// options parsed. subjects, tp1 and tp2 and rf name remaining
out_fname = argv[argc-1] ;
nsubjects = (argc-2)/3 ;
for (options = i = 0 ; i < nsubjects ; i++)
{
if (argv[i+1][0] == '-')
{
nsubjects-- ;
options++ ;
}
}
printf("training on %d subject and writing results to %s\n",
nsubjects, out_fname) ;
// rf_inputs can be T1, PD, ...per subject
if (parms.nvols == 0)
parms.nvols = ninputs ;
/* gca reads same # of inputs as we read
from command line - not the case if we are mapping to flash */
n = 0 ;
//////////////////////////////////////////////////////////////////
// set up gca direction cosines, width, height, depth defaults
gca = GCAread(gca_name) ;
if (gca == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read GCA from %s", Progname, gca_name) ;
/////////////////////////////////////////////////////////////////////////
// weird way options and subject name are mixed here
/////////////////////////////////////////////////////////
// first calculate mean
////////////////////////////////////////////////////////
// going through the subject one at a time
max_index = nsubjects+options ;
nargs = 0 ;
mri_in = NULL ;
#ifdef HAVE_OPENMP
subject_name = NULL ; sname = NULL ; t = 0 ;
// counts = 0 ; would be private
input = 0 ;
transform = NULL ;
tp1_name = tp2_name = NULL ;
mri_tmp = mri_seg = NULL ;
#pragma omp parallel for firstprivate(tp1_name, tp2_name, mri_in,mri_tmp, input, xform_name, transform, subjects_dir, force_inputs, conform, Progname, mri_seg, subject_name, s1_name, s2_name, sname, t, fname) shared(mri_inputs, transforms, mri_segs,argv) schedule(static,1)
#endif
for (i = 0 ; i < max_index ; i++)
{
subject_name = argv[3*i+1] ;
tp1_name = argv[3*i+2] ;
tp2_name = argv[3*i+3] ;
sprintf(s1_name, "%s_%s.long.%s_base", subject_name, tp1_name, subject_name) ;
sprintf(s2_name, "%s_%s.long.%s_base", subject_name, tp2_name, subject_name) ;
//////////////////////////////////////////////////////////////
printf("***************************************"
"************************************\n");
printf("processing subject %s, %d of %d (%s and %s)...\n", subject_name,i+1-nargs,
nsubjects, s1_name,s2_name);
for (t = 0 ; t < 2 ; t++)
{
sname = t == 0 ? s1_name : s2_name;
// reading this subject segmentation
sprintf(fname, "%s/%s/mri/%s", subjects_dir, sname, seg_dir) ;
if (Gdiag & DIAG_SHOW && DIAG_VERBOSE_ON)
fprintf(stderr, "Reading segmentation from %s...\n", fname) ;
mri_seg = MRIread(fname) ;
if (!mri_seg)
ErrorExit(ERROR_NOFILE, "%s: could not read segmentation file %s",
Progname, fname) ;
if ((mri_seg->type != MRI_UCHAR) && (make_uchar != 0))
{
MRI *mri_tmp ;
mri_tmp = MRIchangeType(mri_seg, MRI_UCHAR, 0, 1,1);
MRIfree(&mri_seg) ;
mri_seg = mri_tmp ;
}
if (wmsa_fname)
{
MRI *mri_wmsa ;
sprintf(fname, "%s/%s/mri/%s", subjects_dir, sname, wmsa_fname) ;
printf("reading WMSA labels from %s...\n", fname) ;
mri_wmsa = MRIread(fname) ;
if (mri_wmsa == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read WMSA file %s", fname) ;
MRIbinarize(mri_wmsa, mri_wmsa, 1, 0, WM_hypointensities) ;
MRIcopyLabel(mri_wmsa, mri_seg, WM_hypointensities) ;
lateralize_hypointensities(mri_seg) ;
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON )
{
char s[STRLEN] ;
sprintf(s, "%s/%s/mri/seg_%s",
subjects_dir, subject_name, wmsa_fname) ;
MRIwrite(mri_seg, s) ;
}
}
if (binarize)
{
int j ;
for (j = 0 ; j < 256 ; j++)
{
if (j == binarize_in)
MRIreplaceValues(mri_seg, mri_seg, j, binarize_out) ;
else
MRIreplaceValues(mri_seg, mri_seg, j, 0) ;
}
}
if (insert_fname)
{
MRI *mri_insert ;
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name, insert_fname) ;
mri_insert = MRIread(fname) ;
if (mri_insert == NULL)
ErrorExit(ERROR_NOFILE,
"%s: could not read volume from %s for insertion",
Progname, insert_fname) ;
MRIbinarize(mri_insert, mri_insert, 1, 0, insert_label) ;
MRIcopyLabel(mri_insert, mri_seg, insert_label) ;
MRIfree(&mri_insert) ;
}
replaceLabels(mri_seg) ;
MRIeraseBorderPlanes(mri_seg, 1) ;
////////////////////////////////////////////////////////////
if (DIAG_VERBOSE_ON)
fprintf(stderr,
"Gather all input volumes for the subject %s.\n",
subject_name);
// inputs must be coregistered
// note that inputs are T1, PD, ... per subject (same TE, TR, FA)
for (input = 0 ; input < ninputs ; input++)
{
//////////// set the gca type //////////////////////////////
// is this T1/PD training?
// how can we allow flash data training ???????
// currently checks the TE, TR, FA to be the same for all inputs
// thus we cannot allow flash data training.
////////////////////////////////////////////////////////////
sprintf(fname, "%s/%s/mri/%s", subjects_dir, sname,input_names[input]);
if (DIAG_VERBOSE_ON)
printf("reading co-registered input from %s...\n", fname) ;
fprintf(stderr, " reading input %d: %s\n", input, fname);
mri_tmp = MRIread(fname) ;
if (!mri_tmp)
ErrorExit
(ERROR_NOFILE,
"%s: could not read image from file %s", Progname, fname) ;
// input check 1
if (getSliceDirection(mri_tmp) != MRI_CORONAL)
{
ErrorExit
(ERROR_BADPARM,
"%s: must be in coronal direction, but it is not\n",
fname);
}
// input check 2
if (conform &&
(mri_tmp->xsize != 1 || mri_tmp->ysize != 1 || mri_tmp->zsize != 1))
{
ErrorExit
(ERROR_BADPARM,
"%s: must have 1mm voxel size, but have (%f, %f, %f)\n",
fname, mri_tmp->xsize, mri_tmp->ysize, mri_tmp->ysize);
}
// input check 3 is removed. now we can handle c_(ras) != 0 case
// input check 4
if (i == 0)
{
TRs[input] = mri_tmp->tr ;
FAs[input] = mri_tmp->flip_angle ;
TEs[input] = mri_tmp->te ;
}
else if ((force_inputs == 0) &&
(!FEQUAL(TRs[input],mri_tmp->tr) ||
!FEQUAL(FAs[input],mri_tmp->flip_angle) ||
!FEQUAL(TEs[input], mri_tmp->te)))
ErrorExit
(ERROR_BADPARM,
"%s: subject %s input volume %s: sequence parameters "
"(%2.1f, %2.1f, %2.1f)"
"don't match other inputs (%2.1f, %2.1f, %2.1f)",
Progname, subject_name, fname,
mri_tmp->tr, DEGREES(mri_tmp->flip_angle), mri_tmp->te,
TRs[input], DEGREES(FAs[input]), TEs[input]) ;
// first time do the following
if (input == 0)
{
int nframes = ninputs ;
///////////////////////////////////////////////////////////
mri_in = MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth,
mri_tmp->type, nframes) ;
if (!mri_in)
ErrorExit
(ERROR_NOMEMORY,
"%s: could not allocate input volume %dx%dx%dx%d",
mri_tmp->width, mri_tmp->height, mri_tmp->depth,nframes) ;
MRIcopyHeader(mri_tmp, mri_in) ;
}
// -mask option ////////////////////////////////////////////
if (mask_fname)
{
MRI *mri_mask ;
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name, mask_fname);
printf("reading volume %s for masking...\n", fname) ;
mri_mask = MRIread(fname) ;
if (!mri_mask)
ErrorExit(ERROR_NOFILE, "%s: could not open mask volume %s.\n",
Progname, fname) ;
MRImask(mri_tmp, mri_mask, mri_tmp, 0, 0) ;
MRIfree(&mri_mask) ;
}
MRIcopyFrame(mri_tmp, mri_in, 0, input) ;
MRIfree(&mri_tmp) ;
}// end of inputs per subject
/////////////////////////////////////////////////////////
// xform_name is given, then we can use the consistent c_(r,a,s) for gca
/////////////////////////////////////////////////////////
if (xform_name)
{
// we read talairach.xfm which is a RAS-to-RAS
sprintf(fname, "%s/%s/mri/transforms/%s", subjects_dir, sname, xform_name) ;
if (Gdiag & DIAG_SHOW && DIAG_VERBOSE_ON)
printf("INFO: reading transform file %s...\n", fname);
if (!FileExists(fname))
{
fprintf(stderr,"ERROR: cannot find transform file %s\n",fname);
exit(1);
}
transform = TransformRead(fname);
if (!transform)
ErrorExit(ERROR_NOFILE, "%s: could not read transform from file %s",
Progname, fname);
// modify_transform(transform, mri_in, gca);
// Here we do 2 things
// 1. modify gca direction cosines to
// that of the transform destination (both linear and non-linear)
// 2. if ras-to-ras transform,
// then change it to vox-to-vox transform (linear case)
// modify transform to store inverse also
TransformInvert(transform, mri_in) ;
}
else
{
// GCAreinit(mri_in, gca);
// just use the input value, since dst = src volume
transform = TransformAlloc(LINEAR_VOXEL_TO_VOXEL, NULL) ;
}
/////////////////////////////////////////////////////////
if (do_sanity_check)
{
// conduct a sanity check of particular labels, most importantly
// hippocampus, that such labels do not exist in talairach coords
// where they are known not to belong (indicating a bad manual edit)
int errs = check(mri_seg, subjects_dir, subject_name);
if (errs)
{
printf(
"ERROR: mri_ca_train: possible bad training data! subject:\n"
"\t%s/%s\n\n", subjects_dir, subject_name);
fflush(stdout) ;
sanity_check_badsubj_count++;
}
}
mri_segs[i][t] = mri_seg ;
mri_inputs[i][t] = mri_in ;
transforms[i][t] = transform ;
}
}
rf = train_rforest(mri_inputs, mri_segs, transforms, nsubjects, gca, &parms, wm_thresh,wmsa_whalf, 2) ;
printf("writing random forest to %s\n", out_fname) ;
if (RFwrite(rf, out_fname) != NO_ERROR)
ErrorExit
(ERROR_BADFILE, "%s: could not write rf to %s", Progname, out_fname) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
printf("classifier array training took %d minutes and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
