Merge latest from gallantlab

.gitignore

@@ -3,6 +3,8 @@ scripts
 
 # C extensions
 *.so
+cortex/formats.c
+cortex/openctm.c
 
 # Packages
 *.egg

cortex/align.py

@@ -75,7 +75,7 @@ def save_callback(aligner):
 
     return m
 
-def automatic(subject, xfmname, reference, noclean=False):
+def automatic(subject, xfmname, reference, noclean=False, bbrtype="signed"):
     """Create an automatic alignment using the FLIRT boundary-based alignment (BBR) from FSL. 
 
     If `noclean`, intermediate files will not be removed from /tmp. The `reference` image and resulting 
@@ -121,16 +121,17 @@ def automatic(subject, xfmname, reference, noclean=False):
         raw = db.get_anat(subject, type='raw').get_filename()
         bet = db.get_anat(subject, type='brainmask').get_filename()
         wmseg = db.get_anat(subject, type='whitematter').get_filename()
-        # Compute anatomical-to-epi transform
+        #Compute anatomical-to-epi transform
         print('FLIRT pre-alignment')
         cmd = '{fslpre}flirt  -in {epi} -ref {bet} -dof 6 -omat {cache}/init.mat'.format(
-            fslpre=fsl_prefix, cache=cache, epi=absreference, bet=bet)
+           fslpre=fsl_prefix, cache=cache, epi=absreference, bet=bet)
         if sp.call(cmd, shell=True) != 0:
-            raise IOError('Error calling initial FLIRT')
+           raise IOError('Error calling initial FLIRT')
+
         print('Running BBR')
         # Run epi-to-anat transform (this is more stable than anat-to-epi in FSL!)
-        cmd = '{fslpre}flirt -in {epi} -ref {raw} -dof 6 -cost bbr -wmseg {wmseg} -init {cache}/init.mat -omat {cache}/out.mat -schedule {schfile}'
-        cmd = cmd.format(fslpre=fsl_prefix, cache=cache, raw=raw, wmseg=wmseg, epi=absreference, schfile=schfile)
+        cmd = '{fslpre}flirt -in {epi} -ref {raw} -dof 6 -cost bbr -wmseg {wmseg} -init {cache}/init.mat -omat {cache}/out.mat -schedule {schfile} -bbrtype {bbrtype}'
+        cmd = cmd.format(fslpre=fsl_prefix, cache=cache, raw=bet, wmseg=wmseg, epi=absreference, schfile=schfile, bbrtype=bbrtype)
         if sp.call(cmd, shell=True) != 0:
             raise IOError('Error calling BBR flirt')
 

cortex/database.py

@@ -280,6 +280,9 @@ def get_surfinfo(self, subject, type="curvature", recache=False, **kwargs):
         -------
         verts : Vertex class
             If the surface information has "left" and "right" entries, a Vertex class is returned
+
+        - OR -
+
         npz : npzfile
             Otherwise, an npz object is returned. Remember to close it!
         """

cortex/dataset/__init__.py

@@ -1,12 +1,10 @@
 """Module for maintaining brain data and their masks
 
-Three basic classes, with child classes:
+Four basic classes:
   1. Dataset
-  2. BrainData
-    a. VolumeData
-    b. VertexData
-  3. View
-    a. DataView
+  2. Volume/Vertex
+  3. VolumeRGB/VertexRGB
+  4. Volume2D/Vertex2D
 
 Dataset holds a collection of View and BrainData objects. It provides a thin
 wrapper around h5py to store data. Datasets will store all View and BrainData
@@ -93,7 +91,8 @@ def from_file(cls, filename):
             try:
                 ds.views[name] = Dataview.from_hdf(node)
             except:
-                warnings.warn("Could not load view '%s'"%node.name)
+                import traceback
+                traceback.print_exc()
 
         db.auxfile = None
 

cortex/dataset/braindata.py

@@ -64,7 +64,7 @@ def to_json(self, simple=False):
                 subject=self.subject,
                 min=float(np.nan_to_num(self.data).min()), 
                 max=float(np.nan_to_num(self.data).max()),
-                shape=self.shape))
+                ))
         return sdict
 
     @classmethod
@@ -112,7 +112,9 @@ def __init__(self, data, subject, xfmname, mask=None, **kwargs):
 
     def to_json(self, simple=False):
         if simple:
-            return super(VolumeData, self).to_json(simple=simple)
+            sdict = super(VolumeData, self).to_json(simple=simple)
+            sdict["shape"] = self.shape
+            return sdict
 
         xfm = db.get_xfm(self.subject, self.xfmname, 'coord').xfm
         sdict = dict(xfm=[list(np.array(xfm).ravel())], data=[self.name])
@@ -201,9 +203,10 @@ def volume(self):
     def save(self, filename, name=None):
         """Save the dataset into an hdf file with the provided name
         """
+        import os
         if isinstance(filename, str):
             fname, ext = os.path.splitext(filename)
-            if ext in (".hdf", ".h5"):
+            if ext in (".hdf", ".h5",".hf5"):
                 h5 = h5py.File(filename, "a")
                 self._write_hdf(h5, name=name)
                 h5.close()
@@ -331,6 +334,16 @@ def __getitem__(self, idx):
         #return VertexData(self.data[idx], self.subject, **self.attrs)
         return self.copy(self.data[idx])
 
+    def to_json(self, simple=False):
+        if simple:
+            sdict = dict(split=self.llen, frames=self.vertices.shape[0])
+            sdict.update(super(VertexData, self).to_json(simple=simple))
+            return sdict
+
+        sdict = dict(data=[self.name])
+        sdict.update(super(VertexData, self).to_json())
+        return sdict
+
     @property
     def vertices(self):
         verts = self.data
@@ -378,9 +391,11 @@ def __init__(self, dv):
             self.data = dv.data
 
     def __getitem__(self, masktype):
-        s, x = self.dv.subject, self.dv.xfmname
-        mask = db.get_mask(s, x, masktype)
-        return self.dv.copy(self.dv.volume[:,mask].squeeze())
+        try:
+            mask = db.get_mask(self.dv.subject, self.dv.xfmname, masktype)
+            return self.dv.copy(self.dv.volume[:,mask].squeeze())
+        except:
+            self.dv.copy(self.dv.volume[:, mask].squeeze())
 
 def _hash(array):
     '''A simple numpy hash function'''

cortex/dataset/view2D.py

@@ -116,7 +116,9 @@ def raw(self):
         if self.dim1.xfmname != self.dim2.xfmname:
             raise ValueError("Both Volumes must have same xfmname to generate single raw volume")
 
-        if self.dim1.linear and self.dim2.linear and self.dim1.mask == self.dim2.mask:
+        if ((self.dim1.linear and self.dim2.linear) and
+            (self.dim1.mask.shape == self.dim2.mask.shape) and
+            np.all(self.dim1.mask == self.dim2.mask)):
             r, g, b, a = self._to_raw(self.dim1.data, self.dim2.data)
         else:
             r, g, b, a = self._to_raw(self.dim1.volume, self.dim2.volume)
@@ -128,7 +130,7 @@ def raw(self):
     def xfmname(self):
         return self.dim1.xfmname
 
-class Vertex2D(Dataview):
+class Vertex2D(Dataview2D):
     _cls = VertexData
     def __init__(self, dim1, dim2, subject=None, description="", cmap=None,
         vmin=None, vmax=None, vmin2=None, vmax2=None, **kwargs):
@@ -155,4 +157,4 @@ def __repr__(self):
     @property
     def raw(self):
         r, g, b, a = self._to_raw(self.dim1.data, self.dim2.data)
-        return VertexRGB(r, g, b, alpha=a, subject=self.dim1.subject)
+        return VertexRGB(r, g, b, alpha=a, subject=self.dim1.subject)

cortex/dataset/viewRGB.py

@@ -179,13 +179,21 @@ def vertices(self):
 
         verts = []
         for dv in (self.red, self.green, self.blue, alpha):
-            vert = dv.vertices
+            vert = dv.vertices.copy()
             if vert.dtype != np.uint8:
-                if vert.min() < 0:
-                    vert -= vert.min()
-                if vert.max() > 1:
-                    vert /= vert.max()
-                vert = (vert * 255).astype(np.uint8)
+                if dv.vmin is None:
+                    if vert.min() < 0:
+                        vert -= vert.min()
+                else:
+                    vert -= dv.vmin
+
+                if dv.vmax is None:
+                    if vert.max() > 1:
+                        vert /= vert.max()
+                else:
+                    vert /= dv.vmax - dv.vmin
+
+                vert = (np.clip(vert, 0, 1) * 255).astype(np.uint8)
             verts.append(vert)
 
         return np.array(verts).transpose([1, 2, 0])

cortex/dataset/views.py

@@ -219,8 +219,14 @@ def raw(self):
                 cm.register_cmap(self.cmap,cmap)
             else:
                 cmap = cm.get_cmap(self.cmap)
-        norm = colors.Normalize(self.vmin, self.vmax) # Does this do anything?
-        return np.rollaxis(cmap(self.data), -1)
+        elif isinstance(self.cmap,colors.Colormap):
+            cmap = self.cmap
+        # Normalize colors according to vmin, vmax
+        norm = colors.Normalize(self.vmin, self.vmax) 
+        cmapper = cm.ScalarMappable(norm=norm, cmap=cmap)
+        color_data = cmapper.to_rgba(self.data.flatten()).reshape(self.data.shape+(4,))
+        # rollaxis puts the last color dimension first, to allow output of separate channels: r,g,b,a = dataset.raw
+        return np.rollaxis(color_data, -1)
 
 class Multiview(Dataview):
     def __init__(self, views, description=""):