pycortex 1.2.7__tar.gz → 1.2.9__tar.gz

{pycortex-1.2.7 → pycortex-1.2.9}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.1
 Name: pycortex
-Version: 1.2.7
+Version: 1.2.9
 Summary: Python Cortical mapping software for fMRI data
 Home-page: http://gallantlab.github.io/pycortex
-Download-URL: http://gallantlab.github.io/pycortex
 Author: James Gao
 Author-email: james@jamesgao.com
 License: 2-clause BSD license
+Download-URL: http://gallantlab.github.io/pycortex
+Platform: UNKNOWN
 Classifier: Development Status :: 6 - Mature
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: BSD License
@@ -30,6 +31,10 @@ Pycortex is a software library that allows you to visualize fMRI or other volume
 
 Installation
 ------------
+
+> [!NOTE]
+> Pycortex cannot be currently installed in Windows, only Linux and macOS are supported.
+
 To install the stable release version of pycortex, do the following:
 
 ```bash
@@ -88,7 +93,4 @@ If you use pycortex in published work, please cite the [pycortex paper](http://d
 
 _Gao JS, Huth AG, Lescroart MD and Gallant JL (2015) Pycortex: an interactive surface visualizer for fMRI. Front. Neuroinform. 9:23. doi: 10.3389/fninf.2015.00023_
 
-Getting help
-------------
-Please post on [NeuroStars](https://neurostars.org/) with the tag `pycortex` to
-ask questions about how to use Pycortex.
+

{pycortex-1.2.7 → pycortex-1.2.9}/README.md

@@ -11,6 +11,10 @@ Pycortex is a software library that allows you to visualize fMRI or other volume
 
 Installation
 ------------
+
+> [!NOTE]
+> Pycortex cannot be currently installed in Windows, only Linux and macOS are supported.
+
 To install the stable release version of pycortex, do the following:
 
 ```bash
@@ -68,8 +72,3 @@ Citation
 If you use pycortex in published work, please cite the [pycortex paper](http://dx.doi.org/10.3389/fninf.2015.00023):
 
 _Gao JS, Huth AG, Lescroart MD and Gallant JL (2015) Pycortex: an interactive surface visualizer for fMRI. Front. Neuroinform. 9:23. doi: 10.3389/fninf.2015.00023_
-
-Getting help
-------------
-Please post on [NeuroStars](https://neurostars.org/) with the tag `pycortex` to
-ask questions about how to use Pycortex.

{pycortex-1.2.7 → pycortex-1.2.9}/cortex/align.py

@@ -1,9 +1,18 @@
 """Contains functions for making alignments between functional data and the surface, or, finding where the brain is.
 """
 import os
-import numpy as np
-from builtins import input
+import shutil
+import subprocess as sp
+import tempfile
 import warnings
+from builtins import input
+
+import numpy as np
+
+from .database import db
+from .options import config
+from .xfm import Transform
+
 
 def mayavi_manual(subject, xfmname, reference=None, **kwargs):
     """Open GUI for manually aligning a functional volume to the cortical surface for `subject`. This
@@ -155,11 +164,12 @@ def manual(subject, xfmname, output_name="register.lta", wm_color="yellow",
     Nothing unless noclean is true.
     """
 
+    import shutil
     import subprocess as sp
     import tempfile
-    import shutil
-    from .xfm import Transform
+
     from .database import db
+    from .xfm import Transform
 
     retval = None
 
@@ -235,120 +245,227 @@ def manual(subject, xfmname, output_name="register.lta", wm_color="yellow",
     return retval
 
 
-def automatic(subject, xfmname, reference, noclean=False, bbrtype="signed",
-              pre_flirt_args='', use_fs_bbr=True, epi_mask=False, intermediate=None):
-    """Create an automatic alignment using the FLIRT boundary-based alignment (BBR) from FSL.
+def automatic_fsl(
+    subject, xfmname, reference, noclean=False, bbrtype="signed", pre_flirt_args=""
+):
+    """Perform automatic alignment using the FLIRT boundary-based alignment (BBR) from 
+    FSL. The `reference` image and resulting transform called `xfmname` will be 
+    automatically stored in the database.
 
-    If `noclean`, intermediate files will not be removed from /tmp. The `reference` image and resulting
-    transform called `xfmname` will be automatically stored in the database.
+    If `noclean` is set to True, intermediate files will not be removed from /tmp. 
 
-    It's good practice to open up this transform afterward in the manual aligner and check how it worked.
-    Do that using the following (with the same `subject` and `xfmname` used here, no need for `reference`):
-    > align.manual(subject, xfmname)
+    It's good practice to open up this transform afterward in the manual aligner and 
+    check how it worked. Do that using the following code (passing the same `subject` 
+    and `xfmname` used here, no need for `reference`):
 
-    If automatic alignment gives you a very bad answer, you can try giving the pre-BBR FLIRT
-    some hints by passing '-usesqform' in as `pre_flirt_args`.
+    > cortex.align.manual(subject, xfmname)
+
+    If automatic alignment with FSL fails, you can try giving the pre-BBR FLIRT
+    some hints by passing '-usesqform' in as `pre_flirt_args`. Alternatively, you can 
+    use `cortex.align.automatic` to use Freesurfer's bbregister, which tends to work
+    better than FSL.
 
     Parameters
     ----------
     subject : str
         Subject identifier.
     xfmname : str
-        String identifying the transform to be created.
+        Name of the transform to be created and stored in the database.
     reference : str
-        Path to a nibabel-readable image that will be used as the reference for this transform.
-        Usually, this is a single (3D) functional data volume.
+        Path to a nibabel-readable image that will be used as the reference for
+        this transform. Usually, this is a single (3D) functional data volume.
     noclean : bool, optional
-        If True intermediate files will not be removed from /tmp (this is useful for debugging things),
-        and the returned value will be the name of the temp directory. Default False.
+        If True, intermediate files will not be removed from /tmp (this is useful
+        for debugging things), and the returned value will be the name of the
+        temp directory. Default False.
     bbrtype : str, optional
         The 'bbrtype' argument that is passed to FLIRT.
     pre_flirt_args : str, optional
         Additional arguments that are passed to the FLIRT pre-alignment step (not BBR).
-    use_fs_bbr : bool, optional
-        If True will use freesurfer bbregister instead of FSL BBR. (default, True)
-    epi_mask : bool, optional
-        If True, and use_fs_bbr is True, then the flag --epi-mask is passed to bbregister
-        to mask out areas with spatial distortions. This setting is to be used whenever
-        the reference was not distortion corrected.
-    intermediate : str
-        Path to a nibabel-readable image that will be used as intermediate for the alignment.
-        Usually, this is a single (3D) functional data volume.
 
     Returns
     -------
-    Nothing unless `noclean` is True.
+    None or path to temp directory if `noclean` is True.
     """
-    warnings.warn("Defaults changed in pycortex 1.3. Now automatic alignment "
-                  "uses Freesurfer's bbregister and mri_coreg for "
-                  "initialization.")
-    import shlex
-    import shutil
-    import tempfile
-    import subprocess as sp
-
-    from .database import db
-    from .xfm import Transform
-    from .options import config
-
-    fsl_prefix = config.get("basic", "fsl_prefix")
-    schfile = os.path.join(os.path.split(os.path.abspath(__file__))[0], "bbr.sch")
-
     retval = None
     try:
         cache = tempfile.mkdtemp()
         absreference = os.path.abspath(reference)
+        fsl_prefix = config.get("basic", "fsl_prefix")
+        schfile = os.path.join(os.path.split(os.path.abspath(__file__))[0], "bbr.sch")
+        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
+        print("FLIRT pre-alignment")
+        cmd = (
+            "{fslpre}flirt -in {epi} -ref {bet} -dof 6 {pre_flirt_args} "
+            "-omat {cache}/init.mat"
+        )
+        cmd = cmd.format(
+            fslpre=fsl_prefix,
+            cache=cache,
+            epi=absreference,
+            bet=bet,
+            pre_flirt_args=pre_flirt_args,
+        )
+        if sp.call(cmd, shell=True) != 0:
+            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} "
+            "-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")
 
-        if use_fs_bbr:
-            print('Running freesurfer BBR')
-            cmd = 'bbregister --s {sub} --mov {absref} --init-coreg --reg {cache}/register.dat --t2'
-            if epi_mask:
-                cmd += ' --epi-mask'
-            if intermediate is not None:
-                cmd += f' --int {intermediate}'
-            cmd = cmd.format(sub=subject, absref=absreference, cache=cache)
-
-            if sp.call(cmd, shell=True) != 0:
-                raise IOError('Error calling freesurfer BBR!')
+        x = np.loadtxt(os.path.join(cache, "out.mat"))
+        # Pass transform as FROM epi TO anat; transform will be inverted
+        # back to anat-to-epi, standard direction for pycortex internal
+        # storage by from_fsl
+        xfm = Transform.from_fsl(x, absreference, raw)
+        xfm.save(subject, xfmname, "coord")
+        print("Success")
 
-            xfm = Transform.from_freesurfer(os.path.join(cache, "register.dat"), absreference, subject)
+    finally:
+        if not noclean:
+            shutil.rmtree(cache)
         else:
-            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
-            print('FLIRT pre-alignment')
-            cmd = '{fslpre}flirt  -in {epi} -ref {bet} -dof 6 {pre_flirt_args} -omat {cache}/init.mat'.format(
-               fslpre=fsl_prefix, cache=cache, epi=absreference, bet=bet, pre_flirt_args=pre_flirt_args)
-            if sp.call(cmd, shell=True) != 0:
-               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} -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')
-
-            x = np.loadtxt(os.path.join(cache, "out.mat"))
-            # Pass transform as FROM epi TO anat; transform will be inverted
-            # back to anat-to-epi, standard direction for pycortex internal
-            # storage by from_fsl
-            xfm = Transform.from_fsl(x,absreference,raw)
+            retval = cache
+    return retval
 
-        # Save as pycortex 'coord' transform
-        xfm.save(subject,xfmname,'coord')
-        print('Success')
 
+def automatic(
+    subject,
+    xfmname,
+    reference,
+    init="coreg",
+    epi_mask=False,
+    intermediate=None,
+    reference_contrast="t2",
+    noclean=False,
+):
+    """Perform automatic alignment using Freesurfer's boundary-based registration.
+    The `reference` image and resulting transform called `xfmname` will be automatically
+    stored in the database.
+
+    If `noclean` is set to True, intermediate files will not be removed from /tmp.
+
+    It's good practice to open up this transform afterward in the manual aligner and
+    check how it worked. Do that using the following code (passing the same `subject`
+    and `xfmname` used here, no need for `reference`):
+
+    > cortex.align.manual(subject, xfmname)
+
+    Parameters
+    ----------
+    subject : str
+        Subject identifier.
+    xfmname : str
+        Name of the transform to be created and stored in the database.
+    reference : str
+        Path to a nibabel-readable image that will be used as the reference for
+        this transform. Usually, this is a single (3D) functional data volume.
+    init : str, optional
+        One of "coreg", "fsl", "header", or a path to a transform from the reference
+        volume to the anatomical volume.
+        Specifies the initialization method to obtain a first alignment that will be
+        refined with bbregister. Default is "coreg", which uses Freesurfer's `mri_coreg`
+        and it generally performs best. Other options include "fsl" to use FSL's FLIRT
+        or "header" to assume that the reference and the anatomical are already close
+        enough (this option can be used when the reference and the anatomical are
+        acquired in the same session). Finally, you can also specify a path to a
+        transform file (in DAT or LTA format) that will be used as initialization.
+    epi_mask : bool, optional
+        If True, then the flag --epi-mask is passed to bbregister to mask out areas
+        with spatial distortions. This setting recommended whenever the reference was
+        not distortion corrected.
+    intermediate : str
+        Path to a nibabel-readable image that will be used as intermediate volume
+        for alignment. This is useful if the reference image has a small field-of-view
+        and a whole-brain image was acquired in the same session.
+    reference_contrast : str
+        Contrast of the reference image. This is used to determine the appropriate
+        contrast for the reference image in the bbregister command. Default is "t2"
+        (for BOLD): gray matter is brighter than white matter.
+        The alternative option is "t1": white matter is brighter than gray matter.
+    noclean : bool, optional
+        If True, intermediate files will not be removed from /tmp (this is useful
+        for debugging things), and the returned value will be the name of the
+        temp directory. Default False.
+
+    Returns
+    -------
+    None or path to temp directory if `noclean` is True.
+    """
+    warnings.warn(
+        "Defaults changed in pycortex 1.2.8. Now automatic alignment uses Freesurfer's "
+        "bbregister and mri_coreg for initialization. If you want to use FSL's BBR, "
+        "use the function `cortex.align.automatic_fsl` instead."
+    )
+
+    retval = None
+    try:
+        cache = tempfile.mkdtemp()
+        reference = os.path.abspath(reference)
+        print("Running freesurfer BBR")
+        # Start building the command
+        cmd = f"bbregister --s {subject} --mov {reference} --reg {cache}/register.dat "
+        cmd += f"--{reference_contrast}"
+        if init in ["coreg", "fsl", "header"]:
+            cmd += f" --init-{init}"
+        else:
+            init = os.path.abspath(init)
+            cmd += f" --init-reg {init}"
+        if epi_mask:
+            cmd += " --epi-mask"
+        if intermediate is not None:
+            intermediate = os.path.abspath(intermediate)
+            cmd += f" --int {intermediate}"
+        cmd = cmd.format(sub=subject, absref=reference, cache=cache)
+
+        if sp.call(cmd.split()) != 0:
+            raise IOError("Error calling freesurfer BBR!")
+
+        xfm = Transform.from_freesurfer(
+            os.path.join(cache, "register.dat"), reference, subject
+        )
+        # Save as pycortex 'coord' transform
+        xfm.save(subject, xfmname, "coord")
+        # Load mincost to provide some information
+        # The four values stored in .mincost are
+        # 1. quality of the registration (0 to 1, with 0 is perfect)
+        # 2. mean of WM just below the surface
+        # 3. mean of GM just above the surface
+        # 4. percent contrast
+        # https://surfer.nmr.mgh.harvard.edu/fswiki/MultiModalTutorialV6.0/MultiModalRegistration
+        # Let's return only the quality of the registration
+        mincost = np.loadtxt(os.path.join(cache, "register.dat.mincost"))
+        print(
+            f"bbregister finished with a mincost of {mincost[0]:.2f}\n"
+            "Values between 0 and 0.5 indicate a good registration.\n"
+            "But you should manually inspect the alignment anyway."
+        )
     finally:
         if not noclean:
             shutil.rmtree(cache)
         else:
             retval = cache
-
     return retval
 
+
 def autotweak(subject, xfmname):
     """Tweak an alignment using the FLIRT boundary-based alignment (BBR) from FSL.
     Ideally this function should actually use a limited search range, but it doesn't.
@@ -363,12 +480,12 @@ def autotweak(subject, xfmname):
     """
     import shlex
     import shutil
-    import tempfile
     import subprocess as sp
+    import tempfile
 
     from .database import db
-    from .xfm import Transform
     from .options import config
+    from .xfm import Transform
 
     fsl_prefix = config.get("basic", "fsl_prefix")
     schfile = os.path.join(os.path.split(os.path.abspath(__file__))[0], "bbr.sch")

{pycortex-1.2.7 → pycortex-1.2.9}/cortex/blender/__init__.py

@@ -60,7 +60,7 @@ def _check_file_blender_version(fpath):
     import struct
     with open(fpath, mode='rb') as fid:
         fid.seek(7)
-        bitness, endianess, major, minor = struct.unpack("sss2s", fid.read(5))
+        bitness, endianness, major, minor = struct.unpack("sss2s", fid.read(5))
     return (int(major), int(minor))
 
 

{pycortex-1.2.7 → pycortex-1.2.9}/cortex/database.py

@@ -1,18 +1,19 @@
 """
 Contains a singleton object `db` of type `Database` which allows easy access to surface files, anatomical images, and transforms that are stored in the pycortex filestore.
 """
-import os
-import re
 import copy
+import functools
 import glob
 import json
+import os
+import re
 import shutil
-import warnings
 import tempfile
-import functools
-import numpy as np
-from hashlib import sha1
+import warnings
 from builtins import input
+from hashlib import sha1
+
+import numpy as np
 
 from . import options
 
@@ -104,7 +105,8 @@ class XfmDB(object):
         raise AttributeError
     
     def __repr__(self):
-        return "Transforms: [{xfms}]".format(xfms=",".join(self.xfms))
+        xfms = "\n".join(sorted(self.xfms))
+        return f"Available transforms for {self.subject}:\n{xfms}"
 
 class XfmSet(object):
     def __init__(self, subj, name, filestore=default_filestore):
@@ -177,6 +179,7 @@ class Database(object):
             return self._subjects
         subjs = os.listdir(os.path.join(self.filestore))
         subjs = [s for s in subjs if os.path.isdir(os.path.join(self.filestore, s))]
+        subjs = sorted(subjs)
         self._subjects = dict([(sname, SubjectDB(sname, filestore=self.filestore)) for sname in subjs])
         return self._subjects
 
@@ -225,7 +228,7 @@ class Database(object):
         return volume.anat2epispace(anatnib.get_fdata().T.astype(float), subject, xfmname, order=order)
 
     def get_surfinfo(self, subject, type="curvature", recache=False, **kwargs):
-        """Return auxillary surface information from the filestore. Surface info is defined as 
+        """Return auxiliary surface information from the filestore. Surface info is defined as 
         anatomical information specific to a subject in surface space. A Vertex class will be returned
         as necessary. Info not found in the filestore will be automatically generated.
 
@@ -318,8 +321,12 @@ class Database(object):
         from .utils import load_sparse_array, save_sparse_array
         if fs_subj is None:
             fs_subj = subject
-        fpath = self.get_paths(subject)['surf2surf'].format(source=fs_subj, target=target_subj)
-        # Backward compatiblity
+        fpath = self.get_paths(subject)['surf2surf'].format(
+            source=fs_subj,
+            target=target_subj,
+            surface_type=surface_type
+        )
+        # Backward compatibility
         fdir, _ = os.path.split(fpath)
         if not os.path.exists(fdir):
             print("Creating surf2surf directory for subject %s"%(subject))
@@ -344,7 +351,7 @@ class Database(object):
         pts, polys = self.get_surf(subject, "flat", merge=True, nudge=True)
 
         paths = self.get_paths(subject)
-        # NOTE: This try loop is broken, in that it does nothing for the inteded 
+        # NOTE: This try loop is broken, in that it does nothing for the intended 
         # use case (loading an overlay from a packed subject) - needs fixing. 
         # This hasn't come up yet due to very rare use of packed subjects.
         if self.auxfile is not None:
@@ -686,7 +693,7 @@ class Database(object):
             rois=os.path.join(self.filestore, subject, "rois.svg").format(subj=subject),
             overlays=os.path.join(self.filestore, subject, "overlays.svg").format(subj=subject),
             views=sorted([os.path.splitext(f)[0] for f in views]),
-            surf2surf=os.path.join(self.filestore, subject, "surf2surf", "{source}_to_{target}", "matrices.hdf"),
+            surf2surf=os.path.join(self.filestore, subject, "surf2surf", "{source}_to_{target}", "matrices_{surface_type}.hdf"),
         )
 
         return filenames

{pycortex-1.2.7 → pycortex-1.2.9}/cortex/dataset/braindata.py

@@ -1,10 +1,12 @@
 import hashlib
 from copy import deepcopy
-import numpy as np
+
 import h5py
+import numpy as np
 
 from ..database import db
 
+
 class BrainData(object):
     """
     Abstract base class for brain data.
@@ -592,9 +594,10 @@ class VertexData(BrainData):
 
 
 def _find_mask(nvox, subject, xfmname):
+    import glob
     import os
     import re
-    import glob
+
     import nibabel
     files = db.get_paths(subject)['masks'].format(xfmname=xfmname, type="*")
     for fname in glob.glob(files):
@@ -602,7 +605,7 @@ def _find_mask(nvox, subject, xfmname):
         mask = nib.get_fdata().T != 0
         if nvox == np.sum(mask):
             fname = os.path.split(fname)[1]
-            name = re.compile(r'mask_([\w]+).nii.gz').search(fname)
+            name = re.compile(r'mask_(.+).nii.gz').search(fname)
             return name.group(1), mask
 
     raise ValueError('Cannot find a valid mask')

{pycortex-1.2.7 → pycortex-1.2.9}/cortex/dataset/viewRGB.py

@@ -179,7 +179,7 @@ class VolumeRGB(DataviewRGB):
         Use the same vmin and vmax for all three color channels?
     shared_vmin : float, optional
         Predetermined shared vmin. Does nothing if shared_range == False. If not given,
-        will be the 1st percentil of all values across all three channels.
+        will be the 1st percentile of all values across all three channels.
     shared_vmax : float, optional
         Predetermined shared vmax. Does nothing if shared_range == False. If not given,
         will be the 99th percentile of all values across all three channels

{pycortex-1.2.7 → pycortex-1.2.9}/cortex/dataset/views.py

@@ -1,14 +1,23 @@
-import os
 import glob
 import json
+import os
+
 import h5py
 import numpy as np
 
 from .. import options
-from .braindata import BrainData, VolumeData, VertexData
+from .braindata import BrainData, VertexData, VolumeData
 
 default_cmap = options.config.get("basic", "default_cmap")
 
+# register_cmap is deprecated in matplotlib > 3.7.0 and replaced by colormaps.register
+try:
+    from matplotlib import colormaps as cm
+    def register_cmap(cmap):
+        return cm.register(cmap)
+except ImportError:
+    from matplotlib.cm import register_cmap
+
 
 def normalize(data):
     if isinstance(data, tuple):
@@ -193,7 +202,8 @@ class Dataview(object):
     def get_cmapdict(self):
         """Returns a dictionary with cmap information."""
 
-        from matplotlib import colors, pyplot as plt
+        from matplotlib import colors
+        from matplotlib import pyplot as plt
 
         try:
             # plt.get_cmap accepts:
@@ -206,18 +216,19 @@ class Dataview(object):
             cmapdir = options.config.get('webgl', 'colormaps')
             colormaps = glob.glob(os.path.join(cmapdir, "*.png"))
             colormaps = dict(((os.path.split(c)[1][:-4], c) for c in colormaps))
-            if not self.cmap in colormaps:
+            if self.cmap not in colormaps:
                 raise ValueError('Unkown color map %s' % self.cmap)
             I = plt.imread(colormaps[self.cmap])
-            cmap = colors.ListedColormap(np.squeeze(I))
+            name = self.cmap if isinstance(self.cmap, str) else self.cmap.name
+            cmap = colors.ListedColormap(np.squeeze(I), name=name)
             # Register colormap to matplotlib to avoid loading it again
-            plt.register_cmap(self.cmap, cmap)
+            register_cmap(cmap)
 
         return dict(cmap=cmap, vmin=self.vmin, vmax=self.vmax)
 
     @property
     def raw(self):
-        from matplotlib import colors, cm
+        from matplotlib import cm, colors
 
         cmap = self.get_cmapdict()['cmap']
         # Normalize colors according to vmin, vmax
@@ -398,5 +409,5 @@ def u(s, encoding='utf8'):
         return s
 
 
-from .viewRGB import VolumeRGB, VertexRGB, Colors
-from .view2D import Volume2D, Vertex2D
+from .viewRGB import Colors, VertexRGB, VolumeRGB
+from .view2D import Vertex2D, Volume2D