Soto de la Cruz Ana · sotodela · sotodela · sotodela · sotodela · sotodela
Showing 12 changed files Show diff stats
environment.yml
invesalius/constants.py
invesalius/control.py
invesalius/data/coordinates.py
invesalius/data/coregistration.py
invesalius/data/styles.py
invesalius/data/surface.py
invesalius/data/tractography.py
invesalius/data/viewer_volume.py
invesalius/gui/dialogs.py
invesalius/gui/task_navigator.py
invesalius/navigation/navigation.py
@@ -2,7 +2,7 @@ channels:
   - conda-forge
   - bioconda
 dependencies:
-  - python=3.7
+  - python=3.8
   - cython==0.29.24
   - pillow==8.3.2
   - pypubsub==4.0.3
@@ -17,13 +17,21 @@ dependencies:
   - scipy==1.7.1
   - vtk==9.0.3
   - wxpython==4.1.1
+  - mido==1.2.10
+  - nest-asyncio==1.5.1
   - pip
   - pip:
-    - python-gdcm==3.0.9.1
+    - aioconsole==0.3.2
+    - opencv-python==4.5.3.56
     - plaidml-keras==0.7.0
-    - theano==1.0.5
-    - pyacvd==0.2.3
+    - python-gdcm==3.0.9.1
+    - python-rtmidi==1.4.9
+    - python-socketio[client]==5.3.0
+    - pyacvd==0.2.7
     - pyclaron
     - polhemusFT
     - polhemus
     - pypolaris
+    - theano==1.0.5
+    - uvicorn[standard]==0.15.0
+    - https://github.com/baranaydogan/trekker/raw/master/binaries/Trekker-0.9-cp38-cp38-win_amd64.whl
@@ -671,7 +671,7 @@ Z_COLUMN = 6
  
 MARKER_COLOUR = (1.0, 1.0, 0.)
 MARKER_SIZE = 2
-
+ARROW_MARKER_SIZE = 10
 CALIBRATION_TRACKER_SAMPLES = 10
 FIDUCIAL_REGISTRATION_ERROR_THRESHOLD = 3.0
  
@@ -823,23 +823,35 @@ COIL_ANGLE_ARROW_PROJECTION_THRESHOLD = 5
 CAM_MODE = True
  
 # Tractography visualization
-N_TRACTS = 100
-PEEL_DEPTH = 5
-MAX_PEEL_DEPTH = 30
-SEED_OFFSET = 15
+N_TRACTS = 200
+PEEL_DEPTH = 10
+MAX_PEEL_DEPTH = 40
+SEED_OFFSET = 30
 SEED_RADIUS = 1.5
  
 # Increased the default sleep parameter from 0.1 to 0.15 to decrease CPU load during navigation.
-SLEEP_NAVIGATION = 0.15
+SLEEP_NAVIGATION = 0.2
 SLEEP_COORDINATES = 0.05
 SLEEP_ROBOT = 0.01
  
-BRAIN_OPACITY = 0.5
+BRAIN_OPACITY = 0.6
 N_CPU = psutil.cpu_count()
-TREKKER_CONFIG = {'seed_max': 1, 'step_size': 0.1, 'min_fod': 0.1, 'probe_quality': 3,
-                  'max_interval': 1, 'min_radius_curv': 0.8, 'probe_length': 0.4,
-                  'write_interval': 50, 'numb_threads': '', 'max_lenth': 200,
-                  'min_lenth': 20, 'max_sampling_step': 100}
+# the max_sampling_step can be set to something different as well. Above 100 is probably not necessary
+TREKKER_CONFIG = {'seed_max': 1,
+                  'step_size': 0.03125,
+                  'min_fod': 0.05,
+                  'probe_quality': 3,
+                  'max_interval': 1,
+                  'min_radius_curvature': 0.625,
+                  'probe_length': 0.15625,
+                  'write_interval': 50,
+                  'numb_threads': '',
+                  'max_length': 250,
+                  'min_length': 10,
+                  'max_sampling_step': 100,
+                  'data_support_exponent': 0.5,
+                  'use_best_init': True,
+                  'init_max_est_trials': 100}
  
 MARKER_FILE_MAGICK_STRING = "##INVESALIUS3_MARKER_FILE_"
 CURRENT_MARKER_FILE_VERSION = 0
@@ -69,7 +69,7 @@ class Controller():
         #DICOM = 1
         #TIFF uCT = 2
         self.img_type = 0
-        self.affine = None
+        self.affine = np.identity(4)
  
         #Init session
         session = ses.Session()
@@ -340,7 +340,7 @@ class Controller():
         if proj.affine:
             self.Slice.affine = np.asarray(proj.affine).reshape(4, 4)
         else:
-            self.Slice.affine = None
+            self.Slice.affine = np.identity(4)
  
         Publisher.sendMessage('Update threshold limits list',
                               threshold_range=proj.threshold_range)
@@ -623,6 +623,8 @@ class Controller():
         Publisher.sendMessage(('Set scroll position', 'SAGITAL'),index=proj.matrix_shape[1]/2)
         Publisher.sendMessage(('Set scroll position', 'CORONAL'),index=proj.matrix_shape[2]/2)
  
+        # TODO: Check that this is needed with the new way of using affine
+        #  now the affine should be at least the identity(4) and never None
         if self.Slice.affine is not None:
             Publisher.sendMessage('Enable Go-to-Coord', status=True)
         else:
@@ -731,6 +733,8 @@ class Controller():
         proj.level = self.Slice.window_level
         proj.threshold_range = int(matrix.min()), int(matrix.max())
         proj.spacing = self.Slice.spacing
+        # TODO: Check that this is needed with the new way of using affine
+        #  now the affine should be at least the identity(4) and never None
         if self.Slice.affine is not None:
             proj.affine = self.Slice.affine.tolist()
  
@@ -371,7 +371,7 @@ def DebugCoordRandom(trk_init, trck_id, ref_mode):
     #
     # else:
  
-    dx = [-70, 70]
+    dx = [-30, 30]
     dt = [-180, 180]
  
     coord1 = np.array([uniform(*dx), uniform(*dx), uniform(*dx),
@@ -427,7 +427,7 @@ class CoordinateCorregistrateNoObject(threading.Thread):
 #             # seed_aux = pos_world.reshape([1, 4])[0, :3]
 #             # seed = seed_aux[np.newaxis, :]
 #             #
-#             # self.tracts = dtr.compute_tracts(tracker, seed, affine_vtk, True)
+#             # self.tracts = dtr.compute_and_visualize_tracts(tracker, seed, affine_vtk, True)
 #
 #             # wx.CallAfter(Publisher.sendMessage, 'Co-registered points', arg=m_img, position=coord)
 #             wx.CallAfter(Publisher.sendMessage, 'Update cross position', arg=m_img, position=coord)
@@ -654,7 +654,7 @@ class CoordinateCorregistrateNoObject(threading.Thread):
 #             # seed_aux = pos_world.reshape([1, 4])[0, :3]
 #             # seed = seed_aux[np.newaxis, :]
 #
-#             # self.tracts = dtr.compute_tracts(tracker, seed, affine_vtk, True)
+#             # self.tracts = dtr.compute_and_visualize_tracts(tracker, seed, affine_vtk, True)
 #
 #             # wx.CallAfter(Publisher.sendMessage, 'Co-registered points', arg=m_img, position=coord)
 #             wx.CallAfter(Publisher.sendMessage, 'Update cross position', arg=m_img, position=coord)
@@ -486,7 +486,7 @@ class CrossInteractorStyle(DefaultInteractorStyle):
         x, y, z = self.viewer.get_coordinate_cursor(mouse_x, mouse_y, self.picker)
         self.viewer.UpdateSlicesPosition([x, y, z])
         # This "Set cross" message is needed to update the cross in the other slices
-        Publisher.sendMessage('Set cross focal point', position=[x, y, z, 0., 0., 0.])
+        Publisher.sendMessage('Set cross focal point', position=[x, y, z, None, None, None])
         Publisher.sendMessage('Update slice viewer')
  
     def OnScrollBar(self, *args, **kwargs):
@@ -494,7 +494,7 @@ class CrossInteractorStyle(DefaultInteractorStyle):
         # the actual orientation.
         x, y, z = self.viewer.cross.GetFocalPoint()
         self.viewer.UpdateSlicesPosition([x, y, z])
-        Publisher.sendMessage('Set cross focal point', position=[x, y, z, 0., 0., 0.])
+        Publisher.sendMessage('Set cross focal point', position=[x, y, z, None, None, None])
         Publisher.sendMessage('Update slice viewer')
  
  
@@ -544,7 +544,7 @@ class TractsInteractorStyle(CrossInteractorStyle):
  
     def OnTractsMouseClick(self, obj, evt):
         # print("Single mouse click")
-        # self.tracts = dtr.compute_tracts(self.tracker, self.seed, self.left_pressed)
+        # self.tracts = dtr.compute_and_visualize_tracts(self.tracker, self.seed, self.left_pressed)
         self.ChangeTracts(True)
  
     def OnTractsReleaseLeftButton(self, obj, evt):
@@ -554,7 +554,7 @@ class TractsInteractorStyle(CrossInteractorStyle):
  
     def ChangeTracts(self, pressed):
         # print("Trying to compute tracts")
-        self.tracts = dtr.compute_tracts(self.tracker, self.seed, self.affine_vtk, pressed)
+        self.tracts = dtr.compute_and_visualize_tracts(self.tracker, self.seed, self.affine_vtk, pressed)
         # mouse_x, mouse_y = iren.GetEventPosition()
         # wx, wy, wz = self.viewer.get_coordinate_cursor(mouse_x, mouse_y, self.picker)
         # px, py = self.viewer.get_slice_pixel_coord_by_world_pos(wx, wy, wz)
@@ -365,9 +365,16 @@ class SurfaceManager():
         if self.convert2inv:
             # convert between invesalius and world space with shift in the Y coordinate
             affine = sl.Slice().affine
+            # TODO: Check that this is needed with the new way of using affine
+            #  now the affine should be at least the identity(4) and never None
             if affine is not None:
-                affine[1, -1] -= sl.Slice().spacing[1] * (sl.Slice().matrix.shape[1] - 1)
+                matrix_shape = sl.Slice().matrix.shape
+                spacing = sl.Slice().spacing
+                img_shift = spacing[1] * (matrix_shape[1] - 1)
+                affine = sl.Slice().affine.copy()
+                affine[1, -1] -= img_shift
                 affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(affine)
+
                 actor.SetUserMatrix(affine_vtk)
  
         if overwrite:
@@ -29,14 +29,11 @@ import time
 import numpy as np
 import queue
 from invesalius.pubsub import pub as Publisher
-from scipy.stats import norm
 import vtk
  
 import invesalius.constants as const
 import invesalius.data.imagedata_utils as img_utils
  
-import invesalius.project as prj
-
 # Nice print for arrays
 # np.set_printoptions(precision=2)
 # np.set_printoptions(suppress=True)
@@ -104,75 +101,57 @@ def compute_tubes(trk, direction):
     return trk_tube
  
  
-def combine_tracts_root(out_list, root, n_block):
+def create_branch(out_list, n_block):
     """Adds a set of tracts to given position in a given vtkMultiBlockDataSet
  
     :param out_list: List of vtkTubeFilters representing the tracts
     :type out_list: list
-    :param root: A collection of tracts as a vtkMultiBlockDataSet
-    :type root: vtkMultiBlockDataSet
     :param n_block: The location in the given vtkMultiBlockDataSet to insert the new tracts
     :type n_block: int
-    :return: The updated collection of tracts as a vtkMultiBlockDataSet
-    :rtype: vtkMultiBlockDataSet
-    """
-
-    # create tracts only when at least one was computed
-    # print("Len outlist in root: ", len(out_list))
-    if not out_list.count(None) == len(out_list):
-        for n, tube in enumerate(out_list):
-            root.SetBlock(n_block + n, tube.GetOutput())
-
-    return root
-
-
-def combine_tracts_branch(out_list):
-    """Combines a set of tracts in vtkMultiBlockDataSet
-
-    :param out_list: List of vtkTubeFilters representing the tracts
-    :type out_list: list
-    :return: A collection of tracts as a vtkMultiBlockDataSet
+    :return: The collection of tracts (streamlines) as a vtkMultiBlockDataSet
     :rtype: vtkMultiBlockDataSet
     """
  
+    # create a branch and add the streamlines
     branch = vtk.vtkMultiBlockDataSet()
+
     # create tracts only when at least one was computed
     # print("Len outlist in root: ", len(out_list))
+    # TODO: check if this if statement is required, because we should
+    #  call this function only when tracts exist
     if not out_list.count(None) == len(out_list):
         for n, tube in enumerate(out_list):
-            branch.SetBlock(n, tube.GetOutput())
+            branch.SetBlock(n_block + n, tube.GetOutput())
  
     return branch
  
  
-def tracts_computation(trk_list, root, n_tracts):
+def compute_tracts(trk_list, n_tract=0, alpha=255):
     """Convert the list of all computed tracts given by Trekker run and returns a vtkMultiBlockDataSet
  
     :param trk_list: List of lists containing the computed tracts and corresponding coordinates
     :type trk_list: list
-    :param root: A collection of tracts as a vtkMultiBlockDataSet
-    :type root: vtkMultiBlockDataSet
-    :param n_tracts:
-    :type n_tracts: int
+    :param n_tract: The integer ID of the block in the vtkMultiBlockDataSet
+    :type n_tract: int
+    :param alpha: The transparency of the streamlines from 0 to 255 (transparent to opaque)
+    :type alpha: int
     :return: The updated collection of tracts as a vtkMultiBlockDataSet
     :rtype: vtkMultiBlockDataSet
     """
  
     # Transform tracts to array
     trk_arr = [np.asarray(trk_n).T if trk_n else None for trk_n in trk_list]
-
     # Compute the directions
-    trk_dir = [compute_directions(trk_n) for trk_n in trk_arr]
-
+    trk_dir = [compute_directions(trk_n, alpha) for trk_n in trk_arr]
     # Compute the vtk tubes
     out_list = [compute_tubes(trk_arr_n, trk_dir_n) for trk_arr_n, trk_dir_n in zip(trk_arr, trk_dir)]
+    # create a branch and add the tracts
+    branch = create_branch(out_list, n_tract)
  
-    root = combine_tracts_root(out_list, root, n_tracts)
-
-    return root
+    return branch
  
  
-def compute_tracts(trekker, position, affine, affine_vtk, n_tracts):
+def compute_and_visualize_tracts(trekker, position, affine, affine_vtk, n_tracts_max):
     """ Compute tractograms using the Trekker library.
  
     :param trekker: Trekker library instance
@@ -183,52 +162,51 @@ def compute_tracts(trekker, position, affine, affine_vtk, n_tracts):
     :type affine: numpy.ndarray
     :param affine_vtk: vtkMatrix4x4 isntance with affine transformation matrix
     :type affine_vtk: vtkMatrix4x4
-    :param n_tracts: number of tracts to compute
-    :type n_tracts: int
+    :param n_tracts_max: maximum number of tracts to compute
+    :type n_tracts_max: int
     """
  
-    # during neuronavigation, root needs to be initialized outside the while loop so the new tracts
-    # can be appended to the root block set
-    root = vtk.vtkMultiBlockDataSet()
+    # root = vtk.vtkMultiBlockDataSet()
     # Juuso's
     # seed = np.array([[-8.49, -8.39, 2.5]])
     # Baran M1
     # seed = np.array([[27.53, -77.37, 46.42]])
     seed_trk = img_utils.convert_world_to_voxel(position, affine)
-    # print("seed example: {}".format(seed_trk))
-    trekker.seed_coordinates(np.repeat(seed_trk, n_tracts, axis=0))
-    # print("trk list len: ", len(trekker.run()))
-    trk_list = trekker.run()
-    if trk_list:
-        root = tracts_computation(trk_list, root, 0)
-        Publisher.sendMessage('Remove tracts')
-        Publisher.sendMessage('Update tracts', root=root, affine_vtk=affine_vtk, coord_offset=position)
-    else:
-        Publisher.sendMessage('Remove tracts')
-
-
-def tracts_computation_branch(trk_list, alpha=255):
-    """Convert the list of all computed tracts given by Trekker run and returns a vtkMultiBlockDataSet
-
-    :param trk_list: List of lists containing the computed tracts and corresponding coordinates
-    :type trk_list: list
-    :param alpha: opacity value in the interval [0, 255]. The 0 is no opacity (total transparency).
-    :type alpha: int
-    :return: The collection of tracts as a vtkMultiBlockDataSet
-    :rtype: vtkMultiBlockDataSet
-    """
-    # Transform tracts to array
-    trk_arr = [np.asarray(trk_n).T if trk_n else None for trk_n in trk_list]
-    # Compute the directions
-    trk_dir = [compute_directions(trk_n, alpha) for trk_n in trk_arr]
-    # Compute the vtk tubes
-    tube_list = [compute_tubes(trk_arr_n, trk_dir_n) for trk_arr_n, trk_dir_n in zip(trk_arr, trk_dir)]
-    branch = combine_tracts_branch(tube_list)
-
-    return branch
+    bundle = vtk.vtkMultiBlockDataSet()
+    n_branches, n_tracts, count_loop = 0, 0, 0
+    n_threads = 2 * const.N_CPU - 1
+
+    while n_tracts < n_tracts_max:
+        n_param = 1 + (count_loop % 10)
+        # rescale the alpha value that defines the opacity of the branch
+        # the n interval is [1, 10] and the new interval is [51, 255]
+        # the new interval is defined to have no 0 opacity (minimum is 51, i.e., 20%)
+        alpha = (n_param - 1) * (255 - 51) / (10 - 1) + 51
+        trekker.minFODamp(n_param * 0.01)
+
+        # print("seed example: {}".format(seed_trk))
+        trekker.seed_coordinates(np.repeat(seed_trk, n_threads, axis=0))
+        # print("trk list len: ", len(trekker.run()))
+        trk_list = trekker.run()
+        n_tracts += len(trk_list)
+        if len(trk_list):
+            branch = compute_tracts(trk_list, n_tract=0, alpha=alpha)
+            bundle.SetBlock(n_branches, branch)
+            n_branches += 1
+
+        count_loop += 1
+
+        if (count_loop == 20) and (n_tracts == 0):
+            break
+
+    Publisher.sendMessage('Remove tracts')
+    if n_tracts:
+        Publisher.sendMessage('Update tracts', root=bundle, affine_vtk=affine_vtk,
+                              coord_offset=position, coord_offset_w=seed_trk[0].tolist())
  
  
 class ComputeTractsThread(threading.Thread):
+    # TODO: Remove this class and create a case where no ACT is provided in the class ComputeTractsACTThread
  
     def __init__(self, inp, queues, event, sle):
         """Class (threading) to compute real time tractography data for visualization.
@@ -265,6 +243,7 @@ class ComputeTractsThread(threading.Thread):
  
         trekker, affine, offset, n_tracts_total, seed_radius, n_threads, act_data, affine_vtk, img_shift = self.inp
         # n_threads = n_tracts_total
+        n_threads = int(n_threads/4)
         p_old = np.array([[0., 0., 0.]])
         n_tracts = 0
  
@@ -312,13 +291,13 @@ class ComputeTractsThread(threading.Thread):
                 # run the trekker, this is the slowest line of code, be careful to just use once!
                 trk_list = trekker.run()
  
-                if trk_list:
+                if len(trk_list) > 2:
                     # print("dist: {}".format(dist))
                     if dist >= seed_radius:
                         # when moving the coil further than the seed_radius restart the bundle computation
                         bundle = vtk.vtkMultiBlockDataSet()
                         n_branches = 0
-                        branch = tracts_computation_branch(trk_list)
+                        branch = compute_tracts(trk_list, n_tract=0, alpha=255)
                         bundle.SetBlock(n_branches, branch)
                         n_branches += 1
                         n_tracts = branch.GetNumberOfBlocks()
@@ -326,7 +305,7 @@ class ComputeTractsThread(threading.Thread):
                     # TODO: maybe keep computing even if reaches the maximum
                     elif dist < seed_radius and n_tracts < n_tracts_total:
                         # compute tracts blocks and add to bungle until reaches the maximum number of tracts
-                        branch = tracts_computation_branch(trk_list)
+                        branch = compute_tracts(trk_list, n_tract=0, alpha=255)
                         if bundle:
                             bundle.SetBlock(n_branches, branch)
                             n_tracts += branch.GetNumberOfBlocks()
@@ -361,314 +340,218 @@ class ComputeTractsThread(threading.Thread):
  
 class ComputeTractsACTThread(threading.Thread):
  
-    def __init__(self, inp, queues, event, sle):
+    def __init__(self, input_list, queues, event, sleep_thread):
         """Class (threading) to compute real time tractography data for visualization.
  
         Tracts are computed using the Trekker library by Baran Aydogan (https://dmritrekker.github.io/)
         For VTK visualization, each tract (fiber) is a constructed as a tube and many tubes combined in one
         vtkMultiBlockDataSet named as a branch. Several branches are combined in another vtkMultiBlockDataSet named as
         bundle, to obtain fast computation and visualization. The bundle dataset is mapped to a single vtkActor.
-        Mapper and Actor are computer in the data/viewer_volume.py module for easier handling in the invesalius 3D scene.
+        Mapper and Actor are computer in the data/viewer_volume.py module for easier handling in the
+         invesalius 3D scene.
  
         Sleep function in run method is used to avoid blocking GUI and more fluent, real-time navigation
  
-        :param inp: List of inputs: trekker instance, affine numpy array, seed_offset, seed_radius, n_threads
-        :type inp: list
+        :param input_list: List of inputs: trekker instance, affine numpy array, seed offset, total number of tracts,
+         seed radius, number of threads in computer, ACT data array, affine vtk matrix,
+          image shift for vtk to mri transformation
+        :type input_list: list
         :param queues: Queue list with coord_tracts_queue (Queue instance that manage co-registered coordinates) and
          tracts_queue (Queue instance that manage the tracts to be visualized)
         :type queues: list[queue.Queue, queue.Queue]
         :param event: Threading event to coordinate when tasks as done and allow UI release
         :type event: threading.Event
-        :param sle: Sleep pause in seconds
-        :type sle: float
+        :param sleep_thread: Sleep pause in seconds
+        :type sleep_thread: float
         """
  
         threading.Thread.__init__(self, name='ComputeTractsThreadACT')
-        self.inp = inp
-        # self.coord_queue = coord_queue
+        self.input_list = input_list
         self.coord_tracts_queue = queues[0]
         self.tracts_queue = queues[1]
-        # on first pilots (january 12, 2021) used (-4, 4)
-        self.coord_list_w = img_utils.create_grid((-2, 2), (0, 20), inp[2]-5, 1)
-        # self.coord_list_sph = img_utils.create_spherical_grid(10, 1)
-        # self.coord_list_sph = img_utils.create_spherical_grid(10, 1)
-        # x_norm = np.linspace(norm.ppf(0.01), norm.ppf(0.99), 2*self.coord_list_sph.shape[0])
-        # self.pdf = np.flipud(norm.pdf(x_norm[:self.coord_list_sph.shape[0]], loc=0, scale=2.))
-        # self.sph_idx = np.linspace(0, self.coord_list_sph.shape[0], num=self.coord_list_sph.shape[0], dtype=int)
-        # self.visualization_queue = visualization_queue
         self.event = event
-        self.sle = sle
-
-        # prj_data = prj.Project()
-        # matrix_shape = tuple(prj_data.matrix_shape)
-        # self.img_shift = matrix_shape[1]
+        self.sleep_thread = sleep_thread
  
     def run(self):
  
-        # trekker, affine, offset, n_tracts_total, seed_radius, n_threads = self.inp
-        trekker, affine, offset, n_tracts_total, seed_radius, n_threads, act_data, affine_vtk, img_shift = self.inp
+        trekker, affine, offset, n_tracts_total, seed_radius, n_threads, act_data, affine_vtk, img_shift = self.input_list
  
-        # n_threads = n_tracts_total
         p_old = np.array([[0., 0., 0.]])
-        p_old_pre = np.array([[0., 0., 0.]])
-        coord_offset = None
-        n_tracts = 0
-        n_branches = 0
+        n_branches, n_tracts, count_loop = 0, 0, 0
         bundle = None
-        sph_sampling = True
         dist_radius = 1.5
  
-        xyz = img_utils.random_sample_sphere(radius=seed_radius, size=100)
-        coord_list_sph = np.hstack([xyz, np.ones([xyz.shape[0], 1])]).T
+        # TODO: Try a denser and bigger grid, because it's just a matrix multiplication
+        #  maybe 15 mm below the coil offset by default and 5 cm deep
+        # create the rectangular grid to find the gray-white matter boundary
+        coord_list_w = img_utils.create_grid((-2, 2), (0, 20), offset - 5, 1)
+
+        # create the spherical grid to sample around the seed location
+        samples_in_sphere = img_utils.random_sample_sphere(radius=seed_radius, size=100)
+        coord_list_sphere = np.hstack([samples_in_sphere, np.ones([samples_in_sphere.shape[0], 1])]).T
         m_seed = np.identity(4)
+
         # Compute the tracts
-        # print('ComputeTractsThread: event {}'.format(self.event.is_set()))
         while not self.event.is_set():
             try:
-                # print("Computing tracts")
                 # get from the queue the coordinates, coregistration transformation matrix, and flipped matrix
                 m_img_flip = self.coord_tracts_queue.get_nowait()
-                # coord, m_img, m_img_flip = self.coord_queue.get_nowait()
-                # print('ComputeTractsThread: get {}'.format(count))
-
-                # TODO: Remove this is not needed
-                # 20200402: in this new refactored version the m_img comes different than the position
-                # the new version m_img is already flixped in y, which means that Y is negative
-                # if only the Y is negative maybe no need for the flip_x funtcion at all in the navigation
-                # but check all coord_queue before why now the m_img comes different than position
-                # 20200403: indeed flip_x is just a -1 multiplication to the Y coordinate, remove function flip_x
-                # m_img_flip = m_img.copy()
-                # m_img_flip[1, -1] = -m_img_flip[1, -1]
  
                 # DEBUG: Uncomment the m_img_flip below so that distance is fixed and tracts keep computing
                 # m_img_flip[:3, -1] = (5., 10., 12.)
-                dist = abs(np.linalg.norm(p_old_pre - np.asarray(m_img_flip[:3, -1])))
-                p_old_pre = m_img_flip[:3, -1].copy()
-
-                # Uncertanity visualization  --
-                # each tract branch is computed with one set of parameters ajusted from 1 to 10
-                n_param = 1 + (n_branches % 10)
+                dist = abs(np.linalg.norm(p_old - np.asarray(m_img_flip[:3, -1])))
+                p_old = m_img_flip[:3, -1].copy()
+
+                # Uncertainty visualization  --
+                # each tract branch is computed with one minFODamp adjusted from 0.01 to 0.1
+                # the higher the minFODamp the more the streamlines are faithful to the data, so they become more strict
+                # but also may loose some connections.
+                # the lower the more relaxed streamline also increases the chance of false positives
+                n_param = 1 + (count_loop % 10)
                 # rescale the alpha value that defines the opacity of the branch
                 # the n interval is [1, 10] and the new interval is [51, 255]
                 # the new interval is defined to have no 0 opacity (minimum is 51, i.e., 20%)
                 alpha = (n_param - 1) * (255 - 51) / (10 - 1) + 51
                 trekker.minFODamp(n_param * 0.01)
-                trekker.dataSupportExponent(n_param * 0.1)
                 # ---
  
+                try:
+                    # The original seed location is replaced by the gray-white matter interface that is closest to
+                    # the coil center
+                    coord_list_w_tr = m_img_flip @ coord_list_w
+                    coord_offset = grid_offset(act_data, coord_list_w_tr, img_shift)
+                except IndexError:
+                    # This error might be caused by the coordinate exceeding the image array dimensions.
+                    # This happens during navigation because the coil location can have coordinates outside the image
+                    # boundaries
+                    # Translate the coordinate along the normal vector of the object/coil
+                    coord_offset = m_img_flip[:3, -1] - offset * m_img_flip[:3, 2]
+                # ---
+
+                # Spherical sampling of seed coordinates ---
+                # compute the samples of a sphere centered on seed coordinate offset by the grid
+                # given in the invesalius-vtk space
+                samples = np.random.choice(coord_list_sphere.shape[1], size=100)
+                m_seed[:-1, -1] = coord_offset.copy()
+                # translate the spherical grid samples to the coil location in invesalius-vtk space
+                seed_trk_r_inv = m_seed @ coord_list_sphere[:, samples]
+
+                coord_offset_w = np.hstack((coord_offset, 1.0)).reshape([4, 1])
+
+                try:
+                    # Anatomic constrained seed computation ---
+                    # find only the samples inside the white matter as with the ACT enabled in the Trekker,
+                    # it does not compute any tracts outside the white matter
+                    # convert from inveslaius-vtk to mri space
+                    seed_trk_r_mri = seed_trk_r_inv[:3, :].T.astype(int) + np.array([[0, img_shift, 0]], dtype=np.int32)
+                    labs = act_data[seed_trk_r_mri[..., 0], seed_trk_r_mri[..., 1], seed_trk_r_mri[..., 2]]
+                    # find all samples in the white matter
+                    labs_id = np.where(labs == 1)
+                    # Trekker has internal multiprocessing approach done in C. Here the number of available threads - 1
+                    # is given, but in case a large number of tracts is requested, it will compute all in parallel
+                    # automatically for a more fluent navigation, better to compute the maximum number the computer can
+                    # handle otherwise gets too slow for the multithreading in Python
+                    seed_trk_r_inv_sampled = seed_trk_r_inv[:, labs_id[0][:n_threads]]
+
+                except IndexError:
+                    # same as on the grid offset above, if the coil is too far from the mri volume the array indices
+                    # are beyond the mri boundaries
+                    # in this case use the grid center instead of the spherical samples
+                    seed_trk_r_inv_sampled = coord_offset_w.copy()
+
+                # convert to the world coordinate system for trekker
+                seed_trk_r_world_sampled = np.linalg.inv(affine) @ seed_trk_r_inv_sampled
+                seed_trk_r_world_sampled = seed_trk_r_world_sampled.T[:, :3]
+
+                # convert to the world coordinate system for saving in the marker list
+                coord_offset_w = np.linalg.inv(affine) @ coord_offset_w
+                coord_offset_w = np.squeeze(coord_offset_w.T[:, :3])
+
+                # DEBUG: uncomment the seed_trk below
+                # seed_trk.shape == [1, 3]
+                # Juuso's
+                # seed_trk = np.array([[-8.49, -8.39, 2.5]])
+                # Baran M1
+                # seed_trk = np.array([[27.53, -77.37, 46.42]])
+                # print("Given: {}".format(seed_trk.shape))
+                # print("Seed: {}".format(seed))
+                # joonas seed that has good tracts
+                # seed_trk = np.array([[29.12, -13.33, 31.65]])
+                # seed_trk_img = np.array([[117, 127, 161]])
+
                 # When moving the coil further than the seed_radius restart the bundle computation
                 # Currently, it stops to compute tracts when the maximum number of tracts is reached maybe keep
                 # computing even if reaches the maximum
                 if dist >= dist_radius:
-                    # Anatomic constrained seed computation ---
-                    # The original seed location is replaced by the gray-white  matter interface that is closest to
-                    # the coil center
-                    try:
-                        #TODO: Create a dialog error to say when the ACT data is not loaded and prevent
-                        # the interface from freezing. Give the user a chance to load it (maybe in task_navigator)
-                        coord_list_w_tr = m_img_flip @ self.coord_list_w
-                        coord_offset = grid_offset(act_data, coord_list_w_tr, img_shift)
-                    except IndexError:
-                        # This error might be caused by the coordinate exceeding the image array dimensions.
-                        # Needs further verification.
-                        coord_offset = None
-                    # ---
-
-                    # Translate the coordinate along the normal vector of the object/coil ---
-                    if coord_offset is None:
-                        # apply the coil transformation matrix
-                        coord_offset = m_img_flip[:3, -1] - offset * m_img_flip[:3, 2]
-                    # ---
-
-                    # convert the world coordinates to the voxel space for using as a seed in Trekker
-                    # seed_trk.shape == [1, 3]
-                    seed_trk = img_utils.convert_world_to_voxel(coord_offset, affine)
-                    # print("Desired: {}".format(seed_trk.shape))
-
-                    # DEBUG: uncomment the seed_trk below
-                    # Juuso's
-                    # seed_trk = np.array([[-8.49, -8.39, 2.5]])
-                    # Baran M1
-                    # seed_trk = np.array([[27.53, -77.37, 46.42]])
-                    # print("Given: {}".format(seed_trk.shape))
-                    # print("Seed: {}".format(seed))
-
-                    # Spherical sampling of seed coordinates ---
-                    if sph_sampling:
-                        # CHECK: We use ACT only for the origin seed, but not for all the other coordinates.
-                        # Check how this can be solved. Applying ACT to all coordinates is maybe too much.
-                        # Maybe it doesn't matter because the ACT is just to help finding the closest location to
-                        # the TMS coil center. Also, note that the spherical sampling is applied only when the coil
-                        # location changes, all further iterations used the fixed n_threads samples to compute the
-                        # remaining tracts.
-
-                        # samples = np.random.choice(self.sph_idx, size=n_threads, p=self.pdf)
-                        # m_seed[:-1, -1] = seed_trk
-                        # sph_seed = m_seed @ self.coord_list_sph
-                        # seed_trk_r = sph_seed[samples, :]
-                        samples = np.random.choice(coord_list_sph.shape[1], size=n_threads)
-                        m_seed[:-1, -1] = seed_trk
-                        seed_trk_r = m_seed @ coord_list_sph[:, samples]
-                        seed_trk_r = seed_trk_r[:-1, :].T
-                    else:
-                        # set the seeds for trekker, one seed is repeated n_threads times
-                        # shape (24, 3)
-                        seed_trk_r = np.repeat(seed_trk, n_threads, axis=0)
-
-                    # ---
-
-                    # Trekker has internal multiprocessing approach done in C. Here the number of available threads is
-                    # given, but in case a large number of tracts is requested, it will compute all in parallel
-                    # automatically for a more fluent navigation, better to compute the maximum number the computer
-                    # handles
-                    trekker.seed_coordinates(seed_trk_r)
-                    # trekker.seed_coordinates(np.repeat(seed_trk, n_threads, axis=0))
+                    bundle = None
+                    n_tracts, n_branches = 0, 0
  
+                    # we noticed that usually the navigation lags or crashes when moving the coil location
+                    # to reduce the overhead for when the coil is moving, we compute only half the number of tracts
+                    # that should be computed when the coil is fixed in the same location
+                    # required input is Nx3 array
+                    trekker.seed_coordinates(seed_trk_r_world_sampled[::2, :])
                     # run the trekker, this is the slowest line of code, be careful to just use once!
                     trk_list = trekker.run()
  
                     # check if any tract was found, otherwise doesn't count
-                    if trk_list:
+                    if len(trk_list):
+                        # a bundle consists for multiple branches and each branch consists of multiple streamlines
+                        # every iteration in the main loop adds a branch to the bundle
+                        branch = compute_tracts(trk_list, n_tract=0, alpha=alpha)
+                        n_tracts = branch.GetNumberOfBlocks()
+
+                        # create and add branch to the bundle
                         bundle = vtk.vtkMultiBlockDataSet()
-                        branch = tracts_computation_branch(trk_list, alpha)
                         bundle.SetBlock(n_branches, branch)
                         n_branches = 1
-                        n_tracts = branch.GetNumberOfBlocks()
-                    else:
-                        bundle = None
-                        n_branches = 0
-                        n_tracts = 0
  
                 elif dist < dist_radius and n_tracts < n_tracts_total:
+                    # when the coil is fixed in place and the number of tracts is smaller than the total
+                    if not bundle:
+                        # same as above, when creating the bundle (vtkMultiBlockDataSet) we only compute half the number
+                        # of tracts to reduce the overhead
+                        bundle = vtk.vtkMultiBlockDataSet()
+                        # required input is Nx3 array
+                        trekker.seed_coordinates(seed_trk_r_world_sampled[::2, :])
+                        n_tracts, n_branches = 0, 0
+                    else:
+                        # if the bundle exists compute all tracts requested
+                        # required input is Nx3 array
+                        trekker.seed_coordinates(seed_trk_r_world_sampled)
+
                     trk_list = trekker.run()
-                    if trk_list:
+
+                    if len(trk_list):
                         # compute tract blocks and add to bundle until reaches the maximum number of tracts
                         # the alpha changes depending on the parameter set
-                        branch = tracts_computation_branch(trk_list, alpha)
-                        if bundle:
-                            bundle.SetBlock(n_branches, branch)
-                            n_tracts += branch.GetNumberOfBlocks()
-                            n_branches += 1
-                        else:
-                            bundle = vtk.vtkMultiBlockDataSet()
-                            bundle.SetBlock(n_branches, branch)
-                            n_branches = 1
-                            n_tracts = branch.GetNumberOfBlocks()
-                    # else:
-                    #     bundle = None
+                        branch = compute_tracts(trk_list, n_tract=0, alpha=alpha)
+                        n_tracts += branch.GetNumberOfBlocks()
+                        # add branch to the bundle
+                        bundle.SetBlock(n_branches, branch)
+                        n_branches += 1
  
-                # else:
-                #     bundle = None
+                # keep adding to the number of loops even if the tracts were not find
+                # this will keep the minFODamp changing and new seed coordinates being tried which would allow
+                # higher probability of finding tracts
+                count_loop += 1
  
-                # rethink if this should be inside the if condition, it may lock the thread if no tracts are found
-                # use no wait to ensure maximum speed and avoid visualizing old tracts in the queue, this might
+                # use "nowait" to ensure maximum speed and avoid visualizing old tracts in the queue, this might
                 # be more evident in slow computer or for heavier tract computations, it is better slow update
                 # than visualizing old data
-                # self.visualization_queue.put_nowait([coord, m_img, bundle])
-                self.tracts_queue.put_nowait((bundle, affine_vtk, coord_offset))
-                # print('ComputeTractsThread: put {}'.format(count))
-
+                self.tracts_queue.put_nowait((bundle, affine_vtk, coord_offset, coord_offset_w))
                 self.coord_tracts_queue.task_done()
-                # self.coord_queue.task_done()
-                # print('ComputeTractsThread: done {}'.format(count))
  
                 # sleep required to prevent user interface from being unresponsive
-                time.sleep(self.sle)
+                time.sleep(self.sleep_thread)
             # if no coordinates pass
             except queue.Empty:
-                # print("Empty queue in tractography")
                 pass
             # if queue is full mark as done (may not be needed in this new "nowait" method)
             except queue.Full:
-                # self.coord_queue.task_done()
                 self.coord_tracts_queue.task_done()
  
  
-class ComputeTractsThreadSingleBlock(threading.Thread):
-
-    def __init__(self, inp, affine_vtk, coord_queue, visualization_queue, event, sle):
-        """Class (threading) to compute real time tractography data for visualization in a single loop.
-
-        Different than ComputeTractsThread because it does not keep adding tracts to the bundle until maximum,
-        is reached. It actually compute all requested tracts at once. (Might be deleted in the future)!
-        Tracts are computed using the Trekker library by Baran Aydogan (https://dmritrekker.github.io/)
-        For VTK visualization, each tract (fiber) is a constructed as a tube and many tubes combined in one
-        vtkMultiBlockDataSet named as a branch. Several branches are combined in another vtkMultiBlockDataSet named as
-        bundle, to obtain fast computation and visualization. The bundle dataset is mapped to a single vtkActor.
-        Mapper and Actor are computer in the data/viewer_volume.py module for easier handling in the invesalius 3D scene.
-
-        Sleep function in run method is used to avoid blocking GUI and more fluent, real-time navigation
-
-        :param inp: List of inputs: trekker instance, affine numpy array, seed_offset, seed_radius, n_threads
-        :type inp: list
-        :param affine_vtk: Affine matrix in vtkMatrix4x4 instance to update objects position in 3D scene
-        :type affine_vtk: vtkMatrix4x4
-        :param coord_queue: Queue instance that manage coordinates read from tracking device and coregistered
-        :type coord_queue: queue.Queue
-        :param visualization_queue: Queue instance that manage coordinates to be visualized
-        :type visualization_queue: queue.Queue
-        :param event: Threading event to coordinate when tasks as done and allow UI release
-        :type event: threading.Event
-        :param sle: Sleep pause in seconds
-        :type sle: float
-        """
-
-        threading.Thread.__init__(self, name='ComputeTractsThread')
-        self.inp = inp
-        self.affine_vtk = affine_vtk
-        self.coord_queue = coord_queue
-        self.visualization_queue = visualization_queue
-        self.event = event
-        self.sle = sle
-
-    def run(self):
-
-        trekker, affine, offset, n_tracts_total, seed_radius, n_threads = self.inp
-        # as a single block, computes all the maximum number of tracts at once, not optimal for navigation
-        n_threads = n_tracts_total
-        p_old = np.array([[0., 0., 0.]])
-        root = vtk.vtkMultiBlockDataSet()
-
-        # Compute the tracts
-        # print('ComputeTractsThread: event {}'.format(self.event.is_set()))
-        while not self.event.is_set():
-            try:
-                coord, [coord_raw, markers_flag], m_img, m_img_flip = self.coord_queue.get_nowait()
-
-                # translate the coordinate along the normal vector of the object/coil
-                coord_offset = m_img_flip[:3, -1] - offset * m_img_flip[:3, 2]
-                # coord_offset = np.array([[27.53, -77.37, 46.42]])
-                dist = abs(np.linalg.norm(p_old - np.asarray(coord_offset)))
-                p_old = coord_offset.copy()
-                seed_trk = img_utils.convert_world_to_voxel(coord_offset, affine)
-                # Juuso's
-                # seed_trk = np.array([[-8.49, -8.39, 2.5]])
-                # Baran M1
-                # seed_trk = np.array([[27.53, -77.37, 46.42]])
-                # print("Seed: {}".format(seed))
-
-                # set the seeds for trekker, one seed is repeated n_threads times
-                # trekker has internal multiprocessing approach done in C. Here the number of available threads is give,
-                # but in case a large number of tracts is requested, it will compute all in parallel automatically
-                # for a more fluent navigation, better to compute the maximum number the computer handles
-                trekker.seed_coordinates(np.repeat(seed_trk, n_threads, axis=0))
-                # run the trekker, this is the slowest line of code, be careful to just use once!
-                trk_list = trekker.run()
-
-                if trk_list:
-                    # if the seed is outside the defined radius, restart the bundle computation
-                    if dist >= seed_radius:
-                        root = tracts_computation(trk_list, root, 0)
-                    self.visualization_queue.put_nowait((coord, m_img, root))
-
-                self.coord_queue.task_done()
-                time.sleep(self.sle)
-            except queue.Empty:
-                pass
-            except queue.Full:
-                self.coord_queue.task_done()
-
-
 def set_trekker_parameters(trekker, params):
     """Set all user-defined parameters for tractography computation using the Trekker library
  
@@ -680,21 +563,27 @@ def set_trekker_parameters(trekker, params):
     :rtype: list
     """
     trekker.seed_maxTrials(params['seed_max'])
-    # trekker.stepSize(params['step_size'])
-    trekker.minFODamp(params['min_fod'])
-    # trekker.probeQuality(params['probe_quality'])
-    # trekker.maxEstInterval(params['max_interval'])
-    # trekker.minRadiusOfCurvature(params['min_radius_curv'])
-    # trekker.probeLength(params['probe_length'])
+    trekker.stepSize(params['step_size'])
+    # minFODamp is not set because it should vary in the loop to create the
+    # different transparency tracts
+    # trekker.minFODamp(params['min_fod'])
+    trekker.probeQuality(params['probe_quality'])
+    trekker.maxEstInterval(params['max_interval'])
+    trekker.minRadiusOfCurvature(params['min_radius_curvature'])
+    trekker.probeLength(params['probe_length'])
     trekker.writeInterval(params['write_interval'])
-    trekker.maxLength(params['max_lenth'])
-    trekker.minLength(params['min_lenth'])
+    # these two does not need to be set in the new package
+    # trekker.maxLength(params['max_length'])
+    trekker.minLength(params['min_length'])
     trekker.maxSamplingPerStep(params['max_sampling_step'])
+    trekker.dataSupportExponent(params['data_support_exponent'])
+    #trekker.useBestAtInit(params['use_best_init'])
+    #trekker.initMaxEstTrials(params['init_max_est_trials'])
  
     # check number if number of cores is valid in configuration file,
     # otherwise use the maximum number of threads which is usually 2*N_CPUS
-    n_threads = 2 * const.N_CPU
-    if isinstance((params['numb_threads']), int) and params['numb_threads'] <= 2*const.N_CPU:
+    n_threads = 2 * const.N_CPU - 1
+    if isinstance((params['numb_threads']), int) and params['numb_threads'] <= (2*const.N_CPU-1):
         n_threads = params['numb_threads']
  
     trekker.numberOfThreads(n_threads)
@@ -712,13 +601,21 @@ def grid_offset(data, coord_list_w_tr, img_shift):
  
     # extract the first occurrence of a specific label from the MRI image
     labs = data[coord_list_w_tr_mri[..., 0], coord_list_w_tr_mri[..., 1], coord_list_w_tr_mri[..., 2]]
-    lab_first = np.argmax(labs == 1)
-    if labs[lab_first] == 1:
-        pt_found = coord_list_w_tr_mri[lab_first, :]
+    lab_first = np.where(labs == 1)
+    if not lab_first:
+        pt_found_inv = None
+    else:
+        pt_found = coord_list_w_tr[:, lab_first[0][0]][:3]
         # convert coordinate back to invesalius 3D space
         pt_found_inv = pt_found - np.array([0., img_shift, 0.])
-    else:
-        pt_found_inv = None
+
+    # lab_first = np.argmax(labs == 1)
+    # if labs[lab_first] == 1:
+    #     pt_found = coord_list_w_tr_mri[lab_first, :]
+    #     # convert coordinate back to invesalius 3D space
+    #     pt_found_inv = pt_found - np.array([0., img_shift, 0.])
+    # else:
+    #     pt_found_inv = None
  
     # # convert to world coordinate space to use as seed for fiber tracking
     # pt_found_tr = np.append(pt_found, 1)[np.newaxis, :].T
@@ -70,8 +70,8 @@ class Viewer(wx.Panel):
  
         self.initial_focus = None
  
-        self.staticballs = []
-
+        self.static_markers = []
+        self.static_arrows = []
         self.style = None
  
         interactor = wxVTKRenderWindowInteractor(self, -1, size = self.GetSize())
@@ -278,6 +278,7 @@ class Viewer(wx.Panel):
  
         # Related to marker creation in navigation tools
         Publisher.subscribe(self.AddMarker, 'Add marker')
+        Publisher.subscribe(self.AddMarkerwithOrientation, 'Add arrow marker')
         Publisher.subscribe(self.HideAllMarkers, 'Hide all markers')
         Publisher.subscribe(self.ShowAllMarkers, 'Show all markers')
         Publisher.subscribe(self.RemoveAllMarkers, 'Remove all markers')
@@ -306,7 +307,6 @@ class Viewer(wx.Panel):
         Publisher.subscribe(self.OnRemoveTracts, 'Remove tracts')
         Publisher.subscribe(self.UpdateSeedOffset, 'Update seed offset')
         Publisher.subscribe(self.UpdateMarkerOffsetState, 'Update marker offset state')
-        Publisher.subscribe(self.UpdateMarkerOffsetPosition, 'Update marker offset')
         Publisher.subscribe(self.AddPeeledSurface, 'Update peel')
         Publisher.subscribe(self.GetPeelCenters, 'Get peel centers and normals')
         Publisher.subscribe(self.Initlocator_viewer, 'Get init locator')
@@ -579,7 +579,7 @@ class Viewer(wx.Panel):
         """
         Set all markers, overwriting the previous markers.
         """
-        self.RemoveAllMarkers(len(self.staticballs))
+        self.RemoveAllMarkers(len(self.static_markers))
  
         target_selected = False
         for marker in markers:
@@ -607,6 +607,21 @@ class Viewer(wx.Panel):
  
         self.UpdateRender()
  
+    def AddMarkerwithOrientation(self, arrow_id, size, color, coord):
+        """
+        Markers arrow with orientation created by navigation tools and rendered in volume viewer.
+        """
+        self.arrow_marker_id = arrow_id
+        coord_flip = list(coord)
+        coord_flip[1] = -coord_flip[1]
+
+        arrow_actor = self.Add_ObjectArrow(coord_flip[:3], coord_flip[3:6], color, size)
+        self.static_markers.append(arrow_actor)
+        self.ren.AddActor(self.static_markers[self.arrow_marker_id])
+        self.arrow_marker_id += 1
+
+        self.Refresh()
+
     def AddMarker(self, ball_id, size, colour, coord):
         """
         Markers created by navigation tools and rendered in volume viewer.
@@ -626,12 +641,12 @@ class Viewer(wx.Panel):
         prop.SetColor(colour)
  
         # adding a new actor for the present ball
-        self.staticballs.append(vtk.vtkActor())
+        self.static_markers.append(vtk.vtkActor())
  
-        self.staticballs[self.ball_id].SetMapper(mapper)
-        self.staticballs[self.ball_id].SetProperty(prop)
+        self.static_markers[self.ball_id].SetMapper(mapper)
+        self.static_markers[self.ball_id].SetProperty(prop)
  
-        self.ren.AddActor(self.staticballs[self.ball_id])
+        self.ren.AddActor(self.static_markers[self.ball_id])
         self.ball_id += 1
  
         #self.UpdateRender()
@@ -667,33 +682,33 @@ class Viewer(wx.Panel):
     def HideAllMarkers(self, indexes):
         ballid = indexes
         for i in range(0, ballid):
-            self.staticballs[i].SetVisibility(0)
+            self.static_markers[i].SetVisibility(0)
         self.UpdateRender()
  
     def ShowAllMarkers(self, indexes):
         ballid = indexes
         for i in range(0, ballid):
-            self.staticballs[i].SetVisibility(1)
+            self.static_markers[i].SetVisibility(1)
         self.UpdateRender()
  
     def RemoveAllMarkers(self, indexes):
         ballid = indexes
         for i in range(0, ballid):
-            self.ren.RemoveActor(self.staticballs[i])
-        self.staticballs = []
+            self.ren.RemoveActor(self.static_markers[i])
+        self.static_markers = []
         self.UpdateRender()
  
     def RemoveMultipleMarkers(self, index):
         for i in reversed(index):
-            self.ren.RemoveActor(self.staticballs[i])
-            del self.staticballs[i]
+            self.ren.RemoveActor(self.static_markers[i])
+            del self.static_markers[i]
             self.ball_id = self.ball_id - 1
         self.UpdateRender()
  
     def BlinkMarker(self, index):
         if self.timer:
             self.timer.Stop()
-            self.staticballs[self.index].SetVisibility(1)
+            self.static_markers[self.index].SetVisibility(1)
         self.index = index
         self.timer = wx.Timer(self)
         self.Bind(wx.EVT_TIMER, self.OnBlinkMarker, self.timer)
@@ -701,7 +716,7 @@ class Viewer(wx.Panel):
         self.timer_count = 0
  
     def OnBlinkMarker(self, evt):
-        self.staticballs[self.index].SetVisibility(int(self.timer_count % 2))
+        self.static_markers[self.index].SetVisibility(int(self.timer_count % 2))
         self.Refresh()
         self.timer_count += 1
  
@@ -709,20 +724,20 @@ class Viewer(wx.Panel):
         if self.timer:
             self.timer.Stop()
             if index is None:
-                self.staticballs[self.index].SetVisibility(1)
+                self.static_markers[self.index].SetVisibility(1)
                 self.Refresh()
             self.index = False
  
     def SetNewColor(self, index, color):
-        self.staticballs[index].GetProperty().SetColor([round(s/255.0, 3) for s in color])
+        self.static_markers[index].GetProperty().SetColor([round(s / 255.0, 3) for s in color])
         self.Refresh()
  
     def OnTargetMarkerTransparency(self, status, index):
         if status:
-            self.staticballs[index].GetProperty().SetOpacity(1)
+            self.static_markers[index].GetProperty().SetOpacity(1)
             # self.staticballs[index].GetProperty().SetOpacity(0.4)
         else:
-            self.staticballs[index].GetProperty().SetOpacity(1)
+            self.static_markers[index].GetProperty().SetOpacity(1)
  
     def OnUpdateAngleThreshold(self, angle):
         self.anglethreshold = angle
@@ -841,8 +856,10 @@ class Viewer(wx.Panel):
         else:
             self.DisableCoilTracker()
             if self.actor_peel:
-                self.object_orientation_torus_actor.SetVisibility(1)
-                self.obj_projection_arrow_actor.SetVisibility(1)
+                if self.object_orientation_torus_actor:
+                    self.object_orientation_torus_actor.SetVisibility(1)
+                if self.obj_projection_arrow_actor:
+                    self.obj_projection_arrow_actor.SetVisibility(1)
  
     def OnUpdateObjectTargetGuide(self, m_img, coord):
  
@@ -992,16 +1009,10 @@ class Viewer(wx.Panel):
             self.RemoveTarget()
             self.DisableCoilTracker()
  
-    def CreateTargetAim(self):
-        if self.aim_actor:
-            self.RemoveTargetAim()
-            self.aim_actor = None
-
-        vtk_colors = vtk.vtkNamedColors()
-
+    def CreateVTKObjectMatrix(self, direction, orientation):
         m_img = dco.coordinates_to_transformation_matrix(
-            position=self.target_coord[:3],
-            orientation=self.target_coord[3:],
+            position=direction,
+            orientation=orientation,
             axes='sxyz',
         )
         m_img = np.asmatrix(m_img)
@@ -1012,7 +1023,16 @@ class Viewer(wx.Panel):
             for col in range(0, 4):
                 m_img_vtk.SetElement(row, col, m_img[row, col])
  
-        self.m_img_vtk = m_img_vtk
+        return m_img_vtk
+
+    def CreateTargetAim(self):
+        if self.aim_actor:
+            self.RemoveTargetAim()
+            self.aim_actor = None
+
+        vtk_colors = vtk.vtkNamedColors()
+
+        self.m_img_vtk = self.CreateVTKObjectMatrix(self.target_coord[:3], self.target_coord[3:])
  
         filename = os.path.join(inv_paths.OBJ_DIR, "aim.stl")
  
@@ -1023,7 +1043,7 @@ class Viewer(wx.Panel):
  
         # Transform the polydata
         transform = vtk.vtkTransform()
-        transform.SetMatrix(m_img_vtk)
+        transform.SetMatrix(self.m_img_vtk)
         transformPD = vtk.vtkTransformPolyDataFilter()
         transformPD.SetTransform(transform)
         transformPD.SetInputConnection(reader.GetOutputPort())
@@ -1071,7 +1091,7 @@ class Viewer(wx.Panel):
         self.dummy_coil_actor.GetProperty().SetSpecularPower(10)
         self.dummy_coil_actor.GetProperty().SetOpacity(.3)
         self.dummy_coil_actor.SetVisibility(1)
-        self.dummy_coil_actor.SetUserMatrix(m_img_vtk)
+        self.dummy_coil_actor.SetUserMatrix(self.m_img_vtk)
  
         self.ren.AddActor(self.dummy_coil_actor)
  
@@ -1424,8 +1444,9 @@ class Viewer(wx.Panel):
         actor.GetProperty().SetLineWidth(5)
         actor.AddPosition(0, 0, 0)
         actor.SetScale(size)
-        actor.SetPosition(direction)
-        actor.SetOrientation(orientation)
+
+        m_img_vtk = self.CreateVTKObjectMatrix(direction, orientation)
+        actor.SetUserMatrix(m_img_vtk)
  
         return actor
  
@@ -1587,10 +1608,6 @@ class Viewer(wx.Panel):
         self.ren.AddActor(self.mark_actor)
         self.Refresh()
  
-    def UpdateMarkerOffsetPosition(self, coord_offset):
-        self.mark_actor.SetPosition(coord_offset)
-        self.Refresh()
-
     def UpdateObjectOrientation(self, m_img, coord):
         # print("Update object orientation")
  
@@ -1667,7 +1684,7 @@ class Viewer(wx.Panel):
             #    self.ball_actor.SetVisibility(1)
         self.Refresh()
  
-    def OnUpdateTracts(self, root=None, affine_vtk=None, coord_offset=None):
+    def OnUpdateTracts(self, root=None, affine_vtk=None, coord_offset=None, coord_offset_w=None):
         mapper = vtk.vtkCompositePolyDataMapper2()
         mapper.SetInputDataObject(root)
  
@@ -4203,7 +4203,7 @@ class GoToDialogScannerCoord(wx.Dialog):
         main_sizer.Fit(self)
  
         self.orientation = None
-        self.affine = None
+        self.affine = np.identity(4)
  
         self.__bind_events()
  
@@ -165,7 +165,7 @@ class InnerFoldPanel(wx.Panel):
         # Study this.
  
         fold_panel = fpb.FoldPanelBar(self, -1, wx.DefaultPosition,
-                                      (10, 310), 0, fpb.FPB_SINGLE_FOLD)
+                                      (10, 330), 0, fpb.FPB_SINGLE_FOLD)
  
         # Initialize Tracker and PedalConnection objects here so that they are available to several panels.
         #
@@ -359,7 +359,7 @@ class NeuronavigationPanel(wx.Panel):
  
         self.nav_status = False
         self.tracker_fiducial_being_set = None
-        self.current_coord = 0, 0, 0
+        self.current_coord = 0, 0, 0, None, None, None
  
         # Initialize list of buttons and numctrls for wx objects
         self.btns_set_fiducial = [None, None, None, None, None, None]
@@ -704,7 +704,7 @@ class NeuronavigationPanel(wx.Panel):
         if self.btns_set_fiducial[n].GetValue():
             coord = self.numctrls_fiducial[n][0].GetValue(),\
                     self.numctrls_fiducial[n][1].GetValue(),\
-                    self.numctrls_fiducial[n][2].GetValue(), 0, 0, 0
+                    self.numctrls_fiducial[n][2].GetValue(), None, None, None
  
             Publisher.sendMessage('Set image fiducial', fiducial_name=fiducial_name, coord=coord[0:3])
  
@@ -1078,17 +1078,15 @@ class ObjectRegistrationPanel(wx.Panel):
  
         try:
             if filename:
-                #TODO: Improve method to read the file, using "with" similar to OnLoadParameters
-                data = np.loadtxt(filename, delimiter='\t')
-                self.obj_fiducials = data[:, :3]
-                self.obj_orients = data[:, 3:]
+                with open(filename, 'r') as text_file:
+                    data = [s.split('\t') for s in text_file.readlines()]
  
-                text_file = open(filename, "r")
-                header = text_file.readline().split('\t')
-                text_file.close()
+                registration_coordinates = np.array(data[1:]).astype(np.float32)
+                self.obj_fiducials = registration_coordinates[:, :3]
+                self.obj_orients = registration_coordinates[:, 3:]
  
-                self.obj_name = header[1]
-                self.obj_ref_mode = int(header[-1])
+                self.obj_name = data[0][1]
+                self.obj_ref_mode = int(data[0][-1])
  
                 self.checktrack.Enable(1)
                 self.checktrack.SetValue(True)
@@ -1098,7 +1096,7 @@ class ObjectRegistrationPanel(wx.Panel):
                                       label=_("Object file successfully loaded"))
                 Publisher.sendMessage('Update track object state', flag=True, obj_name=self.obj_name)
                 Publisher.sendMessage('Change camera checkbox', status=False)
-                # wx.MessageBox(_("Object file successfully loaded"), _("Load"))
+                wx.MessageBox(_("Object file successfully loaded"), _("InVesalius 3"))
         except:
             wx.MessageBox(_("Object registration file incompatible."), _("InVesalius 3"))
             Publisher.sendMessage('Update status text in GUI', label="")
@@ -1144,9 +1142,9 @@ class MarkersPanel(wx.Panel):
         x : float = 0
         y : float = 0
         z : float = 0
-        alpha : float = 0
-        beta : float = 0
-        gamma : float = 0
+        alpha : float = dataclasses.field(default = None)
+        beta : float = dataclasses.field(default = None)
+        gamma : float = dataclasses.field(default = None)
         r : float = 0
         g : float = 1
         b : float = 0
@@ -1161,7 +1159,7 @@ class MarkersPanel(wx.Panel):
         # x, y, z, alpha, beta, gamma can be jointly accessed as coord
         @property
         def coord(self):
-            return list((self.x, self.y, self.z, self.alpha, self.beta, self.gamma),)
+            return list((self.x, self.y, self.z, self.alpha, self.beta, self.gamma))
  
         @coord.setter
         def coord(self, new_coord):
@@ -1201,11 +1199,18 @@ class MarkersPanel(wx.Panel):
                 else:
                     res += ('%s\t' % str(getattr(self, field.name)))
  
-            # Add world coordinates (in addition to the internal ones).
-            position_world, orientation_world = imagedata_utils.convert_invesalius_to_world(
-                position=[self.x, self.y, self.z],
-                orientation=[self.alpha, self.beta, self.gamma],
-            )
+            if self.alpha is not None and self.beta is not None and self.gamma is not None:
+                # Add world coordinates (in addition to the internal ones).
+                position_world, orientation_world = imagedata_utils.convert_invesalius_to_world(
+                    position=[self.x, self.y, self.z],
+                    orientation=[self.alpha, self.beta, self.gamma],
+                )
+
+            else:
+                position_world, orientation_world = imagedata_utils.convert_invesalius_to_world(
+                      position=[self.x, self.y, self.z],
+                      orientation=[0,0,0],
+                 )
  
             res += '\t'.join(map(lambda x: 'N/A' if x is None else str(x), (*position_world, *orientation_world)))
             return res
@@ -1215,8 +1220,10 @@ class MarkersPanel(wx.Panel):
             properly formatted, might throw an exception and leave the object
             in an inconsistent state."""
             for field, str_val in zip(dataclasses.fields(self.__class__), inp_str.split('\t')):
-                if field.type is float:
+                if field.type is float and str_val != 'None':
                     setattr(self, field.name, float(str_val))
+                if field.type is float and str_val == 'None':
+                    setattr(self, field.name, None)
                 if field.type is int:
                     setattr(self, field.name, int(str_val))
                 if field.type is str:
@@ -1253,8 +1260,7 @@ class MarkersPanel(wx.Panel):
  
         self.session = ses.Session()
  
-        self.current_coord = 0, 0, 0, 0, 0, 0
-        self.current_angle = 0, 0, 0
+        self.current_coord = 0, 0, 0, None, None, None
         self.current_seed = 0, 0, 0
         self.current_robot_target_matrix = [None] * 9
         self.markers = []
@@ -1264,6 +1270,7 @@ class MarkersPanel(wx.Panel):
  
         self.marker_colour = const.MARKER_COLOUR
         self.marker_size = const.MARKER_SIZE
+        self.arrow_marker_size = const.ARROW_MARKER_SIZE
         self.current_session = 1
  
         # Change marker size
@@ -1431,19 +1438,17 @@ class MarkersPanel(wx.Panel):
         return list(itertools.chain(*(const.BTNS_IMG_MARKERS[i].values() for i in const.BTNS_IMG_MARKERS)))
  
     def UpdateCurrentCoord(self, position):
-        self.current_coord = position
-        #self.current_angle = pubsub_evt.data[1][3:]
+        self.current_coord = list(position)
  
     def UpdateNavigationStatus(self, nav_status, vis_status):
         if not nav_status:
-            sleep(0.5)
-            #self.current_coord[3:] = 0, 0, 0
+            self.current_coord[3:] = None, None, None
             self.nav_status = False
         else:
             self.nav_status = True
  
-    def UpdateSeedCoordinates(self, root=None, affine_vtk=None, coord_offset=(0, 0, 0)):
-        self.current_seed = coord_offset
+    def UpdateSeedCoordinates(self, root=None, affine_vtk=None, coord_offset=(0, 0, 0), coord_offset_w=(0, 0, 0)):
+        self.current_seed = coord_offset_w
  
     def UpdateRobotCoordinates(self, coordinates_raw, markers_flag):
         self.raw_target_robot = coordinates_raw[1], coordinates_raw[2]
@@ -1615,8 +1620,8 @@ class MarkersPanel(wx.Panel):
                     if marker.is_target:
                         self.__set_marker_as_target(len(self.markers) - 1)
  
-        except:
-            wx.MessageBox(_("Invalid markers file."), _("InVesalius 3"))     
+        except Exception as e:
+            wx.MessageBox(_("Invalid markers file."), _("InVesalius 3"))
  
     def OnMarkersVisibility(self, evt, ctrl):
         if ctrl.GetValue():
@@ -1681,10 +1686,18 @@ class MarkersPanel(wx.Panel):
         new_robot_marker.robot_target_matrix = self.current_robot_target_matrix
  
         # Note that ball_id is zero-based, so we assign it len(self.markers) before the new marker is added
-        Publisher.sendMessage('Add marker', ball_id=len(self.markers),
-                                            size=new_marker.size,
-                                            colour=new_marker.colour,
-                                            coord=new_marker.coord[:3])
+        if all([elem is not None for elem in new_marker.coord[3:]]):
+            Publisher.sendMessage('Add arrow marker', arrow_id=len(self.markers),
+                                  size=self.arrow_marker_size,
+                                  color=new_marker.colour,
+                                  coord=new_marker.coord)
+        else:
+            Publisher.sendMessage('Add marker', ball_id=len(self.markers),
+                                  size=new_marker.size,
+                                  colour=new_marker.colour,
+                                  coord=new_marker.coord[:3])
+
+
         self.markers.append(new_marker)
         self.robot_markers.append(new_robot_marker)
  
@@ -1720,7 +1733,7 @@ class TractographyPanel(wx.Panel):
             default_colour = wx.SystemSettings_GetColour(wx.SYS_COLOUR_MENUBAR)
         self.SetBackgroundColour(default_colour)
  
-        self.affine = None
+        self.affine = np.identity(4)
         self.affine_vtk = None
         self.trekker = None
         self.n_tracts = const.N_TRACTS
@@ -1977,7 +1990,6 @@ class TractographyPanel(wx.Panel):
         self.nav_status = nav_status
  
     def OnLinkBrain(self, event=None):
-        Publisher.sendMessage('Update status text in GUI', label=_("Busy"))
         Publisher.sendMessage('Begin busy cursor')
         mask_path = dlg.ShowImportOtherFilesDialog(const.ID_NIFTI_IMPORT, _("Import brain mask"))
         img_path = dlg.ShowImportOtherFilesDialog(const.ID_NIFTI_IMPORT, _("Import T1 anatomical image"))
@@ -1991,31 +2003,37 @@ class TractographyPanel(wx.Panel):
             slic = sl.Slice()
             prj_data = prj.Project()
             matrix_shape = tuple(prj_data.matrix_shape)
+            spacing = tuple(prj_data.spacing)
+            img_shift = spacing[1] * (matrix_shape[1] - 1)
             self.affine = slic.affine.copy()
-            self.affine[1, -1] -= matrix_shape[1]
+            self.affine[1, -1] -= img_shift
             self.affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(self.affine)
  
-        try:
-            self.brain_peel = brain.Brain(img_path, mask_path, self.n_peels, self.affine_vtk)
-            self.brain_actor = self.brain_peel.get_actor(self.peel_depth, self.affine_vtk)
-            self.brain_actor.GetProperty().SetOpacity(self.brain_opacity)
-            Publisher.sendMessage('Update peel', flag=True, actor=self.brain_actor)
-            Publisher.sendMessage('Get peel centers and normals', centers=self.brain_peel.peel_centers,
-                                  normals=self.brain_peel.peel_normals)
-            Publisher.sendMessage('Get init locator', locator=self.brain_peel.locator)
-            self.checkpeeling.Enable(1)
-            self.checkpeeling.SetValue(True)
-            self.spin_opacity.Enable(1)
-            Publisher.sendMessage('Update status text in GUI', label=_("Brain model loaded"))
-            self.peel_loaded = True
-            Publisher.sendMessage('Update peel visualization', data= self.peel_loaded)
-        except:
-            wx.MessageBox(_("Unable to load brain mask."), _("InVesalius 3"))
+        if mask_path and img_path:
+            Publisher.sendMessage('Update status text in GUI', label=_("Busy"))
+            try:
+                self.brain_peel = brain.Brain(img_path, mask_path, self.n_peels, self.affine_vtk)
+                self.brain_actor = self.brain_peel.get_actor(self.peel_depth, self.affine_vtk)
+                self.brain_actor.GetProperty().SetOpacity(self.brain_opacity)
+
+                self.checkpeeling.Enable(1)
+                self.checkpeeling.SetValue(True)
+                self.spin_opacity.Enable(1)
+                self.peel_loaded = True
+
+                Publisher.sendMessage('Update peel', flag=True, actor=self.brain_actor)
+                Publisher.sendMessage('Get peel centers and normals', centers=self.brain_peel.peel_centers,
+                                      normals=self.brain_peel.peel_normals)
+                Publisher.sendMessage('Get init locator', locator=self.brain_peel.locator)
+                Publisher.sendMessage('Update status text in GUI', label=_("Brain model loaded"))
+                Publisher.sendMessage('Update peel visualization', data= self.peel_loaded)
+            except:
+                Publisher.sendMessage('Update status text in GUI', label=_("Brain mask initialization failed."))
+                wx.MessageBox(_("Unable to load brain mask."), _("InVesalius 3"))
  
         Publisher.sendMessage('End busy cursor')
  
     def OnLinkFOD(self, event=None):
-        Publisher.sendMessage('Update status text in GUI', label=_("Busy"))
         Publisher.sendMessage('Begin busy cursor')
         filename = dlg.ShowImportOtherFilesDialog(const.ID_NIFTI_IMPORT, msg=_("Import Trekker FOD"))
         # Juuso
@@ -2026,69 +2044,83 @@ class TractographyPanel(wx.Panel):
         # FOD_path = 'Baran_FOD.nii'
         # filename = os.path.join(data_dir, FOD_path)
  
-        # if not self.affine_vtk:
-        #     slic = sl.Slice()
-        #     self.affine = slic.affine
-        #     self.affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(self.affine)
-
         if not self.affine_vtk:
             slic = sl.Slice()
             prj_data = prj.Project()
             matrix_shape = tuple(prj_data.matrix_shape)
+            spacing = tuple(prj_data.spacing)
+            img_shift = spacing[1] * (matrix_shape[1] - 1)
             self.affine = slic.affine.copy()
-            self.affine[1, -1] -= matrix_shape[1]
+            self.affine[1, -1] -= img_shift
             self.affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(self.affine)
  
-        # try:
-
-        self.trekker = Trekker.initialize(filename.encode('utf-8'))
-        self.trekker, n_threads = dti.set_trekker_parameters(self.trekker, self.trekker_cfg)
-
-        self.checktracts.Enable(1)
-        self.checktracts.SetValue(True)
-        self.view_tracts = True
-        Publisher.sendMessage('Update Trekker object', data=self.trekker)
-        Publisher.sendMessage('Update number of threads', data=n_threads)
-        Publisher.sendMessage('Update tracts visualization', data=1)
-        Publisher.sendMessage('Update status text in GUI', label=_("Trekker initialized"))
-        # except:
-        #     wx.MessageBox(_("Unable to initialize Trekker, check FOD and config files."), _("InVesalius 3"))
+        if filename:
+            Publisher.sendMessage('Update status text in GUI', label=_("Busy"))
+            try:
+                self.trekker = Trekker.initialize(filename.encode('utf-8'))
+                self.trekker, n_threads = dti.set_trekker_parameters(self.trekker, self.trekker_cfg)
+
+                self.checktracts.Enable(1)
+                self.checktracts.SetValue(True)
+                self.view_tracts = True
+
+                Publisher.sendMessage('Update Trekker object', data=self.trekker)
+                Publisher.sendMessage('Update number of threads', data=n_threads)
+                Publisher.sendMessage('Update tracts visualization', data=1)
+                Publisher.sendMessage('Update status text in GUI', label=_("Trekker initialized"))
+                # except:
+                #     wx.MessageBox(_("Unable to initialize Trekker, check FOD and config files."), _("InVesalius 3"))
+            except:
+                Publisher.sendMessage('Update status text in GUI', label=_("Trekker initialization failed."))
+                wx.MessageBox(_("Unable to load FOD."), _("InVesalius 3"))
  
         Publisher.sendMessage('End busy cursor')
  
     def OnLoadACT(self, event=None):
-        Publisher.sendMessage('Update status text in GUI', label=_("Busy"))
-        Publisher.sendMessage('Begin busy cursor')
-        filename = dlg.ShowImportOtherFilesDialog(const.ID_NIFTI_IMPORT, msg=_("Import anatomical labels"))
-        # Baran
-        # data_dir = os.environ.get('OneDrive') + r'\data\dti_navigation\baran\anat_reg_improve_20200609'
-        # act_path = 'Baran_trekkerACTlabels_inFODspace.nii'
-        # filename = os.path.join(data_dir, act_path)
+        if self.trekker:
+            Publisher.sendMessage('Begin busy cursor')
+            filename = dlg.ShowImportOtherFilesDialog(const.ID_NIFTI_IMPORT, msg=_("Import anatomical labels"))
+            # Baran
+            # data_dir = os.environ.get('OneDrive') + r'\data\dti_navigation\baran\anat_reg_improve_20200609'
+            # act_path = 'Baran_trekkerACTlabels_inFODspace.nii'
+            # filename = os.path.join(data_dir, act_path)
+
+            if not self.affine_vtk:
+                slic = sl.Slice()
+                prj_data = prj.Project()
+                matrix_shape = tuple(prj_data.matrix_shape)
+                spacing = tuple(prj_data.spacing)
+                img_shift = spacing[1] * (matrix_shape[1] - 1)
+                self.affine = slic.affine.copy()
+                self.affine[1, -1] -= img_shift
+                self.affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(self.affine)
  
-        act_data = nb.squeeze_image(nb.load(filename))
-        act_data = nb.as_closest_canonical(act_data)
-        act_data.update_header()
-        act_data_arr = act_data.get_fdata()
-
-        if not self.affine_vtk:
-            slic = sl.Slice()
-            prj_data = prj.Project()
-            matrix_shape = tuple(prj_data.matrix_shape)
-            self.affine = slic.affine.copy()
-            self.affine[1, -1] -= matrix_shape[1]
-            self.affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(self.affine)
-
-        self.checkACT.Enable(1)
-        self.checkACT.SetValue(True)
-
-        Publisher.sendMessage('Update ACT data', data=act_data_arr)
-        Publisher.sendMessage('Enable ACT', data=True)
-        # Publisher.sendMessage('Create grid', data=act_data_arr, affine=self.affine)
-        # Publisher.sendMessage('Update number of threads', data=n_threads)
-        # Publisher.sendMessage('Update tracts visualization', data=1)
-        Publisher.sendMessage('Update status text in GUI', label=_("Trekker ACT loaded"))
-
-        Publisher.sendMessage('End busy cursor')
+            try:
+                Publisher.sendMessage('Update status text in GUI', label=_("Busy"))
+                if filename:
+                    act_data = nb.squeeze_image(nb.load(filename))
+                    act_data = nb.as_closest_canonical(act_data)
+                    act_data.update_header()
+                    act_data_arr = act_data.get_fdata()
+
+                    self.checkACT.Enable(1)
+                    self.checkACT.SetValue(True)
+
+                    # ACT rules should be as follows:
+                    self.trekker.pathway_stop_at_entry(filename.encode('utf-8'), -1)  # outside
+                    self.trekker.pathway_discard_if_ends_inside(filename.encode('utf-8'), 1)  # wm
+                    self.trekker.pathway_discard_if_enters(filename.encode('utf-8'), 0)  # csf
+
+                    Publisher.sendMessage('Update ACT data', data=act_data_arr)
+                    Publisher.sendMessage('Enable ACT', data=True)
+                    Publisher.sendMessage('Update status text in GUI', label=_("Trekker ACT loaded"))
+            except:
+                Publisher.sendMessage('Update status text in GUI', label=_("ACT initialization failed."))
+                wx.MessageBox(_("Unable to load ACT."), _("InVesalius 3"))
+
+            Publisher.sendMessage('End busy cursor')
+        else:
+            wx.MessageBox(_("Load FOD image before the ACT."), _("InVesalius 3"))
  
     def OnLoadParameters(self, event=None):
         import json
@@ -2131,10 +2163,13 @@ class TractographyPanel(wx.Panel):
             # print("Running during navigation")
             coord_flip = list(position[:3])
             coord_flip[1] = -coord_flip[1]
-            dti.compute_tracts(self.trekker, coord_flip, self.affine, self.affine_vtk,
-                               self.n_tracts)
+            dti.compute_and_visualize_tracts(self.trekker, coord_flip, self.affine, self.affine_vtk,
+                                             self.n_tracts)
  
     def OnCloseProject(self):
+        self.trekker = None
+        self.trekker_cfg = const.TREKKER_CONFIG
+
         self.checktracts.SetValue(False)
         self.checktracts.Enable(0)
         self.checkpeeling.SetValue(False)
@@ -27,7 +27,6 @@ import numpy as np
 import invesalius.constants as const
 import invesalius.project as prj
 import invesalius.data.bases as db
-import invesalius.data.coordinates as dco
 import invesalius.data.coregistration as dcr
 import invesalius.data.serial_port_connection as spc
 import invesalius.data.slice_ as sl
@@ -98,12 +97,11 @@ class UpdateNavigationScene(threading.Thread):
  
                 # use of CallAfter is mandatory otherwise crashes the wx interface
                 if self.view_tracts:
-                    bundle, affine_vtk, coord_offset = self.tracts_queue.get_nowait()
+                    bundle, affine_vtk, coord_offset, coord_offset_w = self.tracts_queue.get_nowait()
                     #TODO: Check if possible to combine the Remove tracts with Update tracts in a single command
                     wx.CallAfter(Publisher.sendMessage, 'Remove tracts')
-                    wx.CallAfter(Publisher.sendMessage, 'Update tracts', root=bundle,
-                                 affine_vtk=affine_vtk, coord_offset=coord_offset)
-                    # wx.CallAfter(Publisher.sendMessage, 'Update marker offset', coord_offset=coord_offset)
+                    wx.CallAfter(Publisher.sendMessage, 'Update tracts', root=bundle, affine_vtk=affine_vtk,
+                                 coord_offset=coord_offset, coord_offset_w=coord_offset_w)
                     self.tracts_queue.task_done()
  
                 if self.serial_port_enabled:
@@ -118,10 +116,11 @@ class UpdateNavigationScene(threading.Thread):
                 wx.CallAfter(Publisher.sendMessage, 'Set cross focal point', position=coord)
                 wx.CallAfter(Publisher.sendMessage, 'Update raw coordinates', coordinates_raw=coordinates_raw, markers_flag=markers_flag)
                 wx.CallAfter(Publisher.sendMessage, 'Update slice viewer')
+                wx.CallAfter(Publisher.sendMessage, 'Sensor ID', markers_flag=markers_flag)
  
                 if view_obj:
                     wx.CallAfter(Publisher.sendMessage, 'Update object matrix', m_img=m_img, coord=coord)
-                    wx.CallAfter(Publisher.sendMessage, 'Update object arrow matrix',m_img=m_img, coord=coord, flag= self.peel_loaded)
+                    wx.CallAfter(Publisher.sendMessage, 'Update object arrow matrix', m_img=m_img, coord=coord, flag= self.peel_loaded)
                 self.coord_queue.task_done()
                 # print('UpdateScene: done {}'.format(count))
                 # count += 1
@@ -191,7 +190,7 @@ class Navigation():
  
     def UpdateSleep(self, sleep):
         self.sleep_nav = sleep
-        self.serial_port_connection.sleep_nav = sleep
+        # self.serial_port_connection.sleep_nav = sleep
  
     def UpdateSerialPort(self, serial_port_in_use, com_port=None, baud_rate=None):
         self.serial_port_in_use = serial_port_in_use
@@ -307,15 +306,22 @@ class Navigation():
  
             if self.view_tracts:
                 # initialize Trekker parameters
+                # TODO: This affine and affine_vtk are created 4 times. To improve, create a new affine object inside
+                #  Slice() that contains the transformation with the img_shift. Rename it to avoid confusion to the
+                #  affine, for instance it can be: affine_world_to_invesalius_vtk
                 slic = sl.Slice()
                 prj_data = prj.Project()
                 matrix_shape = tuple(prj_data.matrix_shape)
+                spacing = tuple(prj_data.spacing)
+                img_shift = spacing[1] * (matrix_shape[1] - 1)
                 affine = slic.affine.copy()
-                affine[1, -1] -= matrix_shape[1]
+                affine[1, -1] -= img_shift
                 affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(affine)
+
                 Publisher.sendMessage("Update marker offset state", create=True)
+
                 self.trk_inp = self.trekker, affine, self.seed_offset, self.n_tracts, self.seed_radius,\
-                                self.n_threads, self.act_data, affine_vtk, matrix_shape[1]
+                                self.n_threads, self.act_data, affine_vtk, img_shift
                 # print("Appending the tract computation thread!")
                 queues = [self.coord_tracts_queue, self.tracts_queue]
                 if self.enable_act:
...	...	@@ -2,7 +2,7 @@ channels:
2	2	- conda-forge
3	3	- bioconda
4	4	dependencies:
5		- - python=3.7
	5	+ - python=3.8
6	6	- cython==0.29.24
7	7	- pillow==8.3.2
8	8	- pypubsub==4.0.3
...	...	@@ -17,13 +17,21 @@ dependencies:
17	17	- scipy==1.7.1
18	18	- vtk==9.0.3
19	19	- wxpython==4.1.1
	20	+ - mido==1.2.10
	21	+ - nest-asyncio==1.5.1
20	22	- pip
21	23	- pip:
22		- - python-gdcm==3.0.9.1
	24	+ - aioconsole==0.3.2
	25	+ - opencv-python==4.5.3.56
23	26	- plaidml-keras==0.7.0
24		- - theano==1.0.5
25		- - pyacvd==0.2.3
	27	+ - python-gdcm==3.0.9.1
	28	+ - python-rtmidi==1.4.9
	29	+ - python-socketio[client]==5.3.0
	30	+ - pyacvd==0.2.7
26	31	- pyclaron
27	32	- polhemusFT
28	33	- polhemus
29	34	- pypolaris
	35	+ - theano==1.0.5
	36	+ - uvicorn[standard]==0.15.0
	37	+ - https://github.com/baranaydogan/trekker/raw/master/binaries/Trekker-0.9-cp38-cp38-win_amd64.whl
...	...
...	...	@@ -671,7 +671,7 @@ Z_COLUMN = 6
671	671
672	672	MARKER_COLOUR = (1.0, 1.0, 0.)
673	673	MARKER_SIZE = 2
674		-
	674	+ARROW_MARKER_SIZE = 10
675	675	CALIBRATION_TRACKER_SAMPLES = 10
676	676	FIDUCIAL_REGISTRATION_ERROR_THRESHOLD = 3.0
677	677
...	...	@@ -823,23 +823,35 @@ COIL_ANGLE_ARROW_PROJECTION_THRESHOLD = 5
823	823	CAM_MODE = True
824	824
825	825	# Tractography visualization
826		-N_TRACTS = 100
827		-PEEL_DEPTH = 5
828		-MAX_PEEL_DEPTH = 30
829		-SEED_OFFSET = 15
	826	+N_TRACTS = 200
	827	+PEEL_DEPTH = 10
	828	+MAX_PEEL_DEPTH = 40
	829	+SEED_OFFSET = 30
830	830	SEED_RADIUS = 1.5
831	831
832	832	# Increased the default sleep parameter from 0.1 to 0.15 to decrease CPU load during navigation.
833		-SLEEP_NAVIGATION = 0.15
	833	+SLEEP_NAVIGATION = 0.2
834	834	SLEEP_COORDINATES = 0.05
835	835	SLEEP_ROBOT = 0.01
836	836
837		-BRAIN_OPACITY = 0.5
	837	+BRAIN_OPACITY = 0.6
838	838	N_CPU = psutil.cpu_count()
839		-TREKKER_CONFIG = {'seed_max': 1, 'step_size': 0.1, 'min_fod': 0.1, 'probe_quality': 3,
840		- 'max_interval': 1, 'min_radius_curv': 0.8, 'probe_length': 0.4,
841		- 'write_interval': 50, 'numb_threads': '', 'max_lenth': 200,
842		- 'min_lenth': 20, 'max_sampling_step': 100}
	839	+# the max_sampling_step can be set to something different as well. Above 100 is probably not necessary
	840	+TREKKER_CONFIG = {'seed_max': 1,
	841	+ 'step_size': 0.03125,
	842	+ 'min_fod': 0.05,
	843	+ 'probe_quality': 3,
	844	+ 'max_interval': 1,
	845	+ 'min_radius_curvature': 0.625,
	846	+ 'probe_length': 0.15625,
	847	+ 'write_interval': 50,
	848	+ 'numb_threads': '',
	849	+ 'max_length': 250,
	850	+ 'min_length': 10,
	851	+ 'max_sampling_step': 100,
	852	+ 'data_support_exponent': 0.5,
	853	+ 'use_best_init': True,
	854	+ 'init_max_est_trials': 100}
843	855
844	856	MARKER_FILE_MAGICK_STRING = "##INVESALIUS3_MARKER_FILE_"
845	857	CURRENT_MARKER_FILE_VERSION = 0
...	...
...	...	@@ -69,7 +69,7 @@ class Controller():
69	69	#DICOM = 1
70	70	#TIFF uCT = 2
71	71	self.img_type = 0
72		- self.affine = None
	72	+ self.affine = np.identity(4)
73	73
74	74	#Init session
75	75	session = ses.Session()
...	...	@@ -340,7 +340,7 @@ class Controller():
340	340	if proj.affine:
341	341	self.Slice.affine = np.asarray(proj.affine).reshape(4, 4)
342	342	else:
343		- self.Slice.affine = None
	343	+ self.Slice.affine = np.identity(4)
344	344
345	345	Publisher.sendMessage('Update threshold limits list',
346	346	threshold_range=proj.threshold_range)
...	...	@@ -623,6 +623,8 @@ class Controller():
623	623	Publisher.sendMessage(('Set scroll position', 'SAGITAL'),index=proj.matrix_shape[1]/2)
624	624	Publisher.sendMessage(('Set scroll position', 'CORONAL'),index=proj.matrix_shape[2]/2)
625	625
	626	+ # TODO: Check that this is needed with the new way of using affine
	627	+ # now the affine should be at least the identity(4) and never None
626	628	if self.Slice.affine is not None:
627	629	Publisher.sendMessage('Enable Go-to-Coord', status=True)
628	630	else:
...	...	@@ -731,6 +733,8 @@ class Controller():
731	733	proj.level = self.Slice.window_level
732	734	proj.threshold_range = int(matrix.min()), int(matrix.max())
733	735	proj.spacing = self.Slice.spacing
	736	+ # TODO: Check that this is needed with the new way of using affine
	737	+ # now the affine should be at least the identity(4) and never None
734	738	if self.Slice.affine is not None:
735	739	proj.affine = self.Slice.affine.tolist()
736	740
...	...
...	...	@@ -371,7 +371,7 @@ def DebugCoordRandom(trk_init, trck_id, ref_mode):
371	371	#
372	372	# else:
373	373
374		- dx = [-70, 70]
	374	+ dx = [-30, 30]
375	375	dt = [-180, 180]
376	376
377	377	coord1 = np.array([uniform(dx), uniform(dx), uniform(*dx),
...	...
...	...	@@ -427,7 +427,7 @@ class CoordinateCorregistrateNoObject(threading.Thread):
427	427	# # seed_aux = pos_world.reshape([1, 4])[0, :3]
428	428	# # seed = seed_aux[np.newaxis, :]
429	429	# #
430		-# # self.tracts = dtr.compute_tracts(tracker, seed, affine_vtk, True)
	430	+# # self.tracts = dtr.compute_and_visualize_tracts(tracker, seed, affine_vtk, True)
431	431	#
432	432	# # wx.CallAfter(Publisher.sendMessage, 'Co-registered points', arg=m_img, position=coord)
433	433	# wx.CallAfter(Publisher.sendMessage, 'Update cross position', arg=m_img, position=coord)
...	...	@@ -654,7 +654,7 @@ class CoordinateCorregistrateNoObject(threading.Thread):
654	654	# # seed_aux = pos_world.reshape([1, 4])[0, :3]
655	655	# # seed = seed_aux[np.newaxis, :]
656	656	#
657		-# # self.tracts = dtr.compute_tracts(tracker, seed, affine_vtk, True)
	657	+# # self.tracts = dtr.compute_and_visualize_tracts(tracker, seed, affine_vtk, True)
658	658	#
659	659	# # wx.CallAfter(Publisher.sendMessage, 'Co-registered points', arg=m_img, position=coord)
660	660	# wx.CallAfter(Publisher.sendMessage, 'Update cross position', arg=m_img, position=coord)
...	...
...	...	@@ -486,7 +486,7 @@ class CrossInteractorStyle(DefaultInteractorStyle):
486	486	x, y, z = self.viewer.get_coordinate_cursor(mouse_x, mouse_y, self.picker)
487	487	self.viewer.UpdateSlicesPosition([x, y, z])
488	488	# This "Set cross" message is needed to update the cross in the other slices
489		- Publisher.sendMessage('Set cross focal point', position=[x, y, z, 0., 0., 0.])
	489	+ Publisher.sendMessage('Set cross focal point', position=[x, y, z, None, None, None])
490	490	Publisher.sendMessage('Update slice viewer')
491	491
492	492	def OnScrollBar(self, args, *kwargs):
...	...	@@ -494,7 +494,7 @@ class CrossInteractorStyle(DefaultInteractorStyle):
494	494	# the actual orientation.
495	495	x, y, z = self.viewer.cross.GetFocalPoint()
496	496	self.viewer.UpdateSlicesPosition([x, y, z])
497		- Publisher.sendMessage('Set cross focal point', position=[x, y, z, 0., 0., 0.])
	497	+ Publisher.sendMessage('Set cross focal point', position=[x, y, z, None, None, None])
498	498	Publisher.sendMessage('Update slice viewer')
499	499
500	500
...	...	@@ -544,7 +544,7 @@ class TractsInteractorStyle(CrossInteractorStyle):
544	544
545	545	def OnTractsMouseClick(self, obj, evt):
546	546	# print("Single mouse click")
547		- # self.tracts = dtr.compute_tracts(self.tracker, self.seed, self.left_pressed)
	547	+ # self.tracts = dtr.compute_and_visualize_tracts(self.tracker, self.seed, self.left_pressed)
548	548	self.ChangeTracts(True)
549	549
550	550	def OnTractsReleaseLeftButton(self, obj, evt):
...	...	@@ -554,7 +554,7 @@ class TractsInteractorStyle(CrossInteractorStyle):
554	554
555	555	def ChangeTracts(self, pressed):
556	556	# print("Trying to compute tracts")
557		- self.tracts = dtr.compute_tracts(self.tracker, self.seed, self.affine_vtk, pressed)
	557	+ self.tracts = dtr.compute_and_visualize_tracts(self.tracker, self.seed, self.affine_vtk, pressed)
558	558	# mouse_x, mouse_y = iren.GetEventPosition()
559	559	# wx, wy, wz = self.viewer.get_coordinate_cursor(mouse_x, mouse_y, self.picker)
560	560	# px, py = self.viewer.get_slice_pixel_coord_by_world_pos(wx, wy, wz)
...	...
...	...	@@ -365,9 +365,16 @@ class SurfaceManager():
365	365	if self.convert2inv:
366	366	# convert between invesalius and world space with shift in the Y coordinate
367	367	affine = sl.Slice().affine
	368	+ # TODO: Check that this is needed with the new way of using affine
	369	+ # now the affine should be at least the identity(4) and never None
368	370	if affine is not None:
369		- affine[1, -1] -= sl.Slice().spacing[1] * (sl.Slice().matrix.shape[1] - 1)
	371	+ matrix_shape = sl.Slice().matrix.shape
	372	+ spacing = sl.Slice().spacing
	373	+ img_shift = spacing[1] * (matrix_shape[1] - 1)
	374	+ affine = sl.Slice().affine.copy()
	375	+ affine[1, -1] -= img_shift
370	376	affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(affine)
	377	+
371	378	actor.SetUserMatrix(affine_vtk)
372	379
373	380	if overwrite:
...	...
...	...	@@ -70,8 +70,8 @@ class Viewer(wx.Panel):
70	70
71	71	self.initial_focus = None
72	72
73		- self.staticballs = []
74		-
	73	+ self.static_markers = []
	74	+ self.static_arrows = []
75	75	self.style = None
76	76
77	77	interactor = wxVTKRenderWindowInteractor(self, -1, size = self.GetSize())
...	...	@@ -278,6 +278,7 @@ class Viewer(wx.Panel):
278	278
279	279	# Related to marker creation in navigation tools
280	280	Publisher.subscribe(self.AddMarker, 'Add marker')
	281	+ Publisher.subscribe(self.AddMarkerwithOrientation, 'Add arrow marker')
281	282	Publisher.subscribe(self.HideAllMarkers, 'Hide all markers')
282	283	Publisher.subscribe(self.ShowAllMarkers, 'Show all markers')
283	284	Publisher.subscribe(self.RemoveAllMarkers, 'Remove all markers')
...	...	@@ -306,7 +307,6 @@ class Viewer(wx.Panel):
306	307	Publisher.subscribe(self.OnRemoveTracts, 'Remove tracts')
307	308	Publisher.subscribe(self.UpdateSeedOffset, 'Update seed offset')
308	309	Publisher.subscribe(self.UpdateMarkerOffsetState, 'Update marker offset state')
309		- Publisher.subscribe(self.UpdateMarkerOffsetPosition, 'Update marker offset')
310	310	Publisher.subscribe(self.AddPeeledSurface, 'Update peel')
311	311	Publisher.subscribe(self.GetPeelCenters, 'Get peel centers and normals')
312	312	Publisher.subscribe(self.Initlocator_viewer, 'Get init locator')
...	...	@@ -579,7 +579,7 @@ class Viewer(wx.Panel):
579	579	"""
580	580	Set all markers, overwriting the previous markers.
581	581	"""
582		- self.RemoveAllMarkers(len(self.staticballs))
	582	+ self.RemoveAllMarkers(len(self.static_markers))
583	583
584	584	target_selected = False
585	585	for marker in markers:
...	...	@@ -607,6 +607,21 @@ class Viewer(wx.Panel):
607	607
608	608	self.UpdateRender()
609	609
	610	+ def AddMarkerwithOrientation(self, arrow_id, size, color, coord):
	611	+ """
	612	+ Markers arrow with orientation created by navigation tools and rendered in volume viewer.
	613	+ """
	614	+ self.arrow_marker_id = arrow_id
	615	+ coord_flip = list(coord)
	616	+ coord_flip[1] = -coord_flip[1]
	617	+
	618	+ arrow_actor = self.Add_ObjectArrow(coord_flip[:3], coord_flip[3:6], color, size)
	619	+ self.static_markers.append(arrow_actor)
	620	+ self.ren.AddActor(self.static_markers[self.arrow_marker_id])
	621	+ self.arrow_marker_id += 1
	622	+
	623	+ self.Refresh()
	624	+
610	625	def AddMarker(self, ball_id, size, colour, coord):
611	626	"""
612	627	Markers created by navigation tools and rendered in volume viewer.
...	...	@@ -626,12 +641,12 @@ class Viewer(wx.Panel):
626	641	prop.SetColor(colour)
627	642
628	643	# adding a new actor for the present ball
629		- self.staticballs.append(vtk.vtkActor())
	644	+ self.static_markers.append(vtk.vtkActor())
630	645
631		- self.staticballs[self.ball_id].SetMapper(mapper)
632		- self.staticballs[self.ball_id].SetProperty(prop)
	646	+ self.static_markers[self.ball_id].SetMapper(mapper)
	647	+ self.static_markers[self.ball_id].SetProperty(prop)
633	648
634		- self.ren.AddActor(self.staticballs[self.ball_id])
	649	+ self.ren.AddActor(self.static_markers[self.ball_id])
635	650	self.ball_id += 1
636	651
637	652	#self.UpdateRender()
...	...	@@ -667,33 +682,33 @@ class Viewer(wx.Panel):
667	682	def HideAllMarkers(self, indexes):
668	683	ballid = indexes
669	684	for i in range(0, ballid):
670		- self.staticballs[i].SetVisibility(0)
	685	+ self.static_markers[i].SetVisibility(0)
671	686	self.UpdateRender()
672	687
673	688	def ShowAllMarkers(self, indexes):
674	689	ballid = indexes
675	690	for i in range(0, ballid):
676		- self.staticballs[i].SetVisibility(1)
	691	+ self.static_markers[i].SetVisibility(1)
677	692	self.UpdateRender()
678	693
679	694	def RemoveAllMarkers(self, indexes):
680	695	ballid = indexes
681	696	for i in range(0, ballid):
682		- self.ren.RemoveActor(self.staticballs[i])
683		- self.staticballs = []
	697	+ self.ren.RemoveActor(self.static_markers[i])
	698	+ self.static_markers = []
684	699	self.UpdateRender()
685	700
686	701	def RemoveMultipleMarkers(self, index):
687	702	for i in reversed(index):
688		- self.ren.RemoveActor(self.staticballs[i])
689		- del self.staticballs[i]
	703	+ self.ren.RemoveActor(self.static_markers[i])
	704	+ del self.static_markers[i]
690	705	self.ball_id = self.ball_id - 1
691	706	self.UpdateRender()
692	707
693	708	def BlinkMarker(self, index):
694	709	if self.timer:
695	710	self.timer.Stop()
696		- self.staticballs[self.index].SetVisibility(1)
	711	+ self.static_markers[self.index].SetVisibility(1)
697	712	self.index = index
698	713	self.timer = wx.Timer(self)
699	714	self.Bind(wx.EVT_TIMER, self.OnBlinkMarker, self.timer)
...	...	@@ -701,7 +716,7 @@ class Viewer(wx.Panel):
701	716	self.timer_count = 0
702	717
703	718	def OnBlinkMarker(self, evt):
704		- self.staticballs[self.index].SetVisibility(int(self.timer_count % 2))
	719	+ self.static_markers[self.index].SetVisibility(int(self.timer_count % 2))
705	720	self.Refresh()
706	721	self.timer_count += 1
707	722
...	...	@@ -709,20 +724,20 @@ class Viewer(wx.Panel):
709	724	if self.timer:
710	725	self.timer.Stop()
711	726	if index is None:
712		- self.staticballs[self.index].SetVisibility(1)
	727	+ self.static_markers[self.index].SetVisibility(1)
713	728	self.Refresh()
714	729	self.index = False
715	730
716	731	def SetNewColor(self, index, color):
717		- self.staticballs[index].GetProperty().SetColor([round(s/255.0, 3) for s in color])
	732	+ self.static_markers[index].GetProperty().SetColor([round(s / 255.0, 3) for s in color])
718	733	self.Refresh()
719	734
720	735	def OnTargetMarkerTransparency(self, status, index):
721	736	if status:
722		- self.staticballs[index].GetProperty().SetOpacity(1)
	737	+ self.static_markers[index].GetProperty().SetOpacity(1)
723	738	# self.staticballs[index].GetProperty().SetOpacity(0.4)
724	739	else:
725		- self.staticballs[index].GetProperty().SetOpacity(1)
	740	+ self.static_markers[index].GetProperty().SetOpacity(1)
726	741
727	742	def OnUpdateAngleThreshold(self, angle):
728	743	self.anglethreshold = angle
...	...	@@ -841,8 +856,10 @@ class Viewer(wx.Panel):
841	856	else:
842	857	self.DisableCoilTracker()
843	858	if self.actor_peel:
844		- self.object_orientation_torus_actor.SetVisibility(1)
845		- self.obj_projection_arrow_actor.SetVisibility(1)
	859	+ if self.object_orientation_torus_actor:
	860	+ self.object_orientation_torus_actor.SetVisibility(1)
	861	+ if self.obj_projection_arrow_actor:
	862	+ self.obj_projection_arrow_actor.SetVisibility(1)
846	863
847	864	def OnUpdateObjectTargetGuide(self, m_img, coord):
848	865
...	...	@@ -992,16 +1009,10 @@ class Viewer(wx.Panel):
992	1009	self.RemoveTarget()
993	1010	self.DisableCoilTracker()
994	1011
995		- def CreateTargetAim(self):
996		- if self.aim_actor:
997		- self.RemoveTargetAim()
998		- self.aim_actor = None
999		-
1000		- vtk_colors = vtk.vtkNamedColors()
1001		-
	1012	+ def CreateVTKObjectMatrix(self, direction, orientation):
1002	1013	m_img = dco.coordinates_to_transformation_matrix(
1003		- position=self.target_coord[:3],
1004		- orientation=self.target_coord[3:],
	1014	+ position=direction,
	1015	+ orientation=orientation,
1005	1016	axes='sxyz',
1006	1017	)
1007	1018	m_img = np.asmatrix(m_img)
...	...	@@ -1012,7 +1023,16 @@ class Viewer(wx.Panel):
1012	1023	for col in range(0, 4):
1013	1024	m_img_vtk.SetElement(row, col, m_img[row, col])
1014	1025
1015		- self.m_img_vtk = m_img_vtk
	1026	+ return m_img_vtk
	1027	+
	1028	+ def CreateTargetAim(self):
	1029	+ if self.aim_actor:
	1030	+ self.RemoveTargetAim()
	1031	+ self.aim_actor = None
	1032	+
	1033	+ vtk_colors = vtk.vtkNamedColors()
	1034	+
	1035	+ self.m_img_vtk = self.CreateVTKObjectMatrix(self.target_coord[:3], self.target_coord[3:])
1016	1036
1017	1037	filename = os.path.join(inv_paths.OBJ_DIR, "aim.stl")
1018	1038
...	...	@@ -1023,7 +1043,7 @@ class Viewer(wx.Panel):
1023	1043
1024	1044	# Transform the polydata
1025	1045	transform = vtk.vtkTransform()
1026		- transform.SetMatrix(m_img_vtk)
	1046	+ transform.SetMatrix(self.m_img_vtk)
1027	1047	transformPD = vtk.vtkTransformPolyDataFilter()
1028	1048	transformPD.SetTransform(transform)
1029	1049	transformPD.SetInputConnection(reader.GetOutputPort())
...	...	@@ -1071,7 +1091,7 @@ class Viewer(wx.Panel):
1071	1091	self.dummy_coil_actor.GetProperty().SetSpecularPower(10)
1072	1092	self.dummy_coil_actor.GetProperty().SetOpacity(.3)
1073	1093	self.dummy_coil_actor.SetVisibility(1)
1074		- self.dummy_coil_actor.SetUserMatrix(m_img_vtk)
	1094	+ self.dummy_coil_actor.SetUserMatrix(self.m_img_vtk)
1075	1095
1076	1096	self.ren.AddActor(self.dummy_coil_actor)
1077	1097
...	...	@@ -1424,8 +1444,9 @@ class Viewer(wx.Panel):
1424	1444	actor.GetProperty().SetLineWidth(5)
1425	1445	actor.AddPosition(0, 0, 0)
1426	1446	actor.SetScale(size)
1427		- actor.SetPosition(direction)
1428		- actor.SetOrientation(orientation)
	1447	+
	1448	+ m_img_vtk = self.CreateVTKObjectMatrix(direction, orientation)
	1449	+ actor.SetUserMatrix(m_img_vtk)
1429	1450
1430	1451	return actor
1431	1452
...	...	@@ -1587,10 +1608,6 @@ class Viewer(wx.Panel):
1587	1608	self.ren.AddActor(self.mark_actor)
1588	1609	self.Refresh()
1589	1610
1590		- def UpdateMarkerOffsetPosition(self, coord_offset):
1591		- self.mark_actor.SetPosition(coord_offset)
1592		- self.Refresh()
1593		-
1594	1611	def UpdateObjectOrientation(self, m_img, coord):
1595	1612	# print("Update object orientation")
1596	1613
...	...	@@ -1667,7 +1684,7 @@ class Viewer(wx.Panel):
1667	1684	# self.ball_actor.SetVisibility(1)
1668	1685	self.Refresh()
1669	1686
1670		- def OnUpdateTracts(self, root=None, affine_vtk=None, coord_offset=None):
	1687	+ def OnUpdateTracts(self, root=None, affine_vtk=None, coord_offset=None, coord_offset_w=None):
1671	1688	mapper = vtk.vtkCompositePolyDataMapper2()
1672	1689	mapper.SetInputDataObject(root)
1673	1690
...	...
...	...	@@ -4203,7 +4203,7 @@ class GoToDialogScannerCoord(wx.Dialog):
4203	4203	main_sizer.Fit(self)
4204	4204
4205	4205	self.orientation = None
4206		- self.affine = None
	4206	+ self.affine = np.identity(4)
4207	4207
4208	4208	self.__bind_events()
4209	4209
...	...
...	...	@@ -165,7 +165,7 @@ class InnerFoldPanel(wx.Panel):
165	165	# Study this.
166	166
167	167	fold_panel = fpb.FoldPanelBar(self, -1, wx.DefaultPosition,
168		- (10, 310), 0, fpb.FPB_SINGLE_FOLD)
	168	+ (10, 330), 0, fpb.FPB_SINGLE_FOLD)
169	169
170	170	# Initialize Tracker and PedalConnection objects here so that they are available to several panels.
171	171	#
...	...	@@ -359,7 +359,7 @@ class NeuronavigationPanel(wx.Panel):
359	359
360	360	self.nav_status = False
361	361	self.tracker_fiducial_being_set = None
362		- self.current_coord = 0, 0, 0
	362	+ self.current_coord = 0, 0, 0, None, None, None
363	363
364	364	# Initialize list of buttons and numctrls for wx objects
365	365	self.btns_set_fiducial = [None, None, None, None, None, None]
...	...	@@ -704,7 +704,7 @@ class NeuronavigationPanel(wx.Panel):
704	704	if self.btns_set_fiducial[n].GetValue():
705	705	coord = self.numctrls_fiducial[n][0].GetValue(),\
706	706	self.numctrls_fiducial[n][1].GetValue(),\
707		- self.numctrls_fiducial[n][2].GetValue(), 0, 0, 0
	707	+ self.numctrls_fiducial[n][2].GetValue(), None, None, None
708	708
709	709	Publisher.sendMessage('Set image fiducial', fiducial_name=fiducial_name, coord=coord[0:3])
710	710
...	...	@@ -1078,17 +1078,15 @@ class ObjectRegistrationPanel(wx.Panel):
1078	1078
1079	1079	try:
1080	1080	if filename:
1081		- #TODO: Improve method to read the file, using "with" similar to OnLoadParameters
1082		- data = np.loadtxt(filename, delimiter='\t')
1083		- self.obj_fiducials = data[:, :3]
1084		- self.obj_orients = data[:, 3:]
	1081	+ with open(filename, 'r') as text_file:
	1082	+ data = [s.split('\t') for s in text_file.readlines()]
1085	1083
1086		- text_file = open(filename, "r")
1087		- header = text_file.readline().split('\t')
1088		- text_file.close()
	1084	+ registration_coordinates = np.array(data[1:]).astype(np.float32)
	1085	+ self.obj_fiducials = registration_coordinates[:, :3]
	1086	+ self.obj_orients = registration_coordinates[:, 3:]
1089	1087
1090		- self.obj_name = header[1]
1091		- self.obj_ref_mode = int(header[-1])
	1088	+ self.obj_name = data[0][1]
	1089	+ self.obj_ref_mode = int(data[0][-1])
1092	1090
1093	1091	self.checktrack.Enable(1)
1094	1092	self.checktrack.SetValue(True)
...	...	@@ -1098,7 +1096,7 @@ class ObjectRegistrationPanel(wx.Panel):
1098	1096	label=_("Object file successfully loaded"))
1099	1097	Publisher.sendMessage('Update track object state', flag=True, obj_name=self.obj_name)
1100	1098	Publisher.sendMessage('Change camera checkbox', status=False)
1101		- # wx.MessageBox(_("Object file successfully loaded"), _("Load"))
	1099	+ wx.MessageBox(_("Object file successfully loaded"), _("InVesalius 3"))
1102	1100	except:
1103	1101	wx.MessageBox(_("Object registration file incompatible."), _("InVesalius 3"))
1104	1102	Publisher.sendMessage('Update status text in GUI', label="")
...	...	@@ -1144,9 +1142,9 @@ class MarkersPanel(wx.Panel):
1144	1142	x : float = 0
1145	1143	y : float = 0
1146	1144	z : float = 0
1147		- alpha : float = 0
1148		- beta : float = 0
1149		- gamma : float = 0
	1145	+ alpha : float = dataclasses.field(default = None)
	1146	+ beta : float = dataclasses.field(default = None)
	1147	+ gamma : float = dataclasses.field(default = None)
1150	1148	r : float = 0
1151	1149	g : float = 1
1152	1150	b : float = 0
...	...	@@ -1161,7 +1159,7 @@ class MarkersPanel(wx.Panel):
1161	1159	# x, y, z, alpha, beta, gamma can be jointly accessed as coord
1162	1160	@property
1163	1161	def coord(self):
1164		- return list((self.x, self.y, self.z, self.alpha, self.beta, self.gamma),)
	1162	+ return list((self.x, self.y, self.z, self.alpha, self.beta, self.gamma))
1165	1163
1166	1164	@coord.setter
1167	1165	def coord(self, new_coord):
...	...	@@ -1201,11 +1199,18 @@ class MarkersPanel(wx.Panel):
1201	1199	else:
1202	1200	res += ('%s\t' % str(getattr(self, field.name)))
1203	1201
1204		- # Add world coordinates (in addition to the internal ones).
1205		- position_world, orientation_world = imagedata_utils.convert_invesalius_to_world(
1206		- position=[self.x, self.y, self.z],
1207		- orientation=[self.alpha, self.beta, self.gamma],
1208		- )
	1202	+ if self.alpha is not None and self.beta is not None and self.gamma is not None:
	1203	+ # Add world coordinates (in addition to the internal ones).
	1204	+ position_world, orientation_world = imagedata_utils.convert_invesalius_to_world(
	1205	+ position=[self.x, self.y, self.z],
	1206	+ orientation=[self.alpha, self.beta, self.gamma],
	1207	+ )
	1208	+
	1209	+ else:
	1210	+ position_world, orientation_world = imagedata_utils.convert_invesalius_to_world(
	1211	+ position=[self.x, self.y, self.z],
	1212	+ orientation=[0,0,0],
	1213	+ )
1209	1214
1210	1215	res += '\t'.join(map(lambda x: 'N/A' if x is None else str(x), (position_world, orientation_world)))
1211	1216	return res
...	...	@@ -1215,8 +1220,10 @@ class MarkersPanel(wx.Panel):
1215	1220	properly formatted, might throw an exception and leave the object
1216	1221	in an inconsistent state."""
1217	1222	for field, str_val in zip(dataclasses.fields(self.__class__), inp_str.split('\t')):
1218		- if field.type is float:
	1223	+ if field.type is float and str_val != 'None':
1219	1224	setattr(self, field.name, float(str_val))
	1225	+ if field.type is float and str_val == 'None':
	1226	+ setattr(self, field.name, None)
1220	1227	if field.type is int:
1221	1228	setattr(self, field.name, int(str_val))
1222	1229	if field.type is str:
...	...	@@ -1253,8 +1260,7 @@ class MarkersPanel(wx.Panel):
1253	1260
1254	1261	self.session = ses.Session()
1255	1262
1256		- self.current_coord = 0, 0, 0, 0, 0, 0
1257		- self.current_angle = 0, 0, 0
	1263	+ self.current_coord = 0, 0, 0, None, None, None
1258	1264	self.current_seed = 0, 0, 0
1259	1265	self.current_robot_target_matrix = [None] * 9
1260	1266	self.markers = []
...	...	@@ -1264,6 +1270,7 @@ class MarkersPanel(wx.Panel):
1264	1270
1265	1271	self.marker_colour = const.MARKER_COLOUR
1266	1272	self.marker_size = const.MARKER_SIZE
	1273	+ self.arrow_marker_size = const.ARROW_MARKER_SIZE
1267	1274	self.current_session = 1
1268	1275
1269	1276	# Change marker size
...	...	@@ -1431,19 +1438,17 @@ class MarkersPanel(wx.Panel):
1431	1438	return list(itertools.chain(*(const.BTNS_IMG_MARKERS[i].values() for i in const.BTNS_IMG_MARKERS)))
1432	1439
1433	1440	def UpdateCurrentCoord(self, position):
1434		- self.current_coord = position
1435		- #self.current_angle = pubsub_evt.data[1][3:]
	1441	+ self.current_coord = list(position)
1436	1442
1437	1443	def UpdateNavigationStatus(self, nav_status, vis_status):
1438	1444	if not nav_status:
1439		- sleep(0.5)
1440		- #self.current_coord[3:] = 0, 0, 0
	1445	+ self.current_coord[3:] = None, None, None
1441	1446	self.nav_status = False
1442	1447	else:
1443	1448	self.nav_status = True
1444	1449
1445		- def UpdateSeedCoordinates(self, root=None, affine_vtk=None, coord_offset=(0, 0, 0)):
1446		- self.current_seed = coord_offset
	1450	+ def UpdateSeedCoordinates(self, root=None, affine_vtk=None, coord_offset=(0, 0, 0), coord_offset_w=(0, 0, 0)):
	1451	+ self.current_seed = coord_offset_w
1447	1452
1448	1453	def UpdateRobotCoordinates(self, coordinates_raw, markers_flag):
1449	1454	self.raw_target_robot = coordinates_raw[1], coordinates_raw[2]
...	...	@@ -1615,8 +1620,8 @@ class MarkersPanel(wx.Panel):
1615	1620	if marker.is_target:
1616	1621	self.__set_marker_as_target(len(self.markers) - 1)
1617	1622
1618		- except:
1619		- wx.MessageBox(_("Invalid markers file."), _("InVesalius 3"))
	1623	+ except Exception as e:
	1624	+ wx.MessageBox(_("Invalid markers file."), _("InVesalius 3"))
1620	1625
1621	1626	def OnMarkersVisibility(self, evt, ctrl):
1622	1627	if ctrl.GetValue():
...	...	@@ -1681,10 +1686,18 @@ class MarkersPanel(wx.Panel):
1681	1686	new_robot_marker.robot_target_matrix = self.current_robot_target_matrix
1682	1687
1683	1688	# Note that ball_id is zero-based, so we assign it len(self.markers) before the new marker is added
1684		- Publisher.sendMessage('Add marker', ball_id=len(self.markers),
1685		- size=new_marker.size,
1686		- colour=new_marker.colour,
1687		- coord=new_marker.coord[:3])
	1689	+ if all([elem is not None for elem in new_marker.coord[3:]]):
	1690	+ Publisher.sendMessage('Add arrow marker', arrow_id=len(self.markers),
	1691	+ size=self.arrow_marker_size,
	1692	+ color=new_marker.colour,
	1693	+ coord=new_marker.coord)
	1694	+ else:
	1695	+ Publisher.sendMessage('Add marker', ball_id=len(self.markers),
	1696	+ size=new_marker.size,
	1697	+ colour=new_marker.colour,
	1698	+ coord=new_marker.coord[:3])
	1699	+
	1700	+
1688	1701	self.markers.append(new_marker)
1689	1702	self.robot_markers.append(new_robot_marker)
1690	1703
...	...	@@ -1720,7 +1733,7 @@ class TractographyPanel(wx.Panel):
1720	1733	default_colour = wx.SystemSettings_GetColour(wx.SYS_COLOUR_MENUBAR)
1721	1734	self.SetBackgroundColour(default_colour)
1722	1735
1723		- self.affine = None
	1736	+ self.affine = np.identity(4)
1724	1737	self.affine_vtk = None
1725	1738	self.trekker = None
1726	1739	self.n_tracts = const.N_TRACTS
...	...	@@ -1977,7 +1990,6 @@ class TractographyPanel(wx.Panel):
1977	1990	self.nav_status = nav_status
1978	1991
1979	1992	def OnLinkBrain(self, event=None):
1980		- Publisher.sendMessage('Update status text in GUI', label=_("Busy"))
1981	1993	Publisher.sendMessage('Begin busy cursor')
1982	1994	mask_path = dlg.ShowImportOtherFilesDialog(const.ID_NIFTI_IMPORT, _("Import brain mask"))
1983	1995	img_path = dlg.ShowImportOtherFilesDialog(const.ID_NIFTI_IMPORT, _("Import T1 anatomical image"))
...	...	@@ -1991,31 +2003,37 @@ class TractographyPanel(wx.Panel):
1991	2003	slic = sl.Slice()
1992	2004	prj_data = prj.Project()
1993	2005	matrix_shape = tuple(prj_data.matrix_shape)
	2006	+ spacing = tuple(prj_data.spacing)
	2007	+ img_shift = spacing[1] * (matrix_shape[1] - 1)
1994	2008	self.affine = slic.affine.copy()
1995		- self.affine[1, -1] -= matrix_shape[1]
	2009	+ self.affine[1, -1] -= img_shift
1996	2010	self.affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(self.affine)
1997	2011
1998		- try:
1999		- self.brain_peel = brain.Brain(img_path, mask_path, self.n_peels, self.affine_vtk)
2000		- self.brain_actor = self.brain_peel.get_actor(self.peel_depth, self.affine_vtk)
2001		- self.brain_actor.GetProperty().SetOpacity(self.brain_opacity)
2002		- Publisher.sendMessage('Update peel', flag=True, actor=self.brain_actor)
2003		- Publisher.sendMessage('Get peel centers and normals', centers=self.brain_peel.peel_centers,
2004		- normals=self.brain_peel.peel_normals)
2005		- Publisher.sendMessage('Get init locator', locator=self.brain_peel.locator)
2006		- self.checkpeeling.Enable(1)
2007		- self.checkpeeling.SetValue(True)
2008		- self.spin_opacity.Enable(1)
2009		- Publisher.sendMessage('Update status text in GUI', label=_("Brain model loaded"))
2010		- self.peel_loaded = True
2011		- Publisher.sendMessage('Update peel visualization', data= self.peel_loaded)
2012		- except:
2013		- wx.MessageBox(_("Unable to load brain mask."), _("InVesalius 3"))
	2012	+ if mask_path and img_path:
	2013	+ Publisher.sendMessage('Update status text in GUI', label=_("Busy"))
	2014	+ try:
	2015	+ self.brain_peel = brain.Brain(img_path, mask_path, self.n_peels, self.affine_vtk)
	2016	+ self.brain_actor = self.brain_peel.get_actor(self.peel_depth, self.affine_vtk)
	2017	+ self.brain_actor.GetProperty().SetOpacity(self.brain_opacity)
	2018	+
	2019	+ self.checkpeeling.Enable(1)
	2020	+ self.checkpeeling.SetValue(True)
	2021	+ self.spin_opacity.Enable(1)
	2022	+ self.peel_loaded = True
	2023	+
	2024	+ Publisher.sendMessage('Update peel', flag=True, actor=self.brain_actor)
	2025	+ Publisher.sendMessage('Get peel centers and normals', centers=self.brain_peel.peel_centers,
	2026	+ normals=self.brain_peel.peel_normals)
	2027	+ Publisher.sendMessage('Get init locator', locator=self.brain_peel.locator)
	2028	+ Publisher.sendMessage('Update status text in GUI', label=_("Brain model loaded"))
	2029	+ Publisher.sendMessage('Update peel visualization', data= self.peel_loaded)
	2030	+ except:
	2031	+ Publisher.sendMessage('Update status text in GUI', label=_("Brain mask initialization failed."))
	2032	+ wx.MessageBox(_("Unable to load brain mask."), _("InVesalius 3"))
2014	2033
2015	2034	Publisher.sendMessage('End busy cursor')
2016	2035
2017	2036	def OnLinkFOD(self, event=None):
2018		- Publisher.sendMessage('Update status text in GUI', label=_("Busy"))
2019	2037	Publisher.sendMessage('Begin busy cursor')
2020	2038	filename = dlg.ShowImportOtherFilesDialog(const.ID_NIFTI_IMPORT, msg=_("Import Trekker FOD"))
2021	2039	# Juuso
...	...	@@ -2026,69 +2044,83 @@ class TractographyPanel(wx.Panel):
2026	2044	# FOD_path = 'Baran_FOD.nii'
2027	2045	# filename = os.path.join(data_dir, FOD_path)
2028	2046
2029		- # if not self.affine_vtk:
2030		- # slic = sl.Slice()
2031		- # self.affine = slic.affine
2032		- # self.affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(self.affine)
2033		-
2034	2047	if not self.affine_vtk:
2035	2048	slic = sl.Slice()
2036	2049	prj_data = prj.Project()
2037	2050	matrix_shape = tuple(prj_data.matrix_shape)
	2051	+ spacing = tuple(prj_data.spacing)
	2052	+ img_shift = spacing[1] * (matrix_shape[1] - 1)
2038	2053	self.affine = slic.affine.copy()
2039		- self.affine[1, -1] -= matrix_shape[1]
	2054	+ self.affine[1, -1] -= img_shift
2040	2055	self.affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(self.affine)
2041	2056
2042		- # try:
2043		-
2044		- self.trekker = Trekker.initialize(filename.encode('utf-8'))
2045		- self.trekker, n_threads = dti.set_trekker_parameters(self.trekker, self.trekker_cfg)
2046		-
2047		- self.checktracts.Enable(1)
2048		- self.checktracts.SetValue(True)
2049		- self.view_tracts = True
2050		- Publisher.sendMessage('Update Trekker object', data=self.trekker)
2051		- Publisher.sendMessage('Update number of threads', data=n_threads)
2052		- Publisher.sendMessage('Update tracts visualization', data=1)
2053		- Publisher.sendMessage('Update status text in GUI', label=_("Trekker initialized"))
2054		- # except:
2055		- # wx.MessageBox(_("Unable to initialize Trekker, check FOD and config files."), _("InVesalius 3"))
	2057	+ if filename:
	2058	+ Publisher.sendMessage('Update status text in GUI', label=_("Busy"))
	2059	+ try:
	2060	+ self.trekker = Trekker.initialize(filename.encode('utf-8'))
	2061	+ self.trekker, n_threads = dti.set_trekker_parameters(self.trekker, self.trekker_cfg)
	2062	+
	2063	+ self.checktracts.Enable(1)
	2064	+ self.checktracts.SetValue(True)
	2065	+ self.view_tracts = True
	2066	+
	2067	+ Publisher.sendMessage('Update Trekker object', data=self.trekker)
	2068	+ Publisher.sendMessage('Update number of threads', data=n_threads)
	2069	+ Publisher.sendMessage('Update tracts visualization', data=1)
	2070	+ Publisher.sendMessage('Update status text in GUI', label=_("Trekker initialized"))
	2071	+ # except:
	2072	+ # wx.MessageBox(_("Unable to initialize Trekker, check FOD and config files."), _("InVesalius 3"))
	2073	+ except:
	2074	+ Publisher.sendMessage('Update status text in GUI', label=_("Trekker initialization failed."))
	2075	+ wx.MessageBox(_("Unable to load FOD."), _("InVesalius 3"))
2056	2076
2057	2077	Publisher.sendMessage('End busy cursor')
2058	2078
2059	2079	def OnLoadACT(self, event=None):
2060		- Publisher.sendMessage('Update status text in GUI', label=_("Busy"))
2061		- Publisher.sendMessage('Begin busy cursor')
2062		- filename = dlg.ShowImportOtherFilesDialog(const.ID_NIFTI_IMPORT, msg=_("Import anatomical labels"))
2063		- # Baran
2064		- # data_dir = os.environ.get('OneDrive') + r'\data\dti_navigation\baran\anat_reg_improve_20200609'
2065		- # act_path = 'Baran_trekkerACTlabels_inFODspace.nii'
2066		- # filename = os.path.join(data_dir, act_path)
	2080	+ if self.trekker:
	2081	+ Publisher.sendMessage('Begin busy cursor')
	2082	+ filename = dlg.ShowImportOtherFilesDialog(const.ID_NIFTI_IMPORT, msg=_("Import anatomical labels"))
	2083	+ # Baran
	2084	+ # data_dir = os.environ.get('OneDrive') + r'\data\dti_navigation\baran\anat_reg_improve_20200609'
	2085	+ # act_path = 'Baran_trekkerACTlabels_inFODspace.nii'
	2086	+ # filename = os.path.join(data_dir, act_path)
	2087	+
	2088	+ if not self.affine_vtk:
	2089	+ slic = sl.Slice()
	2090	+ prj_data = prj.Project()
	2091	+ matrix_shape = tuple(prj_data.matrix_shape)
	2092	+ spacing = tuple(prj_data.spacing)
	2093	+ img_shift = spacing[1] * (matrix_shape[1] - 1)
	2094	+ self.affine = slic.affine.copy()
	2095	+ self.affine[1, -1] -= img_shift
	2096	+ self.affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(self.affine)
2067	2097
2068		- act_data = nb.squeeze_image(nb.load(filename))
2069		- act_data = nb.as_closest_canonical(act_data)
2070		- act_data.update_header()
2071		- act_data_arr = act_data.get_fdata()
2072		-
2073		- if not self.affine_vtk:
2074		- slic = sl.Slice()
2075		- prj_data = prj.Project()
2076		- matrix_shape = tuple(prj_data.matrix_shape)
2077		- self.affine = slic.affine.copy()
2078		- self.affine[1, -1] -= matrix_shape[1]
2079		- self.affine_vtk = vtk_utils.numpy_to_vtkMatrix4x4(self.affine)
2080		-
2081		- self.checkACT.Enable(1)
2082		- self.checkACT.SetValue(True)
2083		-
2084		- Publisher.sendMessage('Update ACT data', data=act_data_arr)
2085		- Publisher.sendMessage('Enable ACT', data=True)
2086		- # Publisher.sendMessage('Create grid', data=act_data_arr, affine=self.affine)
2087		- # Publisher.sendMessage('Update number of threads', data=n_threads)
2088		- # Publisher.sendMessage('Update tracts visualization', data=1)
2089		- Publisher.sendMessage('Update status text in GUI', label=_("Trekker ACT loaded"))
2090		-
2091		- Publisher.sendMessage('End busy cursor')
	2098	+ try:
	2099	+ Publisher.sendMessage('Update status text in GUI', label=_("Busy"))
	2100	+ if filename:
	2101	+ act_data = nb.squeeze_image(nb.load(filename))
	2102	+ act_data = nb.as_closest_canonical(act_data)
	2103	+ act_data.update_header()
	2104	+ act_data_arr = act_data.get_fdata()
	2105	+
	2106	+ self.checkACT.Enable(1)
	2107	+ self.checkACT.SetValue(True)
	2108	+
	2109	+ # ACT rules should be as follows:
	2110	+ self.trekker.pathway_stop_at_entry(filename.encode('utf-8'), -1) # outside
	2111	+ self.trekker.pathway_discard_if_ends_inside(filename.encode('utf-8'), 1) # wm
	2112	+ self.trekker.pathway_discard_if_enters(filename.encode('utf-8'), 0) # csf
	2113	+
	2114	+ Publisher.sendMessage('Update ACT data', data=act_data_arr)
	2115	+ Publisher.sendMessage('Enable ACT', data=True)
	2116	+ Publisher.sendMessage('Update status text in GUI', label=_("Trekker ACT loaded"))
	2117	+ except:
	2118	+ Publisher.sendMessage('Update status text in GUI', label=_("ACT initialization failed."))
	2119	+ wx.MessageBox(_("Unable to load ACT."), _("InVesalius 3"))
	2120	+
	2121	+ Publisher.sendMessage('End busy cursor')
	2122	+ else:
	2123	+ wx.MessageBox(_("Load FOD image before the ACT."), _("InVesalius 3"))
2092	2124
2093	2125	def OnLoadParameters(self, event=None):
2094	2126	import json
...	...	@@ -2131,10 +2163,13 @@ class TractographyPanel(wx.Panel):
2131	2163	# print("Running during navigation")
2132	2164	coord_flip = list(position[:3])
2133	2165	coord_flip[1] = -coord_flip[1]
2134		- dti.compute_tracts(self.trekker, coord_flip, self.affine, self.affine_vtk,
2135		- self.n_tracts)
	2166	+ dti.compute_and_visualize_tracts(self.trekker, coord_flip, self.affine, self.affine_vtk,
	2167	+ self.n_tracts)
2136	2168
2137	2169	def OnCloseProject(self):
	2170	+ self.trekker = None
	2171	+ self.trekker_cfg = const.TREKKER_CONFIG
	2172	+
2138	2173	self.checktracts.SetValue(False)
2139	2174	self.checktracts.Enable(0)
2140	2175	self.checkpeeling.SetValue(False)
...	...