brkraw 0.3.11__py3-none-any.whl → 0.5.0__py3-none-any.whl

brkraw/lib/orient.py

@@ -1,194 +0,0 @@
-import math
-from copy import copy as cp
-
-import numpy as np
-from nibabel.affines import from_matvec, to_matvec
-
-from .reference import ERROR_MESSAGES
-
-
-def build_affine_from_orient_info(resol, rmat, pose,
-                                  subj_pose, subj_type, slice_orient):
-    if slice_orient in ['axial', 'sagital']:
-        resol = np.diag(np.array(resol))
-    else:
-        resol = np.diag(np.array(resol) * np.array([1, 1, -1]))
-    rmat = rmat.T.dot(resol)
-
-    affine = from_matvec(rmat, pose)
-
-    # convert space from image to subject
-    # below positions are all reflect human-based position
-    if subj_pose:
-        if subj_pose == 'Head_Supine':
-            affine = apply_rotate(affine, rad_z=np.pi)
-        elif subj_pose == 'Head_Prone':
-            pass
-        # From here, not urgent, extra work to determine correction matrix needed.
-        elif subj_pose == 'Head_Left':
-            affine = apply_rotate(affine, rad_z=np.pi/2)
-        elif subj_pose == 'Head_Right':
-            affine = apply_rotate(affine, rad_z=-np.pi/2)
-        elif subj_pose in ['Foot_Supine', 'Tail_Supine']:
-            affine = apply_rotate(affine, rad_x=np.pi)
-        elif subj_pose in ['Foot_Prone', 'Tail_Prone']:
-            affine = apply_rotate(affine, rad_y=np.pi)
-        elif subj_pose in ['Foot_Left', 'Tail_Left']:
-            affine = apply_rotate(affine, rad_z=np.pi/2)
-        elif subj_pose in ['Foot_Right', 'Tail_Right']:
-            affine = apply_rotate(affine, rad_z=-np.pi/2)
-        else:  # in case Bruker put additional value for this header
-            raise Exception(ERROR_MESSAGES['NotIntegrated'])
-
-    if subj_type != 'Biped':
-        # correct subject space if not biped (human or non-human primates)
-        # not sure this rotation is independent with subject pose, so put here instead last
-        affine = apply_rotate(affine, rad_x=-np.pi/2, rad_y=np.pi)
-    return affine
-
-
-def reversed_pose_correction(pose, rmat, distance):
-    reversed_pose = rmat.dot(pose)
-    reversed_pose[-1] += distance
-    corrected_pose = rmat.T.dot(reversed_pose)
-    return corrected_pose
-
-
-def is_rotation_matrix(matrix):
-    t_matrix = np.transpose(matrix)
-    should_be_identity = np.dot(t_matrix, matrix)
-    i = np.identity(3, dtype=matrix.dtype)
-    n = np.linalg.norm(i - should_be_identity)
-    return n < 1e-6
-
-
-def apply_flip(matrix, axis, mat=True, vec=True):
-    '''axis = x or y or z'''
-    flip_idx = dict(x=0, y=1, z=2)
-    orig_mat, orig_vec = to_matvec(matrix)
-
-    aff_mat = np.ones(3)
-    aff_mat[flip_idx[axis]] = -1
-    aff_mat = np.diag(aff_mat)
-    if mat:
-        flip_mat = aff_mat.dot(orig_mat)
-    else:
-        flip_mat = orig_mat
-    if vec:
-        flip_vec = aff_mat.dot(orig_vec)
-    else:
-        flip_vec = orig_vec
-    return from_matvec(flip_mat, flip_vec)
-
-
-def calc_eulerangle(matrix):
-    assert (is_rotation_matrix(matrix))
-
-    sy = math.sqrt(matrix[0, 0] * matrix[0, 0] + matrix[1, 0] * matrix[1, 0])
-    singular = sy < 1e-6
-    if not singular:
-        x = math.atan2(matrix[2, 1], matrix[2, 2])
-        y = math.atan2(-matrix[2, 0], sy)
-        z = math.atan2(matrix[1, 0], matrix[0, 0])
-    else:
-        x = math.atan2(-matrix[1, 2], matrix[1, 1])
-        y = math.atan2(-matrix[2, 0], sy)
-        z = 0
-    return np.array([math.degrees(x),
-                     math.degrees(y),
-                     math.degrees(z)])
-
-
-def apply_rotate(matrix, rad_x=0, rad_y=0, rad_z=0):
-    ''' axis = x or y or z '''
-    rmat = dict(x = np.array([[1, 0, 0],
-                              [0, np.cos(rad_x), -np.sin(rad_x)],
-                              [0, np.sin(rad_x), np.cos(rad_x)]]).astype('float'),
-                y = np.array([[np.cos(rad_y), 0, np.sin(rad_y)],
-                              [0, 1, 0],
-                              [-np.sin(rad_y), 0, np.cos(rad_y)]]).astype('float'),
-                z = np.array([[np.cos(rad_z), -np.sin(rad_z), 0],
-                              [np.sin(rad_z), np.cos(rad_z), 0],
-                              [0, 0, 1]]).astype('float'))
-    af_mat, af_vec = to_matvec(matrix)
-    rotated_mat = rmat['z'].dot(rmat['y'].dot(rmat['x'].dot(af_mat)))
-    rotated_vec = rmat['z'].dot(rmat['y'].dot(rmat['x'].dot(af_vec)))
-    return from_matvec(rotated_mat, rotated_vec)
-
-
-def apply_affine(matrix, affine):
-    return affine.dot(matrix)
-
-
-def swap_orient_matrix(orient_matrix, axis_orient):
-
-    orient_matrix = cp(orient_matrix)
-
-    axis_for_swap = []
-    for origin, destination in enumerate(axis_orient):
-        if origin != destination:
-            axis_for_swap.append(destination)
-    orient_matrix.T[axis_for_swap] = orient_matrix.T[axis_for_swap[::-1]]
-    return orient_matrix
-
-
-def get_origin(slice_position, gradient_orient):
-    """ TODO: the case was not fully tested, if any coordinate mismatch happened, this function will be the issue.
-    Args:
-        slice_position:  visu_pars.parameters['VisuCorePosition']
-        gradient_orient: method.parameters['PVM_SPackArrGradOrient']
-
-    Returns:
-        x, y, z coordinate for origin of image matrix
-    """
-    slice_position = cp(slice_position)
-    dx, dy, dz = map(lambda x: x.max() - x.min(), slice_position.T)
-    max_delta_axis = np.argmax([dx, dy, dz])
-    rx, ry, rz = [None, None, None]
-
-    if isinstance(gradient_orient, np.ndarray):
-        zmat = np.zeros(gradient_orient[0].shape)
-        for cid, col in enumerate(gradient_orient[0].T):
-            yid = np.argmax(abs(col))
-            zmat[cid, yid] = np.round(col[yid], decimals=0)
-        rx, ry, rz = calc_eulerangle(np.round(zmat.T))
-
-    if max_delta_axis == 0:     # sagital
-        if rx != None: # PV 5 filter, only PV6 has gradient_orient info
-            if rz == 90: # typical case
-                idx = slice_position.T[max_delta_axis].argmin()
-            else:
-                idx = slice_position.T[max_delta_axis].argmax()
-        else:
-            idx = slice_position.T[max_delta_axis].argmax()
-    elif max_delta_axis == 1:   # coronal
-        if rx != None:
-            if rx == -90:    # FOV flipped
-                if ry == -90:   # Cyceron cases # 5 and 9
-                    idx = slice_position.T[max_delta_axis].argmax()
-                else:
-                    idx = slice_position.T[max_delta_axis].argmin()
-            else: # rx == -90 are the typical case
-                idx = slice_position.T[max_delta_axis].argmax()
-        else:
-            idx = slice_position.T[max_delta_axis].argmaxs()
-    elif max_delta_axis == 2:   # axial
-        if rx != None:
-            if (abs(ry) == 180) or ((abs(rx) == 180) and (abs(rz) == 180)):
-                # typical case
-                idx = slice_position.T[max_delta_axis].argmax()
-            else:
-                idx = slice_position.T[max_delta_axis].argmin()
-        else:
-            idx = slice_position.T[max_delta_axis].argmin()
-    else:
-        raise Exception
-    origin = slice_position[idx]
-    return origin
-
-
-def reverse_swap(swap_code):
-    reversed_code = [0, 0, 0]
-    for target, origin in enumerate(swap_code):
-        reversed_code[origin] = target
-    return reversed_code

brkraw/lib/parser.py

@@ -1,48 +0,0 @@
-from .utils import *
-
-
-class Parameter:
-    def __init__(self, stringlist):
-        # parse the parameter dictionaries from stringlist
-        self._set_param(*load_param(stringlist))
-
-    @property
-    def parameters(self):
-        return self._parameters
-
-    @property
-    def headers(self):
-        return self._headers
-
-    def _set_param(self, params, param_addr, contents):
-        # get distance between each parameter
-        addr_diff = np.diff(param_addr)
-
-        # for debugging
-        self._contents = contents
-        # build dictionary for parameters
-        self._headers = OrderedDict()
-        self._parameters = OrderedDict()
-        for index, addr in enumerate(param_addr[:-1]):
-            dtype, key, value = params[addr]
-            shape = -1
-            # if there are spaces before next parameter apears
-            if addr_diff[index] > 1:
-                # collect all text within spaces
-                c_lines = contents[(addr + 1):(addr + addr_diff[index])]
-                # merge lines into single text as data
-                data = " ".join([line.strip() for line in c_lines if not re.match(ptrn_comment, line)])
-                # no contents in data
-                if not data:
-                    data = convert_string_to(value)
-                else:
-                    shape = value
-            else:
-                data = convert_string_to(value)
-
-            if dtype is PARAMETER:
-                self._parameters[key] = convert_data_to(data, shape)
-            elif dtype is HEADER:
-                self._headers[key] = data
-            else:
-                raise Exception

brkraw/lib/pvobj.py

@@ -1,301 +0,0 @@
-import os
-import zipfile as zf
-import functools
-from collections import namedtuple
-from .parser import Parameter
-from .utils import get_value
-
-_2dseq = namedtuple('img_2dseq', ['reco_id', 'idx'])
-_visu_pars = namedtuple('visu_pars', ['reco_id', 'idx'])
-_reco = namedtuple('reco', ['reco_id', 'idx'])
-
-
-class PvDatasetBase:
-    path = None
-    _subject = None
-    _fid = None
-    _traj = None
-    _method = None
-    _acqp = None
-    _avail_scanid = None
-    _avail_recoid = None
-
-    def __init__(self, path):
-        self._reset()
-
-    def _reset(self):
-        self._fid = dict()
-        self._traj = dict()
-        self._method = dict()
-        self._acqp = dict()
-        self._visu_pars = dict()
-        self._reco = dict()
-        self._2dseq = dict()
-
-    def _update_studyinfo(self):
-        if self._subject != None:
-            subject = self._subject
-            self.user_account   = subject.headers['OWNER']
-            self.subj_id        = get_value(subject, 'SUBJECT_id')
-            self.study_id       = get_value(subject, 'SUBJECT_study_nr')
-            self.session_id     = get_value(subject, 'SUBJECT_study_name')
-            
-            # [20210820] Add-paravision 360 related.
-            title = subject.headers['TITLE']
-            if "360" in title:
-                self.subj_entry = get_value(subject, 'SUBJECT_study_instrument_position').split('_')[0]
-                self.subj_pose  = get_value(subject, 'SUBJECT_study_instrument_position').split('_')[1]
-            else:
-                self.subj_entry = get_value(subject, 'SUBJECT_entry').split('_')[-1]
-                self.subj_pose  = get_value(subject, 'SUBJECT_position').split('_')[-1]
-            
-            #self.subj_entry     = get_value(subject, 'SUBJECT_entry').split('_')[-1]
-            #self.subj_pose      = get_value(subject, 'SUBJECT_position').split('_')[-1]
-            
-            self.subj_sex       = get_value(subject, 'SUBJECT_sex')
-            self.subj_type      = get_value(subject, 'SUBJECT_type')
-            self.subj_weight    = get_value(subject, 'SUBJECT_weight')
-            self.subj_dob       = get_value(subject, 'SUBJECT_dbirth')
-            self.user_name      = get_value(subject, 'SUBJECT_name_string')
-        else:
-            self.user_account   = None
-            self.subj_id        = None
-            self.study_id       = None
-            self.session_id     = None
-            self.subj_entry     = None
-            self.subj_pose      = None
-            self.subj_sex       = None
-            self.subj_type      = None
-            self.subj_weight    = None
-            self.subj_dob       = None
-            self.user_name      = None
-
-    def _parse_info(self):
-        pass
-
-    @property
-    def avail_scan_id(self):
-        self._avail_scanid = sorted(self._visu_pars.keys())
-        return self._avail_scanid
-
-    @property
-    def avail_reco_id(self):
-        self._avail_recoid = {}
-        for scan_id in self.avail_scan_id:
-            try:
-                self._avail_recoid[scan_id] = sorted(list(map(lambda x: x.reco_id, self._visu_pars[scan_id])))
-            except:
-                self.avail_scan_id.remove(scan_id)
-        return self._avail_recoid
-
-    def _open_binary(self, path):
-        pass
-
-    def _open_string(self, path):
-        pass
-
-    def get_dataobj(self, scan_id, reco_id):
-        import numpy as np
-        from .reference import BYTEORDER, WORDTYPE
-        from .utils import get_value, is_all_element_same
-
-        # parse datatype
-        visu_pars = self.get_visu_pars(scan_id, reco_id)
-        dtype_code = np.dtype('{}{}'.format(BYTEORDER[get_value(visu_pars, 'VisuCoreByteOrder')],
-                                            WORDTYPE[get_value(visu_pars, 'VisuCoreWordType')]))
-        # load dataobject
-        _2dseq = np.frombuffer(self.get_2dseq(scan_id, reco_id), dtype_code)
-
-        # Below code had integrated into header instead changing the value
-        # correction data slope and offset
-        # data_slp = get_value(visu_pars, 'VisuCoreDataSlope')
-        # if isinstance(data_slp, list):
-        #     data_slp = data_slp[0] if is_all_element_same(data_slp) else data_slp
-        # data_off = get_value(visu_pars, 'VisuCoreDataOffs')
-        # if isinstance(data_off, list):
-        #     data_off = data_off[0] if is_all_element_same(data_off) else data_off
-        # try:
-        #     recovered_2dseq = _2dseq * data_slp + data_off
-        # except:
-        #     raise Exception('size mismatch between data with slope or offset parameter.')
-        # return recovered_2dseq
-        return _2dseq
-
-    def get_fid(self, scan_id):
-        return self._open_binary(self._fid[scan_id])
-    
-    def get_traj(self, scan_id):
-        return self._open_binary(self._traj[scan_id])
-
-    def get_2dseq(self, scan_id, reco_id):
-        # return 2dseq binary string
-        for tpl in filter(functools.partial(lambda x, y: True if x.reco_id == y else False,
-                                            y=reco_id), self._2dseq[scan_id]):
-            return self._open_binary(tpl.idx)
-
-    def get_visu_pars(self, scan_id, reco_id):
-        for tpl in filter(functools.partial(lambda x, y: True if x.reco_id == y else False,
-                                            y=reco_id), self._visu_pars[scan_id]):
-            return Parameter(self._open_string(tpl.idx))
-
-    def get_reco(self, scan_id, reco_id):
-        for tpl in filter(functools.partial(lambda x, y: True if x.reco_id == y else False,
-                                            y=reco_id), self._reco[scan_id]):
-            return Parameter(self._open_string(tpl.idx))
-
-    def __repr__(self):
-        return 'PvDataset( storageLocation: "{}" )'.format(self.path)
-
-    def __del__(self):
-        self.close()
-
-    def close(self):
-        pass
-
-
-class PvDatasetDir(PvDatasetBase):
-    def __init__(self, path):
-        super(PvDatasetDir, self).__init__(path)
-        self.__path = path
-        self.path = os.path.basename(path)
-        self._parse_info()
-        self._update_studyinfo()
-
-    def _parse_info(self):
-        self._reset()
-        root_path_fregs = None
-        for root, subdir, files in os.walk(self.__path):
-            if 'subject' in files:
-                if root_path_fregs is None:
-                    root_path_fregs = len(root.split(os.sep))
-                    with open(os.path.join(root, 'subject'), 'r') as f:
-                        self._subject = Parameter(f.read().split('\n'))
-                else:
-                    pass
-            elif 'method' in files and 'acqp' in files:
-                if len(root.split(os.sep)) == root_path_fregs + 1:
-                    scan_id = os.path.basename(root)
-                    if scan_id.isdigit():
-                        with open(os.path.join(root, 'method'), 'r') as f:
-                            self._method[int(scan_id)] = Parameter(f.read().split('\n'))
-                        with open(os.path.join(root, 'acqp'), 'r') as f:
-                            self._acqp[int(scan_id)] = Parameter(f.read().split('\n'))
-                        fid_path = os.path.join(root, 'fid')
-                        traj_path = os.path.join(root, 'traj')
-                        if os.path.exists(fid_path):
-                            self._fid[int(scan_id)] = fid_path
-                        else:
-                            fid_path = os.path.join(root, 'rawdata.job0')
-                            if os.path.exists(fid_path):
-                                self._fid[int(scan_id)] = fid_path
-                        if os.path.exists(traj_path):
-                            self._traj[int(scan_id)] = traj_path
-            elif '2dseq' in files and 'visu_pars' in files:
-                path_freg = root.split(os.sep)
-                if len(root.split(os.sep)) == root_path_fregs + 3:
-                    scan_id = path_freg[-3]
-                    reco_id = path_freg[-1]
-                    if scan_id.isdigit() and reco_id.isdigit():
-                        if int(scan_id) in self._2dseq.keys():
-                            self._2dseq[int(scan_id)].append(_2dseq(reco_id=int(reco_id),
-                                                                    idx=os.path.join(root, '2dseq')))
-                        else:
-                            self._2dseq[int(scan_id)] = [_2dseq(reco_id=int(reco_id),
-                                                                idx=os.path.join(root, '2dseq'))]
-                        if int(scan_id) in self._visu_pars.keys():
-                            self._visu_pars[int(scan_id)].append(_visu_pars(reco_id=int(reco_id),
-                                                                            idx=os.path.join(root, 'visu_pars')))
-                        else:
-                            self._visu_pars[int(scan_id)] = [_visu_pars(reco_id=int(reco_id),
-                                                                        idx=os.path.join(root, 'visu_pars'))]
-                        if int(scan_id) in self._reco.keys():
-                            self._reco[int(scan_id)].append(_reco(reco_id=int(reco_id),
-                                                                  idx=os.path.join(root, 'reco')))
-                        else:
-                            self._reco[int(scan_id)] = [_reco(reco_id=int(reco_id),
-                                                              idx=os.path.join(root, 'reco'))]
-
-    def _open_object(self, path):
-        return open(path, 'rb')
-
-    def _open_binary(self, path):
-        return open(path, 'rb').read()
-
-    def _open_string(self, path):
-        return open(path, 'r').read().split('\n')
-
-
-class PvDatasetZip(zf.ZipFile, PvDatasetBase):
-    def __init__(self, path):
-        super(PvDatasetZip, self).__init__(path)
-        self._parse_info()
-        self._update_studyinfo()
-
-    def _parse_info(self):
-        self._reset()
-        # parse subject information
-        for idx, full_path in enumerate(self.namelist()):
-            # path_freg = full_path.split(os.path.sep)
-            path_freg = full_path.split('/') # zipfile uses / instead of os.sep
-            n_freg = len(path_freg)
-
-            if n_freg == 1:
-                # database object
-                pass
-
-            elif n_freg == 2:
-                if self.path is None:
-                    self.path = path_freg[0]
-                if path_freg[1] == 'subject':
-                    with self.open(full_path) as f:
-                        self._subject = Parameter(f.read().decode('UTF-8').split('\n'))
-
-            elif n_freg == 3 and path_freg[1].isdigit():
-                scan_id = int(path_freg[1])
-                filename = path_freg[2]
-
-                if filename == 'method':
-                    with self.open(full_path) as f:
-                        self._method[scan_id] = Parameter(f.read().decode('UTF-8').split('\n'))
-                elif filename == 'acqp':
-                    with self.open(full_path) as f:
-                        self._acqp[scan_id] = Parameter(f.read().decode('UTF-8').split('\n'))
-                elif filename == 'fid':
-                    self._fid[scan_id] = idx
-                elif filename == 'rawdata.job0':
-                    self._fid[scan_id] = idx
-                elif filename == 'traj':
-                    self._traj[scan_id] = idx
-                else:
-                    pass
-
-            elif n_freg == 5 and path_freg[2] == 'pdata':
-                scan_id = int(path_freg[1])
-                if path_freg[3].isdigit():
-                    reco_id = int(path_freg[3])
-                    filename = path_freg[4]
-
-                    if filename == '2dseq':
-                        if scan_id in self._2dseq.keys():
-                            self._2dseq[scan_id].append(_2dseq(reco_id=reco_id, idx=idx))
-                        else:
-                            self._2dseq[scan_id] = [_2dseq(reco_id=reco_id, idx=idx)]
-                    elif filename == 'visu_pars':
-                        if scan_id in self._visu_pars.keys():
-                            self._visu_pars[scan_id].append(_visu_pars(reco_id=reco_id, idx=idx))
-                        else:
-                            self._visu_pars[scan_id] = [_visu_pars(reco_id=reco_id, idx=idx)]
-                    elif filename == 'reco':
-                        if scan_id in self._reco.keys():
-                            self._reco[scan_id].append(_reco(reco_id=reco_id, idx=idx))
-                        else:
-                            self._reco[scan_id] = [_reco(reco_id=reco_id, idx=idx)]
-
-    def _open_object(self, path):
-        return self.open(self.namelist()[path])
-
-    def _open_binary(self, path):
-        return self.open(self.namelist()[path]).read()
-
-    def _open_string(self, path):
-        return self.open(self.namelist()[path]).read().decode('UTF-8').split('\n')