A Volume Preserving Model for Biomechanically-based - SEE-KID

Сomentários

Transcrição

A Volume Preserving Model for Biomechanically-based - SEE-KID
A Volume Preserving Model
for Biomechanically-based
Muscle Volume Deformation
Michael Lacher
September 10, 2001
ii
Eidesstattliche Erklärung
Ich erkläre, dass ich die Diplomarbeit selbstständig verfasst, andere als die
angegebenen Quellen und Hilfsmittel nicht verwendet und mich auch sonst
keiner unerlaubten Hilfe bedient habe.
Hagenberg, im September 2001
Michael Lacher
iv
ABSTRACT
v
Abstract
This thesis uses 3D reconstructions of MR image data to simulate extra-ocular
muscles at different activation levels.
Traditionally, MR image data has been used to generate static 3D models
of muscles and organs. It is desirable to display such models of extra-ocular
muscles in the SEE-KID project, an ongoing work to create an interactive eye
motility diagnostics and surgery system, at the Department of Software Engineering for Medicine at the Polytechnic University in Hagenberg. However, in
this program the current length and activation of a muscle varies as the user
rotates the eye or changes the insertion points of muscles. Because of this, a
static muscle model is inappropriate.
To overcome this flaw, this thesis uses multiple reconstructions of the same
muscle, at different activations, to build a dynamic model of the muscle. This
model can then be used to generate a muscle volume and surface representation
for any given activation and length.
The model consists of two main parts. The first is the path of the muscle,
which is stored as a set of cubic Hermite splines. The second part is a radius
function which defines the muscle surface around this path. Using this method
both the muscle volume and surface are stored by the same function. Numeric
integration and scaling of the radius function is then used to ensure the volume
is preserved during the interpolation of the dynamic representation.
This thesis also contains the optimized rendering of the resulting muscle
volume. It employs OpenGL as a rendering platform to achieve a broad compatability with existing systems.
vi
KURZFASSUNG
vii
Kurzfassung
Diese Arbeit verwendet 3D-Rekonstruktionen von MR-Bilddaten um Augenmuskeln in verschiedenen Aktivierungszuständen zu simulieren.
MR-Bilddaten werden bereits jetzt in der Medizin verwendet um statische
3D-Modelle von Muskeln und Organen zu konstruieren. An der Abteilung für
Software Engineering für Medizin der Fachhochschule Hagenberg entstand der
Wunsch derartige Modelle von Augenmuskeln im SEE-KID Projekt darzustellen, einem längerwährenden Projekt zur Entwicklung eines interaktiven Augenfehlstellungsdiagnose und -operationssystems. Jedoch verändert sich die
aktuelle Länge und Aktivierung der Muskeln in diesem Programm wenn der
Benutzer das Auge rotiert oder die Insertionspunkte der Muskeln verändert.
Aus diesem Grund ist ein statisches Modell nicht verwendbar.
Um diesem Problem entgegenzuwirken, verwendet diese Arbeit mehrere Rekonstruktionen des selben Muskels bei unterschiedlichen Aktivierungszuständen
um ein dynamisches Modell des Muskels zu erstellen. Dieses Modell kann dann
benutzt werden um eine Volums- und Oberflächenrepräsentation für eine beliebige Aktivierung und Länge zu erzeugen.
Das Modell besteht im Wesentlich aus zwei Teilen. Der erste ist der Pfad des
Muskels welcher als eine Menge von kubischen Hermite-Splines gespeichert wird.
Der zweite Teil ist eine Radiusfunktion, welche die Muskeloberfläche rund um
diesen Pfad definiert. Mittels dieser Methode werden sowohl die Oberfläche des
Muskels als auch sein Volumen über die selbe Funktion definiert. Numerische
Integration und Skalierung der Radiusfunktion werden benutzt um das Volumen
während der Interpolation der dynamischen Repräsentation konstant zu halten.
Diese Arbeit umfasst ebenfalls die optimierte Darstellung des berechneten
Muskelsvolumens. OpenGL wird als Renderplattform eingesetzt um eine breite
Kompatibilität mit existierenden Systemen zu verwirklichen.
viii
ACKNOWLEDGEMENTS
ix
Acknowledgements
I want to thank all those who made this work possible. First of all I want to
express my gratitude towards Michael Buchberger who was my guide through
this work and also, with infinite patience, explained to me the medical details
of the eye and its mechanics as well as the internal details of the SEE-KID
project. Next I want to thank Herwig Mayr, who not only made this work
possible in the beginning but also took the task of correcting and grading it.
Furthermore I want to thank all the colleagues at the FORTE institude, you
were great people to work with.
Also I want to express my thanks to all my friends during the 4 years of
study at the Polytechnic University in Hagenberg, namely Martin “Scorpion”
Brandhuber, Elisabeth “Shiva” Fischer, Andreas “Sir Galahad” Fischl, Klaus
“drake” Gutenbrunner, Rolf “Buddha tm” Hornasek, Christoph “Murdock”
Huter, Thomas “Bommel” Kerbl, Anita “LaVic” Oberer, Peter “calia” Peltzner,
Thomas “Heani” Reitz, Klemens “Klemens” Wallner, Thomas “White Baron”
Weihs and Christian “Wicky” Wickhoff. You made these years a time of fun
and joy.
Next in line, I want to thank all the guys from the Gryps project. The work
I did for this project helped me a great deal with this work. Also this work
gave me a wonderful hobby over the last two years. I thank you guys, and I
am proud to be part of the team and also of what we achieved in the last two
years.
Of course my thanks also go to my parents and my whole family, whithout
whom I could not be here, and whom I am really proud of.
Last, but not least I want to say thank you and greetings to my old highschool buddies, Reinhold Kainhofer, Alexander Soucek and Tobias Triffterer
whom I see way too little in these days.
Mucki
^l^
O^m!
^
T
u, h r_dst
_Ts tm
if YA
ldj
s^
hlTt Yt
j
b_
ld Tr
u T ARL if m^
_ rC
ls
^
if T w_^il C_d. _it shlt b
C_
lR t T T A^
es if T m
^ jC
_ _in Cr^i_
tj AdR
fl ^id
^in
_ m
^ td p_C
trs. m^
eTt T
ub
^in ^iprDs
_ if T A^
es if T ^iR^
Cn
w_^il pAR iR ^i
l
if T ^iRt if _hl
_ j, T
u Alt f_d T_s tm
^in in^
wl
^ib
l w^
ult if YA
ldj,
frwR
i^
b
l _in TO d^
elO AR
C.
_ bd
_ T jd h^ilT ^id ^i_
ljmD
if T ^iR^
Cn
pAR, f
e^im!
^
t^l
s, l
_ b^
rr_^in if T j
eL if YA
ldj
x
ACKNOWLEDGEMENTS
Contents
1 Introduction
1.1 The SEE-KID Project . . . . . . . . . . . . . . . . .
1.2 A Dynamic Eye Muscle Model . . . . . . . . . . . .
1.2.1 Aspects of a Muscle Model . . . . . . . . . .
1.2.1.1 Volume Rendering . . . . . . . . . .
1.2.1.2 Volume Preserving Transformations
1.2.2 Historic Development of Muscle Models . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
2
2
3
5
6
2 Basic Notions
2.1 3D Graphics . . . . . . . . . . . . . .
2.1.1 3D Pipeline . . . . . . . . . .
2.1.2 Transformation and Lighting
2.2 Mathematics . . . . . . . . . . . . .
2.2.1 Splines . . . . . . . . . . . . .
2.3 Medical Terms . . . . . . . . . . . .
2.3.1 Bulbus and Orbita . . . . . .
2.3.2 Muscle Models . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
10
10
12
13
13
14
14
16
3 Muscle Volume Deformation
3.1 Input Data . . . . . . . . . . . . . .
3.2 Coping With the Amount of Data .
3.3 Muscle Model . . . . . . . . . . . . .
3.4 Volume Preserving Transformations
3.5 Rendering . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
19
19
21
25
27
29
4 System Design
4.1 Mathematical Model . . . . . . . . . . . . . . . . .
4.2 Muscle Volume Deformation . . . . . . . . . . . . .
4.2.1 Transforming Input Data . . . . . . . . . .
4.2.2 Dynamic Muscle Volume Generation . . . .
4.2.3 Render Optimization of the Muscle Volume
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
31
31
31
31
34
37
5 Implementation
5.1 Input Data . . . . . . . . . . . . . .
5.2 Coping With the Amount of Data .
5.3 Muscle Model . . . . . . . . . . . . .
5.4 Volume Preserving Transformations
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
39
39
42
43
43
xi
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
xii
CONTENTS
5.5
Rendering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
6 Testing and User Reports
51
6.1 Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.1.1 Verifying the Results . . . . . . . . . . . . . . . . . . . . . 51
7 Conclusion
55
7.1 Goals Achieved . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
7.2 Open Problems . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Literature
57
List of Figures
1.1
Comparison of conventional and pulley models . . . . . . . . . .
2.1
2.2
2.3
2.4
2.5
Rendering pipeline in DirectX 8.0
3D memory layout . . . . . . . .
Eye, overview . . . . . . . . . . .
String model . . . . . . . . . . .
Change of effect in string model .
3.1
3.2
3.3
3.4
3.5
3.6
3.7
Marching cube algorithm . . . . . . . . . . .
Marching cube classes . . . . . . . . . . . . .
Optimization of the marching cube algorithm
Intersecting planes . . . . . . . . . . . . . . .
Muscle model . . . . . . . . . . . . . . . . . .
Modified Hill-type model . . . . . . . . . . . .
Nearest neighbor vs. weighted interpolation of
4.1
4.2
Muscle model with visualization . . . . . . . . . . . . . . . . . . 32
Path and surface of the muscle . . . . . . . . . . . . . . . . . . . 34
5.1
5.2
5.3
Process of recreating muscle volume . . . . . . . . . . . . . . . . 44
Concept of the dynamic muscle . . . . . . . . . . . . . . . . . . . 45
One piece for calculating the volume . . . . . . . . . . . . . . . . 47
6.1
6.2
6.3
Dynamic muscle model . . . . . . . . . . . . . . . . . . . . . . . . 52
Dynamic muscle model with overlay of input model . . . . . . . . 53
Dynamic muscle model with overlay of MR images . . . . . . . . 53
xiii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
actual
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
11
12
15
17
17
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
volume
.
.
.
.
.
.
.
.
.
.
.
.
.
.
20
22
23
25
26
26
28
Chapter 1
Introduction
Whatever you can do, or dream you
can, begin it. Boldness has genius,
power and magic in it.
Johann Wolfgang von Goethe
With the advent of new, optimized graphics cards and powerful processors, three-dimensional graphics have entered the consumer market. It is now
possible to perform highly sophisticated visualizations on consumer machines,
which, a few years before, were only possible with specialized hardware. This
change of technology affects not only home users, but also business, research
and especially medical applications. It is now possible, to have complex tools
for evaluating data at a low cost and therefore providing these capabilities to a
wide range of people. This thesis concentrates on the volume preserving transformation of three-dimensional muscle models, specifically of the extra-ocular
muscle system. It will be shown that it is possible to perform such calculations
in an interactive manner on consumer machines.
This thesis was developed closely together with [Pirklbauer, 2001], which
covers the reconstruction of the three-dimensional muscle model from MR image
data.
1.1
The SEE-KID Project
This thesis does not stand alone, but is part of the SEE-KID project, a
Software Engineering Environment for Knowledge-based Interactive EyeMotility Diagnostics. This is an ongoing project at the department of Software
Engineering for Medicine of the Polytechnic University of Upper Austria, in
connection with the Austrian Ministry of Science and medical partners in
Austria, Switzerland and the United States of America.
1
2
CHAPTER 1. INTRODUCTION
The main goal of this project is to create a three-dimensional model and visualization of the human eye, which can be used to simulate eye muscle surgery.
This system can be used to evaluate possible operation strategies for a given
pathological case, as well as education and training purposes. Additionally all
cases are stored in a knowledge base, so the computer can aid the surgeon by
using this best practices database.
For more detailed information of the SEE-KID project we refer to [Buchberger and Mayr, 2000].
1.2
A Dynamic Eye Muscle Model
Currently, muscles in the SEE-KID environment are visualized as lines. While
this is suitable for displaying muscle paths and modifying insertion points, some
problems do not become apparent when only the path is drawn. In connection
with the oblique muscles there might be problems with certain insertion points,
because the muscle volumes of the musculus obliquus and one of the musculi
recti might intersect. It would therefore be desirable to display the volume of
muscles, instead of their path only. This thesis shows how eye muscles can be
visualized, by displaying activation-dependent muscle volumes. This information is important to surgeons, giving them a better preview of the results of a
treatment, and one can detect proximity problems, when two muscle volumes
would intersect each other in the simulation. This thesis presents a model that
provides a dynamic three-dimensional muscle model from a set of input images.
This model can be used to display the muscle in all states of activation with
desirable accuracy.
1.2.1
Aspects of a Muscle Model
Computer graphics have been used in industry and research from the early
stages of this field of computer research. The possibility to display and modify
graphical models on the computer without the need for a real prototype was
immediately recognized to be, both, cost and time effective. This is one reason
why the development of computer graphics was driven towards better methods
for displaying technical models and modifying them. One part of this area is the
simulation and testing of volumetric models. To be able to do this, a number of
different methods have been developed. They can be split into two categories:
• volume rendering: the storage of volumetric information and subsequent
visualization,
• volume preserving transformations: the modification of volumes in a physically meaningful manner.
1.2. A DYNAMIC EYE MUSCLE MODEL
3
In the following, a few of the most common methods are presented, along with
reasons why we did not choose to implement them in this thesis.
1.2.1.1
Volume Rendering
The difference between volume rendering and normal rendering does not lie in
the actual result that is displayed on the screen. Both methods usually display
the surface of the model. However, normal rendering methods do not store
any information about the volume of the model, they only store a definition of
the surface. Volume rendering methods, define the volume of the model, and
derive the surface from this definition. These methods are generally slower and
therefore used only when the volume data is changing frequently, or when the
definition of the surface is known only via the volume.
Most of the volume rendering methods are based on the idea of voxels. A
voxel is an acronym for “Volume Pixel” and is a logic extension of a normal pixel
into three dimensions. While a pixel is assumed to be a small rectangular area
of a two-dimensional image, a voxel is a small cuboid, and defines the smallest
possible unit in a three dimensional image. A voxel is normally a parallelepiped
and they are evenly spaced and distributed over the whole space. Each volume
in space can then be defined by voxels which lie totally or partially inside the
model. One of the major flaws of voxel models can be seen right now already:
it is an approximative model, and the error is proportional to the size of the
voxels.
Let si , i ∈ {x, y, z} be the length of a voxel in each dimension. Then the
error is e = 0.5 ∗ sx ∗ sy ∗ sz for each voxel which is partially contained in
the model in the worst case. The error per voxel scales linear to the volume
of the voxel, so if the side length is halved, in each dimension, the error is
reduced to one eighth. This however also increases the number of voxels in the
model and hence the number of partially contained voxels. In effect, the error
reduces only by 50% in the worst case. It is still possible to achieve any desired
maximum error, but the number of voxels in the model grows inversely cubic
to the accuracy. This way, accuracy is limited by memory and performance
constraints of the computer used to calculate the model.
To actually visualize an octree model, one needs to draw all contained voxels.
The simplest approach would be to transform each voxel into a cuboid surface
and render the resulting triangles. While this algorithm is reasonable, it lacks
performance, drawing the surfaces of all voxels, also those contained inside
the volume which cannot be visible, additionally it draws the surfaces of the
volume exactly as they are, which results in a rather jaggy outline of the object.
The second problem diminishes with rising accuracy, but the amount of hidden
voxels is then too big to allow suitable performance. One solution would be to
use extremely small voxels, so that each voxel, in essence, corresponds to one
pixel on the output screen. As a consequence there is no need to calculate the
surface of the voxel, as it will be rendered as one pixel anyway.
4
CHAPTER 1. INTRODUCTION
Neither of the two methods can generate correct surface normals. Surface
normals would have to be reverse engineered from the resulting set of surfaces/pixels. Without surface normals however, a useful lighting of the model
is not possible. While this may not be a problem in technical design, it is a
severe drawback when trying to achieve realistic imaging. To accommodate for
this flaw, there exists another method for generating the surfaces that actually
arose from the area of image recognition: the marching cubes algorithm. This
algorithm basically reconstructs a surface by analyzing voxels that lie on the
border of a volume. For a detailed description see Ch. 3.1. This algorithm
calculates surface normals and also smoothes out edges, introduced through
partially contained voxels. The speed of this algorithm depends on the amount
of time needed to decide if a given voxel is part of the model or not.
The direct solution of storing a list of all voxels contained in the object
leads to a linear complexity problem of classifying a voxel with respect to the
model. This can be reduced to logarithmic complexity by storing voxels in a
more efficient way in a tree structure. Each node in the tree has a maximum
of eight childs, representing a cuboid, which is partially or completely inside
the model. The leaves correspond to the actual voxels, while the internal nodes
are aggregations of those voxels. The cuboid of each internal node is split into
halves along each axis, and the resulting eight cuboids are its children, leading
to a fully expanded octreee strcture. To classify a voxel one needs to perform
the following steps:
1. See if the voxel is contained in the root node. If not then it is not part of
the model.
2. Make the root node the active node.
3. If the active node is a leaf, then the voxel is part of the model. Stop the
algorithm.
4. Determine the child that would contain the voxel.
5. If this child exists, then make the child the active node and continue with
Step 3, otherwise the voxel is not part of the model.
Steps 3 to 5 have to be performed at most k times where k is the depth of
the tree and
k ≤ log8 n
(1.1)
where n is the number of voxels in the model. Another optimization can be
achieved when using these trees to store the voxel information. Groups of eight
leaves which all lie inside the model and are all sons of the same internal node
can be removed and their parent becomes a leaf instead. This process can be
repeated until no further leaves classify for this optimization. If the original
voxels on the inside are needed for any reason (e.g. computing the volume),
then their presence or attributes can be easily derived from the parent nodes.
1.2. A DYNAMIC EYE MUSCLE MODEL
1.2.1.2
5
Volume Preserving Transformations
Due to the fact that most applications in computer graphics only render surfaces, they also store surface models only. As long as only non-deformable
transformations are applied, this is not a problem, because the volume is not
changed by them. If however, a model changes its shape, because it is bent
or stretched, these models cannot accurately calculate the result since they do
not know the volume of the object. If the volume and its distribution across a
model are known, then volume preserving transformations can be built. So, for
example, when a model is stretched into one direction, it would automatically
shrink in other directions. This way the model behaves much more realistic,
compared to pure surface representation.
Finite Element Method (FEM)
One of the basic methods used in the field of volume preserving transformations
is the finite element method. The basic idea is to describe a complex system
as the aggregation of small parts each of which can be simulated easily. There
are different types of elements which can compose the complex system, but the
most commonly used is a linear spring. The length of a linear spring is a linear
function of the force applied to it. For a one-dimensional spring,
f =K ∗u
(1.2)
where f is the force applied to the spring, K is the spring constant (a value
describing the stiffness of the spring) and u is the length of the spring.
This approach can be generalized in 3 dimensions by constructing “brick
elements”, elastic cuboids that behave like springs in each dimension. The
calculation now becomes
f~ = K ∗ ~u
(1.3)
where both force and displacement are three-dimensional vectors and K is a
3x3 stiffness matrix. In our case, the elements of the FEM model correspond
to the voxels in the initial configuration. As force is applied to the elements,
they are deformed so that each element still represents the same volume. It
is clear that the volume of the complete model is preserved as long as each
element preserves its volume. However, because the modules changed their
shape, they are now not necessarily parallelepipeds anymore. This breaks the
octree algorithm, and therefore a fast rendering of the object can no longer be
achieved with this method. Either a different rendering algorithm is used, or the
model is resampled into a suitable voxel space to be displayed. This combined
with the fact that FEM is slow because it has to perform the calculations for
each of the elements makes it not very suitable for real-time performance.
One advantage of the method is, however, that more calculations can be
done than only the preserving of the volume. [Zhu et al., 1997] uses the FE
6
CHAPTER 1. INTRODUCTION
method to build a dynamic muscle model by replacing the linear elements f~ =
K ∗ ~u with the second-order differential equation
M
∂~u
∂ 2 ~u
+C
+ K(~u)~u = f~(~u, t)
2
∂t
∂t
(1.4)
Using this representarion M describes the Mass, C the dampening and K the
stiffness of the elements. The equation is then evaluated to generate the displacement, movement and acceleration for the dynamics model. This method
is useful as it calculates and performs the volume preserving transformation in
the same step. This system is computationally even more intensive than the
static model, because solving the differential equation takes more time. Also,
this method is applicable only for voxel models. Other models would have to
be transformed into a voxel model before applying FEM.
In this thesis, the two main reasons for not using FEM are:
• The dynamic muscle model is not part of this thesis, but rather provided
by the SEE-KID project.
• The static case can be calculated using simpler methods, providing better
performance.
1.2.2
Historic Development of Muscle Models
The development of muscle models can be split into two separate areas. One
deals with the development of mathematical models, which describe the eye
and eye motility, the other provides improvement in visualizing these models,
using computer graphics or conventional models.
The first muscle model was the string model of [Krewson, 1950]. In this
model, muscles are modeled as strings, which are always pulled tight and take
the shortest path from the insertion point to their origin in the orbita. This
model is an acceptable approximation for gaze directions near the primary
position, but for other gaze directions, the point of tangency of the muscle
exhibits a very big side-slip.
Using the string model for simulating eye positions produces unwanted effects, because the muscles change the direction in which they apply their forces
in certain gaze directions. In the tape model, [Robinson, 1975] proposed to
limit the side-slip of the point of tangency and therefore stabilized the movement of the eye in extreme positions. The limitation of the side-slip was made
even greater in the restricted tape model ([Kusel and Haase, 1977]), which can
ensure a stable point of tangency for all possible gaze directions.
The tape models assume that muscles are held in place by intermuscular
membranes, which fix the muscle at the point of tangency more or less stable
to the globe. New models, however, use pulleys to describe this behavior; for
1.2. A DYNAMIC EYE MUSCLE MODEL
7
a reference see [Miller and Demer, 2000]. Pulleys are rings or sleeves of elastic
material which are affixed on the orbital wall. Thus, a pulley can be modeled
as a ring guiding the muscle at the point of tangency, which is connected to the
orbital wall by a series of springs. Fig. 1.1 illustrates this behavior.
Figure 1.1: Comparison of conventional and pulley models [Miller and Demer,
2000]
In the past, the globe and oculomotor system has been modeled with socalled ophtalmotropes. These are physical models, using a wooden sphere to
represent the globe and “rubber” muscles. With the advent of computer technology, the modeling of the human eye was moved more and more to the computer, because more complex and accurate models could be built. All these,
so-called biomechanical models aim at the simulation of the oculomotor system in an anatomically meaningful manner. While this is suitable for research
and education, these models do not lend themselves to easy parameterization.
Therefore it is difficult or impossible to use them for physicians to model different pathologies or to simulate surgeries.
The SEE-KID project tries to build a virtual reality environment that can
be used to display any given pathology and therefore needs to be very dynamic.
It uses a graphical model in which the anatomy of the human eye and orbita are
modeled as separate entities, all of them controlled by a mathematical model.
8
CHAPTER 1. INTRODUCTION
The display is less realistic to improve rendering speed and allow interactive behavior of the system. We are, however, continually improving the visual quality
of the model, to provide a better environment for the surgeon or student.
Chapter 2
Basic Notions
The known is finite, the unknown
infinite; intellectually we stand on an
islet in the midst of in illimitable ocean
of inexplicability. Our business in
every generation is to reclaim a little
more land.
Thomas Henry Huxley
As this thesis is interesting for medical applications as well as for 3D modeling purposes, the readers are expected to come from a variety of fields. To
facilitate the understanding of this thesis, this chapter contains basic knowledge needed to understand the techniques presented lateron. The information
presented here does not contain anything directly related to the problems discussed in this thesis. If you already have expertise in one or more of the areas
presented here, you may skip them without problems.
This chapter gives an overview over the basic concepts of three-dimensional
computer graphics. This is especially important as the description of the render
optimizations, later in this thesis, depends heavily on a basic understanding of
current render architecture. If the rendering part of this thesis is of no interest,
then you may skip this section.
The next section gives an overview of splines and the mathematical concepts needed; finally the last section contains the necessary medical background
needed to understand the problem area of this thesis.
9
10
2.1
CHAPTER 2. BASIC NOTIONS
3D Graphics
In the last few years, development in the area of interactive 3D graphics have
revolutionized the development, as well as the complexity, of visualizations on
the entertainment market as well as on the scientific market. The increased
power of computer hardware and newly developed techniques allow an increasingly realistic level of detail combined with short response times for true interactive presentations. The SEE-KID project utilizes some of these advanced
techniques to render calculated muscle volumes in a realistic and interactive
way.
This section is intended to give an overview of the current development
in this area and how it can be used to generate high performance computer
graphics. It covers only essential parts used to deal with the problem field of
the presented paper. If a more detailed overview of this topic is required, see
[Eberly, 2001].
2.1.1
3D Pipeline
The system layout of typical 3D rendering pipelines has changed to reflect the
development in the field of graphics. One of the most important improvements
was emphasizing the graphics-processing chip as a standalone processing unit
on consumer systems. A fully programmable CPU on the graphics controller
now handles more workload of the rendering process. This not only increases
the performance, but also makes the system more flexible.
In the beginning, the only task of the graphics controller was to hold a memory buffer with the data that is to be displayed and transfer it to the screen. The
CPU performed the whole process of rendering. This allowed great flexibility
but also meant a great deal of work because most of the things needed to be reprogrammed by the individual developer. Due to the fact that many parts of a
3D rendering engine are very similar for each implementation, 3D programming
libraries, like OpenGL, were developed to simplify the construction of graphics
applications. After these standards were accepted by the industry, the “rendering pipeline” evolved as a common model for 3D applications. This model
partitions the whole rendering process into a series of encapsulated steps, each
with defined input and output, allowing different components in the computer
to take over the workload of these parts.
Soon afterwards, hardware manufacturers began implementing parts of the
3D rendering pipeline in hardware to accelerate performance. Due to the way
the pipeline was designed, it could only perform one operation out of a number
possible for each step. This was easy to implement in hardware because each
step consisted of a fixed number of functions, each of which was implemented
in hardware. While this system allowed cheap hardware acceleration and supported the mainstream of applications, it was not suitable for special needs.
2.1. 3D GRAPHICS
11
Those had to be implemented in software, without any acceleration at all. Accounting this problem, nVidia, in cooperation with Microsoft, has developed a
new pipeline layout and accompanying chipset, which is fully programmable.
In this design the Pipeline mainly consists of two parts, the transformation and
the rasterizer. The transformation part is in essence a 4-element vector computer, specialized for transforming 4 dimensional vectors with 4x4 matrices.
Thus it has all the possibilities needed to transform 3D geometry and perform
lighting calculations. The rasterizer takes the output of the transformation and
convertes the geometry into pixels on the screen. It is optimized for standard
arithmetical operations and blending functions.
Figure 2.1: Rendering pipeline in DirectX 8.0 [Microsoft, 2001]
Both parts have their own assembly language that let the user program
almost any effect for these parts. Because they are programmed in assembler
they can be compiled to run on the normal CPU as well as on special hardware. State of the art graphics accelerators combine the flexibility of a fully
programmable design with the simplicity of the 3D pipeline. Fig. 2.1 shows
how the rendering pipeline is implemented in DirectX 8.0 from Microsoft. This
design already incorporates the new programmable pipeline, but also allows
programs to use the older fixed function pipeline layout.
12
2.1.2
CHAPTER 2. BASIC NOTIONS
Transformation and Lighting
In the context of 3D computer graphics, hardware processing, as opposed to
software processing, means that the computation is not performed by the CPU
but by some specially designed chip on the graphics controller.
While the most important performance optimization in interactive graphics,
(“do only draw as much as you absolutely need to”) is also true for hardware
transformation and lighting, there are several other aspects of program design
which can greatly increase rendering speed. The most important aspect is the
layout of the data in memory. See Fig. 2.2 for the following explanations.
Figure 2.2: 3D memory layout
With software processing it was most important to place the data in a
memory part that was quickly accessible by the CPU. This was normally an
area in the main memory which was cacheable by the CPU (1). Because the
memory was easily accessible by the CPU it could be set up for read/write
access without performance penalty. Also the layout of data in memory can be
set up in any way suitable for the application, although aligning the data in a
serial manner can increase performance through caching effects.
The next step in hardware acceleration was to implement the rasterization
part of the fixed function pipeline on the graphics chip. In this scenario the best
memory location for the geometry data is still the cacheable main memory, but
the transformed geometry needs to be sent to the controller and, thus, should
either be stored directly in memory on the graphics controller or in memory
which is quickly accessible by the controller (2). The same is true for textures.
For best performance textures are created directly in video memory on the
graphics controller. But as this memory is typically limited, they are created
in Accelerated Graphics Port (AGP) memory (3) and are sent to the card as
needed.
2.2. MATHEMATICS
13
The next step is hardware-accelerated transformation and lighting. In this
case, the graphics controller performs all steps of the 3D rendering. Thus also
the input data needs to be set up in a memory area that is quickly accessible
by the graphics controller. This method brings one major problem: These
memory areas typically have very slow read access. Therefore they are not
suitable for storing data with which the application is working. Because the
video and AGP memory is limited, the geometry data should not be interleaved
with application data. This way, if applications need dynamically generated or
deformed geometry, they have to maintain two copies of the data. One in system
memory, where it can be processed and modified by the program as needed, and
one in video or AGP memory. The second copy is most often referred to as the
vertex buffer. It contains only the corner points of all the polygons that define
the geometry to render, along with color information and texture coordinates
for that point. These vertex buffers usually have write-only access for the CPU
and are synchronized with the system memory copy each time the geometry
changes. To save additional space and processing time, vertices that are used
more often are stored only once and referred to by indices. This is especially
important as the chipsets often implement a post-transformed vertex cache.
Hereby, the transformed vertices are stored in a cache and, if the same vertex is
retransformed, then the cached copy is used instead of transforming the vertex
again. This way a properly ordered vertex buffer can greatly increase rendering
performance.
2.2
Mathematics
As this thesis is presenting a method which tries to be not only accurate but
also optimized for computerized calculation, it is necessary to keep a simple
mathematical formulation. Especially symbolic computation is not suitable,
thus numerical methods must be used. Due to this, most calculations in this
thesis do not require complex mathematical subjects.
However a method for representing arbitrary curves in three-dimensional
space is needed. Splines are an excellent way to represent curves and need little
computational effort. Their definition by a few parameters makes it easy to
store and manipulate them. The basics needed for this thesis are laid out in
this section. For a more detailed explanation we recommend [Mortenson, 1999]
and [Jordan and Smith, 1996].
2.2.1
Splines
Splines are a way to approximate functions whose exact definition is unknown.
They are normally defined be a series of conditions. This thesis uses cubic
Hermite Splines to define the muscle path. Hermite splines are defined by 4
parameters: start- and endpoint, and additionally the tangents (i.e. the first
14
CHAPTER 2. BASIC NOTIONS
derivative) in these points [Mortenson, 1999]. If we name these parameters
p0 , p1 , t0 , t1 respectively, we can use the following representation:
h(0) := p0
(2.1)
0
h (0) := t0
(2.2)
h(1) := p1
(2.3)
0
h (1) := t1
(2.4)
To calculate h, we define h(x) := ax3 + bx2 + cx + d. This leads to the
following correlation of the coefficients with the parameters:

 
p0
0 0
 p1   1 1

 
 t0  =  0 0
t1
3 2
0
1
1
1
By calculating the inverse of the matrix,
the parameters:
  
a
2 −2 1
 b   −3 3 −2
 =
 c   0
0
1
d
1
0
0

a
1
 b
1 

0  c
0
d




(2.5)
we can get the coefficients from

1
p0


1   p1
0   t0
0
t1




(2.6)
The reason, why hermite splines are used instead of cubic polynomials is
that continuity is achieved more easily with splines. Simple continuity is given
when end- and start points of two splines are the same. If the tangents in the
end and start point are the same then the first derivations are continuous.
2.3
Medical Terms
Special conditions of the extra-ocular muscle system, with respect to skeletal
muscles, have strong influence on the way the underlying work of this thesis
was designed and on the algorithms chosen. It is therefore vital to have a basic
background in the anatomy of the eye and its surrounding structures. Equally
important is an overview of historic developments of models that are used to
describe the rotation of the eye together with forces of the muscles.
2.3.1
Bulbus and Orbita
Fig. 2.3 shows an overview of the right eye. It depicts an orbital cut showing
the bulbus, muscles and the orbita. The oculomuscular apparatus consists of
six muscles. Four of them are straight muscles:
2.3. MEDICAL TERMS
15
Figure 2.3: Eye, overview
• musculus rectus superior,
• musculus rectus inferior,
• musculus rectus medialis,
• musculus rectus lateralis.
All originate at the anulus tendineus communis, a small ring of sinews at the
end of the orbita. From there the muscle follows a straight path to the bulbus
and inserts before the equatorial plane of the eye. Their functions are to turn
the bulbus up-, down-, in- and outward respectively.
In addition there are two diagonal muscles:
• musculus obliquus superior,
• musculus obliquus inferior.
Like the straight muscles, the m. obl. superior also has its origin at the anulus
tendineus communis, but follows the orbita wall to a muscular trochlea. From
there, it takes a straight path to the insertion point, directly behind the m.
rec. superior. The m. obl. inferior has its insertion point behind the m. rec.
lateralis. From there it leads to its origin in the front part of the orbita, near
the nasal bone, passing across the m. rec. inferior. At the junction of the m.
rec. inferior and the m. obl. inferior, both muscles are connected by a sinew:
the ligamentum Lockwood.
16
CHAPTER 2. BASIC NOTIONS
The whole system is embedded in a soft, fatty tissue. This is for stabilizing
the bulbus and the muscles. Additionally, the muscles are held in place by
connective tissues and intermuscular membranes. They are especially important
in the area of the point of tangency, where the muscle leaves the bulbus. There
they keep the point of tangency in place and ensure that the force of the muscle
affects the bulbus in the same direction, regardless of the current gaze position
(cf. Ch. 2.3.2).
2.3.2
Muscle Models
The modeling of the oculomuscular system has greatly improved over the last
years. The first model used for describing eye muscles was the string model
by [Krewson, 1950]. In the beginning, a simple string model was used. Each
muscle was assumed to be a thin, elastic string and its insertion on the bulbus
was modeled as a single point. These strings are always pulled tight, and
therefore take the shortest path from the insertion point to their origin in the
orbita
In this model, force of a muscle is applied at the insertion point, where the
muscle leaves the bulbus. When I denotes the insertion point, M the center of
the bulbus and U the origin of the muscle in the orbita, then the muscle lies in
the plane defined by
r~I := I − M
(2.7)
r~U := U − M
(2.8)
The normal vector of this plane
m
~ :=
r~I × r~U
|r~I × r~U |
(2.9)
is the rotation axis, around which the bulbus is rotated by this muscle (Fig. 2.4).
While the accuracy of this model is acceptable while the bulbus is in or near
primary position (not rotated), it becomes less accurate in positions that are
rotated far out of the primary position. Because the muscle takes the shortest
path from the origin to the insertion point, the point of tangency moves on the
bulbus, and in extreme cases the muscle can “flip over” and reverse its effect
(for instance start turning eye outward instead of inward). Fig. 2.5 gives a
schematic overview of this problem.
To accommodate for this flaw, [Robinson, 1975] suggests a tape model in
which the movement of the point of tangency is limited. To achieve this, the
model limits the angle α by which the point of tangency can move from the
original position. If T denotes the insertion point in primary position and Tstring
is the point of tangency in the string model, then
αmax := ∠T ITstring
(2.10)
2.3. MEDICAL TERMS
17
Figure 2.4: String model
Figure 2.5: Change of effect in string model
18
CHAPTER 2. BASIC NOTIONS
is the maximum possible angle the insertion point can move. Robinson limits
this angle by multiplying αmax with the amount of rotation from the primary
position :
α := αmax ∗ |sin |
(2.11)
Due to this limitation in the tape model, the unreel strain from the point of
tangency to the insertion point does not follow a great circle but some arbitrary
circle on the bulbus.
The tape model therefore prohibits muscles from “flipping over”, but the
point of tangency still moves on the bulbus and in tertiary gaze positions,
rotated very far from the primary position, the effects continue to differ from
anatomical expectations. To resolve this, [Kusel and Haase, 1977] proposed the
restricted tape model. This model reduces the angle α again so that
αrestricted :=
α
10
(2.12)
With this restriction, the point of tangency stabilizes throughout the complete
physiologic field of vision.
Chapter 3
Biomechanically-based Muscle
Volume Deformation
Don’t tell people how to do things. Tell
them what to do and let them surprise
you with their results.
George S. Patton
In this chapter the general layout of the system is presented. The main
emphasis lies on giving the reader a structural overview over the different components, and how they work together. An overview of the algorithms used is
given in chapter Ch. 4 and the implementation details are covered in chapter
Ch. 5.
3.1
Input Data
Besides the path of a muscle, which is already defined by the SEE-KID application, the most important information about a muscle, for this thesis, is its
volume and the distribution of its volume. We also need to know how the distribution of the volume changes with changes in muscle activation. While it is the
topic of this thesis to calculate the shape of the muscle at different activations,
starting information is still needed, so that the system does initially know how
the muscle looks like.
To provide this information, the system uses a three-dimensional representation of MR images for calculating the basic parameters of the muscles. This
data, constructed from a set of MR images, each representing a slice of the
muscle, defines the surface and thus the volume of the model. Only a short
overview of how these models are created is given here, for a more detailed
19
20
CHAPTER 3. MUSCLE VOLUME DEFORMATION
discussion see [Pirklbauer, 2001].
The basic method used for constructing three-dimensional models is the
marching cube algorithm. The idea of this algorithm is to generate a continuous surface of the muscle by analyzing the relationship of neighboring points in
space. Each point is classified as either inside or outside of the volume. Surfaces
are created completely between points, situated on opposite sides. This process fills an area in 3D-space with a large number of small cubes, determining
which corners of the cubes lie inside or outside of the volume. According to a
predefined set of rules, this information can be used to generate a continuous
surface, which approximates the surface of the original volume with an accuracy
inversely proportional to the size of the cubes.
To achieve this goal, the marching cube algorithm creates a series of planes,
intersecting the object. They are all parallel to each other and evenly spaced.
Then, for each plane, the parts that lie inside and outside of the object are
determined. In our case this is done by assigning an MR image to each of the
planes. Pixels of the image with a certain color are defined to be inside while
others are outside. The value of the points between the planes is assumed to
be of the same value as the nearest pixel. The result of this step is a volume
representation where each pixel represents a small cube either (partially) inside
or outside of the original object.
Figure 3.1: Marching cube algorithm [Pirklbauer, 2001]
To determine the surface of the object, the algorithm assigns each possible
group of eight neighboring pixels to the corners of a group. See Fig. 3.1 for a
detailed representation of this step. Because the cube has eight corners and each
corner has to be in one of the two states, 28 = 256 possible cube configurations
exist. Each of these configurations defines if and how the surface passes through
the cube. This number is quite high, but it can be shown that by rotation and
3.2. COPING WITH THE AMOUNT OF DATA
21
inversion of the corners, each of the different cubes can be mapped to one of 15
classes, as shown in Fig. 3.2. To generate the surface, the algorithm performs
the following steps:
1. Determine the state of the corners from the pixel values.
2. Find a transformation T that transforms the actual cube, matching one
of the 15 predefined classes.
3. Build a set of triangles, representing the surface passing through this cube.
4. Transform the triangles using the inverse transformation T −1 from step
2.
5. Add triangles to the set that contains the already constructed surface.
After performing these steps for all possible cubes, the result is a set of triangles,
describing the surface of the object. It is obvious from the above layout that for
k images of size m × n, the asymptotic runtime of this algorithm is O(k ∗ m ∗ n).
It is therefore desirable to keep the images as small as possible.
The implementation of the marching cubes algorithm performs another optimization to produce a smoother surface [Pirklbauer, 2001]. It is not only
classifying the corners of a cube as inside or outside, but also determines how
far inside or outside each corner is by evaluating the specific color value of each
pixel. Pixels with color values near a given threshold are assumed to be nearer
to the surface then pixel values far from the threshold. The algorithm is then
moving the corner points of the surface parts inside or outside, depending on
the ratio of the distances of the corners of the cube. This is especially important
when the area of the muscle crossection is getting rapidly smaller from one MR
image to the next. Fig. 3.3 illustrates such a case and shows the difference of
the two methods using a two-dimensional example.
3.2
Coping With the Amount of Data
Our input data is represented using DXF files, and each triangle is stored as a
single primitive within the file. While this representation is interchangable and
easy to generate, it is very insufficient in terms of memory usage and render
speed. Additionally, the data structure does not contain any connectivity or
volume information. Since the last two points are very important for our thesis,
the input data needs to be transformed into a more suitable representation.
The first step is to find connectivity information. For this purpose a simplified boundary representation method is used. Because the surface is built
from triangles only, there is no need to store edge information but only triangles
and corners. In order to build a usable data structure, the input file is transformed into a list of triangles. Corner points of two or more triangles, which
22
CHAPTER 3. MUSCLE VOLUME DEFORMATION
Figure 3.2: Marching cube classes [Pirklbauer, 2001]
3.2. COPING WITH THE AMOUNT OF DATA
23
Figure 3.3: Optimization of the marching cube algorithm
are within a certain limit of spatial proximity, are welded together. The boundary representation is then transformed into an indexed triangle list. In this
form, connectivity information can still be gained from the list, but at a higher
cost. However, this representation is ideal for current rendering hardware. It
also provides a good starting point for creating exactly the data structure we
need. A copy of this representation is kept so that the original DXF model can
be displayed in the program for comparison with the dynamically generated
muscle.
When the input data has been transformed into a data structure that can be
quickly displayed, restoration of the volume information is still needed. Before
deciding how to do this, another constraint from the thesis should be taken
into consideration: The volume needs to be dynamically transformed, and this
transformation should be volume preserving. The way the surface is defined
now it fits neither one of the two conditions. Given two volume models of the
same muscle in two different activation states, the actual goal is to generate a
new model in an intermediary state by interpolating between the states. The
two surface representations do however not contain any topology information.
The positions of the triangles of one surface are not connected in any way
with the position of the triangles on the other surface. Thus, identification of
matching points before each interpolation step would have to be done.
To overcome this flaw the final model needs to contain topological data as
well as volume information. The following information can be identified as vital
for interpolation:
• position and orientation of the muscle in space,
24
CHAPTER 3. MUSCLE VOLUME DEFORMATION
• length of the muscle,
• activation of the muscle,
• volume of the muscle.
The first two points are very important to distinguish muscle movement
and muscle volume deformation in a set of input models. This distinction is
especially important since the interpolation of position and volume works in an
entirely different way. Activation cannot be extracted from the input model
itself but has to be supplied from some external source (e.g. from the physician
who took the MR data). The volume does not only contain the current volume
of a muscle, but also information on how the volume is distributed along the
muscle.
A set of one or more connected Hermite splines is used to represent position,
orientation and length of the muscle. Let P (d) : R 7→ R3 be this path. To
calculate the path, the muscle is devided into several slices. These parts are all
perpendicular to the longest axis of the muscle. The slices are spaced evenly and
are positioned in a way so that all the points in one slice belong to triangles of
one MR image from the marching cube algorithm. The path is then calculated
by repetitive cubic regression, so that the mean square error is below a certain
threshold.
Once the muscle path is established, a function
R(d, φ) : R × R 7→ R
(3.1)
defines the radius of the muscle with respect to the path. Hereby d is the
distance along the path and φ is the angle around the path. Thus, for each
d, R defines the radii of a set of points, all of them contained in a plane that
also contains P (d). The intuitive idea would be to make these planes normal
to the tangent of the path P 0 (d). With this method however, some points on
the surface cannot be correctly categorized. Fig. 3.4 shows how planes can
intersect in this model. Because of this property, one can get problems with
exactly defining the volume and also with specifying the exact function in the
first place. To improve the situation, all planes need to be parallel to the cuts
used for generating the path. This way, the planes itself are parallel and cannot
intersect and also the function can easily be derived from the indexed triangle
list.
This representation is now easy to interpolate because each radius of each
model can be mapped one-to-one to a radius on another model. Furthermore,
the transformation of the muscle
R model can be forced to be volume preserving
by ensuring that the integral R(d, φ) is equal in the dynamic model and in
the input models.
3.3. MUSCLE MODEL
25
Figure 3.4: Intersecting planes
3.3
Muscle Model
This thesis only covers the area of calculating muscle shapes for a given activation and length, and the visualization of the resulting muscle volume. It is not,
however, concerned with the calculation of the current activation and length
of the muscle. The actual length changes are given by the SEE-KID system,
which uses a feedback-driven muscle simulation to determine the length and
activation of each muscle.
When a muscle is activated it contracts and changes its length. If however,
the length of the muscle is fixed, then an activation of the muscle does not
result in a length change, but instead the muscle exacts a force onto the two
fixing points. This force is called tetanic force. The tetanic force of a muscle
depends on its length and activation. The length, at which with for maximum
activation the muscle generates maximum force is called the optimum length l0 .
The force at this length is the maximum tetanic force f0 .
The output of the muscle simulation is the force of the muscle for a given
time in units of f0 . The forces are then transformed into rotations by the
biomechanical model, and the rotations are in turn evaluated into passive length
changes of all 6 extra-ocular muscles. The passive length changes are then
fed back into the muscle simulation and are used with the new activation to
calculate the updated forces of the muscles. This iteration stops when the forces
of the muscles reach an equilibrium at which time the eye has reached a stable
position. Fig. 3.5 shows this cycle and its components.
The muscle simulation is based on a Hill-type model, which is depicted in
26
CHAPTER 3. MUSCLE VOLUME DEFORMATION
Figure 3.5: Muscle model [Buchberger and Mayr, 2000]
Figure 3.6: Modified Hill-type model [Cheng et al., 1999]
3.4. VOLUME PRESERVING TRANSFORMATIONS
27
Fig. 3.6. It extends this model, however, and tries to specialize it for extraocular
muscles. To do so, it mainly changes the contractile element. It adapts the forcelength and force-velocity relationships, based on work by [Miller and Demer,
2000]. While [Miller and Demer, 2000] only uses a static model, this simulation
uses a dynamic model to incorporate the time component.
Three pieces of information are actually taken as input from the SEE-KID
system for this thesis:
• current activation of the muscle,
• current length of the muscle,
• current path of the muscle.
These data are used to calculate the new muscle shape for any given activation. This may be done once the equilibrium is reached or during the iteration,
depending on the goal of the visualization. This thesis does not actively change
any of these values, so the visualization can be performed anytime without
disturbing the iteration process.
3.4
Volume Preserving Transformations
One of the key points in generating correct, realistic interpolations of muscle
volumes, and therefore also one of the main features in this thesis, is the preservation of the muscle volume during the transformation. This is necessary so
that the user always has a plausible picture of the muscle, and how it affects
its environment. This leads to the following three border conditions of this
problem:
• Volume must be preserved during transformations.
• Volume information has to be derived from input models only.
• The algorithm for transformation must be suitable for interactive rendering.
A good method to improve calculation speed would be to precalculate functions for the distribution of the muscle volume, and other parameters that help
building a correct model at runtime. The second aspect, however, prohibits this
way of optimization as it would require user input from a person with in-depth
understanding of the subject, or alternatively would require extensive preprocessing of the input images. Neither of them is suitable for the application, and
therefore the program has to take its information from the input models.
This, however, leads to another problem, which is not initially apparent.
The process of creating the input models is using the marching cube algorithm.
28
CHAPTER 3. MUSCLE VOLUME DEFORMATION
For this algorithm to work, it needs to identify each pixel on the input images as
either inside or outside of the muscle volume. It does this by assigning threshold
values to them, which classify pixels within a certain color range as inside. While
this is a common technique, it leads to problems in this application. The border
of the muscle in the image is not sharp, but is blurry, and actually is a short
gradient of colors. Depending on the threshold, the marching cube algorithm
classifies more or less pixels as inside and therefore is changing the volume.
This is not necessarily a problem using a static image, as it only makes the
muscle grow or shrink by a small percentage value. Because the different input
models used in this thesis are from different sets of input images, it is easily
conceivable that the image sets vary lightly in brightness and contrast. Furthermore, the image sets will use different threshold values during the marching
cube steps. It can therefore not be proven, and it is actually very unlikely, that
all input models have the same volume to start with. And, as the program has
no ability to decide which model has the most correct volume, it cannot prefer
one model.
There are multiple ways to accommodate, all however have to make a tradeoff between accuracy and visual quality. The first would be to make the transformation really volume preserving, taking the volume of one of the two input
models used in the current interpolation step. This could for example be the
one nearest in activation to the current dynamic model. While this is correctly
preserving the volume during transformations, at least during continuous segments of activation, it produces visual artifacts when the reference volume is
switched from one model to the next. Fig. 3.7 illustrates this behavior.
Figure 3.7: Nearest neighbor vs. weighted interpolation of actual volume
To provide a better visual quality, especially during animation of the activation state, this thesis is interpolating the muscle volume linearly between the
input images. This way the transformation is not actually volume preserving,
but it provides better visual quality and is equally correct for all input images.
3.5. RENDERING
29
An alternative method would be to calculate the average volume of all input
models, and use this as volume for the dynamic model. While this prevents
jumps in volume, and is volume preserving, a result that has exactly the same
activation as one of the input models does not have to have the same volume
as the input model.
Therefore the steps during the transformation are as follows:
1. Determine the path of the muscle for the current activation.
2. Determine the distribution of the volume for the current activation.
3. Build a muscle volume, using the interpolated path and the interpolated
distribution.
4. Determine the volume for the current activation from the input models.
5. Determine the actual volume of the interpolated distribution.
6. Apply a scale operation to make the volume of the interpolated distribution the same as the desired distribution.
The scaling in step 6 is uniform. This way it can be ensured that the distribution as well as the volume is exact. The way the volume is defined and
stored also ensures that it does not change by modifying the muscle path. This
partitioning into three independent subproblems allows the independent calculation of each feature and combination afterwards. This way the algorithm
for each subproblem can be kept simple and therefore guarantees acceptable
performance.
3.5
Rendering
As this thesis provides a basic mechanism for interpolation of static muscle
images, it is desirable to keep its output at a generic level. This way it can be
used by different systems without any problems. However, it is also the goal
of this thesis to build a system that is capable of interactive rendering, and
therefore needs to optimize the rendering process itself. Since optimizations in
computer graphics are based mainly on extensive knowledge about the model to
render together with its intrinsic properties, generic usability is being restricted.
To provide good trade-off between speed and generality, this thesis takes
over the complete rendering of the model, but uses the OpenGL generic render
platform, which is widely used in professional visualization. Thus, it is possible to specialize the rendering process, and still use OpenGL as the primary
platform. The only thing that needs to be done by the application is to set up
OpenGL correctly and set a suitable world transformation, so that the model
is rendered at the correct location on the screen.
30
CHAPTER 3. MUSCLE VOLUME DEFORMATION
To give the calling application the possibility to customize how the model
should be displayed, only the most important render states are set by this
thesis. Everything regarding image quality can be set by the calling application.
Furthermore, each part of the model is developed as its own class, and each such
class has its own rendering method. Therefore, the application allows the user
to choose which parts to draw, and how detailed to visualize them. The parts
which can be selected for display are:
• Input models: The copy of the indexed triangle list, saved during the
input process of the DXF file.
• Parameters: The muscle path, with its tangents, for each input model
and the dynamic model.
• Muscle Volume: The muscle volume (i.e. transformed radii) for the dynamic model.
• Input Images: The images used for the marching cube algorithm.
The first and last part exists only for input models, while the third part exists
only for the dynamic (i.e. output) model. The parameters exist for both models.
For input models, the user can select which input model, or which combination
of input models, to draw.
The input images are projected into three-dimensional space, so that they lie
in the planes they were assumed to be in during the marching cube algorithm.
This way the result can be directly compared against the original input images.
The user can select if he wants all input images to be displayed or only specific
images. In the latter case, he can also choose which of them he wants to display.
Chapter 4
System Design
I am always doing that which I can not
do, in order that I may learn how to do
it.
Pablo Picasso
4.1
Mathematical Model
We use the data from the SEE-KID muscle simulation system as input for the
muscle visualization. To get this data, we need an interface to this system. To
this end, we incorporate our muscle into the iteration process. Fig. 4.1 shows
how our work fits into this process, and which components are used to get the
data outlined Ch. 3.3.
4.2
Muscle Volume Deformation
This chapter describes the algorithm used to generate the parameterized representation of the muscle volume, how this model is transformed, interpolated,
and how the results are rendered in an efficient way.
4.2.1
Transforming Input Data
As laid out in Ch. 3.2, the input data is transformed via various steps to a representation that stores, both, path and muscle volume. This section describes,
how this transformation is actually done in the program. For the actual implementation see Ch. 5.2. In the following, the algorithms used and a sketch how
31
32
CHAPTER 4. SYSTEM DESIGN
Figure 4.1: Muscle model with visualization
they interact are presented.
The first step is the generation of the boundary representation from the
input files. For this the DXF files are read and stored in a list of points.
Although the DXF file format is not specified this way, the file structure can
be transformed into a grammar, suitable for parsing with recursive descent
or similar methods. This method was chosen because it allows easier error
handling and is generally more stable than normal processing.
In this case the complete geometry is stored as a sequence of planar quadrangles. Most or all of these quadrangles are degenerated, however, and are
actually triangles. Because the DXF format represents, both, triangles and
quadrangles as quadrangles, the geometry is stored as a list of points containing consecutive groups of 4 points, whereby each group defines one primitive
(i.e. a triangle or a quadrangle). After the whole file has been parsed, each
primitive is analyzed and a triangle structure is generated for it. In this process
quadrangles are split into two triangles.
Each triangle contains references to each of its corner points; likewise each
point has a list of references to the triangles it is a corner of. The corner points
are stored in a separate list. Subsequently the list of points is analyzed and
points whose distance is below a certain threshold are welded together. The
welding replaces all points that are to be welded together with a new point,
which is the geometric average of these points. It can be shown that, because
of the way the marching cube algorithm works, points are either equal to each
other, or have a spatial distance which is higher or equal to 0.5∗ δ where δ is the
smallest distance between two pixels in the stack of images used [Pirklbauer,
2001]. Due to this, as long as the threshold for the welding is smaller than
0.5 ∗ δ, the resulting set of triangles will describe the same (intended) volume
as the triangles in the DXF file.
4.2. MUSCLE VOLUME DEFORMATION
33
The boundary representation can be transformed in linear time into an
indexed triangle list. This list actually just eliminates the references from the
points to the triangles. Neighboring triangles can still be identified by searching
through the list of triangles and looking for references to the same corner points.
This is slow, but this lookup is not needed anymore in the processing of these
points. Because the model can be stored with a small amount of memory, and a
linear traversal over the primitives can be used to display them all, this method
of storing geometry is widely used in today’s rendering applications. A copy of
the indexed triangle list is kept, so that it can be displayed for comparison with
the dynamically generated model.
The next step is to calculate the muscle path. We build an isothetic parallelepiped that bounds the muscle exactly and find the longest dimension of it.
The muscle is then cut into equally spaced slices along this dimension. The cuts
are spaced evenly and positioned in a way so that each slice contains points,
which are defined by exactly one input image into the marching cube algorithm
(i.e. the cuts lie exactly between the planes where the images for the marching
cube algorithm would be). The center of gravity of each slice is calculated and
the resulting set of points is approximated by a series of Hermite splines. The
algorithm is generating splines by using cubic regression on the points, starting
with one spline and recursively splitting and adding splines until the whole set
of splines satisfies a least mean square threshold. The splines are generated
in a way so that c1 continuity 1 can be guaranteed over the whole path. The
complete path is then defined to be a function P (d) : R 7→ R3 , where P (0) is
the beginning of the muscle and P (1) is the end.
After the complete path is established, the radius function R(d, φ) is defined. Actually the function is specified at some points only, and the rest is
interpolated. The number of points can be chosen in the program. The more
points are used, the more accurate is the result, but it also gets computationally
more expensive. Fig. 4.2 shows the path and surface of a muscle. A grid-like
distribution of the points is used, where the grid is aligned to d and φ. The grid
is spaced evenly in both directions. The maximum useful grid resolution along
d is to use one step for every image used for the marching cube algorithm. The
maximum useful resolution along φ is so that the radii are defined for each pixel
on the circumference of the muscle in the images used for the marching cube
algorithm. To achieve a good rendering performance however, the program uses
lower values. By default it uses a 20 by 20 point grid, which gives good visual
and calculatory performance.
As the points defined by the radii are not coincident with the points of the
original DXF model, they are specified to be the averages of the original points.
For this process, a weighted contribution of the original points to the radii is
defined by using a biquadratic filter. The virtual point is then the weighted
average of the contributing points. Let ~v be the vector describing the direction
of the current radius and L be the ray extending from P (d) in the direction of
1
c1 continuity: the first derivative is continuous
34
CHAPTER 4. SYSTEM DESIGN
Figure 4.2: Path and surface of the muscle
~v . Let δX be the distance of a point X in the original model M to the line L
in grid units. Then
S := {X ∈ M |δ < 1}
(4.1)
is the set of all points which lie within a radius of one unit around L. Then the
radius is the sum of the distances of X to P (d) weighted by their respective δ
values:
P
|X − P (d)| ∗ δX
R(d, φ) = X∈S P
(4.2)
X∈S δX
4.2.2
Dynamic Muscle Volume Generation
Once all of the input models are processed, they are assigned values for their
activation. Currently this assignment has to be set by the user, as the program
cannot automatically identify the activation. Then, the complete set of input
models, along with their activation values can be used to interpolate the muscle at any given activation in between. Not only activation is changing when
interpolating the muscle, but length too. This is for two reasons. First, the
length of the muscle changes with activation because it results in a contraction
of the muscle. The second method is passive length change. This is the length
change imposed on all muscles when one is activated, because of the mechanical
properties of the eye. The eye muscles are always working in pairs, and when
one muscle contracts, the other muscle is extended and vice versa. Both, the
4.2. MUSCLE VOLUME DEFORMATION
35
activation and the length of a muscle are given by the SEE-KID application
and are calculated by the dynamic muscle model.
The length change and the activation can be handled as separate problems.
This way the interpolation of the muscle is easier. First the muscle is interpolated from the input images and the length change is disregarded. Afterwards
the muscle length is adapted and the muscle is scaled in the process to keep
the volume the same. The interpolation is done purely on the parameter basis.
After this has been finished, the render model is rebuilt from the parameter set.
The process of interpolating the muscle volume without length changes can
be split into the following steps:
1. identifying the input models used for interpolation,
2. interpolating the muscle path,
3. interpolating the radii,
4. generating the render model from the parameters.
The first step consists of defining weighting factors for the different input
models, depending on their activation relative to the desired activation A. Let
wM be the weight associated with an input model M . This thesis uses interpolation of the nearest neighbors, so the process starts by finding two models
M and N with activations AM , AN respectively, for which AM ≤ A ≤ AN and
there is no model O for which AM < AO < AN . Then a weight is assigned to
each of the two neighbors that depends inversely linear on the distance from
the desired activation. The weights are defined to be
|AM − A|
|AM − AN |
|AM − A|
1−
|AM − AN |
1−
(4.3)
(4.4)
for models M and N respectively. This way they blend linearly into each other.
The next step is to interpolate the muscle path. Linear interpolation is used
for the path. So if PM (d) is the muscle path in model M and PN (d) is the path in
model N, then the resulting path is P (d) = PM (d) ∗ wM + PN (d) ∗ wN . The way
the paths are defined, however, leads to a problem when solving this equation.
Two paths may not have the equal number of spline segments. If they do, the
interpolation is simple: Just interpolate all of the spline segments linearly as
outlined before. If the number is different, then we have to split spline segments
somewhere during the interpolation. They can be split immediately, as long as
the splitting results in the same path. For this we need to find a splitting
operation so that it is possible to cut out a new spline from an existing one
such that all points of the new spline are also points of the old spline. This is
problematic when the new spline would contain points from two original splines
36
CHAPTER 4. SYSTEM DESIGN
so the new set of splines has to be created in such a way that this cannot happen.
If such cases occur then the splines on both sides are split so that each side has
the same number of splines and the splines are in the same places with respect
to the d parameter. This configuration can be achieved by recursively splitting
larger splines into two halves when the corresponding part of the other spline
set also consists of multiple splines.
As all spline segments are normalized so that the start point is S(0) and
the end point is S(1) for any spline segment S, what actually needs to be done
is scale and move the old segment so that S(0) is now the start point of the
new segment and S(1) is the corresponding end point. To do this the spline
segment is transformed to the corresponding third-degree polynomial function
FS (x) := ax3 + bx2 + cx + d. Now this function is moved and scaled to get
FSn ew (x) := FS (x ∗ (h − l) + l) where h and l is the high and low value of the
part we want to cut out.
After splitting both paths, they can be linearly interpolated. As laid out
in Ch. 2.2.1, the polynomial for the path is a direct function of the parameters
of the spline. Thus linearly interpolating the spline parameters is equivalent
to interpolating the polynomial. Accordingly, the interpolation of the complete
path can be performed by linearly interpolating the spline segments.
The method for interpolating the radii and thus the muscle volume is more
difficult because the actual volume has to stay the same. The only thing done
in the interpolation step is to modify the distribution of the volume along the
muscle path. The change of the distribution is actually given by the input
models. The different radii functions describe how the volume is distributed
along the path for this step. The actual distribution is interpolated linearly
between the input models. After the distribution has been established, the
radius function is scaled, so that the volume stays exact. Because the input
models do not all have the exact same volume because of errors in the MR
images, approximations from the marching cube algorithm, and generating the
radii functions, the actual condition used for the volume preserving step is:
Z 1
Z 1
Z 1
R(d, φ) =
RM (d, φ) ∗ wM +
RN (d, φ) ∗ wN
(4.5)
0
0
0
Because interpolation of the path is performed according to the MR images,
the above steps automatically perform the active length change. Passive length
change, however, still needs to be taken into account. This is done in two steps.
First the scaling factor along the path is determined to achieve the new length.
This factor is used to scale the radii function, in order for the muscle volume
to stay exact. After this has been done, two transformation matrices are built.
The first scales the path in order to perform the length change. The second
is a rotation that takes into account the change of the insertion and point of
tangency of the muscle, and rotates the render model for representation.
After all these steps have been performed, the render model is rebuilt. The
static architecture of the render model is already generated when the program
4.2. MUSCLE VOLUME DEFORMATION
37
starts up. What is done actually is that the render function is evaluated and
the resulting points are written into the pre-generated geometry. Furthermore,
the program defines the distribution of sinew and muscle parts, and updates
the texture distribution in the model accordingly.
4.2.3
Render Optimization of the Muscle Volume
As laid out in Ch. 2.1.2, it is important for render performance to choose the
right memory location for the render model. The data structures for the render
model are stored in AGP or video card memory when available. This results
in good write access but very slow read access. Generally it is desirable to
keep the number of operations on this data to a minimum for two reasons: The
first is the previously mentioned slow access, the second is to avoid conflicts
with the graphics card. The actual rendering process is asynchronous to our
program execution. In the normal case, the CPU sets up the render models in
the memory and then informs the graphics card what is to be rendered and in
what manner. The call returns instantaneous and the graphics card then reads
and displays the data asynchronously. While the models are rendered, the CPU
calculates the data for the next iteration of this process.
The access to the data for the render model has to be synchronized however.
Otherwise the integrity of the render model could not be guaranteed and the
results of the rendering process would be undefined. To avoid this problem, the
CPU can lock the memory where the display models reside. As long as the lock
is active the graphics card will not access the memory. If the memory is still
used by the graphics card, then the CPU waits until the lock can be achieved.
If the graphics card needs the memory and it is still locked by the CPU then
the graphics card waits until the resource is free again. These lockdowns are
extremely inefficient because either the CPU or the graphics card is in a busy
waiting loop. To avoid this, the program should access the memory with the
render models as rarely and as short as possible.
However, the render optimization of the model is a difficult and computationally expensive task. To optimize the model every time new data is generated
would slow down render performance significantly. Due to this, it should be
done beforehand and the data should be updated after the new model is calculated without breaking the optimization. This implies requirements concerning
the data structure for the render model:
• Triangle and point definition must be separate.
• Optimization should be independent of actual point location.
• Update of new point values does not involve any dependencies to triangle
definitions.
Additionally we define the following requirements for the layout and usage of
the data in memory:
38
CHAPTER 4. SYSTEM DESIGN
• Triangles are rendered sequentially concerning their location in memory.
• Points referenced by the triangles are used sequentially concerning their
location in memory.
• Each point is stored only once.
• Both structures (triangles and points) take up the least possible space in
memory.
This thesis uses an indexed triangle list for the render model. This list has
already been used for other purposes in this thesis, and it is widely accepted as
a suitable data structure to store triangle information in 3D rendering. It keeps
the point and triangle definitions separate and thus allows us to exchange the
points with new values without having to watch out for any dependencies. The
optimizations, namely the three last points in the list, are independent of the
actual point location, although the topological dependencies of the old and new
point set have to be the same. This means that our interpolation must produce
the same number of points for each dynamically generated model. Furthermore
the points have to be in a specific order, which must be fulfilled by each model.
With our method of defining the radii function and the mode of interpolation,
these conditions are easily met. In fact this mode of operation is inherent to
the algorithm and data structures used, which is why it was chosen.
The condition of sequential usage can be achieved by choosing a suitable
method of storing and rendering the vertices and triangles. In this thesis triangles are enumerated at first radially and then move down the muscle path
from d = 0 to d = 1. The points are enumerated in a similar fashion. In the
usual case it is not possible to achieve exact sequential use of both points and
triangles. Normally the triangles are stored in exact sequential sequence and
the points are then stored as sequentially as possible. The reason for this is
that the most recently used points are in the cache of the CPU or graphics card
and can therefore be accessed more quickly than other points.
Chapter 5
Implementation
It is not enough to have knowledge, one
must also apply it. It is not enough to
have wishes, one must also accomplish.
Johann Wolfgang von Goethe
The last two chapters explained what this thesis is trying to achieve, and
laid out the general algorithms and techniques used to achieve these goals. This
chapter now covers the actual implementation chosen for this thesis. No source
code is used during these explanations, however. Wherever code is necessary,
pseudocode is used to explain the concepts.
5.1
Input Data
The process of creating the input models is not part of this thesis. Their creation
is described in [Pirklbauer, 2001] and the finished DXF files are then imported
by this thesis as input models. The DXF format was chosen because it is a
widely accepted format for transferring two- and three-dimensional geometry
data. The description of the DXF format presented here covers only the aspects
important for this work. For a complete definition see [Pohl and Eriksdottar,
1991].
Although the DXF file format is a serial format, the importer is implemented
as a parser, using an attributed grammar to define the file format. There are,
however, certain peculiarities about the DXF format, which make it necessary
to deviate from the standard implementation of parsers. The main problem
is that the basic entity in a DXF file is a pair of values, called a group. The
first value is an integer determining the type of the second value. The possible
types for the second values are text, integer and floating-point numbers. It
39
40
CHAPTER 5. IMPLEMENTATION
would theoretically be possible to build a grammar that can deal with these
pairs, but since there are 999 values for the type part, the grammar would
become extremely long. Also, the complete file consists only of such pairs, so
it is practical to have the scanner return these pairs as basic entity.
The file is split into 4 sections:
1. Header: Global settings, coordinate frame, colors;
2. Tables: defines layers, line styles, general styles;
3. Blocks: defines groups of graphical elements that can be used in the
entities section;
4. Entities: contains the actual graphical elements.
The files read with our application do not contain blocks, and the header
and tables sections are minimal. The complete definition of the geometry is
contained in the entities section as a series of SOLID entities. Each of those
entities defines a quadrangle, where the 3rd point and 4th point are possibly
the same. As no other entities are expected, but the parser should not break
on slightly non-conform files, other entities are skipped instead of throwing exceptions. In the following we list the grammar used for the parser. This is not
a complete reproduction, only the parts important for the following explanations are printed (<number>-<value> denotes one group, words in all caps are
terminal symbols).
Dxf = { Section } Eof .
Eof = 0-EOF .
Section = 0-SECTION [ Header | Tables | Blocks | Entities ]
0-ENDSEC .
Header = 2-HEADER { Headerfield } .
HeaderField = 9-Identifier HeaderFieldType-value
... exact definition of header fields is skipped
Tables = 2-TABLES { Table } .
Table = 0-TABLE [ VPort | LType | Layer | Style | View |
DimStyle | Ucs | AppID ] 0-ENDTAB .
VPort = 2-VPORT 70-count { VPortFieldType-value } .
... exact view port definition and other tables are skipped
Blocks = 2-BLOCKS { Entity } .
Entities = 2-ENTITIES { Entity } .
Entity = 0-EntityType 8-Identifier
{ EntityGeneralAttributeType-value }
[ Line | Point | Arc | Trace | Solid | Text |
Shape | Block | EndBlk | Insert |AttDef | Attrib |
5.1. INPUT DATA
41
PolyLine | Vertex | SeqEnd | 3DFace | ViewPort |
Dimension ] .
SOLID = 10-x1 20-y1 30-z1
11-x2 21-y2 31-z2
12-x3 22-y3 32-z3
13-x4 23-y4 33-z4 .
.. rest of the entities is skipped
The actual processing of the file is simple. The program keeps a list of points,
and each SOLID entity appends all 4 points to this list. Because SOLID is the
only type of entity in the file, and each SOLID has 4 points, no information
about which point belongs to which solid needs to be stored. After the whole
file has been processed, the list is traversed again. Each group of 4 points is
taken and stored in a boundary representation list, as described in Ch. 4.2.1.
To weld the vertices, they are first sorted by a spatial sorting algorithm.
As the distance between two points is either 0 or greater than 0.5 ∗ δ, a
comparison that maintains a topological order can be conceived where all
points with distance 0 are next to each other in the list. To do this the
comparison operator p ≺ q is used, where p and q are both three element
vectors with values p = [p1 p2 p3 ] , q = [q1 q2 q3 ]. It is defined
as follows:
δ
δ
δ
< q2 − 4 ∨
p ≺ q :⇔ p3 < q3 − 4 ∨ |p3 −
q3 | < 4 ∧ p2 (5.1)
|p3 − q3 | < 4δ ∧ |p2 − q2 | < 4δ ∧ p1 < q1 − 4δ
This order effectively groups all vertices in cubes with length 0.5 ∗ δ. The
contents of each group are the vertices that are to be welded in the later process.
As each group is now a continuous part of the list of vertices, the welding process
can be achieved in linear time. Starting with the first point, the algorithm
traverses the list until he finds a vertex whose distance to the first point is
greater than 0.5 ∗ δ. All points between the first and this one are erased, and
the references to their triangles are added to the first point. Then these triangles
are traversed and the references to the delete points are replaced with references
to the first point. After the complete list of the points has been traversed, all
vertices are welded, and the data structure is updated.
The complexity of the complete algorithm depends on the sorting algorithm
used. The sorting algorithm provided by the C++ STL is used in this thesis,
which has asymptotic runtime of O(n log2 n). Therefore the complete algorithm
has a complexity of O(n log2 n).
The transformation of the boundary representation into an indexed triangle
list can also be done in linear time. The first step is to transform the vertices.
This process is trivial, as only the references to the triangles from the vertex
data need to be striped. During this traversal the index of the points in the
original representation is also stored. The second step is to generate the index
list with the triangles. For this an iteration over all triangles is performed and
the index of each point is determined by reading the index written in step one.
Each triangle has three indices and they are written consecutively into the index
42
CHAPTER 5. IMPLEMENTATION
list.
5.2
Coping With the Amount of Data
After the file has been imported and the vertices welded, the parameters for
the input image are calculated. The first parameter is the muscle path P (d).
To get the path the muscle is devided into a series of slices along the z-axis.
Because the images used for generating the input images are coronal cuts 1 and
the image axes x and y are mapped to x and y in 3D space, the muscle always
has its longest extents along the z-axis. The identification of the slices is easy,
as a cut can be performed every δ units, starting at −0.5∗δ. This way each slice
contains exactly the points which were defined by one image in the marching
cube algorithm. In the ideal case (i.e. the model contains no noise) these points
form a ring whose borders are two star shaped polygons around the center of
gravity. When the ring is closed on both sides with a flat surface, the center
of gravity can be calculated by splitting the resulting body into pyramids and
tetrahedrons and calculating their centers of gravity.
The result is a list of points, each of them the center of gravity of one slice.
Now a set of splines is constructed, which approximate these points with a least
mean square distance. To accomplish this the best fitting spline is calculated
with normal cubic regression. The points are defined to be equally spaced
along the spline, which is an acceptable approximation in this case. When
pi , i ∈ {0..n} are the points and ui , i ∈ {0..n} are the locations along the spline
S(u) := au3 + bu2 + cu + d, then the error is minimized:
:=
n
X
(S(ui ) − pi )2
(5.2)
i=0
After the regression, the average error n is compared to a previously defined
threshold. If the criterion is met we stop, otherwise the list of points is split into
two halves and regression is performed on each one. This process is repeated
recursively until the criterion is met on each small spline segment. The process
can be proven to stop because when the amount of points for one segment is
4 or less then the regression produces a spline where is zero. The complete
curve is made continuous by making the start and end points and tangents of
two consecutive splines equal.
After creating the muscle path it can be used to calculate the radii. The
radius function is determined by a number of control points. These control
points represent where rays, starting along the path and extending radially,
intersect with the surface of the muscle. Finding these intersection points is the
first step in calculating the radii function. The control points are not necessarily
coincident with any known point of the surface, so interpolation of the known
surface points is needed.
1
coronal cut: the plane which the image lies in, is normal to the optical nerve
5.3. MUSCLE MODEL
43
First the ray of each of the control points is expressed as the parameters d
and φ which give the distance along the path, and the angle around the path.
Then all points from the input model are examined and their set of parameters
d and φ is determined. Now the weighted average of all points which have a
distance of less than one in grid units is calculated. The distance of the resulting
point to the path is taken as the radius for the current ray. This way all rays
are processed until the function is completely defined.
5.3
Muscle Model
The visualization of the muscle and the interpolation of a new muscle volume
are independent. Therefore the new muscle can be interpolated whenever the
muscle model dictates a change. The design of this thesis was chosen in a
way to support this. To initiate the calculation of a new muscle volume, the
muscle model informs the dynamic muscle that the innervation has changed.
The muscle volume is then recalculated acording to the steps laid out in the
next section. Fig. 5.1 shows a diagram of the process of recreating a muscle
volume.
5.4
Volume Preserving Transformations
Fig. 5.2 shows the conceptual layout of a dynamic muscle in the program. Each
muscle has a set of input images. Additionally it has an extra instance of
the MuscleParameters class that stores the parameters for the current state.
The DynamicModel class is the output model of the muscle, i.e. the transformed parameters, ready for display. Each input has its own instance of the
MuscleParameter class along with a copy of the DXF model and the input images. Also each input model has a defined activation.
As laid out in Ch. 3.4 the process of determining the interpolated dynamic
muscle model consists of the following steps:
1. Determine the path of the muscle for the current activation.
2. Determine the distribution of the volume for the current activation.
3. Build a muscle volume, using the interpolated path and the interpolated
distribution.
4. Determine the volume for the current activation from the input models.
5. Determine the actual volume of the interpolated distribution.
6. Apply a scale operation to make the volume of the interpolated distribution the same as the desired distribution.
44
CHAPTER 5. IMPLEMENTATION
Figure 5.1: Process of recreating muscle volume
5.4. VOLUME PRESERVING TRANSFORMATIONS
Figure 5.2: Concept of the dynamic muscle
45
46
CHAPTER 5. IMPLEMENTATION
The first part of the process is to identify the two input models, which should
be used for the interpolation. The nearest neighbors in each direction are used
for interpolation. After this has been established, the process can be started
with interpolating the muscle path. Problems arise when the actual splines in
one input path cover different areas of the complete curve in both sets. To avoid
this, the input paths are modified so that they contain the same set of points
as in the original state, but have the same number of splines and cover the
same areas. The path chosen to be modified is the one with - originally - fewer
splines. Let the path to be modified be Ps and the path after the modification
be Pd . Because of the way the splines are generated, it can be shown that each
spline in Pd is contained completely in one spline in Ps . To calculate the new
splines the following process is used for each of the target splines in the path:
1. Calculate the area where the spline is, relative to the path. This is a
continuous area [m, n], where 0 ≤ m < n ≤ 1.
2. Determine which spline S(u) in Ps contains the target spline.
3. Get the modified area of the spline [m0 , n0 ] so that it is relative to the
source spline.
4. Build a new spline S 0 (u) so that S 0 (0) = S(m0 ) ∧ S 0 (1) = S(n0 ) and
∀p∈S p ∈ S 0 .
Points one to three are straightforward, and point 4 is also easy, because
S 0 (u) := S((u − m0 ) ∗ (n0 − m0 )). This is actually just scaling and moving
of the parameter u and the result set is unchanged. Now the splines can be interpolated linearly between the two paths. This is done by linearly interpolating
the end points and tangents of the splines at the end points.
The distribution of the volume is determined by interpolating the radius
function between the two input models. Because the radius function is defined
by a set of points, they are interpolated to get the definition of the new radius
function. Now the new muscle volume can be calculated. This is done by
first cutting the volume into slices along the parameter d. Each slice is then
cut along parameter φ. The final pieces can be built from a 4-sided pyramid
and a tetrahedron. Fig. 5.3 illustrates this. In the illustration the height ht is
r3 ∗sin α and hb is r2 ∗sin α. The base area of the pyramid is Ap = d∗(r1 +r3 )/2
and the base area of the tetrahedron is At = r4 ∗ d/2. Therefore the volume of
the piece is
d ∗ r2 ∗ (r1 + r3 ) ∗ sin α d ∗ r4 ∗ r3 ∗ sin α
d ∗ sin α
+
=
∗(r2 ∗ (r1 + r3 ) + r3 ∗ r4 ) .
6
6
6
(5.3)
As d and sin α is constant for each slice it makes sense to pull them and the
division out and precalculate this term for each slice to speed up the calculation.
The volumes of these pieces can be calculated and then added together to
produce the final volume.
5.5. RENDERING
47
Figure 5.3: One piece for calculating the volume
After the calculation of the current volume, the radii are scaled. It needs to
be taken into account, though, that the change in volume is the square of the
change in radii. Therefore the radii are scaled by
r
Vdesired
.
(5.4)
Vcurrent
5.5
Rendering
While the interpolation of two muscle volumes is only performed when the
muscle changes, the rendering has to be performed every time the screen is
redrawn. This is the case whenever the user rotates or moves the camera, or
when other viewing parameters change. Also the display has to be updated
after the muscle volume has changed. Due to these facts, the rendering is the
operation the program will spend the most time in. In order to enable the
program to work in an interactive manner the rendering process needs to be
optimized for speed.
The first part in this optimization is to find a suitable data structure. The
following conditions must be met:
• The data structure must be of minimal size for our needs.
48
CHAPTER 5. IMPLEMENTATION
• The data must be directly usable for rendering without any further transformation.
• The memory layout should be in a way to maximize cache efficiency.
The first point means, that no additional information can be stored in the
data structure. No lists or graphs are usable for its representation as they need
additional storage for pointers and are more complex to traverse. The second
point limits the represenation to data types, which are directly usable by the
rendering mechanism. OpenGL can handle almost any numeric datatype for the
vertex data, but in this application only floating point numbers are reasonable.
In order to improve speed and maintain portability with other systems, single
precision floating point numbers are used for the definition of the vertices. They
offer sufficient precision for the display of the data and provide a considerable
speedup over double precision values. To allow the system fast access and
traversal of the vertices, they are stored as a vector of vertices in one continuous
memory block.
Information
Position
Surface normal
Texture coordinates
Sum
Representation
3 float values
3 float values
2 float values
Size
12 octets
12 octets
8 octets
32 octets
Table 5.1: Vertex format for dynamic model
Tab. 5.1 shows the elements we need to store per vertex in the dynamic
model. The amount of memory needed is nearly optimal in terms of memory
bandwidth. The typical memory bus width in a PC is 64 bits. This means
that the whole vertex can be transferred in four bus cycles or in one burst
transfer. The memory buses of the newest graphics cards and also of upcoming
motherboards use a 128 bit bus width and can therefore transfer the vertex in
two bus cycles. This means that even if it were possible to process the vertex
in only two CPU cycles, this would not stall the pipeline because of memory
transfer bottlenecks.
When the CPU is reading data from the main memory it normally does
not only read the data currently requested, but reads ahead some data. The
complete block that was read is stored in the CPU’s cache memory. This is
done mainly because access to the cache is much faster than access to the main
memory area. Because of this read-ahead, it is helpful to order the vertices
in memory in ascending order of their usage. In this case, when the system
reads ahead and transfers extra bytes from memory, the data will be readily
available when the next vertex is transformed. This way the number of cache
hits is increased, and this greatly speeds up performance. If the vertices were
unordered, the extra bytes would be wasted and would have to be transferred
again later. This would cost twice, since the data has to be transferred again
5.5. RENDERING
49
over the bus, and the CPU always has slow access to the vertices.
The other data structure needed is the triangle index list. This list defines
how the geometry looks like by assigning vertices to triangles. It consists of
three values per triangle. Each value is the index of a vertex in the vertex list.
To save memory the indices are defined to be 16 bit integers. This imposes a
limit of 216 = 65536 vertices per model, but this is more than enough for our
application.
These two lists can already be pre-computed for the models, so no additional
transformations have to be performed before the rendering. This not only saves
computing power, but also allows to store the lists in AGP or video memory.
These memories have normal speed for write access, but are very slow for CPU
read access. This means that lists can only be stored there, but not used for
anything else afterwards. The advantage is that, although the CPU has very
slow read access, the graphics card does not. The graphics card actually has
much faster read access to AGP and even more so to video memory than to
conventional system memory.
As the indexed triangle list described above is a very common method to
store geometry data, OpenGL, like most graphics subsystems, can use the data
as it is, To render the geometry, the application only needs to tell OpenGL
where the data is and how much of it it wants to have rendered.
To efficiently implement the complete render process, the rendering and
recreation of the dynamic model is split up into 3 steps.
1. The first step is only performed once, at the start of the program. At this
time the capabilities of the system are evaluated and it is decided which
is the best memory location for our model. There are three possibilities:
• If transformation and lighting has to be done by the CPU, the data
structure is allocated in the main memory.
• If the graphics card can do transformation and lighting, but there
is not enough space in video memory for the geometry, the data
structure is allocated in AGP memory.
• If the graphics card can do transformation and lighting and enough
video memory is available, the data structure is allocated in video
memory.
After this is done the triangle list is built. The topology of the vertices
does not change in our model, so this can be done without knowing the
exact location of the vertices.
2. The second step is to fill in the actual values for the vertices. This is
done each time when a new render model has been built. It is done by
iterating over all points in the render model and storing their position,
the surface normal and the texture coordinates into the memory already
50
CHAPTER 5. IMPLEMENTATION
reserved. Again, to utilize caching best, this is done in a strictly forward
manner, filling the list in one go from beginning to end.
3. The third step is the actual rendering. This is done every time the display
needs an update. This occurs after a part of the display has been occluded
by another window and is now visible, or the user has changed the camera
or the model has changed. Only very little work has to be done for this
step, as the rendering is completely performed by OpenGL.
Chapter 6
Testing and User Reports
If something can go wrong it will.
Murphy’s Law (Edward A. Murphy)
6.1
Testing
One problem of this thesis is the verification of the results. The generated muscle volume cannot be compared directly to the real muscle, as it is unavailable.
To be able to judge the quality of the result at all, two methods are used,
• comparing the result to the original input models,
• comparing the result to the original MR images.
The two methods are similar, however the first is used to verify the volumetric proberties of the dynamic model, while the second method is used to
verify the correct shape of the muscle with respect to the MR images.
6.1.1
Verifying the Results
Both methods are based on a visual test procedure, which is built into the visualization client. Fig. 6.1 shows a generated muscle model. The correctness
can now be checked with respect to the input model by overlaying the input
model onto the dynamic model. This is depicted in Fig. 6.2. The input model is
displayed semitransparent and it can be seen how the dynamic model approximates the input model along the surface. The light areas show where the DXF
model is bigger than the dynamic model and vice versa. The picture also shows
51
52
CHAPTER 6. TESTING AND USER REPORTS
how small errors in the input model are filtered by the process of generating
the radii function.
Figure 6.1: Dynamic muscle model
The second method is based on comparing the dynamic model directly to
the MR images. This way it can be made sure that the cross section of the
muscle has the right shape. To this end, the client can display each MR image
at exactly the location where it was assumed to be during the marching cube
step. The intersectin of this plane and the dynamic model can then be examined
and compared to the muscle on the MR image. Fig. 6.3 shows one MR image
from the set used for this and the previous two pictures.
6.1. TESTING
Figure 6.2: Dynamic muscle model with overlay of input model
Figure 6.3: Dynamic muscle model with overlay of MR images
53
54
CHAPTER 6. TESTING AND USER REPORTS
Chapter 7
Conclusion
A mind once stretched by a new idea
never regains its original dimension.
Oliver Wendell Holmes
In the end I want to summarize the contents of this thesis, and show which
problems were solved, and what is still to do. Furthermore, I want to give an
outlook on the future possibilities in this area.
7.1
Goals Achieved
The main goal of this thesis was the generation of a muscle volume at any given
activation by interpolating from a set of input models. The input models are
generated by a separate program, not part of this thesis, and imported via a
DXF file format. The key problems solved in this thesis are:
• importing the input models from DXF file,
• calculating the muscle path from the input models,
• calculating the muscle volume from the input models,
• interpolating the muscle path,
• interpolating the muscle volume,
• preserving the volume,
• generating the render model from the volume and optimizing it.
The import algorithm is built as a parser, based on a grammar. After the
input models are read, they are optimized for rendering and the later processing.
55
56
CHAPTER 7. CONCLUSION
Welding vertices being close to each other enables this. Furthermore the vertices
are sorted to speed up the rendering of the input model and the later processing.
After the input models are read, the parameters are calculated for each
of them. First the muscle path is calculated by approximating the centers of
gravity of slices along the muscle. The approximation uses cubic regression and
a recursive subdivision scheme to achieve a least mean square threshold over
the complete path. This path is then used to define the volume of the muscle
as a radius function around the path. The radii are generated by analyzing the
input model and using a biquadratic filter to assign points of the input model
to them.
The interpolation of the muscle path needs to split both input paths so that
they have the same number of spline segments. Then linear interpolation of
the segments is used to interpolate the complete path. After the path has been
established, the volume is interpolated by linear interpolation of the radii function. During this step, the length of the muscle is also changed to accommodate
for active and passive length change. When the muscle volume interpolation
is finished, the generated volume is scaled to preserve the muscle volume. The
scaling affects only the radii function and not the length, which was set to the
correct value in the previous step.
The interpolated muscle volume is then used to generate a new render model.
The model is already optimized during the startup of the program. The regeneration only changes the position of the points that make up the geometry. The
render model is optimized for render speed by aligning the data in memory and
uses the optimal memory location.
7.2
Open Problems
The main objective of this thesis was to show that the volume preserving transformation of the muscle volume can be done wit a performance that allows for
interactive rendering. Therefore some minor parts are not implemented in full
detail and the whole system is not designed for user friendliness. There are
several points which could be improved in this system, when it is used for a
commercial product.
First the import of input models should be made more generic. The DXF
parser is working per se, but is skipping many of the entities possible in a DXF
file, because they are not used by the application generating them in our case.
It might even be desirable to build the marching cubes algorithm directly into
the application so that a new muscle can be generated from a set of MR images,
which is taken directly from the patient.
The second issue is of a more functional nature. The interpolation of the
dynamic model uses the nearest neighbors only. Path and radii functions are
interpolated linear, but if more input models were used, then the result might
LITERATURE
57
get more accurate. A possible solution here would be to use a method similar
to B-splines for the interpolation of the muscle volume. Also the method used
for determining the desired volume of the muscle, as outlined in Ch. 3.4, should
be selectable by the user and not fixed.
If even more accuracy in the volume preserving step is required, then the
radii function can be modeled as an actual function instead of specifying control points only. This might be done by specifying it as a parametric surface
(e.g. NURBS patches). This way the volume could be expressed exactly as
the integral of the function; however, the computational effort would be much
bigger. With dynamic tessellation, this method would also generate a smoother
surface, which would adapt itself to the screen resolution and size of the muscle
volume. Nonetheless, new problems would arise when scaling and interpolating
the muscle volume.
58
LITERATURE
Literature
[Buchberger and Mayr, 2000] M. Buchberger and H. Mayr. SEE-KID: Software Engineering
Environment for Knowledge-based Interactive Eye Motility Diagnostics. Proc. International
Symposium on Telemedicine 2000, Gothenburg, Sweden., pages 67–79, 2000. 1.1, 3.5
[Cheng et al., 1999] E. Cheng, J. Loeb, and I.Brown. Muscle Model for Matlab. User’s
manual, Canadian Institutes of Health Research Group in Sensory-Motor Systems, 1999.
3.6
[Eberly, 2001] D. H. Eberly. 3D Game Engine Design. Academic Press, 2001. 2.1
[Jordan and Smith, 1996] D. W. Jordan and P. Smith. Mathematische Methoden für die
Praxis. Spektrum Akademischer Verlag GmbH, 1996. 2.2
[Krewson, 1950] W. E. Krewson.
The
Trans.Amer.Opthalmol, 48, 1950. 1.2.2, 2.3.2
action
of
the
extraocular
muscles.
[Kusel and Haase, 1977] R. Kusel and W. Haase. Versuch einer mathematischen Darstellung
der Augenmuskelwirkung. Berichte der Deutschen Opthalmologischen Gesellschaft, 45:453–
458, 1977. 1.2.2, 2.3.2
[Microsoft, 2001] Microsoft.
Directx 8.0 programmer’s reference.
[Website,
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dx8 c/hh/dx8 c/
graphics understand 7d0z.asp, accessed July 25, 2001], 2001. 2.1
[Miller and Demer, 2000] J.M. Miller and J.L. Demer. Clinical applications of computer models for strabismus. Technical report, Upper Austrian Polytechnic University, Department
of Software Engineering for Medicine, 2000. 1.2.2, 1.1, 3.3
[Mortenson, 1999] M. E. Mortenson. Mathematics for computer graphics applications. Industrial Press, Inc., 2nd edition, 1999. 2.2, 2.2.1
[Pirklbauer, 2001] F. Pirklbauer. 3D-Rekonstruktion extraokulärer Augenmuskeln aus MRBilddaten. Diploma thesis, Polytechnic University, Hagenberg, Austria, Europe, 2001. 1,
3.1, 3.1, 3.1, 3.2, 4.2.1, 5.1
[Pohl and Eriksdottar, 1991] M. Pohl and H. Eriksdottar. Die wunderbare Welt der Grafikformate. Wolfram’s Fachverlag, 1991. 5.1
[Robinson, 1975] D.A. Robinson. A quantitative analysis of extraocular muscle cooperation
and squint. Invest Ophthalmol, 14, 1975. 1.2.2, 2.3.2
[Zhu et al., 1997] Q.H. Zhu, Y. Chen, and A. Kaufman. Real-time Biomechanically-based
Muscle Volume Deformation using FEM. Technical report, Center for Visual Computing,
State University of New York at Stony Brook, Stony Brook, NY 11794-4400 USA, 1997.
1.2.1.2
59

Documentos relacionados