dive-mri 1.0.0__py3-none-any.whl

dive/Viz_UI.py

@@ -0,0 +1,205 @@
+import tkinter as tk
+from tkinter import ttk
+from tkinter import filedialog
+import os 
+
+nifti_li, track_li,vtk_li = [], [], []
+ouptput_file_name = []
+width_value = 1
+zoom_value = 0.5
+command = ""
+def nifti():
+    global nifti_li
+    filename = filedialog.askopenfilenames(initialdir = os.getcwd(),title = "Select Nifti Files",multiple=True, filetypes = (("Nifti files", "*.nii.*"),("Compressed","*.gz"),("all files","*.*")))
+    if filename:
+        nifti_li = list(filename)
+    else:
+        nifti_li = None
+
+def track():
+    global track_li
+    filename = filedialog.askopenfilenames(initialdir = os.getcwd(),title = "Select Tracks Files",multiple=True, filetypes = (("Trk files", "*.trk"),("Tck files", "*.tck"),("Trx files", "*.trx"),("all files","*.*")))
+    if filename:
+        track_li = list(filename)
+    else:
+        return None
+
+def vtk():
+    global vtk_li
+    filename = filedialog.askopenfilenames(initialdir = os.getcwd(),title = "Select Tracks Files",multiple=True, filetypes = (("Vtk files", "*.vtk"),("all files","*.*")))
+    if filename:
+        vtk_li = list(filename)
+    else:
+        return None
+background_val = 0
+def width_control(value2):
+    global width_value
+    value_label_track.config(text=f"Track Width: {value2}")
+    width_value = value2
+
+def choose_output_path():
+    global ouptput_file_name
+    filename = filedialog.asksaveasfilename(defaultextension=".png",title="Save As" )
+    if filename:
+        ouptput_file_name = filename
+    else:
+        return None
+
+mask_csv_val,tract_csv_val = [],[]
+## CSV functions
+def csv_mask():
+    global mask_csv_val
+    filename = filedialog.askopenfilenames(initialdir = "/",title = "Select CSV Files",multiple=True, filetypes = (("CSV files", "*.csv"),("all files","*.*")))
+    if filename:
+        mask_csv_val = list(filename)
+    else:
+        mask_csv_val = None
+
+def csv_track():
+    global tract_csv_val
+    filename = filedialog.askopenfilenames(initialdir = "/",title = "Select CSV Files",multiple=True, filetypes = (("CSV files", "*.csv"),("all files","*.*")))
+    if filename:
+        tract_csv_val = list(filename)
+    else:
+        tract_csv_val = None
+
+def p_val():
+    if var_log_pval.get() == 1:
+        label_pval.config(text="Do log for pval")
+    else:
+        label_pval.config(text="Don't apply")
+def submit():
+    global command
+    global nifti_li,track_li,vtk_li,ouptput_file_name,mask_csv_val,tract_csv_val,threshold_tract
+    global threshold_mask,var_log_pval,zoom_value,width_value
+    global tvalue_range, pvalue_range, map_pval_value_val, map_tval_value_val
+    global color_mask_value_val,color_tract_value_val,color_vtk_value_val
+    global background_val
+    if len(vtk_li)>0:
+        command+= " --mesh " + " ".join(vtk_li)
+    if len(nifti_li)>0:
+        command+= " --mask " + " ".join(nifti_li)
+    if len(track_li)>0:
+        command+= " --tract " + " ".join(track_li)
+    if len(mask_csv_val)>0:
+        command+= " --stats_csv " + " ".join(mask_csv_val)
+    if threshold_mask.get():
+        command+= " --threshold " + str(threshold_mask.get())
+    if width_value:
+        command+= " --width_tract " + str(width_value)
+    if var_log_pval.get():
+        command+= " --log_p_value " + str(var_log_pval.get())
+    if str(pvalue_range.get())!="(Min,Max)":
+        command+= " --range_value "+ str(pvalue_range.get()).replace(",", " ")
+    if map_pval_value.get():
+        command+= " --map "+ str(map_pval_value_val.get())
+    if color_mask_value.get():
+        command+= " --color_mask "+ str(color_mask_value_val.get())
+    if color_vtk_value.get():
+        command+= " --color_mesh "+ str(color_vtk_value_val.get())
+    if color_tract_value.get():
+        command+= " --color_tract "+ str(color_tract_value_val.get())
+
+    #  command
+    print(command)
+    window.destroy()
+
+
+
+window = tk.Tk()
+window.title("DiVE")
+window.geometry('400x600')
+
+title = ttk.Label(master = window, text="Input Files",font='Arial 15 bold')
+title.pack()
+
+input_frame = ttk.Frame(master=window)
+mask = ttk.Button(input_frame,text='Add Mask',command=nifti)
+track_button = ttk.Button(input_frame,text='Add Tract',command=track)
+vtk_button = ttk.Button(input_frame,text="Add Mesh",command=vtk)
+
+mask.grid(row=0, column=0)
+track_button.grid(row=0, column=1)
+vtk_button.grid(row=0, column=2)
+input_frame.pack(pady=10)
+
+input_frame2 = ttk.Frame(master=window)
+
+value_label_track = tk.Label(input_frame2, text="Track Width: 1",fg="blue")
+width_slider = tk.Scale(input_frame2, from_=1, to=15,  orient="horizontal", command=width_control)
+width_slider.set(1) 
+width_slider.grid(row=4, column=0, padx=1, pady=1)
+value_label_track.grid(row=4, column=1, padx=1, pady=1)
+
+
+input_frame2.pack(pady=10)
+
+title3 = ttk.Label(master = window, text="Visualize with Stats",font='Arial 15 bold')
+title3.pack()
+input_frame3 = ttk.Frame(master=window)
+
+mask_csv = ttk.Button(input_frame3,text='Add CSV for Mask',command=csv_mask)
+mask_csv.grid(row=0, column=0, padx=1, pady=1)
+
+
+threshold_label = ttk.Label(input_frame3, text="Threshold Value:")
+threshold_label.grid(row=1, column=0, padx=1, pady=1, sticky="w")
+threshold_mask=tk.DoubleVar()
+threshold_entry = ttk.Entry(input_frame3,textvariable=threshold_mask)
+threshold_entry.grid(row=1, column=1, padx=1, pady=1)
+
+
+var_log_pval = tk.IntVar() 
+checkbox_pval = tk.Checkbutton(input_frame3, text="Apply Log for P value", variable=var_log_pval, command=p_val)
+label_pval = tk.Label(input_frame3, text=" Default Don't apply", fg="blue")
+
+checkbox_pval.grid(row=3, column=0, padx=1, pady=1)
+label_pval.grid(row=3, column=1, padx=1, pady=1)
+
+pvalue_r = ttk.Label(input_frame3, text=" Pvalue Range(Min,Max):")
+pvalue_r.grid(row=4, column=0, padx=1, pady=1, sticky="w")
+pvalue_range=tk.StringVar()
+pvalue_range_entry = ttk.Entry(input_frame3,textvariable=pvalue_range)
+pvalue_range_entry.insert(0, "(Min,Max)") 
+pvalue_range_entry.grid(row=4, column=1, padx=1, pady=1)
+
+map_pval = ttk.Label(input_frame3, text="Color Map for Value")
+map_pval.grid(row=5, column=0, padx=1, pady=1, sticky="w")
+map_pval_value_val=tk.StringVar()
+map_pval_value = ttk.Entry(input_frame3,textvariable=map_pval_value_val)
+map_pval_value.insert(0, "RdBu") 
+map_pval_value.grid(row=5, column=1, padx=1, pady=1)
+
+input_frame3.pack(pady=10)
+
+##Colors
+title4 = ttk.Label(master = window, text="Add Colors",font='Arial 15 bold')
+title4.pack()
+input_frame4 = ttk.Frame(master=window)
+
+color_mask = ttk.Label(input_frame4, text="Mask Colors")
+color_mask.grid(row=0, column=0, padx=1, pady=1, sticky="w")
+color_mask_value_val=tk.StringVar()
+color_mask_value = ttk.Entry(input_frame4,textvariable=color_mask_value_val)
+color_mask_value.grid(row=0, column=1, padx=1, pady=1)
+
+color_tract = ttk.Label(input_frame4, text="Tract Colors")
+color_tract.grid(row=1, column=0, padx=1, pady=1, sticky="w")
+color_tract_value_val=tk.StringVar()
+color_tract_value = ttk.Entry(input_frame4,textvariable=color_tract_value_val)
+color_tract_value.grid(row=1, column=1, padx=1, pady=1)
+
+color_vtk = ttk.Label(input_frame4, text="Mesh Colors")
+color_vtk.grid(row=2, column=0, padx=1, pady=1, sticky="w")
+color_vtk_value_val=tk.StringVar()
+color_vtk_value = ttk.Entry(input_frame4,textvariable=color_vtk_value_val)
+color_vtk_value.grid(row=2, column=1, padx=1, pady=1)
+
+
+
+input_frame4.pack(pady=10)
+submit_button = ttk.Button(window,text='Submit',command=submit)
+submit_button.pack()
+window.mainloop()
+
+

dive/__init__.py

@@ -0,0 +1 @@
+

dive/csv_tocolors.py

@@ -0,0 +1,79 @@
+import matplotlib
+import matplotlib.colors as mcolors
+import matplotlib.pyplot as plt
+import collections
+import numpy as np
+import pandas as pd
+from math import isnan
+import os
+
+
+## Read this reference to update normalization ...
+## https://matplotlib.org/stable/api/colors_api.html
+
+class Colors_csv():
+    def __init__(self,stats_csv=None):
+        self.csv_flag = None
+        self.colors_from_csv = []
+        self.stats_csv = stats_csv
+        self.map = None
+
+    def intialize(self,log_p_value=False):
+        self.df = pd.read_csv(self.stats_csv)
+        # if self.df.shape[-1] == 2:
+        #     self.col_name = 'P_value'
+
+        if log_p_value:
+            self.df['P_value'] = -np.log10(self.df['P_value'])
+            self.col_name = 'P_value'
+        else:
+            self.col_name = 'Value'
+            
+        self.min_value = self.df[self.col_name].min()       
+        self.max_value = self.df[self.col_name].max()  
+
+        
+    def assign_colors(self,map,range_value=[],log_p_value=False,threshold=None,output=None,filename='_color_bar.pdf'):
+        self.map = map
+        self.intialize(log_p_value)
+        cmap = matplotlib.cm.get_cmap(map)
+        di = {}
+        if range_value and len(range_value)>0:
+            self.min_value = range_value[0]
+            self.max_value = range_value[1]
+            self.csv_flag = True
+            self.df.sort_values(by=['Labels'],inplace=True)
+
+        norm = mcolors.Normalize(vmin=self.min_value, vmax=self.max_value)
+        self.df['Value_n'] = norm(self.df[self.col_name])
+
+        for i,k,j in zip(self.df['Value_n'],self.df['P_value'],self.df['Labels']):
+            if self.csv_flag == True:
+                if k>threshold:
+                    r=g=b=0.5
+                else:
+                    if i!= None and self.min_value<=i<=self.max_value:  
+                        r,g,b,a = cmap(i)
+                    if i>self.max_value:
+                        r,g,b,a = cmap(self.max_value)
+                    if i<self.min_value:
+                        r,g,b,a = cmap(self.min_value)
+            else:
+                r,g,b,a = cmap(i)
+            di[j] = [r,g,b]
+        clean_dict = {k: di[k] for k in di if not isnan(k)}
+        clean_dict = collections.OrderedDict(sorted(clean_dict.items()))
+        for k, v in clean_dict.items():
+            self.colors_from_csv.append(v)
+        self.colors_from_csv = np.asarray(self.colors_from_csv)
+
+        ## Save the color bar images
+        fig, ax = plt.subplots(figsize=(6, 1))
+        print(self.df[self.col_name])
+        if output!=None:
+            cb = matplotlib.colorbar.ColorbarBase(ax, cmap=cmap, values=sorted(self.df[self.col_name]), orientation='horizontal',spacing='uniform') # 
+            cb.ax.tick_params(labelsize=10) 
+            plt.savefig((output + filename) , bbox_inches='tight', dpi=300)
+
+        return self.colors_from_csv
+    

dive/helper.py

@@ -0,0 +1,155 @@
+import re
+import vtk
+import webcolors
+import matplotlib
+import numpy as np
+import nibabel as nib
+from fury import actor,utils
+from scipy.ndimage import gaussian_filter
+from fury.colormap import colormap_lookup_table
+from vtkmodules.vtkRenderingCore import vtkProperty
+
+
+class load_3dbrain:
+
+    def __init__(self,nifti) -> None:
+        self.data = nifti.get_fdata()
+        self.threshold = 45
+        self.sigma = 0.5
+        self.affine = nifti.affine
+        self.glass_brain_actor = actor
+
+    # def set_property(self):
+    #     self.glass_brain_actor.GetProperty().EdgeVisibilityOn()  
+    #     self.glass_brain_actor.GetProperty().VertexVisibilityOff()
+    #     self.glass_brain_actor.GetProperty().SetEdgeColor(0.5, 0.5, 0.5)  
+    #     glass_material =  self.glass_brain_actor.GetProperty()
+    #     glass_material.SetAmbient(1)
+    #     glass_material.SetDiffuse(1)
+    #     glass_material.SetSpecular(1.0)
+    #     glass_material.SetSpecularPower(100.0)
+    #     glass_material.SetOcclusionStrength(0.1)
+    #     glass_material.SetRenderLinesAsTubes(True)
+    #     glass_material.SetMetallic(1)
+    #     self.glass_brain_actor.GetProperty().SetRoughness(0)
+    #     self.glass_brain_actor.GetProperty().SetOpacity(0.05)
+
+    def loading(self):
+        self.data[self.data<self.threshold] = 0
+        smooth_data = gaussian_filter(self.data,sigma=self.sigma)
+        self.glass_brain_actor = actor.contour_from_roi(self.data,self.affine,color=[0,0,0],opacity=0.08)
+        # self.set_property()
+        return self.glass_brain_actor
+
+
+class load_2dbrain:
+    def __init__(self,nifti) -> None:
+        self.data = nifti.get_fdata()
+        # self.data[self.data == 0] = 1000
+        self.max_v = min(self.data.shape)      ### not used yet
+        self.affine = nifti.affine
+        self.mean, self.std = self.data[self.data > 0].mean(), self.data[self.data > 0].std()
+        self.value_range = (self.mean - 0.1* self.std, self.mean + 3 * self.std)
+
+    def load_actor(self):
+        slice_actor = actor.slicer(self.data,self.affine,self.value_range,opacity=0.9)
+        return slice_actor
+
+
+class Mesh:
+    def __init__(self,vtk,color_list=[]) -> None:
+        self.vtk = vtk
+        self.color_list = color_list
+
+    def property(self):
+        property = vtkProperty()
+        property.SetColor(self.color_list)
+        property.SetOpacity(1.0)
+        property.SetRoughness(0.0)
+        return property
+
+    def load_mesh(self):
+        property = self.property()
+        actor_2 = vtk.vtkActor()
+        actor_2 = utils.get_actor_from_polydata(self.vtk)
+        actor_2.SetProperty(property)
+        return actor_2
+
+    def load_mesh_with_colors(self,mask,color_map):
+        voxels = nib.affines.apply_affine(np.linalg.inv(mask.affine), self.vtk.points).astype(int)
+        shape = mask.get_fdata().shape
+        array_3d = np.zeros(shape, dtype=float)
+        nifti_dict = {(i, j, k): val for (i, j, k), val in np.ndenumerate(mask.get_fdata())}
+        master_color = list(map(lambda vox: nifti_dict[vox[0], vox[1], vox[2]], voxels))
+        for index in voxels:
+            array_3d[int(index[0]),int(index[1]),int(index[2])] = mask.get_fdata()[index[0],index[1],index[2]]
+        roi_dict = np.delete(np.unique(array_3d), 0)
+        unique_roi_surfaces = vtk.vtkAssembly()
+        color_map = np.asarray(color_map)
+        for i, roi in enumerate(roi_dict):
+            roi_data = np.isin(array_3d,roi).astype(int)
+            roi_surfaces = actor.contour_from_roi(roi_data,mask.affine,color=color_map[i])
+            unique_roi_surfaces.AddPart(roi_surfaces)
+        return unique_roi_surfaces
+        
+
+class Colors:
+
+    def __init__(self):
+        self.rgb_decimal_tuple = None
+    
+    def get_rgb_from_color_name(self,color_name):
+        try:
+            rgb_tuple = webcolors.name_to_rgb(color_name)
+            self.rgb_decimal_tuple = tuple(component / 255.0 for component in rgb_tuple)
+            return self.rgb_decimal_tuple
+        except ValueError:
+            print("Invalid color name:",color_name)
+            return None
+    
+    def hex_to_rgb(self,hex_value):
+        rgb_tuple = webcolors.hex_to_rgb(hex_value) #Check Matplotlib
+        self.rgb_decimal_tuple = tuple(component / 255.0 for component in rgb_tuple)
+        return self.rgb_decimal_tuple
+
+    def string_to_list(self,input_string):
+        list_of_lists = []
+        cleaned_string = input_string.replace('[', '').replace(']', '').replace('(','').replace(')','')  
+        elements = cleaned_string.split(',')
+        for element in elements:
+            if element.startswith('#'):
+                list_of_lists.append(self.hex_to_rgb(element))
+            else:
+                list_of_lists.append(self.get_rgb_from_color_name(element))
+        return list_of_lists
+    
+    def get_tab20_color(index,type_):
+        if type_=='vol':
+            tab20_colors = matplotlib.cm.get_cmap('tab20')
+        else:
+            tab20_colors = matplotlib.cm.get_cmap('Pastel1_r')
+
+        return matplotlib.colors.to_rgb(tab20_colors(index))
+
+    def load_colors(self,colors_path=None):
+        dic_colors = {}
+        if colors_path==None: return
+        with open(colors_path) as colors_file:
+            lines = [line.rstrip() for line in colors_file if not line.rstrip().startswith('#')]
+        for i in lines:
+            match = re.search(r'[a-zA-Z]', i)
+            first_alphabet_index = match.start() if match else None
+            # Find the index of the last alphabetic character
+            last_alphabet_index = None
+            for match in re.finditer(r'[a-zA-Z]', i):
+                last_alphabet_index = match.start()
+            
+            key = str(i[first_alphabet_index:last_alphabet_index+1])
+            colors_str = i[last_alphabet_index+2:]
+            colors_list = colors_str.split()
+            colors_list = list(map(int, colors_list))
+            rgb_tuple = colors_list[0:-1]
+            rgb_decimal_tuple = tuple(component / 255.0 for component in rgb_tuple)
+            dic_colors[key] = rgb_decimal_tuple
+
+        return dic_colors

dive/loading.py

@@ -0,0 +1,101 @@
+
+import io
+import gzip
+import zipfile
+import numpy as np
+from dive.mask import Mask
+import nibabel as nib
+from dive.tract import Tract
+from dive.helper import  Colors
+class load:
+    def __init__(self):
+        self.index_mask = 0
+        self.flag_multple = 0
+        self.distinctpy_colormask = None
+        self.mask = None
+
+    def read_from_compressed(file = None):
+        """
+        Args:
+            file: path to the compressed file
+
+        Returns:
+            img: file object to be read by nibabel
+        This function reads compressed (zip or gz) TRK or TCK files and returns an object 
+        that can be read using nibabel
+        """
+        zip_type = file.split('.')[-1]
+        if zip_type == 'gz':
+            with gzip.open(file) as gf:
+                data = gf.read()
+                img = io.BytesIO(data)
+        elif zip_type == 'zip':
+            with zipfile.ZipFile(file, mode="r") as zf:
+                f_name = zf.namelist()[0]
+                img = zf.open(f_name)
+        else:
+            print("Wrong zip type. Either '.gz' or '.zip' ")
+        return img
+
+        
+    def load_mask(self,mask_args,color_map_mask=[],color=None,color_map=None):
+        
+        self.flag_multple = 0
+        self.index_mask= self.index_mask+1
+        print(mask_args,color)
+        if mask_args==None: actor_mask = None
+        else:
+            mask = nib.load(mask_args)
+            self.mask = mask
+            if len(np.unique(mask.get_fdata()))>2:
+                self.flag_multple = 1
+                if len(color_map_mask)>0:
+                    mask_caller = Mask(mask,colormap=color_map_mask)
+                    actor_mask,self.distinctpy_colormask = mask_caller.multi_label()
+                else:
+                    mask_caller = Mask(mask)
+                    actor_mask,self.distinctpy_colormask = mask_caller.multi_label()
+            else:
+                if color:
+                    mask_caller = Mask(mask,color)
+                    actor_mask = mask_caller.one_label()
+                else:
+                    if color_map!=None: 
+                        name = mask_args.split('/')[-1].split('.')[0]
+                        dic_colors = Colors.load_colors()
+                        if name in dic_colors:
+                            mask_caller = Mask(mask,dic_colors[name])
+                            actor_mask = mask_caller.one_label()
+                    else: 
+                        mask_caller = Mask(mask,Colors.get_tab20_color(index = self.index_mask, type_='vol'))
+                        actor_mask = mask_caller.one_label()
+        return actor_mask
+
+    def load_tract(self,tract_args=None,tract_width = 1.0,tract_color = None,color_map_csv_tract=[],color_map_csv_mask=[]):
+
+        if tract_args!=None:
+            if str(tract_args).split('.')[-1] == '.gz' or str(tract_args).split('.')[-1] == 'zip':
+                tract_image =  nib.streamlines.load(self.read_from_compressed(tract_args))
+            else: tract_image = nib.streamlines.load(tract_args)
+
+            if not tract_image.header : print("The Track has no Header!") 
+
+            if self.flag_multple == 1:
+                tract_caller = Tract(bundle = tract_image.streamlines,tw=tract_width)
+                if len(color_map_csv_tract)>0:
+                    tract_caller.selt_colormap(instance=color_map_csv_tract)
+                    
+                elif len(color_map_csv_mask)>0:
+                    tract_caller.selt_colormap(instance=color_map_csv_mask)
+                
+                else: tract_caller.selt_colormap(instance=self.distinctpy_colormask)
+                actor_tract = tract_caller.with_colormap(mask=self.mask)
+
+            elif tract_color!=None:
+                tract_caller = Tract(bundle = tract_image.streamlines,tw=tract_width,color_list=tract_color)
+                actor_tract = tract_caller.single_color()
+            else:
+                tract_caller = Tract(bundle = tract_image.streamlines,tw=tract_width)
+                actor_tract = tract_caller.dirrection_color()
+        return actor_tract
+