GPU-basierte Erkennung von algebraisch beschreibbaren Strukturen

Transcription

Fachhochschule Wiesbaden
Fachbereich Design Informatik Medien
Diplomarbeit
zur Erlangung des akademischen Grades
Diplom-Informatiker (FH)
GPU-basierte Erkennung von
algebraisch beschreibbaren
Strukturen
vorgelegt von Christian Rathemacher
am
16. November 2007
Referent
Prof. Dr. Ulrich Schwanecke
Korreferent
Prof. Dr. Peter Barth
Erklärung
Ich erkläre hiermit,
• dass ich die vorliegende Diplomarbeit selbstständig angefertigt,
• keine anderen als die angegebenen Quellen benutzt,
• die wörtlich oder dem Inhalt nach aus fremden Arbeiten entnommenen Stellen, bildlichen Darstellungen und dergleichen als solche genau kenntlich gemacht und
• keine unerlaubte fremde Hilfe in Anspruch genommen habe.
..................................................................................
(Ort, Datum)
(Unterschrift Diplomand)
Hiermit erkläre ich mein Einverständnis mit den im folgenden aufgeführten
Verbreitungsformen dieser Diplomarbeit:
Verbreitungsform
ja
nein
Einstellung der Arbeit in die Bibliothek der FHW
√
Veröffentlichung des Titels der Arbeit im Internet
√
Veröffentlichung der Arbeit im Internet
√
..................................................................................
(Ort, Datum)
(Unterschrift Diplomand)
Danksagung
An dieser Stelle möchte ich einigen Personen danken, die zum Gelingen dieser Arbeit sowie meines
Studiums beigetragen haben.
Ich danke vor allem meiner Mutter und meinem Stiefvater, die mich während meines gesamten
Studiums stets unterstützt haben und auf deren Hilfe ich mich jederzeit verlassen konnte. Ohne diese
Hilfe wäre mein Studium nicht möglich gewesen.
Herzlich bedanken möchte ich mich natürlich bei Prof. Dr. Schwanecke, der mich bereits seit
dem ersten Semester in mehreren Vorlesungen und Lehrveranstaltungen betreute und mich vom
ertsen Hello World bis zur GPU-basierte Erkennung von algebraisch beschreibbaren Strukturen
immer unterstützt und neu motiviert hat. Darüber hinaus gilt mein Dank auch Prof. Dr. Barth und
Prof. Dr. Weitz, die immer ein offenes Ohr für Fragen und Probleme hatten. Durch diese drei Professoren war mein Studium an der FH-Wiesbaden immer durch interessante Vorlesungen und humorvolle Geschichten geprägt.
An dieser Stelle möchte ich mich auch bei der gesamten Arbeitsgruppe der Uni Mainz und vor
allem bei Uli Heil, für die erfolgreiche, interessante und hoffentlich auch weiterhin gute Zusammenarbeit und Unterstützung bedanken.
Danken möchte ich auch der Firma weltenbauer., vor allem Robert Mayer und Rene Nold, für die
Unterstützung während meiner Diplomarbeit. Ich freue mich schon sehr auf interessante, spannende
und lustige Projekte, die wir bald zusammen angehen werden.
Dem Gelingen dieser Arbeit äußerst zuträglich, waren außerdem alle meine Freunde, die während
der letzten Wochen und Monate immer wieder dafür gesorgt haben, dass ich mein Privatleben in
Form von vielen Partys und Festen nicht vernachlässige. Ganz besonders danke ich hierbei Malte
und Tanja Bethke, die hoffentlich alle Rechtschreibfeler dieser Arbeit korrigiert haben.
Als letztes möchte ich mich bei der Person bedanken, die den größten Anteil am Gelingen dieser
Arbeit hat. Ich danke meiner Freundin Nina für die vielen Stunden, in denen sie für mich da war und
mich immer wieder neu motiviert und angeschoben hat. Ihr möchte ich an dieser Stelle sagen, dass
ich sie über alles liebe und mich auf eine gemeinsame Zukunft mit ihr freue.
Diese Diplomarbeit widme ich meinem Vater, dem ich mein Interesse an
Technik und Computern verdanke.
5
Inhaltsverzeichnis
1 Einleitung
1
1.1
Referenzkugelmethode . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
1.2
Software zur 3D-Rekonstruktion . . . . . . . . . . . . . . . . . . . . . . .
3
1.3
Ziele und Aufbau der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . .
3
2 Erkennen algebraisch beschreibbarer Strukturen
2.1
2.2
2.3
Algebraisch beschreibbare Strukturen . . . . . . . . . . . . . . . . . . . .
9
2.1.1
Geraden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.1.2
Kreise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
2.1.3
Ellipsen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
Bildverarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
2.2.1
Digitale Bilder . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
2.2.2
Punktbasierte Operationen . . . . . . . . . . . . . . . . . . . . . .
17
2.2.3
Ortsbasierte Operationen . . . . . . . . . . . . . . . . . . . . . . .
19
Finden von Strukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
31
3 Hough Transformation
3.1
3.2
3.3
7
Hough Transformation für Geraden
35
. . . . . . . . . . . . . . . . . . . . .
38
3.1.1
Erstellen des Parameterraums . . . . . . . . . . . . . . . . . . . .
39
3.1.2
Füllen des Parameterraums . . . . . . . . . . . . . . . . . . . . . .
41
3.1.3
Verbesserungen der Hough Transformation für Geraden . . . . . .
42
Hough Transformation für Kreise . . . . . . . . . . . . . . . . . . . . . . .
46
3.2.1
Erstellen des Parameterraums . . . . . . . . . . . . . . . . . . . .
46
3.2.2
Füllen des Parameterraums . . . . . . . . . . . . . . . . . . . . . .
48
3.2.3
Schnelles Finden von Kreisen mittels der Gradientenrichtung . . . .
48
Hough Transformation für Ellipsen . . . . . . . . . . . . . . . . . . . . . .
52
3.3.1
54
Speicherbedarf des Parameterraums . . . . . . . . . . . . . . . . .
i
Inhaltsverzeichnis
3.3.2
3.4
3.5
Schnelles Finden von Ellipsen . . . . . . . . . . . . . . . . . . . .
54
Verallgemeinerte Hough Transformation . . . . . . . . . . . . . . . . . . .
58
3.4.1
Beschreibung einer Struktur durch ihren Rand . . . . . . . . . . . .
59
3.4.2
Finden einer Struktur mittels der Verallgemeinerten Hough Transformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
61
Alternative zur Hough Transformation . . . . . . . . . . . . . . . . . . . .
62
4 Ellipsenfindung in Röntgenbildern
65
4.1
Röntgenbilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
65
4.2
Projektionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
66
4.3
Projektionen von Referenzkugeln in Röntgenbildern . . . . . . . . . . . . .
70
4.4
Finden von projizierten Ellipsen in Röntgenbildern . . . . . . . . . . . . .
73
4.4.1
Finden der Ellipsenparameter . . . . . . . . . . . . . . . . . . . .
73
4.4.2
Probleme der Chord-Tangent Methode bei Röntgenbildern . . . . .
76
4.4.3
Einschränken des Bildraumes um die Ellipse . . . . . . . . . . . .
78
5 Implementierung
5.1
5.2
81
Java Prototyp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
81
5.1.1
Grundfunktionalitäten . . . . . . . . . . . . . . . . . . . . . . . .
82
5.1.2
Implementierte Algorithmen . . . . . . . . . . . . . . . . . . . . .
83
Rsm3D Modul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
91
5.2.1
Software Implementierung . . . . . . . . . . . . . . . . . . . . . .
93
5.2.2
Implementierung auf der GPU . . . . . . . . . . . . . . . . . . . .
95
6 Test des Moduls und Performancemessung
105
6.1
Versuchsaufbau und Testumgebung . . . . . . . . . . . . . . . . . . . . . . 106
6.2
Test mit synthetischen Bildern . . . . . . . . . . . . . . . . . . . . . . . . 106
6.3
Test mit Röntgenbildern
. . . . . . . . . . . . . . . . . . . . . . . . . . . 109
7 Zusammenfassung und Ausblick
113
Abbildungsverzeichnis
115
Quellen
119
A Inhalt der CD
123
ii
Inhaltsverzeichnis
B Java Prototyp
125
B.1 Schnelle Hough Transformation für Geraden . . . . . . . . . . . . . . . . . 126
B.2 Schnelle Hough Transformation für Kreise . . . . . . . . . . . . . . . . . . 126
B.3 Schnelle Hough Transformation für Ellipsen . . . . . . . . . . . . . . . . . 127
C Rsm3D Modul
129
C.1 Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
C.2 Installationshinweis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
C.3 Anleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
C.4 CUDA Compute Capability . . . . . . . . . . . . . . . . . . . . . . . . . . 133
C.5 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
iii
Inhaltsverzeichnis
iv
1 Einleitung
Im Jahr 1917 zeigte der österreichische Mathematiker Johann Radon1 , dass, wenn alle Linienintegrale einer Funktion bekannt sind, auch die Funktion an sich bekannt ist [17]. Durch
diesen rein mathematisch motivierten Beweis, schaffte Radon die mathematische Grundlage für eine der größten medizinischen Innovationen des 20. Jahrhunderts. Johann Radon
starb 1956 und erlebte so nicht mehr, wie Goldfrey Hounsfield, aufbauend auf den Arbeiten
von Allan M. Cormack, in den 1960er Jahren die ersten Computertomographen (CT) baute
und 1971 die erste CT-Aufnahme eines Menschen lieferte. Hounsfield und Cormack wurde
dafür 1979 der Nobelpreis für Medizin verliehen.
Ein Computertomograph erstellt eine Vielzahl von Röntgenbildern eines Objektes aus
verschiedenen Richtungen und setzt diese computerbasiert zu einem dreidimensionalen (3D)
Bild zusammen. Diese Rekonstruktion des geröntgten Objektes wird als Tomosynthese bezeichnet. Die dreidimensionale Darstellung stellt gegenüber zweidimensionalen Röntgenbildern einen erheblichen Mehrwert dar und ist aus der modernen Diagnostik und Medizin
nicht mehr wegzudenken. Zum Beispiel werden rund 30% aller Brustkrebserkrankungen auf
Röntgenbildern nicht erkannt, da das Krebsgeschwür durch anderes Gewebe verdeckt wird
[23]. Hier kann eine dreidimensionale Darstellung helfen, die Erkennungsrate der Krebstumore zu steigern.
Allerdings beinhaltet die Untersuchung mittels der Computertomographie auch Nachteile. Zum Beispiel kann die Strahlenbelastung durch eine CT-Aufnahme um das tausendfache
höher liegen, als bei einzelnen Röntgenbildern. Dadurch steht die Computertomographie
für gewisse Patientengruppen, wie etwa schwangere Frauen, nicht zur Verfügung. Weitere
Nachteile sind unter anderem die hohen Kosten, die durch die Anschaffung und Verwendung eines CT im Vergleich zu Röntgenaufnahmen entstehen.
1
Johann Radon 1887 – 1956
1
1 Einleitung
1.1 Referenzkugelmethode
Um dreidimensionale Darstellungen aus Röntgenbildern zu rekonstruieren, ist es notwendig, die Projektionsgeometrie der Röntgenbilder zu kennen. Als Projektionsgeometrie wird
dabei die räumliche Anordnung der Röntgenquelle, des geröntgten Objektes und des Röntgensensors zum Zeitpunkt der Aufnahme bezeichnet. Bei einem Computertomographen ist
die räumliche Anordnung dieser Komponenten aufgrund des starren Aufbaus eines CTs und
der festen Verbindung der einzelnen Komponenten gut bekannt, so dass die Rekonstruktion
kein Problem darstellt.
Eine alternative Methode zum Feststellen der Projektionsgeometrie ist die Referenzkugelmethode (RSM)2 , die innerhalb des Forschungsprojektes „3D Rekonstruktion aus wenigen 2D – Projektions – Röntgenaufnahme“ erarbeitet wurde [19]. Bei dem RSM-Verfahren
werden mehrere Kugeln bekannter Größe an dem zu röntgenden Objekt befestigt. Durch die
auf die Röntgenbilder projizierten Kugeln kann die Projektionsgeometrie einer Aufnahme
berechnet, die einzelnen Aufnahmen in einen räumlichen Bezug zueinander gebracht und
somit in ein einheitliches Koordinatensystem überführt werden. Befinden sich alle Aufnahmen in einem gemeinsamen Koordinatensystem, ist es möglich ein dreidimensionales
Modell des geröntgten Objektes zu rekonstruieren.
Dieses Verfahren verwendet eine erheblich geringere Anzahl von Röntgenbildern (< 10)
als ein Computertomograph, was zu einer deutlich niedrigeren Strahlenbelastung führt. Allerdings stellt das RSM-Verfahren keine echte Alternative zur herkömmlichen Computertomographie dar, da die rekonstruierten 3D-Modelle bei weitem nicht der Genauigkeit und
dem Detailgrad einer CT Aufnahme entsprechen.
Die Verwendung von 3D-Rekonstruktionen aus Röntgenbildern ist nicht nur in der Medizin sinnvoll. So werden zum Beispiel Bomben vor ihrer Entschärfung geröntgt, um den
inneren Aufbau zu ermitteln. Dabei kann eine dreidimensionale Darstellung des Bombeninneren helfen, präzise einzelne Komponenten der Bombe zu identifizieren, die eventuell auf
einzelnen Röntgenbildern aufgrund von Überdeckungen nicht sichtbar sind. Bei einer solchen Anwendung zeigt sich ein klarer Vorteil des RSM-Verfahrens: Durch die geringeren
Voraussetzungen zur Anwendung, es müssen lediglich die Referenzkugeln an dem Objekt
befestigt werden, ist dieses Verfahren sehr flexibel und universell einsetzbar.
An dem Forschungsprojekt „3D Rekonstruktion aus wenigen 2D – Projektions – Röntgenaufnahme“ ist die Poliklinik für Zahnärztliche Chirurgie der Universität Mainz, das In2
2
engl.: Reference Sphere Method (RSM)
1.2 Software zur 3D-Rekonstruktion
stitut für Informatik der Universität Mainz und der Fachbereich Design Informatik Medien
der Fachhochschule Wiesbaden beteiligt.
1.2 Software zur 3D-Rekonstruktion
Um aus einer Serie vorliegender Röntgenbilder ein 3D-Modell rekonstruieren zu können,
wurde die Software Rsm3D entwickelt [20]. Sie erlaubt es, bestehende Röntgenbilder zu
importieren, in ein einheitliches Koordinatensystem zu überführen und eine dreidimensionale Darstellung des geröntgten Objektes zu berechnen. Darüber hinaus enthält die Software
mehrere Anzeigemöglichkeiten zur Darstellung rekonstruierter 3D-Modelle.
Die Software besteht aus mehreren Modulen, die verknüpft werden können. Jedes Modul
nimmt dabei die Daten seines Vorgängermoduls entgegen, arbeitet darauf und gibt sie anschließend an sein Nachfolgemodul weiter. Durch die Verknüpfung entsteht ein sogenannter
Modulgraph, dessen Module untereinander kommunizieren und Daten weiterreichen können. Die Module können dabei durch eine grafische Umgebung miteinander verbunden werden. Ein Beispiel eines Modulgraphen ist in Abbildung 1.1 zu sehen. Zur Zeit existieren
Module zum Importieren von Röntgenbildserien, 3D-Rekonstruktionen und verschiedener
anderer Datenformate, zum Berechnen der Projektionsgeometrie und zur Rekonstruktion,
sowie zum Exportieren der erstellten 3D-Modelle. Darüber hinaus gibt es mehrere Module,
die die verwendeten Röntgenbilder und die erstellten Rekonstruktionen visualisieren können.
1.3 Ziele und Aufbau der Arbeit
Im Rahmen dieser Arbeit soll ein Verfahren entwickelt werden, um projizierte Referenzkugeln in Röntgenbildern schnell und zuverlässig zu finden. Dabei sollen die algebraischen
Beschreibungen aller projizierten Referenzkugeln in den vorliegenden zweidimensionalen
Röntgenbildern berechnet werden. Die genaue Beschreibung der projizierten Kugeln ist
notwendig, um die ursprüngliche Position der Kugeln im dreidimensionalen Raum zu berechnen und somit alle Röntgenbilder einer Serie in ein einheitliches Koordinatensystem zu
überführen.
Da das Finden von Strukturen in Bildern mitunter sehr rechenintensiv sein kann, soll,
neben einer reinen softwarebasierten Implementierung des Verfahrens, die Rechenleistung
3
1 Einleitung
Abbildung 1.1: Grafische Oberfläche der Software Rsm3D. Auf der linken Seite ist der
aufgebaute Modulgraph zu sehen, rechts wird ein Röntgenbild angezeigt, in dem deutlich
die projizierten Referenzkugeln zu sehen sind.
4
1.3 Ziele und Aufbau der Arbeit
moderner Graphic Processing Units (GPUs) verwendet werden. Das Verfahren wird dabei
so angepasst, dass performancekritische Teile auf die Grafikkarte ausgelagert werden. Vor
allem sollen hierbei die Möglichkeiten moderner Grafikkarten, Probleme parallel zu berechnen, einen Geschwindigkeitsvorteil gegenüber der Softwareimplementierung bringen. Ziel
ist ein Vergleich der Laufzeiten zwischen der Soft- und Hardwareimplementierung.
Als Implementierung soll dabei ein Modul für die Software Rsm3D entstehen, dass sich
nahtlos in das bestehende Programm integrieren lässt (siehe Abschnitt 1.2). Dazu gehört unter anderem, dass das Modul mit anderen Modulen kommunizieren und Daten austauschen
kann. Das Modul soll eine Serie von Röntgenbilder von einem Importer Modul entgegennehmen und die algebraische Beschreibung der gefundenen projizierten Referenzkugeln an
ein Nachfolgemodul weiterreichen. Die Basis für das Modul bildet das bereits bestehende
Framework von Rsm3D, das es auf einfache Weise ermöglicht, die Anwendung zu erweitern.
Die vorliegende Arbeit ist dabei folgendermaßen strukturiert: In Kapitel 2 werden Grundlagen über algebraische Strukturen und ihre Darstellung sowie Grundlagen der Bildverarbeitung erläutert. Hier wird auf die Vorverarbeitungsschritte eingegangen, die häufig notwendig sind, um Strukturen in Bildern zuverlässig zu extrahieren und zu finden. Des Weiteren werden Verfahren zum Finden von Strukturen in Bildern kurz vorgestellt.
In Kapitel 3 wird detailliert auf das Finden von algebraischen Beschreibungen unterschiedlicher Strukturen eingegangen. Es werden Verfahren vorgestellt, um Geraden, Kreise,
Ellipsen sowie beliebig komplexe Strukturen in Bildern zu erkennen und deren Beschreibung berechnen zu können. Dabei werden unter anderem Ansätze aufgeführt, die die vorgestellten Verfahren beschleunigen und zuverlässiger machen.
Kapitel 4 behandelt das Finden von projizierten Referenzkugeln in Röntgenbildern. Es
wird auf Röntgenbilder sowie die Projektion der Referenzkugeln eingegangen. In diesem
Kapitel wird detailiert das entwickelte Verfahren beschrieben, das später in dem Rsm-Modul
implementiert wird.
Kapitel 5 behandelt die Implementierung eines Prototypen, in dem verschiedene Algorithmen implementiert und getestet wurden. Darüber hinaus wird auf die Implementierung des Rsm3D-Moduls eingegangen. Der Test des implemntierten Verfahrens sowie ein
Performance-Vergleich der Soft- und Grafikkartenvariante des Moduls wird in Kapitel 6
vorgenommen.
Abschließend werden in Kapitel 7 die wesentlichen Aspekte der Arbeit zusammengefasst und das Ergebnis in Bezug auf die genannten Ziele der Arbeit erläutert. In diesem
5
1 Einleitung
Zusammenhang werden auch Überlegungen für weitere Entwicklungen eingebracht und
zusätzliche Anregungen aufgeführt.
6
2 Erkennen algebraisch
beschreibbarer Strukturen
Das Erkennen von Strukturen in Bildern ist eine Anwendung der Bildverarbeitung, die uns
häufig im alltäglichen Leben begegnet. So basieren zum Beispiel moderne Leergutautomaten unter anderem auf einer Umrisserkennung der eingeführten Flaschen und Dosen. Auch
in der Industrie kommt es häufig vor, dass optische Prüfverfahren mit Hilfe moderner Bildverarbeitung realisiert werden. Der Vorgang, aus Bilddaten Informationen zu gewinnen,
wird dabei als Machine Vision, Computer Vision oder als Maschinelles Sehen bezeichnet.
Ziel ist es, aus einer aufgenommenen Szene, eine Aussage über den Szeneninhalt zu treffen.
Aussagen über eine aufgenommenen Szene beziehungsweise ein Bild, können dabei zum
Beispiel Aussagen über erkannte Objekte, über die Beschaffenheit oder die Struktur des
Bildes sein.
In dieser Arbeit sollen Bilder vor allem nach algebraisch beschreibbaren Strukturen untersucht werden. Als Strukturen werden dabei zusammenhängende Bildinformationen bezeichnet, die sich von ihrer Umgebung absetzen. Können diese Strukturen durch eine algebraische Gleichung ausgedrückt werden, spricht man dabei von algebraisch beschreibaren
Strukturen. Allerdings lassen sich durch algebraische Gleichungen nur Kurven und keine
Flächen beschreiben. Das hat zur Folge, dass eine Gleichung immer nur den Rand eines
zusammenhängenden Gebildes beschreibt (siehe Abbildung 2.1). Beispiele algebraisch beschreibarer Strukturen sind Geraden, Kreise oder Ellipsen, die sehr häufig in Bildern und
aufgenommenen Szenen zu finden sind.
Ziel der nachfolgenden Kapitel ist es, Strukturen in einem Bild zu finden und deren algebraische Beschreibung zu berechnen. Um eine Ausage über diese Beschreibungen treffen
zu können, sind mehrere Arbeitsschritte nötig.
1. Als erstes muss die zu untersuchende Szene, aufgenommen und digitalisiert werden.
Viele Aufnahmegeräte, wie zum Beispiel Digitalkameras, liefern dabei schon digitale
7
Abbildung 2.1: Erkannte Strukturen wie Geraden, Kreise oder Ellipsen, werden durch algebraische Gleichungen beschrieben.
Bilder, die direkt von einem Computersystem weiterverarbeitet werden können.
2. Das aufgenommene Bild wird im zweiten Schritt häufig nachbearbeitet. Zum Beispiel werden Farbbilder in Grauwertbilder umgewandelt oder Fehler, die bei der Aufnahme entstanden sind, korrigiert.
3. Im dritten Schritt wird in dem Bild nach zusammenhängenden Bildpunkten gesucht,
die sich von ihrer Umgebung abheben. Es wird also nach bestimmten Merkmalen, in
diesem Fall nach Strukturen, im Bild gesucht.
4. Hat man diese Strukturen extrahiert, ist es im letzten Schritt möglich, eine algebraische Beschreibung dieser Strukturen zu berechnen. Ziel ist hierbei, sämtliche erkannte Strukturen im Bild durch algebraische Gleichungen zu beschreiben.
Nach diesen Schritten lässt sich eine Aussage über den Bildinhalt treffen und es ist möglich,
weitere Rückschlüsse zu ziehen. Zum Beispiel kann aufgrund der Anordnung der gefundenen Strukturen die Kameraposition zum Zeitpunkt der Aufnahme oder die Lage der aufgenommenen Objekte im Raum bestimmt werden, so wie es bei der Referenzkugelmethode
der Fall ist. Ein anderes Beispiel liefert der eingangs erwähnte Pfandautomat. Untersucht
man eine eingeführte Flasche durch die gerade erwähnten Schritte, könnte man eine Aussage über die Art der Flasche treffen und so entscheiden, ob diese vom Pfandautomaten
zurückgenommen werden soll oder nicht.
8
2.1 Algebraisch beschreibbare Strukturen
Um Strukturen in der Ebene zu definieren, existieren mehrere Möglichkeiten. Zum Beispiel
können, alle Punkte der Struktur durch ihre Koordinaten beschrieben werden. Bei Strukturen die nur aus geradenhaften Elementen bestehen, reicht es aus, die Eckpunkte der Struktur
zu definieren.
Strukturen können aber auch über algebraische Gleichungen beschrieben werden. Dadurch kann man jeden Punkt auf der Struktur in kompakter Form definieren. Im Folgenden
wird vor allem auf Geraden, Kreise und Ellipsen als algebraisch beschreibare Strukturen
eingegangen, da diese Grundformen in dieser Arbeit verwendet werden.
Alle im Folgenden verwendeten Koordinaten sind karthesische Koordinaten mit den Koordinatenachsen x und y im R2 sowie den Koordinatenachsen x, y und z im R3 . Punkte
und Vektoren werden dabei durch fett gedruckte Kleinbuchstaben, Skalare durch kursive
Kleinbuchstaben und Matritzen durch kursive Großbuchstaben dargestellt.
2.1.1 Geraden
Um Geraden im R2 zu beschreiben, existieren mehre Möglichkeiten [8]: Zum Beispiel können Geraden durch geometrische Elemente wie Punkte und Vektoren dargestellt werden.
Zwei Punkte beschreiben eine Gerade, die genau durch diese Punkte verläuft. Ein Punkt
und ein Vektor parallel zur Geraden oder ein Punkt und ein Vektor, der senkrecht auf der
Geraden steht, beschreiben ebenfalls eine Gerade. Die Gerade geht dabei genau durch den
gegebenen Punkt und ihre Ausrichtung ist abhängig von dem gegebenen Vektor. Diese geometrischen Konstruktionen von Geraden lassen sich durch algebraische Gleichungen ausdrücken.
Die explizite Darstellung einer Geraden ist definiert durch ihre Steigung und den Schnittpunkt mit der y-Achse (siehe Abbildung 2.2 a). Sie hat die Form:
y = m · x + b,
m, b ∈ R
Die Steigung m kann durch das Verhältnis von Höhe und Breite zweier Punkte auf dieser
Geraden berechnet werden. Der Achsenabschnitt b dient dazu, die Gerade in y-Richtung zu
verschieben. Die explizite Form einer Geraden besitzt jedoch den Nachteil, dass man mit
ihr keine Geraden parallel zur y-Achse beschreiben kann, weil dafür die Steigung m = ∞
sein müsste. Aus diesem Grund wird die explizite Form nur selten in der Bildverarbeitung
9
a)
b)
y
c)
y
y
g
m = dx
dy
l(2)
g
v
dy
dx
d
g
p
b
a
x
g: l(t) = p + tv
g: y = m x + b
x
x
g: x cos a + y sin a - d = 0
Abbildung 2.2: Verschiedene Geradengleichungen.
benutzt.
Die parametrische Darstellung einer Geraden entsteht duch die Addition eines Punktes
mit einem Vektor, der parallel zu dieser Geraden verläuft (siehe Abbildung 2.2 b). Die
Parameterdarstellung hat die Form
l(t) = p + tv
(2.1)
mit dem Parameter t ∈ R, dem Punkt p ∈ R2 und dem Vektor v ∈ R2 . Über den Parameter
t ist es möglich, den Vektor zu skalieren und damit zu Punkten zu gelangen, die auf der
Gerade liegen.
Die implizite Darstellung einer Geraden ergibt sich durch einen Punkt p auf dieser Geraden und einem Normalenvektor n, der orthogonal auf der Geraden steht. Für jeden Punkt x
auf dieser Geraden gilt:
n · (x − p) = 0,
n, x, p ∈ R2 ,
knk = 1
(2.2)
Durch Umformen von (2.2) kann man die Hessesche Normalform1 herleiten. Dazu beschreibt man den Normalenvektor n durch seinen Winkel zur x-Achse. Schreibt man für die
Vektoren x und p die x- und y-Komponente untereinander in eine Klammer, was als Komponentendarstellung eines Vektors bezeichnet wird, ergibt sich aus (2.2) die Gleichung:
!
cos α
sin α
1
·
x − px
y − py
nach Ludwig Otto Hesse (1811 – 1874)
10
!
= 0,
α ∈ [0, 2π)
Bildet man nun das Skalarprodukt der beiden Vektoren und löst daraufhin die Klammern
auf, ergibt sich:
(x − px ) cos α + (y − py ) sin α = x cos α + y sin α − px cos α − py sin α = 0
{z
}
|
=:d
Dabei entspricht px cos α − py sin α dem Abstand d des Punktes p zum Ursprung. Dadurch
ist ein Vektor der Länge d mit dem Winkel α zur x-Achse definiert auf dem orthogonal die
Gerade steht (siehe Abbildung 2.2 c). Die Richtung des Vektors, beziehungsweise das Vorzeichen des Abstandes d, ist dabei wichtig, um den Wertebereich des Winkels auf α ∈ [0, π)
zu beschränken. Die Gleichung der Hesseschen Normalform lässt sich somit beschreiben
durch
x cos α + y sin α − d = 0
(2.3)
mit α ∈ [0, π) und d ∈ R. Durch (2.3) lassen sich mit zwei Skalaren beliebige Geraden im
R2 darstellen, was diese Form der Geradengleichung für das Finden von Geraden besonders
attraktiv macht.
2.1.2 Kreise
Geometrisch kann ein Kreis durch alle Punkte beschrieben werden, die zu einem fest definierten Mittelpunkt den gleichen Abstand haben. Ein Kreis ist also über seinen Mittelpunkt
und den Abstand von diesem Mittelpunkt zu seinem Kreisrand definiert. Dabei wird dieser
Abstand auch als Radius bezeichnet (siehe Abbildung 2.3).
Erstellt man mit diesem Wissen eine Gleichung, die einen Kreis beschreibt, kommt man
so zur Koordinaten- beziehungsweise impliziten Form der Kreisgleichung. Sie lässt sich
durch
(x − mx )2 + (y − my )2 − r 2 = 0
(2.4)
beschreiben, mit dem Mittelpunkt (mx , my ) ∈ R2 und dem Radius r ∈ R. Demnach liegen
alle Punkte (x, y), die die Gleichung (2.4) erfüllen auf dem Kreisrand.
2.1.3 Ellipsen
Im vorherigen Abschnitt wurde die implizite Form eines Kreises nach (2.4) eingeführt. Die
implizite Gleichung einer Ellipse, ist von einer etwas allgemeineren Form und kann be-
11
y
r
(mx ,my )
x
Abbildung 2.3: Kreisrand mit Mittelpunkt und Radius.
schrieben werden durch
λ1 x2 + λ2 y 2 − c = 0
(2.5)
mit λ1 , λ2 ∈ R+ und c ∈ R [8]. In dieser Form liegt die Ellipse mit ihrem Mittelpunkt im
Koordinatenursprung und ist entlang der x- und y-Achse verzerrt beziehungsweise skaliert
(siehe Abbildung 2.4). Ihre Haupt- und Nebenachsen liegen dabei auf den Koordinatenachsen.
y
s3
s2
m
l1 x2 + l2 y2 - c = 0
s1
x
s4
s1s2 Hauptachse
s3s4 Nebenachse
Abbildung 2.4: Eine Ellipse in impliziter Form und ihre Achsen.
Möchte man Ellipsen beschreiben, die beliebig in der Ebene liegen, benötigt man eine
allgemeinere Form der Gleichung (2.5). Zum einen möchte man Ellipsen um ihren Mittelpunkt drehen, sodass die Achsen der Ellipse nicht mehr auf den Koordinatenachsen liegen.
12
Zum anderen möchte man die Ellipse in beliebiger Richtung im Koordinatensystem verschieben können. Um diese allgemeingültige Ellipsengleichung herzuleiten, schreibt man
zunächst (2.5) in der Form:
!
!
λ
x
0
1
−c=0
x y
y
0 λ2
| {z }
=:D
In etwas kürzerer Form ergibt sich daraus:
xT Dx − c = 0
(2.6)
Die Ellipse kann in dieser Form um den Koordinatenursprung durch die Rotationsmatrix R
um den Winkel α gedreht werden. Ersetzt man in (2.6) xT durch xT R und x durch RT x,
ergibt sich die Gleichung:
xT RDRT x − c = 0 mit R =
cos α − sin α
sin α
cos α
!
Dadurch erhält man eine Ellipse, die beliebig um den Koordinatenursprung gedreht werden
kann. Möchte man die Ellipse zusätzlich noch in der Ebene verschieben, benötigt man einen
Verschiebungsvektor v. Verschiebt man nun in der obigen Gleichung den Vektor x um v
kommt man zu der Gleichung:
(xT − vT )RDRT (x − v) − c = 0
(2.7)
Durch Abkürzen von RDRT durch A und das Auflösen der Klammern erhält man:
xT Ax − 2xT |{z}
Av + vT Av − c = 0
| {z }
=:b
=:d
Als letzten Schritt lässt sich Av durch b und vT Av − c durch d ersetzen. Damit erhält
man die implizite Ellipsengleichung durch die sämtliche Ellipsen in der Ebene beschrieben
werden können:
xT Ax − 2xT b + d = 0
(2.8)
Durch die Gleichung (2.8) lassen sich allerdings nicht nur Ellipsen, sondern auch sämtli-
13
che Kegelschnitte wie Hyperbeln und Parabeln beschreiben. Welcher Kegelschnitt beschrieben wird, kann anhand der Matrix D aus (2.6) bestimmt werden [8]:
• Existiert nur ein Element in der Matrix, das ungleich Null ist, beschreibt die Gleichung eine Parabel.
• Existieren zwei Elemente in der Matrix mit gleichem Vorzeichen, die ungleich Null
sind, liegt eine Ellipse vor.
• Existieren zwei Elemente in der Matrix mit unterschiedlichem Vorzeichen, die ungleich Null sind, liegt eine Hyperbel vor.
2.2 Bildverarbeitung
Die Bildverarbeitung beschäftigt sich mit dem Speichern, Manipulieren und Anzeigen von
Bilddaten. Es geht allerdings nicht um den kreativen Aspekt Bilder- und Bildelemente besonders ansprechend zu arrangieren, was als Bildbearbeitung bezeichnet wird, sondern um
die mathematische Grundlage auf der Bilddaten in einem Computersystem basieren. Sie
darf deswegen nicht mit der Benutzung von Grafikprogrammen gleichgesetzt werden, sondern bezeichnet die Entwicklung von Methoden und Algorithmen aus denen diese Grafikprogramme bestehen [22].
Die Manipulation digitaler Bilddaten spielt beim Finden von Strukturen in Bildern eine
große Rolle. Durch geeignete Vorverarbeitungsschritte kann das Ergebnis beim Detektieren
der Strukturen erheblich verbessert werden. Gerade da, wo das menschliche Auge Geraden,
Kreise, Ellipsen oder andere Strukturen schnell und zuverlässig findet, sind die Ergebnisse
eines Computers aufgrund schlecht aufgenommener und verrauschter Bilder oftmals sehr
mangelhaft (siehe Abbildung 2.5). Hier liefert die Bildverarbeitung Methoden, um Eingabedaten so aufzubereiten, dass auch aus schlecht aufgenommenen Bildern Strukturinformationen extrahiert werden können.
2.2.1 Digitale Bilder
Die Grundlage der Bildverarbeitung auf einem Rechner bilden digitale Bilder. Ein digitales
Bild besteht aus einem Raster dessen Elemente einem Bildpunkt oder auch Pixel2 entspre2
Pixel = Picture Element
14
Abbildung 2.5: Trotz stark verrauschter Bilder kann das menschliche Auge immer noch
geradenhafte Strukturen erkennen.
chen. Man kann sich ein digitales Bild als zweidimensionale Tabelle vorstellen, in deren
Felder diskrete Werte gespeichert sind. Bei Grauwertbildern sind dabei die jeweiligen Helligkeitsinformation für jedes Pixel in der Tabelle gespeichert. Bei Farbbildern werden die
Farbinformationen in ein Datenwort kodiert, das wiederum an der entsprechenden Position
der Tabelle abgelegt wird. Häufig wird dabei das RGB-Farbmodell verwendet, in dem sich
eine Farbe aus Rot-, Grün- und Blauanteilen zusammensetzt. Die Farbtanteile des gespeicherten Datenwortes werden auch als Bänder bezeichnet, sodass ein RGB-Bild aus einem
roten, grünen und blauen Band besteht. Im weiteren Verlauf dieser Arbeit wird immer wieder von digitalen Bildern die Rede sein. Deswegen an dieser Stelle einige wichtige Definitionen:
Als Bildkoordinaten bezeichnet man die Position eines Pixels in einem Bildraster (siehe
Abbildung 2.6). Um die genauen Koordinaten in einem Bild anzugeben, ist ein einheitliches
Koordinatensystem für Bilder notwendig. In den meisten Fällen wird ein Koordinatensystem verwendet bei dem der Koordinatenursprung in der linken oberen Ecke des Bildes sitzt.
Die x-Achse verläuft dabei vom Koordinatenursprung in die rechte obere Ecke des Bildes
und die y-Achse verläuft vom Koordinatenursprung in die linke untere Ecke des Bildes.
Im Vergleich zu einem „normalen“ mathematischen Koordinatensystem ist hier also die yAchse an der x-Achse gespiegelt. Dieses Koordinatensystem entstand wahrscheinlich durch
den Röhrenmonitor bei dem ein Kathodenstrahl von der linken oberen Ecke der Bildfläche
Zeile für Zeile in die untere rechte Ecke der Bildfläche läuft und dabei das Monitorbild auf
der Bildfläche erzeugt [22].
15
(w-1, 0)
(0,0)
y
x
(0, h-1)
Abbildung 2.6: Bildraster der Größe w × h im Bildkoordinatensystem.
Die Höhe h und Breite w eines rechteckigen Bildrasters wird als Bildgröße bezeichnet
und wird in Pixel angegeben. Dabei bezeichnet man die Anzahl der Zeilen des Bildrasters
als Höhe und die Anzahl der Spalten des Bildrasters als Breite.
Die Bildauflösung stellt das Verhältnis des digitalen Bildes in einer reale Größe wie Meter oder Inch dar. Sie gibt an, wieviele Pixel einer realen Längeneinheit entsprechen. Häufig
wird dabei das Verhältnis „dots per inch“ (dpi) verwendet. Diese Verhältnis ist zum Beispiel
wichtig beim Einscannen von Bildern und sagt aus, wie häufig ein Bild innerhalb einer bestimmten Fläche abgetastet wird. Eine Auflösung von zum Beispiel 600 dpi bedeutet, dass
das eingescannte Bild auf einer Fläche von 1 inch2 , 600×600 mal abgetastet wird und somit
die reale Bildfläche auf 360.000 Pixel abgebildet wird. Die meisten Bilder haben die gleiche horizontale und vertikale Auflösung, was quadratischen Pixeln entspricht. Jedoch kann
es zum Beispiel durch bauliche Ungenauigkeiten dazu kommen, dass sich die horizontale
und vertikale Auflösung eines Fotosensors unterscheidet, sodass Höhe und Breite der Pixel
unterschiedlich sein können.
Die Farbtiefe eines Bildes gibt an, mit wieviel Bit die Farbe beziehungsweise Helligkeit
eines Pixels kodiert ist. Bei einer Auflösung von k Bit, wird der Farbwert also auf 2k Werte
abgebildet. Je höher die Auflösung, desto genauer können Farb- oder Helligkeitsinformationen unterschieden werden.
Als Nachbarn eines Pixels bezeichnet man alle Pixel, die an dieses angrenzen. Als 4Nachbarn werden dabei die vier Pixel (x, y − 1), (x − 1, y), (x + 1, y) und (x, y + 1) für
16
ein Pixel mit der Position (x, y) bezeichnet. Der Abstand eines Pixels zu einem seiner 4Nachbarn ist dabei eins. Darüber hinaus existieren noch die vier diagonalen Nachbarn mit
den Koordinaten (x − 1, y − 1), (x + 1, y − 1), (x − 1, y + 1) und (x + 1, y + 1), die
√
den Abstand 2 für ein Pixel (x, y) besitzen. Zusammen werden die 4-Nachbarn und die
diagonalen Nachbarn als 8-Nachbarn bezeichnet [10].
Grauwertbilder
Grauwertbilder oder auch Intensitätsbilder speichern für jedes Pixel einen Helligkeits- beziehungsweise Intensitätswert. Häufig wird zum Kodieren der Helligkeit eine Farbtiefe von
8 Bit benutzt, was einem Helligkeitswert zwischen 0 und 255 entspricht. Dabei bezeichnet
der Wert 0 ein komplett schwarzes Pixel und der Wert 255 ein rein weißes Pixel. Im Folgenden sind Grauwertbilder mit einer Auflösung von 8 Bit gemeint, wenn im Allgemeinen
von Bildern gesprochen wird.
Mathematisch gesehen kann ein Grauwertbild als diskrete Funktion beschrieben werden
(siehe Abbildung 2.7). Sie bildet dabei eine Pixelposition (x, y) auf einen diskreten Helligkeitswert ab. Die Bildfunktion I mit der Auflösung k hat dabei die Form
I(x, y) ∈ {0, 1, . . . , 2k − 1}
(2.9)
mit (x, y) ∈ N2 und k ∈ N+ .
Beim Finden von Strukturen in Bildern werden häufig Grauwertbilder anstatt Farbbilder
verwendet. Farbbilder haben den Nachteil, dass in ihnen unterschiedliche Farbkomponenten getrennt voneinander kodiert sind. Zum Beispiel sind in einem RGB-Farbbild der Rot-,
Grün-, und Blauanteil eines Pixels getrennt gespeichert. Da eventuell Kanten oder Strukturen nur in einem der drei Farbanteile auftauchen, müssen alle drei Farbanteile nach Strukturen durchsucht werden, was aufwendig und wenig effizient ist. Aus diesem Grund rechnet
man häufig Farbbilder vor dem Suchen nach Strukturen in Grauwertbilder um.
2.2.2 Punktbasierte Operationen
Eine wichtiger Teilbereich der Bildverarbeitung ist das Manipulieren von Farb- und Helligkeitswerten von Pixeln in einem Bild. Praktische Anwendungen sind unter anderem das
Aufhellen oder Abdunkeln eines Bildes, die Manipulation des Kontrasts oder die Segmentierung anhand von Schwellwerten. Was alle diese Manipulationsmethoden gemeinsam ha-
17
Abbildung 2.7: Das Orginalbild (links), als diskrete Bildfunktion (rechts) in Abhängigkeit
einer Pixelposition.
ben ist, dass sie für jedes Pixel die gleiche Operation, unabhängig von der Position des Pixels im Bild, anwenden. Es wird also ein Pixel aufgrund seiner Helligkeits- beziehungsweise Farbinformation verändert und der manipulierte Wert wieder an die gleiche Stelle im Bild
zurückgeschrieben. Mathematisch entspricht das einer Abbildung von einem Ursprungs- in
ein Zielbild durch eine Manipulationsfunktion und kann beschrieben werden durch:
I 0 (x, y) ← f (I(x, y))
Da diese Operationen ausschließlich vom jeweiligen Pixel abhängen, spricht man von punktbasierten Operationen. Entscheidend dabei ist, dass die manipulierten Pixel wieder an ihre
ursprüngliche Position zurückgeschrieben werden und somit die so genannte Bildgeometrie
erhalten bleibt.
Als einfaches Beispiel soll die Invertierung eines 8 Bit-Grauwertbildes dienen. Die Invertierunsfunktion ist definiert mit:
f (I(x, y)) = 255 − I(x, y)
Wendet man diese Funktion auf alle Pixel im Bild an, werden sämtliche Helligkeitswerte
im Bild invertiert. So wird zum Beispiel ein schwarzes Pixel zu einem weißen Pixel, ein
18
weißes Pixel wird zu einem schwarzen Pixel.
Ein weiteres Beispiel ist die Manipulation der Helligkeit eines Bildes. Durch einfaches
Addieren beziehungsweise Subtrahieren eines konstanten Wertes auf alle Pixel lässt sich die
Helligkeit eines Bildes anpassen. Die Manipulationsfunktion sieht dabei folgendermaßen
aus:
f (I(x, y)) = I(x, y) + a,
a∈Z
Bei dieser Manipulation der Helligkeitswerte muss darauf geachtet werden, dass der zulässige Wertebereich (zum Beispiel 0 – 255 bei 8 Bit-Bildern) nicht über oder unterschritten
wird. Gegebenenfalls müssen die manipulierten Werte auf den minimalen oder maximalen
Wert des Wertebereichs abgebildet werden, was man auch als Clamping bezeichnet. Das
Ergebnis einer stufenweisen Aufhellung eines Bildes ist in Abbildung 2.8 zu sehen.
Helligkeit reduziert um 80%
Orginalbild
Helligkeit erhöht um 80%
Abbildung 2.8: Verschiedene Helligkeitsstufen eines Bildes.
2.2.3 Ortsbasierte Operationen
Punktbasierte Operationen ermöglichen es, Pixelwerte in einem Bild zu manipulieren. Sie
können jedoch keine Bildmanipulationen vornehmen, die abhängig von ihrer Umgebung
sind. So entsteht zum Beispiel das Bildrauschen in Abbildung 2.5 dadurch, dass sich die
Helligkeitswerte einiger Pixel sehr stark von ihrer Umgebung absetzen und so den Eindruck
eines verrauschten Bildes erzeugen. Hier können ortsbasierte Operationen helfen, da sie
neben dem zu manipulierenden Pixelwert auch noch weitere Pixel aus dessen Umgebung in
die Berechnung mit einfließen lassen.
Eine Eigenschaft von punktbasierten Operationen ist, dass zum Manipulieren eines Pixelwertes nur der ursprüngliche Pixelwert an der gleichen Stelle für die Berechnung des neuen
19
Pixelwertes berücksichtigt wird. Bei ortsbasierten Operationen hingegen werden zur Berechnung des neuen Pixelwertes zusätzlich noch weitere Pixelwerte aus der Umgebung des
zu manipulierenden Pixels verwendet. Was beide Operationen gemeinsam haben ist, dass
sie den manipulierten Wert an die gleiche Stelle im Bild zurückschreiben und somit die
so genannte Bildgeometrie nicht verändern. Ortsbasierte Operationen werden dabei häufig
auch als Filter bezeichnet.
Man kann sich einen Filter als zweidimensionale Maske vorstellen, die mit ihrem Mittelpunkt auf ein Pixel im Bild gelegt wird. Um dieses Pixel zu manipulieren, werden alle
Pixel, die von der Maske abgedeckt werden, in die Berechnung des neuen Pixelwertes mit
einbezogen. Der auf das zu manipulierende Pixel gelegte Maskenmittelpunkt, wird dabei
als Hot Spot bezeichnet. Den Bereich den die Maske abdeckt, wird Filterregion genannt.
Schiebt man diese Maske mit ihrem Hot Spot nun über jedes Bildpixel und schreibt das
Ergebniss des manipulierten Pixels in ein neues Bild, wird der Filter auf das gesamte Bild
angewendet und ein neues manipuliertes beziehungsweise gefiltertes Bild erstellt.
Um sich eine Bildmanipulation durch Filter besser vorstellen zu können, folgt ein Beispiel zum Glätten von Bildern. Durch dieses Glätten ist es möglich, Bildrauschen (siehe
Abbildung 2.5) zu reduzieren. Die Grundidee dabei ist, dass zu manipulierende Pixel durch
einen Durchschnitt aller angrenzenden Pixelwerte zu ersetzen. Dadurch werden in der Bildfunktion (2.9) Extremwerte auf einen Durchschnitt der jeweiligen Region abgebildet und
die Funktion somit geglättet. Die Filterfunktion, die ein Helligkeitswert I(x, y) auf einen
manipulierten Helligkeitswert I 0 (x, y) abbildet, kann zum Beispiel folgendermaßen definiert werden:
f (I(x, y)) =
1
9
( I(x − 1, y − 1) + I(x, y − 1) + I(x + 1, y − 1) +
I(x − 1, y)
+ I(x, y)
+ I(x + 1, y)
+ (2.10)
I(x − 1, y + 1) + I(x, y + 1) + I(x + 1, y + 1) )
Diese Filterfunktion addiert alle Grauwerte in der Umgebung des zu manipuliernden Pixels
und teilt die Summe durch die Anzahl der aufsummierten Werte. Dadurch wird für das jeweilige Pixel der Mittelwert aller Helligkeitswerte seiner Region gebildet. Zur Berechnung
des neuen Pixelwertes werden alle Pixel benutzt, die an das zu manipulierende Pixel angrenzen. Somit ergibt sich eine Filterregion der Größe 3 × 3. Wird diese Funktion nun auf jedes
Pixel im Ursprungsbild angewandt und das Ergebnis in ein Zielbild geschrieben, werden
starke Maxima und Minima, wie sie in verrauschten Bildern häufig auftreten, geglättet.
20
Lineare und nichtlineare Filter
Bei ortsbasierten Operationen beziehungsweise Filtern können zwei Gruppen unterschieden
werden: Die linearen und die nichtlinearen Filter. Vom Prinzip arbeiten beide ähnlich. Beide
benutzen zur Berechnung eines neuen Pixelwertes weitere Pixel aus der Umgebung des zu
manipulierenden Pixels. Was beide Filter unterscheidet ist, wie der neue Pixelwert berechnet
wird.
H=
i
j
I(x,y)
I(x,y)
Abbildung 2.9: Durch Anwendung der Filtermatrix auf ein Bild I entsteht das manipulierte
Bild I’.
Bei linearen Filtern erfolgt die Berechnung des neuen Pixelwertes in linearer Form, das
heißt als gewichtete Summation [22]. Ein Beispiel dafür ist die Filterfunktion (2.10), die,
durch eine einfache Durchschnittsbildung über die Helligkeitswerte in einem bestimmen
Bereich, ein Eingangsbild glättet. Um lineare Filter übersichtlich zu beschreiben, ist es
möglich diese in Matrixform aufzuschreiben. So kann zum Beispiel der Filter aus (2.10)
auch als Matrix der Größe 3 × 3 beschrieben werden,


1 1 1
1

H(i, j) = 1 1 1
9
1 1 1
(2.11)
mit i, j ∈ {−1, 0, 1}. Der Hot Spot liegt hier auf dem mittleren Element der Matrix mit
der Position (0, 0) und wird über dem Pixel positioniert, das manipuliert werden soll. In
dieser Schreibweise wird die verwendete Matrix auch als Filtermatrix bezeichnet. Die Grö-
21
ße dieser Filtermatrix definiert dabei, welche umliegenden Pixel in die Berechnung des zu
manipulierenden Pixels mit einbezogen und wie stark diese gewichtet werden. In diesem
Beispiel sind alle Pixel gleichermaßen in die Berechnung des neuen Pixelwertes mit einbezogen, weshalb an jeder Position der Filtermatrix eine 1 steht. Es werden also alle Pixelwerte der Berechnung gleich gewichtet. Abbildung 2.9 zeigt, wie durch einen linearen Filter in
Form einer Filtermatrix ein Ausgangsbild auf ein gefiltertes Bild abgebildet werden kann.
Allgemein beschreibt man lineare Filter durch eine Filtermatrix H(i, j) der Größe w × h.
Geht man davon aus, dass w und h ungerade sind und sich der Hot Spot auf dem mittleren
Element der Filtermatrix befindet, ergibt sich ein gefiltertes Bild I 0 (x, y) durch folgende
Gleichung:
j=d h2 e
I 0 (x, y) =
X
i=d w
e
2
X
w
c i=−b 2 c
j=−b h
2
I(x + i, y + j) · H(i, j)
Mathematisch gesehen sind sowohl Bilder als auch Filter Funktionen. Wendet man einen
Filter auf ein Bild an, so ist das nichts anderes als eine Verknüpfung dieser Funktionen.
Dieses Verknüpfen wird in der Mathematik als Faltung bezeichnet und kann beschrieben
werden als:
I0 = I ∗ H
Im Gegensatz zu linearen Filtern, können nichtlineare Filter nicht durch gewichtete Summationen ausgedrückt werden. Diese Filter können durch nichtlineare Ausdrücke beschrieben werden und bieten damit umfassende Möglichkeiten Bilder zu manipulieren. Jedoch
arbeiten sie wie bereits weiter vorne erwähnt nach dem gleichen Prinzip wie lineare Filter.
Ein Beispiel für nichtlineare Filter sind so genannte Minimum- und Maximum-Filter. Sie
sind zum Beispiel dafür geeignet, hohe Maxima und Minima in Bildfunktionen zu eliminieren, die nur ein Pixel umfassen. Die Arbeitsweise dieser Filter ist dabei denkbar einfach:
Jedes zu manipulierende Pixel wird durch den maximalen beziehungsweise minimalen Pixelwert innerhalb der Filterregion ersetzt. Durch einen Minimum Filter der Größe 3 × 3
ergibt sich dadurch ein manipuliertes Bild:
I 0 (x, y) = min {I(x + i, y + j) | i, j ∈ {−1, 0, 1}}
Durch diese Filterung wird jeweils das zu manipulierende Pixel durch das dunkelste Pixel
innerhalb der Filterregion ersetzt. Damit kann zum Beispiel Rauschen mit weißen Pixeln
eliminiert werden.
22
Glätten von Bildern
Häufig treten in Bildern Störungen auf, die mit der eigentlichen Bildinformation nichts zu
tun haben. Man spricht dabei von Bildrauschen (siehe Abbildung 2.5). Dieses Rauschen
besteht dabei aus Pixeln, deren Helligkeitswerte stark von ihrer Umgebung abweichen. Mathematisch gesehen sind diese Pixel starke Maxima und Minima in der Bildfunktion, sodass
in der Bildfunktion starke Steigungen und Gefälle entstehen (siehe Abbildung 2.10). Es
ist möglich, über Glättungsfilter das Rauschen in Bildern zu reduzieren. Man spricht von
einer Glättung, da die Minima und Maxima in der Bildfunktion von diesen Filtern an die
umliegenden Funktionswerte angepasst werden und die Funktion somit „geglättet“ wird.
Abbildung 2.10: Orginalbild (links) und die dazugehörige diskrete Bildfunktion (rechts).
Man kann deutlich erkennen, dass das obere Bild erheblich weniger Extremwerte aufweist,
als das verrauschte untere Bild.
Der einfachste Glättungsfilter ist ein Boxfilter nach (2.11) wie er schon im vorigen Abschnitt beschrieben wurde [13]. Dieser Glättungsfilter berechnet einen Durchschnitt aller
Pixelwerte innerhalb einer bestimmten Umgebung und weist diesen Durchschnitt dem zu
manipulierenden Pixel zu. Man spricht hier von einem Boxfilter, da alle Elemente seiner
23
Filtermatrix gleich groß sind und die Matrix deswegen im dreidimensionalen Raum eine
Box beschreiben würde (siehe Abbildung 2.11).
Abbildung 2.11: 3D-Plot der Filtermatrix eines Boxfilter (links) und eines Gaußfilters (rechts).
Allerdings besitzt der Boxfilter aufgrund seiner Eigenschaften Nachteile. So werden alle
Pixelwerte, die in die Berechnung mit einbezogen werden gleich gewertet, egal wie weit sie
vom Hot Spot entfernt liegen. Es wäre sinnvoller, die Pixel, die näher am Hot Spot liegen,
stärker zu gewichten und diejenigen, die weiter entfernt liegen, weniger stark. Ein Filter, der
diese Eigenschaften besitzt, ist der Gaußfilter. Die Elemente seiner Filtermatrix entsprechen
einer dreidimensionalen Gaußglocke, die im mittleren Matrixelement ein Maximum hat und
zu den Rändern hin abfällt (siehe Abbildung 2.11). Der Hot Spot wird somit am stärksten
gewichtet und beinflusst den neu berechneten Pixelwert des zu manipulierenden Pixels am
meisten. Die Filtermatrix eines 5 × 5 Gaussfilters sieht dabei folgendermaßen aus [22]:

0 1 2 1 0

1
1 

2
57 
1

0


3 5 3 1


5 9 5 2

3 5 3 1

1 2 1 0
Die 57 im Nenner des Bruchs mit dem jedes Element der Matrix multipliziert wird, ergibt
sich durch das Aufsummieren aller Matrixelemente. Durch diese Normierung ist sichergestellt, dass sich der neu berechnete Pixelwert noch im gültigen Wertebereich der Bildfunktion befindet. Die Anwendung eines Gaußfilters auf ein verrauschtes Bild ist in Abbildung 2.12 zu sehen.
Nachdem nun zwei lineare Glättungsfilter vorgestellt wurden, soll nun noch ein nicht-
24
Verrauschtes Bild
Filterung über
5x5 Gauß Filter
Abbildung 2.12: Bild vor und nach einer Glättung durch den 5x5 Gaußfilter.
linearer Glättungsfilter erläutert werden. Ein Nachteil von Gauß- und Boxfiltern ist, dass
sie zwar ein Bild glätten, aber der neu berechnete Helligkeitswert nicht unbedingt einem
Helligkeitswert der Pixel entspricht, die für die Berechnung verwendet wurden. Es werden
also Helligkeiten mit Werten ersetzt, die eventuell im Bild gar nicht vorkommen. Dadurch
entsteht das Problem, dass Gauß- und Boxfilter Kanten verwischen. Platziert man einen der
Filter genau auf einem Schwarz-Weiß Übergang in einem Bild, wäre das Ergebniss für das
gefilterte Bild ein graues Pixel, da der Durchschnitt aller schwarzen und weißen Pixel in der
Filterregion verwendet wird. Je nach der Größe der Filterregion wird die Kante mehr oder
weniger stark verwischt (siehe Abbildung 2.13).
Durch den Medianfilter lässt sich dieses Problem beheben. Er bildet nicht den Durchschnitt der Pixelwerte innerhalb der Filterregion, sondern verwendet den Median aller Pixelwerte für das zu manipulierende Pixel. Dadurch werden keine Helligkeitsinformationen
in dem gefilterten Bild verwendet, die nicht schon im Orginalbild vorgekommen sind, womit sich das Verwischen von Kanten verhindern lässt. Das Prinzip eines Medianfilters ist
in Abbildung 2.14 beschrieben. Wendet man den Medianfilter auf eine ungerade Anzahl
von Helligkeitswerten an, so ist das Ergebnis (wie man in Abbildung 2.14 erkennen kann)
das mittlere Element der sortierten Werte. Liegt jedoch eine gerade Zahl von Helligkeitswerten vor, wird der Mittelwert der beiden mitteleren Elemente berechnet und dieser Wert
als Median verwendet. Dadurch wird aber wieder ein Pixelwert berechnet, der so im Bild
nicht vorkommt. Aus diesem Grund sollte bei einem Medianfilter immer eine Filtermaske
25
I(x) = I(x) * h(x)
h(x)
I(x)
I(x)
x
x
x
Abbildung 2.13: Eindimensionaler Helligkeitsverlauf vor und nach der Anwendeung des
Gaußfilters. Es ist deutlich zu erkennen, dass die Faltung die Kante verwischt.
I(x,y)
123
93
248
12
45
177
32
233
102
Sortieren
12
32
45
93
102
123
177
233
248
Abbildung 2.14: Beispiel eines 3x3 Medianfilters.
26
Median
102
verwendet werden, die eine ungerade Anzahl von Helligkeitswerten liefert.
Kantenfindung und Gradientenbilder
Möchte man Kanten in Bildern finden, stellt sich zunächst die Frage wie Kanten eigentlich
definiert sind. Im Allgemeinen wird eine Struktur als Kante bezeichnet, wenn sich Helligkeitsinformationen von Pixel auf kleinem Raum und entlang einer ausgeprägten Richtung
ändern [22]. Je kleiner der Raum ist und je stärker sich die Helligkeitsinformationen in
diesem Raum ändern, desto Stärker wird eine Kante wahrgenommen.
Betrachtet man die Funktion eines Bildes, erkennt man an den Stellen an denen Kanten auftreten, einen starken Anstieg beziehungsweise Abfall der Bildfunktion. Es ist also
möglich, aufgrund von Steigungen innerhalb der Bildfunktion Kanten zu detektieren. Die
Steigung einer Funktion ist aber genau deren erste Ableitung. Das bedeutet, dass Kanten in
einer Bildfunktion in Form von Maxima und Minima in der ersten Ableitung der Funktion
auftreten. Um dies besser zu verstehen, betrachtet man zunächst eindimensionale Helligkeitsverläufe. In Abbildung 2.15 ist gut zu erkennen, dass, an den Stellen an denen sich die
Helligkeitswerte ändern, die Bildfunktion I(x) steiler wird und somit in der ersten Ablei˜
tung I(x)
der Bildfunktion Maxima entstehen, wenn die Helligkeit zunimmt beziehungsweise Minima entstehen, wenn die Helligkeit abnimmt.
I(x)
x
~
I(x)
x
I(x)
Abbildung 2.15: Bildfunktion und erste Ableitung eines eindimensionalen Helligkeitsverlaufs. Bild nach [22].
27
Mit Hilfe der ersten Ableitung einer Bildfunktion können also Kanten gefunden werden.
Dabei ist die erste Ableitung für eine eindimensionale Funktion definiert durch:
df (x)
f˜(x) =
dx
(2.12)
dx ist dabei der Abstand zweier Punkte auf der x-Achse und df der Abstand der beiden
Funktionswerte der beiden Punkten. Das Verhältnis der beiden Abstände entspricht demnach der Steigung der Funktion zwischen den beiden verwendeten Punkten.
Aus der allgemeinen Ableitungsfunktion (2.12) wird nun versucht, eine Ableitungsfunktion für diskrete Bildfunktionen zu erstellen. Der Einfachheit halber werden zunächst wieder nur eindimensionale Helligkeitsverläufe für die Herleitung verwendet. Nimmt man die
Ableitung einer Funktion aus (2.12) entspricht df dem Abstand der zwei Pixelwerte die
genau an das zu untersuchende Pixel angrenzen. dx entspricht demnach dem Abstand der
Bildpositionen der verwendeten Pixel. Da die beiden Nachbarn des zu untersuchenden Pixels verwendet wurden, liegt dieser konstant bei zwei. Daraus ergibt sich die Ableitung im
Punkt x einer eindimensionalen diskreten Bildfunktionen durch:
I(x + 1) − I(x − 1)
˜
I(x)
=
2
(2.13)
Die Ableitung in der Form (2.13) wird dabei symetrisch genannt, da der zu untersuchende
Punkt symetrisch zwischen den beiden Bildpunkten liegt durch die die Steigung berechnet
wird [13]. Darüber hinaus existieren noch die vorwärtsgerichtete beziehungsweise rückwärtsgerichtete Ableitung der Form:
I(x + 1) − I(x)
˜
I(x)
=
2
und
I(x) − I(x − 1)
˜
I(x)
=
.
2
Im Folgenden wird als erste Ableitung einer Funktion jedoch nur die symetrische Form
nach (2.13) verwendet.
Überträgt man das Wissen über die erste Ableitung vom eindimensionalen in den zweidimensionalen Bildraum, kann die Ableitung eines Bildpunktes einmal in x- und einmal in
y-Richtung berechnet werden, sodass für jede Richtung ein Steigungswert entsteht. Fasst
man beide Werte als Vektor zusammen, zeigt dieser in die Richtung des steilsten Anstiegs.
28
Die Ableitung eines Bildpunktes entlang der x- und y-Koordinate ist also definiert durch:
1
∇I(x, y) =
2
I(x + 1, y) − I(x − 1, y)
I(x, y + 1) − I(x, y − 1)
!
Da es sich um eine mehrdimensionale Funktion handelt, wird die Ableitung auch partielle Ableitung genannt. Den entstandenen Vektor bezeichnet man als Gradientenvektor oder
Gradient [22]. Der Betrag des Gradienten | ∇I(x, y) | entspricht dabei der Steigung des
Bildpunktes (x, y). Je höher der Betrag des Gradienten ist, desto stärker ist die Kante auf
der der untersuchte Bildpunkt liegt. Weitere Eigenschaften des Gradientenvektors sind, dass
er senkrecht auf der dazugehörigen Kante steht und immer in den helleren Bereich der zwei
angrenzenden Regionen zeigt, die die Kante trennt.
Mit diesem Wissen ist es nun möglich, für jedes Pixel in einem Bild den Gradienten
zu berechnen. Speichert man den Betrag dieses Gradienten wiederum in einem Bild an
der Position des dazugehörigen Pixels, entsteht ein soganntes Gradientenbild. In diesem
Gradientenbild sind Kanten je nach ihrer Stärke hervorgehoben, sodass alle Pixel, die auf
einer Kante liegen, sichtbar sind. Es ist nun möglich, alle Pixel in einem Bild zu finden
deren Gradientenbetrag über einem festen Schwellwert liegt und so ein binäres Kantenbild
zu erzeugen.
Wenn man Gleichung (2.13) näher betrachtet, fällt auf, dass man diese auch als linearen
Filter aufschreiben kann, da es sich um eine gewichtete Summation handelt. Die Filtermatrix für eine Ableitung in x- beziehungsweise in y-Richtung würde dabei folgendermaßen
aussehen:
Hx (i, j) =
1
2
−1 0 1 ,

−1
1 
Hy (i, j) =  0 
2
1

(2.14)
Die Kantenfindung ist folglich nichts anderes, als ein gewöhnlicher linearer Filter wie er in
Abschnitt 2.2.3 erläutert wurde.
Ein Nachteil der gerade vorgestellten Filtermasken aus (2.14) ist, dass sie sehr anfällig
gegenüber Bildrauschen sind. Schon ein einzelnes verrauschtes Pixel, das zum Beispiel ganz
schwarz oder ganz weiß ist, kann die Berechnung des Gradienten fehlerhaft beeinflussen.
Es wäre besser, die Filtermasken zu erweitern, um sie so robuster gegenüber einzelnen
verrauschten Pixeln zu gestalten. Ein Filter, der diesen Anforderungen entspricht, ist der
29
so genannte Sobel-Operator [22]. Seine Filtermasken sehen dabei folgendermaßen aus:


−1 0 1
1

Hx (i, j) = −2 0 2 ,
8
−1 0 1

−1 −2 −1
1

Hy (i, j) =  0
0
0
8
1
2
1

Durch seine größere Filtermaske ist der Sobel-Operator robuster gegenüber einzelnen verrauschten Pixeln als (2.14). Außerdem wird die zentrale Spalte beziehungsweise Zeile etwas
stärker gewichtet. Eine praktische Anwendung des Sobel-Operators ist in Abbildung 2.16
zu sehen.
Abbildung 2.16: Von links nach rechts: Orginalbild, Sobel-Operator in x-Richtung, SobelOperator in y-Richtung, Gradientenbild.
Nachdem man zum Beispiel über den Sobel-Operator den Gradienten eines Pixels berechnet hat, lassen sich zwei wichtige Aussagen treffen: Zum einen wie stark die Kante
ist auf der das Pixel liegt, zum anderen welche ungefähre Richtung die Kante hat. Für die
Ergebnisse des Sobel-Operators mit der Filtermatrix H können die Gradientenwerte
Gx (x, y) = Hx ∗ I(x, y) und
Gy (x, y) = Hy ∗ I(x, y)
(2.15)
berechnet werden. Die Kantenstärke entspricht dabei dem Betrag des Gradienten und wird
bestimmt durch:
E(x, y) =
q
Gx (x, y)2 + Gy (x, y)2
(2.16)
Die lokale Kantenrichtung α eines Kantenpixels kann berechnet werden durch:
α = tan−1
Gy (x, y)
Gx (x, y)
(2.17)
In Abbildung 2.17 ist eine Kante mit einem Kantenpixel (kx , ky ) zu sehen, auf dessen Tan-
30
2.3 Finden von Strukturen
gente senkrecht der Gradient steht. Die lokale Kantenrichtung ist dabei der Winkel zwischen
der Tangente und der x-Achse.
(Gx ,Gy)
E
(kx ,ky)
a
Abbildung 2.17: Kantenpixel mit Gradient und lokaler Kantenrichtung.
Im vorherigen Abschnitt wurde erläutert wie festgestellt werden kann, ob ein Pixel auf einer Kante liegt. Diese Kanteninformation liegt aber nur lokal bei einem Pixel Es kann keine
Aussage über die Struktur oder Region gemacht werden, die von der Kante umschlossen
wird. Um zusammenhängende Regionen beziehungsweise Strukturen in einem Kantenbild
zu erhalten, existieren unterschiedliche Verfahren. Das Ziel dabei ist herauszufinden welches Pixel zu welcher Region gehört, wie viele Regionen im Bild existieren und vor allem
wo sich diese Regionen befinden. Diese Schritte werden auch Regionmarkierung oder Region Labeling genannt. Welche Region dabei gefunden werden soll, ist dabei natürlich von
der jeweiligen Anwendung abhängig. Im Falle eines Röntgenbildes mit projizierten Referenzkugeln wäre eine Unterteilung des Bildes in die Bereiche „projizierte Kugeln“ und
„restliches Bild“ sinnvoll (siehe Abbildung 2.18).
Eine Möglichkeit eine Region zu berechnen, die von einer Kante umschlossen wird, ist
das Konturverfolgsverfahren. Die Vorraussetzung hierbei ist, dass eine Region komplett von
einer Kante umschlossen ist. Die Kante, bestehend aus mehreren Kantenpixeln, wird als
Kontur bezeichnet. Ausgehend von einem Startkantenpixel der Region wird dabei die Kon-
31
Abbildung 2.18: Orginalbild (links) und markierte Regionen (rechts).
tur der Region solange verfolgt bis sie wieder am ursprünglichen Startpunkt angekommen
ist [22]. Alle Pixel, die sich nun innerhalb der Kontur befinden, gehören zu einer Region
und alle Pixel, die sich außerhalb der Kontur befinden, zu einer anderen. Eine geschickte
Umsetzung der Konturverfolg ist das Live Wire-Verfahren von Barrett und Mortensen, das
detailliert in [15] beschrieben ist.
Die Regionmarkierung eignet sich dazu, ein Bild in verschiedene Regionen zu unterteilen und jedes Pixel im Bild einer Region zuzuordnen. Neben dem gerade vorgestellten Verfahren existieren dazu noch viele weitere. Zur Weiterverarbeitung einer markierten Region
kann unter anderem ihr Schwerpunkt oder ihre Bounding Box berechnet werden. Allerdings
liefert das Verfahren keine algebraische Beschreibung der Regionen (siehe Abbildung 2.19).
Ein weiteres Verfahren, das ebenfalls auf Kantenbildern arbeitet und eine algebraische Beschreibung einer Region berechnet, wird im nächsten Kapitel vorgestellt.
32
Abbildung 2.19: Im linken Bild werden für erkannte Regionen der Schwerpunkt aller Pixel
und die Bounding Box eingezeichnet. Im rechten Bild wird eine Region algebraisch als
Kreis über einen Mittelpunkt und einen Radius beschrieben.
33
34
Am 18. Dezember 1962 meldete Paul V. C. Hough ein Patent [11] beim United States Patent Office an, in dem er beschreibt, wie geradenhafte Strukturen in Bildern erkannt werden können. Bis heute bildet dieses Patent die Grundlage für viele Verfahren, mit denen
sich algebraisch beschreibbare Strukturen in Bildern finden lassen. Nach seinem Erfinder
wird dieses Verfahren heutzutage allgemein als Hough Transformation (HT) bezeichnet. Inzwischen existieren unzählige Modifikationen und Verbesserungen der HT, die trotz allem
immer noch auf der ursprünglichen Idee von Paul V. C. Hough basieren [6]. So wird inzwischen die HT nicht mehr nur zum Finden von Geraden, sondern auch für Kreise, Ellipsen
oder komplexere Strukturen verwendet.
Die eigentliche Idee der HT ist, ein Gradientenbild (siehe Abschnitt 2.2.3) in einen Parameterraum zu übertragen. Man kann dabei den Ablauf der HT in drei Schritte unterteilen.
1. Als erstes wird ein diskreter Parameterraum aufgebaut, der in der Literatur auch häufig als Hough-Akkumulator oder Houghraum bezeichnet wird.
2. Der zweite Schritt beinhaltet das Füllen des Parameterraums, die eigentliche Transformation zwischen Bild- und Parametrraum.
3. Der dritte Schritt besteht aus der Ermittlung der besterkanntesten Strukturen aus dem
Parameterraum.
Diese drei Schritte sollen im Folgenden kurz beschrieben werden, um den allgemeinen Ablauf der HT zu verdeutlichen. Der gesamte Ablauf der HT ist in Abbildung 3.1 zu sehen.
Als erster Schritt wird ein Parameterraum gebildet. Dabei ist der Aufbau des Parameterraums abhängig von den Parametern die nötig sind, um die zu findenden Struktur zu beschreiben. Als einfaches Beispiel soll eine Gerade in der Hesschen Normalform nach (2.3)
dienen, die als Struktur gefunden werden soll. In dieser Form ist eine Gerade abhängig von
den beiden Parametern α und d. Für den Aufbau des Parameterraumes werden die beiden
35
Orginalbild
Geglättetes Bild
(z.B. Gauß-Filter)
Kantenfindung
(z.B. über Sobel Operator)
Kantenpixel
mittels Schwellwert
Parameterraum
für Geraden
Maximas Finden
Gefundene
Geraden
Abbildung 3.1: Ablauf einer Hough Transformation für Geraden. Als Vorverarbeitungsschritt wird das Orginalbild durch den Gauss-Filter geglättet. Danach werden mittels des
Sobel-Filters und einem festgelegtem Schwellwert mögliche Kantenpixel detektiert. Für
alle möglichen Geraden durch alle Kantenpixel, werden die dazugehörigen Parameter berechnet und die jeweiligen Zellen im Parameterraum inkrementiert. Nach dem Füllen des
Parameterraums wird nach Maxima gesucht und die gefundenen Geraden im Orginalbild
angezeigt.
36
Parameter diskretisiert und bilden jeweils eine Koordinatenachsen des Parameterraumes. Jede diskrete Position einer Zelle im Parameterraum entspricht so einem Parameterpaar (α, d),
das genau eine Gerade beschreibt. Für Geraden entsteht demnach ein zweidimensionaler Parameterraum. Allgemeiner ausgedrückt bildet eine algebraisch beschreibbare Struktur mit
den Parametern p = (p1 , ..., pn ) einen Parameterraum H(p) der Dimension n. Demnach
ist die Dimension eines Parameterraumes abhängig von der Anzahl der Parameter, die nötig
sind, um eine Struktur zu beschreiben.
Der zweite Schritt besteht aus dem Füllen des erstellten Parameterraumes. Hierfür wird
das zu untersuchende Gradientenbild Pixel für Pixel durchlaufen und über einen Schwellwert nach Kantenpixeln gesucht (siehe Abschnitt 2.2.3). Abhängig von der zu findenden
Struktur werden nun alle Möglichkeiten berechnet, wie die gesuchte Struktur das gefundene Kantenpixel durchlaufen kann. Jede dadurch entstehende Struktur wird dabei von anderen Parametern beschrieben. Bei einer Geraden werden zum Beispiel sämtliche Geraden
durch das gefundene Kantenpixel berechnet, so dass eine Geradenschar entsteht. Jede Geraden dieser Schar wird dabei von einem anderen Parameterpaar (α, d) beschrieben. Die
berechneten Parameterpaare entsprechen genau einer Zelle in dem zuvor definierten Parameterraum. Um nun den Parameterraum zu füllen, wird jede Zelle der berechneten Parameterpaare inkrementiert. Dadurch füllt sich der Parameterraum und es bilden sich Maxima
an den Stellen, an denen unterschiedliche Kantenpixel von der selben Struktur durchlaufen
werden. Mathematisch gesehen ist dieses Vorgehen eine Transformation T von einem diskreten Bildraum, in einen diskreten Parameterraum und kann durch T (x) = p, T : I → H
mit dem Ortsvektor x = (x, y) und dem Parametervektor p = (p1 , ..., pn ) ausgedrückt
werden.
Im dritten Schritt werden potentielle Strukturen aus dem Parameterraum herausgesucht.
Maxima im Parameterraum verweisen dabei über die Lage ihrer Zelle auf die Parameterkombination, die am wahrscheinlichsten der gesuchten Struktur entspricht (siehe Abbildung 3.2). Es gilt also die am höchsten gewerteten Zellen aus dem Parameterraum zu finden. Ein Problem, das dabei auftritt, ist, dass nicht nur eine einzelne Zelle, sondern auch die
Nachbarn in ihrer Umgebung hoch gewertet sein können. Aus diesem Grund wird versucht,
die am höchsten gewertete Zelle in einem gewissen Umkreis zu extrahieren. Dies kann über
einen Offset stattfinden, mit dem überprüft wird, ob die jeweilige Zelle die am höchsten
gewertete innerhalb einer Region ist.
Nach diesen drei Schritten liegen die parametrischen Beschreibungen der Strukturen vor,
die am besten erkannt wurden. Wie genau eine Struktur erkannt wurde, liegt dabei vor al-
37
Abbildung 3.2: Gefüllter Parameterraum (links) und die dazugehörigen Geraden im
Bildraum (rechts).
lem an der Diskretisierung des Parameterraumes. Es ist nun möglich, diese wieder in das
ursprüngliche Bild einzuzeichnen, um zu überprüfen, wie genau das gewählte Verfahren gearbeitet hat. Im Folgenden wird genauer auf die speziellen Verfahren der HT eingegangen,
die es ermöglichen, Geraden, Kreise, Ellipsen oder auch komplexere Strukturen zu finden.
Der wesentliche Unterschied zwischen den einzelnen Verfahren ist dabei der Aufbau und
das Füllen der jeweiligen Parameterräume. Trotz aller Unterschiede bilden die oben vorgestellten Schritte die Basis einer jeden HT und liegen jedem Verfahren zu Grunde.
3.1 Hough Transformation für Geraden
Geraden begegnen uns häufig in digitalen Bildern. Unabhängig ob in Fotografien, Zeichnungen oder synthetischen Bildern, geradenhafte Strukturen sind überall zu erkennen. In
digitalen Bildern bestehen Geraden aus einzelnen Pixeln, die sich durch ihren Helligkeitswert von der Umgebung absetzen und dabei auf einer Linie liegen. Nicht immer hängen die
Pixel einer Geraden zusammen, sondern werden von anderen Objekten im Bild überdeckt
oder durch Bildrauschen gestört.
Die Hough Transformation für Geraden [7], wurde in ihrer heutigen Form erstmals 1972
von Duda und Hart vorgestellt und baut dabei auf den Arbeiten von Hough auf. Sie beschreibt ein Verfahren, das einzelne Pixel zu einer Geraden zusammenfasst und die algebraische Beschreibung der Geraden berechnet. Dabei ist sie tolerant gegenüber Verdeckungen und Bildrauschen und liefert auch bei Eingabebildern mit schlechter Qualität noch gute
Ergebnisse [6].
38
3.1.1 Erstellen des Parameterraums
Wie bereits erwähnt, wird für die Darstellung von Geraden bei der HT die Hessesche Normalform nach (2.3) verwendet. Eine Gerade im R2 ist demzufolge abhängig vom Winkel
eines Vektors, relativ zur x-Achse sowie dessen Länge. Der Parameterraum wird also zweidimensional über den Winkel α und die Länge d gebildet. Zum Erstellen des Parameterraums sind aber noch zwei wichtige Punkte zu klären: Zum ersten, in welchen Wertebereichen liegen α und d, also welchen minimalen beziehungsweise maximalen Wert können
die beiden Parameter annehmen? Und zum zweiten, wie sind diese Wertebereiche aufgelöst
beziehungsweise diskretisiert?
Zuerst wird die Frage nach den Wertebereichen der Parameter geklärt. Es sollen in einem
Bild der Größe w × h sämtliche Geraden beschrieben werden. Als erstes wird der Koor-
dinatenursprung von der oberen linken Ecke des Bildes in die Bildmitte verschoben. Man
transformiert also das Bildkoordinatensystem, was den Vorteil hat, dass die Wertebereiche
für die Parameter klein gehalten werden (siehe Abbildung 3.3). Ausgehend von dem neuen
(0,0)
(w/2,h/2)
Abbildung 3.3: Der Wertebereich für den Abstand d im linken Bild der Größe w × h mit
√
dem Ursprung in der linken oberen Ecke des Bildes, muss [−w, w2 + h2 ] sein um beide
Geraden darzustelle. Im
√ rechten Bild
√ mit dem Ursprung in der Bildmitte reicht es aus den
Wertebereich auf [− 12 w2 + h2 , 12 w2 + h2 ] festzulegen. Bild nach [27].
Koordinatensystem, wird die Länge des Parameters d maximal, wenn die zu beschreibende
Gerade genau durch einen der Eckpixel des Bildes geht. Für den Wertebereich der Länge
39
des Vektors ergibt sich daraus:
i
h 1p
1p 2
w2 + h2 ,
w + h2
d∈ −
2
2
Der Wertebereich für den Winkel des Vektors ist unabhängig von der Größe des Bildes. Für
ihn gilt:
α ∈ [0, π)
Durch diese Wertebereiche kann jede beliebige Gerade im Bild beschrieben werden. Da
die Länge des Vektors auch negative Werte annehmen kann, reicht es aus, den Winkel des
Vektors nur über den Halbkreis [0, π) zu definieren, anstatt ihn über den gesamten Kreis
[0, 2π) aufzuspannen.
Nachdem die Wertebereiche der Parameter feststehen, kann man die Auflösung dieser
Bereiche festlegen. Je höher beide Parameter aufgelöst sind, desto genauer können Geraden im Bild beschrieben werden. Da Geraden in der Hesseschen Normalform durch die
Länge eines Vektors und dessen Winkel relativ zur x-Achse definiert sind, befindet sich
die Beschreibung einer Geraden in einem Polarkoordinatensystem (siehe Abbildung 3.4).
Die Auflösung der Wertebereiche muss nun so gewählt werden, dass eine Zelle im diskrey
d
a
x
Abbildung 3.4: Eine Gerade in der Hesseschen Normalform befindet sich aufgrund ihrer
Parameter in einem Polarkoordinatensystem.
ten Polarkoordinatensystem, einer Zelle im diskreten Bildkoordinatensystem entspricht. Ein
Polarkoordinatensystem hat die Eigenschaft, dass seine Zellen größer werden, je weiter man
sich vom Ursprung entfernt (siehe Abbildung 3.4). Aus diesem Grund muss die Auflösung
des Wertebereichs für den Winkel α groß genug gewählt werden, so dass auch jedes Pixel
40
am Bildrand erreicht und nicht mit einem Winkelschritt übersprungen wird. Um dies zu ermöglichen, wählt man für die Schritte 4α, mit denen über den Wertebereich des Winkels
iteriert wird:
4α = √
1
w2 + h2
Durch diese Auflösung des Wertebereichs ist sichergestellt, dass Pixel am Bildrand durch
einen Winkel und ihren Abstand zum Ursprung beschrieben werden können, ohne sie wegen
einer zu geringen Auflösung zu überspringen (siehe Abbildung 3.5 a) [27].
a)
b)
y
Da =
1
y
Dd = 2
2
w + h2
x
x
Dd = 1
Abbildung 3.5: Auflösung für Winkel und Länge im Bildkoordinatensystem.
Die Auflösung für den Wertebereich der Länge des Vektors ist einfacher zu berechnen.
Hierfür stellt sich die Frage nach dem minimalen Abstand zweier benachbarter Pixel. Dieser
√
ist für für die 4-Nachbarn eines Pixels genau eins. Für seine 8-Nachbarn, eins oder 2 (siehe
Abbildung 3.5 a). Da hier der kleinere Abstand zu den Nachbarn verwendet wird, um keine
Pixel zwischen zwei diskreten Abständen zu überspringen, wird 4d = 1 gewählt.
3.1.2 Füllen des Parameterraums
Nachdem ein geeigneter Parameterraum definiert wurde, findet die eigentliche Transformation zwischen Bild- und Parameterraum statt. Ziel ist es, das Gradientenbild und die darin
enthaltenen Geraden so in den Parameterraum zu überführen, dass danach genau die Zellen
im Parameterraum hoch gewertet sind, die den gesuchten Geraden entsprechen. Dafür werden für jedes Kantenpixel im Bild, die Parameter (α, d) aller Geraden durch dieses Pixel
41
berechnet. Die Geraden ergeben dabei eine Geradenschar, dessen Mittelpunkt das Kantenpixel ist. Diese Geradenschar bildet sich, indem über alle Winkel innerhalb des definierten
Wertebereichs iteriert wird und so für jeden Winkel eine Gerade entsteht. Der dazugehörige
Abstand zum Ursprung, lässt sich für jeden entsprechenden Winkel durch die Hessesche
Normalform berechnen. Für ein Kantenpixel (kx , ky ), ergibt sich somit der Abstand durch:
d = kx cos α + ky sin α
(3.1)
Nachdem man den Winkel und den Abstand zum Ursprung einer Geraden berechnet hat,
wird die dazugehörige Zelle im Parameterraum inkrementiert (siehe Abbildung 3.6 a). Dies
wird nun für alle Geraden durch das Kantenpixel durchgeführt, so dass für jede Gerade
eine andere Zelle im Parameterraum erhöht wird. Dadurch entsteht für ein Kantenpixel eine
Sinusartige diskrete Kurve im Parameterraum (siehe Abbildung 3.6 b).
Wendet man dieses Verfahren auf alle Kantenpixel an, enstehen Maxima im Parameterraum. Angenommen zwei Kantenpixel im Bild liegen auf einer Geraden und durch beide
wird eine Geradenschar erstellt, dann ist in beiden Geradenscharen eine Gerade dabei, die
durch beide Kantenpixel läuft und somit durch die gleichen Parameter beschrieben wird.
Während alle Geraden der beiden Geradenscharen mit ihren Parameter die dazugehörige
Zelle im Parameterraum einmal inkrementieren, wird die Zelle der Geraden, die durch beide
Kantenpixel läuft, zweimal inkrementiert. Dadurch entsteht ein Maxima im Parameterraum
für die parametrische Beschreibung der Geraden, die beide Kantenpixel durchläuft. Wird
dieses mit allen Kantenpixeln gemacht, wachsen die Zellen im Parameterraum, je mehr
Kantenpixeln auf der dazugehörigen Gerade liegen (siehe Abbildung 3.6 c).
Nachdem der Parameterraum gefüllt wurde, entsprechen die Maxima in diesem Parameterraum den Geraden, die im Bild erkannt wurden. Durch die Dedektion der Maxima
und das Einzeichnen der entsprechenden Geraden in das Ursprungsbild, kann eine optische
Kontrolle des Erkennungsergebnis vorgenommen werden.
3.1.3 Verbesserungen der Hough Transformation für
Geraden
Seitdem Paul V. C. Hough seine Idee 1962 als Patent anmeldete, sind viele weitere Arbeiten rund um das ursprüngliche Verfahren verfasst worden. Heutzutage existieren unzählige
Verbesserungen und Modifikationen, die die Hough Transformation beschleunigen, robus-
42
a)
dmax
HT
y
(kx , ky)
d
g
d
a
0
a
Pi
H( a, d )
x
I(x, y)
dmin
b)
dmax
HT
y
0
(kx , ky)
Pi
H( a, d )
x
I(x, y)
dmin
c)
dmax
HT
y
Pi
0
H( a, d )
x
I(x, y)
dmin
Abbildung 3.6: Transformation zwischen Bild- und Parameterraum.
43
ter gegenüber Fehlerkennungen gestalten und um zusätzliche Methoden erweitern [6].
Schnelle Hough Transformation für Geraden
Zum Finden von Geraden in Bildern verwendet die Hough Transformation Kantenpixel in
einem Gradientenbild. Für jedes Kantenpixel werden dabei sämtliche Geraden durch dieses
Pixel berechnet und im Parameterraum eingetragen. Durch das bilden einer Geradenschar
durch ein Kantenpixel werden sozusagen alle Geraden durch dieses Kantenpixel „ausprobiert“. Besser wäre es jedoch, mittels zusätzlicher Informationen über die Lage einer Geraden, das Bilden der Geradenschar so zu beschränken, dass nur noch „sinnvolle“ Geraden
berechnet werden.
Diese zusätzlichen Informationen beinhalten das verwendete Gradientenbild. Bei der Anwendung eines Sobel Filters erhält man neben der Kantenstärke für jedes Pixel die ungefähre Lage der Kante im Bildraum (siehe Abschnitt 2.2.3). Die lokale Lage der Kante
kann dabei durch (2.17) berechnet werden. Anstatt nun die Geradenschar über alle Winkel
des Wertebereiches zu bilden, kann der Winkelbereich auf den berechneten lokalen Winkel
plus/minus eines Toleranzwertes eingeschränkt werden (siehe Abbildung 3.7).
(kx ,ky)
(kx ,ky)
a
Abbildung 3.7: Geradenschar über den gesamten Wertebereich des Winkels (links) und um
den Winkel der lokalen Kanten des Kantenpixels (rechts).
Das Verkleinern des Wertebereichs beschleunigt den Hough Algorithmus erheblich, weshalb dieses Verfahren Fast Hough Transformation genannt wird. Die Grundidee zum Verwenden der lokalen Kantenrichtung wurde dabei erstmals 1976 von O’Gorman und Clowes
44
vorgestellt [16]. Die Beschleunigung der HT ist aber nicht der einzige Vorteil dieses Ansatzes. Eine weitere Verbesserung entsteht, indem nur noch sinnvolle Geradenparameter in
den Parameterraum eingetragen werden. Maxima im Parameterraum bilden sich nur an den
Stellen, die auch wirklich einer Geraden im Bild entsprechen. Das macht dieses Verfahren
robuster gegen Fehlerkennungen, da zufällig entstandene Erhöhungen der Parameterraumzellen vermieden und so die eigentlichen Maxima zuverlässiger erkannt werden. In Abbildung (3.8) ist gut zu erkennnen, dass der Parameterraum einer Fast Hough Transformation
erheblich übersichtlicher gefüllt ist, als bei einer „normalen“ Hough Transformation.
Abbildung 3.8: Orginalbild (links) mit Parameterraum nach einer HT über alle Winkel (mitte) und nach einer Fast HT (rechts).
Auswerten der Kantenstärke
Häufig wird bei der HT ein Sobel-Operator zum Finden von Kantenpixeln verwendet. Überschreitet die Intensität des Gradienten einen festen Schwellwert, liegt das Pixel auf einer
Kante. Bei der HT werden nun Geraden durch das Pixel berechnet und der Parameterraum
an der entsprechenden Stelle inkrementiert. Dabei gibt es verschiedene Möglichkeiten, den
Wert der Zelle zu erhöhen. Eine Möglichkeit ist, die Länge des Gradienten beziehungsweise die Kantenstärke des Pixels zu berücksichtigen. Anstatt die Zelle um einen einheitlichen
Wert zu erhöhen, wird sie um die Intensität des Gradienten inkrementiert. Dadurch wird die
Stärke einer Kante mit in die Geradenfindung integriert. Stärkere Kanten im Bild werden so
im Parameterraum höher gewertet als schwächere.
Je nach Anwendung kann eine einheitliche oder eine gradientenbasierte Inkrementierung
der Parameterraumzellen sinnvoll sein. Sollen vor allem gut sichtbare und starke Kanten im
Bild gefunden werden, sollte die Inkrementieung einer Zelle von dessen Gradienteninten-
45
sität abhängen. Sollen auch schwache Kanten in einem Bild detektiert werden, sollte eine
einheitliche Inkrementierung der Zellen stattfinden.
3.2 Hough Transformation für Kreise
Ähnlich wie die Hough Transformation für Geraden, arbeitet die Hough Transformation für
Kreise [7] auf Gradientenbildern. Der Ablauf ist dabei analog zu dem Finden von Geraden.
Zuerst wird ein Parameterraum über alle Parameter erstellt, die einen Kreis beschreiben.
Danach wird dieser Parameterraum mittels der Hough Transformation gefüllt und zuletzt die
maximal gewerteten Zellen aus dem Parameterraum ermittelt. Diese maximal gewerteten
Zellen beschreiben die am besten gefundenen Kreise im Bild.
3.2.1 Erstellen des Parameterraums
Eine geeignete algebraische Darstellung von Kreisen ist die Koordinatenform eines Kreises
nach (2.4). Ein Kreis kann demnach in einem zweidimensionalen Bild über seinen Radius, sowie seinen Mittelpunkt beschrieben werden. Daraus ergibt sich ein dreidimensionaler
Parameterraum, bei dem auf zwei Achsen die x- und y-Komponente des Mittelpunkts abgebildet werden und die dritte Achse den Radius des Kreises repräsentiert. Auch hier enspricht
eine Zelle im Parameterraum genau einem Kreis im Bildraum. Zum Erstellen des Parameterraums stellt sich also die Frage, welche maximalen und minimalen Werte können die drei
Parameter annehmen und wie müssen diese Wertebereiche aufgelöst sein.
Betrachten wir zunächst den Radius des Kreises. In einem digitalen Bild muss der Radius
eines Kreises mindestens zwei Pixel groß sein, so dass überhaupt ein Kreis zu erkennen ist
(siehe Abbildung 3.9 a). Demnach ist die untere Grenze des Wertebereiches für den Radius
zwei. Die obere Grenze des Wertebereiches, also der maximale Wert des Radius entsteht,
wenn der Kreismittelpunkt in einer Ecke des Bildes angenommen wird und der Kreisrand
genau die diagonal gegenüberliegende Ecke im Bild schneidet (siehe Abbildung 3.9 b). Der
Radius r kann damit folgende Werte annehmen:
2<r<
p
w2 + h2
(3.2)
Mit diesem Wertebereich können auch Kreise beschrieben werden, die nur teilweise im Bild
zu sehen sind.
46
b)
a)
h
h
w
w
Abbildung 3.9: Minimaler Radius (links) und maximaler Radius (rechts) in einem digitalen
Bild mit der Breite w und der Höhe h.
Häufig ist es jedoch so, dass die Größe des Kreises in etwa einschätzbar ist. Aus diesem
Grund beschränkt man den Wertebereich auf zwei selbst festgelegte Schranken innerhalb
des ermittelten Wertebereiches, wodurch sich ein kleinerer Parameterraum ergibt. Der Wertebereich des Kreises entspricht also:
r ∈ [rmin , rmax ]
Nun stellt sich die Frage nach der Auflösung des Wertebereichs für den Radius. Hier
ist wieder entscheidend, wie weit zwei Pixel in einem digitalen Bild minimal auseinander
liegen können. In Abbildung 3.5 b ist zu erkennen, dass der minimale Abstand zwischen
zwei Pixeln genau eins ist, so dass ∆r = 1 gewählt werden kann.
Nachdem der Wertebereich und dessen Auflösung des Radius feststehen, können diese Werte auch für den Kreismittelpunkt berechnet werden. Um den Parameterraum nicht
zu groß werden zu lassen, beschränkt man sich auf Kreise, deren Mittelpunkt innerhalb
des Bildes liegt. Daraus ergibt sich, dass der Parameterraum der beiden Komponenten des
Kreismittelpunktes genau dem Bildraum entspricht. Die Wertebereiche des Mittelpunkts
(mx , my ) entsprechen demnach der Bildbreite w und der Bildhöhe h, so dass gilt:
mx ∈ [0, w)
und
my ∈ [0, h)
Die Auflösung des Wertebereichs entspricht dabei der Pixelauflösung des Bildes, so dass
ein Kreismittelpunkt genau auf ein Pixel abgebildet werden kann.
47
3.2.2 Füllen des Parameterraums
Nachdem ein geeigneter Parameterraum erstellt wurde, kann dieser nun mittels der Hough
Transformation für Kreise gefüllt werden. Ziel ist es erneut, Zellen im Parameterraum so
zu inkrementieren, dass sich Maxima an den Stellen bilden, die den am besten erkannten
Kreisen im Bild entsprechen. Die Basis für die Erkennung von Kreisen bilden dabei alle
gefundenen Kantenpixel (kx , ky ) im Bild (siehe Abbildung 3.10 a). Die Idee der Hough
Transformation für Kreise ist, alle Kantenpixel als potentiele Kreismittelpunkte zu betrachten. Iteriert man nun über den Wertebereich des Radius, entstehen neue Kreise, deren Mittelpunkt ein Kantenpixel ist (siehe Abbildung 3.10 b). Für jedes Pixel, das auf dem Kreisrand
des neu erstellten Kreises liegt, wird die dazugehörige Zelle im dreidimensionalen Parameterraum an der Position (x, y) des Pixels und des jeweiligen Radius inkrementiert. Dadurch
entsteht für jedes Kantenpixel ein Kegelstumpf im Parameterraum. Wird nun der Radius
des neu enstandenen Kreises genau so groß wie der Radius des gesuchten Kreises, geht der
Kreisrand des neuen Kreises durch den Kreismittelpunkt des gesuchten Kreises. Da dieses
nun für alle Kantenpixel die auf dem Kreisrand des gesuchten Kreises liegen passiert, entsteht ein Maximum auf dem Mittelpunkt des gesuchten Kreises mit dem entsprechendem
Radius (siehe Abbildung 3.10 c).
Nachdem für jedes Kantenpixel über alle Radien iteriert wurde und jedes Pixel auf dem
Kreisrand des neu enstandenen Kreises und dem dazugehörigen Radius eine Zelle im Parameterraum inkrementiert hat, ist dieser fertig gefüllt. Es ist jetzt nur noch nötig, die maximal
gewerteten Zellen im Parametrraum zu finden, um so die am besten erkanntesten Kreise im
Bild zu ermitteln.
3.2.3 Schnelles Finden von Kreisen mittels der
Gradientenrichtung
Bei der HT für Kreise wird ein dreidimensionaler Parameterraum verwendet. Die Größe
dieses Parameterraums richtet sich dabei nach der Bildgröße und dem Wertebereich des
Radius. Je größer ein Bild ist, desto größer wird der dazugehörige Parameterraum, was
bei großen Bildern auch auf modernen Computern zu hohen Berechnungslaufzeiten führen
kann. Nimmt man zum Beispiel ein Bild der Größe 800 × 600 Pixel und möchte Kreise von
einem Radius von 30 bis 150 Pixeln finden, ergibt sich ein Parameterraum mit 57.600.0001
1
800 · 600 · (150 − 30) = 57.600.000
48
a)
(k , k )
x y
r
(m , m )
x y
b)
r
min
r
max
c)
r
r
r
r
Abbildung 3.10: Hough Transformation für Kreise
49
Zellen. Abhängig von der Anzahl der gefundenen Kantenpixel in dem Bild, dauert es entsprechend lange, den Parameterraum zu füllen.
Durch zusätzliche Informationen, lässt sich die Ausführung des Algorithmus jedoch beschleunigen [14]. Hierzu wird die Information über die lokale Ausrichtung einer Kante nach
(2.17) verwendet. Diese lokale Ausrichtung entspricht bei einem Kantenpixel eines Kreisrandes, genau der Tangente des Kreises durch das Kantenpixel. Da der Gradientenvektor
des Kantenpixels senkrecht auf der Tangente steht, zeigt dieser genau in die Richtung des
Kreismittelpunktes beziehungsweise genau davon weg2 (siehe Abbildung 3.11 a). Diese zu-
a)
b)
(kx , ky)
m
(Gx ,Gy)
Abbildung 3.11: Die Gradienten der Kreisrandes zeigen auf den Kreismittelpunkt.
sätzliche Information kann dazu verwendet werden, schnell den Mittelpunkt eines Kreises
zu finden.
Die Grundidee ist hierbei, an allen Gradientenvektoren von sämtlichen Kantenpixeln im
Bild entlangzulaufen und dabei alle Pixel, die der Vektor passiert, in einem zweidimensionalen Parameterraum zu inkrementieren. Hierzu erstellt man zunächst einen zweidimensionalen Parameterraum, der genau die gleiche Größe und Auflösung wie das dazugehörige
Bild hat. Um auch Kreismittelpunkte zu finden, die außerhalb des Bildes liegen, wird der
Parameterraum an seinen Rändern um den maximal zu findenden Radius erweitert (siehe
Abbildung 3.12 a). Nun nimmt man ein Kantenpixel und läuft in Richtung des Gradientenvektors beziehungsweise entgegen dieser Richtung. Für jedes Pixel, das dabei passiert wird,
2
Bei einem hellen Kreis auf dunklem Untergrund, zeigt der Gradientenvektor genau auf den Kreismittelpunkt. Bei einem dunklem Kreis auf hellem Hintergrund zeigt er genau vom Mittelpunkt
weg.
50
a)
b)
rmax
rmax
I(x,y)
h
w
H(x,y)
Abbildung 3.12: Ein Bild der Größe w × h mit dem dazugehörige Parameterraum, der um
den maximal zu findenen Radius erweitert ist (links). Kreise in einem Bild mit den jewiligen
Gradientenlinien der Kantenpixel im Parameterraum (rechts).
wird die entsprechende Zelle im Parameterraum inkrementiert. Das hat zur Folge, dass Linien im Parameterraum entstehen. Wendet man dieses Vorgehen nun auf alle Kantenpixel
an, schneiden sich die Gradientenlinien der Kantenpixel eines Kreisrandes genau in dessen
Mittelpunkt (siehe Abbildung 3.11 b). Es entstehen also Maxima an den Stellen im zweidimensionalen Parameterraum, an denen sich potentielle Kreismittelpunkte befinden (siehe
Abbildung 3.12 b). Mit diesem Verfahren können durch Ausnutzung der Gradientenrichtung mögliche Kreismitelpunkte schnell ermittelt werden. Die dazugehörigen Radien für
die Kreismittelpunkte werden nun in einem weiteren Schritt berechnet.
Für das Finden der passenden Radien benötigt man für jeden dedektierten Kreismittelpunkt einen eindimensionalen Parameterraum. Die Größe dieses diskreten Parameterraums
entspricht dem Wertebereich der Radien, die gefunden werden sollen. Er ist also exakt
rmax − rmin Zellen groß. Um nun den Radius für einen Mittelpunkt zu finden, wird der
Bildbereich um den Mittelpunkt genauer untersucht. Dabei wird der für einen Mittelpunkt
(mx , my ) der quadratische Bildausschnitt ((mx − rmax , my − rmax ) bis (mx + rmax , my +
rmax )) durchlaufen und nach Kantenpixeln gesucht. Für jedes Kantenpixel in diesem Bereich wird der Abstand zum Mittelpunkt dieses Ausschnittes beziehungsweise zum Kreismittelpunkt berechnet. Die ermittelte Entfernung wird in dem eindimensionalen Parameterraum eingetragen. Da Kantenpixel die auf einem Kreisrand liegen, genau den selben
Abstand zum Mittelpunkt besitzen, inkrementieren alle Pixel des Kreisrandes die gleiche
51
Zelle. Das Maximum im Parameterraum entspricht demnach dem Radius des untersuchten
Kreismittelpunktes.
Dieses Verfahren scheint zunächst etwas komplizierter und langsamer zu sein als die
„normale“ Hough Transformation für Kreise wie sie im vorherigen Abschnitt vorgestellt
wurde, da hier Kreise in zwei getrennten Schritten anstatt in einem gefunden werden. Diese
Trennung und das damit verbundene Aufteilen des Parameterraums ist jedoch sinnvoll. Benötigt man für ein 800 × 600 Pixel großes Bild mit einem Wertebereich für den Radius von
30 bis 150 Pixeln einen Parameterraum mit 57.600.000 Zellen, so benötigt man mit diesem
Verfahren nur noch einen Parametrraum mit 480.000 Zellen zum Finden des Kreismittelpunkts und einen jeweils 120 Zellen großen Parameterraum zum Finden des passenden
Radius. Zum Vergleich sind das 480.120 Zellen3 beim Finden eines Kreises. Somit ist der
Parameterraum nur ca. 0.8% so groß wie der Parameterraum bei der herkömmlichen HT für
Kreise. Hinzu kommt, dass ähnlich wie bei der Fast HT für Geraden (siehe Abschnitt 3.1.3),
die Gradientenrichtung der Kantenpixel berücksichtigt wird, was die eigentliche Beschleunigung dieses Verfahrens ausmacht. Dadurch kann gezielt der Kreismittelpunkt schnell und
robust gefunden werden, so dass für jeden potentiellen Kreismittelpunkt im zweiten Schritt
nur noch der dazugehörige Radius berechnet werden muss.
3.3 Hough Transformation für Ellipsen
Ellipsen begegnen uns in Aufnahmen von realen Szenen, zum Beispiel als abgebildete Kreise in Fotografien. Kreise im dreidimensionalen Raum werden in der perspektivischen Abbildung auf ein zweidimensionales Bild, sofern sie nicht frontal betrachtet werden, als Ellipsen
projiziert. Möchte man diese Ellipsen in einem Bild durch eine algebraische Gleichung beschreiben, so sind dazu nach (2.8) fünf Parameter nötig, da eine Ellipse fünf Freiheitsgerade
in der Ebene hat. Die x- und y-Komponente des Ellipsenmittelpunktes, die Länge der beiden
Achsen sowie die Rotation relativ zur x-Achse.
Die Hough Transformation für Ellipsen ermöglicht es, diese fünf Parameter für Ellipsen in einem Bild zu berechnen und somit eine algebraische Beschreibung der gefundenen
Ellipsen zu liefern. Aufgrund der fünf Freiheitsgerade wird hier ein fünfdimensionaler Parameterraum verwendet. Dessen Füllung erfolgt dabei nach dem selben Prinzip wie bei der
HT für Kreise. Dort wurde ein Kantenpixel als Mittelpunkt eines neuen Kreises verwendet
3
(800 · 600) + (150 − 30) = 480.120
52
und daraufhin über den Radius iteriert. Jedes Pixel auf dem Kreisrand des neu entstandenen
Kreises wurde dabei in den dreidimensionalen Parameterraum überführt und somit Maxima
gebildet, welche den am besten erkannten Kreisen entsprachen.
In ähnlicher Form wird dieses Verfahren auch bei Ellipsen verwendet. Ein gefundenes
Kantenpixel wird als Mittelpunkt einer neuen Ellipse genommen. Für diese Ellipse wird nun
über alle restlichen Parameter (Länge der Achsen und Rotation) iteriert. Dadurch entstehen
für jedes Kantenpixel auf der ursprünlichen Ellipse viele weitere Ellipsen (siehe Abbildung 3.13 a). Jedes Pixel auf dem Ellipsenrand der neu entstandenen Ellipsen, wird dabei in
a)
b)
y
y
x
x
Abbildung 3.13: Ellipsen deren Mittelpunkt auf der zu findenen Ellipse liegen (links). Ellipsen mit gleichen Achsen und gleicher Rotation wie die zu findende Ellipse mit Mittelpunkt
auf deren Ellipsenrand (rechts).
den Parameterraum überführt beziehungsweise die entsprechende Zelle im Parameterraum
inkrementiert. Ein Pixel auf dem Ellipsenrand entspricht somit der Zelle (x-Komponente
des Pixels, y-Komponente des Pixels, verwendete Länge der Hauptachse, verwendete Länge der Nebenachse, verwendeter Winkel für die Rotation).
Wie entstehen aber nun Maxima im Parameteraum? Alle Ellipsen, welche die gleiche
Länge der Achsen und die gleiche Rotation wie die zu findende Ellipse besitzen, schneiden
sich auf der Bildebene in einem Punkt (siehe Abbildung 3.13 b). Die Koordinate dieses
Punktes sowie die Länge der Achsen und der Winkel der Ellipse entsprechen damit der
Zelle, die am häufigsten im Parameterraum inkrementiert wird, und somit die zu findenden
Ellipse repräsentiert.
53
3.3.1 Speicherbedarf des Parameterraums
Bei der gerade vorgestellten HT für Ellipsen wird ein fünfdimensionaler Parameterraum
verwendet. Dies hat zur Folge, dass schon für kleine Bilder und kleingehaltene Wertebereiche für die Parameter, der Speicherbedarf des Parameterraums sehr groß wird. Eine einfache Rechnung soll das verdeutlichen: Nimmt man ein Bild der Größe 400 × 300 Pixel,
einen Wertebereich für die beiden Achsen von [30, 100) und einen Wertebereich für den
Winkel der Rotation von α ∈ [0, π) mit ∆α = 0.1, ergibt das einen Parameterraum mit
über 18 Milliarden Zellen. Hat jede Zelle einen Speicherbedarf von nur einem Byte, ergibt
sich daraus ein Speicherbedarf für den gesamten Parameterraum von 18.228 Gigabyte. Der
Speicherbedarf des Parameterraums wird also bei fünf Parametern schon so riesig, dass sich
dieses Verfahren auf derzeitigen Computern nicht implementieren lässt. Die Vollkombination aller Parameter ergibt zu viele Möglichkeiten, wie eine Ellipse in der Ebene liegen kann,
um diese in annehmbarer Zeit und mit heutigen Computern berechnen zu können.
3.3.2 Schnelles Finden von Ellipsen
Wie im vorherigen Abschnitt gezeigt wurde, ist die „herkömmliche“ HT für Ellipsen in
der Praxis nicht realisierbar. Um dennoch Ellipsen in Bildern zu finden, müssen also andere Methoden angewendet werden. Die HT für Kreise kann erheblich beschleunigt werden,
indem man den Parameterraum aufteilt und zuerst den Kreismittelpunkt berechnet. Erst danach wird der passenden Radius ermittelt. Die gleiche Taktik kann auch beim Finden von
Ellipsen verwendet werden. In einem ersten Schritt wird der Mittelpunkt der zu findenden Ellipse ermittelt und in einem zweiten Schritt die Länge der Achsen und die Rotation
der Ellipse berechnet. Damit wurde der ursprüngliche fünfdimensionale Parameterraum in
einen Parameterraum für die x- und y-Komponente des Mittelpunktes und einen weiteren
Parameterraum zum Finden der restlichen drei Parameter unterteilt. Durch diese Aufteilung des Parameterraums ist es möglich, Ellipsen in zweidimensionalen Bildern mit einem
vertretbaren Speicherbedarf zu ermitteln. Im den nachfolgenden Abschnitten, werden zwei
Verfahren zum Finden des Ellipsenmittelpunktes vorgestellt.
Nachdem der Mittelpunkt zuverlässig gefunden wurde, können die drei restlichen Parameter berechnet werden. Durch die bekannte Position des Ellipsenmittelpunktes (cx , cy ),
lässt sich die Ellipse in den Ursprung verschieben und kann somit durch
x02 + 2ax0 y 0 + by 02 + c = 0,
54
mit x0 , y 0 , a, b, c ∈ R,
(3.3)
ausgedrückt werden. Dabei entsprechen x0 und y 0 einer Verschiebung der Ellipse in den
Ursprung durch
x0 = x − xc
und
y 0 = y − yc .
Nach (3.3) liegt somit eine gedrehte Ellipse im Ursprung vor, die durch die drei Parameter
a, b und c beschrieben werden kann. Um diese drei Parameter zu ermitteln und daraus den
Ellipsenwinkel und die Länge der Ellipsenachsen zu bestimmen, kann die Methode von
Tsukune und Goto [12] verwendet werden. Danach wird zunächst (3.3) differenziert, so
dass man die Gleichung
x0 dy 0
by 0 dy 0
0
+a y +
=0
x +
dx0
dx0
0
(3.4)
erhält. In der abgeleiteten Form fällt der Konstante Parameter c weg, so dass nur noch die
beiden Unbekannten a und b erhalten bleiben. Für diese beiden Parameter kann nun ein Parameterraum erstellt und gefüllt werden. Ein Kantenpixel (kx , ky ) im Bildraum entspricht
dabei den Werten x0 und y 0 . Zum Füllen des Parameterraumes wird für jedes Kantenpixel
über einen der beiden Parameter aus (3.4) iteriert und der andere berechnet. Das Ergebnis wird in den Parameterraum eingetragen. Nach dem Füllen entspricht die Position des
Maximum in diesem Parameterraum den beiden Parametern a und b. Setzt man diese in
Gleichung (3.3) ein, kann der Parameter c bestimmt werden.
Dadurch sind die drei Parameter aus (3.3) bekannt und es können der Ellipsenwinkel und
die Länge der beiden Hauptachsen bestimmt werden durch:
1
α = arctan
2
λ21 =
λ22 =
2a
1−b
−2c
1
−2c
1
(b + 1) − ((b − 1)2 + 4a2 ) 2
(b + 1) + ((b − 1)2 + 4a2 ) 2
Diameter Bisection Methode
Die Diameter Bisection Methode [21], zum schnellen Finden eines Ellipsenmittelpunktes,
wurde erstmals von Tsuji und Matsumoto 1978 vorgestellt. Die grundlegende Idee dieser
Methode ist es, zwei Kantenpixel einer Ellipse zu finden, deren Gradienten antiparallel zu-
55
einander sind. Der Mittelpunkt der beiden Kantenpixel fällt bei einer ideal konstruierten Ellipse damit auf den Ellipsenmittelpunkt (siehe Abbildung 3.14). Es wird folglich die Punkt-
m
Abbildung 3.14: Der Mittelpunkt von zwei Kantenpixeln deren Gradienten antiparallel verlaufen, fällt auf den Ellipsenmittelpunkt.
symetrie einer Ellipse ausgenutzt, durch die ein Punkt auf deren Ellipsenrand auf einen
weiteren Punkt ebenfalls auf dem Ellipsenrand abgebildet wird, dessen Gradient antiparallel ist. Ein Vorteil dieser Methode ist, dass sich mit ihr nicht nur Mittelpunkte von Ellipsen
bestimmen lassen, sondern Mittelpunkte von allen punktsymetrischen Strukturen.
Um dieses Verfahren zu realisieren, wird zunächst ein zweidimensionaler Parameterraum
geschaffen, der in seiner Größe und Auflösung exakt dem Bildraum entspricht. Das bedeutet, dass eine Zelle im Parameterraum genau einem Pixel im Bild entspricht. Im ersten
Schritt dieser Methode werden zunächst alle Kantenpixel im Bild gefunden und in einer Liste gespeichert. Danach werden Paare über alle Kantenpixel gebildet. Für jedes Paar, deren
Gradientenvektoren in etwa antiparallel verlaufen, wird der Mittelpunkt der beiden Kantenpixel gebildet und die entsprechende Zelle im Parameterraum inkrementiert. Dadurch
bilden sich Maxima an der Stelle im Parameterraum, die dem potentiellen Ellipsenmittelpunkt entsprechen.
Ein Problem dieses Verfahrens ist, dass abhängig vom Bild und je nach gewähltem
Schwellwert sehr viele Kantenpixel gefunden werden und demzufolge noch mehr Paare von
2
Kantenpixeln. Für n Kantenpixel existieren n2 Paare, was einer Anzahl von etwa n2 ent-
spricht. Das quadratische Wachsen der Paare in Abhängigkeit der Anzahl aller Kantenpixel
kann schnell zu langen Berechnungszeiten und hohen Speicherverbrauch führen. Desweite-
56
ren müssen zwei Kantenpixel deren Gradienten antiparallel verlaufen, nicht unbedingt auf
dem selben Ellipsenrand liegen, so dass es zu Fehleinträgen im Parameterraum kommen
kann. Um diese Fehleinträgen zu vermeiden ist es möglich, die ermittelten Punktepaare zu
testen. Zum Beispiel werden nur Paare genommen die in einem bestimmten Abstand zueinanderliegen. Die untere Grenze des Abstandes wäre demnach die Länge der Nebenachse
und die obere Grenze die Länge der Hauptachse.
Chord-Tangent Methode
Eine weitere Methode um schnell Mittelpunkte von Ellipsen zu finden, ist die sogennante
Chord-Tangent Methode [24] von Yuen, die erstmals 1988 vorgestellt wurde. Ähnlich wie
bei der Diameter Bisection Methode werden auch hier zwei Kantenpixel herangezogen, um
Informationen über den Mittelpunkt der Ellipse zu gewinnen. Die Grundidee ist hierbei mittels zweier Kantenpixel, eine Gerade zu finden, die durch den Ellipsenmittelpunkt verläuft.
Dafür wird zunächst der Schnittpunkt der Tangenten zweier Kantenpunkte berechnet. Die
Gerade durch diesen Schnittpunkt und den Mittelpunkt der beiden Kantenpixel passiert dabei genau den Ellipsenmittelpunkt (siehe Abbildung 3.15). Macht man dies nun für mehrere
Punktpaare, treffen sich die entstehenden Geraden genau im Ellipsenmittelpunkt.
m
Abbildung 3.15: Die Gerade durch den Schnittpunkt der Tangenten von zwei Kantenpixeln
und durch deren Mittelpunkt, passiert den Ellipsenmittelpunkt.
Um den genauen Mittelpunkt zu ermitteln, wird wieder ein Parameterraum mit gleicher
57
Größe und gleicher Auflösung wie der Bildraum benötigt. Nachdem dieser erstellt ist, werden alle Kantenpixel in einem Bild gefunden, gespeichert und Kantenpixelpaare gebildet.
Für beide Kantenpixel eines Paares wird nun der Schnittpunkt der beiden Tangenten berechnet. Die Tangente eines Kantenpixels steht dabei senkrecht auf dem Gradienten des
Kantenpixels. Der Winkel der Tangente relativ zur x-Achse kann durch (2.17) bestimmt
werden. Durch diesen Winkel und die Koordinate des Kantenpixels kann eine Geradengleichung nach (2.1) aufgestellt werden, welche die Tangenten beschreibt. Der Schnittpunkt
ergibt sich nun durch die Cramersche Regel. Als zweiter Punkt wird der Mittelpunkt der
beiden Kantenpixel berechnet. Die Gerade, die durch diese beiden Punkte beschrieben wird,
passiert genau den Mittelpunkt der Ellipse. Man läuft nun entlang der Geraden und inkrementiert für jedes Pixel, was durch die Gerade geschnitten wird, die entsprechende Zelle im
Parameterraum. Angewandt auf mehrere Punktpaare, schneiden sich die Geraden im Ellipsenmittelpunkt und inkrementieren die zugehörige Zelle. Es entsteht also ein Maximum in
der Zelle, die dem Mittelpunkt der Ellipse entspricht.
Ein Vorteil gegenüber der Diameter Bisection Methode ist, dass bei dieser Methode beliebige Paare von Kanenpixeln gebildet werden können und nicht nur solche, die bestimmten Kriterien entsprechen (zum Beispiel antiparallele Gradienten). Aus diesem Grund ist
es möglich, zum Beispiel mittels eines Monte-Carlo Verfahrens zufällig gewählte Kantenpixel zu Paaren zu verbinden, ohne jede mögliche Kombination von Kantenpixeln auszuprobieren. Es ist jedoch ratsam, bestimmte Kantenpixelkombinationen von vornherein zu
verwerfen. So sollten beide Kantenpixel einen bestimmten Abstand zueinander haben. Jedoch sollte der Abstand beider Kantenpixel die Länge der Hauptachse der Ellipse nicht
überschreiten, da sonst beide Kantenpixel nicht auf dem selben Ellipsenrand liegen können. Ausserdem muss sichergestellt sein, dass beide Tangenten sich auch schneiden, was
bei parallelen und antiparallelen Gradientenvektoren nicht der Fall ist.
3.4 Verallgemeinerte Hough Transformation
In den vorangegangenen Abschnitten wurde gezeigt, wie man die algebraische Beschreibung von Geraden, Kreisen und Ellipsen in Bildern ermitteln kann. Dabei wurden zweidimensionale, dreidimensionale beziehungsweise fünfdimensionale Parameterräume verwendet. Die Dimension der Parameterräume richtete sich dabei nach der Anzahl der Parameter,
durch die die jeweilige Struktur beschrieben werden kann. Schon bei dreidimensinalen Para-
58
meterräumen ergaben sich erste Probleme bei der Berechnungszeit und fünfdimensionalen
Parameterräumen sind selbst auf modernen Computern nicht zu realisieren.
Eine Alternative zu den vorgestellten Verfahren liefert die Verallgemeinerte Hough Transformation (VHT) [2], die in ihrer heute verwendeten Form erstmals von Ballard 1981 vorgestellt wurde. Eine Struktur wird bei dieser Methode nicht mehr über eine algebraische Gleichung beschrieben, sondern durch alle Kantenpunkte auf ihrem Rand. Durch Verschieben,
Rotieren und Skalieren wird diese Struktur im Bild transformiert. Dabei wird untersucht, für
welche Position, Rotation und Größe eine Struktur im Bild am ehesten der zu erkennenden
Struktur entspricht. Der Vorteil dieses Verfahrens ist, dass nicht mehr nur Geraden, Kreise,
Ellipsen oder algebraisch beschreibbare Strukturen gefunden werden können, sondern alle
Arten von Strukturen die sich durch ihren Rand beschreiben lassen. Als Ergebnis erhält man
demzufolge auch keine algebraische Beschreibung einer Struktur, sondern die Lage und die
Größe der zu findenden Struktur im Bild.
3.4.1 Beschreibung einer Struktur durch ihren Rand
Eine Struktur kann über alle Punkte beschrieben werden, die auf ihrem Rand liegen. Eine
Möglichkeit, diese Randpunkte zu beschreiben, ist, ihren Abstand von einem Bezugspunkt
sowie den Winkel anzugeben, der zwischen der Geraden durch den Rand- und den Bezugspunkt relativ zur x-Achse entsteht (siehe Abbildung 3.16). Der Bezugspunkt kann dabei
beliebig gewählt werden. Bezeichnet man den Randpunkt mit (x, y), den Bezugspunkt mit
(xc , yc ), den Abstand mit r und den Winkel mit α, so gilt:
r=
p
(x − xc )2 + (y − yc )2
und
α = tan−1
y − yc
x − xc
Bei der VHT werden die Angaben eines jeden Randpunktes in einer Tabelle gespeichert, die
R-Tabelle genannt wird. Für den weiteren Ablauf der VHT wird außerdem noch der Winkel
θ des Gradienten des Randpunktes relativ zur x-Achse benötigt.
Um die R-Tabelle zu erstellen, werden Gradientenklassen abhängig von dem Winkel
des Gradienten gebildet. Hierfür wird der Wertebereich des Gradienten [0, π) in Stufen
unterteilt und diese in die R-Tabelle eingetragen. Die Größe dieser Stufen beziehungsweise
die Auflösung dieses Wertebereiches richtet sich dabei hauptsächlich nach der maximalen
Auflösung des Gradientenwinkels. Für jeden Randpunkt (x, y) der Struktur wird nun der
Winkel des Gradienten θ, der Abstand zum Bezugspunkt r und der Winkel α der Geraden
59
y
(xc,yc)
G
r
a
q
(x,y)
x
Abbildung 3.16: Ein Randpunkt einer Struktur relativ zu einem Bezugspunkt.
durch den Bezugs- und den Randpunkt ermittelt. Das Wertepaar (r, α) wird an die Stelle in
die R-Tabelle eingetragen, an der der Winkel θ einer der vorher eingetragenen Winkelstufen
entspricht (siehe Tabelle 3.1).
θ
θ1 = 0
···
θj
···
θk = π
(r, α)
(r, α)11
···
(r, α)j1
···
(r, α)k1
(r, α)12
···
(r, α)j2
···
(r, α)k2
···
···
···
···
···
(r, α)1n
···
(r, α)jn
···
(r, α)kn
Tabelle 3.1: Die R-Tabelle ordnet einem Winkelbereich θ die dazugehörigen Randpunkte
einer Struktur zu.
Nachdem die Struktur in der Tabelle kodiert ist, befinden sich nun alle Randpunkte der
Struktur, klassifiziert nach dem Winkel ihres Gradienten, in der Tabelle. Diese Tabelle wird
nun im nächsten Schritt dazu verwendet, die zu findende Struktur in einem Bild zu detektieren.
60
3.4.2 Finden einer Struktur mittels der Verallgemeinerten
Hough Transformation
Das Finden einer Struktur basiert wie in den bisher vorgestellten Methoden wieder auf einem binären Kantenbild (siehe Abschnitt 2.2.3). Um nun die in der R-Tabelle beschriebene
Struktur zu finden, wird ein vierdimensionaler Parameterraum benötigt. In diesem Parameterraum entsprechen zwei Achsen der x- und y-Komponente des Bezugpunktes der Struktur,
eine Achse entspricht der Rotation der Struktur und eine Achse der Skalierung beziehungsweise der Größe der Struktur. Durch diese vier Parameter ist es möglich, jede Lage und
Größe der Struktur in einem Bild zu beschreiben.
Um den Parameterraum zu füllen, wird folgendermaßen vorgegangen. Für jedes Kantenpixel im Bild wird die dazugehörige Gradientenrichtung berechnet. Über diese Richtung
bekommt man alle Randpixel der Struktur, die in der R-Tabelle der selben Gradientenklasse
entsprechen. Ein Randpixel ist dabei durch einen Abstand r zum Bezugspunkt und einen
Winkel α relativ zur x-Achse beschrieben. Nun wird jeder der Randpunkte der selben Gradientenklasse über alle Winkel rotiert und um sämtliche Größen skaliert. Für jeden Schritt
der Rotation und der Skalierung wird die entsprechende Zelle im Parameterraum inkrementiert. Die Zelle hat dabei die Koordinate (xc , yc , ϕ, s) mit dem Winkel ϕ und der Skalierung
s. Die Werte xc und yc für das Kantenpixel (kx , ky ) ergeben sich dabei aus:
xc = kx + r · s · cos(α + ϕ)
und
yc = ky + r · s · sin(α + ϕ)
(3.5)
Dadurch wird die in der R-Tabelle gespeicherte Struktur über das Bild verschoben, rotiert
und skaliert, und dabei für jede Transformation eine Zelle im Parameterraum inkrementiert.
So bilden sich Maxima im Parameterraum genau an der Stelle, die der Position, der Rotation
und der Größe der gesuchten Struktur entspricht.
Bei dieser Methode wird ein vierdimensionaler Parameterraum verwendet. Häufig ist es
jedoch so, dass durch zusätzliches Wissen der Parameterraum eingeschränkt werden kann.
So kann die Größe einer gesuchten Struktur schon vorher bekannt sein oder die Rotation
lässt sich auf bestimmte Werte beschränken. Möchte man zum Beispiel nur die Position
einer Struktur bestimmen von der die Größe und die Rotation bekannt ist, reicht ein zweidimensionaler Parameterraum aus. Aus Gleichung (3.5) fallen dann die beiden Parameter für
die Rotation und die Skalierung weg. Abbildung 3.17 zeigt eine Struktur mit zwei Gradienten aus der selben Gradientenklasse der R-Tabelle. Beide Kantenpunkte im Bild werden
61
für jeden Eintrag in der Gradientenklasse durch (3.5) auf eine Zelle im Parameterraum abgebildet. Man kann erkennen, dass sich dadurch in der Zelle, die dem Bezugspunkt (xc , yc )
entspricht, ein Maximum bildet.
y
G2
(xc,yc)
r1
r2
G1
r1
r2
x
Abbildung 3.17: Zwei Gradienten der selben Gradientenklassen inkrementieren beide den
Bezugspunkt der Struktur.
3.5 Alternative zur Hough Transformation
Die Hough Transformation ist eine der bekanntesten Methoden um algebraisch beschreibbare Strukturen in Bildern zu Finden. Alternativ dazu existieren aber noch weitere Methoden.
Eine davon ist die Radon Transformation [17], die nach dem österreichischem Mathematiker Johann Radon benannt ist, und wie schon in der Einleitung erwähnt wurde, die mathematische Basis der Computertomographie darstellt. Neben ihrer Rolle in der modernen
Medizin kann die Radon Transformation auch im Bereich der Bildverarbeitung eingesetzt
werden, in der sie bislang aber eher noch ein Schattendasein führt [3].
Die Radon Transformation ist dabei der Hough Transformation sehr ähnlich [9]. In beiden wird ein Parameterraum über alle Parameter der zu findenden Struktur gebildet und
dieser gefüllt. Die Maxima in dem gefüllten Parameterraum entsprechen den am deutlichsten erkannten Strukturen im Bild. Der Hauptunterschied der beiden Transformationen liegt
dabei darin, wie der Parameterraum gefüllt wird.
Der Unterschied zwischen der Hough und Radon Transformation wird im Folgenden an
dem Finden von Geraden erläutert. Wie bereits erwähnt wird bei beiden Verfahren zunächst
62
3.5 Alternative zur Hough Transformation
ein Parameterraum über die beiden Parameter der Hesseschen Normalform nach (2.3) gebildet. Die Hough Transformation verfolgt nun zum Füllen des Parameterraumes einen schreibenden Ansatz: Für jeden Kantenpunkt im Bild werden alle Strukturen durch diesen Punkt
gebildet (in diesem Fall Geraden) und die Parameter jeder gebildeten Struktur in den Parameterraum geschrieben, beziehungsweise die entsprechende Zelle erhöht. Es wird also über
den Bildraum iteriert und in den Parameterraum geschrieben.
Die Radon Transformation verfolgt im Gegensatz dazu einen lesenden Ansatz: Dabei
wird über den Parameterraum gelaufen, wobei jede Zelle einer Struktur im Bild entspricht.
Die Intensität der Pixel, die auf dieser Struktur im Bild liegen, werden addiert und in den
Parameterraum übertragen. Hier wird also über den Parameterraum iteriert und aus dem
Bildraum gelesen. Zum Finden von Geraden werden bei der Radon Transformation über
den Winkel und die Distanz zum Ursprung iteriert und so jede mögliche Gerade im Bild
erstellt. Alle Punkte die auf der jeweiligen Gerade liegen, werden addiert und die Summe
an die jeweilige Stelle im Parameterraum geschrieben (siehe Abbildung 3.18). Nach dem
Füllen des Parameterraumes müssen nun wieder Maxima gefunden werden, die dann den
am besten erkannten Geraden im Bild entsprechen.
R(a,d)
I(x,y)
y
d
a
x
d
a
Abbildung 3.18: Für jede Zelle im Parameterraum R, werden alle Punkte der dazugehörigen
Geraden im Bild I addiert und das Ergebnis in die Zelle geschrieben.
63
Die Hough und Radon Transformation sind beide equvivalent zueinander [9]. Welche
Methode zum Finden von Strukturen gewählt wird, sollte in Abhängigkeit von der jeweiligen Anwendung geschehen. Existieren in einem Kantenbild nur wenige Punkte, sollte
die Hough Transformation gewählt werden, da es wenig sinnvoll wäre für wenige Kantenpunkte, alle Strukturen im Bild zu bilden. Andererseits sollte die Radon Transformation
vorgezogen werden, sofern nur nach wenigen Strukturen im Bild gesucht werden soll, der
Parameterraum also sehr klein gehalten ist.
Neben der gerade erläuterten Anwendung der Radon Transformation zum Finden von
Geraden, kann diese zum Finden von vielen weiteren und komplexeren Strukturen verwendet werden [3].
64
4 Ellipsenfindung in
Röntgenbildern
In den vorhergegangenen Kapiteln wurde gezeigt, wie algebraisch beschreibbare Strukturen
in Bildern gefunden werden können. Eine praktische Anwendung der vorgestellten Methoden ist das Finden von Kugelschatten in Röntgenbildern. Wie im Abschnitt 1.1 beschrieben
wurde, können Kugeln in Röntgenanwendungen dazu dienen, den Standpunkt der Röntgenquelle und des geröntgten Objektes zum Zeitpunkt der Aufnahme zu bestimmen. Dazu ist
es notwendig, die projizierten Kugeln im Röntgenbild schnell und zuverlässig zu finden.
Entstehen mehrere Aufnahmen des selben Objektes ist es möglich, anhand der abgebildeten Kugeln die Lage der Röntgenbilder relativ zueinander zu bestimmen und daraufhin ein
dreidimensionales Bild des Objektes zu rekonstruieren.
Um genauer zu verstehen wie Referenzkugeln in Röntgenbildern abgebildet werden, wird
im Folgenden auf Röntgenbilder, Projektionen, Abbildungen von Kugeln in Röntgenbildern
und das Finden der abgebildeten Kugeln eingegangen.
4.1 Röntgenbilder
Röntgenstrahlen haben die Eigenschaft feste Körper zu durchdringen. Je nach der Beschaffenheit des jeweiligen Körpers absorbiert dieser die Strahlung dabei. Die Startintensität
eines Röntgenstrahls ist demnach höher, als die Intensität nach dem Durchdringen eines
Körpers. Auf Röntgenbildern wird diese Intensität visualisiert, nachdem die Röntgenstrahlung das zu röntgende Objekt durchdrungen hat. Geringe Intensität wird in der Regel durch
helle Bereiche dargestellt, hohe Intensität durch dunkle Bereiche (siehe Abbildung 4.1 a).
Wie stark ein Körper die Röntgenstrahlung absorbiert, richtet sich nach dem Massenabsorptionskoeffizient sowie der Dicke des Körpers, die der Röntgenstrahl durchdringen muss. Die
Intensität I eines Röntgenstrahls nach dem Durchdringen eines Körpers lässt sich berechnen
65
durch
I = I0 e−µ·d
mit der Eingangsintensität I0 , dem Massenabsorptionskoeffizient µ und der Dicke des zu
durchdringenden Körpers d (siehe Abbildung 4.1 b).
b)
Röntgenbild
a)
Röntgenquelle
I0
I0 e-m d
I
Abbildung 4.1: Röntgenbild eines künstlichen Schädels und schematische Darstellung eines
Röntgenvorganges.
Die Stelle an der ein Röntgenstrahl ausgehend von der Röntgenquelle senkrecht auf das
Röntgenbild auftritt, wird Fokuspunkt genannt. In diesem Punkt sind die abgebildeten Strukturen am schärfsten zu erkennen [4]. Als Röntgenschatten wird die Abbildung eines Objektes auf ein Röntgenbild bezeichnet.
4.2 Projektionen
Röntgenbilder entstehen auf einer Fläche beziehungsweise auf einem Röntgenbild, wenn
sich ein Objekt zwischen einer Strahlenquelle und dieser Fläche befindet. Durch die Verdeckung der Fläche durch das Objekt erreichen nicht alle Strahlen der Quelle die Fläche.
Die Stelle an der wenig oder keine Strahlen auftreffen, werden Schatten genannt. Abhängig
von Größe und Lage der Quelle zur Fläche und der Lage des Objektes zwischen Quelle
und Fläche wird der Schatten des Objektes auf die Fläche abgebildet. Der Schatten ist dabei eine Projektion oder Abbildung des Objektes. Die Fläche auf die projiziert wird, wird
Projektionsebene genannt.
Eine wichtige Eigenschaft von Projektionen ist die Verringerung der Dimensionalität
eines Objektes [8]. Das bedeutet, dass ein Punkt im dreidimensionalen Raum durch eine
66
4.2 Projektionen
Projektion auf einen zweidimensionalen Punkt in der Ebene abgebildet wird. Ein Beispiel
hierfür sind Projektionen in der Computergrafik. Hier werden Projektionen dazu verwendet,
um Beschreibungen dreidimensionaler Objekte auf zweidimensionale Ausgabemedien wie
Monitore abzubilden.
Wird ein Punkt auf eine Projektionsebene abgebildet, ist diese Abbildung von der Lage der Ebene und der Projektionsrichtung abhängig. Die Projektionsrichtung wird dabei
durch den so genannten Projektionsvektor beschrieben und legt fest, in welche Richtung
das Objekt projiziert wird. Erstellt man eine Gerade durch den zu projezierenden Punkt und
den Projektionsvektor (siehe Abschnitt 2.1.1), wird diese Gerade auch Projektionsstrahl
genannt. Hauptsächlich können zwei Arten von Projektionen unterschieden werden: Parallelprojektionen und Zentralprojektionen. Beide unterscheiden sich dabei nur in der Art und
Weise wie Projektionsrichtungen unterschiedlicher Punkte zueinander verlaufen.
Im Folgenden wird die Projektionsebene im dreidimensionalen Raum durch einen Punkt
in der Ebene und einen Normalenvektor, der senkrecht auf der Ebene steht, in der impliziten
Form beschrieben. Durch
(pe − q) · n = 0,
knk = 1
(4.1)
mit x, q, n ∈ R3 liegt jeder Punkt pe ∈ R3 in der Ebene, der diese Gleichung erfüllt (siehe
Abbildung 4.2).
y
P
q
n
pe
z
x
Abbildung 4.2: Der Punkt q und der Vektor n beschreiben die Ebene P, in der der Punkt pe
liegt.
Bei Parallelprojektionen ist die Projektionsrichtung für jeden Punkt unabhängig von seiner Position im Raum gleich (siehe Abbildung 4.3). Dabei verändert diese Art der Projektion die relativen Größen von Objekten nicht. In einem dreidimensionalen Raum bedeutet
67
y
p2
v
p2
P
v
p1
p1
z
x
Abbildung 4.3: Die Punkte p1 und p2 , werden durch den Vektor v auf die Ebene P projiziert.
das, dass ein Punkt in Richtung des Projektionsvektors, auf die Projektionsebene verschoben wird. Der Punkt wird auf den Schnittpunkt des Projektionsstrahls mit der Projektionsebene abgebildet. Dieser Schnittpunkt kann dabei durch die implizite Darstellung der Projektionsebene nach (4.1) und der parametrischen Form der Geraden nach (2.1) berechnet
werden. Ersetzt man in der Ebenengleichung den Punkt pe mit der Geradengleichung (2.1),
so ist der Schnittpunkt der Gerade mit der Ebene und damit der projizierte Punkt, gegeben
durch:
(p + tv − q) · n = 0
Durch Umstellen der Gleichung nach dem Parameter t erhält man:
t=
(p − q) · n
v·n
Setzt man diese Gleichung in die implizite Gleichung einer Geraden nach (2.1) ein, ergibt
sich der Schnittpunkt der Gerade mit der Ebene und somit der projizierte Punkt durch:
p0 = p +
(p − q) · n
·v
v·n
(4.2)
Der Punkt p wird durch diese Gleichung auf den Punkt p0 mit dem Projektionsvektor v
dem Punkt in der Projektionsebene q und dem Normalenvektor n, der senkrecht auf der
Projektionsebene steht, projiziert.
Eine besondere Art der Parallelprojektion ist die orthogonale Projektion. Von ihr spricht
68
4.2 Projektionen
man, wenn der Projektionsvektor senkrecht auf der Projektionsebene steht. Will man ein
dreidimensionales Objekt ortographisch auf eine Koordinatenebene projizieren, so muss
man nichts weiter tun als die entsprechende Komponente aller dreidimensionalen Punkte
auf null zu setzen. Möchte man beispielsweise einen dreidimensionalen Würfel auf die z =
0 Ebene projezieren, so setzt man alle z-Komponenten der Würfelpunkte auf null.
Sind bei der Parallelprojektion alle Projektionsvektoren gleich und somit alle Projektionsstrahlen parallel, so laufen bei der Zentralprojektion alle Projektionsstrahlen zentral
in einem Punkt zusammen. Dieser Punkt wird Projektionszentrum genannt (siehe Abbildung 4.4). Stellt man sich vor als Betrachter im Projektionszentrum in einer dreidimensio-
y
p1
v1
p2
v2
p1
p2
z
P
v3
p3
pz
Fokuspunkt
p3
x
Abbildung 4.4: Die Punkte p1 , p2 und p3 , werden durch die Vektoren v1 , v2 und v3 auf die
Ebene P projiziert. Die Vektoren schneiden sich dabei alle im Projektionszentrum pz .
nalen Szene zu stehen und in Richtung der Projektionsebene zu schauen, so werden weit
entfernte Objekte kleiner dargestellt als nahe Objekte. Eine Zentralprojektion bildet Objekte demnach perspektivisch ab. Die Projektionsrichtung eines Punktes ergibt sich dabei
durch seine Position im Raum und der Position des Projektionszentrums. Ist beispielsweise
pz das Projektionszentrum und p der zu projezierende Punkt, dann ergibt sich der Projektionsvektor v durch
v = pz − p,
mit v, p, pz ∈ R3 .
Wie auch bei der Parallelprojektion wird ein Punkt auf den Schnittpunkt des Projektionsstrahls mit der Projektionebene abgebildet und kann durch (4.2) berechnet werden.
Diese Art der Projektion entspricht dem Prinzip einer Röntgenanwendung. Das Projekti-
69
onszentrum entspricht dabei einer punktförmigen Strahlenquelle, die Projektionsebene entspricht dem Röntgenbild (siehe Abbildung 4.1 b). Objekte die sich zwischen Röntgenquelle
und Röntgenbild befinden werden demnach perspektivisch auf das Röntgenbild abgebildet.
4.3 Projektionen von Referenzkugeln in
Röntgenbildern
Werden Kugeln mittels einer punktförmigen Röntgenquelle auf eine Ebene beziehungsweise ein Röntgenbild projiziert, werden diese nicht als Kreise, sondern als Ellipsen abgebildet. Je nach Lage der Kugeln, der Röntgenquelle und des Röntgenbildes erscheinen die
Kugelschatten in einem Röntgenbild als mehr oder weniger stark ausgeprägte Ellipsen. In
Abbildung 4.5 ist die Projektion einer Kugel auf ein Röntgenbild zu sehen.
y
Röntgenbild
x
Röntgenquelle
z
Abbildung 4.5: Kugelschatten in einem Röntgenbild.
Wie in Abschnitt 2.1.3 erläutert wurde, können Ellipsen durch Kegelschnitte beschrieben
werden. In einer Röntgenanwendung bildet sich ein Kegel durch die Röntgenstrahlen, die
tangential an der zu projezierenden Kugel entlanglaufen. Die Kegelachse passiert dabei die
Röntgenquelle und den Kugelmittelpunkt. Durch den Schnitt des Kegels mit der Projektionsebene beziehungsweise dem Röntgenbild entsteht eine Ellipse. Der Öffnungswinkel des
70
4.3 Projektionen von Referenzkugeln in Röntgenbildern
Kegels ist dadurch abhängig vom Radius der Kugel und deren Entfernung zur Röntgenquelle. Eine wichtige Eigenschaft der projizierten Ellipsen dabei ist, dass die Hauptachse
der Ellipsen in Richtung des Fokuspunktes des Bildes zeigt. Wie stark die Ellipse von einem
Kreis abweicht, hängt davon ab in welchem Winkel die Kegelachse auf die Projektionsebene
trifft. Je spitzer dieser Winkel ist, desto größer wir die Hauptachse der Ellipse im Vergleich
zu ihrer Nebenachse.
Eine Ellipse kann durch die Lage der Röntgenquelle zum Röntgenbild, die Kegelachse
und den Öffnungswinkel beschrieben werden (siehe Abbildung 4.6). Wir gehen in Zukunft
davon aus, dass im R3 das Röntgenbild in der z = 0 Ebene liegt und sich die Röntgenquelle auf der z-Achse befindet. Durch den Abstand ez der Röntgenquelle zur Bildebene
liegt die Kegelspitze im Punkt e auf der z-Achse in (ex , ey , ez ) mit ex = ey = 0. Der
normierte Vektor v beschreibt die Kegelachse durch den Kugelmittelpunkt und die Röntgenquelle. Der Kugelmittelpunkt wird dabei mit m, der Radius der Kugel mit r bezeichnet.
Der Winkel ϕ ∈ [0, π2 ] gibt den halben Öffnungswinkel des Kegels an. Dadurch ergibt sich
die Kegelgleichung
v · (p − e)
= cos ϕ mit v = m − e.
kp − ek
(4.3)
Dabei sind v, p, e, m ∈ R3 wobei p ein beliebiger Punkt auf dem Kegelmantel ist. Der
Schnittpunkt der Kegelachse mit dem Röntgenbild s ist nicht identisch mit dem Mittelpunkt
c der projizierten Ellipse, sondern ist auf der Hauptachse der Ellipse in Richtung des Fokuspunktes verschoben.
Ist die Entfernung der Röntgenquelle zum Röntgenbild, die Kegelachse und der halbe
Öffnungswinkel bekannt, so kann die Gleichung der projizierten Kugel beziehungsweise
der Ellipse aufgestellt werden. Dafür verwendet man anstatt (4.3) als Kegelgleichung die
Form:
((p − e) × (m − e))2 = r 2 · (p − e)2
Wie bereits erwähnt, entspricht der Punkt p dabei einem beliebigen Punkt auf dem Kegelmantel. Möchte man mit der Kegelgleichung eine Ellipse beschreiben, so wird die zKomponente von p auf null gesetzt. Da dieser Punkt nun zum einen auf der Röntgenbildebene z = 0, und zum anderen auf dem Kegelmantel liegen muss, kann er nur auf dem Rand
der Ellipse liegen, der durch den Schnitt von Kegel und Ebene beschrieben wird. Durch den
Wegfall der z-Komponente von p ergibt sich in Komponentenschreibweise die Gleichung:
71
y
Rön
tgen
bild
Fokuspunkt
s
z
l1
c
v
m
j
l2
r
e = (0, 0, ez)
x
Abbildung 4.6: Der Schnitt zwischen dem Kegel und der Ebene beschreibt eine Ellipse.
(m2y + (ez − mz )2 − r 2 ) · p2x + (m2x + (ez − mz )2 − r 2 ) · p2y − p2y − 2mx my · px py
−2mx ez (ez − mx ) · px − 2my ez (ez − mx ) · py + e2z (m2x + m2y − r 2 ) = 0
Mittels einer Hauptachsentransformation wird daraus:
(pT − cT )RDRT (p − c) − a = 0
Diese Gleichung entspricht genau der Beschreibung einer Ellipse wie sie schon in der Gleichung (2.7) im Abschnitt 2.1.3 vorgestellt wurde.
Sind alle Parameter einer Ellipse im Bild sowie der Radius der Referenzkugeln bekannt,
ist es möglich, die Lage der Kugeln im Raum zu bestimmen. Der Mittelpunkt der Kugeln
72
4.4 Finden von projizierten Ellipsen in Röntgenbildern
im Raum ergibt sich durch:
mx =
re c
pz x
λ2 λ22 + e2z
rez cy
p
λ2 λ22 + e2z
my
=
mz
= ez −
r p 2
λ2 + e2z
λ2
Findet man projizierte Ellipsen in einem Röntgenbild, kann durch das gerade beschriebene Verfahren die Position der Referenzkugeln im Raum bestimmt werden. Entstehen von
einem Objekt mehrere Aufnahmen und werden in diesen mindestens drei Projektionen von
Referenzkugeln gefunden, so ist es möglich die Lage der entstandenen Aufnahmen zueinander im Raum zu bestimmen. Durch die drei projizierten Kugeln kann für jedes Röntgenbild
ein eigenes Koordinatensystem erstellt werden. Überführt man die Koordinatensysteme der
einzelnen Bilder ineinander, so erhält man ein einzelnes Koordinatensystem, in dem alle
Aufnahmen relativ zeinander angeordnet sind (siehe Abbildung 4.7 a). Dadurch ist es möglich, eine dreidimensionale Darstellung des geröntgten Objektes zu rekonstruieren (siehe
Abbildung 4.7 b) [1].
4.4 Finden von projizierten Ellipsen in
Röntgenbildern
Für eine genaue Rekonstruktion des geröntgten Objektes ist es von entscheidender Bedeutung, dass die projizierten Ellipsen in den Röntgenbildern so genau wie möglich gefunden
werden. Jede Abweichung, die beim Finden der Ellipsen stattfindet, verfälscht die Bestimmung der Referenzkugeln im Raum. Das hat zur Folge, dass die Röntgenbilder nicht präzise
zueinander angeordnet werden und somit die 3D-Rekonstruktion ungenau wird.
4.4.1 Finden der Ellipsenparameter
Wie in Abschnitt 2.1.3 beschrieben wurde, haben Ellipsen fünf Freiheitsgerade in der Ebene. Eine „herkömmliche“ Hough Transformation zum Finden der fünf Ellipsenparameter
ist aufgrund des großen Parameterraums, auf heutigen Computern nicht implementierbar
73
Abbildung 4.7: Neun entstandene Röntgenaufnahmen eines Schädels (links), relativ im
Raum zueinander angeordnet. Die beiden Pfeile markieren zwei der drei Referenzkugeln.
Rekonstruiertes dreidimensionales Modell des Schädels (rechts). Bild aus [18].
74
(siehe Abschnitt 3.3.1). Aus diesem Grund ist es sinnvoll, jegliches Vorwissen über die
mögliche Lage der Ellipsen zu verwenden, um den Parameterraum in seiner Größe zu reduzieren.
Projizierte Ellipsen haben die Eigenschaft, dass ihre Hauptachse auf den Fokuspunkt des
Röntgenbildes zeigt. Der Fokuspunkt ergibt sich aus dem Aufbau der Röntgenanwendung
und ist bei den meisten Röntgenbildern bekannt. Damit lässt sich durch die Position des Ellipsenmittelpunktes und die Position des Fokuspunktes die Rotation der Ellipse relativ zur
x-Achse des Röntgenbildes berechnen. Es wird in Zukunft angenommen, dass der Fokuspunkt des Röntgenbildes in der Bildmitte liegt und sich diese im Ursprung im R2 befindet.
Ist der Mittelpunkt (cx , cy ) einer Ellipse im Bild bekannt, so ergibt sich der Rotationswinkel
α der Ellipse durch
α = arctan
cy
,
cx
mit
(cx , cy ) ∈ R2 .
Aus der Abhängigkeit zwischen Ellipsenmittelpunkt und Ellipsenwinkel lässt sich der
ursprünglich fünfdimensionale Parameterraum aufteilen. Anstatt alle fünf Parameter auf
einmal zu suchen, wird zuerst der Mittelpunkt der Ellipse bestimmt, daraufhin die Rotation der Ellipse berechnet und dann nach den Längen der beiden Ellipsenachsen gesucht.
Somit entsteht zunächst nur ein zweidimensionaler Parameterraum zum Finden der x- und
y-Komponente des Mittelpunktes.
Für das Finden des Ellipsenmittelpunktes eignet sich die Chord-Tangent Methode wie sie
in Abschnitt 3.3.2 vorgestellt wurde. Durch die Kombination von Kantenpunkten im Bild
schließt diese Methode auf den Ellipsenmittelpunkt. Dazu wird ein Monte-Carlo Verfahren
verwendet, um beliebige Paare von Kantenpunkten zu generieren. Ist der Ellipsenmittelpunkt durch dieses Verfahren bestimmt, lässt sich die Rotation der Ellipse berechnen.
Nachdem die ersten drei Ellipsenparameter feststehen, können nun die beiden Ellipsenachsen berechnet werden. Da der Ellipsenwinkel bekannt ist, ist auch die Lage der beiden
Achsen bekannt, so dass nur noch deren Länge bestimmt werden muss. Um diese zu ermitteln, läuft man vom Ellipsenmittelpunkt auf den Achsen entlang und sucht nach dem
Kantenpixel mit der höchsten Gradientenintensität. Dieses Kantenpixel repräsentiert sehr
wahrscheinlich den Rand der projizierten Referenzkugel. Da die Referenzkugeln die Röntgenstrahlung fast komplett absorbieren, werden die Kugelschatten im Röntgenbild sehr homogen beziehungsweise als eine einheitlich helle Fläche abgebildet (siehe Abbildung 4.8).
Das bedeutet, dass auf dem Kugelschatten keine hohen Gradientenintensitäten zu erwarten sind und die höchsten Helligkeitsveränderungen am Kugelrand dedektiert werden. Das
75
Suchen nach der höchsten Gradientenintensität entlang einer Achse, kann nun ausgehend
vom Ellipsenmittelpunkt in beide Richtungen für die Haupt- und die Nebenachse ausgeführt
werden. Wurde der Ellipsenmittelpunkt korrekt gefunden, sollten für beide Richtungen einer Achse, beide Kantenpixel mit der höchsten Gradientenintensität den selben Abstand
zum Mittelpunkt haben (siehe Abbildung 4.8).
I(x)
a
b
m
d
d
b
m
a
x
Abbildung 4.8: Eindimensionaler Helligkeitsverlauf entlang einer Achse. Es ist deutlich zu
erkennen, dass die stärkste Helligkeitsveränderung am Kugelrand auftritt und dort somit
eine hohe Sobelintensität detektiert werden kann.
Je nach Anzahl der eingesetzten Referenzkugeln beziehungsweise der projizierten Ellipsen wird für jeden erkannten Mittelpunkt einer Ellipse die Rotation der Ellipse berechnet
und daraufhin die Länge der Ellipsenachsen dedektiert. So können in einem Röntgenbild
alle projizierten Referenzkugeln gefunden und dadurch die Lage der Kugeln im dreidimensionalen Raum berechnet werden.
4.4.2 Probleme der Chord-Tangent Methode bei
Röntgenbildern
In dem gerade erläuterten Verfahren zum Finden aller fünf Ellipsenparameter wird eine
Chord-Tangent Methode zum Finden des Ellipsenmittelpunktes verwendet. Wie schon in
Abschnitt 3.3.2 beschrieben wurde, werden bei dieser Methode zufällig generierte Paare
von Kantenpixel gebildet und dadurch der Ellipsenmittelpunkt ermittelt.
Je nach Größe und Beschaffenheit des Röntgenbildes können jedoch sehr viele Kantenpixel im Bild auftreten. Problematisch sind vor allem Kugeln, die durch ihre Lage im
Raum auf Knochen oder Zähne projiziert werden. Da Knochen oder Zähne sowie die Ku-
76
geln die Röntgenstrahlung stark absorbieren, setzt sich die Kugel kaum von ihrer Umgebung ab (siehe Abbildung 4.9 a). Um dennoch den Rand dieser Kugel als Kantenpixel zu
detektieren, muss der Schwellwert für die Gradientenintesität entsprechend niedrig gewählt
werden. Dies hat wiederrum zur Folge, dass die Anzahl der Kantenpixel im Bild erheblich
zunimmt (siehe Abbildung 4.9 b und c). Gerade bei stark verrauschten Röntgenbildern ist
es kaum noch möglich, zwischen Kanten, die durch Rauschen, und Kanten, die zwischen
zwei Strukturen liegen, zu unterscheiden.
a)
b)
c)
Abbildung 4.9: Die beiden oberen Kugeln setzten sich teilweise kaum von ihrer Umgebung ab (links). Gradientenbild mit hohem Schwellwert für die Kantenerkennung (mitte)
und mit niedrigem Schwellwert (rechts). Es ist gut zu erkennen, dass bei einem zu hohem
Schwellwert die Kugelkanten teilweise nicht erkannt werden. Wird der Schwellwert jedoch
zu niedrig gesetzt, werden auch Kantenpixel erkannt, die durch Bildrauschen entstehen.
Die Chord-Tangent Methode erstellt durch zwei Kantenpixel eine Gerade, die, falls die
Pixel auf einem Ellipsenrand liegen, den Ellipsenmittelpunkt passiert. Der Mittelpunkt wird
bei diesem Verfahren gefunden, indem die entsprechende Zelle der Pixel welche die Gerade
schneidet, im Parameterraum inkrementiert wird. So bilden sich Maxima im Ellipsenmittelpunkt. Liegen die Kantenpixel jedoch nicht auf einem gemeinsamen Ellipsenrand, so
verläuft die erstellte Gerade demnach auch nicht durch den Ellipsenmittelpunkt. Ist dies
der Fall, kommt es zu Fehleintragungen im Parameterraum. Da bei der Chord-Tangent Methode zufällige Paarungen von Kantenpixeln gebildet werden, sinkt jedoch bei steigender
Anzahl von Kantenpixeln die Wahrscheinlichkeit, zufällig zwei zu treffen, die auf dem selben Ellipsenrand liegen. Dadurch werden nur sehr wenige zufällig gewählte Kantenpixel
den Ellipsenmittelpunkt inkrementieren. Durch alle anderen Paare entstehen Fehleinträge.
77
Insgesamt ist es also sehr problematisch eine Chord-Tangent Methode auf ein Röntenbild
mit vielen Kantenpixeln anzuwenden.
4.4.3 Einschränken des Bildraumes um die Ellipse
Um die im vorherigen Abschnitt erläuterten Probleme der Chord-Tangent Methode in Röntgenbildern zu umgehen, ist es sinnvoll, das Bild in dem die Ellipsenfindung stattfindet einzuschränken. Wird der Bildraum so weit eingeschränkt, dass sich nur noch die zu findende
Ellipse darin befindet, steigt die Wahrscheinlichkeit erheblich, dass zwei zufällig ausgewählte Kantenpixel auf dem selben Ellipsenrand liegen. So ist es möglich die Probleme
der Chord-Tangent Methode bei stark verrauschten Bildern mit sehr vielen Kantenpixeln zu
umgehen.
Um den Bildraum einzuschränken, ist es hilfreich die Projektion der Kugeln genauer zu
untersuchen. Wie schon in Abbildung 4.9 a zu erkennen ist, sind die projizierten Ellipsen
fast kreisförmig. Häufig ist ein Unterschied in den Längen der beiden Ellipsenachsen kaum
zu erkennen.
Mit dieser Information ist es möglich, den Bildraum um die Ellipse einzuschränken. Dafür wird eine Hough Transformation für Kreise verwendet, wie sie in Abschnitt 3.2.3 vorgestellt wurde. In dieser wird zuerst der Kreismittelpunkt gefunden und daraufhin der Radius
berechnet. Diese Methode ist wesentlich robuster gegenüber Bildern mit vielen gefundenen
Kantenpixeln als die Chord-Tangent Methode, da die Kreisfindung nicht abhängig von zufällig gewählten Kantenpixelpaaren ist. So ist es möglich, zuerst in dem Röntgenbild nach
Kreisen zu suchen, und daraufhin die Ellipsensuche auf den Bereich um die Kreise einzuschränken. Wird die Chord-Tangent Methode nun nur noch in einem kleinen Teilbild ausgeführt, steigt die Wahrscheinlichkeit erheblich, dass zwei zufällig ausgewählte Kantenpixel
auf dem selben Ellipsenrand liegen.
Durch diesen zusätzlichen Schritt werden schnell und zuverlässig zuerst Kreise gefunden und daraufhin die Ellipsen ermittelt. Insgesamt läuft dabei das eingesetzte Verfahren
folgendermaßen ab:
1. Als erster Schritt wird das Eingangsröntgenbild durch einen Filter geglättet, um verrauschte Bildanteile zu reduzieren.
2. Als nächstes werden Kreismittelpunkte mittels einer schnellen Hough Transformation für Kreise detektiert und daraufhin der dazugehörige Radius berechnet.
78
Orginalbild
Glätten des
Bildes
Bildraum
einschränken
Chord-Tangent
Methode
Hough Transformation
für Kreise
Ermitteln der
Ellipsenparameter
Abbildung 4.10: Ablauf der Ellipsenfindung in Röntgenbildern.
79
3. Nun werden Teilbilder an den Stellen der gefundenen Kreise erstellt.
4. In jedem Teilbild wird mittels der Chord-Tangent Methode der Ellipsenmittelpunkt
detektiert.
5. Der Ellipsenwinkel wird berechnet und die Längen der beiden Ellipsenachsen ermittelt (siehe Abschnitt 4.4.1).
Der gesamte Ablauf zum Finden von projizierten Referenzkugeln in Röntgenbildern, ist in
Abbildung 4.10 zu sehen.
80
5 Implementierung
Als praktische Umsetzung der beschriebenen Verfahren aus den voherigen Kapiteln, entstanden im Rahmen dieser Arbeit zwei Anwendungen. Zum einen ein Prototyp in Java,
der es durch strukturierte Schnittstellen ermöglicht, schnell und einfach neue Algorithmen
zu implementieren und zu testen. In ihm wurden die ersten Tests mit einer Hough Transformation für Geraden, bis hin zu komplexeren Verfahren wie der Ellipsenfindung durch
die Chord-Tangent Methode realisiert. Das eigentlich praktische Ergebnis dieser Arbeit, ist
jedoch ein Modul für die 3D Rekonstruktionssoftware Rsm3D (siehe Abschnitt 1.2) zum
Finden von projizierten Referenzkugeln in Röntgenbildern. Dieses Modul lässt sich nahtlos
in die bereits bestehende Software integrieren und hat die Aufgabe alle Ellipsenparameter
der erkannten Referenzkugeln zu ermitteln und an das nachfolgende Modul weiterzureichen. Dieses Modul wurde in der Programmiersprache C++ entwickelt und läuft, wie auch
die eigentliche Applikation, unter den Betriebssystemen Windows XP der Firma Microsoft und Linux. Darüber hinaus wurden Teile des Moduls mittels eines C-Frameworks so
angepasst, dass die performancekritischen Berechnungen auf die Grafikkarte ausgelagert
werden. Das Ziel war hierbei, dass die Berechnungen zum Finden von Ellipsen durch die
enorme Rechenleistung moderner Grafikkarten gegenüber der Software Implementierung
noch schneller abläuft.
5.1 Java Prototyp
Durch die Implementierung eines Java Prototypen wurde eine Entwicklungsumgebung geschaffen, die es ermöglicht schnell und einfach neue Algorithmen auszuprobieren, Lösungsideen zu verfolgen und erste Ansätze zum schnellen und zuverlässigen Finden von Ellipsen
zu realisieren. Dabei stellt der Prototyp gewisse Grundfunktionalitäten zur Verfügung, die
von den implementierten Algorithmen zum Finden von Strukturen verwendet werden konnten. Ziel der Entwicklung war es, eine gut strukturierte Schnittstelle zwischen den Grund-
81
5 Implementierung
funktionalitäten der Anwendung und den implementierten Algorithmen zu erstellen. Die
Schnittstelle ermöglicht es neu entwickelte Algorithmen, einheitlich in die bestehende Anwendung zu integrieren. Abbildung 5.1 zeigt die grafische Oberfläche des Prototypen mit
einem geladenen Bild und einem ausgewählten Algorithmus zum schnellen Finden von
Kreisen.
Abbildung 5.1: Grafische Oberfläche des Prototypen mit dem Röntgenbild einer Bombenatrappe.
Der Prototyp wurde mit der Java Standard Editon in der aktuellen Version 1.6.0 durchgeführt [30]. Dabei wurden ausschließlich Elemente des dazugehörigen Application Programming Interface (API) verwendet [29]. Die grafische Oberfläche verwendet dabei SwingKomponenten aus dem Paket javax.swing. Als Entwicklungsumgebung kam das OpenSource-Framework Eclipse in der Version 3.3 zum Einsatz [26].
5.1.1 Grundfunktionalitäten
Die eigentliche Funktion des Prototypen ist, durch spezielle Algorithmen algebraisch beschreibbare Strukturen in Bildern zu finden. Die gefundenen Strukturen werden dabei wie-
82
5.1 Java Prototyp
der im ursprünglichen Bild angezeigt werden, um eine optische Kontrolle der Ergebnisse
zu erhalten. Es ist möglich verschiedene Algorithmen auszuwählen sowie deren Parameter
anzuzeigen und zu manipulieren. Darüber hinaus steht, zur einfacheren Fehlersuche und
Optimierung der Algorithmen, eine visuelle Kontrollmöglichkeit der aufgebauten Parameterräume zur Verfügung.
Für das Erstellen von Bildern in denen die Algorithmen Strukturen erkennen sollen, existieren mehrere Möglichkeiten. Zum einen ist es möglich, Bilder mit einfachen Grafikprimitiven selbst zu zeichnen, zum anderen können gespeicherte Bilder die im JPG-Format
vorliegen, eingelesen und angezeigt werden. Als Grafikprimitive stehen Kreise und Linien
zur Verfügung, die mit der Maus direkt auf die Bildfläche gezeichnet werden können.
Über ein Auswahlmenü stehen die implementierten Algorithmen zur Auswahl, die auf
das Bild angewendet werden können. Wird ein Algorithmus ausgewählt, werden die dazugehörigen Algorithmenparameter auf der grafischen Oberfläche angezeigt. Nachdem der
Benutzer die richtigen Parameter für den jeweiligen Algorithmus eingestellt hat, kann dieser auf das vorhandene Bild angewendet werden. Dabei wird nicht unterschieden, ob der
Benutzer das Bild selbst gezeichnet oder ein schon bestehendes Bild von der Festplatte
geladen hat. Vor der Weitergabe der Pixeldaten, wird das Bild in ein Graustufenbild umgewandelt, die Helligkeitswerte in einem zweidimensionales Integer Array gespeichert und an
den jeweils ausgewählten Algorithmus weitergereicht.
Neben dem eigentlichen Bild, bekommt der Algorithmus zusätzlich die eingestellten Parameter übergeben. Der Algorithmus kann nun mit den vorliegenden Daten Strukturen in
Bildern erkennen und deren algebraische Beschreibungen berechnen. Die erkannten Strukturen können durch entsprechende Grafikprimitive mit den jeweils berechneten Parametern
wieder im Bild visualisiert werden. Darüber hinaus werden die Laufzeit der Erkennung
sowie einige weitere Werte auf der Konsole ausgegeben. Der gesamte Ablauf eines Erkennungsprozesses ist in Abbildung 5.2 zu sehen.
5.1.2 Implementierte Algorithmen
Durch eine strukturierte Schnittstelle zwischen der Basissoftware und den Algorithmen,
können schnell und einfach neue Algorithmen in die bestehende Anwendung integriert
werden. Hierzu erben alle konkreten Algorithmenklassen von der abstarkten Basisklasse
Recognition. Durch die Vererbung müssen die Algorithmenklassen eine Methode zum
Erkennen von Strukturen zur Verfügung stellen, der das angezeigte Bild und die eingestell-
83
5 Implementierung
Schritt 1: Benutzer
Bild zeichnen
oder laden
Algorithmus
auswählen
Parameter
einstellen
Algorithmus
starten
Bild und Parameter
an Algorithmus
übergeben
Strukturen
erkennen
gefundene Strukturen visualisieren
Schritt 2: Anwendung
Bild in Graustufen
konvertieren
Abbildung 5.2: Ablauf des Erkennunsprozesses im Java Prototypen.
ten Parameter übergeben werden. Die Algorithmen treten so gegenüber der Basissoftware
nur als Recognition in Erscheinung.
Neben den implementierten Algorithmen existiert eine Helferklasse mit dem Namen
Util, in der verschiedene Methoden ausgelagert sind, die von allen Algorithmen benötigt werden. Unter anderem steht ein Sobel Filter, ein Gauss Filter mit einer Kernel Größe
von 3x3 und 5x5, ein Median Filter sowie einige Methoden zum Finden von lokalen Maxima in Parameterräumen zur Verfügung. Um aufwendige Rechnungen während des Erkennungsprozesses zu vermeiden, werden verschiedene Werte des Sobel Filters schon bei der
Programminitialisierung berechnet und in Look-Up Tabellen gespeichert. Das hat den Vorteil, dass zur Laufzeit der Anwendung Ergebnisse bestimmter Berechnungen nur noch aus
einer Look-Up Tabelle gelesen werden müssen, was viel schneller geschehen kann als die
entsprechenden Werte jedesmal neu zu berechnen.
Im Folgenden wird kurz auf die implementierten Algorithmen und dessen Ablauf eingegangen. Im Rahmen dieser Arbeit wurden dabei eine schnelle Hough Transformation für
Geraden und Kreise sowie eine Chord-Tangent Methode zum Finden von Ellipsen implementiert.
Schnelle Hough Transformation für Geraden
Um Geraden in Bildern zu erkennen, wurde eine schnelle Hough Transformation für Geraden implementiert, so wie sie in Abschnitt 3.1.3 vorgestellt wurde. Der Erkennungsalgorithmus bekommt dabei von der Basissoftware ein Bild in Form eines zweidimensionalen
Integer Arrays sowie einem Integer Array mit den eingestellten Parametern übergeben. Das
84
5.1 Java Prototyp
Bildarray enhält dabei Helligkeitsinformationen, die in einer Auflösung von 8 Bit vorliegen.
Um die eingestellten Parameter verständlicher im Programmcode zu verwenden, werden diese als erstes aus dem Parameterarray in Variablen mit verständlicheren Bezeichnern
kopiert. Als Parameter können dabei der Sobelschwellwert, der festlegt ab welcher Kantenstärke ein Pixel als Kantenpixel gilt, die Anzahl der zu findenden Geraden und der minimale
Abstand zwischen zwei Maxima im Parameterraum angegeben werden. Der minimale Abstand von zwei Maxima stellt sicher, dass keine Zellen als Maximum gewertet werden die
zu nah aneinanderliegen, da zu dicht liegende hochgewertete Zellen sehr wahrscheinlich die
selbe Struktur repräsentieren.
Als zweiter Schritt des Erkennungsprozesses wird der Parameterraum als zweidimensionales Integer Array erstellt. Da für die Indizes für dieses Array nur positive Ganzzahlen
verwendet werden können, wird für den Winkel, der zusammen mit seiner Länge eine Gerade beschreibt, nicht der Wertebereich [0, π) sondern [0, 314) verwendet. Um die Auflösung
des Wertebereiches zu erhöhen, kann dieser mit einem konstanten Wert multipliziert werden. Um von einem Index auf den jeweiligen Winkel zu kommen, muss einfach der Index
durch das hundertfache des konstanten Wertes geteilt werden.
Zusätzlich zum Parameterraum wird eine Datenstruktur initalisiert, in der bereits während der Parameterraum gefüllt wird, die maximal gewertesten Zellen gespeichert werden.
Hierfür wird die Position einer Zelle beziehungsweise die beiden Parameter sowie deren
Wertung gespeichert. Die Anzahl der Zellen die gespeichert werden, kann dabei über einen
Algorithmenparameter eingestellt werden.
Nachdem der Parameterraum erstellt und alle Variablen initalisiert wurden, wird das Eingangsbild durch einen Gauß Filter geglättet. Dazu wird ein zweites Array angelegt, das in
Dimension und Größe genau dem Array des Eingangsbildes entspricht. Dorthin werden die
geglätteten Bildwerte gespeichert.
Für die eigentliche Hough Transformation läuft man nun über das geglättete Bild und
sucht nach Kantenpixeln. Für jedes detektierte Kantenpixel wird über einen Wertebereich
um den Winkel der lokalen Kante des Pixels iteriert. Dabei berechnet man für den Winkel
die dazugehörige Länge des Vektors, die eine Gerade durch dieses Kantenpixel beschreibt.
Sind beide Werte berechnet, wird die entsprechende Zelle im Parameterraum inkrementiert.
Dabei wird überprüft, ob die gerade erhöhte Zelle zu den am höchsten gewertesten Zellen
im Parameterraum gehört und gegebenenfalls in der dafür vorgesehenden Datenstruktur
gespeichert.
Nachdem die Hough Transformation zwischen Bild und Parameterraum abgeschlossen
85
5 Implementierung
ist, befinden sich in der angelegten Datenstruktur die Position der am höchsten gewertesten
Zellen. Die Positionen entsprechen dabei den Parametern, der am besten erkannten Geraden
im Bild. Diese werden nun visualisiert, um das Ergebnis der Geradenfindung zu überprüfen.
Der gesamte Erkennungsprozess für Geraden lässt sich in folgende Abschnitte zusammenfassen:
1. Kopieren der übergebenen Algorithmenparameter
2. Erstellen des Parameterraums und Initalisieren von Variablen
3. Glätten des Eingangsbildes
4. Hough Transformation von den Bild- in den Parameterraum
5. Visualisieren der gefundenen Geraden
Nachdem der Algorithmus auf das Bild angewendet wurde, lässt sich der gefüllte Parameterraum visualisieren (siehe Abbildung 5.3). Dabei ist es zur Fehlersuche innerhalb des
Algorithmus sehr hilfreich, dass die Position des Mauszeigers über dem Parameterraum in
zwei Geradenparameter umgerechnet und die dazugehörige Gerade im Bild angezeigt wird.
Schnelle Hough Transformation für Kreise
Die schnelle Hough Transformation für Kreise ist eine Implementierung des Verfahrens aus
Abschnitt 3.2.3. Dabei wird zunächst der Kreismittelpunkt mittels einen zweidimensionalen
Parameterraumes detektiert und daraufhin der dazugehörige Radius mittels eines eindimensionalen Parameterraumes berechnet.
Wie schon bei dem implementierten Verfahren zum Finden von Geraden, bekommt der
Algorithmus ein Bildarray und ein Parameterarray und kopiert daraufhin die eingestellten
Parameter in Variablen mit verständlichen Bezeichnern. Als Parameter können hierbei der
Sobelschwellwert, die Anzahl der zu findenden Kreise, ein minimaler und ein maximaler
Radius sowie der minimale Abstand zwischen zwei Maxima im Parameterraum eingestellt
werden.
Nachdem alle Werte initalisiert sind, wird ein Parameterraum als zweidimensionales Integer Array erstellt. Dessen Größe entspricht der des Bildes, wird aber zusätzlich an jeder
86
5.1 Java Prototyp
Abbildung 5.3: Durch das Bewegen des Mauszeigers auf dem visualisierten Parameterraum,
bewegt sich die markierte Gerade (siehe Pfeil).
87
5 Implementierung
Seite um den maximal eingestellten Radius vergrößert. Dadurch können auch Kreise detektiert werden, deren Mittelpunkt außerhalb des Bildes liegt. Wie auch bei der Geradenfindung, wird zusätzlich eine Datenstruktur angelegt, um die am höchsten gewertetsten Zellen
schon während dem Füllen des Parameterraumes zu speichern.
Bevor die eigentliche Hough Transformation beginnt wird das Bild zunächst geglättet.
Danach wird Pixel für Pixel über das geglättete Bild gelaufen und Kantenpixel detektiert.
Für jedes Kantenpixel iteriert man nun über den eingestellten Radiusbereich und läuft auf
dem Gradienten des Kantenpixels in Richtung des Kreismittelpunktes. Die entsprechenden
Zellen werden dabei im Parameterraum inkrementiert und die am höchsten gewertesten
gespeichert.
Nach diesem Schritt befinden sich nun sämtliche Kreismittelpunkte in der dafür vorgesehenden Datenstruktur. Für jeden Mittelpunkt wird nun ein Parameterraum für das Finden
des dazugehörigen Radius erstellt und über den umliegenden Bereich iteriert. Für jedes
Kantenpixel in dem Bereich berechnet man den Abstand zum Kreismittelpunkt und erhöht
die entsprechende Zelle im Radiusarray. Danach wird die am höchsten gewerteste Zelle aus
dem Aray herausgesucht, die dem zum Mittelpunkt gehörenden Radius entspricht. Damit
sind alle drei Parameter eines Kreises bestimmt und der gefundene Kreis kann im Orginalbild visualisiert werden.
Auch bei der Kreisfindung lässt sich der verwendete Parameterraum zum Finden der
Kreismittelpunkte visualisieren. Die einzelnen Schritte der Kreisfindung sind im Folgenden
noch einmal kurz zusammengefasst:
2. Erstellen des Parameterraums und Initalisieren von Variablen.
4. Hough Transformation zum Finden der Kreismittelpunkte
5. Hough Transformation zum Finden des entsprechenden Radius
6. Visualisieren der gefundenen Kreise
Schnelle Hough Transformation für Ellipsen
Neben der Geraden- und Kreisfindung, wurde auch eine Schnelle Hough Transformation
für Ellipsen zum Finden von Ellipsenparametern implementiert. Hierbei wurden zuerst El-
88
5.1 Java Prototyp
lipsenmittelpunkte mittels der Chord-Tangent Methode berechnet und danach für jeden gefundenen Mittelpunkt die restlichen Parameter der zu findenden Struktur ermittelt. Dabei
wurde der Fokuspunkt eines Bildes im Bildmittelpunkt angenommen, so dass über die Position des Ellipsenmittelpunktes die Rotation der Ellipse berechnet werden kann.
Als Parameter die dem Algorithmus bei diesem Verfahren übergeben werden, können
unter anderem der Sobelschwellwert, die Anzahl der zu findenden Ellipsen, die maximale Länge der Hauptachse, die Anzahl der Monte-Carlo Schritte und der minimale Abstand
zweier Maxima im Parameterraum eingestellt werden. Ausserdem kann das Bild mittels
eines Parameters an den Rändern abgeschnitten werden. Dies ist sinnvoll, da bei Röntgenbildern teilweise zusätzliche Bildinformationen, wie zum Beispiel der Patientenname, am
Bildrand aufgeführt sind. Da solche Informationen nicht zur eigentlichen Bildinformation
gehören, können sie über den entsprechenden Parameter ausgeblendet werden.
Im ersten Schritt der Erkennung wird zunächst ein Parameterraum erstellt, die Algorithmenparameter in einzelne Variablen kopiert und das Bild geglättet. Die Größe des Parameterraums entspricht dabei der Größe des Eingangsbild. Nach dieser Initalisierung wird über
das gesamte Bild iteriert und alle Kantenpixel in einer dafür angelegten Struktur gespeichert.
Sind die Kantenpixel im Bild gespeichert, beginnt das Monte-Carlo Verfahren der ChordTangent Methode. Dabei werden soviele Paare von Kantenpixeln gebildet, wie Monte-Carlo
Schritte eingestellt sind. Zur Bildung eines Paares werden zwei Kantenpixel zufällig aus
den vorher gespeicherten ausgewählt. Nun wird der Schnittpunkt der Tangenten sowie der
Mittelpunkt der beiden Kantenpixel berechnet. Auf der daraus resultierenden Geraden wird
entlang gelaufen, die entsprechenden Zellen im Parameterraum inkrementiert und die am
höchsten gewertesten Zellen gespeichert.
Nach diesem Verfahren repräsentieren die gespeicherten Zellen die gefundenen Ellipsenmittelpunkte. Nun wird für jeden Mittelpunkt der Ellipsenwinkel berechnet und danach die
Länge der beiden Ellipsenachsen bestimmt. Dazu erstellt man zunächst einen zweidimensionalen Parameterraum, der in beiden Dimensionen der Länge der maximal eingestellten
Ellipsenachse entspricht. Daraufhin iteriert man über alle bereits gespeicherten Kantenpixel
und detektiert solche, die in der Nähe des gefundenen Ellipsenmittelpunktes liegen. Diese werden nun entgegen den Ellipsenmittelpunkt in Richtung des Koordinatenursprungs
verschoben und gegen den berechneten Ellipsenwinkel gedreht. Dadurch wird die Ellipse,
bestehend aus ihren Kantenpixeln, in eine achsparallele Form im Ursprung gebracht (siehe
Abbildung 5.4). Durch Umstellen der impliziten Ellipsengleichung (2.5) zu einem der bei-
89
5 Implementierung
(kx, ky)
y
y
l1
l2
c
(k,
x ky )
l2
a
x
l1
c
x
Abbildung 5.4: Eine Ellipse wird in den Ursprung verschoben und durch eine Rotation in
eine Achsparallele Form gebracht.
den Achsenparameter, ist es nun möglich über einen Achsenparameter zu iterieren und den
anderen auszurechnen. Die entsprechende Zelle im Parameterraum wird inkrementiert und
die am höchsten gewerteste Zelle gespeichert. Die Position der Zelle entspricht den Längen
der beiden Ellipsenachsen, so dass nun alle Ellipsenparameter feststehen und im Bild visualisiert werden können. Die einzelnen Schritte der Ellipsenfindung sind im Folgenden noch
einmal kurz aufgeführt:
2. Erstellen des Parameterraums zum Finden der Ellipsenmittelpunkte und Initalisieren
von Variablen
4. Finden und Speichern aller Kantenpixel
5. Anwenden der Chord-Tangent Methode zum Finden der Ellipsenmittelpunkte
6. Hough Transformation zum Finden der Ellipsenachsen
7. Visualisieren der gefundenen Ellipsen
Bei den Tests des implementierten Algorithmus zeigte sich, das zwar die Ellipsenmittelpunkte durch die Chord-Tangent Methode sehr zuverlässig gefunden wurden, jedoch die
90
5.2 Rsm3D Modul
Berechnung der Achsenlängen nicht zu der gewünschten Genauigkeit führte. Wurde die
Länge der Nebenachse noch gut erkannt, so traten bei der Berechnung der Hauptachsenlänge häufig Fehlerkennungen auf. Selbst bei synthetisch erzeugten Bildern konnte die Länge der Hauptachse nicht zuverlässig detektiert werden. Aus diesem Grund wird bei dem
Verfahren, das in dem Rsm3D Modul implementiert ist, die Achsenberechnung durch die
Detektion der größten Sobelintensität entlang der Achsen realisiert (siehe Abschnitt 4.4.1).
5.2 Rsm3D Modul
Das eigentliche praktische Ergebnis dieser Arbeit, ist ein Modul für die Software Rsm3D
(siehe Abschnitt 1.2), das es ermöglicht schnell und zuverlässig projizierte Ellipsen in Röntgenbildern zu finden. Die Grundstruktur des Moduls war dabei bereits durch das Rsm3D
Framework vorgegeben [20]. Mit dieser Vorgabe war es durch wenig Arbeitsaufwand möglich, die Grundstruktur des Moduls zu implementieren, so dass sich dieses nahtlos in die
bereits bestehende Umebung einfügt und mit anderen Modulen kommunizieren kann. So
konnte der Schwerpunkt auf die Implementierung der entwickelten Algorithmen gelegt werden. Nachdem das Modul alle Ellipsenparameter berechnet hat, gibt es die Ergebnisse an
sein Nachfolgemodul weiter, das daraus die 3D-Position der Referenzkugeln im Raum bestimmt. Mit dieser Information kann eine Rekonstruktion des geröngten Objektes stattfinden.
Die Gundarchitektur des Rsm3D Framework entspricht einer Pipeline. Ein Modul nimmt
Daten von einem Vorgänger-Modul entgegen, arbeitet auf den vorliegenden Daten und gibt
die manipulierten Daten an sein Nachfolgermodul weiter. Es liest dabei verschiedene Datensätze ein und stellt die manipulierten sowie neue Datensätze an seinem Ausgang zur
Verfügung. Für die Implementierung der Ellipsenfindung in Röntgenbildern, wurden bereits
bestehende Module zum Importieren, Glätten und Visualisieren der Röntgenbilder verwendet.
Der verwendete Röntgenbild Importer liest dabei keine einzelnen, sondern ganze Gruppen von Röntgenbildern ein. Dies ist sinnvoll da für eine 3D-Rekonstruktion immer mehrere Röntgenbilder vorliegen. Verschiedene Röntgenbilder können dabei in einer DCV Datei
zusammengefasst werden, in der eine Liste von Referenzen auf die einzelnen Bilder gespeichert ist und die vom Importer eingelesen werden kann. Die Röntgenbilder an sich müssen
91
5 Implementierung
im Dicom Format1 vorliegen, welches häufig zum Speichern von Röntgenbildern in medizinischen Anwendungen verwendet wird. Ist eine Serie von Röntgenbildern importiert, kann
auf deren Helligkeitswerte über einen Bildindex und eine Pixelposition zugegriffen werden.
Zum Anzeigen der Röntgenbilder sowie zum Visualisieren der gefundenen Referenzkugeln wird das Modul Dicom Viewer verwendet. Der Viewer ist in der Lage, die verschiedenen Röntgenbilder in einer Serie anzuzeigen. Darüber hinaus kann er zusätzlich gespeicherte Metainfomationen, wie zum Beispiel gefundenen Strukturen, visualisieren, was eine
optische Kontrolle der Strukturen ermöglicht.
Das entwickelte Modul zum Finden von projizierten Referenzkugeln beziehungsweise
Ellipsen, verwendet den Algorithmus wie er in Abschnitt 4.4 vorgestellt wurde. Dabei wird
zuerst nach Kreisen in den Röntgenbildern gesucht und das Bild um die Kreise herrum beschnitten. In den beschnittenen Teilbildern wird daraufhin mittels der Chord-Tangent Methode nach dem Ellipsenmittelpunkt gesucht, der Ellipsenwinkel berechnet und daraufhin
die beiden Ellipsenachsen bestimmt. Der gesamte Ablauf der Ellipsenfindung ist dabei:
1. Entgegennehmen der Röntgenbilder
2. Schnelles Finden der Kreismittelpunkte (siehe Abschnitt 3.3.2)
3. Berechnen der Kreisradien
4. Beschneiden des Bildes um die gefundenen Kreise
5. Anwenden der Chord-Tangent Methode zum Finden der Ellipsenmittelpunktes in den
beschnittenen Bildbereichen (siehe Abschnitt 3.3.2)
6. Berechnen des Ellipsenwinkels relativ zur x-Achse
7. Bestimmen der Längen der beiden Ellipsenachsen (siehe Abschnitt 4.4.1)
8. Weitergabe der gefundenen Ellipsenparameter an das nachfolgende Modul
Der performancekritischste und rechenintensivste Teil dieses Ablaufes ist das Finden der
Kreise, da dieser auf den gesamten Röntgenbildern stattfindet und nicht wie das Bestimmen
der Ellipsen, nur auf eingeschränkten Teilbildern. Da die verwendeten Röntgenbilder mitunter eine Größe von 2600 × 2100 Bildpunkten haben und sich in einer Röntgenbildserie
1
Dicom = Digital Imaging and Communications in Medicine
92
5.2 Rsm3D Modul
bis zu zehn Röntgenbilder befinden, kann es vorkommen, dass die Kreisfindung im Vergleich zur Ellipsenfindung sehr lange dauert. Aus diesem Grund wurde als Alternative zur
softwarebasierten Methode zum Finden der Kreise auf der CPU (Central Processing Unit),
das verwendete Verfahren auf der Grafikkarte implementiert. Durch die enorme Rechenleistung moderner Grafikkarten und GPUs (Graphic Processing Unit), soll die Kreisfindung
auch auf großen Röntgenbildern schnell ablaufen. Der Ablauf der Ellipsenfindung sowie
die unterschiedlichen Teile des Moduls sind in Abbildung 5.5 aufgeführt.
Rsm3D
Framework
oder
Modul B
CPU
GPU
Kreise finden
Kreise finden
Ellipsenfindung
Bilder beschneiden
Ellipsen finden
Modul A
Abbildung 5.5: Ablauf der Ellipsenfindung.
5.2.1 Software Implementierung
Um sich in die bereits bestehende Applikation integrieren zu können, erbt das entwickelte
Modul von der Klasse RsmModul. Dadurch ist es gezwungen einige Methoden zu überschreiben, die für die Entgegennahme und Weitergabe der Bild- und Metadatenstrukturen
93
5 Implementierung
verantwortlich sind. Welche Daten entgegengenommen und weitergegeben werden kann
dabei genau spezifiziert werden. Darüber hinaus können in der Modulklasse verschiedene
Einstellungen zum Anzeigen und zur Benennung festgelegt werden. Die eigentliche Aufgabe der Modulklasse besteht jedoch darin, die Bilddaten entgegenzunehmen, sie an die
Erkennerklassen für die Kreis- und Ellipsenfindung weiterzugeben und das Ergebnis, beziehungsweise die gefundenen Ellipsenparameter, in eine Datenstruktur zu schreiben und diese
an ein Nachfolgemodul weiterzureichen. Außerdem werden in der Modulklasse über einen
Einstellungsdialog sämtliche Algorithmenparameter gesetzt und diese an die Erkennerklassen weitergereicht. Welche Parameter genau eingestellt werden können, ist im Anhang C.3
beschrieben.
Zum Finden der Kreise in den Röntgenbildern, erstellt sich die Modulklasse eine Instanz
der Kreisfindungsklasse und übergibt ihr die eingestellten Algorithmenparameter sowie die
vorliegenden Bild- und Metainformationen. Beim Starten des Erkenungsvorganges wird außerdem eine Datenstruktur zum Speichern aller gefundenen Kreisparameter übergeben. Für
die Kreisfindung wird nun über alle Bilder der vorliegenden Serie iteriert und in jedem Bild
nach Kreisen gesucht. Dazu wird zunächst ein zweidimensionaler Integer Vektor initalisiert,
der exakt die gleiche Größe wie das zu untersuchende Röntgenbild hat. Dadurch können nur
Kreise gefunden werden, deren Mittelpunkte im Bild liegen. Da aber davon ausgegangen
werden kann, dass sich die projizierten Kugeln vollständig im Bild befinden, sollte diese
Einschränkung kein Problem sein. Für jeden Kantenpunkt im Bild wird nun entlang seines
Gradienten gelaufen und die entspechende Zelle im Parameterraum inkrementiert. Die maximal gewertesten Zellen, welche den Kreismittelpunkten entsprechen, werden dabei schon
während dem Füllen des Parameterraumes gespeichert. Für die gefundenen Mittelpunkte
wird im Folgenden nach einem passenden Radius gesucht. Dafür wird über den Bildbereich
um den Mittelpunkt iteriert und für jedes Kantenpixel die Entfernung zu diesem Mittelpunkt in einem eindimensionalen Parameterraum vermerkt. Die Position der am höchsten
gewertesten Zelle in diesem Parameterraum entspricht dabei dem gefundenen Radius für
den dazugehörigen Mittelpunkt. Als letzter Schritt werden die gefundenen Kreisparameter
in der übergebenen Datenstruktur gespeichert. Außerdem können die gefundenen Kreismittelpunkte und Kreisränder in den Metainformationen gesetzt werden um diese so durch das
Viewermodul zu visualisieren. Der Algorithmus auf dem diese Implementierung basiert, ist
in Abschnitt 3.3.2 genauer erläutert.
Die Modulklasse erstellt nach der Kreisfindung eine Instanz der Ellipsenfindungsklasse
und übergibt dieser die eingestellten Parameter zur Ellipsenfindung, die Bild- und Metada-
94
5.2 Rsm3D Modul
ten sowie die Datenstruktur mit den bereits gefundenen Kreisen. Zum Finden der Ellipsenparameter wird für jedes Bild einer Röntgenserie über alle gefundenen Kreise in diesem Bild
iteriert. In dem Bereich um den Kreis werden alle Kantenpixel detektiert und gespeichert.
Nun wird für jedes Teilbild mittels eines zweidimensionalen Vektors, ein Parameterraum
zum Finden der Ellipsenmittelpunkte erstellt, der die gleiche Größe wie das Teilbild hat, in
dem die Ellipse vermutet wird. Durch das zufällige Auswählen von Kantenpixelpaaren wird
der erstellte Parameterraum durch die Chord-Tangent Methode gefüllt. Wie schon beim Finden der Kreismittelpunkte, so wird auch hier die maximal gewerteste Zelle schon während
dem Füllen des Parameterraumes gespeichert. Diese Zelle entspricht dabei dem detektierten Ellipsenmittelpunkt. Durch den Ellipsenmittelpunkt kann der Ellipsenwinkel relativ zur
x-Achse berechnet werden, so dass schon drei der fünf Ellipsenparameter feststehen und
nur noch die Ellipsenachsen berechnet werden müssen.
Dafür wird vom Ellipsenmittelpunkt entlang der Ellipsenachsen gelaufen und das Pixel
mit der größten Sobelintensität gesucht. Ist der Mittelpunkt der Ellipse korrekt gefunden
worden, so sollte der Abstand vom Mittelpunkt zu den beiden stärksten Kantenpixeln einer
Achse identisch sein. Das genaue Verfahren ist in Abschnitt 4.4.1 erläutert.
Nachdem nun alle fünf Parameter einer Ellipse in einem Teilbild gefunden sind, werden diese in einer Datenstruktur gespeichert. Sind alle Ellipsen in allen Röntgenbildern der
Serie gefunden, können die Ergebnisse von der Modulklasse an ihr Nachfolgemodul weitergegeben werden, welches daraus die Position der projizierten Kugeln im Raum bestimmen
kann.
5.2.2 Implementierung auf der GPU
Wie bereits erwähnt wurde, ist es sinnvoll in Röntgenbildern zuerst nach Kreisen zu suchen,
um so das Bild zu beschneiden und die Ellipsenfindung auf einem wesentlich kleineren Teilbild laufen zu lassen. Jedoch kann auch die Kreisfindung im Vergleich zur Ellipsenfindung
mitunter sehr lange dauern. Die Dauer der Kreisfindung ist dabei vor allem abhängig von
der Größe und Anzahl der Röntgenbilder einer Serie sowie den gewählten Algorithmenparametern. Der Parameter der die Laufzeit am stärksten beeinflusst, ist der Sobelschwellwert,
der angibt ab welcher Sobelintensität ein Kantenpixel vorliegt. Wird dieser zu gering gewählt, steigt die Anzahl der Kantenpixel im Bild, was die Dauer der Kreisfindung erheblich
steigert, da für jeden einzelnen Kantenpunkt der Gradient verfolgt und die entsprechende
Zelle im Parameterraum inkrementiert wird.
95
5 Implementierung
Um die zum Teil hohe Dauer der Kreisfindung zu verringern und das Verfahren zu beschleunigen, kann die Rechenleistung moderner Grafikkarten genutzt werden. Wie in Abbildung 5.6 zu sehen ist, ist in den letzten Jahren die Rechenleistung von 3D-Grafikkarten im
Vergleich zu Prozessoren erheblich gestiegen. Diese Rechenleistung kann nicht nur für grafisch aufwendige Computerspiele, sondern auch in anderen rechenintensiven Programmen
genutzt werden. Die Grafikkarte dient dabei als Koprozessor, dem eine bestimmte Aufgabe
zum Berechnen von einer Hauptanwendung übergeben wird, und dieser nach der Berechnung das Ergebnis an die Hauptanwendung zurückliefert. Die Kommunikation zwischen
Hauptanwendung auf der CPU und Nebenanwendung auf der GPU, findet bei modernen
Grafikkarten über schnelle PCI-Express Bussysteme (ca. 4GB/s) statt, so dass die Datenkommunikation die Ausführungsdauer der Anwendung kaum steigert.
Die hohe Rechenleistung einer Grafikkarte entsteht jedoch nicht durch eine höhere Taktrate des Grafikprozessors, sondern durch den massiven parallelen Einsatz von mehreren
Mikroprozessoren auf der Grafikkarte. Moderne Grafikkarten sind auf die schnelle Darstellung von aufwendigen, dreidimensionalen Szenen ausgelegt, bei denen nicht mehr auf die
Parallelisierung von Berechnungen verzichtet werden kann. Aus diesem Grund wird bei einer Grafikkarte weniger Wert auf die Flusskontrolle eines Programmes gelegt, sondern viel
mehr auf die eigentliche Verarbeitung der anstehenden Daten [5]. Die Stärke einer Grafikkarte ist dabei dass Ausführen des gleichen Programmes auf unterschiedlichen Daten in
vielen parallel laufenden Ausführungssträngen, so genannten Threads.
Die hohe Rechenleistung einer Grafikkarte kann natürlich nur genutzt werden, wenn sich
ein Problem auch ausreichend parallelisieren lässt und so die Berechnung auf mehrere Mikroprozessoren aufgeteilt werde kann. Ein Problem lässt sich dabei parallelisieren, wenn es
in mehrere Teilprobleme zerlegt werden kann, deren Berechnungen unabhängig voneinander ablaufen können. Die Bedingung hierbei ist, dass es möglich ist ein Teilproblem ohne
das Ergebnis eines anderen Teilproblems zu berechnen. Es stellt sich also die Frage, ob die
Kreisfindung parallelisiert werden kann, um so die hohe Rechenleistung moderner Grafikkarten auszunutzen.
Um diese Frage zu klären wird zunächst die Kreisfindung in mehrere Teilprobleme aufgeteilt: Zuerst wird ein Parameterraum zum Finden der Kreismittelpunkte erstellt und gefüllt.
Daraufhin werden Maxima in diesem Parameterraum gesucht, die den Kreismittelpunkten
entsprechen. Als letzter Schritt wird für jeden Mittelpunkt der dazugehörige Radius berechnet. Diese drei Aufgaben sind voneinander abhängig und können nur hintereinander
ablaufen, da für die Berechnung eines Ergebnisses das Ergebnis der vorherigen Aufgabe
96
5.2 Rsm3D Modul
GFLOP/s
300
G80GL
G80
G71
G70
NV40
NV35
NV30
=
=
=
=
=
=
=
G80 /
G80GL
Quadro 5600 FX
GeForce 8800 GTX
GeForce 7900 GTX
GeForce 7800 GTX
GeForce 6800 Ultra
GeForce FX 5900 Ultra
GeForce FX 5800
G71
G70
200
G70-512
100
NV35
NV40
3.0 GHz
Intel Core 2 Duo
NV30
0
Jan 03
Jun 03
Apr 04
Mai 05
Nov 05
März 06
Nov 06
Abbildung 5.6: Vergleich der Rechenleistung in Milliarden Flieskommaberechnungen
pro Sekunde (GFLOP/s) von Grafikprozessoren gegenüber herkömmlichen CPUs. Grafik
nach [5].
97
5 Implementierung
vorliegen muss. Jede dieser Aufgaben bietet aber für sich Ansätze zur Parallelisierung.
Die erste Aufgabe die parallelisiert werden kann, ist das Füllen des Parameterraumes.
Dies geschieht, indem für jedes Pixel berechnet wird, ob es ein Kantenpixel ist. Trifft das
zu, wird entlang des Gradienten des Kantenpixels gelaufen und die entsprechende Zelle
im Parameterraum erhöht. Dieser Vorgang findet für jedes einzelne Pixel statt, unabhängig
davon ob dieses Verfahren auch auf andere Pixel des Bildes angewendet wird. Es ist also
möglich, ein einziges Programm zu verwenden, das auf unterschiedlichen Eingabe- beziehungsweise Pixeldaten arbeitet. Damit ist dieses Problem perfekt parallelisierbar.
Der zweite Schritt ist das Finden der Maxima in dem gefüllten Parameterraum. Hier
kann nicht jede Zelle des Parameterraumes für sich untersucht werden, da die Maxima im
gesamten Parameterraum gefunden werden sollen und somit mehrere Zellen miteinander
verglichen werden müssen. Jedoch existiert eine zusätzliche Bedingung, die helfen kann
das Problem zu parallelisieren. Um nicht zwei Zellen als lokale Maxima zu nehmen, die
in unmittelbarer Nachbarschaft zueinander stehen und wahrscheinlich den gleichen Kreis
repräsentieren, kann in den Einstellungen angegeben werden, welche Entfernung zwei Maxima mindestens haben müssen um als solche angesehen zu werden. Das bedeutet, dass
zwei Maxima einen Mindestabstand einhalten müssen. Mit diesem Wissen ist es möglich,
ein Parameterraum in mehrere Bereiche aufzuteilen, die die Breite und Höhe des eingestellten Mindestabstandes haben. In jedem Bereich kann nur ein einziges Maxima existieren,
da sonst der eingestellte Mindestabstand nicht eingehalten wäre. Für jeden Bereich wird
nun die am höchsten gewerteste Zelle beziehungsweise das lokale Maximum gesucht und
die Position der lokalen Maxima in einer globalen Datenstruktur gespeichert (siehe Abbildung 5.7). Nun muss nur noch einmalig über diese Datenstruktur iteriert werden und die
am höchsten gewertesten Zellen gesucht werden. Das Finden der lokalen Maxima in den
Teilbildern kann dabei parallel ausgeführt werden, da die Ergebnisse für jedes Teilbild unabhängig voneinander sind. Nur das Iterieren über die zusammengefassten Ergebnisse muss
sequentiel ablaufen, da hier wieder unterschiedliche Zellen miteinander verglichen werden.
Nachdem alle Kreismittelpunkte zuverlässig gefunden worden sind, kann für jeden Mittelpunkt der dazugehörige Radius berechnet werden (siehe Abschnitt 3.2.3). Hierzu wird ein
eindimensionaler Parameterraum erstellt und das Bild um den gefundenen Mittelpunkt in
den Parameterraum transformiert. Das Füllen des Parameterraumes könnte dabei genauso
parallelisiert werden wie bei der Mittelpunktssuche. Allerdings wird das Finden des korrekten Radius nur auf einem sehr kleinen Teilbild um den Mittelpunkt ausgeführt und in
98
5.2 Rsm3D Modul
a
x y
a
a = minimaler Abstand
zwischen zwei
Maximas
Parameterraum
Abbildung 5.7: Der Parameterraum wird aufgeteilt, parallel in den Teilbildern nach der
höchstgewertetsten Zelle gesucht und dessen Position gespeichert.
einen vergleichsweise kleinen Parameterraum übertragen. Eine Parallelisierung dieses Vorgangs würde hier also keine wahrnehmbare Beschleunigung des Verfahrens bedeuten. Was
dagegen ohne viel Aufwand parallelisiert werden kann, ist das Finden der Radien für unterschiedliche Kreismittelpunkte. Sollen in einem Röntgenbild beispielsweise drei projizierte
Kugeln gefunden werden, so sind das in einer Serie mit acht Bildern schon 24 Kugeln und
somit 24 Radienberechnungen. Diese Radienberechnungen können ohne Probleme unabhängig voneinander ablaufen, da jeder Radius für einen anderen Kreismittelpunkt in unterschiedlichen Bildbereichen stattfindet.
CUDA
Um die verwendeten Algorithmen zu parallelisieren und auf der Grafikkarte laufen zu lassen, wurde das CUDA Software Development Kit (SDK) der Firma NVIDIA verwendet.
CUDA steht dabei für Compute Unified Device Architecture und bezeichnet eine Soft- und
Hardwarearchitektur zum parallelen Ausführen von Programmen auf einer Grafikkarte [5].
Es besteht aus einem in der Programmiersprache C geschriebenen Application Programming Interface (API) zum Managen, Kontrollieren und Ausführen von Programmen sowie
99
5 Implementierung
einem speziellen Compiler zum Übersetzen der Programme für die Grafikkarte.
Innerhalb des CUDA SDKs wird der Rechner auf dem eine Hauptanwendung läuft als
Host bezeichnet, die Grafikkarte auf die Berechnungen ausgelagert werden als Device. Die
ausgelagerten Funktionen werden dabei auch Kernel genannt. Es ist möglich vom Host
aus Funktionen auf der Grafikkarte aufzurufen und verschiedene Parameter zu übergeben.
Dabei kann angegeben werden wie viele Instanzen der Funktion auf der Grafikkarte parallel
laufen sollen. Darüber hinaus stellt die CUDA-API Funktionen bereit, um Speicher auf der
Grafikkarte zu reservieren und Speicherbereiche zwischen Host und Device zu kopieren.
Eine Funktion beziehungsweise ein Kernel der auf der Grafikkarte läuft, kann, um parallelisiert zu werden, in mehreren Threads ablaufen. Diese Threads werden wiederrum in
so genannten Blocks zusammengefasst, die in einem Grid laufen (siehe Abbildung 5.8). Alle Threads, die auf der Grafikkarte laufen, haben dabei Lese- und Schreibzugriff auf den
globalen Grafikkartenspeicher.
Host
Device
Kernel A
Aufruf
Grid
Block 1
Block 2
Block n
Block 2
Block n
Kernel B
Grid
Aufruf
Block 1
= Thread
Abbildung 5.8: Mehrere Threads sind in Blöcken zusammengefasst, die wiederrum in einem
Grid zusammengefasst werden.
100
5.2 Rsm3D Modul
Um Funktionen auf dem Device laufen zu lassen, erweitert CUDA die Standardbefehle
der Programmiersprache C, um einige Konstrukte die vom CUDA Compiler übersetzt werden können. Dateien in denen diese Spracherweiterungen verwendet werden, enden dabei
nicht wie gewöhlich auf die Endung .c, sondern auf .cu. Beim Übersetzen dieser Dateien
durch den CUDA Compiler, muss noch ein zusätzlicher Compiler mit angegeben werden.
Der CUDA Compiler übersetzt dabei den Code der auf dem Device ausgeführt wird, der
zusätzliche Compiler den Code der auf dem Host ausgeführt wird.
Um zu definieren welche Funktionen innerhalb des Codes auf dem Device und welche
auf dem Host ausgeführt werden, stehen folgende Funktionskennzeichnungen zu Verfügung:
• __device__ legt fest, dass eine Funktion auf dem Device ausgeführt wird und nur
von dort aus aufgerufen werden kann.
• __global__ bezeichnet eine Funktion, die auf dem Device ausgeführt wird, aber
vom Host aufgerufen wird.
• __host__ bezeichnet eine Funktion, die ausschließlich auf dem Host ausgeführt
wird.
Beim Aufruf einer mit __ global__ gekennzeichneten Funktion, muss mit angegeben
werden, in wievielen Threads und Blöcken die Funktion parallel ablaufen soll. Dafür werden zwei Datenstrukturen vom Typ dim3 zwischen Funktionsname und den zu übergebenden Parametern angegeben. Diese Datentypen bestehen jeweils aus drei Integer Varaiablen und legen die Größe und Dimension des Grids und der darin enthaltenen Blöcke
fest, wodurch sich die Anzahl der auszuführenden Threads ergibt. Damit die Grafikkarte
die aufgerufene Funktion mit hoher Performance parallel ausführen kann, sollte die Größe eines Blocks zwischen 192 und 256 liegen [5]. Alle Funktionen auf dem Device laufen dabei asynchron ab. Nach dem Aufruf einer Funktion kann deswegen mit dem Befehl
cudaThreadSynchronize gewartet werden, bis alle Threads ausgeführt worden sind.
Innerhalb der aufgerufenen Funktion kann die Thread- und Block-Nummer des jeweiligen Threads durch die Built-in Variablen blockIdx und threadIdx abgefragt werden.
Ausserdem stehen durch die Variablen gridDim und blockDim die Dimension und Größe des Grids und des Blocks zur Verfügung. Eine Beispielaufruf einer Funktion auf dem
Device ist in Listing 5.1 zu sehen. Weitere Angaben zu CUDA befinden sich im Anhang C.4
und in [25].
101
5 Implementierung
1
#define BLOCK_SIZE 16
2
3
__global__ void func(int* pointer){
4
int currentBlockNumber = blockIdx.x + blockIdx.x * blockIdx.y;
int currentThreadNumber = threadIdx.x + threadIdx.x * threadIdx.y;
5
6
7
};
8
9
__host__ void main(){
10
dim3 dimBlock(BLOCK_SIZE, BLOCK_SIZE, 1);
dim3 dimGrid(5, 5, 1);
11
12
13
func<<< dimGrid, dimBlock >>>(0);
14
15
cudaThreadSynchronize();
16
17
};
Listing 5.1: Die Funktion func wird 6400 mal parallel auf der Grafikkarte ausgeführt und
danach gewartet bis alle Threads durchgelaufen sind.
Parallelisierung der verwendeten Algorithmen
Wie bereits beschrieben, besteht der komplette Ablauf der Kreisfindung aus dem Erstellen und Füllen des Parameterraumes zum Finden der Mittelpunkte, dem Detektieren von
Maxima in diesem Parameterraum und dem Finden der dazugehörigen Kreisradien.
Um diese drei Schritte auf der Grafikkarte auszuführen, werden zunächst alle Röntgenbilder in den Speicher der Grafikkarte kopiert. Die Bilddaten aller Bilder einer Serie liegen
dabei in einem einzigen Short Array vor. Da häufig eine Indexposition dieses Arrays in eine
zweidimensionale Pixelposition und umgekehrt berechnet werden muss, stehen die beiden
Methoden gpu_indexToPosition und gpu_positionToIndex zur Verfügung.
Um den Kreismittelpunkt zu finden, wird zunächst Speicherplatz für den Parameterraum
auf der Grafikkarte reserviert. Der Parameterraum besteht dabei aus einem Integer Array,
das der selben Länge entspricht, wie das übertragene Array mit den Bilddaten. Damit steht
jedem Bild ein Parameterraum der selben Größe zur Verfügung. Nachdem der reservierte
Speicherbereich des Parameterraumes auf der Grafikkarte mit null initalisiert wurde, wird
die Devicefunktion zum Füllen des Parameterraumes aufgerufen. Sie wird dabei in so vielen
Threads ausgeführt, wie es Bildpunkte in allen Bildern der Röntgenserie gibt. Jeder Thread
führt dabei das identische Programm, nur auf unterschiedlichen Pixeln, aus. Der aktuelle
Index des Pixels in dem Bildarray im Speicher der Grafikkarte, lässt sich durch den aktuellen
Thread- und Blockindex berechnen.
Nun wird wieder für jedes Pixel berechnet, ob es ein Kantenpixel ist und gegebenenfalls
102
5.2 Rsm3D Modul
der Gradient des Kantenpixels verfolgt und die entsprechende Parameterraumzelle inkrementiert. Bei dem Inkrementierungsschritt muss darauf geachtet werden, dass dieser Atomar abläuft, da mehrere Threads auf dem selben Speicherbereich arbeiten. Es könnte sonst
passieren, dass zwei Threads nacheinander die zu inkrementierende Speicherzelle auslesen, beide den Inhalt erhöhen und beide das Ergebnis der Berechnung daraufhin wieder
zurück an die gleiche Speicherposition schreiben. Damit wäre die Zelle nur einmal anstatt
zweimal inkrementiert worden. Die CUDA API stellt hierzu die Funktion atomicInc zur
Verfügung. Leider stehen die atomaren Funktionen der API nur auf bestimmten Devices zur
Verfügung (Details im Anhang C.4).
Die Ausführung des Füllen des Parameterraumes findet sehr schnell statt, da für jedes
Pixel ein eigener Thread gestartet wird. Ist der Parameterraum gefüllt, kann dieser in kleinere Teilbereiche aufgeteilt werden, die in der Höhe und Breite dem minimalen Abstand
zweier Maxima entsprechen. Dabei muss darauf geachtet werden, dass der Parameterraum
auf der Grafikkarte eigentlich aus mehreren Parameterräumen für jedes Bild besteht. Um lokale Maxima zu finden, wird zunächst wieder Speicherplatz auf der Grafikkarte reserviert,
um darin die Positionen der Maxima in den Teilbildern zu speichern. Es werden soviele
Threads gestartet wie Teilbereiche vorliegen. Jeder Thread sucht dabei in seinem eingeschränkten Suchbereich nach der am höchsten gewertesten Zelle und speichert diese in die
Datenstruktur im Grafikkartenspeicher. Der Suchbereich eines Threads ergibt sich dabei
wieder aus seinem Thread- und seinem Blockindex.
Nachdem die Datenstruktur auf der Grafikkarte mit den Positionen der lokalen Maxima
gefüllt wurde, wird Speicher für eine weitere Datenstruktur auf der Grafikkarte angelegt,
in der die Position der globalen Maxima aller Röntgenbilder der Serie gespeichert werden.
Dort wird später auch der Radius zu den jeweiligen Mittelpunkten eingetragen. Es werden nun soviele Threads gestartet wie Röntgenbilder in der Serie vorliegen. Jeder Thread
iteriert über den Teilberich der Datenstruktur, in der die Positionen der lokalen Maxima
vorliegen und sucht die am höchsten gewertesten Zellen heraus. Wie viele Maxima dabei
gesucht werden, hängt davon ab, wieviele projizierte Kugeln gefunden werden sollen, was
vom Benutzer eingestellt werden kann. Die gefundenen, globalen Maxima werden in die
vorhandene Datenstruktur auf der Grafikkarte übertragen.
Nachdem nun alle Mittelpunkte auf der Grafikkarte in einer entsprechenden Datenstruktur vorliegen, muss nur noch für jeden Mittelpunkt der entsprechende Radius gefunden werden. Jede Radiusberechnung für einen Mittelpunkt läuft dabei in einem eigenen Thread ab.
Das Ergebnis der Berechnung wird in die entsprechende Datenstruktur auf der Grafikkarte
103
5 Implementierung
gespeichert. Diese ist nun mit allen Kreismittelpunkten und den dazugehörigen Radien gefüllt. Es wird daraufhin aus dem Grafikkartenspeicher in den Arbeitsspeicher des Rechners
kopiert und kann dort an die Ellipsenfindung weitergegeben werden. Diese muss nun nicht
mehr auf dem gesamnten Bildbereich arbeiten, sondern nur in den kleinen Teilbildern in
denen die Kreise gefunden wurden.
104
6 Test des Moduls und
Performancemessung
Um das Verfahren zum Finden von projizierten Kugeln in Röntgenbildern in Form des entwickelten Moduls zu bewerten, wurden mehrere Testläufe mit verschiedenen Eingabedaten
vorgenommen. Ziel der Tests war es die Genauigkeit des Verfahrens zu ermitteln, da nur
durch eine präzise Berechnung der Ellipsenparameter eine gute Rekonstruktion des geröntgten Objektes erstellt werden kann. Die Überprüfung der Exaktheit des Verfahrens wurde dabei optisch vorgenommen, indem die gefundenen Ellipsen im Bild visualisiert wurden und
die Deckungsgenauigkeit der berechneten und der projizierten Ellipse verglichen wurde.
Darüber hinaus wurden auch synthetisch erstellte Bilder getestet, in denen die Ellipsenparameter bereits bekannt waren und so die Ergebnisse genau überprüft werden konnten.
Als Testumgebung wurde jedesmal die Rekonstruktionssoftware Rsm3D verwendet. Neben
dem Test der Ellipsenparameterberechnung, wurden auch die Laufzeiten des softwarebasierten Verfahrens sowie des grafikkartenbasierten Verfahrens miteinander verglichen.
Insgesamt wurden drei Serien mit unterschiedlichen Bildgrößen getestet. Die erste Serie
bestand dabei aus künstlich erzeugten, synthetischen Bildern. Die anderen beiden enthielten
reale Röntgenbilder von einem Zahn und einer Bombenatrappe. Jede Serie benötigte bei den
Tests unterschiedliche Parametereinstellungen, um die Erkennungsrate der projizierten Referenzkugeln zu steigern. Die genau verwendeten Werte der Parameter sind im Anhang C.5
aufgelistet.
Für die Parallelisierung des Verfahrens wurde das CUDA Toolkit in der Version 1.0 verwendet. Die verwendete Grafikkarte unterstützt dabei die so genannte CUDA Compute Capability 1.0 [5]. In dieser Version stehen leider keine atomaren Funktionen zur Verfügung,
was zu Fehlern beim Füllen von Parameterräumen führen kann (siehe Abschnitt 5.2.2).
Jedoch wurden in den durchgeführten Tests trotzdem Kreise auf der GPU zuverlässig gefunden, was jedoch nicht ausschließt, dass Kollisionen von Threads beim Inkrementieren
105
der Parameterraumzellen vorkamen.
Insgesamt erwies sich das CUDA Toolkit als ziemlich fehleranfällig. Häufig stürzte die
Ausführung der Kreisfindung auf der Grafikkarte in der Form ab, dass nur durch einen
Neustart des Systems weitergearbeitet werden konnte. Auf der CUDA Webseite sowie im
Developer Forum von NVIDIA sind viele Bugreports von CUDA Anwendern zu finden,
so dass davon ausgegangen werden muss, dass das gesamte Toolkit noch sehr instabil läuft.
Dies liegt wahrscheinlich zum größten Teil daran, dass CUDA noch ein sehr junges Produkt
ist und die Version 1.0 erst vor einem halben Jahr (Juni 2007) veröffentlicht wurde. Es ist
zu hoffen, dass sich die Stabilität des CUDA Toolkits mit den folgenden Releases erhöhen
wird. Vor allem wäre es wünschenswert, dass sich die Dokumentation verbessert. So werden
zum Beispiel in den mitgelieferten Demoanwendungen CUDA Funktionen verwendet, die
sich nicht in der offiziellen Dokumentation befinden.
6.1 Versuchsaufbau und Testumgebung
Der Versuchsaufbau war bei allen folgenden Tests gleich. Als erstes wurde eine Röntgenbildserie in die Software importiert, danach wurden die importierten Bilder durch einen
3×3 Gauß Filter geglättet und in den geglätteten Röntgenbildern nach der eingestellten Anzahl von Ellipsen gesucht. Innerhalb des Ellipsenfindungsmoduls wurde zunächst softwareoder grafikkartenbasiert nach Kreisen gesucht und daraufhin in den gefundenen Bereichen
die Ellipsenparameter berechnet. Die gefundenen Ellipsen wurden mit ihrem Rand und den
beiden Achsen für eine optische Kontrolle des Verfahrens in das jeweilige Röntenbild eingezeichnet (siehe Abbildung 6.1).
Als Testsystem wurde der Rechner XPS 710 der Firma Dell mit 2,00 GB Arbeitsspeicher
verwendet. Dieser ist mit einem Intel Core2 Quad Prozessor ausgestattet, der mit einer
Taktrate von 2,39 GHz läuft. Als Grafikkarte wurde das Modell GeForce 8800 GTX mit
einem 768 MB grossen Speicher der Firma NVIDIA werwendet. Die Tests liefen alle unter
dem Microsoft Betriebssystem Windows XP Professional mit installiertem Service Pack 2.
6.2 Test mit synthetischen Bildern
Um die Genauigkeit des entwickelten Verfahrens zum Finden der projizierten Ellipsen bestimmen zu können, wurde eine Testserie mit synthetisch erzeugten Ellipsen erstellt. Die
106
6.2 Test mit synthetischen Bildern
Abbildung 6.1: Verwendeter Versuchsaufbau. Zuerst wird eine Röntgenbildserie importiert
und geglättet und daraufhin die projizierten Kugeln gesucht. Das Ergebnis der Suche wird
in die Röntgenbilder eingezeichnet.
107
verwendeten Bilder wurden dabei von einer Anwendung erzeugt, in der man die genauen
Parameter der Ellipse angeben kann. Die Hauptachse aller erzeugten Ellipsen zeigt dabei
auf den Bildmittelpunkt.
Insgesamt wurden drei Bilder mit jeweils drei Ellipsen generiert, so dass das entwickelte Modul neun Ellipsen mit allen fünf Parametern bestimmen musste. Dabei wurden auch
Ellipsen mit stark unterschiedlichen Achsenlängen erstellt, wie sie in dieser Form in realen Röntgendaten nicht vorkommen. Durch die stark ausgeprägte Ellipsenform konnten
nur sehr schwer Kreise in den vorliegenden Daten ermittelt werden. Mit den passenden
Algorithmenparametern wurden jedoch alle Ellipsen zuverlässig gefunden (siehe Abbildung 6.2). Die genau verwendeten Parameter der erzeugten Ellipsen und die berechneten
Ergebnisse sind in Tabelle 6.1 aufgeführt. Bis auf eine Ausnahme wurden alle Ellipsenparameter mit einer Genauigkeit von ±1 Pixel gefunden.
Abbildung 6.2: Orginalbilder (oben) und gefundene Ellipsen (unten) in synthetisch erzeugten Bildern.
Die drei erzeugten Bilder dieser Serie hatten alle eine Größe von 500 × 500 Pixeln. Die
Kreisfindung in den drei Bildern dauerte auf der CPU zirka 440 ms. Die gleiche Berechnung
mittels des grafikkartenbasierten Verfahrens nahm insgesamt 250 ms in Anspruch. Innerhalb
108
6.3 Test mit Röntgenbildern
Bild
1
1
1
2
2
2
3
3
3
x
100
400
267
258
382
267
76
125
350
erzeugte Ellipsen
y
λ1
λ2
100 60
30
250 57
25
422 36
24
422 43
39
253 80
20
50
32
15
68
43
20
251 60
59
350 50
40
α
0,79
0,00
1,47
1,52
0,00
-1,49
0,81
0,00
0,79
x
100
400
267
258
385
267
76
125
350
gefundende Ellipsen
y
λ1
λ2
100 61
31
250 57
25
422 36
24
422 43
39
253 77
20
50
32
15
68
43
21
251 60
59
350 51
41
α
0,79
0,00
1,47
1,52
0,02
-1,49
0,81
0,00
0,79
Tabelle 6.1: Generierte und berechnete Ellipsenparameter der synthetischen Bilddaten.
dieses Zeitraumes wurde jedoch nur zirka 160 ms auf der GPU gerechnet. Die restliche Zeit
wurde benötigt, um Bilder und Datenstrukturen in den Grafikkartenspeicher zu schreiben
und davon zu lesen. Zum Finden der neun Ellipsen in den Teilbildern, wurden ungefähr
1490 ms benötigt.
Neben den synthetischen Daten, wurde das implementierte Modul auch durch zwei Serien
mit realen Röntgendaten getestet. In allen Bildern waren dabei jeweils drei Referenzkugeln
abgebildet. Bei den beiden Testserien wurden, mit den richtig gewählten Parametereinstellungen, sämtliche Ellipsen zuverlässig erkannt. Der visualisierte Ellipsenrand des berechneten Ergebnis, lag bei fast allen Ellipsen deckungsgleich auf dem Rand der projizierten
Ellipsen (siehe Abbildung 6.3).
Bei dem Laufzeitenvergleich zwischen dem GPU- und der CPU-basierendem Verfahren
konnte die Annahme bestätigt werden, dass durch eine Parallelisierung des Kreisfindungsalgorithmus, das implementierte Verfahren erheblich schneller abläuft. So konnten die GPUbasierten Berechnungen, je nach Bildanzahl, Bildgröße und gewählten Parametereinstellungen, bei den beiden Testreihen um den Faktor 8 bis 22 beschleunigt werden. Hierbei wurden
allerdings nur die Ausführung der Kreisfindung gemessen. Um die gesamte Laufzeit zum
Finden der projizierten Referenzkugeln zu erhalten, muss noch die Ellipsenfindung addiert
werden.
109
Abbildung 6.3: Beispiele von gefundenen Projektionen der Referenzkugeln. Der Rahmen
um die Kugeln beschreibt das Teilbild, dass durch die Kreisfindung entstanden ist und in
dem nach der Ellipse gesucht wird.
Bei den durchgeführten Tests konnte gut die Parallelisierung des Verfahrens in den Laufzeiten nachverfolgt werden. Während auf der CPU die Laufzeiten mit zunehmender Anzahl
der zu berechnenden Bilder linear anstiegen, waren die Ausführungszeiten auf der GPU
auch mit vielen Bildern nahezu konstant (siehe Abbildung 6.4 und 6.5). Um das Verfahren
auf einer hohen Bildanzahl zu testen, wurden die gleichen Röntgenbilder teilweise mehrmals zu einer Serie hinzugefügt. Eine Serie enthält dabei Röntgenbilder eines Zahnes mit
der Bildgröße von 664×872 Pixeln, in der anderen befinden sich Bilder einer Bombenatrappe mit einer Bildgröße von 2600 × 2100 Bildern. Die maximale Anzahl von Bildern in einer
Serie war auf der GPU durch die maximale Anzahl parallel laufender Threads beschränkt.
Aus diesem Grund, konnten auf der GPU maximal 28 Bilder bei der Zahnserie und aufgrund
der hohen Auflösung, nur drei Bilder bei der Bombenserie gleichzeitig berechnet werden.
Die genau gemessenen Laufzeitwerte für die Erkennung der Ellipsen in den beiden Serien
sind in Tabelle 6.2 aufgeführt.
Das detektieren von Kreisen auf der Grafikkarte kann in die Teilbereiche Füllen des Parameterraumes, Finden der lokalen Maxima, Finden der globalen Maxima und Finden der
Radien unterteilt werden. Bei den Tests wurde dabei ermittelt wie viel Rechenzeit die einzelnen Teile dabei innerhalb der Laufzeit der Kreisfindung benötigen. Das Füllen des Parameterraumes benötigte in etwa 15%, das Finden der lokalen Maximas 2%, das Finden der
globalen Maximas 50% und die Radiusfindung 25% der benötigten Rechenzeit. Dazu kam
natürlich noch das Kopieren der Bilddaten in den Grafikkartenspeicher sowie das Kopieren
der gefundenen Strukturen vom Grafikkarten- in den Hauptspeicher des Rechners.
110
Sekunden
Zahnserie:
20
Bildgröße
Anzahl Kugeln
664 x 872
3
Kreisfindung CPU
10
Ellipsenfindung
Kreisfindung GPU
0
8
12
16
20
24
28
32
Bilder
Abbildung 6.4: Laufzeiten der Zahnserie.
Sekunden
Bombenserie:
20
Bildgröße
Anzahl Kugeln
2600 x 2100
3
Kreisfindung CPU
10
Kreisfindung GPU
Ellipsenfindung
3
4
0
1
2
Bilder
Abbildung 6.5: Laufzeiten der Bombenserie.
111
Kreise
GPU Speed Up
Ellipsen
Anzahl Bilder
CPU
Zahnserie: 8
12
16
20
24
28
32
5.406
6.016
8.015
10.062
12.859
14.813
16.907
485
469
484
562
560
750
-
11,14
12,83
16,56
17,90
22,96
19,75
-
1.656
2.500
3.297
4.074
5.032
5.734
6.656
Bombenserie: 1
2
3
4
6.344
12.125
18.156
23.985
766
843
891
-
8,28
14,38
20,37
-
188
391
797
1.000
Tabelle 6.2: Gemessene Laufzeiten in Millisekunden.
112
7 Zusammenfassung und
Ausblick
Im Rahmen dieser Arbeit wurden mehrere Verfahren zum Finden von algebraisch beschreibbaren Strukturen vorgestellt und teilweise in einem Prototypen implementiert. Durch verschiedene Tests diverser Algorithmen und dem Ausprobieren unterschiedlicher Ideen, entstand ein Verfahren um projizierte Referenzkugeln in Röntgenbildern zu finden, bei denen
der Fokuspunkt in der Bildmitte liegt. Dieses entwickelte Verfahren wurde in einem Modul für die Rekonstruktionssoftware Rsm3D umgesetzt. Das Modul nimmt dabei eine Serie
von Röntgenbildern entgegen, berechnet die algebraische Beschreibung beziehungsweise
die Parameter der projizierten Referenzkugeln und gibt diese an ein Nachfolgemodul weiter. Das Verfahren sucht dabei zuerst nach Kreisen in den Röntgenbildern, beschneidet die
Bilder um die gefundenen Kreise und sucht daraufhin in den wesentlich kleineren Teilbildern nach Ellipsen. Da die Kreisfindung bei hoch aufgelösten Röntgenbildern mitunter sehr
lange dauert, kann die Kreisfindung auf der Grafikkarte berechnet werden. Dabei wird die
Fähigkeit moderner GPUs zum parallelen Rechnen verwendet. Es wurde gezeigt, dass durch
die Parallelisierung des Kreisfindungsalgorithmus dessen Laufzeit ungefähr um den Faktor
10 bis 20 beschleunigt werden kann.
Die Ellipsenfindung läuft in den getesteten Röntgenbildern zuverlässig ab. Es werden
hierbei alle projizierten Referenzkugeln, unter Voraussetzung der korrekt eingestellten Algorithmenparameter, gefunden. Dadurch ist es möglich, die ursprüngliche Position der Kugeln im Raum zu bestimmen und somit eine Rekonstruktion des geröntgten Objektes zu
erstellen.
Ansätze für zukünftige Entwicklungen bieten sich vor allem bei der Implementierung des
Verfahrens auf der Grafikkarte. Das zur Zeit realisierte Modul läuft bei der Kreisfindung
auf der Grafikkarte mitunter sehr instabil. Falsche Parametereinstellungen können hier zu
einem kompletten Absturz des Systems führen, der nur durch einen Neustart behoben wer-
113
7 Zusammenfassung und Ausblick
den kann. Vor allem kann es in der derzeitigen Version dazu kommen, das parallel laufende
Threads beim Schreiben in den selben Speicherbereich kollidieren, was an der mangelnden
Unterstützung von atomaren Funktionen seitens der Hardware liegt. Hier sollte über eine
Anschaffung entsprechender Grafikkarten nachgedacht werden. Insgesamt bieten sich bei
der derzeitigen Implementierung des Verfahrens auf der GPU noch viele Ansätze für Verbesserungen. Dabei ist es nicht unbedingt notwendig das Verfahren an sich zu verbessern
oder zu beschleunigen, sondern vor allem die Implementierung der Kreisfindung stabiler zu
machen.
Des weiteren bleibt zu hoffen, dass NVIDIA in absehbarer Zeit neue Releases des CUDA
Tollkits veröffentlicht, da sich in der derzeitigen Version noch zahlreichen Bugs und Fehler
befinden. Vor allem wäre eine umfassendere Dokumentation des SDKs wünschenswert.
Abschließend bleibt zu sagen, dass der Einsatz moderner Grafikhardware einen erheblichen Geschwindigkeitsvorteil gegenüber Berechnungen auf der CPU liefern kann. Gerade
beim Detektieren von algebraisch beschreibbaren Strukturen bringt die Parallelisierung von
Algorithmen eine enorme Beschleunigung. Um Probleme auf modernen GPUs berechnen
zu lassen, wird allerdings die Hilfe von gut strukturierten SDKs benötigt, die Funktionen
der Grafikkarte kapseln und kompfortabel zur Verfügung stellen. Aus diesem Grund, geht
NVIDIA mit der Entwicklung von CUDA einen Schritt in die richtige Richtung. Es bleibt
zu hoffen, dass dessen Entwicklung weiter vorangetrieben wird, so dass es in Zukunft noch
einfacher sein wird, rechenintensive Probleme parallel auf der Grafikkarte zu lösen.
114
1.1
Grafische Oberfläche der Software Rsm3D. . . . . . . . . . . . . . . . . .
4
2.1
Erkannte Strukturen in einem Bild. . . . . . . . . . . . . . . . . . . . . . .
8
2.2
Verschiedene Geradengleichungen. . . . . . . . . . . . . . . . . . . . . . .
10
2.3
Kreisrand mit Mittelpunkt und Radius. . . . . . . . . . . . . . . . . . . . .
12
2.4
Eine Ellipse in impliziter Form und ihre Achsen. . . . . . . . . . . . . . .
12
2.5
Stark verrauschte Bilder. . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
2.6
Bildraster der Größe w × h im Bildkoordinatensystem. . . . . . . . . . . .
16
. . . . . . . . . . . . . . . . . . . . . . . .
18
2.8
Verschiedene Helligkeitsstufen eines Bildes. . . . . . . . . . . . . . . . . .
19
2.9
Anwenden einer Filtermatrix . . . . . . . . . . . . . . . . . . . . . . . . .
21
2.10 Extremwerte in verrauschten Bildern. . . . . . . . . . . . . . . . . . . . .
23
2.11 3D-Plot von Filtermatritzen . . . . . . . . . . . . . . . . . . . . . . . . . .
24
2.12 Bild vor und nach einer Glättung durch den 5x5 Gaußfilter. . . . . . . . . .
25
2.13 Verwischung einer Kante durch einen Gaußfilter. . . . . . . . . . . . . . .
26
2.14 Beispiel eines 3x3 Medianfilters. . . . . . . . . . . . . . . . . . . . . . . .
26
2.15 Bildfunktion und erste Ableitung. . . . . . . . . . . . . . . . . . . . . . .
27
2.16 Anwendung eines Sobel-Operators. . . . . . . . . . . . . . . . . . . . . .
30
2.17 Kantenpixel mit Gradient und lokaler Kantenrichtung.
. . . . . . . . . . .
31
2.18 Orginalbild und markierte Regionen. . . . . . . . . . . . . . . . . . . . . .
32
2.19 Unterschiedliche Beschreibung von Regionen. . . . . . . . . . . . . . . . .
33
3.1
Ablauf einer Hough Transformation für Geraden . . . . . . . . . . . . . .
36
3.2
Parameterraum und die dazugehörigen Geraden im Bildraum. . . . . . . . .
38
3.3
Wertebereich für den Abstand d einer Geraden. . . . . . . . . . . . . . . .
39
3.4
Eine Gerade in der Hesseschen Normalform befindet sich aufgrund ihrer
2.7
Orginalbild und Bildfunktion.
Parameter in einem Polarkoordinatensystem. . . . . . . . . . . . . . . . . .
40
115
3.5
Auflösung für Winkel und Länge im Bildkoordinatensystem. . . . . . . . .
41
3.6
Transformation zwischen Bild- und Parameterraum. . . . . . . . . . . . . .
43
3.7
Geradenschar über den gesamten und den eingeschränkten Wertebereich
des Winkels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
44
3.8
Orginalbild mit Parameterraum nach einer HT und nach einer Fast HT. . . .
45
3.9
Minimaler und maximaler Radius in einem digitalen Bild. . . . . . . . . .
47
3.10 Hough Transformation für Kreise . . . . . . . . . . . . . . . . . . . . . . .
49
3.11 Die Gradienten der Kreisrandes zeigen auf den Kreismittelpunkt. . . . . . .
50
3.12 Ein Bild der Größe w × h mit dem dazugehörige Parameterraum.
. . . . .
51
3.13 Ellipsen deren Mittelpunkt auf der zu findenen Ellipse liegen. . . . . . . . .
53
3.14 Diameter Bisection Methode. . . . . . . . . . . . . . . . . . . . . . . . . .
56
3.15 Die Gerade durch den Schnittpunkt der Tangenten von zwei Kantenpixeln
und durch deren Mittelpunkt, passiert den Ellipsenmittelpunkt. . . . . . . .
57
3.16 Ein Randpunkt einer Struktur relativ zu einem Bezugspunkt. . . . . . . . .
60
3.17 Zwei Gradienten der selben Gradientenklassen inkrementieren beide den
Bezugspunkt der Struktur.
. . . . . . . . . . . . . . . . . . . . . . . . . .
62
3.18 Radon Transformation für Geraden. . . . . . . . . . . . . . . . . . . . . .
63
4.1
Röntgenbild eines künstlichen Schädels und schematische Darstellung eines Röntgenvorganges. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
66
4.2
Ebene im dreidimensionalen Raum. . . . . . . . . . . . . . . . . . . . . .
67
4.3
Parallelprojektion von Punkten. . . . . . . . . . . . . . . . . . . . . . . . .
68
4.4
Zentralprojektion von Punkten. . . . . . . . . . . . . . . . . . . . . . . . .
69
4.5
Kugelschatten in einem Röntgenbild. . . . . . . . . . . . . . . . . . . . . .
70
4.6
Der Schnitt zwischen dem Kegel und der Ebene beschreibt eine Ellipse. . .
72
4.7
Röntgenbilder im Raum angeordnet und rekonstruierter Schädel. . . . . . .
74
4.8
Eindimensionaler Helligkeitsverlauf entlang einer Achse. . . . . . . . . . .
76
4.9
Kantenpixel in einem Röntgenbild. . . . . . . . . . . . . . . . . . . . . . .
77
4.10 Ablauf der Ellipsenfindung in Röntgenbildern. . . . . . . . . . . . . . . . .
79
5.1
Grafische Oberfläche des Prototypen. . . . . . . . . . . . . . . . . . . . . .
82
5.2
Ablauf des Erkennunsprozesses im Java Prototypen. . . . . . . . . . . . . .
84
5.3
Parameteraum visualisierung. . . . . . . . . . . . . . . . . . . . . . . . . .
87
5.4
Transformation von Kantenpunkten. . . . . . . . . . . . . . . . . . . . . .
90
116
5.5
Ablauf der Ellipsenfindung. . . . . . . . . . . . . . . . . . . . . . . . . . .
93
5.6
Vergleich der Rechenleistung von CPU und GPU. . . . . . . . . . . . . . .
97
5.7
Paralleles suchen lokaler Maxima . . . . . . . . . . . . . . . . . . . . . .
99
5.8
Mehrere Threads sind in Blöcken zusammengefasst, die wiederrum in einem Grid zusammengefasst werden. . . . . . . . . . . . . . . . . . . . . . 100
6.1
Verwendeter Versuchsaufbau . . . . . . . . . . . . . . . . . . . . . . . . . 107
6.2
Ergebnis der Ellipsenfindung. . . . . . . . . . . . . . . . . . . . . . . . . . 108
6.3
Beispiele von gefundenen Referenzkugeln. . . . . . . . . . . . . . . . . . . 110
6.4
Laufzeiten der Zahnserie. . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
6.5
Laufzeiten der Bombenserie. . . . . . . . . . . . . . . . . . . . . . . . . . 111
117
118
Literaturverzeichnis
Quellen
[1] Tobias Albert: Erkennung und Vermessung von Referenzkugeln bei der 3DRekonstruktion aus wenigen Röntgenbildern. 2005.
[2] D. H. Ballard: Generalizing the Hough Transform to detect Arbitrary Shapes. In:
Pattern Recognition, Seiten 111–122, 1981.
[3] Jürgen Beyerer und Fernando Puente León: Die Radontransformation in der digitalen
Bildverarbeitung. In: Automatisierungstechnik 50. Oldenburg Verlag, 2002.
[4] Dan Brüllmann: Entwicklung einer Software zur a posteriori Berechnung der Projektionsgeometrie aus digitalen Röntgenbildern. 2005.
[5] NVIDIA Corporation: NVIDIA CUDA - Compute Unified Device Architecture. 2007.
[6] E. R. Davies: Machine Vision. Elsevier, 2005.
[7] Richard O. Duda und Peter E. Hart: Use of the Hough transformation to detect lines
and curves in pictures. In: Communications of the ACM, Band 15, Seiten 11–15, New
York, NY, USA, 1972. ACM Press.
[8] Dianne Hansford Gerald Farin: Lineare Algebra: Ein geometrischer Zugang. Springer
Verlag, 2002.
[9] M. van Ginkel, C.L. Luengo Hendriks, und L.J. van Vliet: A short introduction to the
Radon and Hough transforms and how they relate to each other. In: Quantitative
Imaging Group Technical Report Series, 2004.
[10] Peter Haberäcker: Digitale Bildverarbeitung. Carl Hanser Verlag, 1989.
119
Literaturverzeichnis
[11] Paul V. C. Hough und Ann Arbor: Method and Means for Recognizing Complex Patterns. 1962.
[12] H.Tsukune und K. Goto: Extracting elliptical figures from an edge vector field. In:
Proc. IEEE Conf. on Computer Vision and Pattern Recognition, Seiten 138–141, 1983.
[13] Bernd Jähne: Digitale Bildverarbeitung. Springer Verlag, 1989.
[14] C. Kimme, D.H. Ballard, und J. Sklansky: Finding Circles by an Array of Accumulators. In: Communications of the ACM, Band 18, Seiten 120–122, February 1975.
[15] E. Mortensen, B. Morse, W. Barrett, und J. Udupa: Adaptive boundary detection
using ‘live-wire’ two-dimensionaldynamic programming. In: Computers in Cardiology 1992. Proceedings., Seiten 635–638, 1992.
[16] Frank O’Gorman und M. B. Clowes: Finding Picture Edges Through Collinearity of
Feature Points. In: IEEE Trans. Computers, Band 25, Seiten 449–456, 1976.
[17] Johann Radon: Über die Bestimmung von Funktionen durch ihre Integralwerte längs
gewisser Mannigfaltigkeiten. In: Berichte Sächsische Akademie der Wissenschaften,
Leipzig, Mathematisch-Physikalische Klasse, Seite 262–277, 1917.
[18] Ralf Schulze, Dan Brüllmann, Ulrich Heil, Oliver Weinheimer, Daniel Gross, Elmar
Schoemer, Eric Thomas, und Ulrich Schwanecke: Accurate registration of random
radiographic projections based on three spherical references for the purpose of fewview 3D reconstruction. 2007.
[19] Ralf Schulze, Dan Brüllmann, Felix Röder, und Bernd D’Hoedt: Determination of projection geometry from quantitative assessment of the distortion of spherical references
in single - view projection radiography. In: Med Phys, Band 31, Seiten 2849–2854,
2004.
[20] Eric Thomas: Modulares Softwareframework zur 3D-Rekonsruktion aus 2DRöntgenbildern. 2006.
[21] S. Tsuji und F. Matsumoto: Detection of ellipses by a modified Hough transform. In:
IEEE Trans. On Computers vol. 27, Seiten 777–781, 1978.
[22] Mark James Burge Wilhelm Burger: Digitale Bildverarbeitung.
2005.
120
Springer Verlag,
[23] Tao Wu, Juemin Zhangb, Richard Moorea, Elizabeth Raffertya, Daniel Kopansa, Waleed Meleisb, und David Kaelib: Digital tomosynthesis mammography using a parallel
maximum likelihood reconstruction method. In: SPIE Mediacal Imaing, Seiten 1–11,
2004.
[24] H. Yuen, J. Illingworth, und J. Kittler: Ellipse Detection Using the Hough Transform.
In: AVC88: Proc. Fourth Alvey Vision Conference, 1988.
Online Quellen
[25] NVIDIA Corporation: NVIDIA CUDA.
http://developer.nvidia.com/object/cuda.html, November 2007.
[26] Eclipse Foundation: Eclipse.
http://www.eclipse.org/, November 2007.
[27] Udo Frese: Echtzeit Bildverarbeitung.
http://www.informatik.unibremen.de/ufrese/teaching/ebv07/indexd.html, November
2007.
[28] Microsoft: Microsoft MSDN.
http://msdn.microsoft.com/, November 2007.
[29] Sun: Java Platform, Standard Edition 6 API Specification.
http://java.sun.com/javase/6/docs/api/, November 2007.
[30] Sun: JavaSE.
http://java.sun.com/javase/, November 2007.
[31] Trolltech: QT – Trolltech.
http://trolltech.com/products/qt, November 2007.
121
122
Anhang A Inhalt der CD
Auf der beiliegenden CD befinden sich unter anderem die Ausarbeitung der Diplomarbeit,
ein Teil der verwendeten Quellen sowie die erstellte Software. Die CD gliedert sich dabei
in folgende Verzeichnisse:
Diplomarbeit: Hier befindet sich die Diplomarbeit als PDF-Datei.
Quellen: In diesem Ordner befinden sich die als Datei erhältlichen Quellen.
Java Prototyp: Dieser Ordner enthält den Java Prototypen als Jar-Archiv sowie dessen
Quellcode. Des weiteren beinhaltet der Ordner die mit JavaDoc erstellte Dokumentation.
Rsm3D Modul: In diesem Verzeichnis befinden sich die Quelldateien des entwickelten
Moduls und eine ausführbare Version der Software Rsm3D. Es sind alle Module
vorhanden die nötig sind, um Röntgenbildserien zu importieren, die Bilder zu glätten
und die Ergebnisse anzuzeigen. Des weiteren befindet sich hier die mit Doxygen
erzeugte Dokumentation des Codes.
Testdaten: Hier befinden sich die drei verwendeten Testserien sowie der zum Testen aufgebaute Modulgraph.
123
A Inhalt der CD
124
Anhang B Java Prototyp
Der Java Prototyp wurde mit der Java SDK in der Version 6.0 entwickelt. Das Jar-Archiv
ist somit auf allen Plattformen mit installiertem JRE 6.0 ausführbar. Es wurden bei der
Entwicklung keine externen Bibliotheken verwendet.
Nach dem Start des Java Prototypen erscheint das Hauptfenster. Auf der rechten Seite
kann nun zunächst der zu verwendende Algorithmus ausgewählt werden. Daraufhin wird
festgelegt, wie das zu untersuchende Bild generiert werden soll. Hier stehen die drei Optionen Draw Lines zum Zeichnen von Linien, Draw Circles zum Zeichnen von Kreisen und
Show Image zum Anzeigen von Bildern zur Verfügung. Werden die Optionen Draw Lines
oder Draw Circles ausgewählt, so kann mit der Maus direkt das entsprechende Grafikprimitiv auf die Bildfläche gezeichnet werden. Beim Auswählen der Option Show Image öffnet
sich ein Dateiauswahldialog, durch den eine Bilddatei ausgewählt und angezeigt werden
kann.
Es besteht die Möglichkeit, über den Button Clear das angezeigte Bild wieder zu löschen.
Der Button Start Recognition wendet den ausgewählten Algorithmus auf das Bild an und
zeichnet die gefundenen Strukturen in das angezeigte Bild ein.
Auf der Konsole werden zudem die entsprechenden Laufzeiten der Erkennung ausgegeben. Dabei werden der Startzeitpunkt der Erkennung, der angewendete Algorithmus, die
Bildgröße, die benötigte Zeit zum Erkennen der Strukturen, die insgesamt benötigte Zeit,
die Anzahl der detektierten Kantenpunkte im Bild und die Anzahl der gefundenen Strukturen ausgegeben. In der Gesamtzeit ist auch das Konvertieren des Bildes in ein Graustufenbild berücksichtigt, wogegen die Zeit die der Erkenner benötigt hat, nur der Zeit zum
Detektieren der Strukturen entspricht.
Nach einem Erkennungsvorgang kann über den Button Show Parameter Space der aktuell aufgebaute Parameterraum visualisiert werden. Bei der Geradenerkennung wird der
Parameterraum über den Winkel und die Länge des Vektors gezeigt, der eine Gerade beschreibt, bei der Kreiserkennung wird der Parameterraum zum schnellen Finden des Kreis-
125
B Java Prototyp
mittelpunktes und bei der Ellipsenfindung der zweidimensionale Parameterraum der ChordTangent Methode visualisiert. Die Helligkeit der angezeigten Punkte im Parameterraum
kann dabei mit den Tasten + und – erhöht und verringert werden.
Damit Strukturen durch die ausgewählten Algorithmen schnell und zuverlässig erkannt
werden, müssen für diese die passenden Parameter eingestellt werden. Jeder Algorithmus
hat dabei unterschiedliche Parameter zur Auswahl, die im Folgenden kurz erläutert werden.
B.1 Schnelle Hough Transformation für Geraden
Die HT für Geraden kann im Java Prototyp unter dem Namen Fast Hough Transformation
for Lines ausgewählt werden. Bei diesem Algorithmus können folgende Parameter eingestellt werden:
Sobel Treshhold: Der eingestellte Wert legt fest, ab welcher Sobelintensität ein Pixel als
Kantenpixel zählt.
Nr. of Lines: Über diesen Parameter lässt sich die Anzahl der zu findenden Geraden einstellen.
Hough Peak Offset: Dieser Parameter bezeichnet die minimale Distanz von zwei Maxima im Parameterraum. Er dient dazu einen Abstand zu definieren den zwei Maximas
einhalten müssen, um als eigenständige Struktur zu zählen.
B.2 Schnelle Hough Transformation für Kreise
Die HT für Kreise kann im Java Prototyp unter dem Namen Fast Hough Transformation for
Circles ausgewählt werden. Bei diesem Algorithmus können folgende Parameter eingestellt
werden:
Kantenpixel zählt.
Nr. of Circles: Über diesen Parameter lässt sich die Anzahl der zu findenden Kreise einstellen.
Minimum Radius: Dieser Wert legt die untere Schranke des Wertebereiches für den Radius fest.
126
B.3 Schnelle Hough Transformation für Ellipsen
Maximum Radius: Dieser Wert legt die obere Schranke des Wertebereiches für den Radius fest.
B.3 Schnelle Hough Transformation für Ellipsen
Die HT für Ellipsen kann im Java Prototyp unter dem Namen Fast Hough Transformation for Ellipses ausgewählt werden. Bei diesem Algorithmus können folgende Parameter
eingestellt werden:
Kantenpixel zählt.
Nr. of Ellipses: Über diesen Parameter lässt sich die Anzahl der zu findenden Ellipsen
einstellen.
Maximum Major Axis Length: Dieser Wert legt die maximale Länge der Hauptachse
der zu findenden Ellipsen fest.
Monte-Carlo Steps: Hiermit kann die Anzahl der zufällig gewählten Kantenpixelpaare
eingestellt werden.
Image Border Offset: Über diesen Parameter lässt sich einstellen, um wieviel Pixel das
Bild am Rand beschnitten wird. Dies kann bei Röntgenbildern sinnvoll sein, da sich
bei diesen am Bildrand manchmal Patientendaten befinden, die nicht zum eigentlichen Bildinhalt gehören.
Show Parameterspace Lines: Über dieses Flag kann eingestellt werden, ob die gebildeten Geraden durch den Mittelpunkt der Kantenpixel und den Schnittpunkt der
Gradienten ins Bild eingezeichnet werden. Dies hat keine Auswirkung auf den Algorithmus und ist nur für Debugzwecke sinnvoll.
127
B Java Prototyp
128
Anhang C Rsm3D Modul
Das Modul zum Erkennen von projizierten Referenzkugeln ist speziell für die Software
Rsm3D entwickelt und aus diesem Grund nur innerhalb dieses Programms lauffähig. Zur
Entwicklung des Moduls wurde hauptsächlich die Entwicklungsumgebung Visual Studio
C++ 2005 Express Edition der Firma Microsoft verwendet. Als externe Bibliotheken wurden bei der Entwicklung QT der Firma Trolltech [31], das Microsoft Windows Server 2003
Platform SDK [28] sowie das CUDA Toolkit von NVIDIA verwendet [25].
C.1 Dateien
Im Rahmen der Modulentwicklung wurden mehrere Quellcode-Dateien erstellt, die im Folgenden kurz aufgeführt sind:
RsmCircleHt(.cpp|.h): Diese Dateien enthalten die softwarebasierte Kreisfindung, die
auf der CPU abläuft. Die gefundenen Kreise werden in der Klasse RsmCircleObjects
gespeichert und an den Ellipsenfinder weitergegeben.
RsmEllipseHt(.cpp|.h): In dieser Klasse findet die softwarebasierte Ellipsenfindung statt.
Die Klasse nimmt dabei die gefüllte Datenstruktur mit den bereits gefundenen Kreisen entgegen.
RsmCUDA_FindCircles(.cpp|.h): Diese Dateien stellen die Schnittstelle zur grafikkartenbasierten Kreisfindung dar.
RsmCUDA_FindCircles.cu: Hier findet die grafikkartenbasierten Kreisfindung statt. Diese Datei muss mit dem Compiler aus dem CUDA Toolkit übersetzt werden.
RsmFindSpheres(.cpp|.h): Diese Klasse repräsentiert das eigentliche Modul, das in
der Software Rsm3D eingebunden werden kann. Von hier aus wird zuerst die Kreis-
129
C Rsm3D Modul
findung softwareoder grafikkartenbasiert gestartet und daraufhin die Ellipsenfindung aufgerufen.
RsmCircleObjects(.cpp|.h): Diese Klasse repräsentiert die Datenstruktur für gefundene Kreisobjekte im Bild. Die Klasse wird dabei von der Kreisfindung gefüllt und der
Ellipsenfindung übergeben.
RsmEdgePoint(.cpp|.h): Diese Klasse wird verwendet um Kantenpunkte zu speichern,
damit aus diesen später zufällig gewählte Kantenpunktpaare durch ein Monte-Carlo
Verfahren generiert werden können.
RsmRasterPrimitives(.cpp|.h): Diese Klasse ermöglicht es, Grafikprimitive in die Röntgenbilder zu rastern und so die detektierten Ergebnisse zu visualisieren.
C.2 Installationshinweis
Auf der beigelegten CD befindet sich eine lauffähige Version der Software Rsm3D, in der
alle bei den Tests verwendeten Module zur Verfügung stehen. Diese Version lässt sich ausschließlich unter dem Betriebssystem Windows XP Professional ausführen. Im Verzeichnis
Testdaten ist der bei den Tests verwendete Modulgraph gespeichert. Dieser kann über den
Menübefehl File → Load Graph in die Software geladen werden.
Um das Modul selbst zu übersetzen wird empfohlen, die aktuelle Version der kompletten
Software aus dem CVS-Repository der Uni Mainz herunterzuladen, wozu allerdings ein
gültiger Account nötig ist. Eine genaue Anleitung zur Installation der Software befindet
sich in [20].
C.3 Anleitung
Die ausführbare Version von Rsm3D lässt sich direkt von der CD starten. Nachdem das
Programm geladen ist, kann über das Menü der Modulgraph zum Finden der projizierten
Referenzkugeln über den Befehl File → Load Graph geladen werden. Nun sind die Module
Import Dicom Images, Gauss Filter 3x3 axial, Find Spheres und Dicom Viewer in dem
Modulbereich zu sehen.
Durch einen Rechtsklick mit der Maus auf ein Modul erscheint ein Kontextmenü, über
das das jeweilige Modul unter anderem konfiguriert, ausgeführt und zurückgesetzt werden
130
C.3 Anleitung
kann. Wählt man bei dem Modul zum Finden der Referenzkugel den Punkt Configure, lassen sich die genauen Parameter zum Finden der Ellipsen festlegen. Dabei können folgende
Parameter eingestellt werden:
Number of spheres: Dieser Parameter gibt die Anzahl der findenden Referenzkugeln
an.
Sobel Treshhold: Der eingestellte Wert gibt an, ab welcher Sobelintensität ein Pixel als
Kantenpixel zählt.
Minimum Radius: Hierüber wird die untere Schranke des Wertebereiches zum Suchen
des Radius bei der Kreisfindung eingestellt.
Maximum Radius: Hierüber wird die obere Schranke des Wertebereiches zum Suchen
des Radius bei der Kreisfindung eingestellt.
Circle Distance: Dieser Parameter bezeichnet die minimale Distanz von zwei Maxima
im Parameterraum. Er dient dazu einen Abstand zu definieren den zwei Maximas
Maximum Major Axis Length: Der eingestellte Wert gibt an, bis zu welcher Länge
nach den Achsen einer Ellipse gesucht wird.
Use GPU for Recognition: Hiermit wird festgelegt, ob die Kreisfindung softwareoder
grafikkartenbasiert abläuft. Der Wert sollte auf keinen Fall auf true gestellt werden,
wenn keine Grafikkarte zur Verfügung steht, die von CUDA unterstützt wird (siehe
Anhang C.4).
Axis Offset: Über diesen Parameter lässt sich ein Wert festlegen, der auf die berechnete
Achsenlänge addiert wird. Dies ist zum Beispiel sinnvoll, wenn für alle Ellipsen einer
Serie, aufgrund von einem zu unscharfen Kugelrand, zu kurze Achsenlänge detektiert
werden.
Radius Multiplier: Dieser Parameter gibt an, mit welchem Wert der gefundene Radius
der berechneten Kreise multipliziert wird, um daraus das Teilbild zu bestimmen in
dem die Ellipsen gesucht werden. Wird ein Kreis mit den Parametern (cx , cy , r) gefunden, so erstreckt sich das Teilbild durch den Radius Multiplier s von der oberen
linken Ecke (cx − s · r, cy − s · r) bis zur unteren rechten Ecke (cx + s · r, cy + s · r).
131
C Rsm3D Modul
Monte-Carlo Steps: Hiermit kann die Anzahl der zufällig gewählten Kantenpixelpaare eingestellt werden. Je höher der Parameter gesetzt wird, desto genauer wird der
Ellipsenmittelpunkt über die Chord-Tangent Methode gefunden.
Visualize Circle Result: Dieser Parameter legt fest, ob die gefundenen Kreise in das
Röntgenbild gezeichnet werden sollen.
Visualize Ellipse Result: Dieser Parameter legt fest, ob die gefundenen Ellipsen in das
Röntgenbild gezeichnet werden sollen.
Visualize Subimage: Hiermit wird eingestellt, ob der Rand des erstellten Teilbildes im
Röntgenbild angezeigt werden soll.
Sind alle Parameter des Sphere Finder Moduls richtig gesetzt, kann das Modul über den
Menüpunkt Execute des Kontextmenüs ausgeführt werden. Dabei werden alle Module die
unter dem auszuführenden Modul hängen ebenfalls ausgeführt. Es öffnet sich nun ein Dateiauswahldialog des Röntgenbild Importers, über den man die zu untersuchende Röntgenbildserie auswählen kann. Nachdem dies geschehen ist, läuft der Rest des Erkennungsprozesses
automatisch ab. Zunächst werden nach dem Laden der Röntgenbilder diese durch den Gauß
Filter geglättet und das Ergebnis an die Kugelfindung weitergegeben. Daraufhin wird zuerst nach Kreisen und dann nach Ellipsen gesucht. Eine Statusanzeige gibt dabei an, wie
weit der Erkennungsprozess fortgeschritten ist. Details zu den jeweiligen Schritten werden
dabei auch in einem Konsolenfesnter ausgegeben. Ist die Erkennung komplett durchgelaufen, kann im Kontextmenü des Anzeigemoduls der Befehl Open Viewer ausgewählt werden
und das Ergebnis der Ellipsenerkennung angezeigt werden. Dabei werden die Strukturen
visualisiert, die sich im Einstellungsdialog des Erkennermoduls festlegen lassen.
Soll der Erkennungsvorgang wiederholt werden, empfiehlt es sich den Importer und den
Kugelfinder über das Kontextmenü zurückzusetzen, da sonst die alten Ergebnisse in den
Röntgenbildern erhalten bleiben. Ein bereits ausgeführtes Modul ist dabei hellblau, ein zurückgestztes Modul Dunkelblau gekennzeichnet. Soll eine neue Röntgenbildserie geladen
werden, lässt sich diese im Importermodul über den Befehl Choose File realisieren. Eine
detaillierte Anleitung der Software ist in [20] zu finden.
132
C.4 CUDA Compute Capability
C.4 CUDA Compute Capability
Zur Parallelisierung der Algorithmen auf der Grafikkarte wurde das CUDA Toolkit in der
aktuellen Version 1.0 verwendet [25]. In wie weit eine Grafikkarte dabei atomare APIFunktionen unterstützt, gibt die Compute Capability einer Grafikkarte an. Diese ist zur Zeit
aufgeteilt in die beiden Versionen 1.0, die keine atomaren Funktionen unterstützt, und 1.1,
in der atomare Funktionen unterstützt werden. Die bei den Tests eingesetzte Grafikkarte
GeForce 8800 GTX unterstützt nur die Compute Capability 1.0, so dass hier keine atomaren
Funktionen zur Verfügung stehen. Eine genaue Liste der zur Zeit von CUDA unterstützten
Grafikkarten ist in Tabelle C.1 aufgeführt.
Modell
GeForce 8800 Ultra
GeForce 8800 GTX
GeForce 8800 GTS
GeForce 8600 GTS
GeForce 8600 GT
GeForce 8500 GT
Quadro FX 5600
Quadro FX 4600
Tesla C870
Tesla D870
Tesla S870
Compute Capability
1.0
1.0
1.0
1.1
1.1
1.1
1.0
1.0
1.0
1.0
1.0
Tabelle C.1: Von CUDA unterstützte Grafikkarten. Tabelle nach [5].
C.5 Test
Die in Kapitel 6 verwendeten Testserien befinden sich auf der beiliegenden CD. Die verwendeten Parametereinstellungen der Laufzeitests sind detailliert in Tabelle C.2 aufgeführt.
Der Parameter Use GPU for Recognition ist dabei nicht relevant, da zum einen das softwarebasierte und zum anderen das grafikkartenbasierte Verfahren getestet wurden. Auch die
Parameter Visualize Circle Result, Visualize Ellipse Result und Visualize Subimage wirken
sich nicht auf die Laufzeiten der Tests aus und werden deswegen nicht mit angegeben. Sie
befinden sich nur aus Gründen der Vollständigkeit in der Tabelle.
133
C Rsm3D Modul
Parameter
Number of spheres
Sobel Treshhold
Minimum Radius
Maximum Radius
Circle Distance
Max. Major Axis Length
Use GPU for Recognition
Axis Offset
Radius Multiplier
Monte-Carlo Steps
Visualize Circle Result
Visualize Ellipse Result
Visualize Subimage
Synthetische Daten Zahnserie
Bombenserie
3
30
20
90
120
90
-
3
30
60
90
25
90
-
3
30
60
90
25
90
-
0
2,595
30.000
-
1
1,2
10.000
-
1
1,2
10.000
-
Tabelle C.2: Verwendete Parametereinstellungen bei den Laufzeitmessungen.
134

GPU-basierte Erkennung von algebraisch beschreibbaren Strukturen

Transcription

Similar documents

PDF Export

Das Planungskonzept eines Zen

Hochschule München Fakultät 03 Skript zur Darstellenden

Abhängigkeit des Leistungsverhaltens großer

Implantation mit der CEREC Guide II

Zur floristischen Kartierung mittels GPS

Tro§zdem Nr.38 12-2007 - Justizvollzugsanstalt Oldenburg

Product Image and Photo Matching

Die Radontransformation in der digitalen Bildverarbeitung