예제 #1
0
    def testUploadNIDMZip(self):

        for name, info in self.files.items():
            zip_file = open(info['file'], 'rb')
            post_dict = {
                'name': name,
                'description': '{0} upload test'.format(name),
                'collection': self.coll.pk,
            }

            fname = os.path.basename(info['file'])
            file_dict = {
                'zip_file': SimpleUploadedFile(fname, zip_file.read())}
            form = NIDMResultsForm(post_dict, file_dict)

            self.assertTrue(form.is_valid())

            nidm = form.save()

            self.assertEquals(len(nidm.nidmresultstatisticmap_set.all()),
                              info['num_statmaps'])

            map_type = info['output_row']['type'][0]
            map_img = nidm.nidmresultstatisticmap_set.filter(
                map_type=map_type).first()

            self.assertEquals(map_img.name, info['output_row']['name'])
예제 #2
0
    def testFEAT_NIDM(self):

        # test feat parsing
        for fname, info in self.testfiles.items():
            info['found_feat'] = False
            for root, dirs, files in os.walk(info['dir']):
                if detect_feat_directory(root):
                    print 'Found FEAT directory at {}.'.format(root)
                    info['found_feat'] = True
                    try:
                        fslnidm = FSLtoNIDMExporter(feat_dir=root, version="0.2.0")
                        fslnidm.parse()
                        export_dir = fslnidm.export()
                        ttl_file = os.path.join(export_dir,'nidm.ttl')
                    except:
                        print("Unable to parse the FEAT directory: \n{0}.".format(get_traceback()))

                    # confirm results path and existence
                    self.assertTrue(os.path.exists(export_dir))
                    self.assertEquals(os.path.join(info['dir'],info['export_dir']),export_dir)

                    # incomplete ttl = failure in processing
                    self.assertEquals(os.path.getsize(ttl_file),info['ttl_fsize'])

        # test upload nidm
        for fname, info in self.testfiles.items():

            nidm_zpath = os.path.join(self.tmpdir,'{}.nidm.zip'.format(fname.replace('.zip','')))
            nidm_zip = zipfile.ZipFile(nidm_zpath, 'w')

            for root, dirs, files in os.walk(os.path.join(info['dir'],info['export_dir'])):
                for nfile in files:
                    nidm_zip.write(os.path.join(root, nfile))
            nidm_zip.close()

            zname = os.path.basename(nidm_zip.filename)
            post_dict = {
                'name': zname,
                'description':'{0} upload test'.format(zname),
                'collection':self.coll.pk,
            }

            file_dict = {'zip_file': SimpleUploadedFile(zname, open(nidm_zpath,'r').read())}
            form = NIDMResultsForm(post_dict, file_dict)

            # validate NIDM Results
            self.assertTrue(form.is_valid())
            nidm = form.save()

            statmaps = nidm.nidmresultstatisticmap_set.all()
            self.assertEquals(len(statmaps),info['num_statmaps'])

            map_types = [v.map_type for v in statmaps]
            self.assertEquals(sorted(map_types), sorted(info['map_types']))

            names = [v.name for v in statmaps]
            self.assertEquals(sorted(names), sorted(info['names']))
예제 #3
0
파일: views.py 프로젝트: rwblair/NeuroVault
def view_nidm_results(request, collection_cid, nidm_name):
    collection = get_collection(collection_cid,request)
    nidmr = get_object_or_404(NIDMResults, collection=collection,name=nidm_name)
    if request.method == "POST":
        if not request.user.has_perm("statmaps.change_nidmresults", nidmr):
            return HttpResponseForbidden()
        form = NIDMResultsForm(request.POST, request.FILES, instance=nidmr)
        if form.is_valid():
            instance = form.save(commit=False)
            instance.save()
            form.save_nidm()
            form.save_m2m()
            return HttpResponseRedirect(collection.get_absolute_url())
    else:
        if owner_or_contrib(request,collection):
            form = NIDMResultsForm(instance=nidmr)
        else:
            form = NIDMViewForm(instance=nidmr)

    # Generate viewer for nidm result
    nidm_files = [nidmr.ttl_file.path.encode("utf-8")]
    standard_brain = "/static/images/MNI152.nii.gz"

    # We will remove these scripts
    remove_resources = ["BOOTSTRAPCSS","ROBOTOFONT"]

    # We will remove these columns
    columns_to_remove = ["statmap_location","statmap",
                         "statmap_type","coordinate_id"]

    html_snippet = generate(nidm_files,
                            base_image=standard_brain,
                            remove_scripts=remove_resources,
                            columns_to_remove=columns_to_remove,
                            template_choice="embed")

    context = {"form": form,"nidm_viewer":html_snippet}
    return render(request, "statmaps/edit_nidm_results.html", context)
예제 #4
0
def view_nidm_results(request, collection_cid, nidm_name):
    collection = get_collection(collection_cid, request)
    try:
        nidmr = NIDMResults.objects.get(collection=collection, name=nidm_name)
    except NIDMResults.DoesNotExist:
        return Http404("This NIDM Result was not found.")
    if request.method == "POST":
        if not owner_or_contrib(request, collection):
            return HttpResponseForbidden()
        form = NIDMResultsForm(request.POST, request.FILES, instance=nidmr)
        if form.is_valid():
            instance = form.save(commit=False)
            instance.save()
            form.save_nidm()
            form.save_m2m()
            return HttpResponseRedirect(collection.get_absolute_url())
    else:
        if owner_or_contrib(request, collection):
            form = NIDMResultsForm(instance=nidmr)
        else:
            form = NIDMViewForm(instance=nidmr)

    context = {"form": form}
    return render(request, "statmaps/edit_nidm_results.html.haml", context)
예제 #5
0
def view_nidm_results(request, collection_cid, nidm_name):
    collection = get_collection(collection_cid,request)
    try:
        nidmr = NIDMResults.objects.get(collection=collection,name=nidm_name)
    except NIDMResults.DoesNotExist:
        return Http404("This NIDM Result was not found.")
    if request.method == "POST":
        if not owner_or_contrib(request,collection):
            return HttpResponseForbidden()
        form = NIDMResultsForm(request.POST, request.FILES, instance=nidmr)
        if form.is_valid():
            instance = form.save(commit=False)
            instance.save()
            form.save_nidm()
            form.save_m2m()
            return HttpResponseRedirect(collection.get_absolute_url())
    else:
        if owner_or_contrib(request,collection):
            form = NIDMResultsForm(instance=nidmr)
        else:
            form = NIDMViewForm(instance=nidmr)

    context = {"form": form}
    return render(request, "statmaps/edit_nidm_results.html.haml", context)
예제 #6
0
    def testFEAT_NIDM(self):

        # test feat parsing
        for fname, info in self.testfiles.items():
            info['found_feat'] = False
            for root, dirs, files in os.walk(info['dir']):
                if detect_feat_directory(root):
                    print 'Found FEAT directory at {}.'.format(root)
                    info['found_feat'] = True
                    try:
                        fslnidm = FSLtoNIDMExporter(feat_dir=root,
                                                    version="0.2.0")
                        fslnidm.parse()
                        export_dir = fslnidm.export()
                        ttl_file = os.path.join(export_dir, 'nidm.ttl')
                    except:
                        print("Unable to parse the FEAT directory: \n{0}.".
                              format(get_traceback()))

                    # confirm results path and existence
                    self.assertTrue(os.path.exists(export_dir))
                    self.assertEquals(
                        os.path.join(info['dir'], info['export_dir']),
                        export_dir)

                    # incomplete ttl = failure in processing
                    self.assertEquals(os.path.getsize(ttl_file),
                                      info['ttl_fsize'])

        # test upload nidm
        for fname, info in self.testfiles.items():

            nidm_zpath = os.path.join(
                self.tmpdir, '{}.nidm.zip'.format(fname.replace('.zip', '')))
            nidm_zip = zipfile.ZipFile(nidm_zpath, 'w')

            for root, dirs, files in os.walk(
                    os.path.join(info['dir'], info['export_dir'])):
                for nfile in files:
                    nidm_zip.write(os.path.join(root, nfile))
            nidm_zip.close()

            zname = os.path.basename(nidm_zip.filename)
            post_dict = {
                'name': zname,
                'description': '{0} upload test'.format(zname),
                'collection': self.coll.pk,
            }

            file_dict = {
                'zip_file': SimpleUploadedFile(zname,
                                               open(nidm_zpath, 'r').read())
            }
            form = NIDMResultsForm(post_dict, file_dict)

            # validate NIDM Results
            self.assertTrue(form.is_valid())
            nidm = form.save()

            statmaps = nidm.nidmresultstatisticmap_set.all()
            self.assertEquals(len(statmaps), info['num_statmaps'])

            map_types = [v.map_type for v in statmaps]
            self.assertEquals(sorted(map_types), sorted(info['map_types']))

            names = [v.name for v in statmaps]
            self.assertEquals(sorted(names), sorted(info['names']))