Source Code for Module mvpa.tests.test_atlases

  1  # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*- 
  2  # vi: set ft=python sts=4 ts=4 sw=4 et: 
  3  ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ## 
  4  # 
  5  #   See COPYING file distributed along with the PyMVPA package for the 
  6  #   copyright and license terms. 
  7  # 
  8  ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ## 
  9  """Unit tests for PyMVPA atlases""" 
 10   
 11  import unittest, re 
 12  import numpy as N 
 13   
 14  from mvpa.base import externals, warning 
 15   
 16  if externals.exists('nifti', raiseException=True): 
 17      from mvpa.atlases import * 
 18  else: 
 19      raise RuntimeError, "Don't run me if no nifti is present" 
 20   
 21  import os 
 22  from mvpa import pymvpa_dataroot 
 23   
 24 -class AtlasesTests(unittest.TestCase): 
 25      """Basic tests for support of atlases such as the ones 
 26      shipped with FSL 
 27      """ 
 28 -    def testTransformations(self): 
 29          """TODO""" 
 30          pass 
 31   
 32 -    def testAtlases(self): 
 33          """Basic testing of atlases""" 
 34   
 35          tested = 0 
 36          for name in KNOWN_ATLASES.keys(): 
 37              #filename = KNOWN_ATLASES[name] % {'name': name} 
 38              try: 
 39                  atlas = Atlas(name=name) 
 40                  tested += 1 
 41              except IOError: 
 42                  # so we just don't have it 
 43                  continue 
 44              #print isinstance(atlas.atlas, objectify.ObjectifiedElement) 
 45              #print atlas.header.images.imagefile.get('offset') 
 46              #print atlas.labelVoxel( (0, -7, 20) ) 
 47              #print atlas[ 0, 0, 0 ] 
 48              coord = (-63, -12, 22) 
 49   
 50              # Atlas must have at least 1 level and that one must 
 51              # have some labels 
 52              self.failUnless(len(atlas.levels_dict[0].labels) > 0) 
 53   
 54              for res in [ atlas[coord], 
 55                           atlas.labelPoint(coord) ]: 
 56                  self.failUnless(res.get('coord_queried', None) == coord, 
 57                                  '%s: Comparison failed. Got %s and %s' 
 58                                  % (name, res.get('coord_queried', None), coord)) 
 59                  self.failUnless('labels' in res) 
 60                  # all atlases so far are based on voxels 
 61                  self.failUnless('voxel_queried' in res) 
 62   
 63              # test explicit level specification via slice, although bogus here 
 64              # XXX levels in queries should be deprecated -- too much of 
 65              # performance hit 
 66              res0 = atlas[coord, range(atlas.Nlevels)] 
 67              self.failUnless(res0 == res) 
 68   
 69              #print atlas[ 0, -7, 20, [1,2,3] ] 
 70              #print atlas[ (0, -7, 20), 1:2 ] 
 71              #print atlas[ (0, -7, 20) ] 
 72              #print atlas[ (0, -7, 20), : ] 
 73              #   print atlas.getLabels(0) 
 74          if not tested: 
 75              warning("No atlases were found -- thus no testing was done") 
 76   
 77 -    def testFind(self): 
 78          if not externals.exists('atlas_fsl'): return 
 79          tshape = (182, 218, 182)        # target shape of fsl atlas chosen by default 
 80          atl = Atlas(name='HarvardOxford-Cortical') 
 81          atl.levels_dict[0].find('Frontal Pole') 
 82          self.failUnlessEqual( 
 83              len(atl.find(re.compile('Fusiform'), unique=False)), 
 84              4) 
 85   
 86          m = atl.getMap(1) 
 87          self.failUnlessEqual(m.shape, tshape) 
 88          self.failUnless(N.max(m)==100) 
 89          self.failUnless(N.min(m)==0) 
 90   
 91          ms = atl.getMaps('Fusiform') 
 92          self.failUnlessEqual(len(ms), 4) 
 93          self.failUnlessEqual(ms[0].shape, tshape) 
 94   
 95          ms = atl.getMaps('ZaZaZa') 
 96          self.failUnless(not len(ms)) 
 97   
 98          self.failUnlessRaises(ValueError, atl.getMap, 'Fusiform') 
 99          self.failUnless(len(atl.find('Fusiform', unique=False)) == 4) 
100          self.failUnlessEqual(atl.getMap('Fusiform', strategy='max').shape, 
101                               tshape) 
102   
103          # Test loading of custom atlas 
104          # for now just on the original file 
105          atl2 = Atlas(name='HarvardOxford-Cortical', 
106                       image_file=atl._image_file) 
107   
108          # we should get exactly the same maps from both in this dummy case 
109          self.failUnless((atl.getMap('Frontal Pole') == 
110                           atl2.getMap('Frontal Pole')).all()) 
111   
112   
113          # Lets falsify and feed some crammy file as the atlas 
114          atl2 = Atlas(name='HarvardOxford-Cortical', 
115                       image_file=os.path.join(pymvpa_dataroot, 
116                                               'example4d.nii.gz')) 
117   
118          # we should get not even comparable maps now ;) 
119          self.failUnless(atl.getMap('Frontal Pole').shape 
120                          != atl2.getMap('Frontal Pole').shape) 
121   
122   
123 -def suite(): 
124      return unittest.makeSuite(AtlasesTests) 
125   
126   
127  if __name__ == '__main__': 
128      import runner 
129