Neuronavigation: TMS Motor Mapping Visualization

invesalius/constants.py

@@ -795,9 +795,10 @@
 TARGET_COLUMN = 4
 Z_OFFSET_COLUMN = 5
 POINT_OF_INTEREST_TARGET_COLUMN = 6
-X_COLUMN = 7
-Y_COLUMN = 8
-Z_COLUMN = 9
+MEP_COLUMN = 7
+X_COLUMN = 8
+Y_COLUMN = 9
+Z_COLUMN = 10
 
 # ------------ Navigation defaults -------------------
 
@@ -1002,6 +1003,85 @@
 SUPPORTED_MARKER_FILE_VERSIONS = [0, 1, 2, 3]
 WILDCARD_MARKER_FILES = _("Marker scanner coord files (*.mkss)|*.mkss")
 
+# Motor mapping visualization
+
+DEFAULT_MEP_CONFIG_PARAMS = {
+    "mep_enabled": False,
+    "enabled_once": False,
+    "threshold_down": 0,
+    "range_up": 1,
+    "brain_surface_index": None,
+    "mep_colormap": "Viridis",
+    "gaussian_sharpness": 0.4,
+    "gaussian_radius": 20,
+    "bounds": None,
+    "colormap_range_uv": {"min": 50, "low": 200, "mid": 600, "max": 1000},
+}
+
+
+MEP_COLORMAP_DEFINITIONS = {
+    "BlueCyanYellowRed": {  # Blue, Cyan, Yellow, Red
+        "min": (0.0, 0.0, 1.0),
+        "low": (0.0, 1.0, 1.0),
+        "mid": (1.0, 1.0, 0.0),
+        "max": (1.0, 0.0, 0.0),
+    },
+    "GreenYellowOrangeRed": {  # Green, Yellow, Orange, Red
+        "min": (0.0, 1.0, 0.0),
+        "low": (1.0, 1.0, 0.0),
+        "mid": (1.0, 0.647, 0.0),
+        "max": (1.0, 0.0, 0.0),
+    },
+    "PurpleBlueGreenYellow": {  # Purple, Blue, Green, Yellow
+        "min": (0.5, 0.0, 0.5),
+        "low": (0.0, 0.0, 1.0),
+        "mid": (0.0, 1.0, 0.0),
+        "max": (1.0, 1.0, 0.0),
+    },
+    "BlackGrayWhiteRed": {  # Black, Gray, White, Red (grayscale with highlight)
+        "min": (0.0, 0.0, 0.0),
+        "low": (0.5, 0.5, 0.5),
+        "mid": (1.0, 1.0, 1.0),
+        "max": (1.0, 0.0, 0.0),
+    },
+    "Viridis": {  # Viridis (perceptually uniform)
+        "min": (0.267004, 0.004874, 0.329415),
+        "low": (0.226337, 0.31071, 0.577055),
+        "mid": (0.993248, 0.906157, 0.143936),
+        "max": (0.968627, 0.813008, 0.0),
+    },
+    "Grayscale": {  # Grayscale (often used for CT/MRI)
+        "min": (0.0, 0.0, 0.0),  # Black
+        "low": (0.25, 0.25, 0.25),  # Dark Gray
+        "mid": (0.75, 0.75, 0.75),  # Light Gray
+        "max": (1.0, 1.0, 1.0),  # White
+    },
+    "HotMetal": {  # Hot Metal (useful for highlighting hot spots)
+        "min": (0.0, 0.0, 0.0),  # Black
+        "low": (0.5, 0.0, 0.0),  # Dark Red
+        "mid": (1.0, 0.5, 0.0),  # Orange
+        "max": (1.0, 1.0, 1.0),  # White
+    },
+    "Rainbow": {  # Rainbow (although not perceptually uniform, still common)
+        "min": (0.0, 0.0, 1.0),  # Blue
+        "low": (0.0, 1.0, 0.0),  # Green
+        "mid": (1.0, 1.0, 0.0),  # Yellow
+        "max": (1.0, 0.0, 0.0),  # Red
+    },
+    "Bone": {  # Bone (specifically designed for CT bone visualization)
+        "min": (0.0, 0.0, 0.0),  # Black
+        "low": (0.388, 0.224, 0.0),  # Brown
+        "mid": (0.902, 0.827, 0.631),  # Beige
+        "max": (1.0, 1.0, 1.0),  # White
+    },
+    "InvertedGrayscale": {  # Inverted Grayscale (sometimes used for PET)
+        "min": (1.0, 1.0, 1.0),  # White
+        "low": (0.75, 0.75, 0.75),  # Light Gray
+        "mid": (0.25, 0.25, 0.25),  # Dark Gray
+        "max": (0.0, 0.0, 0.0),  # Black
+    },
+}
+
 # Keycodes for moving markers using the keyboard
 MOVE_MARKER_LEFT_KEYCODE = 65  # A
 MOVE_MARKER_RIGHT_KEYCODE = 68  # D

invesalius/data/markers/marker.py

@@ -75,6 +75,9 @@ class Marker:
     z_offset: float = 0.0
     visualization: dict = dataclasses.field(default_factory=dict)
     marker_uuid: str = ""
+    # #TODO: add a reference to original coil marker to relate it to MEP
+    # in micro Volts (but scale in milli Volts for display)
+    mep_value: float = dataclasses.field(default=None)
 
     # x, y, z can be jointly accessed as position
     @property
@@ -217,6 +220,7 @@ def to_dict(self):
             "cortex_position_orientation": self.cortex_position_orientation,
             "z_rotation": self.z_rotation,
             "z_offset": self.z_offset,
+            "mep_value": self.mep_value,
         }
 
     def from_dict(self, d):
@@ -272,6 +276,7 @@ def from_dict(self, d):
         z_offset = d.get("z_offset", 0.0)
         z_rotation = d.get("z_rotation", 0.0)
         is_point_of_interest = d.get("is_point_of_interest", False)
+        mep_value = d.get("mep_value", None)
 
         self.size = d["size"]
         self.label = d["label"]
@@ -287,6 +292,7 @@ def from_dict(self, d):
         self.cortex_position_orientation = cortex_position_orientation
         self.z_offset = z_offset
         self.z_rotation = z_rotation
+        self.mep_value = mep_value
 
         return self
 

invesalius/data/surface.py

@@ -220,10 +220,12 @@ def __bind_events(self):
         Publisher.subscribe(self.OnLoadSurfaceDict, "Load surface dict")
         Publisher.subscribe(self.OnCloseProject, "Close project data")
         Publisher.subscribe(self.OnSelectSurface, "Change surface selected")
+        Publisher.subscribe(self.OnShowOnlySurface, "Show only surface")
         # ----
         Publisher.subscribe(self.OnSplitSurface, "Split surface")
         Publisher.subscribe(self.OnLargestSurface, "Create surface from largest region")
         Publisher.subscribe(self.OnSeedSurface, "Create surface from seeds")
+        Publisher.subscribe(self.GetVisibleSurfaceActor, "Get visible surface actor")
 
         Publisher.subscribe(self.OnDuplicate, "Duplicate surfaces")
         Publisher.subscribe(self.OnRemove, "Remove surfaces")
@@ -704,6 +706,9 @@ def OnSelectSurface(self, surface_index):
         #  if surface.is_shown:
         self.ShowActor(surface_index, True)
 
+    def OnShowOnlySurface(self, surface_index):
+        Publisher.sendMessage("Show single surface", index=surface_index, visibility=True)
+
     def OnLoadSurfaceDict(self, surface_dict):
         for key in surface_dict:
             surface = surface_dict[key]
@@ -1136,6 +1141,20 @@ def OnChangeSurfaceName(self, index, name):
     def OnShowSurface(self, index, visibility):
         self.ShowActor(index, visibility)
 
+    def GetVisibleSurfaceActor(self):
+        """
+        Gets the first visible surface actor.
+        """
+        index = 0
+        for key in self.actors_dict:
+            if self.actors_dict[key].GetVisibility():
+                index = key
+                break
+
+        Publisher.sendMessage(
+            "Load visible surface actor", actor=self.actors_dict[index], index=index
+        )
+
     def ShowActor(self, index, value):
         """
         Show or hide actor, according to given actor index and value.

invesalius/data/viewer_volume.py

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 import math
-
 # --------------------------------------------------------------------------
 # Software:     InVesalius - Software de Reconstrucao 3D de Imagens Medicas
 # Copyright:    (C) 2001  Centro de Pesquisas Renato Archer
@@ -33,7 +32,6 @@
 from vtkmodules.vtkCommonColor import vtkColorSeries, vtkNamedColors
 
 # TODO: Check that these imports are not used -- vtkLookupTable, vtkMinimalStandardRandomSequence, vtkPoints, vtkUnsignedCharArray
-from vtkmodules.vtkCommonComputationalGeometry import vtkParametricTorus
 from vtkmodules.vtkCommonCore import (
     mutable,
     vtkDoubleArray,
@@ -55,9 +53,6 @@
 from vtkmodules.vtkFiltersModeling import vtkBandedPolyDataContourFilter
 from vtkmodules.vtkFiltersSources import (
     vtkArrowSource,
-    vtkDiskSource,
-    vtkLineSource,
-    vtkParametricFunctionSource,
     vtkSphereSource,
 )
 from vtkmodules.vtkInteractionStyle import vtkInteractorStyleTrackballCamera
@@ -81,7 +76,7 @@
     vtkPostScriptWriter,
     vtkTIFFWriter,
 )
-from vtkmodules.vtkRenderingAnnotation import vtkAnnotatedCubeActor, vtkAxesActor, vtkScalarBarActor
+from vtkmodules.vtkRenderingAnnotation import vtkAnnotatedCubeActor, vtkAxesActor
 from vtkmodules.vtkRenderingCore import (
     vtkActor,
     vtkPointPicker,
@@ -112,6 +107,7 @@
 from invesalius.data.ruler_volume import GenericLeftRulerVolume
 from invesalius.data.visualization.coil_visualizer import CoilVisualizer
 from invesalius.data.visualization.marker_visualizer import MarkerVisualizer
+from invesalius.data.visualization.mep_visualizer import MEPVisualizer
 from invesalius.data.visualization.vector_field_visualizer import VectorFieldVisualizer
 from invesalius.gui.widgets.canvas_renderer import CanvasRendererCTX
 from invesalius.i18n import tr as _
@@ -326,6 +322,8 @@ def __init__(self, parent):
             vector_field_visualizer=self.vector_field_visualizer,
         )
 
+        self.mep_visualizer = MEPVisualizer()
+
         self.seed_offset = const.SEED_OFFSET
         self.radius_list = vtkIdList()
         self.colors_init = vtkUnsignedCharArray()
@@ -1055,7 +1053,7 @@ def OnUpdateCoilPose(self, m_img, coord):
                 coord[0:3], (self.target_coord[0], -self.target_coord[1], self.target_coord[2])
             )
 
-            formatted_distance = "Distance: {: >5.1f} mm".format(distance_to_target)
+            formatted_distance = f"Distance: {distance_to_target: >5.1f} mm"
 
             if self.distance_text is not None:
                 self.distance_text.SetValue(formatted_distance)
@@ -1235,7 +1233,7 @@ def OnSetTarget(self, marker):
 
         self.coil_visualizer.AddTargetCoil(self.m_target)
 
-        print("Target updated to coordinates {}".format(coord))
+        print(f"Target updated to coordinates {coord}")
 
     def CreateVTKObjectMatrix(self, direction, orientation):
         m_img = dco.coordinates_to_transformation_matrix(
@@ -1707,15 +1705,12 @@ def mTMS_multiplyFactor(self, factor):
 
     def find_and_extract_data(self, csv_filename, target_numbers):
         import csv
-
         matching_rows = []
-
         with open(csv_filename, "r") as csvfile:
             csv_reader = csv.reader(csvfile)
             for row in csv_reader:
                 # Extract the first three numbers from the current row
                 first_three_numbers = list(map(float, row[:3]))
-
                 # Check if the first three numbers match the target numbers
                 if first_three_numbers == target_numbers:
                     # If there's a match, append the row (excluding the first three numbers)
@@ -1985,7 +1980,6 @@ def SetEfieldTargetAtCortex(self, position, orientation):
     def ShowEfieldAtCortexTarget(self):
         if self.target_at_cortex is not None:
             import vtk
-
             index = self.efield_mesh.FindPoint(self.target_at_cortex)
             if index in self.Id_list:
                 cell_number = self.Id_list.index(index)
@@ -2143,7 +2137,7 @@ def UpdateEfieldPointLocation(self, m_img, coord, queue_IDs):
             self.e_field_IDs_queue = queue_IDs
             if self.radius_list.GetNumberOfIds() != 0:
                 if np.all(self.old_coord != coord):
-                    self.e_field_IDs_queue.put_nowait((self.radius_list))
+                    self.e_field_IDs_queue.put_nowait(self.radius_list)
                 self.old_coord = np.array([coord])
         except queue.Full:
             pass
@@ -2167,7 +2161,8 @@ def GetCoilPosition(self, position, orientation):
         cp = cp * 0.001  # convert to meters
         cp = cp.tolist()
 
-        ct1 = m_img_flip[:3, 1]  # is from posterior to anterior direction of the coil
+        # is from posterior to anterior direction of the coil
+        ct1 = m_img_flip[:3, 1]
         ct2 = m_img_flip[:3, 0]  # is from left to right direction of the coil
         coil_dir = m_img_flip[:-1, 0]
         coil_face = m_img_flip[:-1, 1]
@@ -2330,9 +2325,7 @@ def SaveEfieldData(self, filename, plot_efield_vectors, marker_id):
 
     def SavedAllEfieldData(self, filename):
         import csv
-
         import invesalius.data.imagedata_utils as imagedata_utils
-
         header = [
             "Marker ID",
             "Enorm cell indexes",