Example #1
0
int main(int argc, char *argv[]) {
    static VLong objnr = -1;
    static VString name = "";
    static VString value = "";
    static VOptionDescRec options[] = {
        {
            "obj", VLongRepn, 1, (VPointer) &objnr,
            VOptionalOpt, NULL, "object number, all objects (-1)"
        },
        {
            "name", VStringRepn, 1, (VPointer) &name,
            VRequiredOpt, NULL, "attribute name"
        },
        {
            "value", VStringRepn, 1, (VPointer) &value,
            VRequiredOpt, NULL, "attribute value"
        }
    };
    FILE *in_file, *out_file;
    VAttrList list, olist;
    VAttrListPosn posn;
    VImage isrc;
    VGraph gsrc;
    Volumes vsrc;
    VString buf;
    int nobj;
    char prg_name[100];
    char ver[100];
    getLipsiaVersion(ver, sizeof(ver));
    sprintf(prg_name, "vattredit V%s", ver);
    fprintf(stderr, "%s\n", prg_name);
    /* Parse command line arguments and identify files: */
    VParseFilterCmd(VNumber(options), options, argc, argv,
                    &in_file, & out_file);
    /* Read source image(s): */
    if(!(list = VReadFile(in_file, NULL)))
        exit(1);
    /* Process each image: */
    nobj = 0;
    for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
        olist = NULL;
        if(nobj == objnr || objnr < 0) {
            if(VGetAttrRepn(& posn) == VImageRepn) {
                VGetAttrValue(& posn, NULL, VImageRepn, & isrc);
                olist = VImageAttrList(isrc);
            } else if(VGetAttrRepn(& posn) == VGraphRepn) {
                VGetAttrValue(& posn, NULL, VGraphRepn, & gsrc);
                olist = VGraphAttrList(gsrc);
            } else if(VGetAttrRepn(& posn) == VolumesRepn) {
                VGetAttrValue(& posn, NULL, VolumesRepn, & vsrc);
                olist = VolumesAttrList(vsrc);
            }
            if(olist != NULL) {
                if(VGetAttr(olist, name, NULL, VStringRepn, &buf) == VAttrFound)
                    fprintf(stderr, " object %3d, old value: %s\n", nobj, buf);
                VSetAttr(olist, name, NULL, VStringRepn, value);
                fprintf(stderr, " object %3d, new value: %s\n", nobj, value);
            }
        }
        nobj++;
    }
    /* Make History */
    VHistory(VNumber(options), options, prg_name, &list, &list);
    /* Write out the results: */
    if(! VWriteFile(out_file, list))
        exit(1);
    fprintf(stderr, "%s: done.\n", argv[0]);
    return 0;
}
Example #2
0
int main(int argc, char *argv[]) {
    VAttrList list, out_list;
    VImage src;
    VImage dest = NULL;
    VAttrListPosn posn;
    VString str;
    int nimages;
    char historystr[] = "history";
    char prg_name[100];
    char ver[100];
    getLipsiaVersion(ver, sizeof(ver));
    sprintf(prg_name, "vdelcereb V%s", ver);
    fprintf(stderr, "%s\n", prg_name);
    /* Parse command line arguments: */
    if(!VParseCommand(VNumber(options), options, &argc, argv) ||
            ! VIdentifyFiles(VNumber(options), options, "in", & argc, argv, 0) ||
            ! VIdentifyFiles(VNumber(options), options, "out", & argc, argv, -1))
        goto Usage;
    if(argc > 1) {
        VReportBadArgs(argc, argv);
Usage:
        VReportUsage(argv[0], VNumber(options), options, NULL);
        exit(EXIT_FAILURE);
    }
    /* Read source image(s): */
    if(strcmp(in_filename, "-") == 0)
        in_file = stdin;
    else {
        in_file = fopen(in_filename, "r");
        if(! in_file)
            VError("Failed to open input file %s", in_filename);
    }
    if(!(list = VReadFile(in_file, NULL)))
        exit(EXIT_FAILURE);
    fclose(in_file);
    /* Process image */
    nimages = 0;
    for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
        if(VGetAttrRepn(& posn) != VImageRepn)
            continue;
        VGetAttrValue(& posn, NULL, VImageRepn, & src);
        dest = VCerebellum(src);
        VSetAttrValue(& posn, NULL, VImageRepn, dest);
        VDestroyImage(src);
        nimages++;
        break;
    }
    /* Create outlist */
    out_list = VCreateAttrList();
    /* Make History */
    VHistory(VNumber(options), options, prg_name, &list, &out_list);
    /*  Alle Attribute (ausser history:) in die neue Liste schreiben: */
    for(VFirstAttr(list, &posn); VAttrExists(&posn); VNextAttr(&posn)) {
        if(strncmp(VGetAttrName(&posn), historystr, strlen(historystr)) == 0)
            continue;
        switch(VGetAttrRepn(&posn)) {
        case VImageRepn:
            VGetAttrValue(&posn, NULL, VImageRepn, &src);
            VAppendAttr(out_list, VGetAttrName(&posn), NULL, VImageRepn, src);
            break;
        case VStringRepn:
            VGetAttrValue(&posn, NULL, VStringRepn, &str);
            VAppendAttr(out_list, VGetAttrName(&posn), NULL, VImageRepn, str);
            break;
        default:
            break;
        }
    }
    /* Write the results to the output file: */
    if(strcmp(out_filename, "-") == 0)
        out_file = stdout;
    else {
        out_file = fopen(out_filename, "w");
        if(! out_file)
            VError("Failed to open output file %s", out_filename);
    }
    if(VWriteFile(out_file, out_list)) {
        if(verbose >= 1)
            fprintf(stderr, "%s: processed %d image%s.\n",
                    argv[0], nimages, nimages == 1 ? "" : "s");
        fprintf(stderr, "%s: done.\n", argv[0]);
    }
    return 0;
}
Example #3
0
int main(int argc, char *argv[]) {
    static VArgVector in_files1;
    static VArgVector in_files2;
    static VString out_filename;
    static VOptionDescRec options[] = {
        { "in1", VStringRepn, 0, & in_files1, VRequiredOpt, NULL, "Input files 1" },
        { "in2", VStringRepn, 0, & in_files2, VRequiredOpt, NULL, "Input files 2" },
        { "out", VStringRepn, 1, & out_filename, VRequiredOpt, NULL, "Output file" }
    };
    FILE *fp = NULL;
    VStringConst in_filename, buf1, buf2;
    VAttrList list1, list2, out_list;
    VAttrListPosn posn;
    VImage src, *src1, *src2, dest = NULL;
    int i, nimages, npix = 0;
    char prg_name[100];
	char ver[100];
	getLipsiaVersion(ver, sizeof(ver));
	sprintf(prg_name, "vpaired_wilcoxtest 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);
    }
    /* number of images */
    nimages = in_files1.number;
    if(in_files2.number != nimages)
        VError(" inconsistent number of files ");
    for(i = 0; i < nimages; i++) {
        buf1 = ((VStringConst *) in_files1.vector)[i];
        buf2 = ((VStringConst *) in_files2.vector)[i];
        fprintf(stderr, "%3d:  %s  %s\n", i, buf1, buf2);
    }
    fprintf(stderr, "\n");
    /*
    ** read images 1
    */
    src1 = (VImage *) VCalloc(nimages, sizeof(VImage));
    for(i = 0; i < nimages; i++) {
        src1[i] = NULL;
        in_filename = ((VStringConst *) in_files1.vector)[i];
        fp = VOpenInputFile(in_filename, TRUE);
        list1 = VReadFile(fp, NULL);
        if(! list1)
            VError("Error reading image");
        fclose(fp);
        for(VFirstAttr(list1, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
            if(VGetAttrRepn(& posn) != VImageRepn)
                continue;
            VGetAttrValue(& posn, NULL, VImageRepn, & src);
            if(VPixelRepn(src) != VFloatRepn)
                continue;
            src1[i] = src;
            break;
        }
        if(i == 0)
            npix = VImageNPixels(src1[i]);
        else if(npix != VImageNPixels(src1[i]))
            VError(" inconsistent image dimensions");
        if(src1[i] == NULL)
            VError(" no image found in %s", in_filename);
    }
    /*
    ** read images 2
    */
    src2 = (VImage *) VCalloc(nimages, sizeof(VImage));
    for(i = 0; i < nimages; i++) {
        src2[i] = NULL;
        in_filename = ((VStringConst *) in_files2.vector)[i];
        fp = VOpenInputFile(in_filename, TRUE);
        list2 = VReadFile(fp, NULL);
        if(! list2)
            VError("Error reading image");
        fclose(fp);
        for(VFirstAttr(list2, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
            if(VGetAttrRepn(& posn) != VImageRepn)
                continue;
            VGetAttrValue(& posn, NULL, VImageRepn, & src);
            if(VPixelRepn(src) != VFloatRepn)
                continue;
            src2[i] = src;
            break;
        }
        if(npix != VImageNPixels(src2[i]))
            VError(" inconsistent image dimensions");
        if(src2[i] == NULL)
            VError(" no image found in %s", in_filename);
    }
    /*
    ** paired wilcoxon test
    */
    dest = PairedWilcoxTest(src1, src2, dest, nimages);
    /*
    ** output
    */
    out_list = VCreateAttrList();
    VHistory(VNumber(options), options, prg_name, &list1, &out_list);
    VAppendAttr(out_list, "image", NULL, VImageRepn, dest);
    fp = VOpenOutputFile(out_filename, TRUE);
    if(! VWriteFile(fp, out_list))
        exit(1);
    fclose(fp);
    fprintf(stderr, "%s: done.\n", argv[0]);
    exit(0);
}
Example #4
0
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;
}
Example #5
0
int main(int argc, char *argv[]) {
    static VArgVector in_files;
    static VString  out_filename;
    static VBoolean level  = FALSE;
    static VBoolean zscore = FALSE;
    static VBoolean in_found, out_found;
    static VOptionDescRec options[] = {
        {
            "in", VStringRepn, 0, & in_files,  & in_found, NULL,
            "Contrast images"
        },
        {
            "out", VStringRepn, 1, & out_filename, & out_found, NULL,
            "Output file"
        },
        {
            "level", VBooleanRepn, 1, & level, VOptionalOpt, NULL,
            "Whether to produce output to be used for 3rd level analysis"
        }
        /*    { "zscore", VBooleanRepn, 1, & zscore, VOptionalOpt, NULL,
          "Whether to produce z-scores as output"} */
    };
    FILE *f;
    VStringConst in_filename;
    VAttrList list, out_list;
    VAttrListPosn posn;
    VImage src = NULL;
    VImage cbeta_images[N], sd_images[N];
    int i, nimages = 0;
    VString str = NULL;
    char prg_name[100];
	char ver[100];
	getLipsiaVersion(ver, sizeof(ver));
	sprintf(prg_name, "vbayes V%s", ver);
    fprintf(stderr, "%s\n", prg_name);
    /* Parse command line arguments: */
    if(! VParseCommand(VNumber(options), options, & argc, argv) ||
            ! VIdentifyFiles(VNumber(options), options, "in", & argc, argv, 0) ||
            ! VIdentifyFiles(VNumber(options), options, "out", & argc, argv, -1))
        goto Usage;
    if(argc > 1) {
        VReportBadArgs(argc, argv);
Usage:
        VReportUsage(argv[0], VNumber(options), options, NULL);
        exit(EXIT_FAILURE);
    }
    nimages = in_files.number;
    fprintf(stderr, "Processing %d input files\n\n", nimages);
    if(nimages >= N)
        VError("Too many input images, max: %d", N);
    if(nimages == 0)
        VError("Input images missing");
    /* loop through all input files */
    for(i = 0; i < nimages; i++) {
        in_filename = ((VStringConst *) in_files.vector)[i];
        fprintf(stderr, "%s\n", in_filename);
        f = fopen((char *)in_filename, "r");
        if(! f)
            VError("Failed to open input file %s", in_filename);
        if(!(list = VReadFile(f, NULL)))
            exit(EXIT_FAILURE);
        fclose(f);
        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, "conimg") == 0) {
                cbeta_images[i] = VCopyImage(src, NULL, VAllBands);
            } else if(strcmp(str, "std_dev") == 0 || strcmp(str, "sd") == 0) {
                sd_images[i] = VCopyImage(src, NULL, VAllBands);
            } else
                VError(" Illegal input file! Make sure to use con-images as input");
        }
    }
    /* calculate probabilities */
    out_list = VBayes(cbeta_images, sd_images, nimages, level, zscore);
    if(out_list == NULL)
        VError(" no result");
    /*
    ** output
    */
    VHistory(VNumber(options), options, prg_name, &list, &out_list);
    if(strcmp(out_filename, "-") == 0)
        VError("Output file required");
    f = fopen(out_filename, "w");
    if(! f)
        VError("Failed to open output file %s", out_filename);
    if(! VWriteFile(f, out_list))
        exit(EXIT_FAILURE);
    fprintf(stderr, "\n%s: done \n", argv[0]);
    return EXIT_SUCCESS;
}
Example #6
0
int main(int argc, char *argv[]) {
    /* command line arguments */
    static VString out_filename;
    static VArgVector in_files;
    static VString trans_filename = "";
    static VBoolean in_found, out_found;
    static VShort minval = 0;
    static VBoolean compress = TRUE;
    static VFloat resolution = 3;
    static VOptionDescRec options[] = {
        { "in", VStringRepn, 0, & in_files, & in_found, NULL, "Input file" },
        { "out", VStringRepn, 1, & out_filename, & out_found, NULL, "Output file" },
        {
            "trans", VStringRepn, 1, &trans_filename, VRequiredOpt, NULL,
            "File containing transformation matrix"
        },
        {
            "resolution", VFloatRepn, 1, &resolution, VOptionalOpt, NULL,
            "Output voxel resolution in mm"
        },
        {
            "minval", VShortRepn, 1, &minval, VOptionalOpt, NULL,
            "Signal threshold"
        },
        {
            "compress", VBooleanRepn, 1, &compress, VOptionalOpt, NULL,
            "Whether to compress empty slices"
        }
    };
    VStringConst in_filename;
    FILE *in_file, *out_file, *fp;
    VAttrList list, list1, out_list;
    VAttrListPosn posn;
    VImage trans = NULL;
    VImage *dst_image;
    VImageInfo *imageInfo;
    int nobject = 0, ntimesteps = 0, nbands = 0, nrows = 0, ncols = 0;
    VString ca, cp, extent, str;
    int found = 0;
    int j, dest_nbands;
    char prg_name[100];
	char ver[100];
	getLipsiaVersion(ver, sizeof(ver));
	sprintf(prg_name, "vfunctrans V%s", ver);
    fprintf(stderr, "%s\n", prg_name);
    /* Parse command line arguments: */
    if(! VParseCommand(VNumber(options), options, & argc, argv) ||
            ! VIdentifyFiles(VNumber(options), options, "in", & argc, argv, 0) ||
            ! VIdentifyFiles(VNumber(options), options, "out", & argc, argv, -1))
        goto Usage;
    if(argc > 1) {
        VReportBadArgs(argc, argv);
Usage:
        VReportUsage(argv[0], VNumber(options), options, NULL);
        exit(EXIT_FAILURE);
    }
    if(resolution <= 0)
        VError(" 'resolution' must be an integer > 0");
    /*
    ** Read the transformation matrix:
    */
    fp = VOpenInputFile(trans_filename, TRUE);
    list1 = VReadFile(fp, NULL);
    if(! list1)
        VError("Error reading image");
    fclose(fp);
    for(VFirstAttr(list1, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
        if(VGetAttrRepn(& posn) != VImageRepn)
            continue;
        if(strncmp(VGetAttrName(&posn), "transform", 9) != 0)
            continue;
        VGetAttrValue(& posn, NULL, VImageRepn, & trans);
        break;
    }
    if(trans == NULL)
        VError("transformation matrix not found");
    /*
    ** check attributes
    */
    if(VGetAttr(VImageAttrList(trans), "ca", NULL,
                VStringRepn, (VPointer) & ca) != VAttrFound)
        VError(" attribute 'ca' missing in transformation matrix ");
    if(VGetAttr(VImageAttrList(trans), "cp", NULL,
                VStringRepn, (VPointer) & cp) != VAttrFound)
        VError(" attribute 'cp' missing in transformation matrix ");
    if(VGetAttr(VImageAttrList(trans), "extent", NULL,
                VStringRepn, (VPointer) & extent) != VAttrFound)
        VError(" attribute 'extent' missing in transformation matrix ");
    /*
    ** open in-file
    */
    if(in_files.number < 1 || in_files.number > 1)
        VError(" incorrect number of input files: %d", in_files.number);
    in_filename = ((VStringConst *) in_files.vector)[0];
    if(strcmp(in_filename, "-") == 0)
        in_file = stdin;
    else {
        in_file = fopen((char *)in_filename, "r");
        if(! in_file)
            VError("Failed to open input file %s", in_filename);
    }
    /*
    ** read file info
    */
    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));
    nobject = nbands = found = 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");
        if(imageInfo[nbands].repn == VShortRepn) {
            found = 1;
            nrows = imageInfo[nbands].nrows;
            ncols = imageInfo[nbands].ncolumns;
            ntimesteps = imageInfo[nbands].nbands;
            nbands++;
        }
        nobject++;
    }
    fclose(in_file);
    if(!found)
        VError(" couldn't find functional data");
    /*
    ** process each time step
    */
    dst_image = VFunctrans(in_filename, imageInfo, nbands, trans, resolution,
                           ntimesteps, minval, compress, &dest_nbands);
    /*
    ** output
    */
    out_list = VCreateAttrList();
    VHistory(VNumber(options), options, prg_name, &list, &out_list);
    for(j = 0; j < dest_nbands; j++) {
        VAppendAttr(out_list, "image", NULL, VImageRepn, dst_image[j]);
    }
    /* Open and write the output file: */
    if(strcmp(out_filename, "-") == 0)
        out_file = stdout;
    else {
        out_file = fopen(out_filename, "w");
        if(! out_file)
            VError("Failed to open output file %s", out_filename);
    }
    if(!VWriteFile(out_file, out_list) || fclose(out_file))
        VSystemError("error writing output file");
    fprintf(stderr, "\n%s: done.\n", argv[0]);
    return (EXIT_SUCCESS);
}
Example #7
0
int main(int argc, char *argv[]) {
    static VArgVector in_files1;
    static VArgVector in_files2;
    static VArgVector mask_file;
    static VArgVector report_file;
    static VOptionDescRec options[] = {
        { "in1", VStringRepn, 0, & in_files1, VRequiredOpt, NULL, "Input files 1" },
        { "in2", VStringRepn, 0, & in_files2, VRequiredOpt, NULL, "Input files 2" },
        { "report", VStringRepn, 0, & report_file, VRequiredOpt, NULL, "Report file" },
        { "mask", VStringRepn, 0, & mask_file, VRequiredOpt, NULL, "Mask file(s)" }
    };
    FILE *fp = NULL;
    VStringConst in_filename;
    VAttrList list1, list2, list3;
    VAttrListPosn posn;
    VString str;
    VImage src, *src1, *src2, *mask;
    int i, nimages = 0, mimages = 0;
    char prg_name[100];
	char ver[100];
	getLipsiaVersion(ver, sizeof(ver));
	sprintf(prg_name, "vROIpaired_ttest V%s", ver);
    fprintf(stderr, "%s\n", prg_name);
    if(!VParseCommand(VNumber(options), options, & argc, argv)) {
        VReportUsage(argv[0], VNumber(options), options, NULL);
        exit(0);
    }
    /* get number of input images */
    nimages = in_files1.number;
    if(in_files2.number != nimages)
        VError(" inconsistent number of files: in1: %d, in2: %d ",
               nimages, in_files2.number);
    mimages = mask_file.number;
    if(nimages != mimages && mimages > 1)
        VError(" inconsistent number of files, images: %d, masks: %d", nimages, mimages);
    /* images 1 */
    src1 = (VImage *) VMalloc(sizeof(VImage) * nimages);
    for(i = 0; i < nimages; i++) {
        src1[i] = NULL;
        in_filename = ((VStringConst *) in_files1.vector)[i];
        fp = VOpenInputFile(in_filename, TRUE);
        if(!fp)
            VError("Error opening file %s", in_filename);
        list1 = VReadFile(fp, NULL);
        if(! list1)
            VError("Error reading file %s", in_filename);
        fclose(fp);
        for(VFirstAttr(list1, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
            if(VGetAttrRepn(& posn) != VImageRepn)
                continue;
            VGetAttrValue(& posn, NULL, VImageRepn, & src);
            if(VPixelRepn(src) != VFloatRepn)
                continue;
            if(VGetAttr(VImageAttrList(src), "modality", NULL, VStringRepn, &str) == VAttrFound) {
                if(strcmp(str, "conimg") != 0)
                    continue;
            }
            src1[i] = src;
            break;
        }
        if(src1[i] == NULL)
            VError(" no contrast image found in %s", in_filename);
    }
    /* images 2 */
    src2 = (VImage *) VMalloc(sizeof(VImage) * nimages);
    for(i = 0; i < nimages; i++) {
        src2[i] = NULL;
        in_filename = ((VStringConst *) in_files2.vector)[i];
        fp = VOpenInputFile(in_filename, TRUE);
        if(!fp)
            VError("Error opening file %s", in_filename);
        list2 = VReadFile(fp, NULL);
        if(! list2)
            VError("Error reading file %s", in_filename);
        fclose(fp);
        for(VFirstAttr(list2, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
            if(VGetAttrRepn(& posn) != VImageRepn)
                continue;
            VGetAttrValue(& posn, NULL, VImageRepn, & src);
            if(VPixelRepn(src) != VFloatRepn)
                continue;
            if(VGetAttr(VImageAttrList(src), "modality", NULL, VStringRepn, &str) == VAttrFound) {
                if(strcmp(str, "conimg") != 0)
                    continue;
            }
            src2[i] = src;
            break;
        }
        if(src2[i] == NULL)
            VError(" no contrast image found in %s", in_filename);
    }
    for(i = 0; i < nimages; i++) {
        fprintf(stderr, "%3d:  %s  %s\n", i,
                ((VStringConst *) in_files1.vector)[i],
                ((VStringConst *) in_files2.vector)[i]);
    }
    fprintf(stderr, "\n");
    /* mask images */
    mask = (VImage *) VMalloc(sizeof(VImage) * mimages);
    for(i = 0; i < mimages; i++) {
        mask[i] = NULL;
        in_filename = ((VStringConst *) mask_file.vector)[i];
        fp = VOpenInputFile(in_filename, TRUE);
        if(!fp)
            VError("Error opening file %s", in_filename);
        list3 = VReadFile(fp, NULL);
        if(! list3)
            VError("Error reading file", in_filename);
        fclose(fp);
        for(VFirstAttr(list3, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
            if(VGetAttrRepn(& posn) != VImageRepn)
                continue;
            VGetAttrValue(& posn, NULL, VImageRepn, & src);
            if(VPixelRepn(src) != VUByteRepn)
                mask[i] = VConvertImageCopy(src, NULL, VAllBands, VUByteRepn);
            else
                mask[i] = src;
            break;
        }
        if(mask[i] == NULL)
            VError(" mask %d not found", i);
    }
    /* open report_file */
    fp = NULL;
    in_filename = ((VStringConst *) report_file.vector)[0];
    fp = fopen(in_filename, "w");
    if(!fp)
        VError(" error opening file %s", in_filename);
    /* paired t-test in ROIs */
    VROIpaired_ttest(src1, src2, mask, nimages, mimages, fp);
    exit(0);
}
Example #8
0
int
main(int argc, char *argv[]) {
    /* Command line options: */
    static VString mat = NULL;
    static VBoolean funconly = FALSE;
    static VOptionDescRec  options[] = {
        {"out", VStringRepn, 1, &mat, VRequiredOpt, 0, "Matfile"},
        {"funconly", VBooleanRepn, 1, &funconly, VOptionalOpt, 0, "Functional data only (in one single 4D-object)"},
    };
    FILE *in_file;
    VAttrList in_list;
    VAttrListPosn posn;
    VImage src = NULL;
    VBit     *bit_pp = NULL, *pbSRC = NULL;
    VShort *short_pp = NULL, *psSRC = NULL;
    VUByte *ubyte_pp = NULL, *puSRC = NULL;
    VFloat *float_pp = NULL, *pfSRC = NULL;
    VDouble *double_pp = NULL, *pdSRC = NULL;
    VString mode = NULL, name = NULL;
    mxArray *SRC = NULL;
    MATFile *fp;
    int n = 0, dims[4];
    int bands = 0, rows = 0, cols = 0;
    char prg_name[100];
	char ver[100];
	getLipsiaVersion(ver, sizeof(ver));
	sprintf(prg_name, "vtomat V%s", ver);
    fprintf(stderr, "%s\n", prg_name);
    /* Parse command line arguments and identify files: */
    VParseFilterCmd(VNumber(options), options, argc, argv, &in_file,/* &out_file */ NULL);
    /* Read the input file */
    in_list = VReadFile(in_file, NULL);
    if(!in_list)
        exit(1);
    /* strings */
    mode = (VString)malloc(sizeof(char));
    name = (VString)malloc(sizeof(char) * 50);
    strcpy(mode, "w");
    fp = matOpen(mat, mode);
    if(funconly == TRUE) {
        /*******************************************************************
         *                                                                 *
         *                   L O O P over objects in vista file            *
         *                                                                 *
         *******************************************************************/
        n = 0;
        for(VFirstAttr(in_list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
            if(VGetAttrRepn(& posn) != VImageRepn)
                continue;
            VGetAttrValue(& posn, NULL, VImageRepn, & src);
            if(VPixelRepn(src) == VShortRepn) {
                if(bands < 2)
                    bands = VImageNBands(src);
                if(rows  < 2)
                    rows  = VImageNRows(src);
                if(cols  < 2)
                    cols  = VImageNColumns(src);
                if(bands != VImageNBands(src))
                    VError("Different bands in functional objects");
                if(rows  != VImageNRows(src))
                    VError("Different rows  in functional objects");
                if(cols  != VImageNColumns(src))
                    VError("Different cols  in functional objects");
                n++;
            }
        }
        /*dimensions */
        dims[3] = n;
        dims[2] = bands;
        dims[1] = rows;
        dims[0] = cols;
        SRC   = mxCreateNumericArray(4, dims, mxINT16_CLASS, mxREAL);
        psSRC = (VShort *) mxGetPr(SRC);
        /* copy data to SRC */
        for(VFirstAttr(in_list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
            if(VGetAttrRepn(& posn) != VImageRepn)
                continue;
            VGetAttrValue(& posn, NULL, VImageRepn, & src);
            if(VPixelRepn(src) == VShortRepn) {
                short_pp = (VShort *) VPixelPtr(src, 0, 0, 0);
                memcpy(psSRC, short_pp, sizeof(VShort) * dims[0] * dims[1] * dims[2]);
                psSRC += dims[0] * dims[1] * dims[2];
            }
        }
        /* save data into file */
        if(matPutVariable(fp, "fnc", SRC))
            VError("Could not save data in MATLAB file");
        /* destroy array */
        mxDestroyArray(SRC);
    } else {
        /*******************************************************************
         *                                                                 *
         *                   L O O P over objects in vista file            *
         *                                                                 *
         *******************************************************************/
        n = 0;
        for(VFirstAttr(in_list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
            if(VGetAttrRepn(& posn) != VImageRepn)
                continue;
            VGetAttrValue(& posn, NULL, VImageRepn, & src);
            /*dimensions */
            dims[3] = 1;
            dims[2] = VImageNBands(src);
            dims[1] = VImageNRows(src);
            dims[0] = VImageNColumns(src);
            sprintf(name, "obj%d\0", n);
            /* Bit ONLY */
            if(VPixelRepn(src) == VBitRepn) {
                SRC    = mxCreateNumericArray(3, dims, mxLOGICAL_CLASS, mxREAL);
                pbSRC  = (VBit *) mxGetPr(SRC);
                bit_pp = (VBit *) VPixelPtr(src, 0, 0, 0);
                memcpy(pbSRC, bit_pp, sizeof(VBit) * dims[0] * dims[1] * dims[2]);
            }
            /* Short ONLY */
            if(VPixelRepn(src) == VShortRepn) {
                SRC      = mxCreateNumericArray(3, dims, mxINT16_CLASS, mxREAL);
                psSRC    = (VShort *) mxGetPr(SRC);
                short_pp = (VShort *) VPixelPtr(src, 0, 0, 0);
                memcpy(psSRC, short_pp, sizeof(VShort) * dims[0] * dims[1] * dims[2]);
            }
            /* UByte ONLY */
            if(VPixelRepn(src) == VUByteRepn) {
                SRC      = mxCreateNumericArray(3, dims, mxUINT8_CLASS, mxREAL);
                puSRC    = (VUByte *) mxGetPr(SRC);
                ubyte_pp = (VUByte *) VPixelPtr(src, 0, 0, 0);
                memcpy(puSRC, ubyte_pp, sizeof(VUByte) * dims[0] * dims[1] * dims[2]);
            }
            /* Float ONLY */
            if(VPixelRepn(src) == VFloatRepn) {
                SRC      = mxCreateNumericArray(3, dims, mxSINGLE_CLASS, mxREAL);
                pfSRC    = (VFloat *) mxGetPr(SRC);
                float_pp = (VFloat *) VPixelPtr(src, 0, 0, 0);
                memcpy(pfSRC, float_pp, sizeof(VFloat) * dims[0] * dims[1] * dims[2]);
            }
            /* Double ONLY */
            if(VPixelRepn(src) == VDoubleRepn) {
                SRC       = mxCreateNumericArray(3, dims, mxDOUBLE_CLASS, mxREAL);
                pdSRC     = (VDouble *) mxGetPr(SRC);
                double_pp = (VDouble *) VPixelPtr(src, 0, 0, 0);
                memcpy(pdSRC, double_pp, sizeof(VDouble) * dims[0] * dims[1] * dims[2]);
            }
            /* save data into file */
            if(matPutVariable(fp, name, SRC))
                VError("Could not save data in MATLAB file");
            /* destroy array */
            mxDestroyArray(SRC);
            n++;
        }
    }
    /* Terminate */
    matClose(fp);
    return 0;
}