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
main(int argc, char *argv[]) {
char **av ;
int ac, nargs, width, height, depth, x, y, z, xborder, yborder, zborder,
xrborder, yrborder, zrborder ;
char *in_fname, *out_fname ;
MRI *mri_smooth, *mri_grad, *mri_filter_src, *mri_filter_dst, *mri_dst,
*mri_tmp, *mri_blur, *mri_src, *mri_filtered, *mri_direction,
*mri_offset, *mri_up, *mri_polv, *mri_dir, *mri_clip, *mri_full ;
MRI_REGION region, clip_region ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_nlfilter.c,v 1.14 2011/03/02 00:04:23 nicks Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
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() ;
in_fname = argv[1] ;
out_fname = argv[2] ;
mri_full = mri_src = MRIread(in_fname) ;
if (!mri_src)
ErrorExit(ERROR_NOFILE, "%s: could not read '%s'", Progname, in_fname) ;
if (!FZERO(blur_sigma)) /* allocate a blurring kernel */
{
mri_blur = MRIgaussian1d(blur_sigma, 0) ;
if (!mri_blur)
ErrorExit(ERROR_BADPARM,
"%s: could not allocate blurring kernel with sigma=%2.3f",
Progname, blur_sigma) ;
} else
mri_blur = NULL ;
MRIboundingBox(mri_full, 0, &clip_region) ;
REGIONexpand(&clip_region, &clip_region, (filter_window_size+1)/2) ;
mri_src = MRIextractRegion(mri_full, NULL, &clip_region) ;
width = mri_src->width ;
height = mri_src->height ;
depth = mri_src->depth ;
mri_dst = MRIclone(mri_src, NULL) ;
if (!mri_dst)
ErrorExit(ERROR_NOFILE, "%s: could allocate space for destination image",
Progname) ;
for (z = 0 ; z < depth ; z += region_size) {
for (y = 0 ; y < height ; y += region_size) {
DiagHeartbeat((float)(z*height+y) / (float)(height*(depth-1))) ;
for (x = 0 ; x < width ; x += region_size) {
region.x = x ;
region.y = y ;
region.z = z ;
region.dx = region.dy = region.dz = region_size ;
if (region.x == 142)
DiagBreak() ;
REGIONexpand(®ion, ®ion, (filter_window_size+1)/2) ;
MRIclipRegion(mri_src, ®ion, ®ion) ;
if (region.x == 142)
DiagBreak() ;
/* check for < 0 width regions */
xborder = x-region.x ;
yborder = y-region.y ;
zborder = z-region.z ;
xrborder = MAX(0, (region.dx-xborder) - region_size) ;
yrborder = MAX(0, (region.dy-yborder) - region_size) ;
zrborder = MAX(0, (region.dz-zborder) - region_size) ;
#if 0
if (region.dx < 2*xborder || region.dy<2*yborder||region.dz<2*zborder)
continue ;
#endif
if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW))
fprintf(stderr, "extracting region (%d, %d, %d) --> (%d, %d, %d)...",
region.x,region.y,region.z, region.x+region.dx-1,
region.y+region.dy-1,region.z+region.dz-1) ;
mri_clip = MRIextractRegion(mri_src, NULL, ®ion) ;
if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW))
fprintf(stderr, "done.\nsmoothing region and up-sampling...") ;
if (mri_blur) /* smooth the input image to generate offset field */
mri_smooth = MRIconvolveGaussian(mri_clip, NULL, mri_blur) ;
else
mri_smooth = MRIcopy(mri_clip, NULL) ; /* no smoothing */
if (!mri_smooth)
ErrorExit(ERROR_BADPARM, "%s: image smoothing failed", Progname) ;
/* now up-sample the smoothed image, and compute offset field in
up-sampled domain */
mri_up = MRIupsample2(mri_smooth, NULL) ;
if (!mri_up)
ErrorExit(ERROR_BADPARM, "%s: up sampling failed", Progname) ;
MRIfree(&mri_smooth) ;
if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW))
fprintf(stderr, "done.\n") ;
mri_smooth = mri_up ;
mri_grad = MRIsobel(mri_smooth, NULL, NULL) ;
mri_dir = MRIclone(mri_smooth, NULL) ;
MRIfree(&mri_smooth) ;
if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW))
fprintf(stderr, "computing direction map...") ;
mri_direction =
MRIoffsetDirection(mri_grad, offset_window_size, NULL, mri_dir) ;
if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW))
fprintf(stderr, "computing offset magnitudes...") ;
MRIfree(&mri_grad) ;
mri_offset =
MRIoffsetMagnitude(mri_direction, NULL, offset_search_len);
MRIfree(&mri_direction) ;
if (!mri_offset)
ErrorExit(ERROR_NOMEMORY,
"%s: offset calculation failed", Progname) ;
if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW))
fprintf(stderr, "done.\nfiltering image...") ;
mri_filter_src = MRIupsample2(mri_clip, NULL) ;
MRIfree(&mri_clip) ;
switch (filter_type) {
case FILTER_CPOLV_MEDIAN:
mri_polv = MRIplaneOfLeastVarianceNormal(mri_filter_src,NULL,5);
mri_filter_dst =
MRIpolvMedian(mri_filter_src, NULL, mri_polv,filter_window_size);
MRIfree(&mri_polv) ;
break ;
case FILTER_GAUSSIAN:
mri_filter_dst =
MRIconvolveGaussian(mri_filter_src, NULL, mri_gaussian) ;
if (!mri_filter_dst)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate temporary buffer space",Progname);
break ;
case FILTER_MEDIAN:
mri_filter_dst = MRImedian(mri_filter_src,NULL,filter_window_size, NULL);
if (!mri_filter_dst)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate temporary buffer space",Progname);
break ;
case FILTER_MEAN:
mri_filter_dst = MRImean(mri_filter_src, NULL, filter_window_size) ;
if (!mri_filter_dst)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate temporary buffer space",Progname);
break ;
case FILTER_MINMAX:
mri_filter_dst =
MRIminmax(mri_filter_src, NULL, mri_dir, filter_window_size) ;
if (!mri_filter_dst)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate space for filtered image",
Progname) ;
break ;
default:
mri_filter_dst = MRIcopy(mri_filter_src, NULL) ; /* no filtering */
break ;
}
MRIfree(&mri_dir) ;
MRIfree(&mri_filter_src) ;
if (no_offset)
{
mri_filtered = MRIcopy(mri_filter_dst, NULL) ;
}
else
{
if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW))
fprintf(stderr, "applying offset field...") ;
if (Gdiag & DIAG_WRITE)
MRIwrite(mri_filter_dst, "minmax.mgz") ;
mri_filtered = MRIapplyOffset(mri_filter_dst, NULL, mri_offset) ;
if (!mri_filtered)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate filtered image", Progname) ;
if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW))
fprintf(stderr, "done.\n") ;
if (region.x == 142)
DiagBreak() ;
MRIfree(&mri_offset) ;
}
MRIfree(&mri_filter_dst) ;
if (Gdiag & DIAG_WRITE)
MRIwrite(mri_filtered, "upfilt.mgz") ;
mri_tmp = MRIdownsample2(mri_filtered, NULL) ;
MRIfree(&mri_filtered) ;
if (Gdiag & DIAG_WRITE)
MRIwrite(mri_tmp, "downfilt.mgz") ;
region.x += xborder ;
region.y += yborder ;
region.z += zborder ;
#if 0
region.dx -=2*xborder;
region.dy-= 2*yborder;
region.dz -= 2 * zborder;
#else
region.dx -= xrborder + xborder;
region.dy -= yrborder + yborder;
region.dz -= zrborder + zborder;
#endif
if (region.dx <= 0 || region.dy <= 0 || region.dz <= 0) {
fprintf(stderr, "invalid region: (%d,%d,%d) --> (%d,%d,%d)\n",
region.x,region.y,region.z,region.dx,region.dy,region.dz);
} else
MRIextractIntoRegion(mri_tmp,mri_dst,xborder,yborder,zborder,®ion);
MRIfree(&mri_tmp);
}
}
}
MRIextractIntoRegion(mri_dst,mri_full, 0, 0, 0, &clip_region);
MRIfree(&mri_dst) ;
if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW))
fprintf(stderr, "writing output image %s...", out_fname) ;
MRIwrite(mri_full, out_fname) ;
MRIfree(&mri_full) ;
if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW))
fprintf(stderr, "done.\n") ;
exit(0) ;
return(0) ; /* for ansi */
}
