static int
saturate_PD(MRI *mri, float PDsat) {
int x,y , z ;
float mx, mn, val ;
printf("saturating PD (%2.3f)\n", PDsat) ;
MRIvalRange(mri, &mn, &mx) ;
for (x = 0 ; x < mri->width ; x++) {
for (y = 0 ; y < mri->height ; y++) {
for (z = 0 ; z < mri->depth ; z++) {
val = MRIgetVoxVal(mri, x, y, z, 0) ;
val = 1000 * tanh(val / (PDsat * (mx-mn))) ;
MRIsetVoxVal(mri, x, y, z, 0, val) ;
}
}
}
return(NO_ERROR) ;
}
MRI *
MRIbinarizeEditting(MRI *mri_src, MRI *mri_dst) {
int width, height, depth, x, y, z, val ;
BUFTYPE *
width = mri_src->width ;
height = mri_src->height ;
depth = mri_src->depth ;
mri_dst = MRIalloc(width, height, depth, MRI_UCHAR) ;
if (!mri_dst)
mri_dst = MRIclone(mri_src, NULL) ;
MRIvalRange(mri_src, &fmin, &fmax) ;
for (z = 0 ; z < depth ; z++) {
for (y = 0 ; y < height ; y++) {
for (x = 0 ; x < width ; x++) {}
}
}
return(mri_dst) ;
}
MRI *
MRIfloatToChar(MRI *mri_src, MRI *mri_dst) {
int width, height, depth/*, x, y, z, out_val*/ ;
/* float fmax, fmin ;*/
width = mri_src->width ;
height = mri_src->height ;
depth = mri_src->depth ;
if (!mri_dst)
mri_dst = MRIalloc(width, height, depth, MRI_UCHAR) ;
#if 1
MRIcopy(mri_src, mri_dst) ;
#else
MRIvalRange(mri_src, &fmin, &fmax) ;
for (z = 0 ; z < depth ; z++) {
for (y = 0 ; y < height ; y++) {
for (x = 0 ; x < width ; x++) {}
}
}
#endif
return(mri_dst) ;
}
int main(int argc, char *argv[]) {
tesselation_parms *parms;
MRIS **mris_table, *mris,*mris_corrected;
MRI *mri;
char cmdline[CMD_LINE_LEN] ;
make_cmd_version_string
(argc, argv,
"$Id: mri_mc.c,v 1.22 2011/03/02 00:04:23 nicks Exp $", "$Name: stable5 $",
cmdline);
Progname=argv[0];
if (argc > 1 && (stricmp(argv[1], "-d") == 0)) {
downsample = atoi(argv[2]) ;
argc -= 2;
argv += 2 ;
printf("downsampling input volume %d times\n", downsample) ;
}
if (argc < 4) {
fprintf(stderr,"\n\nUSAGE: mri_mc input_volume "
"label_value output_surface [connectivity]");
fprintf(stderr,
"\noption connectivity: 1=6+,2=18,3=6,4=26 (default=1)\n\n");
exit(-1);
}
parms=(tesselation_parms*)calloc(1,sizeof(tesselation_parms));
if (!parms)
ErrorExit(ERROR_NOMEMORY, "tesselation parms\n") ;
mri=MRIread(argv[1]);
if (downsample > 0) {
MRI *mri_tmp ;
mri_tmp = MRIdownsample2(mri, NULL) ;
MRIfree(&mri) ;
mri = mri_tmp ;
}
{
MRI *mri_tmp ;
mri_tmp = MRIalloc(mri->width+2, mri->height+2, mri->depth+2, mri->type) ;
MRIextractInto(mri, mri_tmp,
0, 0, 0,
mri->width, mri->height, mri->depth,
1, 1, 1) ;
MRIfree(&mri) ;
mri = mri_tmp ;
}
MRIreInitCache(mri);
if (mri->type != MRI_UCHAR) {
MRI *mri_tmp ;
float min_val, max_val ;
MRIvalRange(mri, &min_val, &max_val) ;
if (min_val < 0 || max_val > 255)
ErrorExit
(ERROR_UNSUPPORTED,
"%s: input volume (val range [%2.1f %2.1f]) must be "
"convertible to UCHAR",
Progname, min_val, max_val) ;
printf("changing type of input volume to 8 bits/voxel...\n") ;
mri_tmp = MRIchangeType(mri, MRI_UCHAR, 0.0, 0.999, TRUE) ;
MRIfree(&mri) ;
mri = mri_tmp ;
}
parms->mri=mri;
parms->number_of_labels=1; //only one single label
parms->label_values=(int*)malloc(sizeof(int));
parms->label_values[0]=atoi(argv[2]);//label;
parms->ind=0;
mris_table=(MRIS**)malloc(sizeof(MRIS*)); //final surface information
parms->mris_table=mris_table;
if ((!parms->label_values) || (!mris_table))
ErrorExit(ERROR_NOMEMORY, "labels/surfaces tables\n") ;
if (argc==5) parms->connectivity=atoi(argv[4]);//connectivity;
else parms->connectivity=1;
initTesselationParms(parms);
generateMCtesselation(parms);
free(parms->label_values);
mris=parms->mris_table[0];
free(parms->mris_table);
freeTesselationParms(&parms);
{
float dist,max_e=0.0;
int n,p,vn0,vn2;
VERTEX *v,*vp;
fprintf(stderr,"computing the maximum edge length...");
for (n = 0 ; n < mris->nvertices ; n++) {
v=&mris->vertices[n];
for (p = 0 ; p < v->vnum ; p++) {
vp = &mris->vertices[v->v[p]];
dist=SQR(vp->x-v->x)+SQR(vp->y-v->y)+SQR(vp->z-v->z);
if (dist>max_e) max_e=dist;
}
}
fprintf(stderr,"%f mm",sqrt(max_e));
fprintf(stderr,"\nreversing orientation of faces...");
for (n = 0 ; n < mris->nfaces ; n++) {
vn0=mris->faces[n].v[0];
vn2=mris->faces[n].v[2];
/* vertex 0 becomes vertex 2 */
v=&mris->vertices[vn0];
for (p = 0 ; p < v->num ; p++)
if (v->f[p]==n)
v->n[p]=2;
mris->faces[n].v[2]=vn0;
/* vertex 2 becomes vertex 0 */
v=&mris->vertices[vn2];
for (p = 0 ; p < v->num ; p++)
if (v->f[p]==n)
v->n[p]=0;
mris->faces[n].v[0]=vn2;
}
}
fprintf(stderr,"\nchecking orientation of surface...");
MRISmarkOrientationChanges(mris);
mris_corrected=MRISextractMainComponent(mris,0,1,0);
MRISfree(&mris);
fprintf(stderr,"\nwriting out surface...");
MRISaddCommandLine(mris_corrected, cmdline) ;
if (mriConformed(mri) == 0) {
printf("input volume is not conformed - using useRealRAS=1\n") ;
mris_corrected->useRealRAS = 1 ;
}
// getVolGeom(mri, &mris_corrected->vg);
MRISwrite(mris_corrected,argv[3]);
fprintf(stderr,"done\n");
MRIfree(&mri);
MRISfree(&mris_corrected);
return 0;
}
int
MRIsampleParcellationToSurface(MRI_SURFACE *mris, MRI *mri_parc) {
int min_label, max_label, **label_histo, l, vno, nlabels, x, y, z, max_l ;
float fmin, fmax, max_count, d ;
MRIS_HASH_TABLE *mht ;
VERTEX *v ;
Real xs, ys, zs, xv, yv, zv, val ;
MRI *mri_parc_unused ;
mri_parc_unused = MRIcopy(mri_parc, NULL) ;
MRIvalRange(mri_parc, &fmin, &fmax) ;
min_label = (int)floor(fmin) ;
max_label = (int)ceil(fmax) ;
nlabels = max_label - min_label + 1 ;
label_histo = (int **)calloc(mris->nvertices, sizeof(int *)) ;
if (label_histo == NULL)
ErrorExit(ERROR_NOMEMORY, "%s: could not create label frequency histo", Progname) ;
for (vno = 0 ; vno < mris->nvertices ; vno++) {
label_histo[vno] = (int *)calloc(nlabels, sizeof(int)) ;
if (label_histo[vno] == NULL)
ErrorExit(ERROR_NOMEMORY, "%s: could not create label frequency histo[%d] with %d bins",
Progname, vno, nlabels) ;
}
mht = MHTfillVertexTableRes(mris, NULL, CURRENT_VERTICES, 8.0) ;
MRISclearMarks(mris) ;
// build histograms at each vertex
for (x = 0 ; x < mri_parc->width ; x++) {
for (y = 0 ; y < mri_parc->height ; y++) {
for (z = 0 ; z < mri_parc->depth ; z++) {
if (x == Gx && y == Gy && z == Gz)
DiagBreak() ;
l = (int)MRIgetVoxVal(mri_parc, x, y, z, 0) ;
if (l == 0)
continue ;
MRIvoxelToSurfaceRAS(mri_parc, x, y, z, &xs, &ys, &zs) ;
v = MHTfindClosestVertexInTable(mht, mris, xs, ys, zs, 0) ;
if (v == NULL)
continue ;
if (sqrt(SQR(v->x-xs) + SQR(v->y-ys) + SQR(v->z-zs)) > 3)
continue ;
MRIsetVoxVal(mri_parc_unused, x, y, z, 0, 0) ;
vno = v-mris->vertices ;
if (vno == Gdiag_no)
{
printf("v %d: sampling from (%d, %d, %d) - %d\n",
vno, x, y, z, l);
DiagBreak() ;
}
label_histo[vno][l-min_label]++ ;
}
}
}
MRIwrite(mri_parc_unused, "pu.mgz") ;
for (vno = 0 ; vno < mris->nvertices ; vno++) {
if (vno == Gdiag_no)
DiagBreak() ;
max_l = 0 ;
max_count = 0 ;
for (l = 0 ; l < nlabels ; l++) {
if (label_histo[vno][l] > max_count) {
max_count = label_histo[vno][l] ;
max_l = l+min_label ;
}
}
v = &mris->vertices[vno] ;
v->val = v->annotation = max_l ;
if (max_count > 0)
v->marked = 1 ;
}
for (vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (vno == Gdiag_no)
DiagBreak() ;
if (v->marked)
continue ; // found something here
for (d = 0 ; d <= 2 ; d += 0.25) {
xs = v->x + d*v->nx;
ys = v->y + d*v->ny;
zs = v->z + d*v->nz;
MRIsurfaceRASToVoxel(mri_parc, xs, ys, zs, &xv, &yv, &zv);
MRIsampleVolumeType(mri_parc, xv, yv, zv, &val, SAMPLE_NEAREST) ;
l = (int)nint(val) ;
if (l > 0) {
v->val = v->annotation = l ;
break ;
}
}
}
MHTfree(&mht) ;
for (vno = 0 ; vno < mris->nvertices ; vno++)
free(label_histo[vno]) ;
free(label_histo) ;
MRIfree(&mri_parc_unused) ;
return(NO_ERROR) ;
}
static GCA_SAMPLE *
find_control_points(GCA *gca, GCA_SAMPLE *gcas_total,
int total_samples, int *pnorm_samples, int nregions, int label,
MRI *mri_in, TRANSFORM *transform, double min_prior, double ctl_point_pct)
{
int i, j, *ordered_indices, nsamples,
xmin, ymin, zmin, xmax, ymax, zmax, xv,yv,zv,
x, y, z, xi, yi, zi, region_samples,
used_in_region, prior_wsize=5, image_wsize=3, histo_peak, n,
nbins ;
GCA_SAMPLE *gcas, *gcas_region, *gcas_norm ;
double means[MAX_GCA_INPUTS], vars[MAX_GCA_INPUTS], val, nsigma ;
HISTOGRAM *histo, *hsmooth ;
GC1D *gc ;
float fmin, fmax ;
MRI *mri_T1 = NULL ;
if (label == Gdiag_no)
DiagBreak() ;
MRIvalRange(mri_in, &fmin, &fmax) ;
nbins = (int)(fmax-fmin+1);
histo = HISTOalloc(nbins) ; hsmooth = HISTOalloc(nbins) ;
for (nsamples = i = 0 ; i < total_samples ; i++)
{
if (gcas_total[i].label != label)
continue ;
nsamples++ ;
}
*pnorm_samples = 0 ;
printf("found %d control points for structure...\n", nsamples) ;
if (nsamples == 0)
{
DiagBreak() ;
return(NO_ERROR) ;
}
gcas = (GCA_SAMPLE *)calloc(nsamples, sizeof(GCA_SAMPLE)) ;
gcas_region = (GCA_SAMPLE *)calloc(nsamples, sizeof(GCA_SAMPLE)) ;
gcas_norm = (GCA_SAMPLE *)calloc(nsamples, sizeof(GCA_SAMPLE)) ;
if (!gcas || !gcas_region || !gcas_norm)
ErrorExit
(ERROR_NOMEMORY,
"find_control_points: could not allocate %d samples\n",nsamples);
for (j = i = 0 ; i < total_samples ; i++)
{
if (gcas_total[i].label != label)
continue ;
memmove(&gcas[j], &gcas_total[i], sizeof(GCA_SAMPLE)) ;
j++ ;
}
ordered_indices = (int *)calloc(nsamples, sizeof(int)) ;
gcas_bounding_box(gcas, nsamples, &xmin, &ymin, &zmin, &xmax, &ymax, &zmax, label) ;
printf("bounding box (%d, %d, %d) --> (%d, %d, %d)\n",
xmin, ymin, zmin, xmax, ymax, zmax) ;
for (x = 0 ; x < nregions ; x++)
{
for (y = 0 ; y < nregions ; y++)
{
for (z = 0 ; z < nregions ; z++)
{
/* only process samples in this region */
nsigma = 1.0 ;
do
{
for (region_samples = i = 0 ; i < nsamples ; i++)
{
xi = (int)(nregions*(gcas[i].x - xmin) / (xmax-xmin+1)) ;
yi = (int)(nregions*(gcas[i].y - ymin) / (ymax-ymin+1)) ;
zi = (int)(nregions*(gcas[i].z - zmin) / (zmax-zmin+1)) ;
if ((xi < 0 || xi >= nregions) ||
(yi < 0 || yi >= nregions) ||
(zi < 0 || zi >= nregions))
DiagBreak() ;
xv = gcas[i].x ; yv = gcas[i].y ; zv = gcas[i].z ;
if (xi != x || yi != y || zi != z
|| gcas[i].prior < min_prior)
continue ;
if (xv == Gx && yv == Gy && zv == Gz)
DiagBreak() ;
if (sqrt(SQR(xv-Gx)+SQR(yv-Gy)+SQR(zv-Gz)) < 2)
DiagBreak() ;
if (min_region_prior(gca, gcas[i].xp, gcas[i].yp, gcas[i].zp,prior_wsize, label) < min_prior)
continue ;
if (uniform_region(gca, mri_in, transform,
xv, yv, zv,
image_wsize, &gcas[i], nsigma) == 0)
continue ;
memmove(&gcas_region[region_samples],
&gcas[i],
sizeof(GCA_SAMPLE)) ;
region_samples++ ;
if (gcas[i].x == Gx &&
gcas[i].y == Gy &&
gcas[i].z == Gz)
DiagBreak() ;
}
nsigma *= 1.1 ;
} while (region_samples < 8 && nsigma < 3) ;
if (region_samples < 8)/* can't reliably estimate statistics */
continue ;
if (DIAG_VERBOSE_ON)
printf("\t%d total samples found in region (%d, %d, %d)\n",
region_samples,x, y,z) ;
/* compute mean and variance of label within this region */
for (n = 0 ; n < mri_in->nframes ; n++)
{
HISTOclear(histo, histo) ;
histo->bin_size = 1 ;
for (means[n] = vars[n] = 0.0, i = 0 ;
i < region_samples ;
i++)
{
MRIsampleVolumeFrame
(mri_in,
gcas_region[i].x,gcas_region[i].y,gcas_region[i].z,
n, &val) ;
if (FZERO(val))
{
if (i < (region_samples-1))
memmove(&gcas_region[i],
&gcas_region[i+1],
(region_samples-(i+1))*sizeof(GCA_SAMPLE));
i-- ;
region_samples-- ;
continue ;
}
histo->counts[(int)val]++ ;
means[n] += val ;
vars[n] += (val*val) ;
}
HISTOsmooth(histo, hsmooth, 2) ;
histo_peak =
HISTOfindHighestPeakInRegion(hsmooth, 1, hsmooth->nbins) ;
if (histo_peak < 0) /* couldn't find a valid peak? */
break ;
for (means[n] = vars[n] = 0.0, i = 0 ;
i < region_samples ;
i++)
{
if (gcas_region[i].label < 0)
continue ;
MRIsampleVolumeFrame
(mri_in,
gcas_region[i].x,
gcas_region[i].y,
gcas_region[i].z,
n, &val) ;
means[n] += val ;
vars[n] += (val*val) ;
}
means[n] /= (double)region_samples ;
vars[n] = vars[n] / (double)region_samples - means[n]*means[n] ;
means[n] = histo_peak ;
if (DIAG_VERBOSE_ON)
printf("\tlabel %s[%d]: %2.1f +- %2.1f\n",
cma_label_to_name(label),
n, means[n], sqrt(vars[n])) ;
}
/* ignore GCA mean and variance -
use image instead (otherwise bias field will mess us up) */
for (i = 0 ; i < region_samples ; i++)
{
int r ;
for (r = 0 ; r < gca->ninputs ; r++)
gcas_region[i].means[r] = means[r] ;
/* gcas_region[i].var = var ;*/
}
GCAcomputeLogSampleProbability
(gca, gcas_region, mri_in, transform, region_samples) ;
GCArankSamples
(gca, gcas_region, region_samples, ordered_indices) ;
GCAremoveOutlyingSamples
(gca, gcas_region, mri_in, transform, region_samples, 2.0) ;
for (used_in_region = i = 0 ; i < region_samples ; i++)
{
j = ordered_indices[i] ;
if (gcas_region[j].label != label) /* it was an outlier */
continue ;
memmove
(&gcas_norm[*pnorm_samples],
&gcas_region[j],
sizeof(GCA_SAMPLE)) ;
(*pnorm_samples)++ ; used_in_region++ ;
}
if ((used_in_region <= 0) && region_samples>0)
{
j = ordered_indices[0] ;
/* gcas_region[j].label = label ;*/
printf("forcing use of sample %d @ (%d, %d, %d)\n", j,
gcas_region[j].x,
gcas_region[j].y,
gcas_region[j].z) ;
memmove(&gcas_norm[*pnorm_samples],
&gcas_region[j],
sizeof(GCA_SAMPLE)) ;
(*pnorm_samples)++ ; used_in_region++ ;
}
if (DIAG_VERBOSE_ON)
printf("\t%d samples used in region\n", used_in_region) ;
}
}
}
/* put gca means back into samples */
for (i = 0 ; i < *pnorm_samples ; i++)
{
gc = GCAfindPriorGC(gca,
gcas_norm[i].xp,
gcas_norm[i].yp,
gcas_norm[i].zp,
gcas_norm[i].label) ;
if (gc)
{
int r, c, v ;
for (v = r = 0 ; r < gca->ninputs ; r++)
{
for (c = r ; c < gca->ninputs ; c++, v++)
{
gcas_norm[i].means[v] = gc->means[v] ;
gcas_norm[i].covars[v] = gc->covars[v] ;
}
}
}
}
HISTOfree(&histo) ; HISTOfree(&hsmooth) ;
free(gcas_region) ;
free(gcas) ;
if (mri_T1)
MRIfree(&mri_T1) ;
return(gcas_norm) ;
}
bool FSGroupDescriptor::Read( const QString& filename )
{
// first read XAxis start and delta
QFile file(filename);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return false;
bool bOK = false;
while (!file.atEnd())
{
QString line = file.readLine().trimmed();
if (!line.isEmpty())
{
QStringList list = line.split(QRegExp("\\s+"), QString::SkipEmptyParts);
if (list[0].toLower() == "xaxis" && list.size() == 3)
{
m_dXStart = list[1].toDouble(&bOK);
if (bOK)
m_dXDelta = list[2].toDouble(&bOK);
}
}
}
if (!bOK)
{
// cout << "Could not find XAxis tag in file. Using default one." << endl;
// m_dXStart = 0;
// m_dXDelta = 1;
}
file.close();
if ( m_fsgd )
{
::gdfFree( &m_fsgd );
}
m_fsgd = ::gdfRead( filename.toAscii().data(), 1 );
if ( m_fsgd == NULL )
{
cerr << "gdfRead failed\n";
return false;
}
float fMinValue, fMaxValue;
MRIvalRange( m_fsgd->data, &fMinValue, &fMaxValue );
m_dMeasurementRange[0] = fMinValue;
m_dMeasurementRange[1] = fMaxValue;
FSGDVariable gdv;
for (int i = 0; i < m_fsgd->nvariables; i++)
{
gdv.label = m_fsgd->varlabel[i];
m_variables << gdv;
}
QList<QColor> stockColors;
stockColors << Qt::blue << Qt::red << Qt::green << Qt::yellow << Qt::cyan;
QStringList stockMarkers;
stockMarkers << "square" << "circle" << "plus" << "dot" << "asterisk" << "triangle" << "cross" << "diamond" ;
for (int i = 0; i < m_fsgd->nclasses; i++)
{
FSGDClass gdc;
gdc.label = m_fsgd->classlabel[i];
gdc.marker = m_fsgd->classmarker[i];
if (gdc.marker.isEmpty())
gdc.marker = stockMarkers[i%stockMarkers.size()];
gdc.color = QColor(m_fsgd->classcolor[i]);
if (!gdc.color.isValid())
gdc.color = stockColors[i%stockColors.size()];
m_classes << gdc;
}
for (int i = 0; i < m_fsgd->ninputs; i++)
{
FSGDDataItem scd;
scd.subject_id = m_fsgd->subjid[i];
for (int n = 0; n < m_fsgd->nvariables; n++)
scd.variable_values << m_fsgd->varvals[i][n];
scd.class_id = m_fsgd->subjclassno[i];
m_data << scd;
}
// find variable value range
for (int i = 0; i < m_data.size(); i++)
{
if (i == 0)
{
for (int n = 0; n < m_variables.size(); n++)
{
m_variables[n].range[0] = m_variables[n].range[1]
= m_data[i].variable_values[n];
}
}
else
{
for (int n = 0; n < m_variables.size(); n++)
{
if (m_data[i].variable_values[n] < m_variables[n].range[0])
m_variables[n].range[0] = m_data[i].variable_values[n];
else if (m_data[i].variable_values[n] > m_variables[n].range[1])
m_variables[n].range[1] = m_data[i].variable_values[n];
}
}
// qDebug() << m_data[i].class_id << m_data[i].subject_id << m_data[i].variable_values;
}
m_title = m_fsgd->title;
m_measureName = m_fsgd->measname;
// UpdateData(0);
return true;
}
