int match(int s, char *recbuf, char *fldbuf, const char *target, int fld, int nflds, int *index) /* Assume target has been converted to uppercase */ { int i; int found = 0; char *p; p = recbuf; p++; /* skip record deletion marker */ for (i=1; i < fld; i++) /* move to the target field in buffer */ p += fields[i].length; strncpy(fldbuf, p, fields[i].length); /* get the field */ fldbuf[fields[i].length] = '\0'; /* ensure null-terminated */ strupr(fldbuf); /* uppercase it */ if (strstr(fldbuf, target) != NULL) /* substring search for target */ { found = 1; if (output_format == CSOTEXT) { CSO_printrec(s, recbuf, nflds, ++(*index)); usputc(s, 10); } else printrec(s, recbuf, nflds); } return found; }
void main(void) { record r[100]; int i, j; j=readin(r); dasort(r, j); printf("%-25s%-14s%3s\n", "Name", "ID", "Age"); for(i=0; i<j; i++) printrec(r[i]); }
void printrec(scope *scp,int count=0){ if(scp==NULL) return; symmap::iterator it=scp->symtbl.begin(); for (;it!=scp->symtbl.end();it++){ if(it->first.c_str()!=NULL) { int i; if(it->second->kind!=KBLOCK){ for(i=0;i<count;i++) printf("\t"); printf("%s:............\n",it->first.c_str()); } printrec(it->second->desc,count+1); if(it->second->kind!=KVARIABLE && it->second->kind!=KBLOCK){ for(i=0;i<count;i++) printf("\t"); printf("%s:.................over\n",it->first.c_str()); } } //~ printf(".........................................................\n"); } }
int main (int argc, char *argv[]) { FILE *anafp; char in1root[MAXL]; char in2root[MAXL]; char outroot[MAXL]; char imgfile[MAXL]; char program[MAXL], string[MAXL], *ptr; struct dsr hdr; short *img1, *img2, *imgo; int xdim, ydim, zdim, dimension; int img1max = 0, img2max = 0; int img1min = 0, img2min = 0; int swab_img1 = 0, swab_img2 = 0, swab_imgo = 0; char orient, control = '\0'; int nbin = NBIN; int *hist, *mrg1, *mrg2; int histmax = 0; int range1, range2; int binwid1, binwid2; int grid1, grid2; short valmax = 0; float ftmp; int c, i, j, k; /*********/ /* flags */ /*********/ int status = 0; int debug = 0; int do_grid = 1; if (ptr = strrchr (argv[0], '/')) ptr++; else ptr = argv[0]; strcpy (program, ptr); printf ("%s\n", rcsid); /************************/ /* process command line */ /************************/ for (k = 0, i = 1; i < argc; i++) if (*argv[i] == '-') { strcpy (string, argv[i]); ptr = string; while (c = *ptr++) switch (c) { case 'd': debug++; break; case 'g': do_grid = 0; break; case '@': control = *ptr++; *ptr = '\0'; break; case 'r': j = atoi (ptr++); ptr++; /* skip over ":" */ switch (j) { case 1: getrangei (ptr, &img1min, &img1max); break; case 2: getrangei (ptr, &img2min, &img2max); break; default: usage (program); break; } *ptr = '\0'; break; } } else switch (k) { case 0: getroot (argv[i], in1root); k++; break; case 1: getroot (argv[i], in2root); k++; break; case 2: getroot (argv[i], outroot); k++; break; } if (k < 3) usage (program); fprintf (stdout, "img1: %s\nimg2: %s\n", in1root, in2root); sprintf (imgfile, "%s.hdr", in1root); if (!(anafp = fopen (imgfile, "rb")) || fread (&hdr, sizeof (struct dsr), 1, anafp) != 1 || fclose (anafp)) errr (program, imgfile); if (hdr.hk.sizeof_hdr != sizeof (struct dsr)) { printf ("converting %s byte order\n", in1root); swab_hdr (&hdr); swab_img1++; } if (hdr.dime.bitpix != 16) erri (program, imgfile); xdim = hdr.dime.dim[1]; ydim = hdr.dime.dim[2]; zdim = hdr.dime.dim[3]; orient = hdr.hist.orient; dimension = xdim * ydim * zdim; sprintf (imgfile, "%s.hdr", in2root); if (!(anafp = fopen (imgfile, "rb")) || fread (&hdr, sizeof (struct dsr), 1, anafp) != 1 || fclose (anafp)) errr (program, imgfile); if (hdr.hk.sizeof_hdr != sizeof (struct dsr)) { printf ("converting %s byte order\n", in2root); swab_hdr (&hdr); swab_img2++; } if (hdr.dime.bitpix != 16) erri (program, imgfile); if (xdim != hdr.dime.dim[1] || ydim != hdr.dime.dim[2] || zdim != hdr.dime.dim[3] || orient != hdr.hist.orient) { fprintf (stderr, "%s: %s %s dimension/orientation mismatch\n", program, in1root, in2root); exit (-1); } img1 = (short *) malloc (dimension * sizeof (short)); img2 = (short *) malloc (dimension * sizeof (short)); mrg1 = (int *) calloc (nbin, sizeof (int)); mrg2 = (int *) calloc (nbin, sizeof (int)); hist = (int *) calloc (nbin*nbin, sizeof (int)); imgo = (short *) malloc (nbin*nbin * sizeof (short)); if (!img1 || !img2 || !hist || !mrg1 || !mrg2 || !imgo) errm (program); sprintf (imgfile, "%s.img", outroot); startrece (imgfile, argc, argv, rcsid, control); sprintf (imgfile, "%s.img", in1root); catrec (imgfile); printf ("Reading: %s\n", imgfile); if (!(anafp = fopen (imgfile, "rb")) || fread (img1, sizeof (short), dimension, anafp) != dimension || fclose (anafp)) errr (program, imgfile); if (swab_img1) for (i = 0; i < dimension; i++) swab2 ((char *) &img1[i]); sprintf (imgfile, "%s.img", in2root); catrec (imgfile); printf ("Reading: %s\n", imgfile); if (!(anafp = fopen (imgfile, "rb")) || fread (img2, sizeof (short), dimension, anafp) != dimension || fclose (anafp)) errr (program, imgfile); if (swab_img2) for (i = 0; i < dimension; i++) swab2 ((char *) &img2[i]); if (!img1max && !img1min) { img1max -32768; img1min = 32767; for (i = 0; i < dimension; i++) { if (img1[i] > img1max) img1max = img1[i]; if (img1[i] < img1min) img1min = img1[i]; } } else { for (i = 0; i < dimension; i++) { if (img1[i] > img1max) img1[i] = img1max; if (img1[i] < img1min) img1[i] = img1min; } } range1 = img1max - img1min; if (!img2max && !img2min) { img2max -32768; img2min = 32767; for (i = 0; i < dimension; i++) { if (img2[i] > img2max) img2max = img2[i]; if (img2[i] < img2min) img2min = img2[i]; } } else { for (i = 0; i < dimension; i++) { if (img2[i] > img2max) img2[i] = img2max; if (img2[i] < img2min) img2[i] = img2min; } } range2 = img2max - img2min; fprintf (stdout, "img1: min=%6d\tmax=%6d\trange=%6d\n", img1min, img1max, range1); fprintf (stdout, "img2: min=%6d\tmax=%6d\trange=%6d\n", img2min, img2max, range2); sprintf (string, "before auto range adjust\n"); printrec (string); sprintf (string, "img1: min=%6d\tmax=%6d\trange=%6d\n", img1min, img1max, range1); printrec (string); sprintf (string, "img2: min=%6d\tmax=%6d\trange=%6d\n", img2min, img2max, range2); printrec (string); for (i = 0; i < dimension; i++) { k = (nbin * (img1[i] - img1min)) / range1; if (k < nbin && k > 0) mrg1[k]++; k = (nbin * (img2[i] - img2min)) / range2; if (k < nbin && k > 0) mrg2[k]++; } for (k = 2; k < nbin; k++) { mrg1[k] += mrg1[k - 1]; mrg2[k] += mrg2[k - 1]; } if (debug) for (k = 0; k < nbin; k++) { printf ("%6d %10.6f %10.6f\n", k, (float) mrg1[k] / (float) mrg1[nbin - 1], (float) mrg2[k] / (float) mrg2[nbin - 1]); } for (i = 1; i < nbin; i++) if (((float) mrg1[i] / (float) mrg1[nbin - 1]) > CUM_D) break; for (j = 1; j < nbin; j++) if (((float) mrg1[j] / (float) mrg1[nbin - 1]) > 1.0-CUM_D) break; if (debug) printf ("img1: first_bin=%d\tlast_bin=%d\n", i, j); img1min += (float) (range1 * i) / nbin; range1 *= (float) (j - i) / nbin; binwid1 = (float) range1 / nbin; if (!binwid1) binwid1++; range1 = binwid1 * nbin; img1min += binwid1 - (img1min + range1) % binwid1; for (i = 1; i < nbin; i++) if (((float) mrg2[i] / (float) mrg2[nbin - 1]) > CUM_D) break; for (j = 1; j < nbin; j++) if (((float) mrg2[j] / (float) mrg2[nbin - 1]) > 1.0-CUM_D) break; if (debug) printf ("img2: first_bin=%d\tlast_bin=%d\n", i, j); img2min += (float) (range2 * i) / nbin; range2 *= (float) (j - i) / nbin; binwid2 = (float) range2 / nbin; if (!binwid2) binwid2++; range2 = binwid2 * nbin; img2min += binwid2 - (img2min + range2) % binwid2; fprintf (stdout, "img1: min=%6d\tmax=%6d\trange=%6d\tbinwidth=%d\n", img1min, img1min + range1, range1, binwid1); fprintf (stdout, "img2: min=%6d\tmax=%6d\trange=%6d\tbinwidth=%d\n", img2min, img2min + range2, range2, binwid2); sprintf (string, "after auto range adjust\n"); printrec (string); sprintf (string, "img1: min=%6d\tmax=%6d\trange=%6d\tbinwidth=%d\n", img1min, img1min + range1, range1, binwid1); printrec (string); sprintf (string, "img2: min=%6d\tmax=%6d\trange=%6d\tbinwidth=%d\n", img2min, img2min + range2, range2, binwid2); printrec (string); if (!range1 || !range2) exit (-1); for (k = 0; k < dimension; k++) { i = (img1[k] - img1min) / binwid1; j = (img2[k] - img2min) / binwid2; if (i < 0 || i >= nbin || j < 0 || j >= nbin) continue; hist[nbin * j + i]++; if (!hist[nbin * j + i]) { fprintf (stderr, "2Dhist: histogram bin overflow\n"); exit (-1); } if (hist[nbin * j + i] > histmax) histmax = hist[nbin * j + i]; } fprintf (stdout, "maximum bin count=%d\n", histmax); /***************************/ /* write histogram to imgo */ /***************************/ for (k = 0; k < nbin*nbin; k++) { if (hist[k]) { ftmp = 100 * log ((double) hist[k]); imgo[k] = (short) ftmp; } else imgo[k] = 0; if (imgo[k] > valmax) valmax = imgo[k]; } if (do_grid) { grid1 = range1 / 10; grid1 /= 10; grid1 *= 10; for (i = k = 0; i < nbin; k += grid1) { i = (k - img1min) / binwid1; if (i >= 0 && i < nbin) for (j = 0; j < nbin; j++) imgo[nbin * j + i] = valmax / 2; } sprintf (string, "img1: grid interval=%d\n", grid1); printrec (string); grid2 = range2 / 10; grid2 /= 10; grid2 *= 10; for (j = k = 0; j < nbin; k += grid2) { j = (k - img2min) / binwid2; if (j >= 0 && j < nbin) for (i = 0; i < nbin; i++) imgo[nbin * j + i] = valmax / 2; } sprintf (string, "img2: grid interval=%d\n", grid2); printrec (string); } swab_imgo = ((CPU_is_bigendian() != 0) && (control == 'l' || control == 'L')) || ((CPU_is_bigendian() == 0) && (control == 'b' || control == 'B')); if (swab_imgo) for (i = 0; i < nbin*nbin; i++) swab2 ((char *) &imgo[i]); sprintf (imgfile, "%s.img", outroot); fprintf (stdout, "Writing: %s\n", imgfile); if (!(anafp = fopen (imgfile, "wb")) || fwrite (imgo, sizeof (short), nbin*nbin, anafp) != nbin*nbin || fclose (anafp)) errw (program, imgfile); hdr.dime.dim[0] = 2; hdr.dime.dim[1] = nbin; hdr.dime.dim[2] = nbin; hdr.dime.dim[3] = 1; hdr.dime.datatype = 4; hdr.dime.pixdim[1] = 1; hdr.dime.pixdim[2] = 1; hdr.dime.pixdim[3] = 1; hdr.dime.glmax = valmax; hdr.dime.glmin = 0; hdr.hist.orient = 0; if (swab_imgo) swab_hdr (&hdr); sprintf (imgfile, "%s.hdr", outroot); fprintf (stdout, "Writing: %s\n", imgfile); if (!(anafp = fopen (imgfile, "wb")) || fwrite (&hdr, sizeof (struct dsr), 1, anafp) != 1 || fclose (anafp)) errw (program, imgfile); free (img1); free (img2); free (imgo); free (mrg1); free (mrg2); free (hist); endrec (); exit (status); }
common_format *parse_nifti(const char *fFile, char rec_open) { char *header_name = NULL; char mystr[1024]; get_file_name(fFile, &header_name); int header_file = open(header_name, O_RDONLY); int i, j; if (header_file < 0) { fprintf(stderr, "error opening image '%s': %s\n", header_name, strerror(errno)); free(header_name); return NULL; } struct stat file_stats; if (fstat(header_file, &file_stats) != 0) { fprintf(stderr, "error reading image '%s': %s\n", header_name, strerror(errno)); free(header_name); close(header_file); return NULL; } int64_t file_size = file_stats.st_size; int64_t rounded_size = file_size; int64_t page_size = sysconf(_SC_PAGESIZE); if (rounded_size % page_size) rounded_size += page_size + (-rounded_size % page_size); if (file_size < (int)sizeof(header_block)) { fprintf(stderr, "header '%s' is incomplete\n", header_name); free(header_name); close(header_file); return NULL; } void *image_data = mmap(NULL, rounded_size, PROT_READ, MAP_SHARED, header_file, 0x00); //close(header_file); if (!image_data) { fprintf(stderr, "error reading image '%s': %s\n", header_name, strerror(errno)); free(header_name); return NULL; } struct nifti_1_header modified_header; memcpy(&modified_header, image_data, sizeof(struct nifti_1_header)); int flipped = auto_flip(&modified_header); if (modified_header.sizeof_hdr != sizeof(struct nifti_1_header)) { fprintf(stderr, "WARNING: incorrect header '%s', 'sizeof_hdr' is not %i\n", header_name, (int)sizeof(struct nifti_1_header)); } if (modified_header.dim[0] < 3 || modified_header.dim[0] > 7) { fprintf(stderr, "ERROR: unusable header '%s', 'dim[0]' is not in the usable range 3-7\n", header_name); free(header_name); munmap(image_data, rounded_size); return NULL; } if (strcmp(modified_header.magic, "n+1") != 0 ) { fprintf(stderr, "WARNING: incorrect header '%s', 'magic' is not \"n+1\\0\"\n", header_name); } /*if (modified_header.datatype != DT_FLOAT32 || modified_header.bitpix != 32) { fprintf(stderr, "%s: can only convert 32-bit float ('%s')\n", program_name, header_name); fprintf(stderr, "bitpix: %i\n", modified_header.bitpix); free(header_name); close(header_file); return NULL; }*/ common_format *file_content = calloc(1, sizeof(common_format)); if (!file_content) { fprintf(stderr, "allocation error: %s\n", strerror(errno)); free(header_name); munmap(image_data, rounded_size); return NULL; } file_content->is_mmaped = 1;//signifies not malloced file_content->endian = local_endian() ? !flipped : flipped; file_content->f_offset = 0;//file position tracker for eread file_content->file = header_name; file_content->dims = 4; printf("datatype: %i\t bitpix: %i\n", modified_header.datatype, modified_header.bitpix); if (rec_open) { sprintf(mystr, "datatype: %i\t bitpix: %i\n", modified_header.datatype, modified_header.bitpix); printrec(mystr); } switch (modified_header.datatype) { case DT_UINT8: file_content->bperpix = 1; file_content->isFloat = 0; file_content->isSigned = 0; break; case DT_UINT16: file_content->bperpix = 2; file_content->isFloat = 0; file_content->isSigned = 0; break; case DT_UINT32: file_content->bperpix = 4; file_content->isFloat = 0; file_content->isSigned = 0; break; case DT_UINT64: file_content->bperpix = 8; file_content->isFloat = 0; file_content->isSigned = 0; break; case DT_INT8: file_content->bperpix = 1; file_content->isFloat = 0; file_content->isSigned = 1; break; case DT_INT16: file_content->bperpix = 2; file_content->isFloat = 0; file_content->isSigned = 1; break; case DT_INT32: file_content->bperpix = 4; file_content->isFloat = 0; file_content->isSigned = 1; break; case DT_INT64: file_content->bperpix = 8; file_content->isFloat = 0; file_content->isSigned = 1; break; case DT_FLOAT32: file_content->bperpix = 4; file_content->isFloat = 1; file_content->isSigned = 1; break; case DT_FLOAT64: file_content->bperpix = 8; file_content->isFloat = 1; file_content->isSigned = 1; break; case DT_FLOAT128: file_content->bperpix = 16; file_content->isFloat = 1; file_content->isSigned = 1; break; default: fprintf(stderr, "datatype unsupported ('%s'), value: %i\n", file_content->file, modified_header.datatype); free(header_name); munmap(image_data, rounded_size); free(file_content); return NULL; }; if (modified_header.bitpix != 8 * file_content->bperpix) { fprintf(stderr, "bitpix and datatype do not match ('%s'), using dataype\n", file_content->file); } file_content->scale = modified_header.scl_slope; file_content->offset = modified_header.scl_inter; if (file_content->scale == 0.0)/* its in nifti1.h, wasn't my idea */ { file_content->scale = 1.0; file_content->offset = 0.0; } if (rec_open) { sprintf(mystr, "scale: %f\t offset: %f\n", file_content->scale, file_content->offset); printrec(mystr); } file_content->length[0] = modified_header.dim[1 + 0]; file_content->length[1] = modified_header.dim[1 + 1]; file_content->length[2] = modified_header.dim[1 + 2]; file_content->length[3] = modified_header.dim[1 + 3]; if (modified_header.dim[0] >= 5 && modified_header.dim[1 + 4]) file_content->length[3] *= modified_header.dim[1 + 4]; if (modified_header.dim[0] >= 6 && modified_header.dim[1 + 5]) file_content->length[3] *= modified_header.dim[1 + 5]; if (modified_header.dim[0] >= 7 && modified_header.dim[1 + 6]) file_content->length[3] *= modified_header.dim[1 + 6]; if (file_content->length[3] != modified_header.dim[1 + 3]) { fprintf(stderr, "merging additional dimmensions with time ('%s')\n", file_content->file); if (rec_open) { printrec("additional dimensions merged with time\n"); } } if (file_content->length[3] == 0) file_content->length[3] = 1; const vindex axes[4] = AXES_NII; memcpy(file_content->order, axes, sizeof file_content->order); file_content->size = 1; if (file_content->length[ file_content->order[0] ]) file_content->size *= file_content->length[ file_content->order[0] ]; if (file_content->length[ file_content->order[1] ]) file_content->size *= file_content->length[ file_content->order[1] ]; if (file_content->length[ file_content->order[2] ]) file_content->size *= file_content->length[ file_content->order[2] ]; if (file_content->length[ file_content->order[3] ]) file_content->size *= file_content->length[ file_content->order[3] ]; if ((int) modified_header.vox_offset < (int)sizeof(header_block)) { fprintf(stderr, "WARNING: incorrect header '%s', 'vox_offset' is less than 352\nrecalculating by file size...\n", header_name); modified_header.vox_offset = file_size - (file_content->size) * (file_content->bperpix); } if (modified_header.vox_offset < 348 || file_size < file_content->size * file_content->bperpix + modified_header.vox_offset) { fprintf(stderr, "file length is too short for specified dimensions\n"); free(header_name); munmap(image_data, rounded_size); free(file_content); return NULL; } file_content->voxels = image_data + (int) modified_header.vox_offset; file_content->mmap_offset = (int)modified_header.vox_offset; for (i = 0; i < 3; ++i) for (j = 0; j < 4; ++j) file_content->sform[i][j] = 0.0; file_content->haveCenter = 1; if ( modified_header.sform_code ) {/* prefer sform, due to simplicity */ for (i = 0; i < 4; ++i) { file_content->sform[0][i] = modified_header.srow_x[i]; file_content->sform[1][i] = modified_header.srow_y[i]; file_content->sform[2][i] = modified_header.srow_z[i]; } /* sanity check pixdim against sform, because FSL can use both in flirt */ const float TOLERANCE = 0.999f; for (i = 0; i < 3; ++i) { float calcspace = 0.0f; for (j = 0; j < 3; ++j) { calcspace += file_content->sform[j][i] * file_content->sform[j][i]; } calcspace = sqrt(calcspace); float headerspace = modified_header.pixdim[i + 1]; if (calcspace != headerspace && (calcspace == 0.0f || headerspace == 0.0f || calcspace / headerspace < TOLERANCE || headerspace / calcspace < TOLERANCE)) { fprintf(stderr, "WARNING: nifti pixdims do not match sform, other software (FSL) may interpret this volume differently.\n"); if (rec_open) { printrec("nifti pixdim and sform mismatch!"); } } } } else { if (modified_header.qform_code) {/* quaternions may be compact for rotation, but conceptually obtuse, and ugly to convert, and requires separate scale (when constrained to magnitude 1) and offset */ double b = modified_header.quatern_b, c = modified_header.quatern_c, d = modified_header.quatern_d; double a = sqrt(1.0 - (b * b + c * c + d * d));/* given implementation uses 10 floats instead of 12, so it has questionable value */ if (a != a || a > 1.0 || a < 0.0) a = 0.0;/* make sure a isn't NaN or something equally bad */ file_content->sform[0][0] = a * a + b * b - c * c - d * d;/* TODO: try to find a more elegant way to convert this */ file_content->sform[0][1] = 2 * b * c - 2 * a * d;/* formulas copypasted from nifti1.h */ file_content->sform[0][2] = 2 * b * d + 2 * a * c;/* reused products could be precalculated, but left alone for what remains of clarity */ file_content->sform[1][0] = 2 * b * c + 2 * a * d; file_content->sform[1][1] = a * a + c * c - b * b - d * d; file_content->sform[1][2] = 2 * c * d - 2 * a * b; file_content->sform[2][0] = 2 * b * d - 2 * a * c; file_content->sform[2][1] = 2 * c * d + 2 * a * b; file_content->sform[2][2] = a * a + d * d - c * c - b * b;/* rotation matrix complete */ if (rec_open) { sprintf(mystr, "qform: %12.6f\t%12.6f\t%12.6f\t%12.6f\n", a, b, c, d); printrec(mystr); sprintf(mystr, "qfac: %12.6f\n", modified_header.pixdim[0] < 0.0 ? -1.0f : 1.0f); printrec(mystr); sprintf(mystr, "pixdim: %12.6f\t%12.6f\t%12.6f\n", modified_header.pixdim[1], modified_header.pixdim[2], modified_header.pixdim[3]); printrec(mystr); sprintf(mystr, "qoffset: %12.6f\t%12.6f\t%12.6f\n", modified_header.qoffset_x, modified_header.qoffset_y, modified_header.qoffset_z); printrec(mystr); } /* quaternion does pixdim[] and qfac (pixdim[0]) first, then rotate (R), then qoffset */ if (modified_header.pixdim[0] < 0.0) modified_header.pixdim[3] = -modified_header.pixdim[3];/* read nifti1.h:1005 for yourself, i can't make this stuff up */ /* quaternions can't encode an axis handedness shift (maybe with a negative real component), so they use a float as a boolean and make it a special case */ for (i = 0; i < 4; ++i) { file_content->sform[i][0] *= modified_header.pixdim[1]; file_content->sform[i][1] *= modified_header.pixdim[2]; file_content->sform[i][2] *= modified_header.pixdim[3]; } file_content->sform[0][3] = modified_header.qoffset_x; file_content->sform[1][3] = modified_header.qoffset_y; file_content->sform[2][3] = modified_header.qoffset_z; } else {/* do it the originless, analyze 7.5 way */ file_content->sform[0][0] = modified_header.pixdim[1]; file_content->sform[1][1] = modified_header.pixdim[2]; file_content->sform[2][2] = modified_header.pixdim[3]; file_content->haveCenter = 0; printrec("no origin information, spacing only\n"); } } for (i = 0; i < 3; ++i) { for (j = 0; j < 4; ++j) { if (file_content->sform[i][j] != file_content->sform[i][j]) { file_content->sform[i][j] = 0.0;/* set NaNs to zero */ } } } /* rec file */ for (i = 0; i < 3; ++i) { printf("common:\t%f\t%f\t%f\t%f\n", file_content->sform[i][0], file_content->sform[i][1], file_content->sform[i][2], file_content->sform[i][3]); if (rec_open) { sprintf(mystr, "common sform[%i]: %12.6f\t%12.6f\t%12.6f\t%12.6f\n", i, file_content->sform[i][0], file_content->sform[i][1], file_content->sform[i][2], file_content->sform[i][3]); printrec(mystr); } } return file_content; }
void print(){ printrec(godscope); }
ostream& ppsig::print (ostream& fout) const { int i; double r; Tree c, sel, x, y, z, u, var, le, label, id, ff, largs, type, name, file; if ( isList(sig) ) { printlist(fout, sig); } else if ( isProj(sig, &i, x) ) { fout << "proj" << i << '(' << ppsig(x, fEnv) << ')'; } else if ( isRec(sig, var, le) ) { printrec(fout, var, le, fHideRecursion /*&& (getRecursivness(sig)==0)*/ ); } // debruinj notation else if ( isRec(sig, le) ) { printrec(fout, le, fHideRecursion ); } else if ( isRef(sig, i) ) { fout << "REF[" << i << "]"; } else if ( getUserData(sig) ) { printextended(fout, sig); } else if ( isSigInt(sig, &i) ) { fout << i; } else if ( isSigReal(sig, &r) ) { fout << T(r); } else if ( isSigWaveform(sig) ) { fout << "waveform{...}"; } else if ( isSigInput(sig, &i) ) { fout << "IN[" << i << "]"; } else if ( isSigOutput(sig, &i, x) ) { printout(fout, i, x) ; } else if ( isSigDelay1(sig, x) ) { fout << ppsig(x, fEnv, 9) << "'"; } //else if ( isSigFixDelay(sig, x, y) ) { printinfix(fout, "@", 8, x, y); } else if ( isSigFixDelay(sig, x, y) ) { printFixDelay(fout, x, y); } else if ( isSigPrefix(sig, x, y) ) { printfun(fout, "prefix", x, y); } else if ( isSigIota(sig, x) ) { printfun(fout, "iota", x); } else if ( isSigBinOp(sig, &i, x, y) ) { printinfix(fout, gBinOpTable[i]->fName, gBinOpTable[i]->fPriority, x, y); } else if ( isSigFFun(sig, ff, largs) ) { printff(fout, ff, largs); } else if ( isSigFConst(sig, type, name, file) ) { fout << tree2str(name); } else if ( isSigFVar(sig, type, name, file) ) { fout << tree2str(name); } else if ( isSigTable(sig, id, x, y) ) { printfun(fout, "TABLE", x, y); } else if ( isSigWRTbl(sig, id, x, y, z) ) { printfun(fout, "write", x, y, z); } else if ( isSigRDTbl(sig, x, y) ) { printfun(fout, "read", x, y); } else if ( isSigGen(sig, x) ) { fout << ppsig(x, fEnv, fPriority); } else if ( isSigDocConstantTbl(sig, x, y) ) { printfun(fout, "docConstantTbl", x, y); } else if ( isSigDocWriteTbl(sig, x, y, z, u) ) { printfun(fout, "docWriteTbl", x, y, z, u); } else if ( isSigDocAccessTbl(sig, x, y) ) { printfun(fout, "docAccessTbl", x, y); } else if ( isSigSelect2(sig, sel, x, y) ) { printfun(fout, "select2", sel, x, y); } else if ( isSigSelect3(sig, sel, x, y, z) ) { printfun(fout, "select3", sel, x, y, z); } else if ( isSigIntCast(sig, x) ) { printfun(fout, "int", x); } else if ( isSigFloatCast(sig, x) ) { printfun(fout, "float", x); } else if ( isSigButton(sig, label) ) { printui(fout, "button", label); } else if ( isSigCheckbox(sig, label) ) { printui(fout, "checkbox", label); } else if ( isSigVSlider(sig, label,c,x,y,z) ) { printui(fout, "vslider", label, c, x, y, z); } else if ( isSigHSlider(sig, label,c,x,y,z) ) { printui(fout, "hslider", label, c, x, y, z); } else if ( isSigNumEntry(sig, label,c,x,y,z) ) { printui(fout, "nentry", label, c, x, y, z); } else if ( isSigVBargraph(sig, label,x,y,z) ) { printui(fout, "vbargraph", label, x, y, z); } else if ( isSigHBargraph(sig, label,x,y,z) ) { printui(fout, "hbargraph", label, x, y, z); } else if ( isSigAttach(sig, x, y) ) { printfun(fout, "attach", x, y); } else { cerr << "NOT A SIGNAL : " << *sig << endl; //exit(1); } return fout; }
int main (int argc, char *argv[]) { FILE *imgfp, *datfp; char imgroot[MAXL], imgfile[MAXL], gfcfile[MAXL], ifhfile[MAXL]; char outroot[MAXL], outfile[MAXL], datfile[MAXL], volfile[MAXL], recfile[MAXL]; char program[MAXL], string[MAXL], command[MAXL], *ptr; int isbig; char control = '\0'; IFH ifh; UCHAR ix, iy, iz; XYZN xyzn; int iv, iv0, jv, imgdim[3]; int ir, jr, nn; int c, i, j, k, m, n; double dela, delg, u1; float vmin, vmax, fwhm = 0., alpha = ALPHA, *img_orig=NULL; float maxfac = 0.0; /**************/ /* gain field */ /**************/ int norder = NORDER, nterm = NTERM; int niter = 0, limiter = LIMITER; int eight = 8; /* field length for call to powstring_ () */ float a[NTERM], /* polynomial coefficients */ a0[NTERM]; float drms, diffcrit = DIFFCRIT; float u1gfc[MAXR]; double sum0, sum, q, t; /*********/ /* flags */ /*********/ int test = 0; int status = 0; int debug = 0; int gfreeze = 0; int verbose = 0; int negdef = 0; if (!(ptr = strrchr (argv[0], '/'))) ptr = argv[0]; else ptr++; strcpy (program, ptr); /************************/ /* process command line */ /************************/ for (k = 0, i = 1; i < argc; i++) if (*argv[i] == '-') { strcpy (string, argv[i]); ptr = string; while (c = *ptr++) switch (c) { case 'v': verbose++; break; case 'n': negdef++; break; case 'g': gfreeze++; break; case '@': control = *ptr++; *ptr = '\0'; break; case 'b': g_bandwidth = atof (ptr); *ptr = '\0'; break; case 'p': fwhm = atof (ptr); *ptr = '\0'; break; case 'e': diffcrit = atof (ptr); *ptr = '\0'; break; case 'i': g_sigma = atof (ptr); *ptr = '\0'; break; case 'l': limiter = atoi (ptr); *ptr = '\0'; break; case 'm': g_mr = atoi (ptr); *ptr = '\0'; break; case 's': g_sconst = atof (ptr); *ptr = '\0'; break; case 'z': g_zthresh = atof (ptr); *ptr = '\0'; break; case 'M': maxfac = atof (ptr); *ptr = '\0'; break; case 'r': getrange (ptr, &g_gfc_thresh, &g_gfc_ceil); *ptr = '\0'; break; } } else switch (k) { case 0: getroot (argv[i], imgroot); k++; break; } if (k < 1) { fprintf (stderr, "Usage:\t%s <imgroot>\n", program); fprintf (stderr, " e.g.,\t%s vc1440_mpr_n4_111_t88.4dfp\n", program); /*??*/ fprintf (stderr, "\toption\n"); fprintf (stderr, "\t-g freeze initial gain field\n"); fprintf (stderr, "\t-n force negative definite quadratic gain field\n"); fprintf (stderr, "\t-v verbose mode\n"); fprintf (stderr, "\t-p<flt> pre-blur by specified FWHM in mm\n"); fprintf (stderr, "\t-b<flt>\tspecify bandwidth in intensity units (default=%.1f)\n", BANDWIDTH); fprintf (stderr, "\t-e<flt>\tspecify drms convergence criterion (default=%f)\n", DIFFCRIT); fprintf (stderr, "\t-i<flt>\tspecify sigma (default=%f)\n", SIGMA); fprintf (stderr, "\t-l<int>\tspecify iteration limit (default=%d)\n", LIMITER); fprintf (stderr, "\t-m<flt>\tspecify gfc computation region count (default=%d)\n", MR); fprintf (stderr, "\t-s<flt>\tspecify space constant in mm (default=%f)\n", SCONST); fprintf (stderr, "\t-z<flt>\tspecify background threshold (default=%.1f)\n", ZTHRESH); fprintf (stderr, "\t-M<flt>\tspecify maximum correction factor\n"); fprintf (stderr, "\t-r<flt>[to<flt>]\tspecify gfc range (default=%.1fto%.1f)\n", GFC_THRESH, GFC_CEIL); exit (1); } /*******************************************/ /* read/initialize gain field coefficients */ /*******************************************/ sprintf (gfcfile, "%s.4dfp.gfc", imgroot); if (imgfp = fopen (gfcfile, "r")) { printf ("Reading: %s\n", gfcfile); for (k = 0; k < nterm; k++) fscanf (imgfp, "%f", a + k); fclose (imgfp); } else { a[0] = 1.0; for (k = 1; k < nterm; k++) a[k] = 0.0; } for (k = 0; k < nterm; k++) fprintf (stdout, "%8.4f", a[k]); fprintf (stdout, "\n"); /******************************/ /* get input image dimensions */ /******************************/ if (Getifh (imgroot, &ifh) != 0) errr (program, imgroot); isbig = strcmp (ifh.imagedata_byte_order, "littleendian"); if (!control) control = (isbig) ? 'b' : 'l'; for (k = 0; k < 3; k++) g_voxdim[k] = ifh.scaling_factor[k]; if (debug) printf ("%10.6f%10.6f%10.6f\n", g_voxdim[0], g_voxdim[1], g_voxdim[2]); g_dimension = ((g_xdim = ifh.matrix_size[0]) *(g_ydim = ifh.matrix_size[1]) *(g_zdim = ifh.matrix_size[2])); /************************************************/ /* check image index limits against XYZN typedef */ /*************************************************/ if (g_xdim > MAXD || g_ydim > MAXD || g_zdim > MAXD) { fprintf (stderr, "%s: %s dimension exceeds %d\n", program, imgroot, MAXD); exit (-1); } if (ifh.number_of_bytes_per_pixel != 4) { printf ("%s: cannot process %d bytes per pixel", program, ifh.number_of_bytes_per_pixel); exit (-1); } /************/ /* allocate */ /************/ if (!(g_img1 = (float *) malloc (g_dimension * sizeof (float))) || !(g_img0 = (float *) malloc (g_dimension * sizeof (float))) || !(g_imgg = (float *) malloc (g_dimension * sizeof (float))) || !(g_imgo = (short *) calloc (g_dimension, sizeof (short))) || !(g_imgb = (UCHAR *) calloc (g_dimension, sizeof (UCHAR)))) errm (program); sprintf (imgfile, "%s.4dfp.img", imgroot); printf ("Reading: %s\n", imgfile); if (!(imgfp = fopen (imgfile, "rb")) || eread (g_img0, g_dimension, isbig, imgfp) || fclose (imgfp)) errr (program, imgfile); /******************/ /* pre-blur image */ /******************/ if (!gfreeze && fwhm > 0) { if (!(img_orig = (float *) malloc (g_dimension * sizeof (float)))) errm (program); /*************************************/ /* img_orig will hold original image */ /*************************************/ memcpy (img_orig, g_img0, g_dimension*sizeof(float)); memcpy (g_img1, g_img0, g_dimension*sizeof(float)); printf ("blur FWHM = %.2f mm\n", fwhm); imgdim[0] = g_xdim; imgdim[1] = g_ydim; imgdim[2] = g_zdim; imgblur3d_ (&fwhm, &alpha, g_voxdim, g_img1, imgdim, g_img0); /* g_img1 returned unusable */ /************************************************************************/ /* g_img0 now points to blurred image to be used in further computation */ /************************************************************************/ } /*******************/ /* compute outroot */ /*******************/ if (ptr = strrchr (imgroot, '/')) ptr++; else ptr = imgroot; getroot (ptr, outroot); /*********************/ /* apply initial gfc */ /*********************/ evalgain3d_ (g_imgg, &g_xdim, &g_ydim, &g_zdim, &norder, a); for (sum = sum0 = i = 0; i < g_dimension; i++) { sum0 += g_img0[i]; sum += (g_img1[i] = g_img0[i]/g_imgg[i]); } for (i = 0; i < g_dimension; i++) g_img1[i] *= (sum0/sum); if (gfreeze) goto WRITE; /****************/ /* open datfile */ /****************/ sprintf (datfile, "%s_gfc.dat", outroot); if (!(datfp = fopen (datfile, "a"))) errw (program, datfile); powstring_ (&norder, &eight, string); fprintf (datfp, "#\t%s\n", string); fprintf (datfp, "%d\t", niter); for (k = 0; k < nterm; k++) fprintf (datfp, "%8.4f", a[k]); fprintf (datfp, "%8.4f\n", 0.0); fflush (datfp); /***********************/ /* clear region buffer */ /***********************/ memset (&g_region, '\0', MAXR * sizeof (REGION)); iv0 = ir = 0; /***************************/ /* find contiguous regions */ /***************************/ CONTIG: while (ir < MAXR) { for (iv = iv0; iv < g_dimension; iv++) if (!g_imgo[iv]) break; if (iv == g_dimension) break; iv0 = iv; g_imgo[iv] = ir + 1; g_region[ir].u1 = (floor (g_img1[iv] / g_bandwidth) + 0.5) * g_bandwidth; k = iv; j = g_dimension; j /= g_zdim; iz = k / j; k -= iz * j; j /= g_ydim; iy = k / j; k -= iy * j; j /= g_xdim; ix = k / j; k -= ix * j; xyzn.ix = ix; xyzn.iy = iy; xyzn.iz = iz; xyzn.nn = 0; assign (ir, xyzn); do { m = g_region[ir].ne++; iv = g_region[ir].xyzn[m].ix + g_xdim*(g_region[ir].xyzn[m].iy + g_ydim*g_region[ir].xyzn[m].iz); for (j = 0; j < 6; j++) { xyzn = g_region[ir].xyzn[m]; switch (j) { case 0: k = -1; if (xyzn.ix < 1) continue; xyzn.ix--; break; case 1: k *= -1; if (xyzn.ix > g_xdim - 2) continue; xyzn.ix++; break; case 2: k *= -g_xdim; if (xyzn.iy < 1) continue; xyzn.iy--; break; case 3: k *= -1; if (xyzn.iy > g_ydim - 2) continue; xyzn.iy++; break; case 4: k *= -g_ydim; if (xyzn.iz < 1) continue; xyzn.iz--; break; case 5: k *= -1; if (xyzn.iz > g_zdim - 2) continue; xyzn.iz++; break; } jv = iv + k; if (g_imgo[jv] || g_img0[jv] < g_zthresh) continue; dela = g_img1[jv] - g_region[ir].u1; if (fabs (dela) < 0.5 * g_bandwidth) { g_imgo[jv] = ir + 1; assign (ir, xyzn); } } if (verbose && !(g_region[ir].count % 1000)) { xyzn = g_region[ir].xyzn[m]; printf ("checkr0: region=%4d unexa=%8d coords=%4d%4d%4d u1=%8.2f\n", ir, g_region[ir].count - m, xyzn.ix, xyzn.iy, xyzn.iz, g_region[ir].u1); } } while (g_region[ir].count > g_region[ir].ne); if (g_region[ir].count == 1) { iv = g_region[ir].xyzn[0].ix + g_xdim*(g_region[ir].xyzn[0].iy + g_ydim*g_region[ir].xyzn[0].iz); g_imgo[iv] = -1; g_region[ir].count = g_region[ir].ne = 0; } else { ir++; } } /************************/ /* sort regions by size */ /************************/ qsort ((void *) g_region, ir, sizeof (REGION), rcompare); if (ir == MAXR) { if (verbose) printf ("ir %d -> %d iv0=%10d ivmax=%d\n", ir, MAXR/2, iv0, g_dimension); while (--ir > MAXR/2) { for (m = 0; m < g_region[ir].count; m++) { xyzn = g_region[ir].xyzn[m]; iv = xyzn.ix + g_xdim*(xyzn.iy + g_ydim*xyzn.iz); g_imgo[iv] = 0; } g_region[ir].count = g_region[ir].ne = 0; } goto CONTIG; } g_nr = ir; for (ir = g_nr; ir < MAXR; ir++) if (g_region[ir].xyzn) free (g_region[ir].xyzn); test = 1; ITER: getmean (); /* analyze g_img1 */ getxyzn0 (); /* analyze g_img1 */ /********************/ /* reassign regions */ /********************/ for (i = 0; i < g_dimension; i++) g_imgo[i] = 0; printf ("total number of regions %d\n", g_nr); for (ir = 0; ir < g_nr; ir++) { g_region[ir].ne = g_region[ir].count = 0; if (g_region[ir].u1 < g_gfc_thresh || g_region[ir].u1 > g_gfc_ceil) continue; assign (ir, g_region[ir].xyzn0); do { m = g_region[ir].ne++; xyzn = g_region[ir].xyzn[m]; iv = xyzn.ix + g_xdim*(xyzn.iy + g_ydim*xyzn.iz); for (j = 0; j < 6; j++) { xyzn = g_region[ir].xyzn[m]; switch (j) { case 0: k = -1; if (xyzn.ix < 1) continue; xyzn.ix--; break; case 1: k *= -1; if (xyzn.ix > g_xdim - 2) continue; xyzn.ix++; break; case 2: k *= -g_xdim; if (xyzn.iy < 1) continue; xyzn.iy--; break; case 3: k *= -1; if (xyzn.iy > g_ydim - 2) continue; xyzn.iy++; break; case 4: k *= -g_ydim; if (xyzn.iz < 1) continue; xyzn.iz--; break; case 5: k *= -1; if (xyzn.iz > g_zdim - 2) continue; xyzn.iz++; break; } jv = iv + k; if (g_imgo[jv] || g_img0[jv] < g_zthresh) continue; dela = g_img1[jv] - g_region[ir].u1; delg = g_sconst * (g_img1[jv] - g_img1[iv]) / g_voxdim[j/2]; if (sqrt (dela*dela + delg*delg) < g_sigma*g_bandwidth) { g_imgo[jv] = ir + 1; assign (ir, xyzn); } } if (verbose && !(g_region[ir].count % 1000)) { xyzn = g_region[ir].xyzn[m]; printf ("checkr1: region=%4d unexa=%8d coords=%4d%4d%4d u1=%8.2f\n", ir, g_region[ir].count - m, xyzn.ix, xyzn.iy, xyzn.iz, g_region[ir].u1); } } while (g_region[ir].count > g_region[ir].ne); } getmean (); getxyzn0 (); /* analyze g_img1 */ listreg (stdout); if (g_region[0].u1 < g_bandwidth) { fprintf (stderr, "%s: algorithmic failure\n", program); exit (-1); } if (++niter > limiter || !test) goto COUNT; fprintf (stdout, "%s: iteration %d\n", program, niter); /***************/ /* compute gfc */ /***************/ for (ir = 0; ir < g_nr; ir++) u1gfc[ir] = g_region[ir].u1; for (k = 0; k < nterm; k++) a0[k] = a[k]; fitgain3dd_ (g_img0, &g_xdim, &g_ydim, &g_zdim, g_imgo, u1gfc, &g_mr, &norder, a, &drms); if (negdef) fnegdef_ (a); printf ("niter=%d drms=%.6f diffcrit=%.6f\n", niter, drms, diffcrit); fprintf (datfp, "%d\t", niter); for (k = 0; k < nterm; k++) fprintf (datfp, "%8.4f", a[k]); fprintf (datfp, "%8.4f\n", 100*drms); fflush (datfp); evalgain3d_ (g_imgg, &g_xdim, &g_ydim, &g_zdim, &norder, a); for (sum = i = 0; i < g_dimension; i++) sum += (g_img1[i] = g_img0[i]/g_imgg[i]); for ( i = 0; i < g_dimension; i++) g_img1[i] *= (sum0/sum); /********************/ /* convergence test */ /********************/ test = (drms > diffcrit); goto ITER; COUNT: fclose (datfp); /*******************/ /* count neighbors */ /*******************/ for (ir = 0; ir < g_nr; ir++) { for (g_nl = m = 0; m < g_region[ir].count; m++) { ix = g_region[ir].xyzn[m].ix; iy = g_region[ir].xyzn[m].iy; iz = g_region[ir].xyzn[m].iz; iv = ix + g_xdim*(iy + g_ydim*iz); nn = 0; k = -1; if (ix > 0) {if ((j = g_imgo[iv + k]) == ir + 1) nn++; else enter (j);} k *= -1; if (ix < g_xdim - 1) {if ((j = g_imgo[iv + k]) == ir + 1) nn++; else enter (j);} k *= -g_xdim; if (iy > 0) {if ((j = g_imgo[iv + k]) == ir + 1) nn++; else enter (j);} k *= -1; if (iy < g_ydim - 1) {if ((j = g_imgo[iv + k]) == ir + 1) nn++; else enter (j);} k *= -g_ydim; if (iz > 0) {if ((j = g_imgo[iv + k]) == ir + 1) nn++; else enter (j);} k *= -1; if (iz < g_zdim - 1) {if ((j = g_imgo[iv + k]) == ir + 1) nn++; else enter (j);} if (nn > g_region[ir].nnmax) g_region[ir].nnmax = nn; g_imgb[iv] = g_region[ir].xyzn[m].nn = nn; } if (verbose) { printf ("%5d%10d%10d%5d%2d |", ir, g_region[ir].count, k, j, g_region[ir].nnmax); for (i = 0; i < g_nl; i++) printf (" %d", g_list[i]); printf ("\n"); } } /*********************************/ /* write gain field coefficients */ /*********************************/ if (!(imgfp = fopen (gfcfile, "w"))) errw (program, gfcfile); printf ("Writing: %s\n", gfcfile); for (k = 0; k < nterm; k++) fprintf (imgfp, "%8.4f", a[k]); fprintf (imgfp, "\n"); fclose (imgfp); /*************************/ /* write corrected image */ /*************************/ WRITE: for (sum0 = sum = i = 0; i < g_dimension; i++) { if (!gfreeze && fwhm > 0) g_img0[i] = img_orig[i]; sum0 += g_img0[i]; q = 1./g_imgg[i]; t = (maxfac > 0.0) ? 2.*maxfac*tanh(.5*q/maxfac) : q; if (0) printf ("%10.6f %10.6f\n", q, t); sum += (g_img1[i] = g_img0[i]*t); } for (i = 0; i < g_dimension; i++) g_img1[i] *= (sum0/sum); vmin = FLT_MAX; vmax = -vmin; for (i = 0; i < g_dimension; i++) { if (g_img1[i] < vmin) vmin = g_img1[i]; if (g_img1[i] > vmax) vmax = g_img1[i]; } sprintf (outfile, "%s_gfc.4dfp.img", outroot); fprintf (stdout, "Writing: %s\n", outfile); if (!(imgfp = fopen (outfile, "wb")) || ewrite (g_img1, g_dimension, control, imgfp) || fclose (imgfp)) errw (program, outfile); /***************/ /* ifh and hdr */ /***************/ sprintf (ifhfile, "%s_gfc.4dfp.ifh", outroot); if (Writeifh (program, ifhfile, &ifh, control)) errw (program, ifhfile); sprintf (command, "ifh2hdr %s -r%.0f", ifhfile, vmax); system (command); /*******/ /* rec */ /*******/ startrece (outfile, argc, argv, g_rcsid, control); sprintf (string, "%s gain field coefficients\n", imgroot); printrec (string); powstring_ (&norder, &eight, string); printrec (string); for (k = 0; k < nterm; k++) {sprintf (string, "%8.4f", a[k]); printrec (string);} printrec ("\n"); if (!gfreeze) { sprintf (recfile, "%s_gfc.4dfp.img.rec", outroot); if (!(imgfp = fopen (recfile, "a"))) errw (program, recfile); listreg (imgfp); fclose (imgfp); } catrec (imgfile); endrec (); if (gfreeze) goto FREE; /*************************/ /* compute regions image */ /*************************/ for (i = 0; i < g_dimension; i++) g_img1[i] = 0; for (ir = 0; ir < g_mr; ir++) { for (m = 0; m < g_region[ir].count; m++) { xyzn = g_region[ir].xyzn[m]; iv = xyzn.ix + g_xdim*(xyzn.iy + g_ydim*xyzn.iz); g_img1[iv] = g_region[ir].u1; } } /******************************/ /* write processing QA images */ /******************************/ sprintf (volfile, "%s_gfc_vols.4dfp.img", outroot); printf ("Writing: %s\n", volfile); if (!(imgfp = fopen (volfile, "w"))) errw (program, volfile); /*****************/ /* regions image */ /*****************/ if (ewrite (g_img1, g_dimension, control, imgfp)) errw (program, volfile); /****************/ /* border image */ /****************/ for (i = 0; i < g_dimension; i++) g_img1[i] = g_imgb[i]; if (ewrite (g_img1, g_dimension, control, imgfp)) errw (program, volfile); /**************/ /* gain field */ /**************/ for (i = 0; i < g_dimension; i++) g_img1[i] = g_imgg[i]; if (ewrite (g_img1, g_dimension, control, imgfp)) errw (program, volfile); fclose (imgfp); /***************/ /* ifh and hdr */ /***************/ sprintf (ifhfile, "%s_gfc_vols.4dfp.ifh", outroot); ifh.matrix_size[3] = 3; if (Writeifh (program, ifhfile, &ifh, control)) errw (program, ifhfile); sprintf (string, "ifh2hdr %s -r%.0f", ifhfile, vmax); system (string); /*******/ /* rec */ /*******/ startrece (volfile, argc, argv, g_rcsid, control); sprintf (string, "%s_gfc QA (3 volumes)\n", imgroot); printrec (string); catrec (outfile); printrec ("Volume 1: regions\nVolume 2: border\nVolume 3: gain field\n"); endrec (); /************/ /* clean up */ /************/ FREE: free (g_img1); free (g_img0); free (g_imgg); free (g_imgo); free (g_imgb); if (img_orig) free (img_orig); for (ir = 0; ir < g_nr; ir++) free (g_region[ir].xyzn); exit (status); }
int main (int argc, char *argv[]) { FILE *fp; IFH ifh; char imgroot[2][MAXR][MAXL], Nmgroot[2][MAXL], lstfile[2][MAXL]; int nimg[2], isbig[2][MAXR], isbigN[2]; int orient, orient1, imgdim[4], imgdim1[4], dimension, vdim; char outroot[MAXL] = "", imgfile[MAXL], outfile[MAXL]; float voxdim[3], voxdim1[3]; float amin = FLT_MAX, amax = -FLT_MAX; float *img1, **imgN; double **imgs, **imgv; int **imgm, ngroup; char control = '\0'; /***********/ /* utility */ /***********/ double u; int c, i, j, k, m; char *ptr, *str, command[MAXL]; char *srgv[MAXL]; /* string field pointers */ /*********/ /* flags */ /*********/ int defined; int debug = 0; int NaN_flag = 'E'; /* 'E' 1.e-37; 'Z' 0.0; 'N' NaN; */ int status = 0; int saverec = 1; printf ("%s\n", rcsid); setprog (program, argv); /************************/ /* process command line */ /************************/ k = 0; for (i = 1; i < argc; i++) { if (*argv[i] == '-') { strcpy (command, argv[i]); ptr = command; while (c = *ptr++) switch (c) { case 'R': saverec = 0; break; case 'd': debug++; break; case 'o': getroot (ptr, outroot); *ptr = '\0'; break; case '@': control = *ptr++; *ptr = '\0'; break; } } else switch (k) { case 0: strcpy (lstfile[0], argv[i]); k++; break; case 1: getroot (argv[i], Nmgroot[0]); k++; break; case 2: strcpy (lstfile[1], argv[i]); k++; break; case 3: getroot (argv[i], Nmgroot[1]); k++; break; } } if (k != 2 && k != 4) usage (); ngroup = k/2; /********************/ /* parse list files */ /********************/ for (k = 0; k < ngroup; k++) { nimg[k] = 0; if (!(fp = fopen (lstfile[k], "r"))) errr (program, lstfile[k]); printf ("Reading: %s\n", lstfile[k]); while (fgets (command, MAXL, fp)) { if (nimg[k] >= MAXR) { fprintf (stderr, "%s: maximum number of input images (%d) exceeded\n", program, MAXR); exit (-1); } if (ptr = strchr (command, '#')) *ptr = '\0'; if (!strlen (command)) continue; /* skip blank lines */ if (ptr = strchr (command, '\n')) *ptr = '\0'; /* strip terminal nl */ i = m = 0; while (m < MAXL && i < MAXL) { while (!isgraph ((int) command[i]) && command[i]) i++; if (!command[i]) break; srgv[m++] = command + i; while (isgraph ((int) command[i])) i++; if (!command[i]) break; command[i++] = '\0'; } getroot (srgv[0], imgroot[k][nimg[k]++]); } fclose (fp); if (!nimg[k]) usage (); /*********************************/ /* check dimensional consistency */ /*********************************/ for (i = 0; i < nimg[k]; i++) { printf ("image %3d: %s\n", i + 1, imgroot[k][i]); if (!i && !k) { if (get_4dfp_dimoe (imgroot[k][i], imgdim, voxdim, &orient, isbig[k] + i)) exit (-1); if (Getifh (imgroot[k][i], &ifh)) errr (program, imgroot[k][i]); } else { if (get_4dfp_dimoe (imgroot[k][i], imgdim1, voxdim1, &orient1, isbig[k] + i)) exit (-1); status = (orient1 != orient); for (j = 0; j < 4; j++) status |= (imgdim1[j] != imgdim[j]); for (j = 0; j < 3; j++) status |= (fabs (voxdim1[j] - voxdim[j]) > 1.e-4); } if (status) { fprintf (stderr, "%s: %s %s dimension mismatch\n", program, imgroot[0][0], imgroot[k][i]); exit (-1); } } if (get_4dfp_dimoe (Nmgroot[k], imgdim1, voxdim1, &orient1, isbigN + k)) exit (-1); status = (orient1 != orient); for (j = 0; j < 3; j++) status |= (imgdim1[j] != imgdim[j]); for (j = 0; j < 3; j++) status |= (fabs (voxdim1[j] - voxdim[j]) > 1.e-4); if (status) { fprintf (stderr, "%s: %s %s dimension mismatch\n", program, imgroot[0][0], Nmgroot[k]); exit (-1); } } if (!control) control = (isbig[0][0]) ? 'b' : 'l'; vdim = imgdim[0]*imgdim[1]*imgdim[2]; dimension = vdim*imgdim[3]; if (!(img1 = (float *) calloc (dimension, sizeof (float)))) errm (program); imgv = calloc_double2 (ngroup, dimension); /* variance accumulator */ imgs = calloc_double2 (ngroup, dimension); /* sum accumulator */ imgm = calloc_int2 (ngroup, dimension); /* voxel counter */ imgN = calloc_float2 (ngroup, vdim); /* input N image */ for (k = 0; k < ngroup; k++) { /****************/ /* read N image */ /****************/ printf ("Reading: %s\n", Nmgroot[k]); sprintf (imgfile, "%s.4dfp.img", Nmgroot[k]); if (!(fp = fopen (imgfile, "rb")) || eread (imgN[k], vdim, isbigN[k], fp) || fclose (fp)) errr (program, imgfile); /**********************************/ /* read and accumulate image data */ /**********************************/ for (j = 0; j < nimg[k]; j++) { printf ("Reading: %s\n", imgroot[k][j]); sprintf (imgfile, "%s.4dfp.img", imgroot[k][j]); if (!(fp = fopen (imgfile, "rb")) || eread (img1, dimension, isbig[k][j], fp) || fclose (fp)) errr (program, imgfile); for (i = 0; i < dimension; i++) { defined = isnormal (img1[i]) && img1[i] != (float) 1.e-37; if (!defined) continue; imgm[k][i]++; imgs[k][i] += img1[i]; imgv[k][i] += img1[i]*img1[i]; } } for (i = 0; i < dimension; i++) { u = (imgs[k][i] /= imgm[k][i]); imgv[k][i] -= u*u*imgm[k][i]; if (imgv[k][i] < 0.0) imgv[k][i] = 0.0; imgv[k][i] /= (imgm[k][i] - 1); } /***************************************/ /* divide variance estimate by N image */ /***************************************/ for (i = 0; i < vdim; i++) if (imgN[k][i]) for (j = 0; j < imgdim[3]; j++) { imgv[k][j*vdim + i] /= imgN[k][i]; } } /***************************************************************************/ /* compute voxelwize t statistic (Welch's approximate t' when ngroup == 2) */ /***************************************************************************/ for (i = 0; i < dimension; i++) { if (ngroup == 2) { imgs[0][i] -= imgs[1][i]; imgv[0][i] += imgv[1][i]; } if (isnormal (imgs[0][i]) && isnormal (imgv[0][i])) { img1[i] = imgs[0][i] / sqrt (imgv[0][i]); if (img1[i] > amax) amax = img1[i]; if (img1[i] < amin) amin = img1[i]; } else switch (NaN_flag) { case 'Z': img1[i] = 0.0; break; case 'E': img1[i] = (float) 1.e-37; break; case 'N': img1[i] = rnan (); break; } } if (!strlen (outroot)) { /*******************/ /* compute outroot */ /*******************/ strcpy (command, lstfile[0]); if (!(ptr = strrchr (command, '/'))) ptr = command; else ptr++; if (str = strrchr (ptr, '.')) *str = '\0'; sprintf (outroot, "RFX_%s", ptr); if (ngroup == 2) { strcat (outroot, "_vs_"); strcpy (command, lstfile[1]); if (!(ptr = strrchr (command, '/'))) ptr = command; else ptr++; if (str = strrchr (ptr, '.')) *str = '\0'; strcat (outroot, ptr); } strcat (outroot, "_tmap"); } sprintf (outfile, "%s.4dfp.img", outroot); /****************/ /* write result */ /****************/ printf ("Writing: %s\n", outfile); if (!(fp = fopen (outfile, "wb")) || ewrite (img1, dimension, control, fp) || fclose (fp)) errw (program, outfile); /*******/ /* ifh */ /*******/ Writeifh (program, outfile, &ifh, control); /*******/ /* hdr */ /*******/ sprintf (command, "ifh2hdr %s -r%.0fto%.0f", outroot, amin, amax); printf ("%s\n", command); status |= system (command); /*******/ /* rec */ /*******/ startrecle (outfile, argc, argv, rcsid, control); for (k = 0; k < ngroup; k++) { sprintf (command, "imglist %d\n", k + 1); printrec (command); catrec (lstfile[k]); printrec ("endimglist\n"); if (saverec) { sprintf (imgfile, "%s.4dfp.img", Nmgroot[k]); catrec (imgfile); for (j = 0; j < nimg[k]; j++) { sprintf (imgfile, "%s.4dfp.img", imgroot[k][j]); catrec (imgfile); } } } endrec (); free (img1); free_double2 (imgs); free_double2 (imgv); free_int2 (imgm); free_float2 (imgN); exit (status); }
int main (int argc, char *argv[]) { /************/ /* 4dfp I/O */ /************/ FILE *fp_img, *fp_out; IFH ifh; char outfile[MAXL], imgfile[MAXL]; char imgroot[MAXL], outroot[MAXL] = ""; char control = '\0'; /****************/ /* image arrays */ /****************/ float *img1, *imgc; float voxdim[3]; int imgdim[4], outdim[4], ix, iy, iz, index, vdim, isbig; int ix0 = 1, ix1 = 0, iy0 = 1, iy1 = 0, iz0 = 1, iz1 = 0; int vdim_crop, orient; /***********/ /* utility */ /***********/ int c, i, j, k; char *ptr, string[MAXL]; /*********/ /* flags */ /*********/ int doflip = 0; int docrop = 1; int scrollx = 0, scrolly = 0, scrollz = 0; printf ("%s\n", rcsid); setprog (program, argv); /************************/ /* process command line */ /************************/ for (k = 0, i = 1; i < argc; i++) { if (*argv[i] == '-') { strcpy (string, argv[i]); ptr = string; while (c = *ptr++) switch (c) { case 'f': doflip++; break; case 'Z': docrop = 0; break; case '@': control = *ptr++; *ptr = '\0'; break; case 'x': getirange (ptr, &ix0, &ix1); *ptr = '\0'; break; case 'y': getirange (ptr, &iy0, &iy1); *ptr = '\0'; break; case 'z': getirange (ptr, &iz0, &iz1); *ptr = '\0'; break; case 's': switch (*ptr++) { case 'x': scrollx = atoi (ptr); break; case 'y': scrolly = atoi (ptr); break; case 'z': scrollz = atoi (ptr); break; } *ptr = '\0'; break; } } else switch (k) { case 0: getroot (argv[i], imgroot); k++; break; case 1: getroot (argv[i], outroot); k++; break; } } if (k < 1) { printf ("Usage:\t%s <(4dfp) inroot> [(4dfp) outroot]\n", program); printf ("\toption\n"); printf ("\t-<x|y|z><int>[to[<int>]\tspecify x y z crop limits\n"); printf ("\t-s<x|y|z><int>\tscroll specified axis by specified number of pixels\n"); printf ("\t-f\tinterpret specifications under 4dfp<->analyze flips\n"); printf ("\t-Z\tzero voxels instead of physically cropping\n"); printf ("\t-@<b|l>\toutput big or little endian (default input endian)\n"); printf ("N.B.:\tcrop limit indices count from 1\n"); printf ("N.B.:\tscrolling is done after cropping\n"); printf ("N.B.:\tdefault (4dfp) output root is <(4dfp) inroot>\"_crop\"\n"); exit (1); } sprintf (imgfile, "%s.4dfp.img", imgroot); if (get_4dfp_dimoe (imgfile, imgdim, voxdim, &orient, &isbig) < 0 || Getifh (imgfile, &ifh)) errr (program, imgfile); if (!control) control = (isbig) ? 'b' : 'l'; printf ("input dimensions %10d%10d%10d%10d\n", imgdim[0], imgdim[1], imgdim[2], imgdim[3]); printf ("voxel dimensions %10.6f%10.6f%10.6f\n", voxdim[0], voxdim[1], voxdim[2]); if (ix1 > imgdim[0] || ix1 < 1) ix1 = imgdim[0]; if (iy1 > imgdim[1] || iy1 < 1) iy1 = imgdim[1]; if (iz1 > imgdim[2] || iz1 < 1) iz1 = imgdim[2]; if (ix0 > imgdim[0] || ix0 < 1) ix0 = 1; if (iy0 > imgdim[1] || iy0 < 1) iy0 = 1; if (iz0 > imgdim[2] || iz0 < 1) iz0 = 1; if (ix1 < ix0) {k = ix1; ix1 = ix0; ix0 = k;} if (iy1 < iy0) {k = iy1; iy1 = iy0; iy0 = k;} if (iz1 < iz0) {k = iz1; iz1 = iz0; iz0 = k;} printf ("crop limits x %3d to %3d\n", ix0, ix1); printf ("crop limits y %3d to %3d\n", iy0, iy1); printf ("crop limits z %3d to %3d\n", iz0, iz1); printf ("scroll x %3d\n", scrollx); printf ("scroll y %3d\n", scrolly); printf ("scroll z %3d\n", scrollz); outdim[0] = (docrop) ? ix1 - ix0 + 1 : imgdim[0]; outdim[1] = (docrop) ? iy1 - iy0 + 1 : imgdim[1]; outdim[2] = (docrop) ? iz1 - iz0 + 1 : imgdim[2]; outdim[3] = imgdim[3]; printf ("output dimensions %10d%10d%10d%10d\n", outdim[0], outdim[1], outdim[2], outdim[3]); vdim = imgdim[0] * imgdim[1] * imgdim[2]; if (!(img1 = (float *) malloc (vdim * sizeof (float)))) errm (program); if (!(fp_img = fopen (imgfile, "rb"))) errr (program, imgfile); printf ("Reading: %s\n", imgfile); if (!strlen (outroot)) sprintf (outroot, "%s_crop", imgroot); sprintf (outfile, "%s.4dfp.img", outroot); vdim_crop = outdim[0] * outdim[1] * outdim[2]; if (!(imgc = (float *) calloc (vdim_crop, sizeof (float)))) errm (program); if (!(fp_out = fopen (outfile, "wb"))) errw (program, outfile); printf ("Writing: %s\n", outfile); /***********/ /* process */ /***********/ printf ("processing volume"); for (k = 0; k < imgdim[3]; k++) {printf (" %d", k + 1); fflush (stdout); if (eread (img1, vdim, isbig, fp_img)) errr (program, imgfile); if (doflip) { if (x4dfp2analyze (img1, imgdim, ifh.orientation)) { fprintf (stderr, "%s: invalid %s orientation\n", program, imgroot); exit (-1); } } i = 0; for (iz = iz0 - 1; iz < iz1; iz++) { for (iy = iy0 - 1; iy < iy1; iy++) { for (ix = ix0 - 1; ix < ix1; ix++) { index = ix + imgdim[0]*(iy + imgdim[1]*iz); if (docrop) { imgc[i++] = img1[index]; } else { imgc[index] = img1[index]; } }}} if (scrollx) xscroll (img1, imgc, outdim, scrollx); if (scrolly) yscroll (img1, imgc, outdim, scrolly); if (scrollz) zscroll (img1, imgc, outdim, scrollz); if (doflip) x4dfp2analyze (imgc, outdim, ifh.orientation); if (ewrite (imgc, vdim_crop, control, fp_out)) errw (program, outfile); } printf ("\n"); fflush (stdout); fclose (fp_img); fclose (fp_out); /**************/ /* output ifh */ /**************/ if (docrop) { if (writeifhe (program, outroot, outdim, voxdim, ifh.orientation, control)) errw (program, outroot); } else { Writeifh (program, outroot, &ifh, control); } /***************/ /* run ifh2hdr */ /***************/ sprintf (string, "ifh2hdr %s", outroot); status |= system (string); /************/ /* rec file */ /************/ startrece (outfile, argc, argv, rcsid, control); if (doflip) printrec ("indices subjected to 4dfp<->analyze orientation dependent flips\n"); if (!docrop) printrec ("voxels zeroed instead of physically cropped\n"); sprintf (string, "crop limits x %3d to %3d\n", ix0, ix1); printrec (string); sprintf (string, "crop limits y %3d to %3d\n", iy0, iy1); printrec (string); sprintf (string, "crop limits z %3d to %3d\n", iz0, iz1); printrec (string); if (scrollx) {sprintf (string, "scroll x %3d\n", scrollx); printrec (string);} if (scrolly) {sprintf (string, "scroll y %3d\n", scrolly); printrec (string);} if (scrollz) {sprintf (string, "scroll z %3d\n", scrollz); printrec (string);} catrec (imgfile); endrec (); /************/ /* clean up */ /************/ free (img1); free (imgc); exit (status); }
int main (int argc, char *argv[]) { char ecatspec[MAXL], ecatname[MAXL]; char imgroot[MAXL], imgname[MAXL]; FILE *fptr; struct Matval matval; MatrixFile *mptr; MatrixData *matrix; MatDirNode *entry, **entries; Image_subheader *ih; float global_max, global_min; int volume, plane, line, nframes, iframe, jframe, matnum, *missing, nmissing; float scale_factor, calibration_factor/*, scan_time*/; int cubic = CUBIC; float *img; short *ecat; int i, j, k; char string[MAXL], *ptr, c; char control = '\0'; int isbig; IFH ifh; setprog (program, argv); for (j = 0, i = 1; i < argc; i++) if (*argv[i] == '-') { strncpy (string, argv[i], MAXL); ptr = string; while (c = *ptr++) switch (c) { case '@': control = *ptr++; *ptr = '\0'; break; } } else switch (j) { case 0: strncpy (ecatspec, argv[i], MAXL); j++; break; case 1: getroot (argv[i], imgroot); j++; break; } if (j != 2) { fprintf (stderr, "Usage:\t%s <ecat> <(4dfp)image>\n", program); fprintf (stderr, "\t-@<b|l>\toutput big or little endian (default input endian)\n"); exit (1); } /******** Get filenames and open ********/ matspec (ecatspec, ecatname, &matnum); /* matnum is unused */ if (!(mptr = matrix_open (ecatname, MAT_READ_ONLY, MAT_UNKNOWN_FTYPE))) { fprintf (stderr, "%s: cannot open %s as an ECAT image file\n", program, ecatname); exit (-1); } if (mptr->mhptr->file_type != InterfileImage && mptr->mhptr->file_type != PetImage && mptr->mhptr->file_type != PetVolume && mptr->mhptr->file_type != ByteImage && mptr->mhptr->file_type != ByteVolume) { fprintf (stderr, "%s: filetype not supported\n", program); exit (-1); } sprintf (imgname, "%s.4dfp.img", imgroot); if (!(fptr = fopen (imgname, "w"))) errw (program, imgname); if (!control) control = (CPU_is_bigendian ()) ? 'b' : 'l'; calibration_factor = mptr->mhptr->calibration_factor; fprintf (stdout, "Calibration Factor := %10e\n", calibration_factor); if (!(missing = (int *) calloc (mptr->mhptr->num_frames, sizeof (int))) || !(entries = (MatDirNode **) malloc (mptr->mhptr->num_frames * sizeof (MatDirNode *)))) errm (program); sprintf (string, "%s.4dfp.img.rec", imgroot); startrece (string, argc, argv, rcsid, control); printrec ("Frame \t Length\t Midpoint\t Start\t Frame_Min\t Frame_Max\t Decay_Fac\tEcat_Frame\n"); for (nframes = 0, entry = mptr->dirlist->first; entry; entry = entry->next) entries[nframes++] = entry; qsort (entries, nframes, sizeof (MatDirNode *), frame_cmp); for (iframe = 1, jframe = 0, nmissing = 0/*, scan_time = 0*/; jframe < nframes; iframe++, jframe++) { entry = entries[jframe]; mat_numdoc (entry->matnum, &matval); while (iframe < matval.frame) { fprintf (stderr, "%s: %s frame %d not included\n", program, ecatname, iframe); missing[nmissing++] = iframe++; } if (!(matrix = load_volume (mptr, matval.frame, cubic))) { fprintf (stderr, "%s: ecat frame %d not found\n", program, matval.frame); exit (-1); } if ( matrix->data_type != SunShort && matrix->data_type != VAX_Ix2) { fprintf (stderr, "%s: only integer 2 images are currently supported\n", program); exit(-1); } scale_factor = matrix->scale_factor * calibration_factor; /* fprintf (stdout, "Scale Factor := %10e\tTotal Factor := %10e\n", matrix->scale_factor, scale_factor); */ if (jframe == 0) { ifh.scaling_factor[0] = ifh.scaling_factor[1] = 10 * matrix->pixel_size; ifh.scaling_factor[2] = 10 * matrix->z_size; ifh.matrix_size[0] = matrix->xdim; ifh.matrix_size[1] = matrix->ydim; ifh.matrix_size[2] = matrix->zdim; line = ifh.matrix_size[0]; plane = ifh.matrix_size[1] * line; volume = ifh.matrix_size[2] * plane; if (!(img = (float *) malloc (volume * sizeof (float)))) errm (program); global_min = matrix->data_min; global_max = matrix->data_max; } else { if (matrix->data_min < global_min) global_min = matrix->data_min; if (matrix->data_max > global_max) global_max = matrix->data_max; } /******** Flip Z, and write to output file ********/ ecat = (short *) matrix->data_ptr; for (i = volume-plane; i >= 0; i -= plane) /* for (j = 0; j < plane; j += line) for (k = 0; k < line; k++, ecat++) img[i+j+k] = (*ecat) * scale_factor; */ for (j = 0; j < plane; j++, ecat++) img[i+j] = (*ecat) * scale_factor; if (ewrite (img, volume, control, fptr)) errw (program, imgname); ih = (Image_subheader*) matrix->shptr; sprintf (string, "Frame_%-4d\t%10d\t%10.2f\t%10d\t%10d\t%10d\t%10.5f\t%10d\n", jframe+1, ih->frame_duration, (ih->frame_start_time + ih->frame_duration / 2.0) / 1000/*scan_time += ih->frame_duration / 1000*/, ih->frame_start_time, ih->image_min, ih->image_max, ih->decay_corr_fctr, iframe); printrec (string); } sprintf (string, "%s Missing Frames:", ecatname); printrec (string); for (i = 0; i < nmissing; i++) { sprintf (string, " %d", missing[i]); printrec (string); } printrec ("\n"); endrec (); /******** Write ifh, hdr, and rec files ********/ ifh.matrix_size[3] = nframes; ifh.orientation = TRANSVERSE; sprintf (string, "%s.4dfp.ifh", imgroot); if (writeifhe (program, string, ifh.matrix_size, ifh.scaling_factor, ifh.orientation, control)) errw (program, string); sprintf (string, "ifh2hdr %s -r%fto%f", imgroot, global_min, global_max); system (string); /******** Free, close and quit ********/ matrix_close (mptr); fclose (fptr); free (img); exit (0); }
int main (int argc, char *argv[]) { /*******/ /* i/o */ /*******/ FILE *fpimg, *fpout; IFH ifh; struct dsr hdr; /* ANALYZE hdr */ char imgroot[MAXL], imgfile[MAXL], outfile[MAXL]; char trailer[8] = ".4dint"; /****************/ /* image arrays */ /****************/ float *imgf, cscale = 1.0; short int *imgi=NULL; unsigned char *imgu=NULL; float voxsiz[3]; int imgdim[4], vdim, orient, isbig; int imin = 32767, imax = -32768; char control = '\0'; short int origin[3]; /* used in SPM99 conversions */ /***********/ /* utility */ /***********/ int c, i, j, k; char *str, command[MAXL], program[MAXL]; /*********/ /* flags */ /*********/ int uchar = 0; int debug = 0; int spm99 = 0; int swab_flag = 0; fprintf (stdout, "%s\n", rcsid); setprog (program, argv); /************************/ /* process command line */ /************************/ for (k = 0, i = 1; i < argc; i++) { if (*argv[i] == '-') { strcpy (command, argv[i]); str = command; while ((c = *str++)) switch (c) { case '8': uchar++; strcpy (trailer, "_8bit"); break; case 'd': debug++; break; case 'c': cscale = atof (str); *str = '\0'; break; case 'S': if (!strcmp (str, "PM99")) spm99++; *str = '\0'; break; case '@': control = *str++; *str = '\0'; break; } } else switch (k) { case 0: getroot (argv[i], imgroot); k++; break; } } if (k < 1) { printf ("Usage:\t%s <(4dfp) filename>\n", program); printf ("\toption\n"); printf ("\t-c<flt>\tscale output values by specified factor\n"); printf ("\t-8\toutput 8 bit unsigned char\n"); printf ("\t-SPM99\tinclude origin and scale in hdr (http:/wideman-one.com/gw/brain/analyze/format.doc)\n"); printf ("\t-@<b|l>\toutput big or little endian (default CPU endian)\n"); exit (1); } /*****************************/ /* get input 4dfp dimensions */ /*****************************/ if (get_4dfp_dimoe (imgroot, imgdim, voxsiz, &orient, &isbig)) errr (program, imgroot); vdim = imgdim[0] * imgdim[1] * imgdim[2]; if (uchar) { if (!(imgu = (unsigned char *) malloc (vdim * sizeof (char)))) errm (program); } else { if (!(imgi = (short *) malloc (vdim * sizeof (short)))) errm (program); } if (!(imgf = (float *) malloc (vdim * sizeof (float)))) errm (program); /*************************/ /* open input and output */ /*************************/ sprintf (imgfile, "%s.4dfp.img", imgroot); printf ("Reading: %s\n", imgfile); if (!(fpimg = fopen (imgfile, "rb"))) errr (program, imgfile); sprintf (outfile, "%s%s.img", imgroot, trailer); if (!(fpout = fopen (outfile, "wb"))) errw (program, outfile); printf ("Writing: %s\n", outfile); /**********************/ /* process all frames */ /**********************/ for (k = 0; k < imgdim[3]; k++) { if (eread (imgf, vdim, isbig, fpimg)) errr (program, imgfile); switch (orient) { case 4: flipx (imgf, imgdim + 0, imgdim + 1, imgdim + 2); /* sagittal */ case 3: flipz (imgf, imgdim + 0, imgdim + 1, imgdim + 2); /* coronal */ case 2: flipy (imgf, imgdim + 0, imgdim + 1, imgdim + 2); /* transverse */ break; default: fprintf (stderr, "%s: %s image orientation not recognized\n", program, imgfile); exit (-1); break; } for (i = 0; i < vdim; i++) { j = nint (cscale*imgf[i]); if (debug) printf ("%10.6f%10d\n", imgf[i], j); if (uchar) { if (j < 0) j = 0; if (j > 255) j = 255; imgu[i] = j; } else { imgi[i] = j; } if (j > imax) imax = j; if (j < imin) imin = j; } if (uchar) { if (fwrite ( imgu, sizeof (char), vdim, fpout) != vdim) errw (program, outfile); } else { if (gwrite ((char *) imgi, sizeof (short), vdim, fpout, control)) errw (program, outfile); } } fclose (fpimg); fclose (fpout); /**************************/ /* create ANALYZE 7.5 hdr */ /**************************/ Inithdr (&hdr, imgdim, voxsiz, ""); if (uchar) { hdr.dime.datatype = 2; /* unsigned char */ hdr.dime.bitpix = 8; } else { hdr.dime.datatype = 4; /* signed integer */ hdr.dime.bitpix = 16; } hdr.dime.glmax = imax; hdr.dime.glmin = imin; hdr.hist.orient = orient - 2; swab_flag = ((CPU_is_bigendian() != 0) && (control == 'l' || control == 'L')) || ((CPU_is_bigendian() == 0) && (control == 'b' || control == 'B')); if (spm99) { if (Getifh (imgroot, &ifh)) errr (program, imgroot); for (i = 0; i < 3; i++) origin[i] = 0.4999 + ifh.center[i]/ifh.mmppix[i]; /*************************************************/ /* flip 4dfp->analyze assuming transverse orient */ /*************************************************/ origin[1] = imgdim[1] + 1 - origin[1]; /*******************************************************************/ /* origin field officially text and so not affected by swab_hdr () */ /*******************************************************************/ if (swab_flag) for (i = 0; i < 3; i++) swab2 ((char *) (origin + i)); memcpy ((char *) &hdr + 253, (char *) origin, 3*sizeof (short int)); memcpy ((char *) &hdr + 112, (char *) &cscale, sizeof (float)); hdr.hk.extents = 0; } if (swab_flag) swab_hdr (&hdr); sprintf (outfile, "%s%s.hdr", imgroot, trailer); printf ("Writing: %s\n", outfile); if (!(fpout = fopen (outfile, "wb")) || fwrite (&hdr, sizeof (struct dsr), 1, fpout) != 1 || fclose (fpout)) errw (program, outfile); /*******************/ /* create rec file */ /*******************/ sprintf (outfile, "%s%s.img", imgroot, trailer); startrece (outfile, argc, argv, rcsid, control); sprintf (command, "Voxel values scaled by %f\n", cscale); printrec (command); catrec (imgfile); endrec (); free (imgf); if (uchar) { free (imgu); } else { free (imgi); } exit (0); }