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

brkraw/ui/config.py

@@ -1,17 +0,0 @@
-import sys
-if sys.platform == 'darwin':
-    font                = 'arial 14'
-    button_size         = 10
-else:
-    font                = 'arial 10'
-    button_size         = 12
-win_pre_width           = 250
-win_pst_width           = 1050
-win_pre_height          = 40
-win_pst_height          = 680
-
-window_posx             = 100
-window_posy             = 100
-
-viewer_width            = 400
-viewer_height           = 400

brkraw/ui/main_win.py

@@ -1,214 +0,0 @@
-import tkinter as tk
-from tkinter import filedialog
-from brkraw import __version__, load
-from .scan_list import ScanList
-from .scan_info import ScanInfo
-from .subj_info import SubjInfo
-from .previewer import Previewer
-from .config import win_pre_width as _width, win_pre_height as _height
-from .config import win_pst_width, win_pst_height
-from .config import window_posx, window_posy
-
-class MainWindow(tk.Tk):
-    def __init__(self, *args, **kwargs):
-        super(MainWindow, self).__init__(*args, **kwargs)
-        self._raw = None
-        self._ignore_slope = False
-        self._ignore_offset = False
-        self._scan_id = None
-        self._reco_id = None
-        self._output = None
-        self.title('BrkRaw GUI - v{}'.format(__version__))
-
-        # initiated windows size and location
-        self.geometry('{}x{}+{}+{}'.format(_width, _height,
-                                           window_posx, window_posy))
-        # minimal size
-        self.minsize(_width, _height)
-        self.maxsize(_width, _height)
-
-        self._init_layout()
-
-    def open_filediag(self):
-        self._path = filedialog.askopenfilename(
-            initialdir = ".",
-            title = "Select file",
-            filetypes = (("Zip compressed", "*.zip"),
-                         ("Paravision 6 format", "*.PVdatasets"),
-                         ))
-        self._extend_layout()
-        self._load_dataset()
-
-    def open_dirdiag(self):
-        self._path = filedialog.askdirectory(
-            initialdir = ".",
-            title = "Select directory")
-        self._extend_layout()
-        self._load_dataset()
-
-    def _init_layout(self):
-        # level 1
-        self._subj_info   = SubjInfo(self)
-        self._subj_info.pack(
-            side=tk.TOP,    fill=tk.X, anchor=tk.CENTER)
-
-        # Button binding
-        self._subj_info._loadfile.config(command=self.open_filediag)
-        self._subj_info._loaddir.config(command=self.open_dirdiag)
-
-    def _close(self):
-        if self._raw != None:
-            self.geometry('{}x{}+{}+{}'.format(_width, _height,
-                                               window_posx, window_posy))
-
-            # close opened frames
-            self._subj_info._clean_path()
-            self._subj_info._main_frame.destroy()
-            self._subj_info._path.destroy()
-            self._subj_info._path_label.destroy()
-            # self._subj_info._close.destroy()
-            self._subj_info._refresh.destroy()
-            self._main_frame.destroy()
-
-            self._raw.close()
-            self._raw = None
-
-            # minimal size
-            self.minsize(_width, _height)
-            self.maxsize(_width, _height)
-
-    def _extend_layout(self):
-        # Change windows size
-        self._close()
-        if len(self._path) != 0:
-            self.geometry('{}x{}+{}+{}'.format(win_pst_width, win_pst_height,
-                                               window_posx, window_posy))
-            self.minsize(win_pst_width, win_pst_height)
-            self.maxsize(win_pst_width, win_pst_height)
-
-            # extend level 1
-            self._subj_info._extend_layout()
-            # self._subj_info._close.config(command=self._close)
-            self._subj_info._refresh.config(command=self._refresh)
-
-            self._main_frame = tk.Frame(self)
-            self._main_frame.pack(
-                side=tk.BOTTOM, fill=tk.BOTH,   expand=True)
-
-            # level 2
-            self._scan_list   = ScanList(self._main_frame)
-            view_frame  = tk.Frame(self._main_frame)
-            self._scan_list.pack(
-                side=tk.LEFT,   fill=tk.BOTH)
-            view_frame.pack(
-                side=tk.LEFT,   fill=tk.BOTH,   expand=True)
-
-            # level 3
-            self._scan_info = ScanInfo(view_frame)
-            self._preview   = Previewer(view_frame)
-            self._preview.pack(
-                side=tk.LEFT, fill=tk.BOTH, expand=True)
-            self._scan_info.pack(
-                side=tk.LEFT,   fill=tk.BOTH, padx=10, pady=10)
-            self._bind_scanlist()
-            self._set_convert_button()
-
-    def _refresh(self):
-        self._close()
-        self._extend_layout()
-        self._load_dataset()
-
-    def _load_dataset(self):
-        if len(self._path) != 0:
-            self._raw = load(self._path)
-            self._init_update()
-
-    def _init_update(self):
-        # take first image from dataset
-        self._scan_id, recos = [v for i, v in enumerate(self._raw._avail.items()) if i == 0][0]
-
-        self._reco_id = recos[0]
-        # update subject info
-        self._subj_info.load_data(self._raw)
-
-        # update scan and reco listbox
-        self._scan_list.load_data(self._raw)
-        self._scan_list._update_recos(self._raw, self._scan_id)
-
-        # update scan info of first image
-        self._scan_info.load_data(self._raw, self._scan_id, self._reco_id)
-
-        # update preview of first image
-        self._preview.load_data(self._raw, self._scan_id, self._reco_id)
-
-    def _bind_scanlist(self):
-        self._scan_list._scanlist.bind('<<ListboxSelect>>', self._update_scanid)
-        self._scan_list._recolist.bind('<<ListboxSelect>>', self._update_recoid)
-
-    def _update_scanid(self, event):
-        w = event.widget
-        index = int(w.curselection()[0])
-        self._scan_id = self._raw._pvobj.avail_scan_id[index]
-        self._reco_id = self._raw._avail[self._scan_id][0]
-        self._scan_list._update_recos(self._raw, self._scan_id)
-        self._update_data()
-
-    def _update_recoid(self, event):
-        w = event.widget
-        index = int(w.curselection()[0])
-        self._reco_id = self._raw._avail[self._scan_id][index]
-        self._update_data()
-
-    def _update_data(self):
-        # update scan info of first image
-        self._scan_info.load_data(self._raw, self._scan_id, self._reco_id)
-        # update preview of first image
-        self._preview.load_data(self._raw, self._scan_id, self._reco_id)
-
-    def _set_convert_button(self):
-        self._scan_list._updt_bt.config(state=tk.NORMAL)
-        self._scan_list._conv_bt.config(state=tk.NORMAL)
-        self._scan_list._updt_bt.config(command=self._set_output)
-        self._scan_list._conv_bt.config(command=self._save_as)
-
-    def _set_output(self):
-        self._output = filedialog.askdirectory(initialdir=self._output,
-                                               title="Select Output Directory")
-
-    def _save_as(self):
-        date = self._raw.get_scan_time()['date'].strftime("%y%m%d")
-        pvobj = self._raw._pvobj
-        acqp  = self._raw.get_acqp
-        this_acqp = acqp(self._scan_id)
-        scan_name = this_acqp.parameters['ACQ_scan_name']
-        scan_name = scan_name.replace(' ','-')
-        filename = '{}_{}_{}_{}_{}_{}_{}'.format(date,
-                                              pvobj.subj_id,
-                                              pvobj.session_id,
-                                              pvobj.study_id,
-                                              self._scan_id,
-                                              self._reco_id,
-                                              scan_name)
-        if self._ignore_slope:
-            slope = None
-        else:
-            slope = False
-        if self._ignore_offset:
-            offset = None
-        else:
-            offset = False
-        self._raw.save_as(self._scan_id, self._reco_id, filename,
-                          dir=self._output, slope=slope, offset=offset)
-        method = self._raw._pvobj._method[self._scan_id].parameters['Method']
-        import re
-        if re.search('dti', method, re.IGNORECASE):
-            self._raw.save_bdata(self._scan_id, filename)
-        from tkinter import messagebox
-        messagebox.showinfo(title='File conversion',
-                            message='{}/{}.nii.gz has been converted'.format(self._output,
-                                                                       filename))
-
-
-if __name__ == '__main__':
-    root = MainWindow()
-    root.mainloop()

brkraw/ui/previewer.py

@@ -1,225 +0,0 @@
-import tkinter as tk
-from PIL import Image, ImageTk
-import numpy as np
-from .config import viewer_width, viewer_height
-
-
-class Previewer(tk.Frame):
-    def __init__(self, *args, **kwargs):
-        super(Previewer, self).__init__(*args, **kwargs)
-        # variables
-        self._dataobj = None
-        self._imgobj = None
-        self._is_tripilot = False
-        self._current_slice = 0
-        self._current_frame = 0
-
-        self.tkimg = None
-        self.slice_axis = tk.IntVar()
-        self.slice_axis.set(99)
-
-        self._set_axisbuttons()
-        self._set_canvas()
-        self._set_sliders()
-
-    def _set_canvas(self):
-        self._canvas = tk.Canvas(self,
-                                 width=viewer_width,
-                                 height=viewer_height)
-        self._canvas.place(x=50, y=30)
-
-    def _set_axisbuttons(self):
-        self._axis_buttons = []
-
-        tk.Label(self, text='Slice Axis::').place(x=50, y=5)
-        for i, axis in enumerate(['x', 'y', 'z']):
-            button = tk.Radiobutton(self,
-                                    text=axis,
-                                    padx=10,
-                                    variable=self.slice_axis,
-                                    command=self._change_sliceaxis,
-                                    value=i)
-            button.place(x=150 + i*50, y=5)
-
-            if self.slice_axis.get() == 99:
-                button['state'] = 'disabled'
-            self._axis_buttons.append(button)
-
-    def _set_sliders(self, n_slice=0, n_frame=0):
-
-        tk.Label(self, text='Slice').place(x=70, y=455)
-        tk.Label(self, text='Frame').place(x=70, y=495)
-        self.slice_slider = tk.Scale(self, from_=0, to=n_slice - 1,
-                                     orient=tk.HORIZONTAL,
-                                     command=self._change_slice, length=300)
-
-        self.frame_slider = tk.Scale(self, from_=0, to=n_frame - 1,
-                                     orient=tk.HORIZONTAL,
-                                     command=self._change_frame, length=300)
-
-        self.slice_slider.set(self._current_slice)
-        self.frame_slider.set(self._current_frame)
-        self.slice_slider.place(x=130, y=440)
-        self.frame_slider.place(x=130, y=480)
-
-        if n_slice == 0:
-            self.slice_slider.config(state=tk.DISABLED)
-        if n_frame == 0:
-            self.frame_slider.config(state=tk.DISABLED)
-
-    def update_image(self):
-        self._canvas.create_image((int(viewer_width / 2), int(viewer_height / 2)),
-                                  image=self.tkimg)
-
-    def _load_image(self, brkraw_obj, scan_id, reco_id):
-        from ..lib.utils import multiply_all
-        # update image when scan_id and reco_id is changed
-        visu_pars = brkraw_obj._get_visu_pars(scan_id, reco_id)
-        dataobj = brkraw_obj.get_dataobj(scan_id, reco_id, slope=False)
-
-        if len(dataobj.shape) > 3:
-            x, y, z = dataobj.shape[:3]
-            f = multiply_all(dataobj.shape[3:])
-            # all converted nifti must be 4D
-            self._dataobj = dataobj.reshape([x, y, z, f])[:,:,::-1, ...]
-        else:
-            self._dataobj = dataobj
-
-        # shape = brkraw_obj._get_matrix_size(visu_pars, dataobj)
-        # self._dataobj = dataobj.reshape(shape[::-1]).T[:,:,::-1, ...]
-
-        n_slicepacks = brkraw_obj._get_slice_info(visu_pars)['num_slice_packs']
-        spatial_info = brkraw_obj._get_spatial_info(visu_pars)
-
-        self._resol = spatial_info['spatial_resol']
-        self._matrix_size = spatial_info['matrix_size']
-
-        if n_slicepacks > 1:
-            self._is_tripilot = True
-        else:
-            self._is_tripilot = False
-
-    def _change_sliceaxis(self):
-        if self.slice_axis.get() in range(3):
-            self._imgobj = np.swapaxes(self._dataobj, axis1=self.slice_axis.get(), axis2=2)
-            shape = self._imgobj.shape
-            n_slice = shape[2]
-
-            self._current_slice = int(n_slice / 2)
-            self._current_frame = 0
-
-            shape = self._imgobj.shape
-            if len(shape) > 3:
-                n_frame = shape[3]
-            else:
-                n_frame = 0
-            n_slice = shape[2]
-
-            self._current_slice = int(n_slice / 2)
-            self._current_frame = 0
-
-            self._set_sliders(n_slice, n_frame)
-
-    def _convert_image(self):
-        if len(self._imgobj.shape) > 3:
-            img = self._imgobj[:,:,self._current_slice,self._current_frame]
-        else:
-            img = self._imgobj[:,:,self._current_slice]
-
-        slice_axis = self.slice_axis.get()
-        if slice_axis in range(3):
-            axis_ref = np.array([0, 1, 2])
-            axis_ref[slice_axis], axis_ref[2] = axis_ref[2], axis_ref[slice_axis]
-
-            self._img_resol = np.array(self._resol[0])[axis_ref]
-            self._img_size = np.array(self._matrix_size[0])[axis_ref]
-        else:
-            self._img_resol = np.array(self._resol[0])
-            self._img_size = np.array(self._matrix_size[0])
-
-        img_fov = self._img_resol.astype(float) * self._img_size.astype(float)
-        max_val = img_fov[:2].max()
-        img_fov /= max_val
-        img_fov *= 400
-
-        # check resolution
-        img_width, img_height = int(img_fov[0]), int(img_fov[1])
-
-        self.tkimg = self.convert_pil2tk(self.convert_npy2pil(img),
-                                         img_width, img_height)
-
-    def _change_slice(self, event):
-        self._current_slice = self.slice_slider.get()
-        self._convert_image()
-        self.update_image()
-
-    def _change_frame(self, event):
-        self._current_frame = self.frame_slider.get()
-        self._convert_image()
-        self.update_image()
-
-    def load_data(self, brkraw_obj, scan_id, reco_id):
-        # load image from dataset
-        self._load_image(brkraw_obj, scan_id, reco_id)
-        shape = self._dataobj.shape
-        if len(shape) > 3:
-            n_frame = shape[3]
-        else:
-            n_frame = 0
-        n_slice = shape[2]
-
-        self._current_slice = int(n_slice/2)
-        self._current_frame = 0
-
-        if self._is_tripilot:
-            self.slice_axis.set(99)
-            for button in self._axis_buttons:
-                button['state'] = 'disabled'
-        else:
-            for button in self._axis_buttons:
-                button['state'] = 'normal'
-            self.slice_axis.set(2)
-        self._set_sliders(n_slice, n_frame)
-        self._imgobj = self._dataobj
-        self._convert_image()
-        self.update_image()
-
-    @staticmethod
-    def convert_npy2pil(data, mode=None, rescale=True):
-        """ convert 2D numpy.array to PIL.Image object
-
-        Args:
-            data: 2D array data
-            mode: mode of image object
-                link=https://pillow.readthedocs.io/en/latest/handbook/concepts.html#modes
-            rescale: rescale value to 0~255
-
-        Returns: PIL.Image object
-
-        """
-        if rescale == True:
-            rescaled_data = data / data.max() * 255
-        else:
-            rescaled_data = data
-        rescaled_data = rescaled_data.astype('uint8')
-        return Image.fromarray(rescaled_data.T, mode=mode)
-
-    @staticmethod
-    def convert_pil2tk(pilobj, width, height, method='nearest'):
-        """ convert PIL.Image object to tkinter.PhotoImage object
-        This will allow plotting image on Tk.Canvas
-
-        Args:
-            pilobj: 2D image object
-            width: width of the image
-            height: height of the image
-            method: Method for interpolation
-
-        Returns: TkImage object
-
-        """
-        if method == 'nearest':
-            method = Image.NEAREST
-        else:
-            method = Image.ANTIALIAS
-        return ImageTk.PhotoImage(pilobj.resize((width, height), method))

brkraw/ui/scan_info.py

@@ -1,72 +0,0 @@
-import tkinter as tk
-from .config import font
-
-
-class ScanInfo(tk.Frame):
-    def __init__(self, *args, **kwargs):
-        super(ScanInfo, self).__init__(*args, **kwargs)
-        self.title = tk.Label(self, text='Selected Scan Info')
-        self.title.pack(side=tk.TOP, fill=tk.X)
-        self.textbox = tk.Text(self, width=30)
-        self.textbox.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
-        self.textbox.configure(font=font)
-
-    def load_data(self, brkraw_obj, scan_id, reco_id):
-        from brkraw.lib.utils import get_value, is_all_element_same
-        visu_pars = brkraw_obj._get_visu_pars(scan_id, reco_id)
-        self.textbox.config(state=tk.NORMAL)
-        self.textbox.delete('1.0', tk.END)
-
-        # RepetitionTime
-        tr = get_value(visu_pars, 'VisuAcqRepetitionTime')
-        tr = ','.join(map(str, tr)) if isinstance(tr, list) else tr
-        # EchoTime
-        te = get_value(visu_pars, 'VisuAcqEchoTime')
-        te = 0 if te is None else te
-        te = ','.join(map(str, te)) if isinstance(te, list) else te
-        # PixelBandwidth
-        pixel_bw = get_value(visu_pars, 'VisuAcqPixelBandwidth')
-        # FlipAngle
-        flip_angle = get_value(visu_pars, 'VisuAcqFlipAngle')
-        # Sequence and Protocol names
-        sequence_name = get_value(visu_pars, 'VisuAcqSequenceName')
-        protocol_name = get_value(visu_pars, 'VisuAcquisitionProtocol')
-        acqpars  = brkraw_obj.get_acqp(int(scan_id))
-        scan_name = acqpars._parameters['ACQ_scan_name']
-        # Dimension
-        dim = brkraw_obj._get_dim_info(visu_pars)[0]
-        # MatrixSize
-        size = brkraw_obj._get_matrix_size(visu_pars)
-        size = ' x '.join(map(str, size))
-        # FOV size and resolution
-        spatial_info = brkraw_obj._get_spatial_info(visu_pars)
-        temp_info = brkraw_obj._get_temp_info(visu_pars)
-        s_resol = spatial_info['spatial_resol']
-        fov_size = spatial_info['fov_size']
-        fov_size = ' x '.join(map(str, fov_size))
-        s_unit = spatial_info['unit']
-        t_resol = '{0:.3f}'.format(temp_info['temporal_resol'])
-        t_unit = temp_info['unit']
-        s_resol = list(s_resol[0]) if is_all_element_same(s_resol) else s_resol
-        s_resol = ' x '.join(['{0:.3f}'.format(r) for r in s_resol])
-        # Number of slice packs
-        n_slicepacks = brkraw_obj._get_slice_info(visu_pars)['num_slice_packs']
-
-        # Printing out
-        self.textbox.insert(tk.END, 'Sequence:\n - {}\n'.format(sequence_name))
-        self.textbox.insert(tk.END, 'Protocol:\n - {}\n'.format(protocol_name))
-        self.textbox.insert(tk.END, 'Scan Name:\n - {}\n'.format(scan_name))
-        self.textbox.insert(tk.END, 'RepetitionTime:\n - {} msec\n'.format(tr))
-        self.textbox.insert(tk.END, 'EchoTime:\n - {} msec\n'.format(te))
-        self.textbox.insert(tk.END, 'FlipAngle:\n - {} degree\n\n'.format(flip_angle))
-        if isinstance(pixel_bw, float):
-            self.textbox.insert(tk.END, 'PixelBandwidth:\n - {0:.3f} Hz\n'.format(pixel_bw))
-        else:
-            self.textbox.insert(tk.END, 'PixelBandwidth:\n - {} Hz\n'.format(pixel_bw))
-        self.textbox.insert(tk.END, 'Dimension:\n - {}D\n'.format(dim))
-        self.textbox.insert(tk.END, 'Matrix size:\n - {}\n'.format(size))
-        self.textbox.insert(tk.END, 'Number of SlicePacks:\n - {}\n'.format(n_slicepacks))
-        self.textbox.insert(tk.END, 'FOV size:\n - {} (mm)\n\n'.format(fov_size))
-        self.textbox.insert(tk.END, 'Spatial resolution:\n - {} ({})\n'.format(s_resol, s_unit))
-        self.textbox.insert(tk.END, 'Temporal resolution:\n - {} ({})\n'.format(t_resol, t_unit))
-        self.textbox.config(state=tk.DISABLED)

brkraw/ui/scan_list.py

@@ -1,73 +0,0 @@
-import tkinter as tk
-from .config import font
-
-
-class ScanList(tk.Frame):
-    def __init__(self, *args, **kwargs):
-        super(ScanList, self).__init__(*args, **kwargs)
-        self._init_scanlist()
-        self._init_recolist()
-        self._init_buttons()
-
-    def _init_scanlist(self):
-        self._scanlist_label = tk.Label(self, text='Scan ID / Protocol')
-        self._scanlist_label.pack(side=tk.TOP, fill=tk.X, pady=5)
-        self._scanlist_frame = tk.Frame(self)
-        self._scanlist_frame.pack(side=tk.TOP, fill=tk.BOTH, expand=True, padx=10)
-        self._scanlist= tk.Listbox(self._scanlist_frame, width=30,
-                                   exportselection=False)
-        self._scanlist.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
-        self._set_scollbar(self._scanlist_frame, self._scanlist)
-        self._scanlist.config(font=font, state=tk.DISABLED)
-        self._scanlist_label.config(font=font)
-
-    def _init_recolist(self):
-        self._recolist_label = tk.Label(self, text='Reco ID / DataType')
-        self._recolist_label.pack(side=tk.TOP, fill=tk.X, pady=5)
-        self._recolist_frame = tk.Frame(self, height=5)
-        self._recolist_frame.pack(side=tk.TOP, fill=tk.BOTH, padx=10)
-        self._recolist = tk.Listbox(self._recolist_frame, width=30, height=5,
-                                    exportselection=False)
-        self._recolist.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
-        self._set_scollbar(self._recolist_frame, self._recolist)
-        self._recolist.config(font=font, state = tk.DISABLED)
-        self._recolist_label.config(font=font)
-
-    def _init_buttons(self):
-        self._button_fm = tk.Frame(self)
-        self._button_fm.pack(side=tk.TOP, fill=tk.X)
-        self._updt_bt = tk.Button(self._button_fm, text='SetOutput')
-        self._conv_bt = tk.Button(self._button_fm, text='Convert')
-        self._updt_bt.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
-        self._conv_bt.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
-        self._updt_bt.config(state=tk.DISABLED, font=font)
-        self._conv_bt.config(state=tk.DISABLED, font=font)
-
-    @staticmethod
-    def _set_scollbar(frame, listbox_obj):
-        scrollbar = tk.Scrollbar(frame, orient=tk.VERTICAL)
-        scrollbar.config(command=listbox_obj.yview)
-        scrollbar.pack(side=tk.RIGHT, fill="y")
-        listbox_obj.config(yscrollcommand=scrollbar.set)
-
-    def load_data(self, brkraw_obj):
-        from brkraw.lib.utils import get_value
-        self._scanlist.config(state=tk.NORMAL)
-        for scan_id, recos in brkraw_obj._avail.items():
-            visu_pars = brkraw_obj._get_visu_pars(scan_id, recos[0])
-            protocol_name = get_value(visu_pars, 'VisuAcquisitionProtocol')
-            self._scanlist.insert(tk.END, '{}::{}'.format(str(scan_id).zfill(3),
-                                                          protocol_name))
-        self._scanlist.select_set(0)
-
-    def _update_recos(self, brkraw_obj, scan_id):
-        from brkraw.lib.utils import get_value
-        self._recolist.config(state=tk.NORMAL)
-        recos = brkraw_obj._avail[scan_id]
-        self._recolist.delete(0, tk.END)
-        for reco_id in recos:
-            visu_pars = brkraw_obj._get_visu_pars(scan_id, reco_id)
-            frame_type = get_value(visu_pars, 'VisuCoreFrameType')
-            self._recolist.insert(tk.END, '{}::{}'.format(str(reco_id).zfill(3),
-                                                          frame_type))
-        self._recolist.select_set(0)