 Research Article
 Open Access
GPUaccelerated surgery simulation for opening a brain fissure
 Kazuya Sase^{1}Email author,
 Akira Fukuhara^{2},
 Teppei Tsujita^{3} and
 Atsushi Konno^{1}
 Received: 23 May 2015
 Accepted: 13 December 2015
 Published: 29 December 2015
Abstract
In neurosurgery, dissection and retraction are basic techniques for approaching the site of pathology. These techniques are carefully performed in order to avoid damage to nerve tissues or blood vessels. However, novice surgeons cannot train in such techniques using the haptic cues of existing training systems. This paper proposes a realtime simulation scheme for training in dissection and retraction when opening a brain fissure, which is a procedure for creating a working space before treating an affected area. In this procedure, spatulas are commonly used to perform blunt dissection and brain tissue retraction. In this study, the interaction between spatulas and soft tissues is modeled on the basis of a finite element method (FEM). The deformation of soft tissue is calculated according to a corotational FEM by considering geometrical nonlinearity and element inversion. A fracture is represented by removing tetrahedrons using a novel mesh modification algorithm in order to retain the manifold property of a tetrahedral mesh. Moreover, most parts of the FEM are implemented on a graphics processing unit (GPU). This paper focuses on parallel algorithms for matrix assembly and matrix rearrangement related to FEM procedures by considering a sparsematrix storage format. Finally, two simulations are conducted. A blunt dissection simulation is conducted in real time (less than 20 ms for a time step) using a softtissue model having 4807 nodes and 19,600 elements. A brain retraction simulation is conducted using a brain hemisphere model having 8647 nodes and 32,639 elements with force feedback (less than 80 ms for a time step). These results show that the proposed method is effective in simulating dissection and retraction for opening a brain fissure.
Keywords
 Surgery simulation
 Finite element method
 GPGPU
Background
Virtual reality (VR) surgery simulation is a safe and efficient approach to surgical training. In the last two decades, laparoscopic surgery simulators have been widely developed to support efficient training in surgical techniques. In contrast, neurosurgery simulators have not been investigated extensively. However, recent years have witnessed some significant advancements in the development of neurosurgery simulators [1, 2]. Neurosurgery requires surgeons to perform precise operations. Because surgeons rely on haptic cues in various contexts, the physics of softtissue deformation should be reliable not only for graphical rendering but also for haptic rendering.

The refresh rate of the physics simulation must be greater than 30 Hz for smooth animation [8].

The positions of the surgical instruments are input by haptic devices, and the reaction force must be returned immediately. Ideally, the refresh rate of the force feedback should be greater than 1 kHz for interaction with stiff materials [8].

The number of nodes of target finite element model (brain hemisphere) should be approximately 10,000.

The ability to perform connectivetissue dissection should be present [8].

The soft tissues should have physically correct behavior. Brain tissues are known to have complex mechanical properties; for example, white matter is known to have anisotropic viscohyperelasticity [9].
To fulfill the abovementioned requirements, we firstly formulated the framework of the interactive simulation using a linear FEM and combined it with haptic devices [10]. In order to accelerate the calculation, we developed an algorithm for collision detection that is implemented on a graphics processing unit (GPU) [11]. However, the computational speed is not sufficient to run in realtime. In particular, the FEM solver was not optimized for calculation on the GPU, and it became the bottleneck of the simulation.

A GPUaccelerated method of a corotational linear FEM including a boundaryconditionbased collision response is proposed.

A stabilization algorithm for the fracture simulation based on element removal is incorporated into the proposed GPUaccelerated FEM framework.
Related work
Collision response
Recent cuttingedge studies on realtime haptic rendering for interacting deformable objects have focused on efficient contact handling including collisions between multiple deformable objects and selfcollisions [14, 15]. They modeled contacts based on Signorini’s law and Coulomb’s law, and the linear or nonlinear complementarity problem needs to be solved. Although their algorithms are highly optimized for a GPU, the number of nodes is limited to several thousand for realizing realtime simulation because of their high computational costs.
The fastest implementation of collision response is the penalty method [16]. In this method, external forces are applied to contact nodes according to the penetration depth. To compute the magnitude of the external forces, scalar coefficients are required for multiplication with the depth. However, it is difficult to determine the scalar values for obtaining a stable response.
The other approach is the position constraint method. In this method, nodal displacements are directly input according to geometric relations. In an early study on a realtime surgery simulator, Cotin et al. introduced a position constraint formulation using the Lagrange multiplier method [17]. Hirota et al. adopted a boundaryconditionbased constraint [18]. Although these method are essentially equivalent and both methods resulting in a large simultaneous linear equations, the method of Hirota et al. has the advantage in the term of the size of the linear equations (see “Collision response of soft tissues”). The limitation of this method is that accurate contact response subject to Signorini’s law or Coulomb’s law cannot be computed. However, because the computational cost is lower than that of the accurate methods, the position constraint method can be used for the analysis of a fine detailed mesh.
As mentioned above, the position constraint method based on a boundary condition involves a large number of simultaneous linear equations. Because the linear system is large and sparse, the sparse matrix format should be adopted for efficient execution of mathematical operations and to reduce memory consumption. However, its GPUoptimized implementations considering the sparse matrix format have not been discussed.
Fracture
In the field of computer graphics, several methods of fracture simulation have been discussed [19–21]. This section describes the details of fracture algorithms developed for realtime applications.
A notable approach is the extended FEM [22], which allows for representation of any crack without the limitations of a mesh topology by adding a shape function to the element displacement field interpolations. Thus, an additional degree of freedom (DOF) is provided to model crack discontinuities.
Mor and Kanade modeled the knife cutting of soft objects [23]. They proposed split patterns in which a tetrahedron is split into smaller tetrahedrons according to the knife path. In this approach, the tetrahedral mesh is explicitly modified by adding new nodes to it.
Delingette et al. proposed an element removal approach in the early years of surgery simulation studies [24]. Even though this approach suffers from the disadvantage of a loss of volume, it offers advantages such as a low computational cost and simple implementation. In particular, we focus on the fact that this algorithm does not require the addition of add new nodes. Thus, simulations can be performed at the same computational cost throughout. Because realtime characteristics are important for practical use of the surgery simulator, we adopt this element removal approach.
Some topologicalsingularity avoidance algorithms have been proposed in the literature. Forest et al. proposed a node separation algorithm [12]. They separated the singular vertices and singular edges by adding copies of such vertices and edges. However, this approach increases the computational cost because the DOFs of the system increase with the addition of nodes. Nakayama et al. proposed a delay algorithm that suspends the removal of elements that cause topological singularities [13]. However, the delay algorithm does not correctly simulate actual fracture phenomena. In the actual case, the stress will be concentrated at a singular vertex and singular edge. Thus, the two elements connected by a singular vertex or singular edge will be disconnected. Therefore, such elements should be removed immediately.
Finite element model of the brain
Corotational FEM
\(\mathbf {R}\) is calculated by singular value decomposition (SVD) of deformation gradient. The details are described in “Appendix A: Rotation of a deformed tetrahedron”.
Matrix/vector assembly
Collision response of soft tissues
Implementation and GPU parallelization
This section describes the implementation of the FEM. To measure the computational time, we used a CIARA KRONOS S810R workstation, which employs an Intel Core i73960X (six cores, overclocked to 4.5 GHz) CPU with 64 GB of RAM and two GPUs, an NVIDIA K20c (2,496 CUDA cores) for generalpurpose computing and an NVIDIA Quadro K5000 (1536 CUDA cores) for graphics processing. Parallel processing is implemented using OpenMP for multithread computing on a multicore CPU and NVIDIA CUDA for generalpurpose computing on GPUs (GPGPU).
Simulation procedures

Calculation of element data: \(\mathbf {R^e}\), \(\mathbf {K^e}\), and \({\varvec{f}}_0^e\) are calculated. The details of these parallel implementations are described in “Calculation of element data”.

Matrix/vector assembly: \({\mathbf {K}}\) and \({\varvec{f}}_0\) are assembled. The details of the parallelization of the assembly are described in “Efficient matrix/vector assembly in a sparse storage format”.

Collision detection: Collision detection between a deformable object (brain) and rigid objects (brain spatulas) is executed. The contact nodes of the deformable object and the corresponding forced displacements are determined. The discrete collision detection approach reported in [11] is adopted. This method can deal with collisions between a nonconvex deformable object and a rigid object.

Application of boundary condition: On the basis of collision detection, a boundary condition is set. As mentioned in “Collision response of soft tissues”, a large sparse matrix is rearranged according to the boundary condition. The implementation details are described in “Matrix rearrangement”.

Calculation of the deformation and external forces: The calculation of the deformation is a problem involving a system of linear equations. The linear equations are solved by the conjugate gradient method. Sparsematrix densevector multiplications are implemented by the sparsematrix library CUSPARSE provided by NVIDIA Corp.
Calculation of element data
An element stiffness matrix \({\mathbf {K}}^e\) is calculated using Eq. (4). It is assumed that the materials are isotropic; hence, \({\mathbf {K}}^e\) is a symmetric matrix. Therefore, it is sufficient to store the elements of the upper triangular matrix of \({\mathbf {K}}^e\). Further, \({\varvec{f}}^e_0\) is calculated in the same way as \({\mathbf {K}}^e\) (Eq. 5). Finally, all \({\mathbf {K}}^e\) (\({\mathbf {K}}^1\), \({\mathbf {K}}^2, \ldots , {\mathbf {K}}^{N_{\mathrm{elem}}}\)) and \({\varvec{f}}^e_0\) (\({\varvec{f}}^1_0\), \({\varvec{f}}^2_0, \ldots, {\varvec{f}}^{N_{\mathrm{elem}}}_0\)), where \(N_{\mathrm{elem}}\) is the number of tetrahedral elements, are serialized and stored in the arrays valuesKe and valuesF0e, respectively. These procedures are implemented in parallel using one thread per element.
Efficient matrix/vector assembly in a sparse storage format
In the matrix/vector assembly procedure, the element stiffness matrices are assembled into the global stiffness matrix, as described in Eq. (6), and the element force offset vectors are assembled into the global force offset vector, as described in Eq. (7). First, the implementation of global stiffness matrix assembly is described, and then, that of global force offset vector assembly is described.
The assembly of \({\varvec{f}}_0\) is implemented in a similar manner. After the calculation of \(\mathbf {R}^e\), all values of \({\varvec{f}}^e_0\) are stored as an array. The reduction list for the assembly of \({\varvec{f}}_0\) is constructed in advance. The reduction is performed in a thread per component of \({\varvec{f}}_0\), which allows for the calculation of \({\varvec{f}}_0\) without atomic operation. This reduction is independent of the assembly of \({\mathbf {K}}\). Therefore, assemblies of \({\mathbf {K}}\) and \({\varvec{f}}_0\) are performed concurrently, e.g., on two GPUs.
Matrix rearrangement
As described in “Collision response of soft tissues”, collisions are represented by geometrical boundary conditions and the global stiffness matrix is rearranged by considering the boundary conditions. This rearrangement procedure involves permutation and separation processes.
These procedures require sorting of large arrays, which is computationally expensive. In order to accelerate the sorting process, they are implemented on a GPU using the NVIDIA CUDA thrust library.
Modeling of dissection
Topologicalsingularity avoidance algorithm for element removal
 1.
Fracture detection Determine the tetrahedrons to be removed on the basis of a specified fracture criterion and list them in a set \(T_\mathrm{rm}\).
 2.
Singularity verification Check whether the vertices and edges that belong to \(T_\mathrm{rm}\) are singular after removing the tetrahedrons listed in \(T_\mathrm{rm}\).
 3.
Detection of additional tetrahedrons to be removed If any vertices or edges are predicted to be singular, the tetrahedrons that include the predicted singular vertices or edges are added to \(T_\mathrm{rm}\).
 4.
Repeat Singularity verification and Detection of additional tetrahedrons to be removed until \(T_\mathrm{rm}\) becomes empty.
 1.
Extract \(T^v\), a set of tetrahedrons, that includes v as a vertex.
 2.
Select an arbitrary tetrahedron \(t^v_0 \in T^v\).
 3.
Construct \(T^v_\mathrm{edge}\), a set of tetrahedrons, that shares at least one edge with \(t^v_0\).
 4.
Select a tetrahedron \(t^v_x \in T^v_\mathrm{edge}\) and search for an edgesharing tetrahedron as described above in steps 2 and 3. Add the new edgesharing tetrahedron to \(T^v_\mathrm{edge}\) and repeat until no entry is found.
 5.
If \(n(T^v)\ne n(T^v_\mathrm{edge})\), v is a singular vertex, where \(n(\cdot )\) denotes the number of tetrahedrons.
 1.
Extract \(T^e\), a set of tetrahedrons, that include e as an edge.
 2.
Select an arbitrary tetrahedron \(t^e_0 \in T^e\).
 3.
Construct \(T^e_\mathrm{edge}\), a set of tetrahedrons, that shares at least one edge with \(t^e_0\) except edge e.
 4.
Select a tetrahedron \(t^e_x \in T^e_\mathrm{edge}\) and search for an edgesharing tetrahedron as described above in steps 2 and 3. Add the new edgesharing tetrahedron to \(T^e_\mathrm{edge}\) and repeat until no entry is found.
 5.
If \(n(T^e)\ne n(T^e_\mathrm{edge})\), e is a singular edge.
Examples of fracture simulations are shown in Fig. 11. In the simulation without topologicalsingularity avoidance (Fig. 11b), tetrahedrons connected with only a singular vertex or edge exhibit unstable deformation. On the other hand, in the simulation with topologicalsingularity avoidance (Fig. 11a), the risk of instability is eliminated, and the simulation continues in any fracture situation.
Implementation
The calculation of the maximum principal stress on each element is computed in parallel by the GPU. To calculate the eigenvalues of the stress tensor, the Jacobi eigenvalue algorithm is adopted. The singularity avoidance algorithm is implemented on a sixcore CPU because it requires numerous conditional branchings and complicated data structures for the mesh topology. However, it is not a timeconsuming procedure and is rapidly computed, even on a CPU.
Results
Performance evaluation of GPU implementations
Blunt dissection simulation
Blunt dissection is an operation for separating tissues without cutting. It is generally performed along fissures by breaking connective tissues. In neurosurgery, surgeons perform cutting operations using scissors or blunt dissection depending on the context of the surgery.
An FE model of a cube with a fissure (4807 nodes and 19,600 tetrahedrons) was used in the simulation. It was assumed that the fissure was filled with connective tissues, the Young’s modulus and Poisson’s ratio of which were 100 and 0.4 Pa, respectively. The Young’s modulus and Poisson’s ratio of the main body were assumed to be 1000 and 0.4 Pa, respectively. The fracture threshold stresses were set to the same values as their Young’s moduli. Note that these mechanical parameters are determined to distinguish the relative stiffness of the materials and not validated by experiments. Initially, the tips of two spatulas were inserted into the fissure, and then they were opened to dissect the connective tissues at a velocity of 5.0 mm/s. In order to compare different implementations, this simulation was executed by each implementation with a constant time step of 20 ms.
Brain retraction simulation
Brain retraction is an operation performed by pushing soft tissues to create a working space. One of the important brain fissures, which are frequently performed retractions, is the the Sylvian fissure. The Sylvian fissure is filled with the arachnoid mater, which needs to be dissected by surgeons. This section shows the result of a brain retraction simulation conducted in realtime by user input using a Sensable Phantom Omni haptic device. The reaction force to the usercontrolled instruments was fed back through the haptic device. The simulation was conducted under the assumption that the arachnoid mater was dissected beforehand. The task objective given to the user is to retract the brain tissues and expose the brain tumor existing at the bottom of the Sylvian fissure. A brain hemisphere mesh model (8647 nodes, 32,639 elements) was used in this simulation. This model was constructed by scanning an anatomical model of the human brain, Brain Model C20 (3B Scientific GmbH), and modifying it using 3D modeling software. The bottom nodes of the hemisphere mesh model were fixed; hence, the displacements of the bottom nodes were always set to zero.
Discussions
Figures 12 and 13 show that the GPU implementations had the highest speed among the three implementations in both evaluations. In the comparison of the matrix/vector assembly, for the model with 15,625 nodes and 69,120 elements, the GPU implementation (10.7 ms) was 19.7 times faster than the singleCPU implementation (210.9 ms) and 3.9 times faster than the sixcore CPU implementation (41.9 ms). In the comparison of the matrix rearrangement, for the same model, the GPU implementation (11.0 ms) was 7.1 times faster than the singleCPU implementation (78.4 ms) and 5.1 times faster than the sixcore CPU implementation (56.3 ms).
The results of the blunt dissection simulation show that the combination of our GPU implementation and the fracture algorithm worked as expected. As seen in Fig. 14b, the connective tissue was easily deformed and removed owing to the stress concentration because it was specified to be softer than the main body. In Fig. 15, the calculation time jitter is shown. One of the causes is the difference in the convergence times of the conjugate gradient method. Another cause is the change in the boundary condition. When the boundary condition changed, the matrix rearrangement procedure is executed and takes additional calculation time. The average calculation times of the three implementations, a CPU with no parallelization, a sixcore CPU with multithreaded parallelization, and a GPU implementation, were 103, 41, and 17 ms, respectively. The speedup of the GPU versus the CPU was 6.1. Only the GPU realized smooth animation with a refresh rate greater than 30 Hz. As seen in Fig. 16, the fracture started at step 25, and the peak number of removed elements was 33 at step 60. It is shown that the number of removed elements did not affect the calculation time. This result shows that this approach is preferable for surgery simulation because the simulation can be continued at the same refresh rate throughout.
On the other hand, the results of the brain retraction simulation show that our implementation could not achieve the target calculation speed. The range of calculation time for a time step was 40–80 ms. This refresh rate is not sufficient for visually acceptable animations and reactionforce rendering. The reference force was discontinuous, and the force display could oscillate if we did not apply the lowpass filter. Although the lowpass filter reduced the discontinuous force feedback, this is not a fundamental solution for displaying realistic reaction forces. From these results, further acceleration is needed to achieve stable and visually acceptable simulation. Moreover, the development of a method for displaying smooth and stable forces is a topic for future study.
Conclusion
In this paper, a realtime simulation scheme for softtissue deformation and fracture for brain retraction is proposed. GPU implementations for matrix/vector assembly and a matrix rearrangement procedure for accelerating a corotational FEM including boundaryconditionbased collision response are proposed. A simple mesh modification method considering the avoidance of topological singularities is developed and combined with the proposed GPUaccelerated FEM framework. Finally, blunt dissection and brain retraction simulations are performed using the proposed implementation. Both simulations can be conducted in real time. Although the proposed method could not achieve a visually acceptable update rate for the brain retraction simulation using our target brain hemisphere model, it performs faster than the CPU implementations.
In this study, viscoelasticity and material nonlinearities were not considered. In order to obtain more realistic material behavior, we plan to integrate material properties more precisely in our future implementation.
Declarations
Authors’ contributions
AK led and directed the project. AK and TT showed the need for a fast and stable calculation method of deformation and fracture of soft tissues for neurosurgery. KS proposed the algorithms implemented them on a GPU, and drafted the manuscript. TT, AF, and AK participated in the discussion on the optimization of the algorithms. Furthermore, TT implemented the base simulation framework, and AF implemented the collision detection procedure. All authors read and approved the final manuscript.
Acknowledgements
This work was supported by JSPS through the Funding Program for Next Generation WorldLeading Researchers (LR003), the GrantinAid for Scientific Research (A) (15H01707), the GrantinAid for Challenging Exploratory Research (24650288), and the GrantinAid for JSPS Fellows (15J01452).
Competing interests
The authors declare that they have no competing interests.
Open AccessThis article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.
Authors’ Affiliations
References
 Delorme S, Laroche D, DiRaddo R, Del Maestro RF (2012) Neurotouch: a physicsbased virtual simulator for cranial microneurosurgery training. Neurosurgery 71:32–42Google Scholar
 Banerjee PP, Luciano CJ, Lemole GM, Charbel FT, Oh MY (2007) Accuracy of ventriculostomy catheter placement using a head and handtracked highresolution virtual reality simulator with haptic feedback. J Neurosurg 107:515–521View ArticleGoogle Scholar
 Yasargil MG (1995) Microneurosurgery. ThiemeGoogle Scholar
 Zhong J, Dujovny M, Perlin AR, PerezArjona E, Park HK, Diaz FG (2003) Brain retraction injury. Neurol Res 25:831–838View ArticleGoogle Scholar
 Koyama T, Okudera H, Kobayashi S (1999) Computergenerated surgical simulation of morphological changes in microstructures: concepts of “virtual retractor”. J Neurosurg 90(4):780–785View ArticleGoogle Scholar
 Hansen KV, Brix L, Pedersen CF, Haase JP, Larsen OV (2004) Modelling of interaction between a spatula and a human brain. Med Image Anal 8(1):23–33View ArticleGoogle Scholar
 Hasegawa Y, Adachi K, Azuma Y, Fujita A, Kohmura E, Kanki H (2010) A study on cerebellar retraction simulation for developing neurosurgical training system. J Jpn Soc Comput Aided Surg 12(4):533–543View ArticleGoogle Scholar
 Spicer MA, van Velsen M, Caffrey JP, Apuzzo MLJ (2004) Virtual reality neurosurgery: a simulator blueprint. Neurosurgery 54:783–798View ArticleGoogle Scholar
 Sahoo D, Deck C, Willinger R (2014) Development and validation of an advanced anisotropic viscohyperelastic human brain FE model. J Mech Behav Biomed Mater 33(1):24–42View ArticleGoogle Scholar
 Konno A, Nakayama M, Chen XS, Fukuhara A, Sase K, Tsujita T, Abiko S (2013) Development of a brain surgery simulator. In: Proceedings of the International Symposium on Interdisciplinary Research and Education on Medical Device Developments, pp 29–32Google Scholar
 Fukuhara A, Tsujita T, Sase K, Konno A, Jiang X, Abiko S, Uchiyama M (2014) Proposition and evaluation of a collision detection method for real time surgery simulation of opening a brain fissure. ROBOMECH J 1(1):6View ArticleGoogle Scholar
 Forest C, Delingette H, Ayache N (2005) Removing tetrahedra from manifold tetrahedralisation: application to realtime surgical simulation. Med Image Anal 9(2):113–122View ArticleGoogle Scholar
 Nakayama M, Abiko S, Jiang X, Konno A, Uchiyama M (2011) Stable softtissue fracture simulation for surgery simulator. J Robot Mechatron 23(4):589–597Google Scholar
 Courtecuisse H, Jung H, Allard J, Duriez C, Lee DY, Cotin S (2010) Gpubased realtime soft tissue deformation with cutting and haptic feedback. Prog Biophys Mol Biol 103:159–168View ArticleGoogle Scholar
 Courtecuisse H, Allard J, Kerfriden P, Bordas SPA, Cotin S, Duriez C (2014) Realtime simulation of contact and cutting of heterogeneous softtissues. Med Image Anal 18(2):394–410View ArticleGoogle Scholar
 Galoppo N, Tekin S, Otaduy MA, Gross M, Lin MC (2007) Interactive haptic rendering of highresolution deformable objects. In: Proceedings of the 2nd International Conference on Virtual Reality, pp 215–233Google Scholar
 Cotin S, Delingette H, Ayache N (1999) Realtime elastic deformations of soft tissues for surgery simulation. IEEE Trans Visual Comput Graph 5(1):62–73View ArticleGoogle Scholar
 Hirota K, Kaneko T (2001) Haptic representation of elastic objects. Presence Teleoper Virtual Environ 10(5):525–536View ArticleGoogle Scholar
 O’Brien JF, Bargteil AW, Hodgins JK (2002) Graphical modeling and animation of ductile fracture. ACM Trans Graph 21(3):291–294Google Scholar
 Wojtan C, Thürey N, Gross M, Turk G (2009) Deforming meshes that split and merge. ACM Trans Graph 28(3):76:1–76:10View ArticleGoogle Scholar
 Hegemann J, Jiang C, Schroeder C, Teran JM (2013) A level set method for ductile fracture. In: Proceedings of the 12th ACM SIGGRAPH/Eurographics Symposium on Computer Animation, pp 193–201Google Scholar
 Jeřábková L, Kuhlen T (2009) Stable cutting of deformable objects in virtual environments using xfem. IEEE Comput Graph Appl 29(2):61–71View ArticleGoogle Scholar
 Mor AB, Kanade T (2000) Modifying soft tissue models: progressive cutting with minimal new element creation. In: Proceedings of the Third International Conference on Medical Image Computing and ComputerAssisted Intervention, pp 598–607Google Scholar
 Delingette H, Cotin S, Ayache N (1999) A hybrid elastic model allowing realtime cutting, deformations and forcefeedback for surgery training and simulation. Proc Comput Animat 1999:70–81Google Scholar
 Müller M, Dorsey J, McMillan L, Jagnow R, Cutler B (2002) Stable realtime deformations. In: Proceedings of the 2002 ACM SIGGRAPH/Eurographics Symposium on Computer Animation, pp 49–55Google Scholar
 Cecka C, Lew A, Darve E (2012) Application of assembly of finite element methods on graphics processors for realtime elastodynamics. In: Hwu WmW (ed) GPU Computing Gems Jade Edition, Boston, pp 187–205Google Scholar
 Irving G, Teran J, Fedkiw R (2004) Invertible finite elements for robust simulation of large deformation. In: Proceedings of the 2004 ACM SIGGRAPH/Eurographics Symposium on Computer Animation, pp 131–140Google Scholar
 Myronenko A, Song X (2009) On the closedform solution of the rotation matrix arising in computer vision problems. Tech Rep arXiv:09041613v1 [csCV]
 Lahabar S, Narayanan P (2009) Singular value decomposition on gpu using cuda. In: Proceedings of 23rd IEEE International Parallel and Distributed Processing Symposium, pp 1–10Google Scholar
 Bedkowski J, Maslowski A (2011) GPGPU computation in mobile robot applications. Int J Electr Eng Inform 4(1):15–26View ArticleGoogle Scholar
 Sase K, Konno A, Tsujita T, Fukuhara A, Chen X, Komizunai S (2014) Stable fracture model of soft materials for a simulation of brain tumor resection. In: Proceedings of the 2014 JSME Conference on Robotics and Mechatronics, pp 3A1–B03Google Scholar