Real-Time Optimal Synthetic Inversion Recovery Image Selection (RT-OSIRIS) for Deep Brain Stimulation Targeting

Abstract

Deep brain stimulation (DBS) is a method of electrical neuromodulation used to treat a variety of neuropsychiatric conditions including essential tremor, Parkinson’s disease, epilepsy, and obsessive–compulsive disorder. The procedure requires precise placement of electrodes such that the electrical contacts lie within or in close proximity to specific target nuclei and tracts located deep within the brain. DBS electrode trajectory planning has become increasingly dependent on direct targeting with the need for precise visualization of targets. MRI is the primary tool for direct visualization, and this has led to the development of numerous sequences to aid in visualization of different targets. Synthetic inversion recovery images, specified by an inversion time parameter, can be generated from T₁ relaxation maps, and this represents a promising method for modifying the contrast of deep brain structures to accentuate target areas using a single acquisition. However, there is currently no accessible method for dynamically adjusting the inversion time parameter and observing the effects in real-time in order to choose the optimal value. In this work, we examine three different approaches to implementing an application for real-time optimal synthetic inversion recovery image selection and evaluate them based on their ability to display continually-updated synthetic inversion recovery images as the user modifies the inversion time parameter. These methods include continuously computing the inversion recovery equation at each voxel in the image volume, limiting the computation only to the voxels of the orthogonal slices currently displayed on screen, or using a series of lookup tables with precomputed solutions to the inversion recovery equation. We find the latter implementation provides for the quickest display updates both when modifying the inversion time and when scrolling through the image. We introduce a publicly available cross-platform application built around this conclusion. We also briefly discuss other details of the implementations and considerations for extensions to other use cases.

Background

Deep brain stimulation (DBS) has been shown to be an effective treatment for neuropsychiatric conditions including essential tremor, Parkinson’s disease, primary dystonia, epilepsy, and obsessive–compulsive disorder [1, 2]. The procedure involves inserting electrodes into specific brain regions and connecting them to an implantable pulse generator (Fig. 1). The generator delivers stimulation pulses through the electrodes according to parameters that can be adjusted to maximize symptom control while minimizing side effects. The therapeutic effects are achieved through direct neuromodulation as well as several other postulated mechanisms [2].

Fig. 1.

Deep brain stimulation. System overview (A) illustrates a pulse generator implanted in the upper chest connected to a DBS electrode via a lead wire. The detail view (B) shows the contacts (dark bands) near the electrode tip in the thalamus. The electrode must be inserted with a precise trajectory so the contacts lie within the desired deep brain structures. Imaging, including inversion recovery MRI, is critical in locating these targets

The success of DBS is critically dependent on the accurate placement of the electrodes via burr hole craniotomy into specific deep brain nuclei and tracts, some of which are smaller than five millimeters in size [3]. Historically, such structures were not readily resolvable by magnetic resonance imaging (MRI), and so stereotactic surgical techniques were utilized that relied on standard coordinate systems and offsets from observable imaging landmarks to guide electrode placement [4, 5]. However, such methods were limited in their ability to account for individual variations in anatomy and thus restricted the success and potential applications of DBS [6–8]. Eventually, the transition to higher magnetic field strengths and the introduction of specific MR sequences allowed several previously unresolvable deep nuclei to be discretely identified by imaging, leading to the modern era of neuronavigation and direct targeting [7, 9–11]. Many of these sequences produce image contrast based on tissue T₁ properties via inversion recovery, an MR technique that selectively suppresses the signal from tissues with operator-specified T₁relaxation [12–15].

Despite these advances, the discrimination of many potential DBS targets remains elusive, and the present state of the art combines ultra-high field (7 Tesla) MR imaging with T₁relaxation time mapping to produce high resolution images optimized for target visualization [10, 13, 16]. Conventional inversion-recovery techniques require predefined T₁ inversion times to be selected at the time of image acquisition; however, physiologic variation between patients and B₁transmit field inhomogeneities seen with 7 Tesla MRI, and to a lesser degree with 3 Tesla, can result in suboptimal target visualization if fixed inversion times are used [13, 17]. Scanning across a range of inversion times could address this problem, but would inordinately extend the length of the MR session. Instead, the T₁ mapping approach enables the computation of synthetic inversion recovery images retrospectively at arbitrary inversion times, allowing optimization for DBS target visualization without prolonging scan time (Fig. 2). This is an instance of a broader class of methods for “synthetic MRI” that produce conventional tissue contrast images from underlying tissue property maps [18].

Fig. 2.

Synthetic inversion recovery imaging, axial sections centered on the thalami. Dedicated MR sequences can produce maps of the T₁ relaxation time constant at each point in the brain (A). From these, it is possible to generate inversion recovery images for any arbitrary inversion time without further scan time. Three such synthetic inversion recovery images are shown with inversion times of 200 ms (B), 1150 ms (C), and 2850 ms (D). Varying the inversion time parameter changes the conspicuity of various substructures in the thalamus, facilitating DBS targeting

To incorporate this technique in an efficient clinical workflow, it is essential for neuroradiologists and neurosurgeons to be able to dynamically vary the inversion time parameter and rapidly evaluate the effects of these changes on the conspicuity of specific deep brain targets. To our knowledge, there exists no publicly accessible tool that allows dynamically varying the inversion time for large, high-resolution synthetic inversion recovery image generation in this manner. In this work, we describe the design parameters and implementation details of a new graphical software tool that loads a T₁ map and allows for interactive manipulation of the inversion time parameter while displaying the corresponding synthetic inversion recovery image in real-time. Alternate implementation strategies are also discussed, with their performance compared to the chosen approach. This tool for real-time optimal synthetic inversion recovery image selection (RT-OSIRIS) is made available as a public resource.

Methods

We present the formulation of RT-OSIRIS using the input-process-output (IPO) software design framework. For clarity of explanation, the process component is described last.

Input

There are several methods by which tissue T₁ relaxation time maps may be estimated. For subtle DBS target localization, 7 Tesla MRI offers several advantages, and we prefer to perform T₁mapping via an MP2RAGE sequence according to a method that has been previously described [16, 19]. However, ultra-high field MRI remains limited in clinical availability, and RT-OSIRIS was therefore designed to operate without any assumptions regarding the image acquisition techniques, field strength, or method of T₁ map creation. We require only a scalar-valued input Digital Imaging and Communications in Medicine (DICOM) volume storing the tissue T₁ relaxation time constant at each voxel position $x$, which we denote $T_1(x)$. The only other expected input is the inversion time parameter, $t_i$, which the user should be able to adjust dynamically through a graphical user interface control.

Output

The main output during program interaction is a multiplanar display of orthogonal sagittal, coronal, and axial slices of the calculated synthetic inversion recovery image for the user-selected $t_i$. The user should be able to scroll through the slices of the 3D volume continuously as well as jump to distant voxel coordinates. Any adjustment of the selected $t_i$ or displayed slice coordinates should update the display as quickly as possible, ideally with no perceptible delay (i.e., real-time), which for our purpose we interpret as enabling display buffer updates at a frequency of least 60 Hz. The user should also have the option to export the displayed synthetic inversion recovery images in DICOM format.

Process

The mathematical underpinnings of synthetic inversion recovery imaging are relatively straightforward. Given a T₁ map, the synthetic inversion recovery signal amplitude, $\mathit{sIR}$, for a selected $t_i$ is given by:

$$\begin{array}{c}sIR\left(x,,,t_i\right)\propto \left|1,-,2,e^{-t_i/T_1\left(x\right)}\right|\end{array}$$ 1

Equation (1) denotes a proportionality rather than an equality because the right-hand side neglects the contribution of spin density in acquired inversion recovery images. This is an appropriate simplification in the context of MRI for DBS planning, which is designed to delineate anatomic boundaries rather than resolve some diagnostic uncertainty. This approach has been previously shown to effectively substitute for the conventional acquisition of multiple individual inversion recovery sequences for DBS targeting purposes, with positive outcomes in early clinical translation [20].

We chose to implement our solution as an extension in 3DSlicer, a popular platform for computational analysis of medical images, with built-in functionality for DICOM handling and image display [21]. We compare three possible implementations, illustrated schematically in Fig. 3 and described further in the following paragraphs, with the aim to deploy the most computationally efficient choice for real-time synthetic inversion recovery image display in the final distributed application.

Fig. 3.

Implementations for synthetic inversion recovery imaging. The three tested implementations are shown as parallel branches in a workflow that produces a synthetic inversion recovery image (sIR) from an input T₁ map. The update-volume implementation (top) performs the inversion recovery calculation for the entire image volume before displaying the result. The update-slice method (middle) is similar, but performs the calculation only for the three orthogonal slices currently shown on screen. The update-LUT method (bottom) embeds pre-computed solutions to the inversion recovery calculation in a set of custom lookup tables and simply selects the one corresponding to the prescribed inversion time

In the update-volume approach, we take the most straightforward implementation. The T₁ map is loaded into memory. Each time the user updates the desired $t_i$, a synthetic inversion recovery image is computed in memory by recalculating Eq. (1) for every voxel in the image, and the display is then updated. Changing the displayed slice position does not require re-computation.

The update-slice approach is similar, but we restrict computation to only those voxels currently being displayed. For this method, modification of either $t_i$ or the displayed slice coordinates triggers recalculation of Eq. (1), but only for those voxels within the three orthogonal slices currently shown on-screen, rather than the entire volume. The display is updated once this computation is complete.

The update-LUT approach varies conceptually from the other two and leverages some simplifying observations. Recognizing that evaluating Eq. (1) is computationally expensive, we choose to cache its solutions and implement the display updates via a lookup table (LUT) at runtime. This approach entails creating a different LUT for each possible value of $t_i$ and switching to the appropriate one when the user updates the desired inversion time. In theory, both $T_1(x)$ and $t_i$ can take any nonnegative value, but in the context of deep brain structure imaging, useful image contrast is only achieved for inversion times between 100 and 4500 ms (these bounds are intentionally liberal to allow for variations based on magnetic field strength). Furthermore, altering $t_i$ by less than 10 ms produces negligible changes in image contrast. Based on these observations, when the T₁ map is loaded, we pre-compute a set of custom LUTs evaluating Eq. (1) for inversion times between 100 and 4500 ms, in 10 ms increments, for all unique values of T₁ present in the input map. At runtime, the appropriate LUT is activated when the user modifies the $t_i$, but no portion of Eq. (1) needs to be re-evaluated when the inversion time parameter or displayed slice coordinate are manipulated.

Evaluation

In order to compare the relative performance of each implementation, profiling of the image refresh interval was performed using the timeit module of the Python 3.9.10 interpreter included with version 3DSlicer version 5.2.2. The time needed to update the display buffer was recorded for 500 trials in which the $t_i$ was changed using a list of randomly generated values between 100 and 4500 ms in 10-ms increments, as well as for 500 trials in which the slice coordinate was changed randomly with inversion time held constant at 1000 ms. Our test data volume was a 384 × 296 × 296 voxel T₁ map (a typical volume size for 7 Tesla brain MRI). All tests were performed on a machine with an Intel 11th generation Core i7-1165G7 2.80 GHz processor with embedded Iris Xe graphics, 32 GB DDR4 system memory (128 MB dedicated vRAM), running a freshly-rebooted Linux operating system, kernel version 6.5.5. In each case, the fastest 20% of trials were retained as representative of the true theoretical execution speed, with arbitrary interaction with other system processes presumed to be limiting the remainder. Average display buffer refresh intervals were compared between the three implementations using two-tailed, independent samples t tests.

Results

While varying $t_i$, the measured display buffer refresh rates (mean ± standard deviation) were 3.72 ± 0.018 Hz for the update-volume method, 103 ± 1.50 Hz for the update-slice method, and 1360 ± 19.8 Hz for the update-LUT method. The update-slice method was significantly faster than the update-volume implementation, and the update-LUT method was significantly faster than both of the others (p < 10⁻⁶ in all cases). While randomly varying the displayed slice positions with $t_i$ held constant, the measured display buffer refresh rates were 4870 ± 213 Hz for the update-volume method, 103 ± 1.09 for the update-slice method, and 4600 ± 147 for the update-LUT method. Both the update-volume and update-LUT methods were significantly faster than the update-slice method (p < 10⁻⁶). These results are summarized graphically in Fig. 4.

Fig.4.

Synthetic inversion recovery implementation speed. The rate at which display buffer updates are completed (log scale) is shown for each of the three tested implementation methods. Testing was performed while varying the inversion time (left plot) and varying the displayed slice coordinate (right plot). Each point in the swarm plot represents an individual trial

We note that the performance of the update-volume method when adjusting the inversion time falls below the real-time threshold, and so we exclude it as a candidate for the final implementation. Both the update-slice and update-LUT methods provide for perceptually real-time performance when updating the inversion time or displayed slices, but the update-LUT method significantly outperforms the update-slice method in both scenarios. We therefore selected the update-LUT method for the final implementation.

The RT-OSIRIS application is a customized build of 3DSlicer that streamlines the interface for our extension, as shown in Fig. 5. It consists of graphical user interface controls to load the T₁ map, modify the $t_i$ parameter, and export the displayed synthetic inversion recovery image in DICOM format. These are shown adjacent to an orthogonal slice viewer that updates in real-time according to the slice-update implementation described. Versions of the tool for Windows, Linux, and macOS platforms are available via the NeuroImaging Tools and Resources Collaboratory at https://www.nitrc.org/projects/rt-osiris.

Fig. 5.

RT-OSIRIS user interface. Controls to select the T₁ map, adjust the inversion time, and export the result are shown in the left pane. The interactive 2D orthogonal slice viewers and 3D rendering are displayed on the right side of the application window

Discussion

We have evaluated the computational efficiency of three different implementations for generating a synthetic inversion recovery image with the goal of real-time visualization for DBS planning. Based on our findings, we implemented the update-LUT technique in RT-OSIRIS. The caching and subsequent lookup of the results of frequently repeated code executions is a well-established optimization method in computer science, sometimes referred to as “memoization,” and the use of lookup tables is common in computer graphics and other intensive applications [22–26]. Our use of the approach here demonstrates how an application designed to make use of this powerful technique can enable a specific clinical workflow. Our findings mirror those of others, who have recently shown the value of replacing computationally expensive operations in medical imaging with table lookups for processes like T₁ or T₂map generation, greatly accelerating their throughput [19, 27].

Several factors were not included in our evaluation criteria, but are important for context and may have relevance in similar endeavors. First, we did not consider the time to initial image display when first loading a T₁ map. This was not felt to be an important optimization target because this event occurs only once when switching patients, while inversion time and slice location adjustments may occur hundreds or thousands of times per case. In our implementation, the event to apply the currently selected inversion time is triggered when the T₁ volume is chosen, so we expect the time to the initial image display will closely mirror the performance when adjusting $t_i$. The update-LUT method also computes the required LUTs at this time, which in practice adds about 330 ms to the initial image display, while the update-volume and update-slice methods require approximately 270 ms and 9 ms, respectively. We note also that the LUT computation time could be significantly reduced by loading a pre-computed LUTs from disk rather than computing them at runtime, though again, this is not a particularly meaningful optimization for the presented use case.

In addition, memory requirements differ between the three implementations. All three methods require two data arrays to be held in memory: the T₁ map itself as well as the displayed inversion recovery image. For a typical 7 T brain MRI stored with 32-bit precision, the voxel array occupies approximately 128 MB, which is well within the RAM capacity of modern commodity hardware, even when doubled. In addition, the update-LUT method requires an array of small lookup tables to be stored in memory, increasing the memory usage by an additional 5–6 MB. Future increases in image resolution or applications beyond DBS targeting may be more memory intensive, and in those cases, it may be worthwhile to reconsider memory usage as an evaluation criterion.

Another consideration with future changes in image resolution is the rate of the growth on the computational demand between the various methods. For isotropic increases in the voxel array, the increase in the required number of evaluations of Eq. (1) is quadratic for the update-slice method and cubic for the update-volume method. Thus, increasing image size would increase the discrepancy between these two methods while lowering the theoretical display refresh rates of both. In our current implementation, the update-LUT method would also experience a cubic increase in computation (because the LUT is applied to the entire volume in memory when $t_i$ is modified). However, because the lookup operation is orders of magnitude less computationally expensive than the evaluation of Eq. (1), update-LUT should remain the most performant method aside from theoretical extreme increases in image resolution. The implementation could also be modified to apply the LUT only to the on-screen slices which would reduce its computational growth to quadratic in relation to image size, but given that its performance already far exceeds that needed for real-time visualization, such an optimization is currently premature. Indeed, we already found that, for the intended use case, both the update-slice and LUT methods provide for display buffer refresh rates that may exceed those of display hardware itself (typically 60 Hz in office environments, though specialized hardware targeted at video game players generally updates more quickly and may see broader adoption in the future).

Finally, another way in which the computational burden might increase is if the synthetic inversion recovery calculation described in Eq. (1) is modified. For example, it may be desired in some cases to produce a synthetic double inversion recovery image, which requires the computationally-expensive evaluation of the exponential function to be performed twice per voxel. The overall effect on the relative performance of the methods in this scenario would be similar to that described for increases in image resolution in the preceding paragraph. Again, depending on the magnitude of the effect, this could favor the less computationally intensive implementations.

Conclusion

We have described a method for real-time calculation and display of synthetic inversion recovery images for DBS target localization. This procedure has been implemented in a cross-platform, publicly available software tool.

Data Availability

An implementation of the update-LUT method described in this report is available through the NeuroImaging Tools and Resources Collaboratory at the following URL: https://www.nitrc.org/projects/rt-osiris/.

Declarations

Competing Interests

The authors declare no competing interests.