MAINT: remove io.meas_info duplicates in digitization._utils

Joan Massich · Joan Massich · commit 73bd1944966c · 2019-05-23T11:31:52.000+02:00
diff --git a/mne/channels/montage.py b/mne/channels/montage.py
@@ -20,8 +20,8 @@
 from .channels import _contains_ch_type
 from ..transforms import (apply_trans, get_ras_to_neuromag_trans, _sph_to_cart,
                           _topo_to_sph, _str_to_frame, _frame_to_str)
-from ..io.meas_info import (_make_dig_points, _read_dig_points, _read_dig_fif,
-                            write_dig)
+from ..digitization._utils import (_make_dig_points, _read_dig_points,
+                                   _read_dig_fif, write_dig)
 from ..io.pick import pick_types
 from ..io.open import fiff_open
 from ..io.constants import FIFF
diff --git a/mne/digitization/_mess.py b/mne/digitization/_mess.py
@@ -7,8 +7,8 @@
 # Things that should be common to every reader
 
 # from ..io.meas_info import _empty_info
-from ..io.meas_info import _read_dig_points
-from ..io.meas_info import _make_dig_points
+from ._utils import _read_dig_points
+from ._utils import _make_dig_points
 from ..transforms import apply_trans
 from ..transforms import als_ras_trans
 from ..transforms import get_ras_to_neuromag_trans
diff --git a/mne/digitization/_utils.py b/mne/digitization/_utils.py
@@ -25,7 +25,7 @@
 from mne.utils import warn
 from mne.utils.check import _check_option
 from mne import __version__
-from .base import _format_dig_points
+from .base import _format_dig_points, Digitization
 
 b = bytes  # alias
 
@@ -173,6 +173,7 @@ def _write_dig_points(fname, dig_points):
         raise ValueError(msg)
 
 
+# XXX: all points are supposed to be in FIFFV_COORD_HEAD
 def _make_dig_points(nasion=None, lpa=None, rpa=None, hpi=None,
                      extra_points=None, dig_ch_pos=None):
     """Construct digitizer info for the info.
@@ -194,8 +195,8 @@ def _make_dig_points(nasion=None, lpa=None, rpa=None, hpi=None,
 
     Returns
     -------
-    dig : list
-        List of digitizer points to be added to the info['dig'].
+    dig : Digitization
+        A container of DigPoints to be added to the info['dig'].
     """
     dig = []
     if lpa is not None:
@@ -250,4 +251,5 @@ def _make_dig_points(nasion=None, lpa=None, rpa=None, hpi=None,
             dig.append({'r': dig_ch_pos[key], 'ident': ident,
                         'kind': FIFF.FIFFV_POINT_EEG,
                         'coord_frame': FIFF.FIFFV_COORD_HEAD})
-    return _format_dig_points(dig)
+
+    return Digitization(_format_dig_points(dig))
diff --git a/mne/gui/_kit2fiff_gui.py b/mne/gui/_kit2fiff_gui.py
@@ -13,7 +13,7 @@
 from scipy.linalg import inv
 from threading import Thread
 
-from ..io.meas_info import _read_dig_points, _make_dig_points
+from ..digitization._utils import _read_dig_points, _make_dig_points
 from ..utils import get_config, set_config, logger, warn
 
 from mayavi.core.ui.mayavi_scene import MayaviScene
diff --git a/mne/gui/_marker_gui.py b/mne/gui/_marker_gui.py
@@ -20,7 +20,7 @@
 from ..transforms import apply_trans, rotation, translation
 from ..coreg import fit_matched_points
 from ..io.kit import read_mrk
-from ..io.meas_info import _write_dig_points
+from ..digitization._utils import _write_dig_points
 from ._viewer import PointObject
 from ._backend import _check_pyface_backend
 
diff --git a/mne/io/artemis123/artemis123.py b/mne/io/artemis123/artemis123.py
@@ -11,7 +11,8 @@
 from ...utils import logger, warn, verbose
 from ..utils import _read_segments_file
 from ..base import BaseRaw
-from ..meas_info import _empty_info, _make_dig_points
+from ..meas_info import _empty_info
+from ...digitization._utils import _make_dig_points
 from ..constants import FIFF
 from ...chpi import _fit_device_hpi_positions, _fit_coil_order_dev_head_trans
 from ...transforms import get_ras_to_neuromag_trans, apply_trans, Transform
diff --git a/mne/io/kit/coreg.py b/mne/io/kit/coreg.py
@@ -12,7 +12,7 @@
 import numpy as np
 
 from .constants import KIT
-from ..meas_info import _read_dig_points
+from ...digitization._utils import _read_dig_points
 
 
 def read_mrk(fname):
diff --git a/mne/io/kit/tests/test_coreg.py b/mne/io/kit/tests/test_coreg.py
@@ -10,7 +10,7 @@
 from numpy.testing import assert_array_equal
 
 from mne.io.kit import read_mrk
-from mne.io.meas_info import _write_dig_points
+from mne.digitization._utils import _write_dig_points
 from mne.utils import _TempDir
 
 
diff --git a/mne/io/meas_info.py b/mne/io/meas_info.py
@@ -11,8 +11,6 @@
 import datetime
 from io import BytesIO
 import operator
-import os.path as op
-import re
 
 import numpy as np
 from scipy import linalg
@@ -29,16 +27,15 @@
                     write_coord_trans, write_ch_info, write_name_list,
                     write_julian, write_float_matrix, write_id, DATE_NONE)
 from .proc_history import _read_proc_history, _write_proc_history
-from ..transforms import _to_const, invert_transform
-from ..utils import (logger, verbose, warn, object_diff, _validate_type,
-                     _check_option)
-from .. import __version__
+from ..transforms import invert_transform
+from ..utils import logger, verbose, warn, object_diff, _validate_type
 from ..digitization.base import _format_dig_points
 from ..digitization import Digitization
 from .compensator import get_current_comp
 
 # XXX: most probably the functions needing this, should go somewhere else
 from ..digitization.base import _dig_kind_proper, _dig_kind_rev, _dig_kind_ints
+from ..digitization._utils import _read_dig_fif
 
 b = bytes  # alias
 
@@ -661,7 +658,8 @@ def write_fiducials(fname, pts, coord_frame=FIFF.FIFFV_COORD_UNKNOWN,
         mne.io.constants.FIFF.FIFFV_COORD_...).
     %(verbose)s
     """
-    write_dig(fname, pts, coord_frame)
+    from ..digitization._utils import write_dig as ff
+    ff(fname, pts, coord_frame)
 
 
 def write_dig(fname, pts, coord_frame=None):
@@ -679,214 +677,8 @@ def write_dig(fname, pts, coord_frame=None):
         here. Can be None (default) if the points could have varying
         coordinate frames.
     """
-    if coord_frame is not None:
-        coord_frame = _to_const(coord_frame)
-        pts_frames = {pt.get('coord_frame', coord_frame) for pt in pts}
-        bad_frames = pts_frames - {coord_frame}
-        if len(bad_frames) > 0:
-            raise ValueError(
-                'Points have coord_frame entries that are incompatible with '
-                'coord_frame=%i: %s.' % (coord_frame, str(tuple(bad_frames))))
-
-    with start_file(fname) as fid:
-        write_dig_points(fid, pts, block=True, coord_frame=coord_frame)
-        end_file(fid)
-
-
-def _read_dig_fif(fid, meas_info):
-    """Read digitizer data from a FIFF file."""
-    isotrak = dir_tree_find(meas_info, FIFF.FIFFB_ISOTRAK)
-    dig = None
-    if len(isotrak) == 0:
-        logger.info('Isotrak not found')
-    elif len(isotrak) > 1:
-        warn('Multiple Isotrak found')
-    else:
-        isotrak = isotrak[0]
-        dig = []
-        for k in range(isotrak['nent']):
-            kind = isotrak['directory'][k].kind
-            pos = isotrak['directory'][k].pos
-            if kind == FIFF.FIFF_DIG_POINT:
-                tag = read_tag(fid, pos)
-                dig.append(tag.data)
-                dig[-1]['coord_frame'] = FIFF.FIFFV_COORD_HEAD
-    return _format_dig_points(dig)
-
-
-def _read_dig_points(fname, comments='%', unit='auto'):
-    """Read digitizer data from a text file.
-
-    If fname ends in .hsp or .esp, the function assumes digitizer files in [m],
-    otherwise it assumes space-delimited text files in [mm].
-
-    Parameters
-    ----------
-    fname : str
-        The filepath of space delimited file with points, or a .mat file
-        (Polhemus FastTrak format).
-    comments : str
-        The character used to indicate the start of a comment;
-        Default: '%'.
-    unit : 'auto' | 'm' | 'cm' | 'mm'
-        Unit of the digitizer files (hsp and elp). If not 'm', coordinates will
-        be rescaled to 'm'. Default is 'auto', which assumes 'm' for *.hsp and
-        *.elp files and 'mm' for *.txt files, corresponding to the known
-        Polhemus export formats.
-
-    Returns
-    -------
-    dig_points : np.ndarray, shape (n_points, 3)
-        Array of dig points in [m].
-    """
-    _check_option('unit', unit, ['auto', 'm', 'mm', 'cm'])
-
-    _, ext = op.splitext(fname)
-    if ext == '.elp' or ext == '.hsp':
-        with open(fname) as fid:
-            file_str = fid.read()
-        value_pattern = r"\-?\d+\.?\d*e?\-?\d*"
-        coord_pattern = r"({0})\s+({0})\s+({0})\s*$".format(value_pattern)
-        if ext == '.hsp':
-            coord_pattern = '^' + coord_pattern
-        points_str = [m.groups() for m in re.finditer(coord_pattern, file_str,
-                                                      re.MULTILINE)]
-        dig_points = np.array(points_str, dtype=float)
-    elif ext == '.mat':  # like FastScan II
-        from scipy.io import loadmat
-        dig_points = loadmat(fname)['Points'].T
-    else:
-        dig_points = np.loadtxt(fname, comments=comments, ndmin=2)
-        if unit == 'auto':
-            unit = 'mm'
-        if dig_points.shape[1] > 3:
-            warn('Found %d columns instead of 3, using first 3 for XYZ '
-                 'coordinates' % (dig_points.shape[1],))
-            dig_points = dig_points[:, :3]
-
-    if dig_points.shape[-1] != 3:
-        err = 'Data must be (n, 3) instead of %s' % (dig_points.shape,)
-        raise ValueError(err)
-
-    if unit == 'mm':
-        dig_points /= 1000.
-    elif unit == 'cm':
-        dig_points /= 100.
-
-    return dig_points
-
-
-def _write_dig_points(fname, dig_points):
-    """Write points to text file.
-
-    Parameters
-    ----------
-    fname : str
-        Path to the file to write. The kind of file to write is determined
-        based on the extension: '.txt' for tab separated text file.
-    dig_points : numpy.ndarray, shape (n_points, 3)
-        Points.
-    """
-    _, ext = op.splitext(fname)
-    dig_points = np.asarray(dig_points)
-    if (dig_points.ndim != 2) or (dig_points.shape[1] != 3):
-        err = ("Points must be of shape (n_points, 3), "
-               "not %s" % (dig_points.shape,))
-        raise ValueError(err)
-
-    if ext == '.txt':
-        with open(fname, 'wb') as fid:
-            version = __version__
-            now = datetime.datetime.now().strftime("%I:%M%p on %B %d, %Y")
-            fid.write(b'%% Ascii 3D points file created by mne-python version'
-                      b' %s at %s\n' % (version.encode(), now.encode()))
-            fid.write(b'%% %d 3D points, x y z per line\n' % len(dig_points))
-            np.savetxt(fid, dig_points, delimiter='\t', newline='\n')
-    else:
-        msg = "Unrecognized extension: %r. Need '.txt'." % ext
-        raise ValueError(msg)
-
-
-# XXX: all points are supposed to be in FIFFV_COORD_HEAD
-def _make_dig_points(nasion=None, lpa=None, rpa=None, hpi=None,
-                     extra_points=None, dig_ch_pos=None):
-    """Construct digitizer info for the info.
-
-    Parameters
-    ----------
-    nasion : array-like | numpy.ndarray, shape (3,) | None
-        Point designated as the nasion point.
-    lpa : array-like |  numpy.ndarray, shape (3,) | None
-        Point designated as the left auricular point.
-    rpa : array-like |  numpy.ndarray, shape (3,) | None
-        Point designated as the right auricular point.
-    hpi : array-like | numpy.ndarray, shape (n_points, 3) | None
-        Points designated as head position indicator points.
-    extra_points : array-like | numpy.ndarray, shape (n_points, 3)
-        Points designed as the headshape points.
-    dig_ch_pos : dict
-        Dict of EEG channel positions.
-
-    Returns
-    -------
-    dig : Digitization
-        A container of DigPoints to be added to the info['dig'].
-    """
-    dig = []
-    if lpa is not None:
-        lpa = np.asarray(lpa)
-        if lpa.shape != (3,):
-            raise ValueError('LPA should have the shape (3,) instead of %s'
-                             % (lpa.shape,))
-        dig.append({'r': lpa, 'ident': FIFF.FIFFV_POINT_LPA,
-                    'kind': FIFF.FIFFV_POINT_CARDINAL,
-                    'coord_frame': FIFF.FIFFV_COORD_HEAD})
-    if nasion is not None:
-        nasion = np.asarray(nasion)
-        if nasion.shape != (3,):
-            raise ValueError('Nasion should have the shape (3,) instead of %s'
-                             % (nasion.shape,))
-        dig.append({'r': nasion, 'ident': FIFF.FIFFV_POINT_NASION,
-                    'kind': FIFF.FIFFV_POINT_CARDINAL,
-                    'coord_frame': FIFF.FIFFV_COORD_HEAD})
-    if rpa is not None:
-        rpa = np.asarray(rpa)
-        if rpa.shape != (3,):
-            raise ValueError('RPA should have the shape (3,) instead of %s'
-                             % (rpa.shape,))
-        dig.append({'r': rpa, 'ident': FIFF.FIFFV_POINT_RPA,
-                    'kind': FIFF.FIFFV_POINT_CARDINAL,
-                    'coord_frame': FIFF.FIFFV_COORD_HEAD})
-    if hpi is not None:
-        hpi = np.asarray(hpi)
-        if hpi.ndim != 2 or hpi.shape[1] != 3:
-            raise ValueError('HPI should have the shape (n_points, 3) instead '
-                             'of %s' % (hpi.shape,))
-        for idx, point in enumerate(hpi):
-            dig.append({'r': point, 'ident': idx + 1,
-                        'kind': FIFF.FIFFV_POINT_HPI,
-                        'coord_frame': FIFF.FIFFV_COORD_HEAD})
-    if extra_points is not None:
-        extra_points = np.asarray(extra_points)
-        if extra_points.shape[1] != 3:
-            raise ValueError('Points should have the shape (n_points, 3) '
-                             'instead of %s' % (extra_points.shape,))
-        for idx, point in enumerate(extra_points):
-            dig.append({'r': point, 'ident': idx + 1,
-                        'kind': FIFF.FIFFV_POINT_EXTRA,
-                        'coord_frame': FIFF.FIFFV_COORD_HEAD})
-    if dig_ch_pos is not None:
-        keys = sorted(dig_ch_pos.keys())
-        try:  # use the last 3 as int if possible (e.g., EEG001->1)
-            idents = [int(key[-3:]) for key in keys]
-        except ValueError:  # and if any conversion fails, simply use arange
-            idents = np.arange(1, len(keys) + 1)
-        for key, ident in zip(keys, idents):
-            dig.append({'r': dig_ch_pos[key], 'ident': ident,
-                        'kind': FIFF.FIFFV_POINT_EEG,
-                        'coord_frame': FIFF.FIFFV_COORD_HEAD})
-
-    return Digitization(_format_dig_points(dig))
+    from ..digitization._utils import write_dig as ff
+    return ff(fname, pts, coord_frame=None)
 
 
 @verbose
diff --git a/mne/io/tests/test_meas_info.py b/mne/io/tests/test_meas_info.py
@@ -21,10 +21,11 @@
                     anonymize_info)
 from mne.io.constants import FIFF
 from mne.io.write import DATE_NONE
-from mne.io.meas_info import (Info, create_info, _write_dig_points,
-                              _read_dig_points, _make_dig_points, _merge_info,
+from mne.io.meas_info import (Info, create_info, _merge_info,
                               _force_update_info, RAW_INFO_FIELDS,
                               _bad_chans_comp, _get_valid_units)
+from mne.digitization._utils import (_write_dig_points, _read_dig_points,
+                                     _make_dig_points,)
 from mne.io import read_raw_ctf
 from mne.utils import _TempDir, run_tests_if_main, catch_logging
 from mne.channels.montage import read_montage, read_dig_montage
diff --git a/mne/viz/tests/test_3d.py b/mne/viz/tests/test_3d.py
@@ -19,7 +19,7 @@
                  setup_volume_source_space, read_forward_solution,
                  VolVectorSourceEstimate)
 from mne.io import read_raw_ctf, read_raw_bti, read_raw_kit, read_info
-from mne.io.meas_info import write_dig
+from mne.digitization._utils import write_dig
 from mne.io.pick import pick_info
 from mne.io.constants import FIFF
 from mne.viz import (plot_sparse_source_estimates, plot_source_estimates,
