void TabDialog::apply() { // min und max in gray value table if (strlen(VNewString(tablemin->text()))>0 && strlen(VNewString(tablemax->text()))>0) { float ymax = (float)selImage->maxwert; float ymin = (float)selImage->minwert; float ymaxmin = (float)(ymax - ymin); float min1 = atof(strtok(VNewString(tablemin->text())," ")); float max1 = atof(strtok(VNewString(tablemax->text())," ")); if (min1 > max1) { tablemin->setText(tr("%1").arg(selImage->minwert1)); tablemax->setText(tr("%1").arg(selImage->maxwert1)); } else { selImage->anamean = min1; selImage->anaalpha = (float)255.0/(max1 - selImage->anamean); int newbrig = (int)rint(stretch*(ymin - selImage->anamean + (ymaxmin - 255.0/selImage->anaalpha)/2.0)/ymaxmin); int newhell = (int)rint(log(selImage->anaalpha*ymaxmin/255.0)/log(stretchfact)); if ((newbrig>=-100 && newbrig<=100) && (newhell>=-100 && newhell<=100)) { brig->setValue(newbrig); hell->setValue(newhell); } else { brig->setEnabled( FALSE ); hell->setEnabled( FALSE ); lbrigbr->setEnabled( FALSE ); lwhit->setEnabled( FALSE ); } setMinMaxValue(); emit newColtype(); } } else { tablemin->setText(tr("%1").arg(selImage->minwert1)); tablemax->setText(tr("%1").arg(selImage->maxwert1)); } emit newColtype(); }
VBoolean VExtractAttr (VAttrList list, VStringConst name, VDictEntry *dict, VRepnKind repn, VPointer value, VBooleanPromoted required) { VAttrListPosn posn; /* If the attribute is in the list... */ if (VLookupAttr (list, name, & posn)) { if (value) { /* Get its value: */ if (! VGetAttrValue (& posn, dict, repn, value)) { VWarning ("VExtractAttr: %s attribute has bad value", name); return FALSE; } /* Clone or hide the value if we're about to delete it: */ if (repn == VStringRepn) * (VString *) value = VNewString (* (VString *) value); } /* Remove it from the list: */ VDeleteAttr (& posn); return TRUE; } /* Otherwise complain if the attribute was a required one: */ if (required) VWarning ("VExtractAttr: %s attribute missing", name); return ! required; }
static void LoadHelpFile (void) { FILE *f; size_t len, incr; Topic *topic; char buf[100]; ntopics = 0; topics = topic = VMalloc (sizeof (Topic) * maxTopics); if (! (f = fopen (helpFilename, "r"))) { VWarning ("Unable to open help database %s", helpFilename); ntopics = 1; topic->topic = "(No help topics)"; topic->text = "(No help text)"; topic->len = strlen (topic->text); return; } do { fgets (buf, sizeof (buf), f); } while (! feof (f) && buf[0] != '@'); while (! feof (f) && ntopics < maxTopics) { len = strlen (buf); if (buf[len - 1] == '\n') buf[len - 1] = 0; topic->topic = VNewString (buf + 1); topic->text = NULL; len = 0; while (1) { fgets (buf, sizeof (buf), f); if (feof (f) || buf[0] == '@') break; incr = strlen (buf); topic->text = VRealloc ((XtPointer) topic->text, len + incr + 1); strcpy (topic->text + len, buf); len += incr; } while (len > 0 && isspace (topic->text[len - 1])) len--; topic->text[len] = 0; topic->len = len; ntopics++; topic++; } fclose (f); }
VRepnKind VRegisterType (VStringConst name, VTypeMethods *methods) { VRepnInfoRec *p; /* Move the existing type information into a bigger table: */ if (VRepnInfo == builtin_repn_info) { VRepnInfo = VMalloc ((VNRepnKinds + 1) * sizeof (VRepnInfoRec)); memcpy(VRepnInfo, builtin_repn_info, VNRepnKinds * sizeof (VRepnInfoRec)); } else VRepnInfo = VRealloc (VRepnInfo, (nRepnKinds + 1) * sizeof (VRepnInfoRec)); /* Write the new type's info into the last table entry: */ p = VRepnInfo + nRepnKinds; p->name = VNewString (name); p->size = p->precision = p->min_value = p->max_value = 0.0; p->methods = methods; return nRepnKinds++; }
VAttrList GetListInfo(VString in_filename, ListInfo *linfo) { VAttrList list = NULL; VAttrListPosn posn; FILE *in_file = NULL; VString str, voxel = NULL; VRepnKind repn = VShortRepn; int ntimesteps, nrows, ncols; int id, j, itr, found, nobject, nbands; VImageInfo *imageInfo = NULL; in_file = VOpenInputFile(in_filename, TRUE); if(!in_file) VError("error opening file %s", in_filename); if(! ReadHeader(in_file)) VError("error reading header"); if(!(list = ReadAttrList(in_file))) VError("error reading attr list"); j = 0; for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) { j++; } imageInfo = (VImageInfo *) VMalloc(sizeof(VImageInfo) * (j + 1)); itr = ntimesteps = nrows = ncols = 0; nobject = nbands = found = id = 0; for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) { str = VGetAttrName(&posn); if(strncmp(str, "history", 7) == 0) { nobject++; continue; } VImageInfoIni(&imageInfo[nbands]); if(! VGetImageInfo(in_file, list, nobject, &imageInfo[nbands])) VError(" error reading image info"); linfo->ntimesteps = linfo->nrows = linfo->ncols = 0; if(imageInfo[nbands].repn == VShortRepn) { found = 1; repn = imageInfo[nbands].repn; if(imageInfo[nbands].nbands > ntimesteps) ntimesteps = imageInfo[nbands].nbands; if(imageInfo[nbands].nrows > nrows) nrows = imageInfo[nbands].nrows; if(imageInfo[nbands].ncolumns > ncols) ncols = imageInfo[nbands].ncolumns; if(voxel == NULL) voxel = imageInfo[nbands].voxel; /* check if slice contains non-zero data */ linfo->zero[nbands] = 1; if(imageInfo[nbands].nrows < 2) linfo->zero[nbands] = 0; linfo->info[id] = imageInfo[nbands]; itr = imageInfo[nbands].repetition_time; id++; nbands++; } nobject++; } fclose(in_file); if(!found) VError(" couldn't find functional data"); linfo->ntimesteps = ntimesteps; linfo->nrows = nrows; linfo->ncols = ncols; linfo->nslices = id; linfo->itr = itr; linfo->repn = repn; linfo->voxel = voxel; linfo->filename = VNewString(in_filename); return list; }
int main(int argc, char *argv[]) { static VArgVector in_files; static VString out_filename; static VString filename; static VShort minval = 0; static VFloat fwhm = 4.0; static VOptionDescRec options[] = { {"in", VStringRepn, 0, & in_files, VRequiredOpt, NULL, "Input files" }, {"out", VStringRepn, 1, & out_filename, VRequiredOpt, NULL, "Output file" }, {"design", VStringRepn, 1, (VPointer) &filename, VRequiredOpt, NULL, "Design file"}, { "fwhm", VFloatRepn, 1, (VPointer) &fwhm, VOptionalOpt, NULL, "FWHM of temporal Gaussian filter in seconds" }, {"minval", VShortRepn, 1, (VPointer) &minval, VOptionalOpt, NULL, "Signal threshold"} }; FILE *fp = NULL, *f = NULL; VStringConst in_filename; VString ifilename; VAttrList list = NULL, list1 = NULL; VAttrList out_list = NULL, history_list = NULL; VAttrListPosn posn; VImage design = NULL; ListInfo *linfo; VLong itr = 0; VFloat sigma = 0, tr = 0; int i, n, nimages; char prg_name[100]; char ver[100]; getLipsiaVersion(ver, sizeof(ver)); sprintf(prg_name, "vcolorglm V%s", ver); fprintf(stderr, "%s\n", prg_name); /* ** parse command line */ if(! VParseCommand(VNumber(options), options, & argc, argv)) { VReportUsage(argv[0], VNumber(options), options, NULL); exit(EXIT_FAILURE); } if(argc > 1) { VReportBadArgs(argc, argv); exit(EXIT_FAILURE); } /* ** read design matrix */ fp = VOpenInputFile(filename, TRUE); list1 = VReadFile(fp, NULL); if(! list1) VError("Error reading design file"); fclose(fp); n = 0; for(VFirstAttr(list1, & posn); VAttrExists(& posn); VNextAttr(& posn)) { if(VGetAttrRepn(& posn) != VImageRepn) continue; VGetAttrValue(& posn, NULL, VImageRepn, & design); if(VPixelRepn(design) != VFloatRepn /* && VPixelRepn(design) != VDoubleRepn */) continue; n++; break; } if(n == 0) VError(" design matrix not found "); /* ** get pre-coloring info */ if(VGetAttr(VImageAttrList(design), "repetition_time", NULL, VLongRepn, &itr) != VAttrFound) VError(" TR info missing in header"); tr = (float) itr / 1000.0; sigma = 0; if(tr > 0.001 && fwhm > 0.001) { fprintf(stderr, " TR: %.3f seconds\n", tr); sigma = fwhm / 2.35482; sigma /= tr; if(sigma < 0.1) { VWarning(" 'fwhm/sigma' too small (%.3f / %.3f), will be set to zero", fwhm, sigma); sigma = 0; } } /* ** Read each input file */ nimages = in_files.number; linfo = (ListInfo *) VMalloc(sizeof(ListInfo) * nimages); for(i = 0; i < nimages; i++) { in_filename = ((VStringConst *) in_files.vector)[i]; ifilename = VNewString(in_filename); fprintf(stderr, " file: %s\n", ifilename); list = GetListInfo(ifilename, &linfo[i]); /* Create history */ if(i == 0) { history_list = VReadHistory(&list); if(history_list == NULL) history_list = VCreateAttrList(); VPrependHistory(VNumber(options), options, prg_name, &history_list); } } /* ** GLM */ out_list = VRegression(linfo, nimages, minval, design, sigma, itr); /* ** Output: */ VPrependAttr(out_list, "history", NULL, VAttrListRepn, history_list); f = VOpenOutputFile(out_filename, TRUE); if(!f) VError(" error opening outout file %s", out_filename); if(! VWriteFile(f, out_list)) exit(1); fprintf(stderr, "%s: done.\n", argv[0]); return 0; }
VBoolean VDecodeAttrValue (VStringConst str, VDictEntry *dict, VRepnKind repn, VPointer value) { VLong i_value = 0; VDouble f_value = 0.0; char *cp = NULL, buf[20]; /* If a dict is provided, see if str maps to any dict entry keyword, substituting the associated value if found: */ if (dict) { dict = VLookupDictKeyword (dict, str); /* If there's a dictionary entry, complete it: */ if (dict && ! dict->svalue) { str = NULL; dict->icached = dict->fcached = TRUE; sprintf (buf, "%ld", (long) dict->ivalue); dict->svalue = VNewString (buf); dict->fvalue = dict->ivalue; } } /* Convert to the internal representation: */ switch (repn) { case VBitRepn: case VUByteRepn: case VSByteRepn: case VShortRepn: case VLongRepn: case VBooleanRepn: if (dict) { if (dict->icached) i_value = dict->ivalue; else { dict->ivalue = i_value = strtol (dict->svalue, & cp, 0); dict->icached = TRUE; } } else i_value = strtol (str, & cp, 0); break; case VFloatRepn: case VDoubleRepn: if (dict) { if (dict->fcached) f_value = dict->fvalue; else { dict->fvalue = f_value = strtod (dict->svalue, & cp); dict->fcached = TRUE; } } else f_value = strtod (str, & cp); break; case VStringRepn: if (dict) str = dict->svalue; break; default: VError ("VDecodeAttrValue: Can't decode to %s", VRepnName (repn)); } if (cp && *cp) return FALSE; /* Store at *value: */ switch (repn) { case VBitRepn: * (VBit *) value = i_value; break; case VUByteRepn: * (VUByte *) value = i_value; break; case VSByteRepn: * (VSByte *) value = i_value; break; case VShortRepn: * (VShort *) value = i_value; break; case VLongRepn: * (VLong *) value = i_value; break; case VFloatRepn: * (VFloat *) value = f_value; break; case VDoubleRepn: * (VDouble *) value = f_value; break; case VBooleanRepn: * (VBoolean *) value = i_value; break; case VStringRepn: * (VStringConst *) value = str; break; default: break; } return TRUE; }
VAttrList VGetContrast(VAttrList list, gsl_vector_float *con, VShort type) { VAttrList out_list; int nbands = 0, nrows = 0, ncols = 0, band, row, col; VImage src = NULL, dest = NULL, std_image = NULL; VImage beta_images[MBETA], res_image = NULL, bcov_image = NULL; VString buf = NULL; VAttrListPosn posn; VString str; int i, nbeta; float t = 0, s = 0, tsigma = 0, z = 0, zmax = 0, zmin = 0; float sigma, var, sum, df; float *ptr1, *ptr2; char *constring = NULL; gsl_vector_float *beta = NULL, *tmp = NULL; gsl_matrix_float *bcov = NULL; i = 0; for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) { if(VGetAttrRepn(& posn) != VImageRepn) continue; VGetAttrValue(& posn, NULL, VImageRepn, & src); if(VPixelRepn(src) != VFloatRepn) continue; VGetAttr(VImageAttrList(src), "modality", NULL, VStringRepn, &str); if(strcmp(str, "BETA") == 0) { beta_images[i++] = VCopyImage(src, NULL, VAllBands); } else if(strcmp(str, "RES/trRV") == 0) { res_image = VCopyImage(src, NULL, VAllBands); } else if(strcmp(str, "BCOV") == 0) { bcov_image = VCopyImage(src, NULL, VAllBands); } } nbeta = VImageNRows(bcov_image); nbands = VImageNBands(beta_images[0]); nrows = VImageNRows(beta_images[0]); ncols = VImageNColumns(beta_images[0]); if(VGetAttr(VImageAttrList(beta_images[0]), "df", NULL, VFloatRepn, &df) != VAttrFound) VError(" attribute 'df' not found"); if(nbeta > MBETA) { fprintf(stderr, " number of betas: %d, maximum number of betas: %d\n", nbeta, MBETA); VError(" maximum number of betas is exceeded"); } /* ** read contrast vector */ if(nbeta != con->size) VError("contrast vector has bad length (%d), correct length is %d", con->size, nbeta); fprintf(stderr, " contrast vector:\n"); char str1[10]; constring = (char *)VMalloc(sizeof(char) * 10 * nbeta); constring[0] = '\0'; for(i = 0; i < nbeta; i++) { fprintf(stderr, " %.2f", fvget(con, i)); sprintf(str1, "%1.2f ", fvget(con, i)); strcat((char *)constring, (const char *)str1); } fprintf(stderr, "\n"); /* get variance estimation */ bcov = gsl_matrix_float_alloc(nbeta, nbeta); ptr1 = VImageData(bcov_image); ptr2 = bcov->data; for(i = 0; i < nbeta * nbeta; i++) *ptr2++ = *ptr1++; gsl_matrix_float_transpose(bcov); tmp = fmat_x_vector(bcov, con, tmp); var = fskalarproduct(tmp, con); sigma = sqrt(var); /* ** create output data structs */ out_list = VCreateAttrList(); dest = VCreateImage(nbands, nrows, ncols, VFloatRepn); VFillImage(dest, VAllBands, 0); VCopyImageAttrs(beta_images[0], dest); switch(type) { case 0: /* conimg */ buf = VNewString("conimg"); break; case 1: /* t-image */ buf = VNewString("tmap"); break; case 2: /* zmap */ buf = VNewString("zmap"); break; default: VError(" illegal type"); } fprintf(stderr, " output type: %s\n", buf); VSetAttr(VImageAttrList(dest), "modality", NULL, VStringRepn, buf); VSetAttr(VImageAttrList(dest), "name", NULL, VStringRepn, buf); VSetAttr(VImageAttrList(dest), "contrast", NULL, VStringRepn, constring); VAppendAttr(out_list, "image", NULL, VImageRepn, dest); if(type == 0) { std_image = VCreateImage(nbands, nrows, ncols, VFloatRepn); VFillImage(std_image, VAllBands, 0); VCopyImageAttrs(beta_images[0], std_image); VSetAttr(VImageAttrList(std_image), "modality", NULL, VStringRepn, "std_dev"); VSetAttr(VImageAttrList(std_image), "name", NULL, VStringRepn, "std_dev"); VAppendAttr(out_list, "image", NULL, VImageRepn, std_image); } /* ** loop thru image */ zmax = zmin = 0; beta = gsl_vector_float_alloc(nbeta); for(band = 0; band < nbands; band++) { for(row = 0; row < nrows; row++) { for(col = 0; col < ncols; col++) { t = z = sum = 0; ptr1 = beta->data; for(i = 0; i < nbeta; i++) { *ptr1++ = VPixel(beta_images[i], band, row, col, VFloat); } sum = fskalarproduct(beta, con); if(ABS(sum) < 1.0e-10) continue; s = VPixel(res_image, band, row, col, VFloat); tsigma = sqrt(s) * sigma; if(tsigma > 0.00001) t = sum / tsigma; else t = 0; if(isnan(t) || isinf(t)) t = 0; switch(type) { case 0: /* conimg */ z = sum; break; case 1: /* t-image */ z = t; break; case 2: /* zmap */ z = t2z_approx(t, df); if(z > 30) z = 30; if(sum < 0) z = -z; break; default: ; } if(isnan(z) || isinf(z)) z = 0; if(z > zmax) zmax = z; if(z < zmin) zmin = z; VPixel(dest, band, row, col, VFloat) = z; if(type == 0) VPixel(std_image, band, row, col, VFloat) = tsigma; } } } fprintf(stderr, " min= %.3f, max= %.3f\n", zmin, zmax); return out_list; }