On the simulation of cutting organs in a virtual environment for training of surgeons. A case study in the context of the ablation of the appendix for a commercial simulator. The algorithm is about an accurate dissection of the mechanical meshes that represents the organs and their enhanced visualisation.

1. Interservice/Industry Training, Simulation, and Education Conference (I/ITSEC) 2015
2015 Paper No. 15333 Page 1 of 10
Real-Time Cutting of Organs with Scissors
Edouard Poutot Aditya Bhatia
CAE Inc, Healthcare Division CAE Inc, Healthcare Division
Montreal, CANADA Montreal, CANADA
edouard.poutot@cae.com aditya.bhatia@cae.com
ABSTRACT
The ability to perform random cuts to organs in real-time is crucial in a virtual reality based surgical simulator.
Nowadays, organs are commonly simulated using the Finite Element Method (FEM) on tetrahedral meshes. In many
cases, cuts can be approximated as singular sections. Thus, the method presented in this paper was designed to
perform subdivisions of tetrahedrons accurately along the path of the blades following a set of pre-computed
patterns. To ensure the resulting meshes remain suitable for simulation, the subdivisions are performed in such a
way that adjacent tetrahedrons will weld and not overlap. Care is taken to minimize the subdivision of tetrahedrons
in the instances where blades traverse the mesh along the boundaries of elements, in which case application of the
basic patterns would have generated degenerated tetrahedrons. This paper also describes the way in which the
surface mesh is extracted from the tetrahedral mesh after the cut is performed, in order to update the data for
collision management and visualization.
ABOUT THE AUTHORS
Edouard Poutot has been a Technical Specialist at CAE Healthcare for the last five years, working as a computer
scientist on fluids and soft-bodies simulation for virtual reality solutions for training medical students. Prior to that,
he worked for more than a decade in the video game industry on computer graphics and physics based animation.
He holds a Bachelor of Science in Mechanics from the University of Marseille and a Masters in Computer Graphics
from the University of Paris.
Aditya Bhatia is a Senior Technical Professional at CAE Healthcare specializing in real time graphics rendering. He
has a decade of combined work experience in computer graphics, architecture, shaders and rendering pipelines in
both virtual reality simulation and video games industry. He holds a Master’s degree in Computer Science from
McGill University, Montreal.

2. Interservice/Industry Training, Simulation, and Education Conference (I/ITSEC) 2015
2015 Paper No. 15333 Page 2 of 10
Real-Time Cutting of Organs with Scissors
Edouard Poutot Aditya Bhatia
CAE Inc, Healthcare Division CAE Inc, Healthcare Division
Montreal, CANADA Montreal, CANADA
edouard.poutot@cae.com aditya.bhatia@cae.com
INTRODUCTION
LapVR-Appendectomy is a virtual reality based surgical simulator for training students on how to perform
laparoscopic appendectomy procedures. The simulator is representative of the real procedural abdominal
environment, including haptics, which are transmitted via two simulated surgical instrument handles inserted in a
black box connected to a computer. The handles allow for the manipulation of virtual tools which interact with
anatomical elements such as organs. There is also a screen where the user can see a simulated real-time endoscopic
image of the interior of the abdominal cavity. The simulation of the organs is achieved by applying the Finite
Elements Method (FEM) on tetrahedral meshes (Müller et al., 2004). Thus one simple means to represent cutting
would be to remove elements that are intersected by the cutting blade. The issue with this simplified method is that
too much material is removed during a cut given the mesh resolution which results in unrealistic looking meshes.
Another solution considered was to limit cutting to some pre-determined regions on organs identified with visible
lines, however, this limitation of cutting movements was deemed unacceptable. The simulator requirements include
realistic organ cutting in one shot, near instantaneous haptic response, and freedom to cut anywhere on the appendix
with scissors, cutter-staplers and other tools. The method presented in this paper allows random cuts to be performed
anywhere, accurately and without any resulting discrepancies between the mechanical, collision and visual meshes.
This is achieved because of the fact that cuts are only applied to the tetrahedral mesh following a set of pre-defined
patterns. The resulting surface is extracted to build a triangular mesh for collisions management and subdivided for
visualization. The paper’s contribution is to detail the subdivision patterns utilized and discuss how to avoid
singularities that could arise at the elemental boundaries. Cutting is presented as a whole feature including the
generation of interactive organs that are realistic from a user’s visual and haptics perspectives
Related Work
A recent survey about cutting simulation can be found in (Wu et al., 2014). To summarize, there are two groups of
strategies, the ones with new element generation and the ones without new elements generation; all based on a
mixture of element removal, separation, splitting or duplication. The most straightforward solution is to simply
delete elements in contact with the blades (Cotin et al., 2000) and fix the topology to preserve the manifoldness of
the new tetrahedral mesh (Forest et al., 2002) or rebuild a surface mesh following the deletion. Disadvantages with
these approaches are that there is no conservation of mass and it produces a jagged surface with unrealistic holes
unless one can afford a high enough resolution. To avoid those issues, one can limit elemental separation to their
boundaries; however, the resulting cut will not match the path of the blades. To address this, one can project the
nodes on the cutting path (Nienhuys et al., 2001) but that might flatten some elements and damage the FEM mesh
requiring some form of mesh relaxation following the node snapping operation in order to preserve the shape of
elements in the neighborhood of the cut (Serby et al., 2001). The other approaches without new elements generation
are based on element duplication. This usually means that the cut is performed on a surface mesh that is embedded
inside the mechanical mesh. This is the virtual node algorithm (Molino et al., 2004) that has been further enhanced
by (Sifakis et al., 2007). In this case, one has to share the physical properties between the duplicated elements.
Another family of methods is based on the creation of new elements. To start with, there is the idea of making a
local refinement of the mesh where the cut takes place and remove tetrahedrons in contact with the blades (Forest et
al., 2002), however, this shares the same limitations as the simple element removal method. There are also solutions
that split elements along the edges of tetrahedrons in a progressive way that have been developed for scalpels (Mor
et al., 2000) and (Bielser et al., 2000); some based on temporary edge splitting until the cut is validated (Bielser et
al., 2003). Hybrid solutions combine tetrahedrons splitting, boundary separation and node snapping prior to
subdivision (Steinemann et al., 2006) in order to reduce the occurrence of singularities.

3. Interservice/Industry Training, Simulation, and Education Conference (I/ITSEC) 2015
2015 Paper No. 15333 Page 3 of 10
METHODOLOGY
Cutting Algorithm
The path of the blades across two frames of the simulation can be seen as a convex polygon attached to the jaws of
the surgical instrument at the time of the cut. As such, the algorithm tackles the problem of accurately splitting a set
of tetrahedrons by that polygon while retrieving a mesh that is still suitable for the simulation. The algorithm acts on
every tetrahedron within a mesh separately. It performs accurate cuts by splitting the tetrahedrons where they
overlap with the cut polygon. The subdivision of each tetrahedron is based on a set of pre-defined canonical
patterns, in which the original tetrahedron is replaced by a set of smaller child ones that cover the same volume
without any overlap, as required by the FEM method. Those patterns were designed to ensure that the child
tetrahedrons weld to each other properly in addition to welding with their neighboring tetrahedrons. This ensures
that the resulting mesh remains a three-manifold to preserve a consistent topology for the collisions system.
For each tetrahedron, the algorithm first determines on which side of the cut plane that its four nodes lay. This
includes detecting if some nodes lie on the cut plane itself, within an established tolerance. As a result, each node
can have three states: on the positive side, on the plane, or on the negative side. This allows determination of which
of the 34
= 81 possible cases that this tetrahedron falls under. Then, by referring to a look-up table of possible nodal
permutations, the tetrahedron can be appropriately transformed according to one of the seven canonical cases that
lead to either splitting or boundary separation.
The next step is to verify if the cut is complete or partial given the boundaries of the polygon within the cut plane.
This can be achieved since the edges that are expected to be cut are known in addition to which nodes are coplanar
to the cut polygon. Thus, an intersection test can be performed between the suspected edges and the cut polygon and
verification if any coplanar nodes lie inside it. This allows sorting of the nodes in order to select the final pattern,
again using a look-up table.
Once the appropriate pattern has been determined, the look-up table is accessed to define how to split the
tetrahedron into a set of primitives (i.e. smaller tetrahedrons, pyramids and prims). For the latter two, there are
specific procedures defining how to consistently split them into tetrahedrons such that two adjacent tetrahedrons
sharing a face will end-up with the same topology and are able to be welded together. This is ensured by choosing
the diagonal of the quads in the prims and pyramids to be the one that links the minimal node indices. It is also
possible to take the diagonal that gives the best area ratio between the two resulting triangles, however, that is
subject to floating point round-off errors so the solution chosen ensures the manifoldness of the resulting mesh is
more reliable.
The seven canonical cases are listed below and detailed in the following pages:
 One and three nodes on each side
 Two nodes on each side
 One node on the plane and the others on each side
 One node on the plane and the others on the same side
 Two nodes on the plane and the others on each side
 Two nodes on the plane and the others on the same side
 Three nodes on the plane

4. Interservice/Industry Training, Simulation, and Education Conference (I/ITSEC) 2015
2015 Paper No. 15333 Page 4 of 10
Cases with all nodes on each side of the cut polygon:
Figure 1 presents the cases involving only edge cuts. The first three sketches represent the cases with one and three
nodes on each side and the last five are the ones that may happen with two nodes on each side. Notice the second
and third ones can be found in both configurations.
Figure 1 – Edge cuts only
In the sketch for each case, the subdivision pattern is highlighted in red and the new nodes numbered. For example,
the second case of Figure 1 is split into four subdivision primitives as detailed in Figure 2 below, each primitive
being defined by the set of its nodes following the nomenclature as the sketch.
Figure 2 – Example of a subdivision
To open a wound following cutting, the edges are intersected with the cut polygon and two nodes are created; one on
each side of the plane. Those new nodes are inserted at the end of a buffer and the algorithm keeps track of them in a
hash map in order to share any same nodes between new adjacent elements and thus achieving welding of the new
elements within the mesh.
Tetrahedrons
023 123 2 3
Prims
0 03a 023 1 13a 123
Pyramids
023 123 13b 03b 3
023 123 1 0 2

5. Interservice/Industry Training, Simulation, and Education Conference (I/ITSEC) 2015
2015 Paper No. 15333 Page 5 of 10
Cases with some nodes coplanar to the cut plane and the others on each side:
One node on the cut plane and the others on each side (Figure 3).
Figure 3 – Partial subdivisions in cases of one coplanar node and the others on each side
Two nodes on the cut plane and the others on each side (Figure 4).
Figure 4 – Partial subdivisions in cases of two coplanar nodes and the others on each side
The cases with nodes coplanar to the cut plane need to clone the nodes that lie inside the cut polygon to open the
wound on top of the expected edge splits consistent with the regular cases. The convention used is to leave the
original node with the tetrahedrons on the negative side of the plane and the duplicated one with those on the
positive side.
Cases with some nodes coplanar to the cut plane and the others on the same side:
The cases with one node, one edge or one face coplanar to the cut plane can be thought of as clipping problems. In
the cases with one single node on the plane, one simply has to check if the node is inside the polygon in which case
it is cloned if its other nodes are on the positive side of the plane, as defined by our convention, to detach that node
from the mesh. Following the same principle, the cases of edges and faces are managed by scissoring algorithms for

6. Interservice/Industry Training, Simulation, and Education Conference (I/ITSEC) 2015
2015 Paper No. 15333 Page 6 of 10
segments and triangles against the cut polygon and generate tetrahedrons accordingly using the remaining non-
coplanar nodes. The case of a coplanar edge is shown below in Figure 5.
Figure 5 – One coplanar edge inside (left) or partially outside the blade
Most of the cases with a coplanar face are omitted here because there are a plethora of them. The simplest coplanar
face case is shown in Figure 6 where the nodes of the green face are all within cut plane (thus will all detach).
Another example case shown is one of the most extreme ones (Figure 7) were a cut triangle (in green) overlaps all
the edges of a face.
Figure 6 – One coplanar face inside Figure 7 – One coplanar face partially outside
End-cases
The algorithm is all about cutting edges and tries to avoid singularities by taking care of cases with coplanar nodes
but some extra cases must be taken into account. Those are the cases where the blade traverses a face without cutting
any edge on that side. This is illustrated here with an example that can arise in the case of one single edge cut
previously depicted in the third sketch of Figure 1. In Figure 8, the blade is cutting an edge while traversing a face
on the other side of the edge cut and that face has to be cut as well. The sketch on the right in Figure 8 shows the
degeneration of the first one where the blade traverses an opposite edge.
Figure 8 – One edge cut by a blade that also overlaps a face

7. Interservice/Industry Training, Simulation, and Education Conference (I/ITSEC) 2015
2015 Paper No. 15333 Page 7 of 10
Subdivision primitives
The algorithm heavily relies on subdivisions made out of prisms and pyramids that ultimately also split into
tetrahedrons. To consistently split the quadrilateral faces of those primitives into triangles, one has to choose the
diagonal which contains the smallest vertex index of the face. This ensures topology preservation of the final mesh.
Pyramids always split in two. Prisms, in most cases, simply break down into three tetrahedrons but two of the cases,
namely Schönhardt polyhedra (Dompierre et al., 1999), can only be triangulated into tetrahedrons with an extra
Steiner point (in this case the average of the nodes). The configurations are shown in the table below:
Table 1 – Subdivisions of prims into tetrahedra
Count Tetrahedra for Prisms
8 { 0, 1, 2, 6 }, { 0, 1, 3, 6 }, { 1, 3, 4, 6 }, { 1, 2, 4, 6 }, { 2, 4, 5, 6 }, { 0, 2, 5, 6 }, { 0, 3, 5, 6 }, { 3, 4, 5, 6 }
3 { 0, 1, 3, 5 }, { 1, 3, 4, 5 }, { 0, 1, 2, 5 },
3 { 0, 1, 2, 3 }, { 1, 2, 3, 4 }, { 2, 3, 4, 5 },
3 { 0, 1, 2, 3 }, { 1, 3, 4, 5 }, { 1, 2, 3, 5 },
3 { 0, 3, 4, 5 }, { 0, 1, 2, 4 }, { 0, 2, 4, 5 },
3 { 0, 3, 4, 5 }, { 0, 1, 4, 5 }, { 0, 1, 2, 5 },
3 { 0, 2, 3, 4 }, { 0, 1, 2, 4 }, { 2, 3, 4, 5 },
8 { 0, 1, 2, 6 }, { 0, 3, 4, 6 }, { 0, 1, 4, 6 }, { 1, 4, 5, 6 }, { 1, 2, 5, 6 }, { 2, 3, 5, 6 }, { 0, 2, 3, 6 }, { 3, 4, 5, 6 }
Table 2 - Subdivisions of pyramids into tetrahedra
Count Tetrahedra for Pyramids
2 { 0, 1, 2, 4 }, { 0, 2, 3, 4 },
2 { 1, 2, 3, 4 }, { 0, 1, 3, 4 }
The pseudo-code allowing determination of the right subdivisions is shown below:
1. splitPrism( in nodes )
2. case_idx = 0
3. if (min(node[1], node[3]) > min(node[0], node[4]) case_idx |= 4
4. if (min(node[0], node[5]) > min(node[2], node[3]) case_idx |= 2
5. if (min(node[2], node[4]) > min(node[1], node[5]) case_idx |= 1
6. count = prism_cases[case_idx].count
7. elems = prism_cases[case_idx].elems
8. if (count == 8)
9. nodes[6] = addSteinerPoint(nodes)
10. endif
11. addElems(elems, count)
12. end
13.
14. splitPyramid( in nodes )
15. case_idx = 0
16. if (min(node[0], node[2]) > min(node[1], node[3]) case_idx = 1
17. count = pyramid_cases[case_idx].count
18. elems = pyramid_cases[case_idx].elems
19. addElems(elems, count)
20. end
Figure 9 – subdivision selectors for prisms and pyramids into tetrahedrons

8. Interservice/Industry Training, Simulation, and Education Conference (I/ITSEC) 2015
2015 Paper No. 15333 Page 8 of 10
SURFACE EXTRACTION AND RENDERING
Surface extraction
The surface needs to be extracted from the mechanical mesh for collisions and for rendering. The surface needs to
be re-computed each time the topology of the mechanical mesh changes (i.e. in case of a cut or removal of a
tetrahedron). This computation is done using CUDA with Thrust libraries. The mechanical mesh could be an
aggregate of several visual meshes, each with its own materials and rendering options. It is imperative that after a
topology change, the information of what parts of surface belong to which visual mesh is preserved. Each visual
mesh is just an offset in the geometry’s buffer. Since the same initial mesh is used to produce the mechanical mesh,
the number of groups that a tetrahedron can belong to is the same as the number of visual meshes. It is also assumed
that each tetrahedron element can only belong to a unique group. The algorithm takes tetrahedron indices and groups
as input, and outputs boundary faces and boundary visual groups. The basic idea is that each face of a tetrahedron
that is not shared by any other tetrahedron is a surface face. Here is the algorithm:
21. extractBoundary( in tet_indices, in tet_groups, out boundary_faces, out boundary_groups)
22. tuple<face, group> faces_group
23. for each tet_index in tet_indices
24. Group G = tet_groups[tet_index]
25. faces_group.add(face1, G)
26. faces_group.add(face2, G)
27. faces_group.add(face3, G)
28. faces_group.add(face4, G)
29. endfor
30.
31. sort_by_key(faces_group.face, faces_group.group)
32. reduce_by_key(faces_group.face, unique_face_groups, unique_faces_count)
33. no_shared_faces = remove_if(unique_faces_count != 1)
34.
35. sort_by_key(unique_face_groups.group, unique_face_groups.face)
36. reduce_by_key(unique_face_groups.group, unique_groups, unique_groups_count)
37. boundary_groups = unique_groups_count
38. end
Figure 10 – boundary extraction algorithm
GPU subdivision
The first approach was done using (Catmull-Clark et al., 1978) subdivision on CPU. This solution was slow and
didn’t scale well with the size of the mesh. The computation increases not only as the size of the mesh changes, but
also with the number of subdivisions per face. Also, it is memory bandwidth intensive, as all the newly created
vertices need to be sent to the GPU for rendering. With emergence of the OpenGL 4.0 standard and compliant GPU
hardware and drivers, it is possible to use the native support for Mesh Tessellation on the hardware. It is done in the
Vertex Processing stage where an input of patches is subdivided into smaller primitives. Two new, optional
programmable stages – Tessellation Control Shader (TCS) and Tessellation Evaluation Shader (TES) were added
between Vertex Shader stage and Geometry Shader Stage. TCS defines the size of a patch and controls how much
tessellation each patch gets. TES takes as input the tessellated patch and computes per-vertex data. A brief literature
survey reveals a few algorithms that can be implemented for Tessellation. Curved PN Triangles (Vlachos et al.,
2001) takes as input a triangle with vertices and normals and outputs a smooth cubic Bezier patch and a
quadratically varying normal. Vertex positions are interpolated and projected along the closest normal to generate
the control points. The averaged normal is used for a control point in the center. The Phong Tessellation (Boubekeur
et al.’s, 2008) approach is a geometric version of Phong Shading as it is applied locally on vertex positions. It
interpolates the projection of each vertex on to a tangent plane to produce a new point. The advantages of this
approach are multifold. First, it acts locally, thereby preserving the original mesh vertices. This helps preserve
continuity with other meshes. Second, it is extremely fast and efficient. With small enough (each triangle splitting
into 9) tessellation parameters, there was hardly any noticeable difference in performance with a significant increase
in visual quality. Third, it requires no change in the input meshes format like adjacency information for Catmull-
Clark and, is not based on a recursive strategy that requires multiple render passes. For the above-mentioned
reasons, Phong Tessellation was the choice of algorithm for tessellation.

9. Interservice/Industry Training, Simulation, and Education Conference (I/ITSEC) 2015
2015 Paper No. 15333 Page 9 of 10
Figure 11 shows the mechanical, the collision, the visual (wireframe) meshes and the resulting image.
Figure 11 – The three representations of the organs and the image with realistic shading.
CONCLUSION
The primary weakness of cutting in the previous Lap-VR procedure modules was inaccuracy due to utilization of the
element removal approach. This new algorithm developed for the Appendectomy procedure module allows accurate
cuts to be performed with scissors anywhere in the organs which are simulated in real-time as tetrahedral meshes
without any noticeable lag on a Xeon E5620 processor at 2.4 Ghz. The cutting simulation itself is extremely fast and
the surface extraction, being performed by GPU, is more efficient than it would be on CPU by an order of
magnitude. The subdivision step is hidden by the fact it is deferred to the OpenGL rendering time. The only
drawback of this approach is that the resulting mesh can lead to an ill-conditioned stiffness matrix. Thanks to
parallelization of the FEM, it was possible to utilize a high count of nodes and elements; despite the fact some might
be misshapen. The solution is stable and ensures no discrepancy between different mechanical, collision and visual
representations of the organs. An example of simulated cutting can be seen below in a screen-shot taken from the
Lap-VR simulator (Figure 12), and the underlying tetrahedral mesh is detailed in Figure 13.
Figure 12 – Cut of the appendix with scissors.
Figure 13 – A tetrahedral mesh being cut by a red triangle.
ACKNOWLEDGEMENT
Thanks to Sylvain Vignaud for his prior work on visual mesh cutting and subdivision, Gianni Campion for his help
with non-manifoldness fixes after the cuts and Pierre St-Hilaire for the illustrations in this paper.

10. Interservice/Industry Training, Simulation, and Education Conference (I/ITSEC) 2015
2015 Paper No. 15333 Page 10 of 10
REFERENCES
Boubekeur, T., & Alexa, M. (2008). Phong Tessellation. ACM Transactions on Graphics volume 27 (SIGGRAPH
Asia 2008). 141:1-141:5
Bielser, D., & Gross, M. (2000). Interactive simulation of surgical cuts. Proceedings Pacific Graphics, 116–125
Bielser, D., Glardon, P., Teschner, M., & Gross, M. (2003). A state machine for real-time cutting of tetrahedral
meshes. Pacific Graphics, 377–386
Catmull, E., & Clark, J. (1978). Recursively Generated B-Spline Surfaces on Topological Meshes. Computer-Aided
Design Vol. 10. 350–355
Cotin, S., Delingette, H., & Ayache, N. (2000). A hybrid elastic model for real-time cutting, deformations, and force
feedback for surgery training and simulation. The Visual Computer 16, 8, 437–452
Dompierre, J., Labbé, P., Vallet, M-G., & Camarero, R. (1999). How to Subdivide Pyramids, Prisms and Hexahedra
into Tetrahedra. Proceedings 8th
International Meshing Roundtable, Sandia National Lab. Technical report
R99-78, CERCA. 195–204
Forest, C., Delingette, H., & Ayache, N. (2002). Removing tetrahedra from a manifold mesh. Proceedings in
Computer Animation, 225–229
Forest, C., Delingette, H., & Ayache, N. (2002). Cutting simulation of manifold simulation meshes. MICCAI
Proceedings, 235–244
Molino, N., Bao, Z., & Fedkiw, R. (2004). A virtual node algorithm for changing mesh topology during simulation.
ACM SIGGRAPH Proceedings 23, 385–392
Müller, M., & Gross, M. (2004). Interactive virtual materials. Proceedings Graphics Interface, 239–246
Mor, A. B., & Kanade, T. (2000). Modifying soft tissue models: Progressive cutting with minimal new element
creation. MICCAI Proceedings, 598–607
Nienhuys, H.-W., & Van Der Stappen, A. F. (2001). A surgery simulation supporting cuts and finite element
deformation. Proceedings MICCAI, 145–152
Steinemann, D., Harders, M., Gross, M., & Szekely, G. (2006). Hybrid cutting of deformable solids. Proceedings of
the IEEE Virtual Reality Conference, 35–42
Serby, D., Harders, M., & Székely, G. (2001). A new approach to cutting into finite element models. MICCAI
Proceedings, 425–433
Sifakis, E., Der, K., & Fedkiw, R. (2007). Arbitrary cutting of deformable tetrahedralized objects. Proceedings
Symposium Computer Animation, 73–80
Vlachos, A., Peters, J., Boyd, C., & Mitchell, J. (2001). Curved PN Triangles. Symposium on Interactive 3D
Graphics. 159–166
Wu, J., Westermann, R., & Dick, C. (2014). Physically based simulation of cuts in deformable bodies: A survey.
Eurographics. State-of-the-Art Report.