Sie sind auf Seite 1von 99

Universitt Karlsruhe (TH)

a
Fakultt fr Informatik
a u
Institut fr Rechnerentwurf und Fehlertoleranz (IRF)
u
Lehrstuhl Prof. Dr.-Ing. R. Dillmann

Entwicklung eines Projektor-basierten 3D-Scanners


fur dynamische Szenen

Diplomarbeit
von
Pedram Azad
19. Juni 2003 18. Dezember 2003

Referent:
Korreferent:
Betreuer:

Prof. Dr.-Ing. R. Dillmann


Prof. Dr.-Ing. H. Wrn
o
Dipl.-Ing. T. Gockel

Ich versichere hiermit, die vorliegende Diplomarbeit selbststndig und ohne fremde Hilfe
a
angefertigt zu haben. Die verwendeten Hilfsmittel und Quellen sind im Literaturverzeichnis
vollstndig angefhrt.
a
u

Karlsruhe, den 18. Dezember 2003

Inhaltsverzeichnis
Abbildungsverzeichnis

iii

Tabellenverzeichnis

iv

Algorithmenverzeichnis

1 Einfuhrung

1.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Ansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3 Gliederung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1
1
1
2

2 Stand der Forschung


2.1 Klassizierung der Verfahren zur 3D-Oberchenerfassung . . . . .
a
2.2 Verfahren basierend auf Musterprojektion mit strukturiertem Licht
2.2.1 Zeitlich codierte Verfahren . . . . . . . . . . . . . . . . . . .
2.2.2 Frequenz-codierte Verfahren . . . . . . . . . . . . . . . . . .
2.2.3 Phasen-codierte Verfahren . . . . . . . . . . . . . . . . . . .

2.2.4 Ortlich codierte Verfahren . . . . . . . . . . . . . . . . . . .


2.3 Vergleich der Verfahren . . . . . . . . . . . . . . . . . . . . . . . .

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

3
3
3
5
8
8
10
12

3 Grundlagen
3.1 Bildverarbeitung . . . . . . . . . . . . . . . . . . .
3.1.1 Farbkonvertierung . . . . . . . . . . . . . .
3.1.2 Binarisierung . . . . . . . . . . . . . . . . .
3.1.3 Spreizung . . . . . . . . . . . . . . . . . . .
3.1.4 Region-Growing . . . . . . . . . . . . . . .
3.1.5 Schwerpunktbestimmung . . . . . . . . . .
3.2 Kamera- und Projektorkalibrierung . . . . . . . . .
3.2.1 Testfeldkalibrierung . . . . . . . . . . . . .
3.2.2 Direkte Lineare Transformation . . . . . . .
3.3 Korrespondenzproblem . . . . . . . . . . . . . . . .
3.3.1 Kreuzkorrelation und SSD . . . . . . . . . .
3.3.2 Korrelation nach der Methode der kleinsten
3.4 Epipolar-Geometrie . . . . . . . . . . . . . . . . . .
3.5 Triangulation in Stereokamerasystemen . . . . . .
3.6 Registrierung (Iterative Closest Point) . . . . . . .
3.6.1 Grundalgorithmus . . . . . . . . . . . . . .
3.6.2 Berechnung des nchsten Punktes . . . . .
a
3.6.3 Berechnung der optimalen Transformation .

. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
Quadrate
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .

4 Umsetzung der Algorithmik


4.1 Kamera-/Projektormodell nach Hoppe et al. . . . . . .
4.2 Verarbeitung von Punktemustern . . . . . . . . . . . .
4.3 Umsetzung der Binarisierung . . . . . . . . . . . . . .
4.3.1 Globale Binarisierung . . . . . . . . . . . . . .
4.3.2 Lokale Binarisierung . . . . . . . . . . . . . . .
4.4 Umsetzung der Korrelation . . . . . . . . . . . . . . .
4.4.1 Korrelation whrend der Projektorkalibrierung
a
4.4.2 Korrelation whrend des Scanvorgangs . . . . .
a
i

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

14
14
14
14
15
16
16
18
18
18
20
20
21
23
24
25
25
26
27

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

29
29
34
36
36
37
39
39
40

.
.
.
.
.
.

42
42
43
45
45
46

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

49
49
50
50
50
50
50
50
50
52
54
56
56
57
57
58
58
59
59
59
59
59

6 Ergebnisse
6.1 Exemplarische Scans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2 Evaluierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

60
60
64

7 Diskussion
7.1 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2.1 Verbesserte Registrierung . . . . . . . . . . . . . . . . . . .
7.2.2 Verbesserung der Projektor- und Bildaufnehmer-Hardware .
7.2.3 Leistungsfhigere Rechnerhardware . . . . . . . . . . . . . .
a

66
66
66
67
67
67

4.5
4.6

4.4.3 Wahl der Konstanten . . . . . . . . . . . . . . . . .


4.4.4 Weitere verfolgte Anstze . . . . . . . . . . . . . . .
a
Filterung der Einzelscans . . . . . . . . . . . . . . . . . . .
Umsetzung des ICP . . . . . . . . . . . . . . . . . . . . . .
4.6.1 Berechnung des nchsten Punktes . . . . . . . . . .
a
4.6.2 Gesamtalgorithmus und Suche nach Initialbedingung

5 Systementwurf
5.1 Hardwarearchitektur . . . . . . . . . . . . . . . . .
5.1.1 Kamera . . . . . . . . . . . . . . . . . . . .
5.1.2 Frame-Grabber-Karte . . . . . . . . . . . .
5.1.3 Video-Beamer . . . . . . . . . . . . . . . . .
5.1.4 PC . . . . . . . . . . . . . . . . . . . . . . .
5.1.5 Embedded-PC . . . . . . . . . . . . . . . .
5.2 Kalibrier- und Scanvorgang . . . . . . . . . . . . .
5.2.1 Kamerakalibrierung . . . . . . . . . . . . .
5.2.2 Projektorkalibrierung . . . . . . . . . . . .
5.2.3 Scanvorgang . . . . . . . . . . . . . . . . .
5.3 Softwarearchitektur . . . . . . . . . . . . . . . . . .
5.3.1 UML-Klassendiagramm des Gesamtsystems
5.3.2 Video-Capturing-Modul . . . . . . . . . . .
5.3.3 Bildverarbeitungsmodule . . . . . . . . . .
5.3.4 Verwaltungsmodule . . . . . . . . . . . . .
5.3.5 Kalibrierungsmodul . . . . . . . . . . . . .
5.3.6 Visualisierungsmodul . . . . . . . . . . . . .
5.4 Softwareumgebung . . . . . . . . . . . . . . . . . .
5.4.1 Betriebssystem . . . . . . . . . . . . . . . .
5.4.2 Programmiersprache . . . . . . . . . . . . .
5.4.3 APIs und Bibliotheken . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

Anhang A Mathematik

69

Anhang B Quellcode Ausschnitte

73

Anhang C Format der Eingabedateien

86

Anhang D Technische Daten und Datenbltter


a

87

Literaturverzeichnis

91

ii

Abbildungsverzeichnis
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

Klassizierung der Verfahren zur 3D-Oberchenerfassung . . . . . . . . . . .


a
Klassizierung der aktiven Verfahren zur 3D-Oberchenerfassung . . . . . .
a
Dualcode der Zahlen 0 bis 15 . . . . . . . . . . . . . . . . . . . . . . . . . . .
Graycode der Zahlen 0 bis 15 . . . . . . . . . . . . . . . . . . . . . . . . . . .
Illustration des Dualcodes und des Graycodes . . . . . . . . . . . . . . . . . .
Codierung von 110 Rndern in einer Folge von vier Mustern nach [HR01] . .
a
Zweideutige Zuordnung von Rndern bei der Decodierung nach [HR01] . . . .
a
Beispiel eines Frequenz-codierten Streifenmusters . . . . . . . . . . . . . . . .
Beispiel einer Folge von vier Mustern fr das Phasen-Schiebe-Verfahren . . .
u
Beispiel eines rtlich codierten Streifenmusters . . . . . . . . . . . . . . . . .
o
Binr codiertes Muster nach [VO90] . . . . . . . . . . . . . . . . . . . . . . .
a
Vier Primitive nach [VO90] . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Binr-Sequenzen nach [VO90] . . . . . . . . . . . . . . . . . . . . . . . . . . .
a
Graustufen-Muster nach [DBCM02] . . . . . . . . . . . . . . . . . . . . . . .
Beispiel eines bimodalen Histogramms . . . . . . . . . . . . . . . . . . . . . .
Beispiel zur Korrelation nach der Methode der kleinsten Quadrate . . . . . .
Epipolar-Geometrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Darstellung zweier windschiefer Geraden . . . . . . . . . . . . . . . . . . . . .
Kameramodell nach Hoppe et al. . . . . . . . . . . . . . . . . . . . . . . . . .
Veranschaulichung der Einschrnkung des Suchraums fr die Korrelation . . .
a
u
Foto des 3D-Scanners . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Punkte-Muster mit eingezeichnetem Weltkoordinatensystem . . . . . . . . . .
Foto zur Kamerakalibrierung . . . . . . . . . . . . . . . . . . . . . . . . . . .
Screenshot zur Kamerakalibrierung . . . . . . . . . . . . . . . . . . . . . . . .
Veranschaulichung der Berechnungen fr die Projektorkalibrierung . . . . . .
u
Foto zur Projektorkalibrierung . . . . . . . . . . . . . . . . . . . . . . . . . .
Veranschaulichung der Berechnung eines Objektpunktes . . . . . . . . . . . .
Foto eines realen Scanvorgangs . . . . . . . . . . . . . . . . . . . . . . . . . .
Screenshot whrend eines realen Scanvorgangs . . . . . . . . . . . . . . . . .
a
UML-Klassendiagramm des Gesamtsystems . . . . . . . . . . . . . . . . . . .
Zwei Scans einer Porzellangur eines Hhnchens: 3D-Laser-Scan und Scan mit
u
dem vorliegenden System . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Thermoplot der Scans aus Abbildung 31 . . . . . . . . . . . . . . . . . . . . .
Scan einer Ebene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Sequenz der Einzelscans eines gesamten Scanvorgangs . . . . . . . . . . . . .
Gerenderte Darstellung des Ergebnisses zu Abbildung 34 . . . . . . . . . . . .
Gerenderte Darstellung eines Einzelscans einer Computer-Maus . . . . . . . .
Gerenderte Darstellung eines Einzelscans einer Szene bestehend aus Kreidestcken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
u

iii

3
4
5
6
6
7
7
8
9
10
11
11
12
12
15
23
23
24
30
40
49
51
51
52
53
53
54
55
56
57
60
61
61
62
62
63
63

Tabellenverzeichnis
1
2

Vergleich der Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


Zuordnung der Verwaltungsmodule zu den Bildverarbeitungsmodulen . . . .

iv

13
58

Algorithmenverzeichnis
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

RegionGrowing(image, x, y, id) . . . . . . . . . . . . . . .
ICP(P, M) . . . . . . . . . . . . . . . . . . . . . . . . . .
KalibriereKamera(xi , ndi , mdi ) . . . . . . . . . . . . . .
VerarbeitePunktemuster(image) . . . . . . . . . . . . .
BerechneRegionUndSchwerpunkt(image, x, y, id) . . . . .
BinarisiereGlobal(image) . . . . . . . . . . . . . . . . .
BinarisiereLokal(image) . . . . . . . . . . . . . . . . . .
BestimmeKorrespondenzenKalibrierung(f, g) . . . . . .
FindeKorrespondenzKalibrierung(f, g, x, y, dx0 , dy0 , s)
BestimmeKorrespondenzenScan(f, g) . . . . . . . . . . . .
FindeKorrespondenzScan(f, g, x, y) . . . . . . . . . . . .
FiltereEinzelscan(G) . . . . . . . . . . . . . . . . . . .
BerechneNchstePunkte(P, M) . . . . . . . . . . . . . .
a
FastICP(P, M) . . . . . . . . . . . . . . . . . . . . . . . .
VerarbeiteEinzelscan(G) . . . . . . . . . . . . . . . . .
LseLGSGau(A, b) . . . . . . . . . . . . . . . . . . . . . .
o
LseLGSCholesky(A, b) . . . . . . . . . . . . . . . . . . .
o

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

17
26
33
34
35
36
38
39
40
42
42
44
47
48
55
70
71

1
1.1

Einfuhrung

Motivation

Das 3D-Scannen von groen und komplexen Objekten mit einem herkmmlichen Laser- oder
o
Projektor-basierten Scanner ist ein aufwndiger iterativer Prozess. Der Benutzer muss fr
a
u
jeden einzelnen Scan das Objekt xieren, ohne zu wissen ob die neue Position des Objekts
ein besseres Ergebnis fr die fehlenden Regionen, die aufgrund von Abschattungen entsteu
hen, liefern wird oder nicht. Zudem muss der Benutzer nach jedem Einzelscan eine oineRegistrierung mit den vorhergehenden Scans vornehmen, bei der meist die manuelle Vorgabe
einer Initialbedingung im 3D-Editor erforderlich ist. Diese schrittweise Vorgehensweise ist ein
sehr zeitraubender und inezienter Prozess.
Ein System, das die freie Fhrung eines Scankopfes respektive die freie Fhrung des zu scanu
u
nenden Objekts erlaubt, die Registrierung vollautomatisch on-the-y durchfhrt und dabei
u
das neue Scanergebnis unmittelbar visualisiert, wrde dem Benutzer erlauben interaktiv zu
u
reagieren und dadurch eine betrchtliche Ezienzsteigerung bewirken. Der Anspruch den
a
Scankopf respektive das Objekt frei fhren zu knnen, bedeutet, dass ein Einzelscan trotz
u
o
einer unbekannten Relativbewegung berechnet werden muss. Die Projektion eines einzigen
zeitlich konstanten Musters gengt dieser Bedingung und erlaubt die Miniaturisierung eines
u
solchen Systems durch den Einsatz entsprechender Hardware. Im Vergleich zu Stereokamerasystemen mit passiver Musterprojektion reduziert die Beschrnkung auf eine Kamera den
a
Hardwareaufwand auf ein Minimum. Da keine Synchronisation von zwei Kameras notwendig
ist, kann das System mit nahezu beliebigen Kameras und Frame-Grabber-Karten betrieben
werden.
Systeme, welche die Trajektorie der Handbewegung durch ein Tracking-System berechnen,
wie beispielsweise in [HR98] vorgestellt, vermgen die Einzelscans ohne Registrierung zuo
sammenzusetzen, bentigen jedoch einen hheren Hardwareaufwand, der sich nachteilig auf
o
o
Portabilitt und Praktikabilitt auswirkt. Ferner schrnkt der Einsatz eines Tracking-Systems
a
a
a
- je nach konkreter Wahl - die erreichbare Genauigkeit und die Bewegungsfreiheit des Benutzers ein. Aus diesen Grnden galt die Magabe, das beschriebene interaktive 3D-Scan-System
u
ohne die Verwendung eines Tracking-Systems zu realisieren.

1.2

Ansatz

Projiziert man ein zeitlich konstantes Muster auf das zu scannende Objekt und betrachtet
die resultierende Szene mit einer Kamera, so kann uber das Aunden von Korrespondenzen

des Originalmusters im Kamerabild zwischen Projektor und Kamera trianguliert werden. Auf
diese Weise liefert jede Korrespondenz einen Punkt der Objektoberche im dreidimensionaa
len Raum.
Die Lsung des Korrespondenzproblems gestaltet sich einfacher, indem man das Muster ino
itial annhernd senkrecht auf eine Ebene im Tiefenschrfebereich des Projektors und der
a
a
Kamera projiziert, und das entsprechende Kamerabild als Referenzmuster fr die Korrelau
tion verwendet. Mit einer speziell entwickelten Abwandlung der Projektorkalibrierung ist es
dann mglich, auf die Kenntnis des Originalmusters gnzlich zu verzichten. Dies bietet den
o
a
erheblichen Vorteil, dass die Anfertigung des Positivs fr ein Projektionssystem mit einem feu
sten Muster keinerlei Genauigkeitsanforderungen gengen muss. Dadurch lassen sich anstatt
u
eines Diapositivs auch Gobos verwenden, die aus dem Bereich der Medientechnik stammen
und sehr kostengnstig gefertigt werden knnen [Der].
u
o
1

Da mit der beschriebenen Methode ein Einzelscan nicht nur eine Kontur, sondern die Oberche eines gesamten Teilstcks des Objekts berechnet, ist es mglich aufeinander folgende
a
u
o
Einzelscans mit Hilfe von Registrierungsalgorithmen zusammenzusetzen.
Um Interaktion zu ermglichen mssen alle Vorgnge uerst ezient erfolgen, sodass heuo
u
a
a
tige Rechnerhardware eine Operation nur auf einem Teil der berechenbaren Punkte fr den
u
online-Prozess erlaubt. In einem nachfolgenden oine-Prozess kann dann auf Basis der gespeicherten Bilddaten eine Auswertung mit maximaler Ausung und Genauigkeit erfolgen.
o

1.3

Gliederung

In Kapitel 2 wird zunchst eine Klassizierung der Verfahren zur 3D-Oberchen- und Volua
a
menerfassung gegeben. Dabei werden insbesondere die Verfahren basierend auf aktiver Musterprojektion mit strukturiertem Licht vorgestellt und miteinander verglichen, um das eingesetzte Verfahren einordnen und dessen Wahl begrnden zu knnen. In Kapitel 3 werden
u
o
anschlieend die notwendigen Grundlagen fr das Verstndnis des Systems vermittelt, aus
u
a
den Bereichen der digitalen Bildverarbeitung und der Photogrammetrie, insbesondere der
Stereoskopie und der Registrierung von dreidimensionalen Datenstzen. Die Umsetzung der
a
Algorithmen und die spezielle Abstimmung der Verfahren aus dem Grundlagenteil auf das
vorliegende System werden in Kapitel 4 erlutert. In Kapitel 5 werden der gesamte Kalia
briervorgang und der Systementwurf vorgestellt, bestehend aus der Hardwarearchitektur und
der Softwareumgebung. Schlielich werden die Ergebnisse dieser Diplomarbeit in Kapitel 6
prsentiert, welche die Evaluierung des Systems und einige exemplarische Scans umfassen.
a
Die Arbeit endet schlielich mit einer Zusammenfassung und einem Ausblick auf mgliche
o
Verbesserungen des Systems.

2
2.1

Stand der Forschung


Klassizierung der Verfahren zur 3D-Oberchenerfassung
a

Mit der folgenden Ubersicht soll eine Klassizierung der Verfahren zur 3D-Oberchenera
fassung gegeben werden, ohne Anspruch auf Vollstndigkeit zu erheben. Die Problematik bea
steht hierbei in dem Umstand, dass die Unterscheidung von aktiven und passiven Verfahren
und die Unterscheidung von triangulationsbasierten und anderen Verfahren nicht gleichzeitig
in einem Baum darstellbar ist. Um die Verfahren dennoch ordnen zu knnen, wird nur die
o
Unterscheidung von aktiven und passiven Verfahren durch die Baumstruktur vorgenommen.
Die triangulationsbasierten Verfahren werden durch eine entsprechende Markierung in den
Blttern des Baumes gekennzeichnet. Die Klassizierung stellt eine Erweiterung der Darstela
lungen aus [BS98] und [SPB04] dar.

Verfahren zur 3DOberflchen- und


Volumenerfassung

Mechanische
Verfahren

Koordinatenmessmaschine

Radiologische
Verfahren

Ultraschall-basierte
Verfahren

Optische
Verfahren

Sonar-Arrays

Sonar-Systeme

Shape-fromShading

Stereopsis
(Stereokameras)

MRT

Aktive Verfahren

Silhouettenschnitt

CT

Passive Verfahren

Faro-Arm

Klassische
Photogrammetrie

Focus/De-Focus,
Confokale
Mikroskopie

Abbildung 1: Klassizierung der Verfahren zur 3D-Oberchenerfassung


a

2.2

Verfahren basierend auf Musterprojektion mit strukturiertem Licht

Da das ausgewhlte Verfahren ein optisches Verfahren ist, das auf aktiver Musterprojektion
a
mit strukturiertem Licht basiert, wird im Folgenden diese Untergruppe im Detail betrachtet.
Von besonderem Interesse ist die Eignung der jeweiligen Verfahren fr den Einsatz in einem
u
handgefhrten System. Hierbei wird ausdrcklich auf die Verfolgung der Hand mit Hilfe eines
u
u
Tracking-Systems, wie beispielsweise in [HR98] vorgestellt, verzichtet. Dieser Ansatz bietet
zwei Vorteile: der Hardwareaufwand wird auf ein Minimum reduziert und es bestehen keinerlei
Einschrnkungen, die zwangslug durch den Einsatz eines Tracking-Systems entstnden.
a
a
u
3

Aktive
Verfahren

Verfahren basierend
auf Musterprojektion

Lichtpunkt

Lichtschnitt

Strukturiertes
Licht

Holografie

Phasencodiert

Zeitlich codiert
(Graycode...)

Frequenzcodiert

rtlich codiert

SpeckleInterferometrie

Time-of-FlightVerfahren

Interferometrische
Verfahren

Laufzeitverfahren

Abbildung 2: Klassizierung der aktiven Verfahren zur 3D-Oberchenerfassung


a
Beispielsweise mssen bei einem Stereokamera-Tracking-System Verdeckungen des Trackingu
Musters vermieden werden, bei einem magnetischen Tracking-System machen metallische und
magnetische Gegenstnde in der nheren Umgebung eine korrekte Positionierung unmglich.
a
a
o
Um auch ohne den Einsatz eines Tracking-Systems einzelne Scans zusammenfgen zu knnen,
u
o
werden die aus den einzelnen Scans gewonnenen dreidimensionalen Datenstze mit Hilfe
a
von Registrierungsalgorithmen zusammengesetzt. Hierzu mssen drei Voraussetzungen erfllt
u
u
sein:

Uberlappung aufeinander folgender Einzelscans


Ausreichende Dichte und Flchendeckung eines Einzelscans
a
Beschrnkung auf eine Bildaufnahme je Einzelscan
a

Grundvoraussetzung fr alle Registrierungsalgorithmen ist, dass sich die zu registrierenden


u
Datenstze zu einem Groteil uberlappen. Damit diese Bedingung fr aufeinander folgende
a
u

Einzelscans in einem handgefhrten System erfllt ist, muss die Berechnung eines Einzelscans
u
u
so ezient wie mglich erfolgen. Je mehr Einzelscans pro Sekunde berechnet werden knnen,
o
o
desto schnellere Handbewegungen knnen toleriert werden.
o
Weiterhin mssen die Einzelscans ein Flchenstck mit einer ausreichenden Dichte erfassen,
u
a
u
sodass gengend Merkmale fr die Registrierung vorhanden sind. Aus der Gruppe der auf
u
u
aktiver Musterprojektion basierenden Verfahren vermgen ausschlielich die Verfahren basieo
rend auf Musterprojektion mit strukturiertem Licht diese Voraussetzung zu erfllen.
u
4

Die Beschrnkung auf eine Bildaufnahme je Einzelscan schrnkt die Mglichkeiten zur Codiea
a
o
rung der Herkunft eines Lichtstrahls drastisch ein. Die im Folgenden vorgestellten Verfahren
erfllen nicht alle die genannten Voraussetzungen. Nach der Erluterung jedes Verfahrens
u
a
wird deshalb gesondert auf diese Eigenschaft eingegangen. In Abschnitt 2.2.1 wird ein besonderes Verfahren vorgestellt, das eine Ausnahme darstellt, da es die dritte Voraussetzung
nicht erfllt, aber dennoch in einem handgefhrten System zum Einsatz kommt.
u
u
Zur weiteren Verwendung des Begris Lichtschnitt sei Folgendes angemerkt. Die Gruppe der
Lichtschnittverfahren, die in Abbildung 2 aufgefhrt ist, soll diejenigen Verfahren umfasu
sen, die durch den Schnitt einer festen Lichtebene mit der optischen Gerade eines jeweiligen

Bildpunktes 3D-Information berechnen. Ublicherweise wird als Lichtquelle ein Linien-Laser


verwendet. Mit Hilfe eins Projektors lassen sich zweidimensionale Streifenmuster projizieren,
sodass gleichzeitig eine Vielzahl von Linien als Berechnungsgrundlage zur Verfgung stehen.
u
Die Problematik besteht hierbei in der Identikation der Herkunft eines einzelnen Streifens,
da die relative Bestimmung durch einfaches Abzhlen nur bei glatten stetigen Objektobera
chen mit geringen Steigungen mglich ist. Obwohl fr jeden einzelnen Streifen letztlich
a
o
u
ein Lichtschnitt berechnet wird, bedienen sich solche Verfahren komplexer zweidimensionaler
Muster und sind deshalb zu der Gruppe der Verfahren basierend auf Musterprojektion mit
strukturiertem Licht zu zhlen.
a
2.2.1

Zeitlich codierte Verfahren

Zeitlich codierte Verfahren verwenden eine Folge von Mustern, die zusammen einen binren
a
Code ergeben. In der Regel werden schwarz-weie Streifenmuster verwendet. Mit einer Folge
von n Mustern lassen sich so maximal 2n Streifen codieren, mit denen dann jeweils ein Lichtschnitt berechnet werden kann. [PA82]
Besonders geeignet fr dieses Verfahren ist der Graycode, der gegenber dem Dualcode zwei
u
u
Vorteile bietet. Der Graycode ist so deniert, dass aufeinander folgende Zahlen sich in ihrer binren Darstellung in genau einem Bit unterscheiden. Eine falsche Decodierung, die am
a
wahrscheinlichsten an Stellen auftritt, an denen ein Bit wechselt, erzeugt deshalb einen Fehler
von nur einer Einheit der Ausung des Musters. Weiterhin ist der Graycode so deniert,
o
dass die Streifen des Musters mit der feinsten Ausung doppelt so breit sind wie die feino
sten Streifen eines entsprechenden Dualcodes (vgl. Abbildungen 3, 4 und 5). Dies erleichtert
die Analyse an steilen Objektoberchen, auf denen der Code komprimiert abgebildet wird.
a
[Gh01]
u
In den Abbildungen 3 und 4 ist die Codierung der Zahlen 0 bis 15 im Graycode bzw. im
Dualcode veranschaulicht, wobei ein schwarzes Kstchen eine binre Null darstellt, ein weia
a
es Kstchen eine binre Eins. In Abbildung 5 ist die Folge von n = 4 Streifenmustern im
a
a
Dualcode (links) und im Graycode (rechts) gegenbergestellt.
u

Abbildung 3: Dualcode der Zahlen 0 bis 15


5

Abbildung 4: Graycode der Zahlen 0 bis 15

Abbildung 5: Illustration des Dualcodes und des Graycodes


Bei den ublichen zeitlich codierten Verfahren gilt die Voraussetzung fr die korrekte Decodieu

rung, dass whrend der Projektion der Folge der n Muster das Objekt relativ zum Projektor
a
unbewegt bleibt, weshalb solche Verfahren fr dynamische Szenen ungeeignet sind.
u
Eine Mglichkeit, langsame Bewegungen dennoch zu tolerieren, besteht in der Verfolgung der
o
Streifen von Bild zu Bild [HR01] [RHHL02]. Wenn die Bewegung des Objekts relativ zum
Projektor langsam genug erfolgt, sodass die Streifen verfolgt werden knnen, ist es mglich
o
o
die Bits des Codes uber die Zeit zu akkumulieren, trotz der Tatsache, dass diese nicht vom

selben Kamerapixel stammen. In der Praxis knnen Regionen, und somit auch Streifen, nur
o
uber die Verfolgung ihrer Rnder verfolgt werden. Sei ein Rahmenwerk zur Berechnung der
a

Verfolgung der Streifen gegeben, so wird ein Code bentigt, der auf dieser Basis den folgenden
o
Anforderungen gengt:
u
Die Streifen mssen so schmal wie mglich sein, damit die Menge der Rnder so dicht
u
o
a
wie mglich ist.
o
Da Rnder betrachtet werden, kann mehr Information einbezogen werden, indem der
a
an/aus Status auf beiden Seiten der Rnder betrachtet wird. Somit muss der Code jedes
a
Paar benachbarter Streifen eindeutig uber die Zeit codieren.

Die Anzahl der Rnder zwischen zwei Streifen derselben Farbe muss minimal sein,
a

da solche ghosts nicht im Kamerabild erkennbar sind.

In Abbildung 6 ist ein solcher Code abgebildet. Um das Problem der ghosts zu beheben,
bendet sich in einem Muster zwischen zwei sichtbaren Rndern maximal ein ghost. Zudem
a
entspricht dieser ghost sichtbaren Rndern in den vorherigen und folgenden Mustern, sodass
a
die mglichen Entsprechungen eingegrenzt werden. Trotz diesen Bedingungen kann die Zuo
ordnung nicht eindeutig erfolgen, wie Abbildung 7 zeigt. Beide Mglichkeiten erfllen die
o
u
6

Abbildung 6: Codierung von 110 Rndern in einer Folge von vier Mustern nach [HR01]
a

Abbildung 7: Zweideutige Zuordnung von Rndern bei der Decodierung nach [HR01]
a
geforderten Bedingungen. Zur Lsung dieses Problems wird die Taktik verfolgt, potentielo
le Fehler so gro wie mglich werden zu lassen, sodass Ausreier einfacher identiziert und
o
geltert werden knnen. [HR01] [RHHL02]
o

2.2.2

Frequenz-codierte Verfahren

Frequenz-codierte Verfahren codieren die Herkunft eines Lichtstrahls direkt durch seine Fre
quenz, d.h. durch seine Farbe. Ublicherweise werden Streifenmuster verwendet, in denen jeder Streifen mit einer eigenen Farbe codiert wird. Frequenz-codierte Verfahren sind erheblich
von der Farbe der Objektoberche abhngig. Die Objektoberche muss fr eine erfolgreia
a
a
u
che Decodierung einheitlich eingefrbt sein und zudem annhernd dieselbe Farbe besitzen,
a
a
die whrend der photometrischen Kalibrierung verwendet wurde. Auch die Lichtverhltnisse
a
a
drfen nur gering variieren. Generell gilt, je dichter die Streifen verteilt sind, desto hher
u
o
ist die erzielte Ausung eines einzelnen Scans, umso niedriger ist jedoch die Robustheit des
o
Systems und somit auch de facto die Genauigkeit. Ein exemplarisches Beispiel eines solchen
Musters ist in Abbildung 8 dargestellt.

Abbildung 8: Beispiel eines Frequenz-codierten Streifenmusters


Zu den Vorteilen Frequenz-codierter Verfahren gehrt, dass sie fr dynamische Szenen geeigo
u
net sind, da eine einzige Aufnahme ausreicht, um die Herkunft der Streifen uber ihre Farbe

zu identizieren. Ferner ist der Rechenaufwand fr die Decodierung verhltnismig gering,


u
a
a
sodass problemlos eine Vielzahl von Einzelscans pro Sekunde berechnet werden knnen. Bei
o
einer hinreichenden Dichte der Streifen sind somit alle genannten Voraussetzungen fr den
u
Einsatz in einem handgefhrten System erfllt.
u
u
2.2.3

Phasen-codierte Verfahren

Das Phasen-Schiebe-Verfahren ist eine Variante der dynamischen Streifenprojektion. Die Phasenmessung erfolgt direkt mit den abgebildeten Intensittswerten. Dazu wird das Streifena
muster als Interferogramm aufgefasst und insgesamt m-mal projiziert. Fr die Intensitten
u
a
einer Streifenposition im n-ten Streifenmuster gilt:
In (x, y) = I0 (1 + (x, y)cos((x, y) + n ))
mit
I0 :
(x, y):
(x, y):
n :

Gleichlicht- oder Hintergrundintensitt


a
Streifenmodulation
Phase
Phasendierenz

Die Beziehung enthlt die drei Unbekannten I0 , (x, y) und (x, y), weshalb zur Lsung
a
o
8

mindestens drei Gleichungen aufzustellen sind. Man erhlt sie durch m-maliges Verschieben
a
des Streifengitters um die Phasendierenz n :
n = (n 1)0
mit
n = 1, ..., m
0 = 2/m

m3

Die interessierende Phase (x, y) ergibt sich beispielsweise fr m = 4 zu:


u
(x, y) = arctan

I2 (x, y) I4 (x, y)
I3 (x, y) I1 (x, y)

Das Ergebnis ist lediglich im Bereich ... + eindeutig. Die Hhenmessgenauigkeit des
o
Verfahrens betrgt ca. /100, wobei den Abstand zwischen zwei Helligkeitsmaxima bzw.
a
-minima bezeichnet. [Luh00]

Abbildung 9: Beispiel einer Folge von vier Mustern fr das Phasen-Schiebe-Verfahren


u
Durch die Einbeziehung der Frequenz des Lichts in die Berechnungen ist das Verfahren stark
von den Obercheneigenschaften des Objekts abhngig. Im Gegensatz zu rein Frequenza
a
codierten Verfahren ist das Phasen-Schiebe-Verfahren jedoch nicht fr dynamische Szenen
u
geeignet, da mindestens drei aufeinander folgende Streifenmuster fr einen Berechnungsu
vorgang projiziert werden mssen. Gegenber den rein zeitlich codierten Verfahren bietet
u
u
das Phasen-Schiebe-Verfahren den Vorteil einer hheren Genauigkeit und Ausung. Da
o
o
das Ergebnis, wie bereits erwhnt, lediglich im Bereich ... + eindeutig ist, wird das
a
Phasen-Schiebe-Verfahren oftmals mit einem zeitlich codierten Verfahren, wie zum Beispiel
der Graycode-Projektion, kombiniert, sodass die Position der Streifen absolut eindeutig codiert werden kann. Ein solches Verfahren wird in [Gh01] vorgestellt. Da auch fr dieses
u
u
Verfahren eine Folge von Bildern fr einen Einzelscan notwendig ist, eignet es sich nicht fr
u
u
den Einsatz in einem handgefhrten System.
u
9

2.2.4

Ortlich codierte Verfahren

Ortlich codierte Verfahren codieren die Herkunft eines Lichtstrahls in dessen unmittelbarer
Umgebung. Hierzu sind eine Vielzahl verschiedener Codes denkbar, derer eine Auswahl im
Folgenden vorgestellt werden soll. Alle vorzustellenden Verfahren eignen sich fr den Einsatz
u
in einem handgefhrten System, da sie die genannten Bedingungen erfllen.
u
u
In einem Streifenmuster lsst sich die Herkunft eines Streifens durch einen Farbcode in den
a
benachbarten Zwischenrumen codieren [OS]. Die Streifen knnen mit den ublichen Algoa
o

rithmen zur Linien-Lokalisation Subpixel-genau lokalisiert werden. Der Code in den benachbarten Zwischenrumen wird dann zur Identizierung des jeweiligen Streifens im projizierten
a
Original-Muster herangezogen, als Grundlage fr die Berechnung des Lichtschnitts.
u
Die Wahl einer Basis grer zwei fr den Farbcode mit der zustzlichen Beschrnkung, dass
o
u
a
a
zwei benachbarte Kstchen nicht die gleiche Farbe besitzen drfen, gestaltet die Bildverara
u
beitung besonders einfach. So knnen ohne zustzliche Vorkehrungen im Muster Farbwechsel
o
a
als Indiz fr ein neues Kstchen verwendet werden. Denkbar wre auch bei einer Basis beu
a
a
stehend aus den Farben Rot, Grn und Blau, Schwarz als Separator zwischen zwei Kstchen
u
a
zu verwenden. Ein solches Muster ist in Abbildung 10 abgebildet. Fr die Decodierung der
u
Herkunft eines weien Streifens in diesem Muster mssen in beiden benachbarten Streifen
u
zwei aufeinander folgende Kstchen identiziert werden. Somit existieren genau sechs Farba
codes (gg, rr, bb, gr, gb, rb), da rg zu gr aquivalent ist, bg zu gb und br zu rb. Da je weiem

Streifen zwei Farbcodes fr die Decodierung herangezogen werden, knnen insgesamt 62 = 36


u
o
Streifen codiert werden. Der Code fr den erste Streifen lautet dann (gg, gg), fr den zweiten
u
u
Streifen (gg, rr), usw.
Prinzipiell hat die Verwendung von Farben im Muster den Nachteil, dass das Verfahren
bei farbigen Objektoberchen im Allgemeinen scheitert. Ein binrer Schwarz-Wei-Code
a
a
ist dagegen unabhngiger von der Farbe der Objektoberche und somit robuster, bentigt
a
a
o
allerdings einen greren Ausschnitt der Umgebung zur erfolgreichen Codierung und Decoo
dierung, bedingt durch die Wahl der kleineren Basis fr den Code. Dies bedeutet wiederum,
u
dass bei unstetigen Objektoberchen kleinere abgegrenzte Flchenstcke nicht erkannt wera
a
u
den knnen, da sie nicht genug Flche fr die Aufnahme des Codes bieten. Nachteilig wirkt
o
a
u
sich hierbei aus, dass der Code entlang einer Geraden angebracht ist. Ein Quadrat oder optimalerweise ein Kreis wren durch ihre hhere Kompaktheit geeigneter fr die Unterbringung
a
o
u
des Codes.

Abbildung 10: Beispiel eines rtlich codierten Streifenmusters


o
10

Ein Muster, das die Herkunft eines Lichtstrahls rtlich codiert, jedoch nicht aus Streifen
o
zusammengesetzt ist, ist in Abbildung 11 dargestellt [VO90]. Grundstzlich ist das Muster
a
von einem Schachbrett-Muster abgeleitet. Es besteht aus 63 Spalten und 63 Reihen, derer
nur 10 abgebildet sind. Als Spalte bzw. Reihe wird die zwischen zwei Kstchen verlaufende
a
Grenzlinie verstanden, die Schnittpunkte dieser Grenzlinien werden als Gitterpunkte bezeichnet. Das Muster ist aus vier Primitiven zusammengesetzt, die in Abbildung 12 abgebildet
sind. Die Primitive unterscheiden sich in zwei Eigenschaften, die jeweils zwei unterschiedliche
Ausprgungen besitzen knnen. Sind die zwei groen Kstchen in der Mitte verbunden, so
a
o
a
wird eine binre 0 reprsentiert, andernfalls eine 1. Die zwei mglichen Anordnungen der
a
a
o

Kstchen auf einer Diagonalen werden mit + bzw. gekennzeichnet. Um nun eine binre
a
a

Interpretation des Musters aus Abbildung 11 zu erhalten, werden zwei binre Sequenzen ck
a
und bk , von jeweils 63 Bits Lnge, verwendet. Den Gitterpunkten auf der k-ten Spalte des
a
Typs + wird der binre Wert ck zugewiesen, whrend denjenigen des Typs der Wert
a
a

bk zugewiesen wird. Die dem Muster aus Abbildung 11 entsprechende Zuordnung ist in Abbildung 13 dargestellt. Bei geeigneter Wahl der Folgen ck und bk trgt jedes Fenster von 2 3
a
Gitterpunkten an jeder beliebigen Position ein 6-bit Codewort, das die zu Grunde liegende
Spalte eindeutig identiziert. Die dem Muster aus Abbildung 11 zu Grunde liegenden Folgen
ck und bk sind in Bezug auf eine robuste Decodierung optimiert. [VO90]

Abbildung 11: Binr codiertes Muster nach [VO90]


a

Abbildung 12: Vier Primitive nach [VO90]

Der allgemeinste Ansatz, ein rtlich codiertes Musters zu decodieren, basiert auf der Korreo
lation mit dem Originalmuster. Projiziert man ein nahezu beliebiges Muster auf ein Objekt,
so lsst sich im so gewonnenen Kamerabild theoretisch zu jedem Fensterausschnitt das kora
respondierende Fenster im Originalmuster bestimmen. Praktisch gelingt dies jedoch nicht
fr jeden Ausschnitt, da fr die Korrelation die entsprechende Objektoberche lokal glatt
u
u
a
sein muss, um das Teilmuster aufnehmen zu knnen. Nach erfolgreicher Lsung des Koro
o
respondenzproblems (vgl. Abschnitt 3.3) wird ein Objektpunkt gewonnen, indem zwischen

Kamera und Projektor trianguliert wird. Dieser Ansatz weist groe Ahnlichkeit mit dem
11

Abbildung 13: Binr-Sequenzen nach [VO90]


a
in Stereokamerasystemen eingesetzten Verfahren auf. Im Vergleich gestaltet sich die Lsung
o
des Korrespondenzproblems in Stereokamerasystemen mit passiver Musterprojektion jedoch
einfacher, da dort die Kameras nahezu identische Intensitten in ubereinstimmenden Bereia

chen wahrnehmen. Der Nachteil besteht allerdings in einem Mehraufwand an Hardware und
Synchronisation. Das synchrone Betreiben von zwei Kameras ist nicht an beliebigen PCs
mit beliebiger Hardware zur Bildgewinnung mglich. In Abbildung 14 wird ein verrauschtes
o
Graustufen-Muster durch Aufsummierung von drei einzelnen binren Zufallsmustern vera
schiedener Skalierung zusammengesetzt [DBCM02]. Zustzlich zur unterschiedlichen Skaliea
rung wird ein Phasenshift von einem halben Pixel verwendet, um horizontale und vertikale
Artefakte im zu erzeugenden Muster zu vermeiden.

Abbildung 14: Graustufen-Muster nach [DBCM02]


Die Korrelation wird durch Verzerrungen erschwert, die durch eine nicht orthogonale Projektion des Musters auf die Objektoberche entstehen. Hierfr existieren spezielle Korrelatia
u
onsalgorithmen, die durch das Einbeziehen einer Antransformation auch projektive Verzerrungen erkennen knnen (vgl. Abschnitt 3.3.2). Weiterhin sind die reektierten Intensitten
o
a
von der Farbe der Objektoberche abhngig, sodass fr eine erfolgreiche Korrelation eine
a
a
u
Vorvearbeitung der Kamerabilder unerlsslich ist.
a

2.3

Vergleich der Verfahren

In der folgenden tabellarischen Ubersicht sollen die vorgestellten Verfahren basierend auf
Musterprojektion mit strukturiertem Licht miteinander verglichen werden. Dabei wird kein
Anspruch auf den Einbezug aller Eigenschaften der Verfahren erhoben. Vielmehr sollen die
12

charakteristischen Merkmale hervorgehoben werden, um die grundlegenden Unterschiede verdeutlichen zu knnen.


o
Der Decodierungsaufwand ist als unabhngig von der Ausung zu verstehen, gemeint ist
a
o
der zeitliche Aufwand fr die Decodierung in Bezug auf die Anzahl der berechneten Objektu
punkte. Unter der Ausung wird hier die maximal erreichbare Anzahl der Objektpunkte je
o
Einzelscan verstanden.

Verfahren

Graycode
Code nach [RHHL02]
Graycode + Phasenshift
Rein Frequenz-codiert

Ortlich Frequenz-codiert
Code nach [VO90]
Verfahren nach [DBCM02]
Unser System

Dynamische
Szenen
nein
ja
nein
ja
ja
ja
ja
ja

Robustheit in
Bezug auf
die Objekttextur
hoch
hoch
hoch
sehr gering
gering
hoch
gering-mittel
mittel

Decodierungsaufwand

Ausung
o

gering-mittel
mittel
mittel
gering
mittel
mittel
hoch
hoch

hoch
hoch
sehr hoch
hoch
mittel
gering
hoch
hoch

Anforderungen an
das Muster
mehrere
bekannt
ja
ja
ja
ja
ja
ja
nein
ja
nein
ja
nein
ja
nein
ja
nein
nein

Tabelle 1: Vergleich der Verfahren


Es sei angemerkt, dass unser System prinzipiell nach dem Ansatz von [DBCM02] arbeitet, sich
jedoch dahingehend unterscheidet, dass ein Schwarz-Wei-Muster anstatt eines GraufstufenMusters verwendet wird und das Muster dem System initial nicht bekannt sein muss. Dies
hat den mageblichen Vorteil, dass keine Anforderungen an die Przision der Fertigung des
a
Diapositivs bestehen. Die Verwendung eines Schwarz-Wei-Musters erlaubt die Verwendung
von Gobos, die aus dem Bereich der Medientechnik bekannt sind und sehr kostengnstig
u
gefertigt werden knnen [Der].
o

13

Grundlagen

In diesem Kapitel sollen die notwendigen Grundlagen fr das Verstndnis des entwickelten
u
a
Systems vermittelt werden. Zunchst werden Verfahren zur Verarbeitung von 2D-Bildern vora
gestellt. Anschlieend werden grundlegende Verfahren aus der Photogrammetrie zur Kameraund Projektorkalibrierung behandelt. Obwohl das entwickelte System nicht auf klassischer

Stereoskopie basiert, weist die notwendige Algorithmik dennoch groe Ahnlichkeiten mit der
eines Stereokamerasystems auf. In diesem Zusammenhang werden insbesondere verschiedene
Algorithmen zur Korrelation, die Epipolar-Geometrie und die Triangulation in Stereokamerasystemen vorgestellt. Abschlieend wird der meist verwendete Algorithmus zur Registrierung
von 3D-Punktwolken erlutert.
a

3.1

Bildverarbeitung

In diesem Abschnitt werden die verwendeten Grundlagen zur Verarbeitung von 2D-Bildern
vorgestellt. Zunchst wird die Grauwert-Transformation erlutert, mit der aus einer RGBa
a
Reprsentation der korrespondierende Grauwert extrahiert werden kann. Anschlieend wera
den zwei grundlegende Algorithmen zur Vorverarbeitung der Bilder vorgestellt, die in leichter
Modikation im System Einsatz nden. Der letzte Teil dieses Abschnitts befasst sich mit
Algorithmen, die fr die Verarbeitung von Punktemustern (vgl. Abbildungen 23 und 24)
u
notwendig sind. Solche Muster werden zur Gewinnung von diskreten Punkten als Eingabe
fr die Kamerakalibrierung verwendet. Zur Lokalisation von Punkten auf einem Punktemuu
ster muss zunchst jeder schwarze Kreis als zusammenhngendes Gebiet identiziert werden.
a
a
Hierzu wird der Region-Growing-Algorithmus verwendet. Anschlieend werden die Zentren
der einzelnen Gebiete mittels Schwerpunktbestimmung Subpixel-genau berechnet.
3.1.1

Farbkonvertierung

Um den Grauwert eines im RGB-Farbmodell gegebenen Pixels zu bestimmen, muss die Farbinformation in das YUV-Farbmodell konvertiert werden. Diese Konvertierung ist durch eine
einfache lineare Transformation deniert:

Y
0.299
0.587
0.114
R
U = 0.147 0.289 0.437 G
V
0.615 0.515 0.100
B
Der Y-Wert im YUV-Modell deniert die Lichtintensitt eines Pixels und kann deshalb als der
a
korrespondierende Grauwert interpretiert werden. Somit erhlt man fr die Berechnung des
a
u
Grauwertes g eines im RGB-Farbmodell dargestellten Pixels die folgende lineare Beziehung:
g = 0.299 R + 0.587 G + 0.114 B
3.1.2

(1)

Binarisierung

Unter Binarisierung versteht man die Transformation eines Bildes in ein Schwarz-Wei-Bild.
Eine einfache und in vielen Fllen geeignete Methode, dies zu erreichen, ist die Schwellwerta
Segmentierung. Jedem Pixel wird, unabhngig von seiner Position, durch Vergleich seines
a
Grauwertes mit einem initial denierten Schwellwert t, ein neuer Grauwert zugewiesen. Sei
g(x, y) die Grauwertfunktion des zu transformierenden Bildes und g (x, y) die Grauwertfunktion des Ergebnisses der Binarisierung. Ausgehend von einer 8bit-Skala lautet die Transformationsfunktion dann:
255 : g(x, y) t
g (x, y) =
(2)
0 : sonst
14

7000

6000

Frequenz

5000

4000

3000

2000

1000

253

229

241

205

217

181

193

169

145

157

121

133

97

109

73

85

61

37

49

13

25

Intensitt

Abbildung 15: Beispiel eines bimodalen Histogramms


Die Eektivitt des Verfahrens hngt mageblich von der Wahl des Schwellwertes ab. Eine
a
a
aufwndige jedoch zuverlssige Methode zur Schwellwertbestimmung basiert auf der Analyse
a
a
des Histogramms eines Bildes. Bilder, die aus Objekten mit annhernd gleichem Grauwert
a
bestehen, welche sich vom Grauwert eines annhernd einheitlichen Hintergrundes abheben,
a
weisen ein bimodales Histogramm auf. Die Grauwerte der Pixel der Objekte bilden eines der
beiden Maxima, whrend die Pixel des Hintergrundes das zweite Maximum bilden. Abbila
1 zeigt ein typisches Beispiel eines solchen bimodalen Histogramms. Intuitiv liegt der
dung 15
optimale Schwellwert im Minimum zwischen den beiden Maxima. [SHB99]
Erfahrungsgem liegen die beiden Maxima nherungsweise im Grauwert des dunkelsten und
a
a
des hellsten Pixels. Ferner liegt das oben angesprochene Minimum nherungsweise in der
a
Mitte dieser beiden Grauwerte. Aus mathematischer Sicht nimmt das Minimum der Grauwertdistanzen zu den beiden Maxima in der Mitte seinen maximalen Wert an, sodass die
folgende Formel insbesondere bei der Betrachtung von kleinen Bildregionen eine robuste und
ezient berechenbare Nherung fr den optimalen Schwellwert liefert:
a
u
t=
3.1.3

min g(x, y) + max g(x, y)


2

(3)

Spreizung

Die Spreizung ist eine Transformation, die das Histogramm eines Bildes auf das volle Spektrum der Grauwerte erweitert. Die Anzahl der Diskretisierungen eines Bildes bleibt von dieser
Transformation unberhrt, d.h. der Informationsgehalt eines Bildes ist invariant gegenber
u
u
der Spreizung. Jedoch knnen durch die Spreizung mehr Details fr das Auge sichtbar geo
u
macht werden, da das Auge grere Grauwertdistanzen besser wahrnehmen kann. Die Spreio
1

Das Histogramm wurde mit einem eigenen Programm generiert und in Microsoft Excel als Tabelle importiert

15

zung kann auch verwendet werden, um Muster auf eine Normalform zu bringen, ohne den
Informationsgehalt dabei zu verringern, sodass auf Basis der so gewonnen Normalform Vergleiche durchfhrbar sind. Sei g(x, y) die Grauwertfunktion des zu transformierenden Bildes
u
und g (x, y) die Grauwertfunktion des Ergebnisses der Spreizung. Ausgehend von einer 8bitSkala lautet die Transformationsfunktion dann:
g(x, y) min g(x, y)
g (x, y) =
255
(4)
max g(x, y) min g(x, y)
Die auf diese Weise gewonnenen Grauwerte mssen weiterhin auf ganzzahlige Werte gerundet
u
werden.
3.1.4

Region-Growing

Der Region-Growing-Algorithmus ist ein Standardverfahren zur Segmentierung von Bildern


in zusammenhngende Gebiete. Initial wird eine Menge von Saatpunkten bestimmt, auf deren
a
Wahl in Abschnitt 3.1.5 eingegangen wird. Jeder Saatpunkt erhlt eine ID und wird auf eine
a
Stack-Datenstruktur gelegt. Alle anderen Pixel erhalten die ID 0. Nun wird in einer Schleife
das jeweils oberste Element des Stacks entfernt und sowohl sein Grauwert als auch seine ID
mit denen der vier direkten Nachbarpixel verglichen. Falls die ID des aktuell betrachteten
Pixels grer ist und der Betrag der Dierenz der Grauwerte unter einem zu denierenden
o
Schwellwert liegt, erhlt das Nachbarpixel die ID und den Grauwert des aktuellen Pixels und
a
wird auf den Stack gelegt. [Br01]
a
Der Region-Growing-Algorithmus ist in Algorithmus 1 in Pseudocode dargestellt. Dabei bezeichnen x, y die Koordinaten des Saatpunktes und id die ID der entsprechenden Region.

3.1.5

Schwerpunktbestimmung

Fr Muster, die eine symmetrische Verteilung von Grauwerten aufweisen, kann deren lokaler
u
Schwerpunkt zur Berechnung des Zentrums verwendet werden. Der Schwerpunkt wird als
gewichtetes Mittel der Pixelkoordinaten bestimmt:
n

(xi gi )
xm =

i=1

(5)

gi
i=1
n

(yi gi )
ym =

i=1

(6)

gi
i=1

wobei n die Anzahl der Pixel der Region bezeichnet und gi den Grauwert des Pixels mit den
Koordinaten xi , yi . [Luh00]
Die Bercksichtigung der Grauwerte fhrt jedoch erfahrungsgem zu schlechteren Ergebnisu
u
a
sen, weshalb gi als konstant vorausgesetzt werden kann. Somit erhlt man:
a
xm =
ym =

1
n
1
n
16

xi

(7)

yi

(8)

i=1
n
i=1

Algorithmus 1 RegionGrowing(image, x, y, id)


image[x][y].id := id
stack.push(ref image[x][y])
while (stack = ) do
(x, y, g, id) := stack.pop()
if (x > 0 AND image[x 1][y].id < id AND |image.[x 1][y].g g| < threshold) then
image[x 1][y].id := id
image[x 1][y].g := g
stack.push(ref image[x 1][y])
end if
if (y > 0 AND image[x][y 1].id < id AND |image.[x][y 1].g g| < threshold) then
image[x][y 1].id := id
image[x][y 1].g := g
stack.push(ref image[x][y 1])
end if
if (x < image.width 1 AND image[x + 1][y].id < id AND |image.[x + 1][y].g g| <
threshold) then
image[x + 1][y].id := id
image[x + 1][y].g := g
stack.push(ref image[x + 1][y])
end if
if (y < image.height 1 AND image[x][y + 1].id < id AND |image.[x][y + 1].g g| <
threshold) then
image[x][y + 1].id := id
image[x][y + 1].g := g
stack.push(ref image[x][y + 1])
end if
end while

17

3.2

Kamera- und Projektorkalibrierung

Um eine Kamera fr photogrammetrische Zwecke nutzen zu knnen, muss diese zunchst


u
o
a
kalibriert werden. Selbiges gilt fr Projektoren, falls sie fr die aktive Musterprojektion einu
u
gesetzt werden, da hier die Geometrie des Musters und die Abbildungsfunktion des Projektors
in die Berechnungen einieen. Eine Kamera bzw. einen Projektor zu kalibrieren, bedeutet
die zu Grunde liegende Abbildungsfunktion f zu berechnen, die jeden 3D-Punkt der realen
Welt auf den entsprechenden 2D-Bildpunkt des CCD-Chips bzw. des Musters, abbildet. Im
Folgenden werden die vorzustellenden Verfahren auf Kameras bezogen, sie sind analog fr
u
die Kalibrierung von Projektoren anzuwenden.
3.2.1

Testfeldkalibrierung

Bei der Testfeldkalibrierung werden die Parameter der Abbildung f uber eine Vielzahl von

Punktkorrespondenzen (PW elt , PBild ) berechnet. Die Gewinnung solcher Punktepaare erfolgt
durch die Aufnahme eines geeigneten Testfeldes, uber das apriori-Wissen uber die Lage der

einzelnen Punkte in einem festen dreidimensionalen Weltkoordinatensystem vorhanden ist.


Wird ein ebenes Testfeld gewhlt, so muss dieses in mindestens zwei Positionen bzw. Oriena
tierungen aufgenommen werden, da die Algorithmen zur Berechnung der Parameter nichtkoplanare Daten verlangen.
Das wahrscheinlich bekannteste Kalibrierverfahren nach Tsai [Tsa87] bentigt zustzlich zu
o
a
den Punktkorrespondenzen als Initialbedingung den CCD-Chip betreende Kamerakonstanten. Das Verfahren zeichnet sich durch die Modellierung radialer Linsenverzerrung aus, der
Implementierungs- und Rechenaufwand sind jedoch verhltnismig hoch. In Abschnitt 3.2.2
a
a
wird ein leicht zu implementierender und ezienter Algorithmus vorgestellt, der keine Initialbedingung bentigt, jedoch keinerlei Verzerrungsparameter bercksichtigt. Der im voro
u
liegenden System eingesetzte Algorithmus stellt diesbezglich eine Erweiterung um radiale
u
Verzerrungsparameter dar und wird in Abschnitt 4.1 erlutert.
a
3.2.2

Direkte Lineare Transformation

Die DLT (Direkte Lineare Transformation) ist die einfachste Methode fr die Berechnung der
u
Kameraparameter in einem Testfeld-basierten Kalibrierverfahren, modelliert jedoch keinerlei
Verzerrungsparameter. Der Algorithmus basiert auf einem Kleinste-Quadrate-Ansatz, weshalb zunchst die perspektivische Projektion als lineare Transformation formuliert werden
a
muss. Dies gelingt durch die Verwendung homogener Koordinaten. Seien x, y, z die kartesischen Koordinaten eines Punktes im Weltkoordinatensystems und n, m die Koordinaten des
korrespondierenden 2D-Punktes im Bildkoordinatensystem. t sei ein fr jeden Objektpunkt
u
spezischer Mastabsfaktor, dann lsst sich die Abbildungsfunktion der Kamera als lineare
a
Abbildung mit der Transformationsmatrix A R(3,4) wie folgt darstellen:

x
nt
L1 L2 L3 L4
y
m t = A , A = L5 L6 L7 L8
(9)
z
t
L9 L10 L11 L12
1
Notiert man die in (9) enthaltenen drei Gleichungen explizit, so erhlt man:
a
n t = L1 x + L2 y + L3 z + L4
m t = L5 x + L6 y + L7 z + L8
t = L9 x + L10 y + L11 z + L12
18

Da alle reellen Vielfachen der Matrix A in Bezug auf Gleichung (9) quivalent sind (t ist
a

variabel), kann o.B.d.A. ein Parameter normiert werden. Ublicherweise wird L12 := 1 gewhlt.
a
Durch Division folgen hiermit die Grundgleichungen der DLT:
n =
m =

L1 x + L2 y + L3 z + L4
L9 x + L10 y + L11 z + 1
L5 x + L6 y + L7 z + L8
L9 x + L10 y + L11 z + 1

(10)
(11)

Durch Multiplikation mit dem Nenner erhlt man schlielich:


a
n = L1 x + L2 y + L3 z + L4 L9 x n L10 y n L11 z n

(12)

m = L5 x + L6 y + L7 z + L8 L9 x m L10 y m L11 z m

(13)

Ausgehend von n 6 Punktepaaren erhlt man das folgende uberstimmte LGS, das sich mit
a

der Methode der kleinsten Quadrate lsen lsst (vgl. Anhang B):
o
a

x1
0
.
.
.

y1
0
.
.
.

z1
0
.
.
.

xn yn zn
0 0 0

1 0 0 0
0 x1 y1 z1
. .
.
.
. .
.
.
. .
.
.
1 0 0 0
0 xn yn zn

0 n1 x1 n1 y1
1 m1 x1 m1 y1
.
.
.
.
.
.
.
.
.
0 nn xn nn yn
1 mn xn mn yn

n1 z1


m1 z1

.
.

.

nn zn

mn zn

L1
L2
L3
L4
L5
L6
L7
L8
L9
L10
L11

n1
m1
.
.
.
nn
mn

Mit den so gewonnenen DLT-Parametern lsst sich der zu einem im Weltkoordinatensystem


a
beschriebenen 3D-Punkt korrespondierende 2D-Bildpunkt direkt mit Hilfe der Gleichungen
(10) und (11) bestimmen. Mchte man anhand der DLT-Parameter die zu einem Bildpunkt
o
(n, m) zugehrige Gerade im Weltkoordinatensystem bestimmen, so ist das folgende, durch
o
Umformung der Gleichungen (12) und (13) entstandene, unterbestimmte LGS lsen:
o

L9 n L1 L10 m L2 L11 n L3
L9 m L5 L11 m L6 L11 m L7

x
y =
z

L4 n
L8 m

(14)

Zu den Vorteilen der DLT zhlt die einfache direkte Bestimmung der Abbildungsparameter
a
mit Hilfe von numerischen Standard-Algorithmen. Es sind keine initialen Nherungswerte der
a
zu bestimmenden Parameter notwendig. Nachteilig ist, dass die DLT uberparametrisiert ist;

die elf DLT-Parameter beschreiben eine photogrammetrische Abbildung mit sieben Kenndaten. Weiterhin kommt es zu singulren oder schlecht konditionierten Gleichungssystemen,
a
wenn die Punkte PW elt koplanar verlaufen oder wenn die Aufnahmekonstellation dazu fhrt,
u
dass der Nenner der Gleichungen (10) und (11) nahe Null wird [Luh00].
Es sei angemerkt, dass sich die Genauigkeit der DLT durch die Modellierung radial-symmetrischer Verzerrung deutlich verbessern lsst. Im noch vorzustellenden Kameramodell nach
a
Hoppe et al., dessen Parameter auf Basis der DLT-Parameter berechnet werden, wird eine
solche Modellierung vorgenommen.
19

3.3

Korrespondenzproblem

Das Korrespondenzproblem kann als ein Suchproblem formuliert werden: zu einem gegebenen
Element in einem Bild F wird das korrespondierende Element in einem Bild G gesucht. Dieses
Problem ist nur dann lsbar, wenn zwei Voraussetzungen erfllt sind:
o
u
Der dem Element aus Bild F entsprechende Szenenpunkt ist in Bild G sichtbar.
Sich entsprechende Regionen der Bilder F und G sind sich ahnlich.

Ublicherweise werden die Algorithmen zur Lsung des Korrespondenzproblems in zwei Klaso
sen eingeteilt, merkmalsbasierte und auf Korrelation basierende Verfahren. [TV98]
Merkmalsbasierte Verfahren verwenden numerische und symbolische Eigenschaften, wie z.B.

Umfang, Flche, Kompaktheit, Form, Farbe, und prfen diese auf Ubereinstimmung. Solche
a
u
Verfahren sind vor allem dazu geeignet, bekannte Gegenstnde oder geometrische Objekte
a
bekannter Gre, wie Linien oder Kreise, in einem Bild wieder zu erkennen. Um eine Vielzahl
o
von Korrespondenzen in beliebigen sich entsprechenden Bildern berechnen zu knnen, mssen
o
u
Korrelationsalgorithmen eingesetzt werden. Diese sollen im Folgenden vorgestellt werden.

Auf Korrelation basierende Verfahren haben alle gemeinsam, dass die in Ubereinstimmung

zu bringenden Elemente Fenster fester Gre sind. Das Ahnlichkeitsma ist ein Ma der Koro
relation zwischen den Fenstern in beiden Bildern. [TV98]
Im Folgenden sei f (x, y) die Grauwertfunktion der Vorlage F und g(x, y) die Grauwertfunktion des Suchbildes G.
3.3.1

Kreuzkorrelation und SSD

Im Folgenden werden die Kreuzkorrelation und die SSD-Korrelation (Sum of Squared Dierences) nach den Darstellungen aus [TV98] vorgestellt.
Sei 2W + 1 die Kantenlnge des Suchfensters, seien i, j die Koordinaten eines Punktes in
a
F und d = (d1 , d2 ) ein Verschiebungsvektor innerhalb des Suchraums. Abhngig von der
a

Wahl der Funktion (u, v) deniert die Funktion c(i, j, d1 , d2 ) ein Ahnlichkeitsma fr die
u
Korrelation:
W

c(i, j, d1 , d2 ) =

(f (i + k, j + l), g(i + k + d1 , j + l + d2 ))

(15)

k=W l=W

Die zwei meist verwendeten Funktionen fr (u, v) sind


u
(u, v) = uv,

(16)

womit man die Kreuzkorrelation zwischen dem Fenster in Bild F und dem Suchfenster in
Bild G erhlt, und
a
(u, v) = (u v)2 ,
(17)
womit die Summe der quadrierten Dierenzen (SSD) berechnet wird. Gesucht wird derjenige

Punkt x, y in G, der das Ahnlichkeitsma c(i, j, d1 , d2 ) maximiert.


Es sei angemerkt, dass die beiden Mglichkeiten fr in Gleichung (16) und (17) dieselben
o
u
Korrespondenzen berechnen, falls die Energie jedes Fensters im Suchbild G konstant ist, wobei
die Energie deniert ist als die Summe der Quadrate der Intensitten in einem Fenster. In
a
20

den meisten Fllen trit dies nicht zu, und die SSD ist normalerweise der Kreuzkorrelation
a
vorzuziehen. Eine Alternative besteht in der Anwendung der normalisierten Kreuzkorrelation,
welche jedoch aufgrund des hheren Rechenaufwands fr den Einsatz im vorliegenden System
o
u
ungeeignet ist. [TV98]
In der obigen Darstellung wurde die negative Summe der quadrierten Dierenzen berechnet,
um zu einer einheitlichen Darstellung zu gelangen. Im Folgenden wird jedoch die positive
Summe berechnet, sodass die SSD ein Fehlerma liefert, das es zu minimieren gilt:
W

(f (i + k, j + l) g(i + k + d1 , y + l + d2 ))2

ssd(i, j, d1 , d2 ) =

(18)

k=W l=W

3.3.2

Korrelation nach der Methode der kleinsten Quadrate

Die bereits erluterten Korrelationsalgorithmen sind ezient, weisen jedoch zwei Nachteile
a
auf: sie sind weder in der Lage perspektivische Verzerrungen zu erkennen noch vermgen sie
o
Subpixel-Ausung zu erreichen. Der bekannteste Algorithmus zur Lsung beider Probleme
o
o
basiert auf der Methode der kleinsten Quadrate und wurde 1984 von F. Ackermann publiziert
und 1985 von A. W. Grn zu einem adaptiven Verfahren weiterentwickelt [Ack84] [Gru85].
u
Im Folgenden wird der Basisalgorithmus vorgestellt, die Darstellung ist an die Notation in
[Luh00] angelehnt.
Seien f (x, y) und g(x, y) wie in Abschnitt 3.3 deniert. Im Folgenden werden nur Bildausschnitte betrachtet. Sei g (x, y) die Grauwertfunktion des zum betrachteten Ausschnitt aus
der Vorlage F korrespondierenden entzerrten Ausschnitts im Suchbild G. Es wird davon
ausgegangen, dass diese Ausschnitte bis auf eine durch Rauschen verursachte Dierenz e(x, y)
identisch sind:
f (x, y) e(x, y) = g (x, y)

(19)

Die Beziehung zwischen dem Suchbild und dem entzerrten Ausschnitt wird durch eine Translation und eine Antransformation modelliert:
g (x, y) = g(x , y )

= a0 + a1 x + a2 y

(20)

= b0 + b1 x + b2 y

Um die gesuchten Parameter nach der Methode der kleinsten Quadrate bestimmen zu knnen,
o
muss g(x, y) linearisiert werden. Zusammengefasst ergeben sich fr die Verbesserungsgleichunu
gen
f (x, y) e(x, y) = gi (x, y) + gx da0 + gx x da1 + gx y da2 + gy db0 + gy x db1 + gy y db2 (21)

gx :=
gy :=

gi (x, y)
= gi (x + 1, y) gi (x, y)
x
gi (x, y)
= gi (x, y + 1) gi (x, y),
y
21

Das uberbestimmte LGS fr die Lsung nach der Methode der kleinsten Quadrate lautet
u
o

dann:

da0
(1)
da

(1)
(1)
(1)
(1)
(1)
1
gx
gx x(1) gx y (1) gy
gy x(1) gy y (1)
f (x(1) , y (1) ) gi (x(1) , y (1) )

.
da2

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
db0 =

(n)
(n) (n)
(n) (n)
(n)
(n) (n)
(n) (n)
(n) , y (n) ) g (x(n) , y (n) )
f (x
db1
i
gx
gx x
gx y
gy
gy x
gy y
db2
wobei die Hochzahlen (i) den Punkt mit den Koordianten (x(i) , y (i) ) bzw. die Anwendung
von gx respektive gy in diesem Punkt identizieren, mit i {1, ..., n}. Da g(x, y) im Allgemeinen nicht linear ist, muss die Lsung iterativ berechnet werden. Hierzu wird zu Beginn
o
jeder Iteration g(x, y) mit den aktuellen Parametern a0 , a1 , a2 , b0 , b1 , b2 und durch Anwendung der Gleichung (20) entzerrt, gi (x, y) steht fr die entzerrte Grauwertfunktion zu Beginn
u
der (i + 1)-ten Iteration. Da die berechneten entzerrten Koordinaten x , y im Allgemeinen
nicht ganzzahlige Werte sind, mssen die Grauwerte in geeigneter Weise interpoliert werden,
u
z.B. durch bilineare Interpolation. In der Regel gengt fr die Initialwerte der Ansatz:
u
u
a0 = a0 = b0 = b0 = 0, a0 = b0 = 1
0
2
0
1
1
2
Am Ende jeder Iteration werden die inkrementellen Verbesserungen da0 , da1 , da2 , db0 , db1 , db2
zu den Parametern a0 , a1 , a2 , b0 , b1 , b2 addiert. Die Iteration kann entweder nach einer festen
Anzahl von Durchlufen abgebrochen werden oder wenn die Betrge der inkrementellen Vera
a
besserungen ein Minimum unterschreiten. In dem meisten Fllen sind nach Ablauf der Itea
ration nur die Shift-Parameter a0 und b0 von Interesse. Als Fehlerma kann die Summe der
quadrierten Dierenzen (SSD) von f (x, y) und gi (x, y) aus Abschnitt 3.3.1 verwendet werden.
Der Konvergenzradius des Algorithmus betrgt im Allgemeinen ca. 2 3 Pixel, abhngig von
a
a
der tatschlichen Linearitt von g(x, y). Aus diesen Grnden lsst sich eine zustzliche Suche
a
a
u
a
a
nicht vermeiden. Der verwendete Lsungsansatz fr dieses Problem wird in Abbschnitt 4.4.1
o
u
detailliert erlutert.
a
Die nachstehende Abbildung 16 zeigt die Eektivitt des beschriebenen Algorithmus. Es sind
a
drei Beispiele zeilenweise abgebildet. In der linken Spalte sind die Bildausschnitte der Vorlage
F abgebildet, in der mittleren Spalte der korrespondierende Bildausschnitt aus dem Suchbild
G und in der rechten Spalte der entzerrte Ausschnitt, beschrieben durch die Grauwertfunktion g (x, y). Verwendet wurden fr die Erstellung der Abbildung jeweils drei Iterationen und
u
eine Fenstergre von 23 23 Pixel. Bei der Entzerrung wurde keine Interpolation der Grauo
werte berechnet, stattdessen wurden die entzerrten Koordinaten x , y gerundet. Der mittels
SSD berechnete Fehler konnte damit jeweils von ca. 2500n auf ca. 350n reduziert werden, mit
n = 232 = 529.

22

Abbildung 16: Beispiel zur Korrelation nach der Methode der kleinsten Quadrate

3.4

Epipolar-Geometrie

Die einem Stereokamerasystem zu Grunde liegende Epipolar-Geometrie ist in Abbildung 17


dargestellt. Die Abbildung zeigt zwei Kameras, die nach dem Mattscheibenmodell modelliert
sind, die Projektionszentren sind mit Zl und Zr beschriftet. Beide Kameras betrachten den
selben Punkt P , die jeweiligen Abbildungen in deren Bildebene sind mit pl und pr bezeichnet. Verbindet man die beiden Projektionszentren Zl und Zr und schneidet diese Gerade
mit den Bildebenen, so erhlt man die Epipole el und er . Die Epipolar-Linien erhlt man
a
a
durch Verbinden der Punkte pl , el respektive pr , er . Sie sind deniert durch den Schnitt der
Epipolar-Ebene, gebildet durch die drei Punkte Zl , Zr , P , mit der jeweiligen Bildebene.

Abbildung 17: Epipolar-Geometrie


Der praktische Nutzen der Epipolar-Geometrie liegt in der Reduzierung des Suchraums des
Korrespondenzproblems auf eine Dimension. Fr den Bildpunkt pl in der Bildebene der linu
23

ken Kamera muss der korrespondierende Punkt auf der entsprechenden Epipolar-Linie in der
Bildebene der rechten Kamera liegen und umgekehrt. Das Suchproblem wird dadurch auf ein
Problem linearer Komplexitt reduziert. Dies bedeutet nicht nur eine signikante Ezienza
steigerung der Korrelation, sondern gleichzeitig auch eine Steigerung der Robustheit, da eine
Reduzierung des Suchraums auch die Wahrscheinlichkeit der Berechnung falscher Korrespondenzen verringert. [TV98]
Auf die konkrete Berechnung der Epipolar-Linien wird an dieser Stelle nicht eingegangen,
da in dem vorliegenden System hierzu eine spezielle Methode entwickelt wurde. Die entsprechende Vorgehensweise wird in Abschnitt 4.4.2 erlutert.
a

3.5

Triangulation in Stereokamerasystemen

Die Berechnung der Triangulation in einem Stereokamerasystem kann auf mehrere Arten
erfolgen. Geometrisch anschaulich und unabhngig vom gewhlten Kameramodell lsst sich
a
a
a
das Problem jedoch einheitlich formulieren. Existieren fr einen beliebigen im Weltkoordinau
tensystem beschriebenen 3D-Punkt zwei Abbildungen auf die Bildebene zweier kalibrierter
Kameras, so kann jeweils die Sichtgerade aller mglichen korrespondierenden Punkte im Welto
koordinatensystem berechnet werden. Der Punkt P ist dann durch den Schnitt dieser Geraden
deniert. In der Praxis jedoch schneiden sich die Geraden aufgrund von Ungenauigkeiten im
Allgemeinen nicht exakt in einem Punkt (vgl. Abbildung 18). Diese Ungenauigkeiten haben
ihre Ursache sowohl im Grundrauschen des CCD-Chips als auch in der Tatsache, dass dieser
eine beschrnkte Ausung besitzt. Der Einsatz von Algorithmen mit Subpixel-Ausung
a
o
o
kann dieses Problem nur nherungsweise lsen.
a
o

g
R
d

P
S

h
Abbildung 18: Darstellung zweier windschiefer Geraden
Gegeben seien die zwei oben genannten Sichtgeraden g und h in Parameterdarstellung:
g : x=a+r u
h : x=b+s v
Unter der Voraussetzung, dass g und h nicht windschief sind, folgt aus geometrischer Betrachtung, dass genau eine krzeste Verbindungsstrecke d zwischen g und h existiert, die auf
u
beiden Geraden senkrecht steht. Der gesuchte Punkt liegt in der Mitte dieser Strecke, da hier
das Maximum der Abstnde zu beiden Geraden sein Minimum annimmt. Eine mgliche Vaa
o
riante fr die Berechnung dieses Punktes basiert auf einem Kleinste-Quadrate-Ansatz. Setzt
u
man die Gleichungen der Geraden g und h gleich, so erhlt man:
a
a+r u=b+s v
24

(22)

Durch Umformung folgt:


ab=s vr u
Daraus ergibt sich das folgende uberbestimmte LGS:

a1 b1
u1 v1

u2 v2 r
= a2 b2
s
u3 v3
a3 b3

(23)

Da die optimale Lsung bezglich der euklidischen Norm dieses linearen Gleichungssystems
o
u
auch Gleichung (22) optimal lst, denieren die Lsungen r und s genau die Endpunkte R
o
o
und S der krzesten Verbindungsstrecke d. Damit ist der Ortsvektor des gesuchten Punktes
u
P schlielich deniert durch:
a + r u + b + s v
p=
(24)
2
Schneiden sich die Geraden g und h, so liefert die Ausgleichsrechnung exakt deren Schnittpunkt. Es gengt also, den Fall g h auszuschlieen, der praktisch auf Basis einer korrekt
u
bestimmten Korrespondenz bei einem sinnvoll gewhlten Triangulationswinkel trotz eventua
eller Abweichungen nicht eintreten kann.

3.6

Registrierung (Iterative Closest Point)

Unter der Registrierung zweier sich uberlappender dreidimensionaler Datenstze versteht


a

man die Uberfhrung des Ist-Datensatzes in das Koordinatensystem des Soll-Datensatzes.


u
Hierzu muss die Transformation zwischen den beiden Koordinatensystemen berechnet werden, bestehend aus einer Rotation und einer Translation. Der bekannteste Ansatz zur Lsung
o
dieses Problems ist der ICP-Algorithmus (Iterative Closest Point) [BM92], der im Folgenden
vorgestellt werden soll.
3.6.1

Grundalgorithmus
n

Sei P = {pi }1 p der Ist-Datensatz und M = {mi }nm der Soll-Datensatz. Im Allgemeinen gilt
1
np = nm . Gesucht sind die Rotation R und die Translation t, welche die Datenstze P und
a

M bestmglich in Ubereinstimmung bringen:


o
M = R P + t,

(25)

wobei diese Schreibweise meint, dass die Rotation R und die Translation t auf jeden Punkt aus

P angewandt werden. Im Allgemeinen sind die Datenstze nicht exakt in Ubereinstimmung zu


a
bringen, weshalb Gleichung (25) nach dem Prinzip der kleinsten Quadrate zu interpretieren
ist.
Der nchste Punkt (closest point) im Soll-Datensatz M zu einem Punkt p aus dem Ista
Datensatz P ist deniert durch:
cp(p) = min |m p|
mM

(26)

In jeder Iteration des ICP-Algorithmus wird zunchst zu jedem Punkt aus dem Ist-Datensatz
a
der nchste Punkt aus dem Soll-Datensatz bestimmt. Fr die resultierende Menge von Punkta
u
korrespondenzen wird dann die optimale Transformation im Sinne der euklidischen Norm
berechnet. Am Ende jeder Iteration wird diese Transformation auf jeden Punkt des IstDatensatzes angewandt. Die Iteration wird abgebrochen, wenn eine der folgenden Bedingungen erfllt ist:
u
25

Der durchschnittliche Fehler d =

1
np

np

|yk pk | ist hinreichend klein.


k=1

Die Dierenz zwischen zwei aufeinander folgenden Iterationen ist hinreichend klein.
Die maximale Anzahl der erlaubten Iteration wurde erreicht.

Der ICP-Grundalgorithmus ist in Algorithmus 2 in Pseudocode dargestellt, wobei aus Grnden


u
der besseren Lesbarkeit eine feste Anzahl von n Iterationen zu Grunde gelegt wird. Der Algorithmus transformiert die Punkte aus P in das Koordinatensystem der Punktmenge M.
Zustzlich werden die akkumulierte Rotation R und Translation t ausgegeben, die diese
a
Transformation beschreiben. Ferner sei I R(3,3) die Einheitsmatrix und o R3 der Nullvektor.
Algorithmus 2 ICP(P, M)
R := I
t := o
for i := 1 to n do
Y := {m M | p P : m = cp(p)}
np

(R, t) = min

R,t k=1

|yk Rpk t|2

P := R P + t
R := R R
t := t + t
end for

3.6.2

Berechnung des nchsten Punktes


a

Die Berechnung des nchsten Punktes stellt das Herzstck und gleichzeitig den Flaschena
u
hals des ICP-Algorithmus dar. Die Wahl des Distanzmaes beeinusst die Eektivitt des
a
Algorithmus, die Wahl des Suchalgorithmus die Ezienz. In [RL01] werden verschiedene
Distanzmae und die damit verbundenen Suchalgorithmen untersucht und miteinander ver
glichen. Im Folgenden soll ein zusammenfassender strukturierter Uberblick gegeben werden.
Als mgliche Distanzmae zwischen zwei Punkten p P und m M werden genannt:
o
Distanz zwischen p und m
Distanz von p zu der Ebene durch m mit der Normalen in m
Einbezug der Intensitten oder Farbwerte der korrespondierenden 2D-Punkte zu p und
a
m
Winkel zwischen den Normalen der Ebenen durch p und m

Diese Distanzmae knnen bzw. mssen kombiniert werden. Die Grauwertdistanz allein ist
o
u
beispielsweise kein hinreichend zuverlssiges Ma. Die Wahl hngt auch vom konkreten Sya
a
stem ab. In einem System wie das vorliegende, das keinerlei Texturinformation akquiriert, ist
der Einbezug der Intensitten bzw. Farbwerte nicht mglich.
a
o
26

Der Algorithmus fr die Suche des nchsten Punktes hngt auch von der Wahl des Distanzu
a
a
maes ab. Grundstzlich knnen jedoch unterschieden werden:
a
o
Suche in einer Liste mit einem Aufwand von O(n)
Beschleunigte Suche mit einem Aufwand von O(log n) durch Verwendung eines kd-tree
Projektion auf eine geeignet diskretisierte Ebene und anschlieende Suche in einem
Umkreis fester Gre mit einem Aufwand von insgesamt O(1)
o

Die Aufwandsangaben beziehen sich hierbei auf die Berechnung eines Punktes in Bezug auf
die Anzahl der Punkte in M, also nm . Folgerichtig erhlt man den Aufwand der Gesamtsuche
a
fr alle Punkte durch Multiplikation mit np . Es sei angemerkt, dass fr die Verwendung der
u
u
letztgenannten Variante in O(1) eine spezielle Abstimmung auf das System notwendig ist.
Ferner knnen im Allgemeinen komplette 3D-Oberchenmodelle, die sich nicht eineindeutig
o
a
auf eine Ebene projizieren lassen, mit dieser Variante nicht korrekt registriert werden. Fr
u
eine weiterfhrende Erluterung der mglichen Verfahren und die Darstellung der Ergebnisse
u
a
o
wird auf die Literatur verwiesen. [RL01]
3.6.3

Berechnung der optimalen Transformation

Die Berechnung der optimalen Transformation kann auf mehrere Arten erfolgen. Lsungso
methoden, die auf der Singulrwertzerlegung [AHB87], auf Einheits-Quaternionen [Hor87]
a
und auf dualen Quaternionen [WS91] basieren, wurden von Eggert et al. bezglich ihrer
u
numerischen Genauigkeit und Stabilitt untersucht [ELF97], mit dem Ergebnis, dass die Una
terschiede gering ausfallen.
Im Folgenden soll die Methode nach Horn vorgestellt werden, da sie der Implementierung
im vorliegenden System zu Grunde liegt. Dabei wird auf eine ubersichtliche Darstellung in

Hinblick auf die Implementierung des Algorithmus Wert gelegt, eine detaillierte Herleitung
ist [Hor87] zu entnehmen.
Gegeben seien die Punktmengen P = {pi }n und Y = {yi }n aus Abschnitt 3.6, wobei gilt
1
1
n := np und cp(pi ) = yi , mit i {1, ..., n}. Es erweist sich als ntzlich, alle Punkte auf die
u
Schwerpunkte zu beziehen, deniert durch:

p =

1
n

pi

(27)

yi

(28)

pi = pi p

(29)

y i = yi y

(30)

y =

1
n

i=1
n
i=1

Die neuen Koordinaten ergeben sich damit zu:

Es wird dann die Matrix M R(3,3) deniert

M=

pi yi
i=1

Sxx Sxy Sxz


= Syx Syy Syz ,
Szx Szy Szz
27

(31)

deren Elemente die Summen der Produkte der Koordinaten der Punkte aus Y sind. Diese
Matrix enthlt smtliche Information, die fr die Lsung des Kleinste-Quadrate-Problems fr
a a
u
o
u
die Rotation bentigt wird. Die symmetrische Matrix N R(4,4) wird dann deniert durch:
o

Sxx + Syy + Szz


Syz Szy
Szx Sxz
Sxy Syx

Syz Szy
Sxx Syy Szz
Sxy + Syx
Szx + Sxz
(32)
N =

Szx Sxz
Sxy + Syx
Sxx + Syy Szz
Syz + Szy
Sxy Syx
Szx + Sxz
Syz + Szy
Sxx Syy + Szz
In [Hor87] wird gezeigt, dass der korrespondierende Eigenvektor zum grten Eigenwert von
o
N die Einheits-Quaternion ist, welche die optimale Rotation beschreibt. Das verwendete
numerische Verfahren zur Eigenwertzerlegung ist die Jacobi-Iteration. Die Implementierung
wurde aus den Quellen der statischen Methode vtkMath::JacobiN der Bibliothek VTK entnommen und geringfgig fr die spezielle Anwendung auf 4 4-Matrizen optimiert, die entu
u
sprechenden Datenstrukturen und deren Allokation betreend [Kita]. Sei e = (w, x, y, z)T
der Eigenvektor zum grten Eigenvektor. Die Rotationsmatrix R berechnet sich dann zu:
o

ww + xx yy zz
2(wz + xy)
2(wy + xz)

2(wz + xy)
ww xx + yy zz
2(wx + yz)
R=
(33)
2(wy + xz)
2(wx + yz)
ww xx yy + zz
Die optimale Translation ergibt sich dann aus der Dierenz des rotierten Schwerpunktes der
Punktmenge P und des Schwerpunktes der Punktmenge Y:

t=yR p

(34)

Es sei angemerkt, dass fr den Sonderfall der exakten Koplanaritt beider Datenstze die
u
a
a
Matrix M singulr wird und die Berechnung der Einheits-Quaternion (w, x, y, z) auf andere
a
Weise erfolgen muss, indem die Rotation zwischen den Ebenen explizit uber die Normalenvek
toren berechnet wird. Als Indikator fr diesen Fall kann der Sachverhalt verwendet werden,
u
dass die beiden grten berechneten Eigenwerte identisch sind.
o
Da das Eintreten dieses Sonderfalls praktisch bedeutet, dass die Datenstze zu wenig Merka
male fr eine zuverlssige und korrekte Registrierung enthalten, werden im vorliegenden Syu
a
stem koplanare Punktmengen verworfen. Zudem kann eine exakte Koplanaritt in realen
a
Datenstzen praktisch nur dann vorliegen, wenn der entsprechende Datensatz aus drei Punka
ten besteht. Dieser Fall kann ohnehin ausgeschlossen werden.
Aus diesen Grnden wird fr die Berechnung der Einheits-Quaternion in diesem Spezialfall
u
u
auf [Hor87] verwiesen.

28

4
4.1

Umsetzung der Algorithmik


Kamera-/Projektormodell nach Hoppe et al.

Das Kamera- und Projektormodell nach Hoppe et al. [HKRW02] modelliert in erster Linie
die zentralperspektive Projektion des CCD-Chips respektive der LCD-Matrix auf diejenige
Ebene E, die durch den Ursprung des Weltkoordinatensystems verluft. Diese Projektion vom
a
Bildkoordinatensystem in das Weltkoordinatensystem wird beschrieben durch die Abbildung
p(n, m) = a(n n0 ) + b(m m0 ),

(35)

wobei n, m die Koordinaten eines beliebigen Punktes im Bildkoordinatensystem sind und


n0 , m0 die Koordinaten der Projektion des Projektionszentrums Z auf die Ebene des Bildkoordinatensystems sind. Die Vektoren a, b spannen gerade ein Pixel auf. Man erhlt so die
a
Beziehungen
= a(nf n0 ) + b(mf m0 )

(36)

xd = a(nd n0 ) + b(md m0 )

(37)

xu = a(nu n0 ) + b(mu m0 ),

(38)

wobei nf , mf die Bildkoordinaten der orthogonale Projektion des Projektionszentrums Z auf


die Ebene des Bildkoordinatensystems sind. Somit ist f der Ortsvektor der orthogonalen
Projektion von Z auf E. Die verzerrten (distorted ) Bildkoordinaten eines Punktes (so wie
sie auf dem Bildschirm sichtbar sind) werden durch nd , md gekennzeichnet, die unverzerrten
(undistorted ) durch nu , mu .
Da f z senkrecht auf E steht, gilt:
(a(nf n0 ) + b(mf m0 ) z) a = 0

(39)

(a(nf n0 ) + b(mf m0 ) z) b = 0 .

(40)

Durch Lsung dieses LGS erhlt man die Parameter nf , mf (59), (60). Die Beziehung zwischen
o
a
xd und xu wird als radiale Linsenverzerrung modelliert:
2
xu = f + (1 + 0 rd + 1 rd ) rd

mit rd = xd f , rd = |rd |.

(41)

Setzt man (37) und (38) in (41) ein, so erhlt man:


a
nu
mu

nd
md

2
+ (0 rd + 1 rd )

nd nf
md mf

(42)

Zunchst sollen die Parameter a, b, n0 , m0 bestimmt werden. Hierzu geht man wiederum von
a
Punktepaaren (PW elt , PBild ) aus, wobei im Folgenden x den Ortsvektor von PW elt beschreibt
und nd , md die Koordinaten von PBild sind. Die unverzerrten Bildkoordinaten nu , mu erhlt
a
man aus nd , md mit (42). Initial wird die radiale Verzerrung vernachlssigt und von 0 =
a
1 = 0 ausgegangen. Da die Projektion der unverzerrten Bildkoordinaten nu , mu mittels der
Abbildung p denselben Punkt liefern soll, den man durch perspektivische Projektion von x
auf E erhlt, ergibt sich die Gleichung:
a
a(nu n0 ) + b(mu m0 ) = x + s(z x).

(43)

Multipliziert man (43) mit b (z x) respektive a (z x), so erhlt man:


a
(nu n0 ) [a(b z) + a(x b)] = x(b z)

(44)

(mu m0 ) [b(a z) + b(x a)] = x(a z) ,

(45)

29

Abbildung 19: Kameramodell nach Hoppe et al.


da (a (z x)) a, (a (z x)) (z x), (a x) x respektive (b (z x)) b,
(b (z x)) (z x), (b x) x gilt. Durch zyklische Vertauschung (75) folgt:
(nu n0 ) [z(a b) + x(a b)] = x(b z)

(46)

(mu m0 ) [z(a b) + x(a b)] = x(a z) .

(47)

Es werden nun folgende Abkrzungen eingefhrt:


u
u
:= z(a b)
k := (a b)/
c := (a z)/
d := (b z)/
u := n0 k + d
v := m0 k c.
Teilt man (46) und (47) jeweils durch und benutzt die Abkrzungen, so erhlt man:
u
a
(nu n0 ) (1 xk) = xd
(mu m0 ) (1 xk) = xc
30

(48)
(49)

und durch Einsetzen der Abkrzungen u und v schlielich:


u
xu + n0 nu xk = nu

(50)

xv + m0 mu xk = mu .

(51)

Man beachte, dass diese Gleichungen - bis auf die hier verwendete Vektorschreibweise - mit
den DLT-Gleichungen (12) und (13) ubereinstimmen. Das entsprechende uberbestimmte LGS

zur Bestimmung von k, u, v, n0 , m0 lautet:

n
x1 T 1
o
0 nu1 x1 T
u1
u
o
0 x1 T 1 mu1 x1 T n0 mu1


.
.

.
.
.
.
.
.
.
.
.
v = .
(52)
.

.
.
.
.
.


xn T 1
nun
o
0 nun xn T m0
T 1 m x T
k
mun
o
0 xn
un n
Nach Lsung von (52) sind n0 und m0 unmittelbar bekannt. Aus der Denition von folgt
o
mit den Identitten (74), (75) und (76):
a
z[z(a b)]
z[z(a b)] b[z(a z)]
(z a) (z b)
=
=
= (c d)

a[z(a b)]
a[b(z a)]
a[b(z a)] b[a(z a)]
(z a) (a b)
a =
=
=
=
= (c k)

b[z(a b)]
b[a(b z)]
b[a(b z)] a[b(b z)]
(b z) (b a)
b =
=
=
=
= (d k)

1
z a b
= z(a b) 2 =

1/ (c d)[(c k) (d k)] .

z =

Die Kamera-Parameter a, b, z knnen somit durch folgende Berechnungs-Sequenz gewonnen


o
werden:
c = m0 k v

(53)

d = n0 k + u

(54)

= 1/

(55)

(c d)[(c k) (d k)]

z = (c d)

(56)

a = (c k)

(57)

b = (d k)
(az)b2 (bz)(ab)
nf = n0 +
a2 b2 (ab)2
(bz)a2 (az)(ab)
mf = m0 +
a2 b2 (ab)2
f = a(nf n0 ) + b(mf m0 )

(58)
(59)
(60)
(61)

Liegt das mit (0, 0) indizierte Pixel in der linken oberen oder rechten unteren Ecke des CCDChips, muss negativ, ansonsten positiv sein.
Zur Berechnung der Verzerrungsparameter werden zunchst die gegebenen xi perspektivisch
a
auf E projiziert. Dies ist quivalent zum Schnitt der Geraden, deniert durch den Ortsvektor
a
xi und den Richtungsvektor z xi , mit der Ebene E:
xui := xi (z xi )
31

xi (a b)
.
(z xi )(a b)

(62)

Die Vektoren xui sind durch nd , md und den Gleichungen (37), (41) deniert. Es sind nun
diejenigen Parameter 0 , 1 zu bestimmen, die die Summe der euklidischen Abstnde von
a
den xui und xui minimieren. Dies ist quivalent zur Minimierung der Funktion:
a
(xui xui )2 .

f (0 , 1 ) :=

(63)

Deniert man rui := xui f und rui := xui f , so gilt:


f (0 , 1 )

=
i

=
i

=
i

=
i

(xui xui )2
(rui rui )2
2
[rdi (1 + 0 rdi + 1 rdi ) rui ]2
2
2
2
[rdi (1 + 0 rdi + 1 rdi )2 2(1 + 0 rdi + 1 rdi )rdi rui + rui 2 ] .

Leitet man nun nach 0 und 1 ab, so erhlt man:


a
3
4
5
rdi + 0 rdi + 1 rdi rdi (rdi rui )

(64)

4
5
6
2
rdi + 0 rdi + 1 rdi rdi (rdi rui ) .

f (0 ) = 2

(65)

f (1 ) = 2
i

Setzt man schlielich (64) und (65) gleich Null, so ergibt sich das folgende LGS

5
4
rdi rdi
6
5
rdi rdi

0
1

=
i

3
(rui rdi )rdi rdi
4
2
(rui rdi )rdi rdi

(66)

dessen Lsung quivalent zur Minimierung der Funktion f ist.


o
a
Das von Hoppe et al. vorgestellte Verfahren ist iterativ. Wie schon erwhnt, wird zu Bea
ginn der Iteration 0 = 1 = 0 gesetzt. In jedem Iterationsschritt werden zunchst die
a
Parameter n0 , m0 , a, b, z, nf , mf , f durch Lsung von (52) und Ausfhrung der beschriebeo
u
nen Berechnungs-Sequenz (53) - (61) bestimmt. Dabei ist zu beachten, dass die mit (42) zu
bestimmenden unverzerrten Pixelkoordinaten in (52) eingehen. Anschlieend werden die Verzerrungsparameter 0 , 1 durch Lsung von (66) bestimmt. Die Iteration wird abgebrochen,
o
wenn die mittlere Abweichung f (0 , 1 )/n nicht mehr kleiner wird.

32

Algorithmus 3 KalibriereKamera(xi , ndi , mdi )


a :=
while (1) do
BerechneParameter() mit (52) - (61)
BerechneKappa() mit (66)
a := f (0 , 1 )/n
if (a > a ) then
break
end if
SichereAlleParameter()
a := a
end while
LadeAlleParameter()
Nach Kalibrierung der Kamera lsst sich schlielich mit Hilfe von (37) und (41) die Paraa
meterdarstellung der Geraden aller Punkte, die auf einen Bildpunkt P (nd , md ) abgebildet
werden, wie folgt bestimmen:
g : x = z + r(xu z) .
(67)

33

4.2

Verarbeitung von Punktemustern

Fr die Verarbeitung von Punktemustern bietet es sich an die Schwerpunktbestimmung in


u
den Region-Growing-Algorithmus 1 zu integrieren. Dem kombinierten Algorithmus 5 dienen
als Eingabe die Koordinaten eines Saatpunktes. Der Algorithmus bestimmt die Region um
diesen Saatpunkt und berechnet deren Schwerpunkt. Um alle Punkte zu erfassen, wird in
Algorithmus 4 uber alle Bildpunkte iteriert. Als Saatpunkte werden diejenigen Bildpunkte

gewhlt, deren Grauwert unter einem zu denierenden Schwellwert liegt und die nicht bereits
a
zu einer Region gehren.
o
Die besten Ergebnisse wurden mit einer vorherigen globalen Binarisierung mit Algorithmus
6 erzielt. Liegt nun ein binarisiertes Bild vor, so kann sowohl in Algorithmus 4 als auch in
Algorithmus 5 die Konstante threshold auf den Wert 1 gesetzt werden.
Im Folgenden werden die entsprechenden Algorithmen in Pseudocode dargestellt. Da die
Verarbeitung von Punktemustern in dem vorliegenden System ausschlielich fr Zwecke der
u
Kalibrierung eingesetzt wird, ist dieser Prozess nicht zeitkritisch. Daher wurden auch in
der tatschlichen Implementierung keinerlei Optimierungen, insbesondere in Bezug auf die
a
Adressarithmetik, vorgenommen.

Algorithmus 4 VerarbeitePunktemuster(image)
BinarisiereGlobal(image)
id := 0
for y := 0 to image.height 1 do
for x := 0 to image.width 1 do
image[x][y].region := 0
end for
end for
for y := 0 to image.height 1 do
for x := 0 to image.width 1 do
if image[x][y].g threshold AND image[x][y].region = 0 then
id := id + 1
BerechneRegionUndSchwerpunkt(image, x, y, id);
end if
end for
end for

34

Algorithmus 5 BerechneRegionUndSchwerpunkt(image, x, y, id)


n := 0
xsum := 0
ysum := 0
image[x][y].id := id
stack.push(ref image[x][y])
while (stack = ) do
(x, y, g, id) := stack.pop()
n := n + 1
xsum := xsum + x
ysum := ysum + y
if (x > 0 AND image[x 1][y].id < id AND |image.[x 1][y].g g| < threshold) then
image[x 1][y].id := id
image[x 1][y].g := g
stack.push(ref image[x 1][y])
end if
if (y > 0 AND image[x][y 1].id < id AND |image.[x][y 1].g g| < threshold) then
image[x][y 1].id := id
image[x][y 1].g := g
stack.push(ref image[x][y 1])
end if
if (x < image.width 1 AND image[x + 1][y].id < id AND |image.[x + 1][y].g g| <
threshold) then
image[x + 1][y].id := id
image[x + 1][y].g := g
stack.push(ref image[x + 1][y])
end if
if (y < image.height 1 AND image[x][y + 1].id < id AND |image.[x][y + 1].g g| <
threshold) then
image[x][y + 1].id := id
image[x][y + 1].g := g
stack.push(ref image[x][y + 1])
end if
end while
VerarbeitePunkt(xsum/n, ysum/n)

35

4.3

Umsetzung der Binarisierung

Sowohl fr die Verarbeitung von Punktemustern whrend der Kamerakalibrierung als auch
u
a
fr den Scanvorgang werden die Kamerabilder in einem Vorverarbeitungsschritt mit der in
u
Abschnitt 3.1.2 erluterten Schwellwertsegmentierung binarisiert. In beiden Fllen ist das Ziel
a
a
unterschiedliche Beleuchtungsverhltnisse und Objektoberchen tolerieren zu knnen. Fr
a
a
o
u
die Vorverarbeitung der Punktemuster wird die Binarisierung global, fr den Scanvorgang
u
lokal, durchgefhrt. Beide Vorgehensweise sollen im Folgenden erlutert werden.
u
a
4.3.1

Globale Binarisierung

Da das Punktemuster einen homogenen (weien) Hintergrund besitzt und das Bild annhernd
a
gleichmig ausgeleuchtet ist, ist es fr die Vorverarbeitung ausreichend die Binarisierung
a
u
global durchzufhren, d.h. der Schwellwert wird einmal bestimmt und auf das gesamte Bild
u
angewendet. Die Abschtzung (3) aus Abschnitt 3.1.2 fr die Bestimmung des Schwellwertes
a
u
liefert erfahrungsgem ein robustes Ma.
a
In Algorithmus 6 wird die globale Binarisierung in Pseudocode dargestellt.

Algorithmus 6 BinarisiereGlobal(image)
max := 0
min := 255
for y := 0 to image.height 1 do
for x := 0 to image.width 1 do
if image[x][y].g > max then
max :=image[x][y].g
else if image[x][y].g < min then
min :=image[x][y].g
end if
end for
end for
threshold := (min + max)/2
for y := 0 to image.height 1 do
for x := 0 to image.width 1 do
if image[x][y].g threshold then
image[x][y].g := 255
else
image[x][y].g := 0
end if
end for
end for

36

4.3.2

Lokale Binarisierung

Fr die Vorverarbeitung des projizierten Schwarz-Wei-Musters whrend des Scanvorgangs


u
a
ist es nicht ausreichend, die Binarisierung global durchzufhren. Objekte, welche Oberchen
u
a
mit verschiedenen Farben und Texturen aufweisen, reektieren das Licht je nach betrachtetem Flchenstck in unterschiedlicher Weise. Aus diesem Grund muss der Schwellwert lokal
a
u
fr kleine Ausschnitte jeweils neu berechnet werden.
u
Optimal wre eine Neuberechnung des Schwellwertes fr jedes betrachtete Suchfenster wha
u
a
rend der Korrelation. Dies ist jedoch aus Laufzeitgrnden nicht mglich. Stattdessen wird das
u
o
gesamte Kamerabild in einem Vorverarbeitungsschritt binarisiert, wobei das Bild in bndiu
ge Kacheln eingeteilt wird, die ungefhr der Fenstergre fr die Korrelation entsprechen.
a
o
u
Da diese so gewhlt wird, dass eine ausreichende Anzahl von Pixeln des Originalmusters
a
enthalten sind, ist mit sehr hoher Wahrscheinlichkeit stets sowohl ein weies als auch ein
schwarzes Pixel des Originalmusters in einem Fenster dieser Gre vorhanden. Somit ist die
o
Voraussetzung fr eine korrekte Bestimmung des Schwellwertes erfllt. Es bietet sich an, die
u
u
Fenstergre fr die lokale Binarisierung als ganzzahligen Teiler der Breite und der Hhe des
o
u
o
Kamerabildes zu whlen.
a
In Bildausschnitten, die keine Objektpunkte enthalten, wird das Muster durch den schwarzen
Hintergrund vollstndig absorbiert. In diesen Bereichen, die durch eine geringe Grauwertdia
stanz des hellsten und des dunkelsten Pixels erkennbar sind, wird threshold auf das Maximum
255 gesetzt, sodass allen Pixeln des entsprechenden Ausschnitts stets die Farbe Schwarz zugewiesen wird. Der entsprechende Schwellwert fr die minimale Grauwertdistanz wurde mit
u
mindistance = 20 gewhlt.
a
In Algorithmus 7 wird die lokale Binarisierung in Pseudocode dargestellt. In der aktuellen
Implementierung wurde eine Fenstergre von 16 16, d.h. tilesize = 16 gewhlt, whrend
o
a
a
die Fenstergre fr die Korrelation 17 17 betrgt, wie in Abschnitt 4.4.3 nher erlutert.
o
u
a
a
a
In der tatschlichen Implementierung wurde die Adressarithmetik optimiert, da die lokale
a
Binarisierung whrend des Scanvorgangs Einsatz ndet und daher ezient realisiert werden
a
muss. Der entsprechende Quellcode ist im Anhang aufgefhrt.
u

37

Algorithmus 7 BinarisiereLokal(image)
tilesperrow := image.width/tilesize
tilespercolumn := image.height/tilesize
for i := 0 to tilespercolumn 1 do
for j := 0 to tilesperrow 1 do
max := 0
min := 255
dx := j tilesize
dy := i tilesize
for y := dy to dy + tilesize 1 do
for x := dx to dx + tilesize 1 do
if image[x][y].g > max then
max :=image[x][y].g
else if image[x][y].g < min then
min :=image[x][y].g
end if
end for
end for
if max min mindistance then
threshold := (min + max)/2
else
threshold := 255
end if
for y := dy to dy + tilesize 1 do
for x := dx to dx + tilesize 1 do
if image[x][y].g threshold then
image[x][y].g := 255
else
image[x][y].g := 0
end if
end for
end for
end for
end for

38

4.4

Umsetzung der Korrelation

Fr die Korrelation whrend des Kalibrierungsprozesses und whrend des Scanvorgangs wuru
a
a
den unterschiedliche Anstze gewhlt. Die Ausgangsbedingungen und Anforderungen untera
a
scheiden sich je nach Einsatzgebiet der Korrelation grundlegend. Im Folgenden sollen die
gewhlten Anstze begrndet und erlutert werden. In beiden Fllen sind die Punkte im
a
a
u
a
a
Referenzmuster, fr die nach Korrespondenzen gesucht wird, in einem rechteckigen Gitter
u
angeordnet. Dieses Gitter ist deniert durch die Eckpunkte (sx , sy ) und (ex , ey ), mit dem
festen Abstand in x- und in y-Richtung.
4.4.1

Korrelation whrend der Projektorkalibrierung


a

Whrend des Kalibrierungsprozesses ist die Laufzeit von geringer Bedeutung, sodass die rea
lativ aufwndige Korrelation nach der Methode der kleinsten Quadrate aus Abschnitt 3.3.2
a
eingesetzt werden kann, um Subpixel-Genauigkeit zu erzielen. Ferner sind die Ausgangsbedingungen hierfr deutlich gnstiger als whrend des Scanvorgangs, da whrend der Projeku
u
a
a
torkalibrierung die Intensitten der zu korrelierenden Bilder nahezu ubereinstimmen. Somit
a

knnen die Algorithmen direkt auf den Kamerabildern angewendet werden, ohne zuvor eine
o
Normalisierung durchfhren zu mssen. Erfahrungsgem wirkt sich dieser Sachverhalt sehr
u
u
a
positiv auf die de facto erzielte Genauigkeit durch den Korrelationsalgorithmus nach der Methode der kleinsten Quadrate aus.
Da whrend der Projektorkalibrierung noch keine Information uber die Epipolar-Geometrie
a

zur Verfgung steht, muss die Suche in zwei Dimensionen erfolgen. Es hat sich bewhrt,
u
a
zu Anfang jeder Zeile des Gitters mit der SSD-Korrelation in einem relativ groen Umkreis
nach einem Saatpunkt zu suchen, um anschlieend, ausgehend von geringen Vernderungen
a
von Punkt zu Punkt innerhalb einer Zeile des Gitters, in einem kleinen Umkreis, ebenfalls
mit der SSD-Korrelation, nach einer Korrespondenz suchen zu knnen. Diese Vorgehensweise
o
beschleunigt nicht nur die Korrelation, sie wirkt sich auch positiv auf die Robustheit aus.
Fr jede gefundene Korrespondenz wird schlielich die Korrelation nach der Methode der
u
kleinsten Quadrate eingesetzt, um Subpixel-Genauigkeit zu erzielen.
Der beschriebene Korrelationsalgorithmus 8ist nachfolgend in Pseudocode dargestellt. Dabei
bezeichnet f das Referenzmuster und g das Suchbild. Die Konstanten s1 und s2 beschreiben
die Gre des Suchraums. In der aktuellen Implementierung wurden s1 = 50 und s2 = 5
o
gewhlt.
a

Algorithmus 8 BestimmeKorrespondenzenKalibrierung(f, g)
for y := sy to ey step do
(error, dx , dy ) := FindeKorrespondenzKalibrierung(f, g, x, y, 0, 0, s1 )
for x := sx to ex step do
(min, dx , dy ) := FindeKorrespondenzKalibrierung(f, g, x, y, dx , dy , s2 )
if min maxssdcalibration then
(error, dx , dy ) := KleinsteQuadrateKorrelation(f, g, x, y, dx , dy )
if error maxlscalibration then
BerechnePunktepaar(x, y, x + dx , y + dy )
end if
end if
end for
end for
39

Algorithmus 9 FindeKorrespondenzKalibrierung(f, g, x, y, dx0 , dy0 , s)


min :=
for dy := dy0 s to dy0 + s do
for dx := dx0 s to dx0 + s do
error := SSD(f, g, x, y, dx, dy)
if error < min then
dx := dx
dy := dy
min := error
end if
end for
end for

4.4.2

Korrelation whrend des Scanvorgangs


a

Die Korrelation whrend des Scanvorgangs ist auerst laufzeitkritisch. Der ezienten Umseta

zung ist im vorliegenden System hhere Prioritt beizumessen als der Erlangung von Subpixelo
a
Genauigkeit, da eine zu niedrige Aktualisierunsrate eine schnelle und korrekte Registrierung
unmglich macht. Aus diesen Grnden wird eine optimierte Variante der SSD-Korrelation
o
u
auf binarisierten Daten verwendet und auf Subpixel-Genauigkeit verzichtet.
Eine grundlegende Steigerung der Ezienz aber auch der Robustheit der Korrelation kann
durch die Einschrnkung des Suchraums auf einen Geradenausschnitt erreicht werden, gem
a
a
Betrachtungen in Anlehnung an die Epipolar-Geometrie aus Abschnitt 3.4.

Abbildung 20: Veranschaulichung der Einschrnkung des Suchraums fr die Korrelation


a
u
In Abbildung 20 sind die Verhltnisse fr die Triangulation zweidimensional dargestellt.
a
u
Whrend der Korrelation wird versucht Korrespondenzen fr feste Punkte des Referenza
u
musters im Kamerabild zu nden. Geeigneterweise wird das Referenzmuster in der xy-Ebene
40

aufgenommen. Betrachtet man nun einen beliebigen festen Punkt p0 im Referenzmuster, so sei
P0 der korrespondierende 3D-Punkt im Weltkoordinatensystem, der sich mit Hilfe der Parameter der kalibrierten Kamera und dem Schnitt der berechneten Sichtgerade g0 mit der Ebene
deniert durch z = 0 berechnen lsst. Legt man Betrachtungen uber den Tiefenschrfebereich
a
a

der Kamera und des Projektors zu Grunde, so ist es sinnvoll ausschlielich Objektpunkte P
bis zu einer festen Hhe h zuzulassen. Mit Hilfe der Parameter des kalibrierten Projektors
o
kann die Sichtgerade g1 berechnet werden. Der Schnitt der Gerade g1 mit der Ebene deniert
durch z = h liefert den Punkt Pmax , welcher wiederum mit Hilfe der Kamerabbildung in den
Bildpunkt pmax umgerechnet werden kann. Da alle mglichen 3D-Punkte P zu einem festen
o
a
u
2D-Punkt p0 im Referenzmuster auf der Strecke P0 Pmax liegen, lsst sich der Suchraum fr
den korrespondierenden 2D-Punkt p im Kamerabild auf die Strecke p0 pmax einschrnken.
a
Diese Betrachtungen setzen vereinfachend eine optimale, linear abbildende Kamera voraus.
Die dadurch entstehenden Abweichungen sind jedoch vernachlssigbar, sodass diese Vorgea
hensweise zulssig ist. In diesem Zusammenhang sei angemerkt, dass die Berechnungen mit
a
Hilfe des Kamera- und des Projektormodells radialsymmetrische Verzerrungen einbeziehen.
Da die Punkte im Referenzmuster, fr die nach Korrespondenzen gesucht wird, fest sind,
u
knnen diese Berechnungen oine durchgefhrt werden. Statt der Strecke der Punkte wird
o
u
die Strecke der Verschiebungen gespeichert. Diese Suchstrecken der Verschiebungen werden
in einer Lookup-Table abgespeichert, in die mit den Koordinaten der festen Punkte p0 indiziert wird. Die Eintrge beinhalten die Steigung m und die maximale Verschiebung in xa
bzw. in y-Richtung, je nach Wahl der Modellierung der Suchstrecke durch eine Funktion
s(x) oder s(y). Diese Wahl hngt vom konkreten Aufbau ab. Wirken sich Hhenunterschiede,
a
o
d.h. Verschiebungen in z-Richtung des Weltkoordinatensystems, im Bildkoordinatensystem
hauptschlich in Verschiebungen in x-Richtung aus, so ist es aus numerischer Sicht sinnvoller
a
die Suchstrecke durch eine Funktion s(x) zu modellieren, analog ist fr den anderen Fall die
u
Darstellung s(y) vorzuziehen.
Fr die Suche wird eine optimierte Variante der SSD-Korrelation auf binarisierten Daten veru
wendet. In einem Vorverarbeitungsschritt wird das Kamerabild G binarisiert, wobei Schwarz
dem Wert 0 entspricht und Wei dem Wert 1. Das Referenzmuster F liegt in derselben Form
vor. Gem dieser Denition ist die Summe der quadrierten Dierenzen gleich der Summe der
a
Dierenzen der Betrge, welche ezient mit XOR-Verknpfungen berechnet werden knnen.
a
u
o
Um die Anzahl der Speicherzugrie zu minimieren, werden jeweils 32-bit-Werte gelesen. Da
eine Fenstergre von 17 17 gewhlt wurde, muss das letzte Byte in jeder Zeile gesono
a
dert betrachtet werden. Bei der gewhlten Fenstergre betrgt der maximale Fehler 289,
a
o
a
sodass 8 Bit fr das Zhlen eines Viertels des maximalen Fehlers mehr als ausreichend sind.
u
a
Somit ist es zulssig, die Ergebnisse der XOR-Verknpfung der 32-bit Werte aufzusummiea
u

ren, da die vier einzelnen 8-bit Rume sich gegenseitig nicht durch Ubertrge beeinussen
a
a
knnen. Die Summe der einzelnen 8-bit-Werte wird dann schlielich mit Hilfe von UND- und
o
SHIFT-Operationen ein einziges Mal berechnet. Die konkrete Implementierung ist im Anhang aufgefhrt.
u
Erfahrungsgem ist das Minimum der SSD bei einer sinnvollen Wahl der Fenstergre in
a
o
einem gewissen Ma invariant gegenber perspektivischen Verzerrungen. Das heit existiert
u
eine Korrespondenz, so produziert das entsprechende Fenster trotz perspektivischer Verzerrungen den minimalen Fehler.
Der resultierende Korrelationsalgorithmus 10 ist nachfolgend in Pseudocode dargestellt. Dabei bezeichnet f das bereits binarisierte Referenzmuster und g das Suchbild. Die Suchstrecke
41

der Verschiebungen wird durch eine Funktion f (x) modelliert.

Algorithmus 10 BestimmeKorrespondenzenScan(f, g)
BinarisiereLokal(g)
for y := sy to ey step do
for x := sx to ex step do
(min, dx , dy ) := FindeKorrespondenzScan(f, g, x, y)
if min maxssdscan then
Trianguliere(x, y, x + dx , y + dy )
end if
end for
end for

Algorithmus 11 FindeKorrespondenzScan(f, g, x, y)
(end, m) := GetShiftLine(x, y)
dy := 0
min :=
for dx := 0 to end do
error := SSDBin(f, g, x, y, dx, dy)
if error < min then
dx := dx
dy := dy
min := error
end if
dy := dy + m
end for

4.4.3

Wahl der Konstanten

Es ist von grundlegender Bedeutung, eine gute Wahl fr die Fenstergre und die Konstanu
o
ten maxssdcalibration, maxlscalibration und maxssdscan zu treen. Die besten Ergebnisse
wurden mit maxssdcalibration = 3000n, maxlscalibration = 1000n und maxssdscan =
n/4.5 erzielt, wobei n die Anzahl der Pixel in einem Fenster beschreibt. Verwendet wurde
eine Fenstergre von 17 17, womit gilt n = 172 = 289. Die optimale Fenstergre hngt
o
o
a

jedoch vor allem von der Wahl des Grades der Uberabtastung ab. In der aktuellen Implementierung wird das Originalmuster in jeder Richtung ca. vierfach uberabgetastet. Damit fallen

auf ein Pixel des Originalmusters ca. 16 Pixel im Kamerabild, und ein Suchfenster enthlt
a
die Information von ca. 4 4 Pixel des Originalmusters. Der Netto-Informationsgehalt eines
Suchfensters kann also in etwa mit 16 Bit abgeschtzt werden. Die Konstanten fr die Dea
u
nition des Suchgitters im Referenzmuster wurden mit sx = 70, sy = 70, ex = 570, ey = 410
und = 5 (Pixel) gewhlt, bei einer Kameraausung von 640 480 Bildpunkten.
a
o
4.4.4

Weitere verfolgte Anstze


a

Zu Beginn wurde ein weiterer Ansatz fr die eziente Lsung des Korrespondenzproblems
u
o
verfolgt. DAppuzo stellt in [DA98] ein Mehrkamerasystem fr das Scannen von Gesichtern
u
vor, in dem manuell eine Menge von Punktkorrespondenzen bestimmt wird. Mit diesen Saatpunkten wird dann ein Voronoi-Diagramm gebildet und jede einzelne Zelle mit Horizontal42

und Vertikal-Verschiebungen abgearbeitet. In jedem Punkt wird die Korrelation nach der
Methode der kleinsten Quadrate berechnet, wobei die Initialbedingung des letzten Punktes
verwendet werden kann. Schlgt die Korrelation fehl, so wird durch Variation der Parameter
a
in einem kleinen Raum adaptiv gesucht. Da im vorliegenden System keine manuelle Wahl
der Saatpunkte mglich ist, mssen diese automatisch berechnet werden. Dies ist ezient
o
u
nur mit dem bereits vorgestellten Ansatz zur Reduzierung des Suchraums gem Epipolara
Betrachtungen mglich. Es wurde die Erfahrung gemacht, dass bei beliebigen (unbekannten)
o
Objekten mit komplexeren Oberchen dieser Ansatz kein robustes System liefert. Berecha
net man die Saatpunkte on-the-y, so hngt die Laufzeit eines Einzelscans stark von der
a
vorliegenden Objektgeometrie ab, sodass im Allgemeinen keine Laufzeitverbesserung erzielt
werden konnte.
Ein weiterer verfolgter Ansatz bestand darin, die Initialbedingung fr den Korrelationsalu
gorithmus nach der Methode der kleinsten Quadrate in jedem Punkt unter Einbezug von
Epipolar-Betrachtungen mit Hilfe der SSD-Korrelation zu berechnen. Grundstzlich ist dieser
a
Ansatz vielversprechend, da auf diese Weise perspektivische Verzerrungen tatschlich berecha
net und somit toleriert werden knnen, wie Abbildung 16 in Abschnitt 3.3.2 zeigt. Fr eine
o
u
solche Strategie muss der Schwellwert fr die SSD-Korrelation deutlich hher als derjenige
u
o
der Kleinste-Quadrate-Korrelation gewhlt werden. Auf diese Weise werden durch die SSDa
Korrelation auch in perspektivisch verzerrten Regionen Korrespondenzen gefunden, die dann
mit Hilfe der Kleinste-Quadrate-Korrelation auf ihre Gltigkeit zu uberprfen sind. Mit dieu
u

sem Ansatz kann zudem Subpixel-Ausung erzielt werden. Jedoch ist in diesem Zusammeno
hang der Begri Subpixel-Genauigkeit vorsichtig zu verwenden. Der Korrelationsalgorithmus

nach der Methode der kleinsten Quadrate bentigt relativ gute Ubereinstimmungen der Grauo
werte um zu konvergieren. Eine Normalisierung mit Hilfe der in Abschnitt 3.1.3 beschriebenen
Spreizung schat hier zwar Abhilfe, jedoch resultiert ein solcher Grauwertausgleich in einem
verrauschteren Ergebnis. Wird durch Binarisierung normalisiert, so geht wichtige GrauwertInformation an Kanten verloren, sodass de facto keine Subpixel-Genauigkeit erzielt werden
kann. Ferner verlangsamt der Mehraufwand fr die iterative Ausgleichsrechnung die Korrelau
tion deutlich, sodass die korrekte Registrierung der Einzelscans und eine sinnvolle Interaktion
unter Einsatz heute verfgbarer PCs nur noch sehr eingeschrnkt gewhrleistet ist.
u
a
a

4.5

Filterung der Einzelscans

Wird ein relativ kleines Suchfenster fr die Korrelation gewhlt und ist der Schwellwert
u
a
fr den maximalen Fehler nicht restriktiv genug, so werden in geringer Anzahl falsche Korreu
spondenzen gefunden, die sich im Allgemeinen als Ausreier in der resultierenden Punktwolke
bemerkbar machen. Nach der Berechnung der Punktwolke eines Einzelscans knnen solche
o
Ausreier sehr eektiv und ezient geltert werden.
Eine solche Vorgehensweise kann sinnvoll sein, um ezienter ein grere Anzahl von Objekto
punkten je Einzelscan gewinnen zu knnen. Ferner knnen mit einem kleineren Suchfenster
o
o
bei gleichbleibendem Aufbau feinere Objektgeometrien erfasst werden.
Fr die Filterung werden die durch Triangulation berechneten 3D-Punkte in eine Gitteru
Datenstruktur G eingegliedert. Die Indizes werden aus den Koordinaten x, y des ursprngliu
chen 2D-Punktes im Referenzmuster gebildet. Werden im Referenzmuster nur die Punkte in
dem rechteckigen Gitter, deniert durch die Eckpunkte (sx , sy ) und (ex , ey ), mit dem festen
43

Abstand in x- und in y-Richtung, betrachtet, so gilt fr die maximale Anzahl der Punkte:
u
ex sx
+1

ey sy
+1
ymax =

maxpoints = xmax ymax


xmax =

(68)
(69)
(70)

Die Indizes x , y fr das Gitter werden berechnet zu


u
x

x sx

y sy

(71)
(72)

Wird fr einen Punkt (x, y) im Referenzmuster keine Korrespondenz gefunden, so wird die
u
z-Koordinate des entsprechenden Eintrags (x , y ) in G mit NaN (Not a Number ) markiert.
Der Algorithmus verwendet einen Schwellwert threshold fr die maximal zulssige Dierenz
u
a
der z-Koordinaten benachbarter Punkte. Wird dieser Schwellwert uberschritten, so liegt ein

Fehler vor. Ein Fehler liegt auch dann vor, wenn der benachbarte Punkt undeniert ist.
Ein Punkt wird als zuverlssig berechnet angesehen, wenn die Summe der Fehler die Kona
stante maxerror nicht ubersteigt. In der aktuellen Implementierung wurde threshold = 2

und maxerror = 2 gewhlt. Somit wird ein Punkt nur dann akzeptiert, wenn mindestens
a
sechs denierte Nachbarn innerhalb des Toleranzbereichs fr die z-Koordinate liegen. Da die
u
Randpixel des Gitters G keine ausreichende Anzahl von Nachbarn besitzen um das Kriterium zu erfllen, werden diese nicht betrachtet. Auf diese Weise knnen auch die ansonsten
u
o

notwendigen Uberprfungen von Speichergrenzen eingespart werden. Ferner gilt fr beliebige


u
u
z = NaN stets |NaN z| > threshold, sodass die z-Koordinate jedes Nachbarn nicht explizit mit NaN verglichen werden muss. Der Filter-Algorithmus lsst sich dann wie folgt in
a
Pseudocode darstellen.
Algorithmus 12 FiltereEinzelscan(G)
Pneu :=
for y := 1 to ymax 2 do
for x := 1 to xmax 2 do
z := G[x ][y ].z
if z = NaN then
error := (|G[x ][y + 1].z| z > threshold))
+ ((|G[x ][y 1].z z| > threshold))
+ (|G[x + 1][y + 1].z z| > threshold))
+ (|G[x + 1][y ].z z| > threshold))
+ (|G[x + 1][y 1].z z| > threshold))
+ (|G[x 1][y + 1].z z| > threshold))
+ (|G[x 1][y ].z z| > threshold))
+ (|G[x 1][y 1].z z| > threshold))
if error maxerror then
Pneu := Pneu {G[x ][y ]}
end if
end if
end for
end for

44

4.6

Umsetzung des ICP

Fr den Einsatz im vorliegenden System muss der ICP-Grundalgorithmus aus Abschnitt


u
3.6 besonders ezient implementiert werden. Der Ansatzpunkt ist hierbei die Berechnung
des nchsten Punktes, die den Flaschenhals in puncto Ezienz darstellt, wie bereits in Aba
schnitt 3.6.2 angesprochen. Des Weiteren muss eine Suche nach einer hinreichend genauen
Initialbedingung eingesetzt werden, um nicht nicht in lokalen Minima zu konvergieren. Die
entsprechenden Algorithmen sollen im Folgenden vorgestellt werden.

4.6.1

Berechnung des nchsten Punktes


a

Sei n die Anzahl der Punkte des Ist-Datensatzes und m diejenige des Soll-Datensatzes. Fr jeu
den Punkt des Ist-Datensatzes wird der nchste Punkt des Soll-Datensatzes gesucht im Sinne
a
der euklidischen Distanz. Anfnglich wurde die Berechnung des nchsten Punktes mit einer
a
a
einfachen Suche mit einem Aufwand von O(m) implementiert, um die Funktionsfhigkeit des
a
Algorithmus testen zu knnen. Da somit der Gesamtaufwand fr diesen Schritt O(n m) beo
u
trgt, ist bei Einzelscans mit mehreren Tausend Punkten eine solche Suche nicht einsetzbar.
a
Im vorliegenden System ist die dritte der in Abschnitt 3.6.2 vorgestellten Varianten implementiert, die Projektion auf eine geeignet diskretisierte Ebene und eine anschlieende Suche
in einem Umkreis fester Gre mit einem Aufwand von insgesamt O(1). Zwar lassen sich
o
mit diesem Ansatz im Allgemeinen komplette 3D-Oberchenmodelle nicht korrekt registriea
ren, im vorliegenden System bilden jedoch zwei aufeinander folgende Einzelscans stets ein
Oberchenstck, dass sich praktisch eineindeutig auf die xy-Ebene projizieren lsst, da die
a
u
a
Positions- und Orientierungsnderungen gering ausfallen. Somit knnen mit diesem Ansatz
a
o
durchaus komplette 3D-Oberchenmodelle akquiriert werden, obwohl die Registrierung aufa
einander folgender Einzelscans auf sogenannte 2 1/2-dimensionale Oberchen angewendet
a
wird.
Realisiert wird die Projektion durch Streichen der z-Koordinate. Zunchst wird das einhllena
u
de Rechteck aller Punkte, d.h. beider Datenstze, in der xy-Ebene berechnet. Ausgehend
a
von einer maximalen Gre des Rechtecks und einem festen Grad der Diskretisierung wird
o
der Speicher fr die Gitter-Datenstruktur statisch alloziert. Die Punkte des Soll-Datensatzes
u
werden dann in die Gitter-Datenstruktur eingegliedert. Nun wird fr jeden Punkt des Istu
Datensatzes in das Gitter indiziert und in einem festen Umkreis nach dem nchsten Punkt
a
gesucht.
Der Aufwand fr die Eingliederung in die Gitter-Datenstruktur ist mit O(max n, m) anzuu
geben. Das direkte Indizieren und die anschlieende Suche in einem festen Umkreis verursacht fr jeden Punkt einen Aufwand von O(1). Somit reduziert sich bei n Punkten des
u
Ist-Datensatzes der Gesamtaufwand von ursprnglich O(n m) auf O(max (n, m)).
u
Um die Beeinussung der Berechnungen durch Ausreier zu verhindern, werden nur solche
nchsten Punkte akzeptiert, der Abstand unter einem Schwellwert liegt.
a
Anstatt die Gitter-Datenstruktur bei jedem Aufruf neu mit Markierungen initialisieren zu
mssen, wird eine statische Zhlvariable verwendet, die nach jedem Aufruf inkrementiert
u
a
wird. Bei der Eingliederung der Punkte aus dem Soll-Datensatz in die Gitter-Datenstruktur
wird diese Zhlvariable als ID zusammen mit jedem Punkt gespeichert. Auf diese Weise kann
a
bei der Suche nach dem nchsten Punkt die Gltigkeit eines Punktes durch Vergleich dessen
a
u
ID mit der aktuellen Zhlvariable festgestellt werden.
a
45

In Algorithmus 13 ist der entsprechende Algorithmus in Pseudocode dargestellt. Die Konstante oversample beschreibt den Grad der Diskretisierung der Gitter-Datenstruktur. Es ist
sinnvoll fr oversample einen Wert zu whlen, der in etwa doppelt so gro dem Abstand
u
a
der Punkte in der xy-Ebene in x- und y-Richtung ist. Dies gewhrleistet einerseits, dass eine
a
praktisch eineindeutige Projektion berechnet wird, anderseits bleiben benachbarte Punkte
in einer nahen Umgebung in der Gitter-Datenstruktur, sodass eine Suche in einem relativ
kleinen Umkreis ausreichend ist. Im vorliegenden System betrgt der Abstand in x- und in
a
y-Richtung der Punkte ca. 0.9 mm, weshalb oversample = 2 gewhlt wurde. Die Konstante
a
search beschreibt die Gre des Suchaums in jeder Richtung. Gewhlt wurde search = 3,
o
a
2 = 49 Punkte des Gitters betrachtet werden. Um die Berechnung
womit insgesamt (3 + 1 + 3)
der Wurzel fr den Abstand einsparen zu knnen, wird als Schwellwert der maximal zulssige
u
o
a
quadrierte Abstand angegeben, der mit threshold = 25 gewhlt wurde. Ferner beschreibt P
a
den Ist-Datensatz und M den Soll-Datensatz, entsprechend den Konventionen aus Abschnitt
3.6. Die Funktion trunc rundet auf einen ganzzahligen Wert ab. Die Konstante maxsize
beschreibt die Gre der statisch allozierten Gitter-Datenstruktur G in jeder Dimension. Die
o
Ausgabe des Algorithmus bildet die Menge der berechneten Punktepaare Y.

4.6.2

Gesamtalgorithmus und Suche nach Initialbedingung

Die zu registrierenden Datenstze stellen 2 1/2-dimensionale Oberchenmodelle dar, die eia


a
ne eineindeutige Projektion auf die xy-Ebene besitzen. Auf solchen Datenstzen operierend,
a
vermag der ICP-Algorithmus ohne eine hinreichend genaue Initialbedingung nicht die korrekte Registrierung zu berechnen. Die Translation in x- und in y-Richtung wird im Allgemeinen
nicht korrekt bestimmt, da oftmals die durch die Initialbedingung vorgegebene Translation in ein falsches lokales Minimum fhrt, wobei die Translationen in x- und in y-Richtung
u
nahezu unverndert bleiben. Informell beschrieben liegt der Grund darin, dass fr die kora
u
rekte Berechnung der Translation in einer bestimmen Richtung durch den ICP, Punkte von
Oberchen orthogonal zu dieser Richtung vorhanden sein mssen. Diese Voraussetzung ist
a
u
hauptschlich nur in z-Richtung erfllt.
a
u
Aus diesem Grund mssen verschiedene Translationen in x- und y-Richtung vorgegeben und
u
uberprft werden, um dann diejenige Translation als Initialbedingung zu whlen, die den
u
a

minimalen Fehler produziert. Zur Feststellung des Fehlers wird eine Iteration des eigentlichen ICP-Algorithmus verwendet, wobei die Punkte des Ist-Datensatzes im Gegensatz zu
den spteren Iterationen nicht transformiert werden. Das Minimum der Fehler am Ende der
a
ersten Iteration stellt ein zuverlssiges Ma fr die Bestimmung einer hinreichend genauen
a
u
Translation als Initialbedingung dar. Erweiterte Konzepte fr die Lsung dieses Problem weru
o
den in Abschnitt 7.2.1 genannt.
In Algorithmus 14 wird die implementierte Variante des ICP-Algorithmus dargestellt, inklusive der beschriebenen Suche nach der Initialbedingung. Die Wahl der Konstante , welche
den Feinheitsgrad der Suche beschreibt, hngt von der Aktualisierungsrate des gesamten Sya
stems ab und von Erfahrungswerten, wie schnell die Handbewegungen in etwa erfolgen. In der
aktuellen Implementierung wurde = 0.5 gewhlt. Die Konstante search beschreibt die Ana
zahl der Iterationen in x- und in y-Richtung. Gewhlt wurde search = 5, womit insgesamt
a
52 = 25 verschieden Translationen uberprft werden. Es sei angemerkt, dass fr die Konu
u

stante search stets eine ungerade Zahl gewhlt werden sollte, damit die Translation (0, 0, 0)
a
ebenfalls innerhalb der Schleife uberprft wird. Die Schreibweise P +(dx, dy, 0) soll bedeuten,
u

dass in Algorithmus 13 intern die Translation (dx, dy, 0) zu den Punkten aus P whrend den
a
Berechnungen addiert wird, die Punktmenge P bleibt jedoch unverndert. Verwendet wurde
a
46

Algorithmus 13 BerechneNchstePunkte(P, M)
a
static idcounter := 0
xmin =
xmax =
ymin =
ymax =
Y :=
for i := 0 to P.size 1 do
if P[i].x < xmin then
xmin := P[i].x
end if
if P[i].x > xmax then
xmax := P[i].x
end if
if P[i].y < ymin then
ymin := P[i].y
end if
if P[i].y > ymax then
ymax := P[i].y
end if
end for
for i := 0 to M.size 1 do
if M[i].x < xmin then
xmin := M[i].x
end if
if M[i].x > xmax then
xmax := M[i].x
end if
if M[i].y < ymin then
ymin := M[i].y
end if
if M[i].y > ymax then
ymax := M[i].y
end if
end for
xsize := oversample (trunc(xmax)trunc(xmin)+1)
ysize := oversample (trunc(ymax)trunc(ymin)+1)
if xsize 0 OR xsize > maxsize OR ysize 0 OR ysize > maxsize then
STOP {Gre der statisch allozierten Gitter-Datenstruktur reicht nicht aus}
o
end if
for i := 0 to M.size 1 do
x := trunc(2 (M[i].xtrunc(xmin)))
y := trunc(2 (M[i].ytrunc(ymin)))
G[x][y].x := M[i].x
G[x][y].y := M[i].y
G[x][y].z := M[i].z
G[x][y].id := idcounter
end for
for i := 0 to P.size 1 do
x := trunc(2 (P[i].xtrunc(xmin)))
y := trunc(2 (P[i].ytrunc(ymin)))
min := threshold
sj := (y search > 0)?y search : 0
sk := (x search > 0)?x search : 0
ej := (y + search < maxsize)?y + search : maxsize 1
ek := (x + search < maxsize)?x + search : maxsize 1
for j := sj to ej do
for k := sk to ek do
if G[j][k].id = idcounter then
x1 := G[j][k].x
x2 := G[j][k].y
x3 := G[j][k].z
ds := x1 x1 + x2 x2 + x3 x3
if ds < min then
j := j
k := k
min := ds
end if
end if
end for
end for
if min = threshold then
Y := Y := {(P[i], G[j ][k ])}
end if
47
end for
idcounter := idcounter + 1

eine feste Anzahl von iterations = 10 Iterationen. Der Algorithmus MinimiereFehler ist
entsprechend den Ausfhrungen aus Abschnitt 3.6.3 nach [Hor87] implementiert und liefert
u
als Ergebnis die berechnete Transformation als homogene Transformationsmatrix T R(4,4)
und den entsprechenden durchschnittlichen Fehler. Algorithmus 14 berechnet die optimale
Transformation TN eu R(4,4) , transformiert die Punkte des Ist-Datensatzes entsprechend
und liefert den durchschnittlichen Fehler. I R(4,4) sei die Einheitsmatrix.
Algorithmus 14 FastICP(P, M)
min :=
s := -trunc(search/2)
dy := s
for i := 1 to search do
dx := s
for j := 1 to search do
Y := BerechneNchstePunkte(P + (dx, dy, 0), M)
a
error := MinimiereFehler(Y)
if error < min then
dx := dx
dy := dy
min := error
end if
dx := dx +
end for
dy := dy +
end for
P := P + (dx , dy , 0)
TN eu := I + (dx , dy , 0) { Setzen der Translation in TN eu }
for i := 1 to iterations do
Y := BerechneNchstePunkte(P, M)
a
(error, T ) := MinimiereFehler(Y)
P := T P {Anwendung der berechneten Transformation T auf alle Punkte aus P}
TN eu :=TTN eu
end for

48

5
5.1

Systementwurf
Hardwarearchitektur

Im vorliegenden makroskopischen Aufbau besteht der 3D-Scanner im Wesentlichen aus den


beiden Komponenten Kamera und Video-Beamer. Zustzlich werden eine Frame-Grabbera
Karte fr den PC und ein Netzgert fr die Stromversorgung der Kamera bentigt. Das
u
a u
o
zeitlich konstante Muster fr den Video-Beamer wird mit einem kompakten Embedded-PC
u
mit eingebauter SVGA-Grakkarte generiert.
Es wurde besonderen Wert darauf gelegt, ein skalierbares Testsystem zu entwerfen, sodass
durch Variation der Anordnung von Kamera und Video-Beamer Objekte unterschiedlicher
Gre detailgetreu gescannt werden knnen. Hierzu sind sowohl die Kamera als auch der
o
o
Video-Beamer beweglich auf einer Schiene angebracht. Der Triangulationswinkel lsst sich
a
leicht durch Drehung der Kamera variieren.

Abbildung 21: Foto des 3D-Scanners

49

5.1.1

Kamera

Fr die Bildaufnahme wird eine Standard-PAL-Videokamera im Interlaced-Modus mit einer


u
Ausung von 640480 Bildpunkten verwendet. Einzelheiten sind dem Datenblatt im Anhang
o
zu entnehmen. Das Datenblatt des eingesetzten Objektivs ist ebenfalls im Anhang enthalten.
5.1.2

Frame-Grabber-Karte

Die Kamera wird uber eine Hauppauge WinTV PCI Frame-Grabber-Karte an den PC ange
schlossen, welche auf dem BT878-Chipsatz aufbaut.
5.1.3

Video-Beamer

Der eingesetzte Projektor ist ein besonders kompakter Video-Beamer mit SVGA-Eingang.
Der Hersteller und das Modell sind dem Anhang zu entnehmen.
5.1.4

PC

Als Test-PC wurde ein Intel PIII 1 GHz mit 512 MB SDRAM verwendet. Die einzige Hardwareschnittstelle zwischen PC und Scanner stellt ein PCI-Steckplatz mit eingebauter FrameGrabber-Karte dar.
5.1.5

Embedded-PC

Fr die Generierung des Signals fr den Video-Beamer wird ein Embedded-PC in Verbindung
u
u
mit einer herkmmlichen SVGA-Grakkarte verwendet. Das Betriebssystem DOS 6.22 wird
o
uber Floppy-Disk geladen. Ein mit Borland Turbo C++ speziell entwickeltes Programm, das

eine 8bit-Graustufen-Bitmap-Datei beliebiger Ausung (640 480, 800 600, 1024 768)
o
einlesen kann und uber den entsprechenden VESA-Modus ausgibt, wird durch Eintrag in die

Datei AUTOEXEC.BAT automatisch am Ende des Boot-Vorgangs aufgerufen. Die notwendigen BIOS-Aufrufe, insbesondere fr den Wechsel des Video-Modus und das Umschalten der
u
VESA-Bnke, erfolgen uber die Schnittstelle <dos.h>. Die Grakausgabe erfolgt schlielich
a

durch das Schreiben in den via Memory-Mapping zugnglichen Speicher der Grakkarte.
a

5.2

Kalibrier- und Scanvorgang

Das beschriebene System wird in einem zweistugen Verfahren kalibriert:


1. Kamerakalibrierung
2. Projektorkalibrierung
Fr beide Schritte werden quadratische Plexiglas-Platten der Dicke d = 10 mm verwendet.
u
Diese werden mit Hilfe eines rechtwinkligen Anschlags auf die Basis des Scanners aufgelegt
(vgl. Abbildung 21).
5.2.1

Kamerakalibrierung

Das Punktemuster wird auf einer Plexiglas-Platte angebracht. Durch Unterlegen von weiteren
Plexiglas-Platten kann das Punktemuster in verschiedenen denierten Hhen aufgenommen
o
werden.

50

Abbildung 22: Punkte-Muster mit eingezeichnetem Weltkoordinatensystem


Nach Denition eines Rechtssystems zeigt die z-Achse nach oben. Mit Hilfe des rechtwinkligen Anschlags fr die Plexiglas-Platten, der auf Abbildung 21 zu sehen ist, wird sicheru
gestellt, dass die z-Achse des Weltkoordinatensystems tatschlich orthogonal auf der Ebene
a
der Plexiglas-Platten steht. Seien gerade n Plexiglas-Platten der obersten Plexiglas-Platte
unterlegt und der Abstand der Punkte in waagrechter und senkrechter Richtung 10 mm,
dann lauten die Weltkoordinaten des rot markierten Punktes in Abbildung 22 P (40, 30, nd).
Durch zweckmige Justierung der Kamera, d.h. die x- und y-Achse von Bild- und Weltkoa
ordinatensystem verlaufen jeweils annhernd parallel, kann die Zuordnung der berechneten
a
Punktzentren durch Sortierung nach x- und y-Koordinate geschehen. Mit der so gewonnenen
Menge von Punktkorrespondenzen kann die Kamera nach dem in Abschnitt 4.1 vorgestellten
Verfahren nach [HKRW02] kalibriert werden.
In Abbildung 23 ist ein Foto des Systems whrend des Vorgangs der Kamerakalibrierung zu
a
sehen. Abbildung 24 zeigt einen entsprechenden Screenshot der Scanner-Applikation, wobei
die einzelnen erkannten Regionen rot und deren Schwerpunkte blau markiert sind.

Abbildung 23: Foto zur Kamerakalibrierung

51

Abbildung 24: Screenshot zur Kamerakalibrierung

5.2.2

Projektorkalibrierung

Die Projektorkalibrierung basiert auf dem in Abschnitt 4.4.1 vorgestellten Korrelationsalgorithmus. Eine Plexiglas-Platte mit weier Oberche wird, wiederum durch Unterlegen
a
von weiteren Plexiglas-Platten, in verschiedenen denierten Hhen aufgenommen. Die ero
ste Aufnahme ohne unterlegte Plexiglas-Platten bildet das Referenzmuster, das auch spter
a
fr den Scanvorgang verwendet wird. Fr feste Punkte p0 in diesem Referenzmuster wird
u
u
nun nach Korrespondenzen in den folgenden Aufnahmen gesucht. Fr jede gefundene 2Du
Korrespondenz (p0 , p) werden mit Hilfe der Parameter der kalibrierten Kamera die beiden
Sichtgeraden g0 und g1 berechnet und diese mit der xy-Ebene respektive der Ebene deniert
durch z = h = nd, mit n > 0, geschnitten.
Sei P0 (ni , mi , 0) der 3D-Punkt aus dem Referenzmuster und P (xi , yi , h) der korrespondierende 3D-Punkt aus dem projizierten Muster auf eine Ebene deniert durch z = h. Die
resultierende Punktkorrespondenz fr die Eingabe des Kalibrierungs-Algorithmus ist dann
u
deniert durch (P (xi , yi , h), P0 (ni , mi )). Die entsprechenden Verhltnisse sind in Abbildung
a
zweidimensional 25 dargestellt. Die entsprechende Szene des realen Systems ist in Abbildung
26 zu sehen.
Es sei betont, dass mit dieser Methode fr die Kalibrierung des Projektors das Originalmuster
u
dem System nicht bekannt sein muss. Alle Berechnungen erfolgen auf den mit der Kamera
aufgenommen Bilddaten.

52

Abbildung 25: Veranschaulichung der Berechnungen fr die Projektorkalibrierung


u

Abbildung 26: Foto zur Projektorkalibrierung

53

5.2.3

Scanvorgang

Mit der vorgestellten Methode der Projektorkalibrierung wird nicht die Projektion des OriginalMusters berechnet, sondern die Projektion des Referenzmusters. Damit wird ein Objektpunkt
whrend des Scanvorgangs wie folgt gewonnen. Fr jede mit Algorithmus 10 gefundene Kora
u
respondenz wird die dem 2D-Punkt p aus dem Kamerabild entsprechende Sichtgerade g1
durch Anwendung der Parameter der kalibrierten Kamera berechnet. Die Berechnung der
dem 2D-Punkt p0 aus dem Referenzmuster entsprechenden Sichtgerade g0 erfolgt auf dieselbe Weise. Der entsprechende 3D-Punkt P0 (n, m, 0) wird dann durch den Schnitt von g0 mit
der xy-Ebene gewonnen. Mit Hilfe der Parameter des kalibrierten Projektors kann nun die
Sichtgerade g2 durch Einsetzen der Koordinaten n, m bestimmt werden. Die Berechnung des
resultierenden Objektpunktes P erfolgt schlielich mit den Geraden g1 , g2 und den Betrachtungen aus Abschnitt 3.5. Die entsprechenden Verhltnisse sind in Abbildung 27 zweidimena
sional dargestellt.

Abbildung 27: Veranschaulichung der Berechnung eines Objektpunktes


Algorithmus 15 stellt die Folge aller Einzelschritte fr die Verarbeitung eines Einzelscans in
u
Pseudocode dar. Dabei beschreibt Pneu die Punktmenge des aktuellen gelterten Einzelscans
aus Algorithmus 12 und Palt die Punktmenge des letzten (akzeptierten) Einzelscans. T beschreibt die akkumulierte homogene Transformationsmatrix, mit der jeder neue Einzelscan
transformiert wird, um in Relation zum letzten Einzelscan bestmglich vorpositioniert zu
o
werden. Der Algorithmus FastICP (Algorithmus 14) transformiert die Punktmenge Pneu und
liefert zustzlich den Fehler error und die berechnete homogene Transformationsmatrix Tneu .
a
Als maximal zulssiger durchschnittlicher Fehler wurde maxerror = 0.7 gewhlt. G sei die
a
a
Gitter-Datenstruktur aus Abschnitt 4.5 und I R(4,4) die Einheitsmatrix.

54

Algorithmus 15 VerarbeiteEinzelscan(G)
Pneu := FiltereEinzelscan(G)
Pneu := T Pneu
Tneu = I
error := 0
if Palt = then
(Tneu , error) := FastICP(Pneu ,Palt )
end if
if error maxerror then
VisualisierePunktmenge(Pneu )
T := Tneu T
Palt := Pneu
end if
Abbildung 28 zeigt einen realen Scanvorgang, bei dem eine Porzellangur eines Hhnu
chens mit schwarzen Handschuhen frei gefhrt wird. Die Handschuhe haben den Zweck die
u
Erfassung der Hand zu verhindern. Abbildung 29 zeigt einen entsprechenden Screenshot der
Scanner-Applikation.

Abbildung 28: Foto eines realen Scanvorgangs

55

Abbildung 29: Screenshot whrend eines realen Scanvorgangs


a

5.3

Softwarearchitektur

Um eine saubere Trennung der einzelnen Programmteile zu gewhrleisten, wurde eine moa
dulare Architektur mit einem Objektorientierten Design (OOD) realisiert. Durch die Implementierung der entsprechenden Schnittstelle kann jedes Modul problemlos ausgetauscht
werden.
5.3.1

UML-Klassendiagramm des Gesamtsystems

Im nachfolgenden UML-Klassendiagramm sind alle Beziehungen aller Klassen zueinander ein


gezeichnet. Die Namen der einzelnen Methoden sind aus Grnden der Ubersichtlichkeit nur
u
bei den Schnittstellen-Klassen aufgefhrt.
u
Die Klasse COrganizer erstellt im Konstruktor alle Instanzen der im UML-Diagramm aufgefhrten Module. Des Weiteren stellt sie Methoden zur Bedienung des gesamten Softwareu
Systems zur Verfgung.
u

56

Abbildung 30: UML-Klassendiagramm des Gesamtsystems


5.3.2

Video-Capturing-Modul

Das Modul CVideoCapture ist fr die Kommunikation mit der Frame-Grabber-Karte zustnu
a
dig. Die gewonnenen Bilddaten werden uber die Schnittstelle CImageProcessorInterface an

COrganizer weitergereicht. Von dort aus werden die Daten an das jeweils bentigte Bildvero
arbeitungsmodul weitergeleitet. Die VfW-API bietet die Mglichkeit, sowohl einzelne Frames
o
als auch Sequenzen aufzunehmen. In beiden Fllen muss eine Callback-Funktion bestimmt
a
werden, um einen Zeiger auf die Bilddaten zu erhalten. Die Aufrufe an die VfW-API zur
Aufnahme von Bildern erfolgen asynchron.
5.3.3

Bildverarbeitungsmodule

Zu den Bildverarbeitungsmodulen zhlen CCentroidImageProcessor und CCorrelationImagea


Processor. Beide Module erhalten die zu verarbeitenden Bilddaten mittels der SchnittstellenMethode ProcessData. Die Ausgabedaten werden in Form von zweidimensionalen PunktKoordinaten uber die Schnittstelle CDataManagerInterface an das jeweilige Verwaltungsmo
57

dul weitergeleitet.
CCentroidImageProcessor berechnet die Zentren von dunklen Punkten auf einem hellen Hintergrund mit Algorithmus 4. CCorrelationImageProcessor ndet Korrespondenzen eines Referenzmusters im aktuellen Kamerabild mit Algorithmus 8 bzw. Algorithmus 10.
5.3.4

Verwaltungsmodule

Die drei Verwaltungsmodule CCameraManager, CProjectorManager und CScanManager sind


fr die Weiterverarbeitung der Daten zustndig, die mit Hilfe eines Bildverarbeitungsmoduls
u
a
aus den Bilddaten gewonnen werden. Die Verwaltungsmodule erhalten uber die uberladene

Schnittstellen-Methode AddElement ihre Eingabe. Die nicht bentigte Variante von Addo
Element wird mit einem leeren Rumpf als Dummy implementiert. Weiterhin informieren die
Bildverarbeitungsmodule durch Aufruf der Schnittstellen-Methode ProcessData die Verwaltungsmodule, dass ein Bild komplett bearbeitet worden ist.
Die Zuordnung der Verwaltungsmodule zu den Bildverarbeitungsmodulen ist in der nachfolgenden Tabelle aufgefhrt.
u

CCentroidImageProcessor
CameraManager

CCorrelationImageProcessor
CProjectorManager CScanManager

Tabelle 2: Zuordnung der Verwaltungsmodule zu den Bildverarbeitungsmodulen


Das Modul CCameraManager ist fr die Zuordnung der gefundenen 2D-Punkte zu den entu
sprechenden 3D-Punkten und die anschlieende Kamerakalibrierung mit Hilfe des Moduls
CCalibration zustndig, wie in Abschnitt 5.2.1 beschrieben. Das Modul CProjectorManaa
ger fhrt die Kalibrierung des Projektors durch, wie in Abschnitt 5.2.2 beschrieben, ebenu
falls mit Hilfe des Moduls CCalibration. Das Modul CScanManager ist fr den Scanvoru
gang zustndig, es berechnet den aktuellen Einzelscan, ltert diesen, fhrt die Registrierung
a
u
mit Hilfe des Moduls CICP durch, aktualisiert das Modul CVisualize und akkumuliert die
Gesamt-Transformationsmatrix.
Jedes Verwaltungsmodul besitzt durch das Erben der abstrakten Basisklasse CDataManagerBase zwei Verweise des Typs CCalibrationInterface auf das Modul CCalibration fr das
u
Kameramodell bzw. das Projektormodell.
5.3.5

Kalibrierungsmodul

Das Modul CCalibration implementiert das in Abschnitt 4.1 vorgestellte Kamera- und Projektormodell nach 4.1. Als Eingabe erhlt das Modul eine Menge von Punktkorrespondenzen.
a
Das Modul verbirgt die Parameter und stellt eine Methode fr die Berechnung der einem
u
2D-Bildpunkt entsprechenden Geraden im Weltkoordinatensystem zur Verfgung. Weiterhin
u
bietet das Modul Methoden fr die Serialisierung und Deserialisierung der Parameter.
u
Im System existieren fr die Kamera und den Projektor jeweils eine Instanz des Kalibrieu
rungsmoduls, da jeweils ein eigener Zustand fr die unterschiedlichen Parameter bentigt
u
o
wird. Damit ist streng genommen die Regel einer modularen Architektur verletzt, dass nur
eine Instanz jedes Moduls existieren darf. Der Charakter einer modularen Architektur bleibt
58

dennoch erhalten. Eine Realisierung mit Hilfe von Listen verschiedener Parametersttze ist
a
prinzipiell mglich, wurde jedoch aus Designgrnden abgelehnt.
o
u
5.3.6

Visualisierungsmodul

Das Visualisierungsmodul CVisualize implementiert eine schnelle 3D-Visualisierung des aktuellen Scanergebnisses als Punktwolke. Um die Hardwarebeschleunigung der Grakhardware
ausnutzen zu knnen, wird die OpenGL-API verwendet. Wird der Scanvorgang ausgesetzt, so
o
kann mit Hilfe der Tastatur die Position der virtuellen Kamera rotativ und translativ beliebig
verndert werden, um so verschiedene Sichten der Punktwolke zu erhalten.
a

5.4
5.4.1

Softwareumgebung
Betriebssystem

Die Software wurde unter Windows 2000 entwickelt. Damit stand ein stabiles Betriebssystem
inklusive einer komfortablen Entwicklungsumgebung und einer einfach zu bedienenden VideoSchnittstelle zur Verfgung. Die Software ist unter allen Windows-Betriebssystemen fr PCs
u
u
ohne Modikation einsetzbar. Durch die modulare Softwarearchitektur, die in Abschnitt 5.3
vorgestellt wurde, bedienen sich ausschlielich die GUI (Graphical User Interface) und das
Video-Capturing-Modul der Windows-API (Application Programming Interface). Somit kann
die Software unter nahezu jedem Betriebssystem, durch Implementierung einer GUI und
Austausch des Video-Capturing-Moduls, eingesetzt werden.
5.4.2

Programmiersprache

Als Programmiersprache wurde C++ gewhlt, da es galt ein uerst laufzeitkritisches System
a
a
mit einem Objektorientierten Design zu realisieren. Als Entwicklungsumgebung diente das
Microsoft Visual Studio 6, das sich durch komfortable Werkzeuge und im Besonderen durch
exzellente Debugging-Mglichkeiten auszeichnet.
o
5.4.3

APIs und Bibliotheken

Als GUI dient ein Win32-Dialog. Die Frame-Grabber-Karte wird mit Hilfe der VfW-API
(Video for Windows) angesprochen, die ebenfalls Teil der Windows-API ist.
Die online-Visualisierung erfolgt in einem zustzlichen Win32-Dialog mit Hilfe der OpenGLa
API (Open Graphics Library). Die OpenGL-API stellt eine plattformbergreifende standaru
disierte Schnittstelle zu den meisten 3D-Funktionen heutiger Grakhardware dar. Sie ist gut
dokumentiert und zeichnet sich durch einfache Bedienbarkeit aus. Des Weiteren existiert ein
groes Spektrum an Literatur. Die OpenGL-Bibliothek ist unter allen gngigen Betriebssya
stemen verfgbar und war deshalb letztlich DirectX vorzuziehen.
u
Fr die oine-Visualisierung wurde die 3D-Softwarebibliothek VTK (Visualization Toolkit)
u
verwendet. VTK setzt auf OpenGL auf und stellt somit eine Grakbiblitothek auf einem
hheren Abstraktionsniveau dar. Neben einer Vielzahl von Datenstrukturen, Filtern und
o
weiteren Algorithmen bietet VTK ein eigenes Dateiformat fr Punktwolken und Polygonu
Netze an. Entsprechende Module ermglichen das komfortable Einlesen und Schreiben der
o
Datenstze auf Basis dieses Dateiformats. [Kita] [Kitb]
a

59

Ergebnisse

Im Folgenden sollen die Ergebnisse dieser Arbeit in Form von einigen exemplarischen Scans
und in quantitativer Form, die Geschwindigkeit, Ausung und Genauigkeit betreend, voro
gestellt werden.

6.1

Exemplarische Scans

In Abbildung 31 sind zwei gerenderte Scans einer Porzellangur eines Hhnchens abgebildet.
u
Links ist ein Referenzscan mit dem 3D-Laser-Scanner aus [Aza03] abgebildet, rechts ein aus
fnf Einzelscans bestehender Gesamtscan mit dem vorliegenden System (vgl. Abbildungen
u
28 und 29) mit = 5 (Pixel) (vgl. Abschnitt 4.4). In Abbildung 32 ist der Vergleich der beiden Datenstze in Form eines Thermoplots zu sehen. Beide Abbildungen wurden mit einem
a
professionellen ReverseEngineering-CAD-Programm erstellt. Bis auf Abbildung 35 wurden
alle weiteren Abbildungen mit einer eigenen Applikation mit Hilfe der Grakbibliothek VTK
erstellt [Kita].

Abbildung 31: Zwei Scans einer Porzellangur eines Hhnchens: 3D-Laser-Scan und Scan mit
u
dem vorliegenden System
In Abbildung 33 ist die Visualisierung der Punktwolke eines Scans einer Ebene deniert
durch z = 10mm abgebildet. Der durchschnittliche Abstand der Punkte von deren Regressionsebene betrgt 0.12 mm, der maximale Abstand betrgt 0.47 mm. Der Winkelfehler der
a
a
Regressionsebene betrgt 0.07. Der sichtbare Treppeneekt ist entsteht dadurch, dass die
a
verwendete SSD-Korrelation keine Subpixel-Genauigkeit zu erzielen vermag (vgl. Abschnitt
4.4.2).
60

Abbildung 32: Thermoplot der Scans aus Abbildung 31

Abbildung 33: Scan einer Ebene

61

In Abbildung 34 ist die Folge der Einzelscans eines kompletten Scanvorgangs dargestellt.
Es ist zu sehen, wie sich die Punktwolke Schritt fr Schritt aufbaut, sodass schlielich die
u
gesamte Figur erfasst wird. Das Endergebnis ist in Form einer gerenderten Darstellung in
Abbildung 35 zu sehen. Hierbei wurde eine relativ hohe Ausung von = 2 (Pixel) vero
wendet (vgl. Abschnitt 4.4).

Abbildung 34: Sequenz der Einzelscans eines gesamten Scanvorgangs

Abbildung 35: Gerenderte Darstellung des Ergebnisses zu Abbildung 34

62

Abbildung 36 zeigt die gerenderte Darstellung eines Einzelscans einer Computer-Maus.


Es ist zu sehen, dass die gesamte Maus mit einem Einzelscan nicht erfasst werden konnte.
Abbildung 37 zeigt ebenfalls einen Einzelscan. Die Szene besteht aus drei lngeren, liegenden
a
Kreidestcken und einem senkrecht aufgestellten kurzen Kreidestck.
u
u

Abbildung 36: Gerenderte Darstellung eines Einzelscans einer Computer-Maus

Abbildung 37: Gerenderte Darstellung eines Einzelscans einer Szene bestehend aus Kreidestcken
u

63

6.2

Evaluierung

Die Ausung ist vor allem bestimmt durch die Ausung des CCD-Chips und die Wahl
o
o
der Konstante aus Abschnitt 4.4. In der aktuellen Implementierung wurde = 5 (Pixel)
gewhlt. Beim aktuellen Aufbau resultieren Verschiebungen von fnf Pixel im Kamerabild in
a
u
einem Abstand von etwa 0.9 mm in der xy-Ebene des Weltkoordinatensystems. Entsprechend
der gewhlten Gre des Suchgitters aus Abschnitt 4.4.3 knnen entsprechend den Berecha
o
o
nungen aus Abschnitt 4.5 je Einzelscan maximal 99 67 = 6633 akquiriert werden, unter
Bercksichtigung des Sachverhalts, dass alle Randpunkte whrend des Filterungsprozesses
u
a
eliminiert werden (vgl. Abschnitt 4.5). Bei der Wahl von = 1 (Pixel) kann bei gleichbleibender Gre des Suchgitters die maximale Ausung von 499 339 = 169161 Punkten
o
o
erreicht werden, bei einem Abstand der Punkte in der xy-Ebene von ca. 0.2 mm. Solch hohe
Ausungen sind jedoch im vorliegenden System mit heute verfgbaren PCs nicht sinnvoll
o
u
realisierbar.
Die Genauigkeit ist bestimmt durch die Hardware- bzw. Software-Komponenten Kamera,
Projektor, Korrelation und Registrierung. Die Genauigkeiten der Kamera und des Projektors knnen durch die berechneten Fehlerwerte derer Kalibrierung wiedergegeben werden.
o
Der durchschnittliche Fehler der Kamerakalibrierung betrgt 0.03 mm, der durchschnittlia
che Fehler der Projektorkalibrierung 0.06 mm. Da derzeit kein Korrelationsalgorithmus mit
Subpixel-Genauigkeit verwendet wird (vgl. Abschnitt 4.4.2), ist die Genauigkeit der Korrelation durch die Skalierung eines Pixels in das Weltkoordinatensystem gegeben. Im aktuellen
Aufbau hat die Suchstrecke der Verschiebungen (vgl. Abschnitt 4.4.2), die fr einen Hhenu
o
unterschied von 50 mm berechnet wird, eine Lnge von in etwa 110 Pixel. Somit betrgt die
a
a
maximal erreichbare Genauigkeit mit einer ganzzahligen Korrelation beim aktuellen Aufbau
in etwa 0.5 mm.
Den Flaschenhals der Genauigkeit stellt der Registrierungsalgorithmus dar. In der aktuellen
Implementierung wurde der Schwellwert fr den maximal zulssigen Fehler der Registrierung
u
a
mit 0.7 mm gewhlt (vgl. Abschnitt 5.2.3). Es sei jedoch angemerkt, dass bei einer falschen
a
Registrierung der tatschliche Fehler den angegebenen Wert uberschreiten kann. Die Genaua

igkeit der Registrierung hngt mageblich von der Suche nach einer hinreichend genauen
a
Initialbedingung ab, da der verwendete ICP-Algorithmus ansonsten in lokalen Minima konvergiert. In der aktuellen Implementierung wird eine einfache Suche in einem eingeschrnkten
a
Raum der mglichen Translationen in x- und in y-Richtung vorgenommen. Dies reicht nicht
o
aus, um die Genauigkeit der Einzelscans im Gesamtscan zu erhalten. Des Weiteren lsst sich
a
mit dieser einfachen Suche nach Translationen keine hinreichend genaue Initialbedingung
fr die Rotation berechnen, die fr das Erfassen von kompletten 3D-Oberchenmodellen
u
u
a
notwendig ist, im Gegensatz zu 2 1/2-dimensionalen Oberchenmodellen. Nachteilig wirkt
a
sich schlielich vor allem auch aus, dass sich Fehler whrend der Registrierung akkumulieren.
a
Mgliche Konzepte fr eine Lsung des Problems werden in Abschnitt 7.2.1 angesprochen.
o
u
o
Mit der aktuellen Implementierung wird eine Aktualisierungsrate von etwa 2 Hz auf dem
verwendeten 1 GHz PC erreicht (vgl. Abschnitt 5.1.4). Der Aufwand fr die Visualisierung
u
ist anfangs zu vernachlssigen, wchst jedoch mit zunehmender Zahl der Einzelscans an. Bei
a
a
der derzeit implementierten Suche nach der Initialbedingung fr den ICP-Algorithmus beanu
sprucht die Registrierung in etwa die Hlfte der Laufzeit der Korrelation. Fr eine hinreichend
a
u
genaue Bestimmung der Initialbedingung wird jedoch mehr Rechenzeit bentigt werden.
o
Durch die spezielle Implementierung der Suche des nchsten Punktes fr den ICP-Algorithmus
a
u
aus Abschnitt 4.6.1 konnte fr die Registrierung von zwei Datenstzen mit jeweils ca. 1600
u
a
64

Punkten eine Leistungssteigerung um etwa Faktor 25 erreicht werden. Durch die optimierte
Implementierung der SSD-Korrelation aus Abschnitt 4.4.2 wurde eine Leistungssteigerung
um Faktor 5 erreicht.

65

7
7.1

Diskussion
Zusammenfassung

Ziel dieser Diplomarbeit war es, einen Projektor-basierten 3D-Scanner fr die Erfassung von
u
dynamisch bewegten Objekten zu entwickeln, um auf diese Weise den iterativen Prozess
bestehend aus der Berechnung von Einzelscans und deren Registrierung komfortabel und interaktiv zu realisieren.

Zunchst wurde ein umfassender Uberblick uber den aktuellen Stand der Forschung gegeben.
a

Die vorgestellten Verfahren wurden miteinander verglichen, um das implementierte Verfahren


einordnen und bewerten zu knnen.
o
Anschlieend wurden die fr das Verstndnis der implementierten Algorithmik notwendigen
u
a
Grundlagen aus Bildverarbeitung und Photogrammetrie vermittelt.
Die konkrete Umsetzung der in den Grundlagen vorgestellten Verfahren stellt den Kern dieser
Arbeit dar. Nahezu jedes Verfahren musste fr den Einsatz in dem vorliegenden, uerst laufu
a
zeitkritischen System optimiert und angepasst werden. Fr die Korrelation wurden mehrere
u
Verfahren implementiert und getestet. Es stellte sich heraus, dass eine lokale Binarisierung mit
anschlieender SSD-Korrelation unter Einbezug der Epipolar-Geometrie das ezienteste und
robusteste Verfahren in Bezug auf unterschiedliche Oberchentexturen ist. Fr die Berecha
u
nung der SSD-Korrelation wurde eine besonders eziente Methode vorgestellt, mit deren Hilfe
es erst gelang, die Ezienzanforderungen des Systems auf heute verfgbaren PCs zu erfllen.
u
u
Fr die Filterung von Ausreiern aus den Einzelscans wurde ein eektiver und ezienter
u
Algorithmus vorgestellt. Der ICP-Algorithmus fr die Registrierung der Einzelscans wurde
u
modiziert und optimiert. Erst durch die spezielle Implementierung der Suche des nchsten
a
Punktes mit konstantem Aufwand wurde das Problem der Registrierung handhabbar, sodass
auch Datenstze mit mehreren Tausend Punkten uerst ezient registriert werden knnen.
a
a
o
Des Weiteren wurde eine auf das vorliegende System abgestimmte Suche nach einer Initialbedingung fr den ICP-Algorithmus vorgestellt. Fr die Kalibrierung des Projektors wurde
u
u
eine Vorgehensweise vorgestellt, die es ermglicht das System ohne Kenntnis des Originalmuo
sters zu kalibrieren. Somit bestehen keine Anforderungen an die Fertigungsgenauigkeit des
zu projizierenden Musters. Der Quellcode des eingesetzten Kalibrierungs-Algorithmus, den
Harald Hoppe freundlicherweise zur Verfgung gestellt hatte, wurde leicht modiziert. Die
u
ausschlielich fr den Kalibrierungs-Algorithmus notwendigen Datenstrukturen wie Matrizen
u
und Vektoren konnten aus der eigenen Studienarbeit ubernommen werden [Aza03].

Die in C++ umgesetzte modulare Softwarearchitektur erlaubt durch wohldenierte Schnittstellen einen problemlosen Austausch der einzelnen Module. Insbesondere kann durch Austausch der GUI und des Moduls fr das Video-Capturing die Software auf einfache Weise fr
u
u
den Betrieb unter anderen Betriebssystemen portiert werden.
Die Ergebnisse dieser Diplomarbeit, welche insbesondere Angaben uber die Geschwindigkeit,

Ausung und Genauigkeit des Systems umfassen, wurden abschlieend vorgestellt.


o

7.2

Ausblick

Das im vorliegenden System eingesetzte Verfahren besitzt ein groes Potenzial, das jedoch
erst durch den Einsatz speziell abgestimmter Hardware fr die Bildaufnahme und die Musteru
projektion und durch die Verfgbarkeit leistungsfhigerer PCs ausgeschpft werden kann. Des
u
a
o
Weiteren ist eine Verbesserung des Registrierungsvorgangs notwendig, um die Leistungsfhiga
66

keit des Verfahrens in vollem Umfang ausnutzen zu knnen. Die entsprechenden Ansatzpunkte
o
sollen abschlieend in knapper Form erlutert werden.
a
7.2.1

Verbesserte Registrierung

Wie bereits in Abschnitt 6.2 erlutert, stellt momentan die Registrierung der Einzelscans den
a
Flaschenhals in puncto Genauigkeit dar. Sowohl die Erhaltung der Genauigkeit der Einzelscans als auch die Mglichkeit der Erfassung von Volumina scheitern derzeit an der Suche
o
nach einer hinreichend genauen Initialbedingung fr den ICP-Algorithmus. In [LLH00] wird
u
ein mgliches Konzept fr die Lsung dieses Problems, basierend auf Simulated Annealing,
o
u
o
vorgestellt.
Ein weiterer Ansatzpunkt fr die Verbesserung des Registrierungsvorgangs ist die Einbezieu
hung der Flchennormalen der vernetzten Einzelscans in das Distanzma nach [DWJ98] (vgl.
a
Abschnitt 3.6.2).
Schlielich ist die Registrierung umso genauer, je hher die Aktualisierungsrate des Systems
o
ist, da dann die Translation und Rotation betragsmig kleiner ausfallen. Die Suche nach einer
a
Initialbedinung kann somit in einem deutlich feiner diskretisierten Suchraum vorgenommen
werden, was wesentlich zur Genauigkeit der Registrierung beitrgt.
a
7.2.2

Verbesserung der Projektor- und Bildaufnehmer-Hardware

Die Leistung des Systems hngt mageblich von der eingesetzten Projektor- und Bildaufa

nehmer-Hardware ab. Je hher die Ausung des CCD-Chips desto hhere Uberabtastungen
o
o
o
des projizierten Musters sind bei gleichbleibendem Umfang der Einzelscans mglich. Der Grad
o

der Uberabtastung beeinusst die Genauigkeit und Robustheit des Systems mageblich. Ein

hherer Grad der Uberabtastung erfordert die Vergrerung des Fensters fr die Korrelation
o
o
u
im gleichen Mae, um den Informationsgehalt konstant zu halten. Hierzu wird wiederum leistungsfhigere Rechnerhardware bentigt, um den hohen Ezienzanforderungen des Systems
a
o
gerecht werden zu knnen.
o

Um den Kammeekt bei der Aufnahme bewegter Objekte zu verhindern ist der Ubergang
zum Betrieb der Kameras im Progressive-Scan-Modus erforderlich.
Das Projektionssystem beeinusst die Robustheit des Verfahrens in Bezug auf unterschiedlich texturierte Oberchen mageblich. Der derzeit verwendete Projektor muss sich in einem
a
Mindestabstand von in etwas achtzig Zentimetern von dem zu scannenden Objekt benden,
um den Tiefenschrfebereich ausnutzen zu knnen. Da die Lichtintensitt mit der Entfernung
a
o
a
quadratisch abnimmt, kann somit die verfgbare Lichtleistung nicht ausgenutzt werden. Eiu
ne Blitzlichtquelle mit einer speziellen Apertur dagegen eignet sich ideal fr den Einsatz im
u
vorliegenden System. Durch das Blitzen kann das zu scannende Objekt zeitlich praktisch
festgehalten werden, sodass auch schnellere Handbewegungen keinen negativen Einuss auf
die Bildqualitt nehmen.
a
7.2.3

Leistungsfhigere Rechnerhardware
a

Das vorliegende System ist uerst laufzeitkritisch. Auf Basis des verwendeten Verfahrens
a
vermgen aufwndigere Korrelationsalgorithmen die Genauigkeit und die Robustheit des Syo
a
stems mageblich zu verbessern. So knnen mit dem vorgestellten Korrelationsalgorithmus
o
nach der Methode der kleinsten Quadrate Subpixel-Genauigkeit erreicht und projektive Verzerrungen bercksichtigt werden. Dies ist allerdings erst sinnvoll bei einem hinreichend hou
67


hen Grad der Uberabtastung und der damit verbundenen wachsenden Fenstergre mglich.
o
o
Fr den Einsatz eines solchen Verfahrens ist jedoch eine Steigerung der Rechenleistung um
u
schtzungsweise Faktor 5 notwendig, welche nach dem Mooreschen Gesetz in etwa drei bis
a
vier Jahren verfgbar sein wird. Ferner ist, wie in Abschnitt 6.2 erlutert, eine 25-fache hheu
a
o
re Ausung als derzeit verwendet realisierbar, wozu jedoch wiederum eine entsprechende
o
Leistungssteigerung der verwendeten Rechnerhardware notwendig ist.

68

Anhang A Mathematik
Numerik
Methode der kleinsten Quadrate Gegeben sei ein uberbestimmtes LGS der Form Ax =

(m,n) , x Rm und b Rn , mit m > n. Ein solches LGS ist im Allgemeinen


b, mit A R
nicht lsbar. Es wird jedoch angenommen, dass A vollen Rang besitzt: rang(A) = n =
o
min{n, m}. Mit der Methode der kleinsten Quadrate nach Gau lsst sich das vorliegende
a
LGS bestmglich lsen [HS02]:
o
o
Das Verfahren minimiert den Abstand Ax b bezglich der euklidischen Norm
u
min |Ax b|.
x

Die Verwendung der euklidischen Norm fhrt zu einer Minimierungsaufgabe mit einer difu
ferenzierbaren Funktion. Um die anfallenden Rechnungen zu vereinfachen, geht man zu der
quadrierten Funktion uber und deniert

= |Ax b|2

f (x1 , ..., xn )

= |(

akj xj bk )m |2
k=1

j=1
n
m

akj xj bk )2 .

k=1 j=1

Diese Summe von quadratischen Termen nimmt ihr Minimum an, wenn alle Ableitungen
gleich Null sind
0=

df
dx
i

=2
n

aki
k=1

j=1

(
k=1 j=1

akj x =
j

akj x bk )aki ,
j

i = 1, ..., n

aki bk ,

i = 1, ..., n.

k=1

Mit der Matrixnotation dieser n Gleichungen erhlt man das Gleichungssystem


a
AT Ax = AT b ,
das wegen rang(AT A) = rang(A) = n eindeutig lsbar ist. Man bezeichnet AT Ax = AT b
o
als die Normalgleichung zu A und b. Der Lsungsvektor x des vorliegenden LGS minimiert
o
den Abstand |Ax b|. Da AT A stets eine positiv denite Matrix ist, lsst sich x durch die
a
Berechnung der unteren Dreiecksmatrix von AT A und Anwendung der Cholesky-Verfahren
ezient berechnen.

69

Gau-Elimination Gegeben sei ein LGS Ax = b, mit A R(n,n) , x Rn und b Rn .


Weiterhin sei A regulr. Eine Mglichkeit, den Lsungsvektor x zu bestimmen, besteht in der
a
o
o
Anwendung der Gau-Elimination. Im Folgenden wird der Algorithmus mit einer SpaltenPivotsuche in Pseudocode dargestellt. Sollen A und b unverndert bleiben, so mssen die
a
u
Werte kopiert werden. Vgl. auch [HS02].

Algorithmus 16 LseLGSGau(A, b)
o
for i := 0 to n 1 do
max := 0
p := 1
for j := i to n 1 do
if (|aji | > max) then
max := |aji |
p := j
end if
end for
if p = 1 then
STOP {Matrix A ist nicht regulr}
a
end if
if p = i then
VertauscheZeilen(A, i, p)
s := bi
bi := bp
bp := s
end if
pivot := aii
for j := i + 1 to n 1 do
f actor := aji /pivot
bj := bj f actor bi
for k := i + 1 to n 1 do
ajk := ajk f actor aik
end for
end for
end for
for i := n 1 downto 0 do
sum := 0
for j := i + 1 to n 1 do
sum := sum + aij xj
end for
xi := (bi sum)/aii
end for

70

Cholesky-Verfahren Gegeben sei ein LGS Ax = b, mit A R(n,n) , x Rn und b Rn .


Weiterhin sei A positiv denit. Dann lsst sich der Lsungsvektor x mit dem Choleskya
o
Verfahren mit etwa dem halben Aufwand einer Gau-Elimination bestimmen. Im Folgenden
wird der Algorithmus in Pseudocode dargestellt, wobei L R(n,n) . Nach Ablauf des Algorithmus gilt A = LLT . A und b bleiben unverndert. Vgl. auch [HS02].
a

Algorithmus 17 LseLGSCholesky(A, b)
o
if a00 0 then
STOP {Matrix A ist nicht positiv denit}
end if
l00 =

a00

for i := 1 to n 1 do
for j := 0 to i 1 do
sum := aij
for k := 0 to j 1 do
sum := sum lik ljk
end for
lij := sum/ljj
end for
sum1 := aii
sum2 := bi
for j := 0 to i 1 do
2
sum1 := sum1 lij
sum2 := sum2 lij xj
end for
if sum 0 then
STOP {Matrix A ist nicht positiv denitiv}
end if

lii := sum1
xi := sum2/lii
end for
for i := n 1 downto 0 do
sum := xi
for j := i + 1 to n 1 do
sum := sum lji xj
end for
xi := sum/lii
end for

71

Vektorrechnung
a
Denition Seien a, b R3 und linear unabhngig, so ist das Vektorprodukt a b deniert
als der Vektor mit den folgenden Eigenschaften:
a b steht senkrecht auf a und b
a, b, a b bilden in dieser Folge ein Rechtssystem
|a b| = |a| |b| sin (a, b)

Es kann wie folgt berechnet werden:

a2 b3 a3 b2
a b = a3 b1 a1 b3
a1 b2 a2 b1
Es gelten folgende Rechenregeln [Koe83]:
(a + b) c = (a c) + (b c)

(73)

a b = b a

(74)

a (b c) = c (a b) .

(75)

a (b c) = b (ac) c (ab)

72

(76)

Anhang B Quellcode-Ausschnitte

Im Folgenden sind einige Quellcode-Ausschnitte aus dem aktuellen Stand der Scanner-Software
abgedruckt, die inzwischen uber 5000 Zeilen Quellcode umfasst. Dabei wurden diejenigen

Methoden aus den drei Modulen CCorrelationImageProcessor, CICP und CScanManager


ausgewhlt (vgl. Abschnitt 5.3), welche die konkrete Umsetzung der Algorithmik und der
a
Optimierungen aus Kapitel 4 in der Programmiersprache C++ veranschaulichen sollen.

73

"CorrelationImageProcessor.h"
"Common/Defines.h"
"Interfaces/DataManagerInterface.h"
"Common/Helpers.h"

int
int
int
int
int

PIXELS_IN_WINDOW = TILESIZE * TILESIZE;


MAX_SUM_SSD_BIN = int(PIXELS_IN_WINDOW / 4.5);
MAX_SUM_SSD_CALIB = PIXELS_IN_WINDOW * 3000;
MAX_SUM_GRUEN_CALIB = PIXELS_IN_WINDOW * 1000;
MAX_SUM_GRUEN_BIN
= PIXELS_IN_WINDOW * 15000;

Mittwoch Dezember 17, 2003 19:47

writebmp("out.bmp", m_pFrame, m_nWidth * m_nHeight);

if (m_bScan)
{
// only binarize for scanning
BinarizeLocal();

int CCorrelationImageProcessor::ProcessData()
{
m_pResampledPicture = new unsigned char[m_nWidth * m_nHeight];

// *****************************************************************
// ProcessData
// *****************************************************************

const
const
const
const
const

const int GRUEN_ITERATIONS = 3;


const int TILESIZE = 17;
const int TILESIZE_BINARIZE = 16;

#define USE_GRUEN_FOR_SCAN 0

// *****************************************************************
// defines and constants
// *****************************************************************

#include <stdio.h>
#include <math.h>

#include
#include
#include
#include

correlationimageprocessor.cpp

if (c < min)
min = c;

if (c > max)
max = c;

pHelper = m_pFrame + i * TILESIZE_BINARIZE * m_nWidth +


j * TILESIZE_BINARIZE;
for (y = 0; y < TILESIZE_BINARIZE; y++)
{
for (x = 0; x < TILESIZE_BINARIZE; x++)
{
unsigned char c = pHelper[x];

for (int i = 0; i < nTilesPerColumn; i++)


{
for (int j = 0; j < nTilesPerRow; j++)
{
unsigned char min = 255, max = 0;
int x, y;

void CCorrelationImageProcessor::BinarizeLocal()
{
unsigned char *pHelper = m_pFrame;
const int nTilesPerRow = m_nWidth / TILESIZE_BINARIZE;
const int nTilesPerColumn = m_nHeight / TILESIZE_BINARIZE;

// *****************************************************************
// Binarize
// *****************************************************************

return m_pDataManagerInterface>ProcessElements();

delete [] m_pResampledPicture;

if (!m_bScan)
{
// for callibration use correlation algorithm with
// search in two dimensions
FindAllCorrelationsCalibration();
}

if (m_bScan)
writebmp(TEMPLATE_FILENAME, m_pTemplate, m_nWidth * m_nHeight);

// *****************************************************************
// includes
// *****************************************************************

1/5

Seite 2/10

if (!m_pTemplate)
{
// allocate memory for template, copy it and write it to hard disk
m_pTemplate = new unsigned char[m_nWidth * m_nHeight];
memcpy(m_pTemplate, m_pFrame, m_nWidth * m_nHeight);

correlationimageprocessor.cpp

if (m_pTemplate)
{
// for scan use correlation algorithm with epipolar constraint
FindAllCorrelationsScan();
}

Mittwoch Dezember 17, 2003 19:45

*****************************************************************
Author: Pedram Azad
Date:
1.9.2003
*****************************************************************

Seite 1/10

//
//
//
//

correlationimageprocessor.cpp

*****************************************************************

CorrelationImageProcessor.cpp Implementation of
CCorrelationImageProcessor

*****************************************************************

//
//
//
//
//
//

Mittwoch Dezember 17, 2003 19:45

Gedruckt von Unbekannter Benutzer

pHelper += m_nWidth;

ShowPixel(j * TILESIZE_BINARIZE + x,
i * TILESIZE_BINARIZE + y, 255 * pHelper[x],
255 * pHelper[x], 255 * pHelper[x]);

pHelper = m_pFrame + i * TILESIZE_BINARIZE * m_nWidth +


j * TILESIZE_BINARIZE;
for (y = 0; y < TILESIZE_BINARIZE; y++)
{
for (x = 0; x < TILESIZE_BINARIZE; x++)
{
pHelper[x] = (pHelper[x] > threshold) ? 1 : 0;

return 0;

Mittwoch Dezember 17, 2003 19:47

int CCorrelationImageProcessor::FindAllCorrelationsCalibration()
{
for (int y = START_Y; y <= END_Y; y += DELTA)
{
if (FindSeed(START_X, y))
{
for (int x = START_X; x <= END_X; x += DELTA)
{

// *****************************************************************
// FindAllCorrelationsCalibration
// *****************************************************************

int CCorrelationImageProcessor::FindAllCorrelationsScan()
{
for (int y = START_Y; y <= END_Y; y += DELTA)
{
for (int x = START_X; x <= END_X; x += DELTA)
{
if (FindCorrelation(x, y))
{
m_pDataManagerInterface>AddElement(x, y, a0, b0);
}
else
m_pDataManagerInterface>AddElement(x, y, NaN, 0);
}
}

// *****************************************************************
// FindAllCorrelationsScan
// *****************************************************************

pHelper += m_nWidth;

correlationimageprocessor.cpp
Seite 3/10

return 0;

}
}
else
{
for (int x = START_X; x <= END_X; x += DELTA)
m_pDataManagerInterface>AddElement(NaN, NaN);
}

d1 += m;

bool CCorrelationImageProcessor::FindSeed(int sx, int sy)


{

// *****************************************************************
// FindSeed
// *****************************************************************

#if USE_GRUEN_FOR_SCAN
return (min <= MAX_SUM_SSD_BIN) && LeastSquaresCorrelation(i, j);
#else
return min <= MAX_SUM_SSD_BIN;
#endif
}

if (error < min)


{
a0 = d1;
b0 = d2;
min = error;
}

for (int d2 = 0; d2 <= end; d2++)


{
unsigned int error = SSDBin(i, j, round(d1), d2);

unsigned int min = 1;


double d1 = 0;

bool CCorrelationImageProcessor::FindCorrelation(int i, int j)


{
// get line
int end = (int) lines[i][j][0];
double m = lines[i][j][1];

// *****************************************************************
// FindCorrelation
// *****************************************************************

correlationimageprocessor.cpp

if (FindMatch(x, y))
{
m_pDataManagerInterface>AddElement(x + a0, y + b0);
}
else
m_pDataManagerInterface>AddElement(NaN, NaN);

Mittwoch Dezember 17, 2003 19:45

correlationimageprocessor.cpp

double threshold = (max min > 20) ? 0.5 * (min + max) : 255;

Mittwoch Dezember 17, 2003 19:45

2/5

Seite 4/10

Gedruckt von Unbekannter Benutzer

Seite 5/10

Mittwoch Dezember 17, 2003 19:47

a0 = best_a0;
b0 = best_b0;

if (res < min)


{
best_a0 = a0;
best_b0 = b0;
min = res;
}

unsigned int res = SSD(sx, sy, round(a0), round(b0));

for (int j = 5; j <= 5; j++)


{
for (int i = 2; i <= 2; i++)
{
a0 = old_a0 + i;
b0 = old_b0 + j;

bool CCorrelationImageProcessor::FindMatch(int sx, int sy)


{
double old_a0 = a0;
double old_b0 = b0;
double best_a0, best_b0;
unsigned int min = 1;

return sum;

offset += diff2;

pHelperTemplate = (unsigned int *) (((unsigned char *)


pHelperTemplate) + m_nWidth);
pHelperPicture = (unsigned int *) (((unsigned char *)
pHelperPicture) + m_nWidth);

for (int y = 0; y < TILESIZE; y++)


{
sum += *pHelperTemplate ^ *pHelperPicture;
sum += pHelperTemplate[1] ^ pHelperPicture[1];
sum += pHelperTemplate[2] ^ pHelperPicture[2];
sum += pHelperTemplate[3] ^ pHelperPicture[3];
sum += (((unsigned char *) pHelperTemplate)[16]) ^ (((unsigned char *)
pHelperPicture)[16]);

3/5

Seite 6/10

inline unsigned int CCorrelationImageProcessor::SSDBin(int i, int j,


int d1, int d2)
{
const int offset = j * m_nWidth + i (TILESIZE / 2) * (m_nWidth + 1);
unsigned int *pHelperTemplate = (unsigned int *) (m_pTemplate + offset);
unsigned int *pHelperPicture = (unsigned int *) (m_pFrame + d2 *
m_nWidth + d1 + offset);
unsigned int sum = 0;

// *****************************************************************
// SSDFast
// *****************************************************************

for (int y = 0; y < TILESIZE; y++)


{
for (int x = 0; x < TILESIZE; x++)
{
int c = m_pTemplate[offset] pHelperPicture[offset];
sum += c * c;
offset++;
}

inline unsigned int CCorrelationImageProcessor::SSD(int i, int j,


int d1, int d2)
{
unsigned char *pHelperPicture = m_pFrame + d2 * m_nWidth + d1;
const int diff2 = m_nWidth TILESIZE;
int offset = j * m_nWidth + i (TILESIZE / 2) * (m_nWidth + 1);
unsigned int sum = 0;

// *****************************************************************
// SSD
// *****************************************************************

correlationimageprocessor.cpp

return min <= MAX_SUM_SSD_CALIB && LeastSquaresCorrelation(sx, sy);

Mittwoch Dezember 17, 2003 19:45

correlationimageprocessor.cpp

return (min <= MAX_SUM_SSD_CALIB) && LeastSquaresCorrelation(sx, sy);

a0 = best_a0;
b0 = best_b0;

if (res < min)


{
best_a0 = a0;
best_b0 = b0;
min = res;
}

unsigned int res = SSD(sx, sy, round(a0), round(b0));

for (int j = 0; j < 50; j++)


{
for (int i = 0; i < 50; i++)
{
a0 = i;
b0 = j;

// *****************************************************************
// FindMatch
// *****************************************************************

correlationimageprocessor.cpp

unsigned int min = 1;


double best_a0 = 0, best_b0 = 0;

Mittwoch Dezember 17, 2003 19:45

Gedruckt von Unbekannter Benutzer

Seite 7/10

a1
a2
b1
b2

=
=
=
=

1;
0;
0;
1;

offset += diff2;

gx;
gx *
gx *
gy;
gy *
gy *
x;
y;

x;
y;

Mittwoch Dezember 17, 2003 19:47

int i = 0;
offset = sy * m_nWidth + sx diff3;
for (y = 0; y < TILESIZE; y++)
{
for (x = 0; x < TILESIZE; x++)

// build design matrix and observation vector


#define GRUEN_PARAMETERS
6
double A[PIXELS_IN_WINDOW][GRUEN_PARAMETERS];
double b[PIXELS_IN_WINDOW];

correlationimageprocessor.cpp

L[j][k] = sum / L[k][k];

for (i = 0; i < k; i++)


sum = L[j][i] * L[k][i];

// cholesky
double L[GRUEN_PARAMETERS][GRUEN_PARAMETERS];
L[0][0] = sqrt(ATA[0][0]);
int j, k;
for (j = 1; j < GRUEN_PARAMETERS; j++)
{
for (k = 0; k < j; k++)
{
double sum = ATA[j][k];

ATb[y] = sum;

m_pResampledPicture[offset++] = pFrame[j * m_nWidth + i];


}

ATA[y][x] = sum;
double sum = 0;

for (i = 0; i < PIXELS_IN_WINDOW; i++)


sum += A[i][y] * A[i][x];

for (y = 0; y < GRUEN_PARAMETERS; y++)


{
for (x = 0; x <= y; x++)
{
double sum = 0;

for (i = 0; i < PIXELS_IN_WINDOW; i++)


sum += A[i][y] * b[i];

offset += diff1;
}
// </resample>

=
=
=
=
=
=

i++;
offset++;

A[i][0]
A[i][1]
A[i][2]
A[i][3]
A[i][4]
A[i][5]

b[i] = m_pTemplate[offset] m_pResampledPicture[offset];

double gx = m_pResampledPicture[offset + 1]
m_pResampledPicture[offset];
double gy = m_pResampledPicture[offset + m_nWidth]
m_pResampledPicture[offset];

correlationimageprocessor.cpp

// build A.GetTransposed() * A and A.GetTransposed() * b


double ATA[GRUEN_PARAMETERS][GRUEN_PARAMETERS];
double ATb[GRUEN_PARAMETERS];

Mittwoch Dezember 17, 2003 19:45

if (i < 0 || i >= m_nWidth 1 || j < 0 || j >= m_nHeight 1)


return false;

for (int it = 0; it < GRUEN_ITERATIONS; it++)


{
// <resample>
int offset = sy * m_nWidth + sx diff3;
for (y = 0; y <= TILESIZE; y++)
{
for (x = 0; x <= TILESIZE; x++)
{
// round instead of bilinear interpolation
int i = round(sx + a0 + x * a1 + y * a2);
int j = round(sy + b0 + x * b1 + y * b2);

unsigned int nError;

double
double
double
double

bool CCorrelationImageProcessor::LeastSquaresCorrelation(int sx, int sy)


{
int x, y;
const int diff1 = m_nWidth TILESIZE 1;
const int diff2 = m_nWidth TILESIZE;
const int diff3 = (TILESIZE / 2) * (m_nWidth + 1);
unsigned char *pFrame = m_pFrame diff3;

// *****************************************************************
// LeastSquaresCorrelation
// *****************************************************************

correlationimageprocessor.cpp

return (sum & 0xff) + ((sum & 0xff00) >> 8) + ((sum & 0xff0000) >> 16) +
((sum & 0xff000000) >> 24);

Mittwoch Dezember 17, 2003 19:45

4/5

Seite 8/10

Gedruckt von Unbekannter Benutzer

yy[j] = sum / L[j][j];

//
a0
a1
a2
b0
b1
b2

add differences
+= xx[0];
+= xx[1];
+= xx[2];
+= xx[3];
+= xx[4];
+= xx[5];

xx[j] = sum / L[j][j];

for (i = GRUEN_PARAMETERS1; i > j; i)


sum = L[i][j] * xx[i];

double xx[GRUEN_PARAMETERS];
for (j = GRUEN_PARAMETERS1; j >= 0; j)
{
double sum = yy[j];

offset++;

offset += diff2;

m_pResampledPicture[offset] = pFrame[j * m_nWidth + i];

Mittwoch Dezember 17, 2003 19:47

correlationimageprocessor.cpp

if (i < 0 || i >= m_nWidth 1 || j < 0 || j >= m_nHeight 1)


return false;

offset = sy * m_nWidth + sx diff3;

if (m_bScan)
return nError <= MAX_SUM_GRUEN_BIN;
else
return nError <= MAX_SUM_GRUEN_CALIB;

offset += diff2;
}
// </result>

offset++;
}

double yy[GRUEN_PARAMETERS];
for (j = 0; j < GRUEN_PARAMETERS; j++)
{
double sum = ATb[j];

for (i = 0; i < j; i++)


sum = L[j][i] * yy[i];

correlationimageprocessor.cpp

nError = 0;
for (y = 0; y < TILESIZE; y++)
{
for (x = 0; x < TILESIZE; x++)
{
int c = m_pResampledPicture[offset] m_pTemplate[offset];

Mittwoch Dezember 17, 2003 19:45

nError += c * c;

L[j][j] = sqrt(sum);

Seite 9/10

// <result>
int offset = sy * m_nWidth + sx diff3;
for (y = 0; y < TILESIZE; y++)
{
for (x = 0; x < TILESIZE; x++)
{
// round instead of bilinear interpolation
int i = round(sx + a0 + x * a1 + y * a2);
int j = round(sy + b0 + x * b1 + y * b2);

correlationimageprocessor.cpp

for (i = 0; i < j; i++)


sum = L[j][i] * L[j][i];

double sum = ATA[j][j];

Mittwoch Dezember 17, 2003 19:45

5/5

Seite 10/10

Gedruckt von Unbekannter Benutzer

int DISTANCE_SQUARED_THRESHOLD = 25;


int ITERATIONS = 10;
int OVERSAMPLE = 2;
double MAX_ERROR = 0.7;

Mittwoch Dezember 17, 2003 19:48

void CICP::FindCPsFast(double** ppSourcePoints, int nSourcePoints,


double** ppTargetPoints, int nTargetPoints)
{
const int maxabs = 9999999;

// *****************************************************************
// FindCPsFast
// *****************************************************************

CICP::~CICP()
{
}

// *****************************************************************
// Destructor
// *****************************************************************

CICP::CICP()
{
for (int i = 0; i < maxdim; i++)
for (int j = 0; j < maxdim; j++)
m_grid[i][j][3] = 0;
}

// *****************************************************************
// Constructor
// *****************************************************************

const
const
const
const

// *****************************************************************
// constants
// *****************************************************************

#include "ICP.h"
#include <stdio.h>
#include <math.h>

// *****************************************************************
// includes
// *****************************************************************

*****************************************************************
Author: Pedram Azad
Date:
6.9.2003
*****************************************************************

//
//
//
//

icp.cpp

*****************************************************************

ICP.cpp Implementation of CICP

*****************************************************************

Mittwoch Dezember 17, 2003 19:45

//
//
//
//
//

Seite 1/7

icp.cpp

icp.cpp

= ppTargetPoints[i][0];
= ppTargetPoints[i][1];
= ppTargetPoints[i][2];

i < nTargetPoints; i++)

int yy = int(OVERSAMPLE * (y ymin));


int xx = int(OVERSAMPLE * (x xmin));

for (i = 0;
{
double x
double y
double z

if (xsize <= 0 || xsize > maxdim || ysize <= 0 || ysize > maxdim)
return;

int xsize = OVERSAMPLE * (xmax xmin + 1);


int ysize = OVERSAMPLE * (ymax ymin + 1);

if (y > ymax)
ymax = y;

if (y < ymin)
ymin = y;

if (x > xmax)
xmax = x;

if (x < xmin)
xmin = x;

for (i = 0; i < nSourcePoints; i++)


{
int x = int(ppSourcePoints[i][0]);
int y = int(ppSourcePoints[i][1]);

if (y > ymax)
ymax = y;

if (y < ymin)
ymin = y;

if (x > xmax)
xmax = x;

if (x < xmin)
xmin = x;

for (i = 0; i < nTargetPoints; i++)


{
int x = int(ppTargetPoints[i][0]);
int y = int(ppTargetPoints[i][1]);

m_nLandmarks = 0;

const int search = 3;


int xmin = maxabs;
int ymin = maxabs;
int xmax = maxabs;
int ymax = maxabs;
int i, j, k;
static double idcounter = 0;

Mittwoch Dezember 17, 2003 19:45

1/4

Seite 2/7

Gedruckt von Unbekannter Benutzer

icp.cpp

if (ds < min)


{
best_j = j;
best_k = k;
min = ds;
}

sum += sqrt(x1 * x1 + x2 * x2 + x3 * x3);

icp.cpp

// copy original points


double **ppOriginalSourcePoints = new double*[nSourcePoints];
for (j = 0; j < nSourcePoints; j++)

if (nSourcePoints <= 2 || nTargetPoints <= 2)


return false;

idcounter++;

matrix[i][i] = 1.0;
finalMatrix[i][i] = 1.0;

// init transformation matrix with unit


for (i = 0; i < 4; i++)
{
for (j = 0; j < 4; j++)
{
matrix[i][j] = 0.0;
finalMatrix[i][j] = 0.0;
}

bool CICP::ICP(double **ppSourcePoints, int nSourcePoints,


double **ppTargetPoints, int nTargetPoints, double finalMatrix[4][4])
{
double error, matrix[4][4];
int i, j, k;

*****************************************************************
ICP (public)
input: list of source and target points
output: transformation matrix and transformed source points
(original source points will be replaced by transformed ones)
*****************************************************************

return sum / m_nLandmarks;

Mittwoch Dezember 17, 2003 19:48

2/4

Seite 4/7

double x1 = matrix[0][0] * x + matrix[0][1] * y + matrix[0][2] * z +


matrix[0][3] m_targetLandmarks[j][0];
double x2 = matrix[1][0] * x + matrix[1][1] * y + matrix[1][2] * z +
matrix[1][3] m_targetLandmarks[j][1];
double x3 = matrix[2][0] * x + matrix[2][1] * y + matrix[2][2] * z +
matrix[2][3] m_targetLandmarks[j][2];

x;
y;
z;
m_grid[best_j][best_k][0];
m_grid[best_j][best_k][1];
m_grid[best_j][best_k][2];

double ds = x1 * x1 + x2 * x2 + x3 * x3;

if (min != DISTANCE_SQUARED_THRESHOLD)
{
m_sourceLandmarks[m_nLandmarks][0] =
m_sourceLandmarks[m_nLandmarks][1] =
m_sourceLandmarks[m_nLandmarks][2] =
m_targetLandmarks[m_nLandmarks][0] =
m_targetLandmarks[m_nLandmarks][1] =
m_targetLandmarks[m_nLandmarks][2] =
m_nLandmarks++;
}

LandmarkTransform(m_sourceLandmarks, m_targetLandmarks,
m_nLandmarks, matrix);

for (int j = 0; j < m_nLandmarks; j++)


{
double x = m_sourceLandmarks[j][0];
double y = m_sourceLandmarks[j][1];
double z = m_sourceLandmarks[j][2];

//
//
//
//
//
//

icp.cpp

FindCPsFast(ppSourcePoints, nSourcePoints, ppTargetPoints, nTargetPoints);

Mittwoch Dezember 17, 2003 19:45

= ppSourcePoints[i][0];
= ppSourcePoints[i][1];
= ppSourcePoints[i][2];

double sum = 0;

for (j = start_j; j <= end_j; j++)


{
for (k = start_k; k <= end_k; k++)
{
if (m_grid[j][k][3] == idcounter)
{
double x1 = x m_grid[j][k][0];
double x2 = y m_grid[j][k][1];
double x3 = z m_grid[j][k][2];

Seite 3/7

double CICP::DoStep(double** ppSourcePoints, int nSourcePoints,


double** ppTargetPoints, int nTargetPoints, double matrix[4][4])

x;
y;
z;
idcounter;

i < nSourcePoints; i++)

=
=
=
=

int yy = int(OVERSAMPLE * (y ymin));


int xx = int(OVERSAMPLE * (x xmin));
double min = DISTANCE_SQUARED_THRESHOLD;
int best_j, best_k;
int start_j = (yy search > 0) ? yy search : 0;
int start_k = (xx search > 0) ? xx search : 0;
int end_j = (yy + search < maxdim) ? yy + search : maxdim 1;
int end_k = (xx + search < maxdim) ? xx + search : maxdim 1;

for (i = 0;
{
double x
double y
double z

m_grid[yy][xx][0]
m_grid[yy][xx][1]
m_grid[yy][xx][2]
m_grid[yy][xx][3]

Mittwoch Dezember 17, 2003 19:45

Gedruckt von Unbekannter Benutzer

dx += 0.5;

// perform transformation
for (j = 0; j < nSourcePoints; j++)
{
double x = ppSourcePoints[j][0];
double y = ppSourcePoints[j][1];

error = DoStep(ppSourcePoints, nSourcePoints, ppTargetPoints,


nTargetPoints, matrix);

Mittwoch Dezember 17, 2003 19:48

for (i = 0; i < ITERATIONS; i++)

finalMatrix[0][3] += best_dx;
finalMatrix[1][3] += best_dy;

for (j = 0; j < nSourcePoints; j++)


{
ppSourcePoints[j][0] = ppOriginalSourcePoints[j][0] + best_dx;
ppSourcePoints[j][1] = ppOriginalSourcePoints[j][1] + best_dy;
ppSourcePoints[j][2] = ppOriginalSourcePoints[j][2];
}

dy += 0.5;

if (error != NaN && error < min)


{
min = error;
best_dx = dx;
best_dy = dy;
}

double error = DoStep(ppSourcePoints, nSourcePoints,


ppTargetPoints, nTargetPoints, matrix);

for (j = 0; j < 5; j++)


{
// pack1
for (k = 0; k < nSourcePoints; k++)
{
ppSourcePoints[k][0] = ppOriginalSourcePoints[k][0] + dx;
ppSourcePoints[k][1] = ppOriginalSourcePoints[k][1] + dy;
ppSourcePoints[k][2] = ppOriginalSourcePoints[k][2];
}

// go
double best_dx = 0, best_dy = 0, dy = 1;
for (i = 0; i < 11; i++)
{
double dx = 1;

icp.cpp

ppOriginalSourcePoints[j] = new double[3];


ppOriginalSourcePoints[j][0] = ppSourcePoints[j][0];
ppOriginalSourcePoints[j][1] = ppSourcePoints[j][1];
ppOriginalSourcePoints[j][2] = ppSourcePoints[j][2];

// init
double min = 999999;

Mittwoch Dezember 17, 2003 19:45

Seite 5/7

icp.cpp

for (j = 0; j < nSourcePoints; j++)

3/4

Seite 6/7

// update total tranformation matrix


finalMatrix[0][0] = matrix[0][0] * finalMatrix[0][0] +
matrix[0][1] * finalMatrix[1][0] + matrix[0][2] * finalMatrix[2][0]
matrix[0][3] * finalMatrix[3][0];
finalMatrix[0][1] = matrix[0][0] * finalMatrix[0][1] +
matrix[0][1] * finalMatrix[1][1] + matrix[0][2] * finalMatrix[2][1]
matrix[0][3] * finalMatrix[3][1];
finalMatrix[0][2] = matrix[0][0] * finalMatrix[0][2] +
matrix[0][1] * finalMatrix[1][2] + matrix[0][2] * finalMatrix[2][2]
matrix[0][3] * finalMatrix[3][2];
finalMatrix[0][3] = matrix[0][0] * finalMatrix[0][3] +
matrix[0][1] * finalMatrix[1][3] + matrix[0][2] * finalMatrix[2][3]
matrix[0][3] * finalMatrix[3][3];
finalMatrix[1][0] = matrix[1][0] * finalMatrix[0][0] +
matrix[1][1] * finalMatrix[1][0] + matrix[1][2] * finalMatrix[2][0]
matrix[1][3] * finalMatrix[3][0];
finalMatrix[1][1] = matrix[1][0] * finalMatrix[0][1] +
matrix[1][1] * finalMatrix[1][1] + matrix[1][2] * finalMatrix[2][1]
matrix[1][3] * finalMatrix[3][1];
finalMatrix[1][2] = matrix[1][0] * finalMatrix[0][2] +
matrix[1][1] * finalMatrix[1][2] + matrix[1][2] * finalMatrix[2][2]
matrix[1][3] * finalMatrix[3][2];
finalMatrix[1][3] = matrix[1][0] * finalMatrix[0][3] +
matrix[1][1] * finalMatrix[1][3] + matrix[1][2] * finalMatrix[2][3]
matrix[1][3] * finalMatrix[3][3];
finalMatrix[2][0] = matrix[2][0] * finalMatrix[0][0] +
matrix[2][1] * finalMatrix[1][0] + matrix[2][2] * finalMatrix[2][0]
matrix[2][3] * finalMatrix[3][0];
finalMatrix[2][1] = matrix[2][0] * finalMatrix[0][1] +
matrix[2][1] * finalMatrix[1][1] + matrix[2][2] * finalMatrix[2][1]
matrix[2][3] * finalMatrix[3][1];
finalMatrix[2][2] = matrix[2][0] * finalMatrix[0][2] +
matrix[2][1] * finalMatrix[1][2] + matrix[2][2] * finalMatrix[2][2]
matrix[2][3] * finalMatrix[3][2];
finalMatrix[2][3] = matrix[2][0] * finalMatrix[0][3] +
matrix[2][1] * finalMatrix[1][3] + matrix[2][2] * finalMatrix[2][3]
matrix[2][3] * finalMatrix[3][3];
finalMatrix[3][0] = matrix[3][0] * finalMatrix[0][0] +
matrix[3][1] * finalMatrix[1][0] + matrix[3][2] * finalMatrix[2][0]
matrix[3][3] * finalMatrix[3][0];
finalMatrix[3][1] = matrix[3][0] * finalMatrix[0][1] +
matrix[3][1] * finalMatrix[1][1] + matrix[3][2] * finalMatrix[2][1]
matrix[3][3] * finalMatrix[3][1];
finalMatrix[3][2] = matrix[3][0] * finalMatrix[0][2] +
matrix[3][1] * finalMatrix[1][2] + matrix[3][2] * finalMatrix[2][2]
matrix[3][3] * finalMatrix[3][2];
finalMatrix[3][3] = matrix[3][0] * finalMatrix[0][3] +
matrix[3][1] * finalMatrix[1][3] + matrix[3][2] * finalMatrix[2][3]
matrix[3][3] * finalMatrix[3][3];

icp.cpp

ppSourcePoints[j][0] = matrix[0][0] * x + matrix[0][1] * y +


matrix[0][2] * z + matrix[0][3];
ppSourcePoints[j][1] = matrix[1][0] * x + matrix[1][1] * y +
matrix[1][2] * z + matrix[1][3];
ppSourcePoints[j][2] = matrix[2][0] * x + matrix[2][1] * y +
matrix[2][2] * z + matrix[2][3];

double z = ppSourcePoints[j][2];

Mittwoch Dezember 17, 2003 19:45

Gedruckt von Unbekannter Benutzer

return error != NaN && error < MAX_ERROR;

Mittwoch Dezember 17, 2003 19:48

delete [] ppOriginalSourcePoints[j];
delete [] ppOriginalSourcePoints;

Mittwoch Dezember 17, 2003 19:45

icp.cpp
Seite 7/7

icp.cpp

4/4

Gedruckt von Unbekannter Benutzer

Mittwoch Dezember 17, 2003 19:45

scanmanager.cpp

camera line:
_x = _a + _u * r
projector line: _x = _b + _v * s
(x, y) is in template
(x + dShiftX, y + dShiftY) in camera image

Mittwoch Dezember 17, 2003 19:48

// get _b and _v
CVec3d b(m_z1, m_z2, m_z3);

// get _a and _u
// the center of projection of the camera is already assigned to a
u = m_pCameraModel>GetWorldCoordinates(x + dShiftX, y + dShiftY);

// reference was the first plane (z = 0)


double t = a.m_dX3 / u.m_dX3;
double dX = a.m_dX1 + t * u.m_dX1;
double dY = a.m_dX2 + t * u.m_dX2;

// find camera projection of pixel (x, y) on world plane dZ = 0


CVec3d a = m_pCameraModel>GetCenter();
CVec3d u = m_pCameraModel>GetWorldCoordinates(x, y);

//
//
//
//

return 0;

if (dShiftX == NaN)
{
// add to point grid
m_pointGrid[y_pos][x_pos][2] = NaN;

scanmanager.cpp

return 0;

// add to point grid


m_pointGrid[y_pos][x_pos][0] = world.m_dX1;
m_pointGrid[y_pos][x_pos][1] = world.m_dX2;
m_pointGrid[y_pos][x_pos][2] = world.m_dX3;

// find "intersection" of two straight lines


CVec3d x1 = a + u * r;
CVec3d x2 = b + v * s;
CVec3d world = (x1 + x2) * 0.5;

double s = yy1 / L11;


double r = (yy0 + L10 * s) / L00;

double yy0 = ATb0 / L00;


double yy1 = (ATb1 L10 * yy0) / L11;

double L00 = sqrt(ATA00);


double L10 = ATA10 / L00;
double L11 = sqrt(ATA11 L10 * L10);

and A.GetTransposed() * b
* A10 + A20 * A20;
* A10 + A21 * A20;
* A11 + A21 * A21;
b1 + A20 * b2;
b1 + A21 * b2;

double A01 = v.m_dX1;


double A11 = v.m_dX2;
double A21 = v.m_dX3;
a.m_dX1;
a.m_dX2;
a.m_dX3;

// filter
for (i = 1; i < MAX_POINTS_Y 1; i++)
{
for (j = 1; j < MAX_POINTS_X 1; j++)
{
if (m_pointGrid[i][j][2] != NaN)
{
int sum = 0;
sum += m_pointGrid[i
][j + 1][2] == NaN ||
fabs(m_pointGrid[i
][j + 1][2]
m_pointGrid[i][j][2]) > Z_FILTER_THRESHOLD;
sum += m_pointGrid[i
][j 1][2] == NaN ||
fabs(m_pointGrid[i
][j 1][2]

bool CScanManager::ProcessAllElements()
{
double matrix[4][4];
double **ppTemp;
int i, j;

= b
A00 = u.m_dX1;
A10 = u.m_dX2;
A20 = u.m_dX3;
b0 = b.m_dX1
b1 = b.m_dX2
b2 = b.m_dX3

// build A.GetTransposed() * A
double ATA00 = A00 * A00 + A10
double ATA10 = A01 * A00 + A11
double ATA11 = A01 * A01 + A11
double ATb0 = A00 * b0 + A10 *
double ATb1 = A01 * b0 + A11 *

// A x
double
double
double
double
double
double

CVec3d v = CVec3d(dX, dY, 0) b;

Mittwoch Dezember 17, 2003 19:45

scanmanager.cpp

Seite 1/5

int CScanManager::AddElement(int x, int y, double dShiftX, double dShiftY)


{
int x_pos = (x START_X) / DELTA;
int y_pos = (y START_Y) / DELTA;

const int Z_FILTER_THRESHOLD = 2;

#include <stdio.h>
#include <math.h>

// icp
#include "ICP/ICP.h"

// error codes
#include "Common/ErrorCodes.h"

// opengl visualizer
#include "Visualizer/OpenGLVisualizer.h"

// visualizer
#include "Visualizer/Visualizer.h"

// camera model
#include "Interfaces/CameraModelInterface.h"

// own header
#include "ScanManager.h"

1/3

Seite 2/5

Gedruckt von Unbekannter Benutzer

if (sum < 3)
{
m_ppPointList[m_nPoints][0] = m_pointGrid[i][j][0];
m_ppPointList[m_nPoints][1] = m_pointGrid[i][j][1];
m_ppPointList[m_nPoints][2] = m_pointGrid[i][j][2];
m_nPoints++;
}

Mittwoch Dezember 17, 2003 19:48

if (m_nLastPoints > 0)
{
// run icp
bRet = m_pICP>ICP(m_ppPointList, m_nPoints, m_ppLastPointList,

bool bRet = true;


bool bICP = false;

m_ppPointList[i][0] = m_transformationMatrix[0][0] * x +
m_transformationMatrix[0][1] * y +
m_transformationMatrix[0][2] * z +
m_transformationMatrix[0][3];
m_ppPointList[i][1] = m_transformationMatrix[1][0] * x +
m_transformationMatrix[1][1] * y +
m_transformationMatrix[1][2] * z +
m_transformationMatrix[1][3];
m_ppPointList[i][2] = m_transformationMatrix[2][0] * x +
m_transformationMatrix[2][1] * y +
m_transformationMatrix[2][2] * z +
m_transformationMatrix[2][3];

// transform new points with (last) transformation matrix


for (i = 0; i < m_nPoints; i++)
{
double x = m_ppPointList[i][0];
double y = m_ppPointList[i][1];
double z = m_ppPointList[i][2];

if (m_nPoints < 500)


return false;

scanmanager.cpp

m_pointGrid[i][j][2]) > Z_FILTER_THRESHOLD;


sum += m_pointGrid[i + 1][j + 1][2] == NaN ||
fabs(m_pointGrid[i + 1][j + 1][2]
m_pointGrid[i][j][2]) > Z_FILTER_THRESHOLD;
sum += m_pointGrid[i + 1][j 1][2] == NaN ||
fabs(m_pointGrid[i + 1][j 1][2]
m_pointGrid[i][j][2]) > Z_FILTER_THRESHOLD;
sum += m_pointGrid[i + 1][j
][2] == NaN ||
fabs(m_pointGrid[i + 1][j
][2]
m_pointGrid[i][j][2]) > Z_FILTER_THRESHOLD;
sum += m_pointGrid[i 1][j + 1][2] == NaN ||
fabs(m_pointGrid[i 1][j + 1][2]
m_pointGrid[i][j][2]) > Z_FILTER_THRESHOLD;
sum += m_pointGrid[i 1][j 1][2] == NaN ||
fabs(m_pointGrid[i 1][j 1][2]
m_pointGrid[i][j][2]) > Z_FILTER_THRESHOLD;
sum += m_pointGrid[i 1][j
][2] == NaN ||
fabs(m_pointGrid[i 1][j
][2]
m_pointGrid[i][j][2]) > Z_FILTER_THRESHOLD;

Mittwoch Dezember 17, 2003 19:45

scanmanager.cpp

if (bICP)
{
// update total tranformation matrix
m_transformationMatrix[0][0] = matrix[0][0] *
m_transformationMatrix[0][0] + matrix[0][1]
m_transformationMatrix[1][0] + matrix[0][2]
m_transformationMatrix[2][0] + matrix[0][3]
m_transformationMatrix[3][0];
m_transformationMatrix[0][1] = matrix[0][0] *
m_transformationMatrix[0][1] + matrix[0][1]
m_transformationMatrix[1][1] + matrix[0][2]
m_transformationMatrix[2][1] + matrix[0][3]
m_transformationMatrix[3][1];
m_transformationMatrix[0][2] = matrix[0][0] *
m_transformationMatrix[0][2] + matrix[0][1]
m_transformationMatrix[1][2] + matrix[0][2]
m_transformationMatrix[2][2] + matrix[0][3]
m_transformationMatrix[3][2];
m_transformationMatrix[0][3] = matrix[0][0] *
m_transformationMatrix[0][3] + matrix[0][1]
m_transformationMatrix[1][3] + matrix[0][2]
m_transformationMatrix[2][3] + matrix[0][3]
m_transformationMatrix[3][3];
m_transformationMatrix[1][0] = matrix[1][0] *
m_transformationMatrix[0][0] + matrix[1][1]
m_transformationMatrix[1][0] + matrix[1][2]
m_transformationMatrix[2][0] + matrix[1][3]
m_transformationMatrix[3][0];
m_transformationMatrix[1][1] = matrix[1][0] *
m_transformationMatrix[0][1] + matrix[1][1]
m_transformationMatrix[1][1] + matrix[1][2]
m_transformationMatrix[2][1] + matrix[1][3]
m_transformationMatrix[3][1];
m_transformationMatrix[1][2] = matrix[1][0] *
m_transformationMatrix[0][2] + matrix[1][1]
m_transformationMatrix[1][2] + matrix[1][2]
m_transformationMatrix[2][2] + matrix[1][3]
m_transformationMatrix[3][2];
m_transformationMatrix[1][3] = matrix[1][0] *
m_transformationMatrix[0][3] + matrix[1][1]
m_transformationMatrix[1][3] + matrix[1][2]
m_transformationMatrix[2][3] + matrix[1][3]
m_transformationMatrix[3][3];
m_transformationMatrix[2][0] = matrix[2][0] *
m_transformationMatrix[0][0] + matrix[2][1]
m_transformationMatrix[1][0] + matrix[2][2]
m_transformationMatrix[2][0] + matrix[2][3]
m_transformationMatrix[3][0];
m_transformationMatrix[2][1] = matrix[2][0] *

*
*
*

*
*
*

*
*
*

*
*
*

*
*
*

*
*
*

*
*
*

*
*
*

*
*
*

2/3

Seite 4/5

if (bRet)
{
// viusalize transformed points
for (i = 0; i < m_nPoints; i++)
{
m_pVisualizer>AddPoint(m_ppPointList[i][0], m_ppPointList[i][1],
m_ppPointList[i][2]);
}

m_nLastPoints, matrix);
bICP = true;

Mittwoch Dezember 17, 2003 19:45

scanmanager.cpp

Seite 3/5

Gedruckt von Unbekannter Benutzer

return true;

Mittwoch Dezember 17, 2003 19:48

m_nPoints = 0;

// now render
m_pVisualizer>Render();

// change points to last points and reset points


ppTemp = m_ppLastPointList;
m_ppLastPointList = m_ppPointList;
m_ppPointList = ppTemp;
m_nLastPoints = m_nPoints;

*
*
*

*
*
*

*
*
*

*
*
*

*
*
*

*
*
*

*
*
*

scanmanager.cpp

m_transformationMatrix[0][1] + matrix[2][1]
m_transformationMatrix[1][1] + matrix[2][2]
m_transformationMatrix[2][1] + matrix[2][3]
m_transformationMatrix[3][1];
m_transformationMatrix[2][2] = matrix[2][0] *
m_transformationMatrix[0][2] + matrix[2][1]
m_transformationMatrix[1][2] + matrix[2][2]
m_transformationMatrix[2][2] + matrix[2][3]
m_transformationMatrix[3][2];
m_transformationMatrix[2][3] = matrix[2][0] *
m_transformationMatrix[0][3] + matrix[2][1]
m_transformationMatrix[1][3] + matrix[2][2]
m_transformationMatrix[2][3] + matrix[2][3]
m_transformationMatrix[3][3];
m_transformationMatrix[3][0] = matrix[3][0] *
m_transformationMatrix[0][0] + matrix[3][1]
m_transformationMatrix[1][0] + matrix[3][2]
m_transformationMatrix[2][0] + matrix[3][3]
m_transformationMatrix[3][0];
m_transformationMatrix[3][1] = matrix[3][0] *
m_transformationMatrix[0][1] + matrix[3][1]
m_transformationMatrix[1][1] + matrix[3][2]
m_transformationMatrix[2][1] + matrix[3][3]
m_transformationMatrix[3][1];
m_transformationMatrix[3][2] = matrix[3][0] *
m_transformationMatrix[0][2] + matrix[3][1]
m_transformationMatrix[1][2] + matrix[3][2]
m_transformationMatrix[2][2] + matrix[3][3]
m_transformationMatrix[3][2];
m_transformationMatrix[3][3] = matrix[3][0] *
m_transformationMatrix[0][3] + matrix[3][1]
m_transformationMatrix[1][3] + matrix[3][2]
m_transformationMatrix[2][3] + matrix[3][3]
m_transformationMatrix[3][3];

Mittwoch Dezember 17, 2003 19:45

scanmanager.cpp

Seite 5/5

3/3

Gedruckt von Unbekannter Benutzer

Anhang C Format der Eingabedateien

Kamerakalibrierung
[Anzahl der Punkte in einer Zeile, d.h. in x-Richtung]
[Anzahl der Punkte in einer Spalte, d.h. in y-Richtung]
[Anzahl der aufzulegenden Ebenen]
[Relative Position der Ebenen zueinander, in z-Richtung]
[xw1 yw1 ]
.
.
.
[xwn ywn ]

Der vierte Parameter, die relative Position der Ebenen zueinander, entspricht der Dicke einer
Plexiglas-Platte. Die Anzahl der Punkte n ist gleich dem Wert, den man durch Multiplikation
der ersten drei Parameter erhlt. Die x- und y-Koordinaten der einzelnen Punkte bezeichnen
a
ihre Lage in der xy-Ebene des Weltkoordinatensystems. Die Einheit ist [mm]. Die Punkte
sind zeilenweise sortiert einzugeben, beginnend mit dem ersten Punkt der obersten Zeile.

Projektorkalibrierung
[Anzahl der aufzulegenden Ebenen]
[Relative Position der Ebenen zueinander, in z-Richtung]
Der zweite Parameter, die relative Position der Ebenen zueinander, entspricht der Dicke einer
Plexiglas-Platte.

86

Anhang D Technische Daten und Datenbltter


a

Projektor
Firma Dell
3100MP
SVGA-Projektor

Kamera
Firma Pulnix
TM-745E
Standard-PAL-Videokamera

Frame-Grabber-Karte
Firma Hauppauge
WinTV Go PCI
mit BT878-Chipsatz

Objektiv
Firma TAMRON
1:1,6, 8-16mm
Durchmesser 35,5 mm

87

TM-745E SERIES AND TM-745i SERIES


HIGH RESOLUTION CCD CAMERAS
IMAGING PRODUCTS
Pr oduct Featur es
Very high resolution
768(H) x 493(V) ... TM-745E/TM-745i (EIA)
756(H) x 581(V) ... TM-765E/TM-765i (CCIR)

Built-in edge enhancement (E version)


Fully automatic exposure control (i version)
Low light sensitivity (0.5 lux)
Smearless shutter 1/60 to 1/10,000 (1/31,000 optional)
Full frame integration and asynchronous reset
External sync, interlace, non-interlace auto select
Excellent S/N (50 dB)
AGC on/off, gamma 1 or 0.45

Electr onic Shutter

The PULNiX TM-745E and TM-745i series are high resolution


monochrome shutter cameras with uniform MTF (Modulation
Transfer Function) characteristics. The E version offers built
in edge enhancement, while the i version features automatic
electronic exposure controls. Asynchronous reset capability and
full frame integration are standard features of these cameras.
Excellent low light sensitivity of 0.5 lux at F1.4 provides added
versatility. Optional features include AGC enable, blemish free
imagers, internal IR cut filter, gamma = 0.45, and the popular
remoted imagers (standard is 48", with other lengths available
by special order).
The TM-745E and TM-745i series cameras are very compact,
creating low inertia when mounted within moving objects. The
mount provided for C-mount lenses is rigidly affixed to the camera
to assure a secure fitting. Circuitry is field proven, and features
primarily surface mount technology for resistance to high shock
and vibration. The automatic exposure control using electronic
shuttering (i version) eliminates all dependence on mechanical
apertures, reducing vulnerability to down time due to high vibration
or shock, or from temperature variations.
The TM-745E series cameras are perfect for applications
such as bar code reading, gauging, character reading,
automated inspection, intensified CCD cameras, and detailed
surveillance. The TM-745i series cameras are particularly well
suited for airborne surveillance, vehicles and remote piloted
vehicles, ATMs, welding inspection, and any application requiring
auto iris function by electronic shuttering.

The TM-745E and TM-745i series cameras have a substrate


drain type shutter mechanism which provides a superb picture
at various speeds without smearing. The substrate drain moves
the charges vertically. When excess potential is applied to the
substrate underneath each cell, a potential barrier is pulled
down to release the charge into the drain from all of the cells
simultaneously. In comparison, conventional CCD shuttering is
done with a horizontal charge shift to the drain by interline
transferring or reverse transferring of the frame transfer chip.
Shutter speeds range from 1/60, 1/125, 1/250, 1/500,
1/1,000, 1/2,000, 1/4,000, to 1/10,000 sec., with a special option
available for variable shutter speeds up to 1/31,000. External
selection of the electronic shutter rate is a standard feature of
these cameras. Shuttering eliminates the need for costly and
distracting strobe lights on a high speed assembly or
inspection line.
TM-745E/765E
MTF AND RESOLUTION CHART

100

AGC OFF
Gamma=1

1000

TM-745E
(Enhancer ON)
80

800

60

600

TM-745E
(Enhancer OFF)
XC-77

Integration

TM-745
40

The CCD imager may be exposed for longer than normal


TV timing (16.7 msec.), providing high sensitivity for dark
environment applications. Integration is achieved by controlling
the #11 pin of the 12-pin connector to Low (TTL). Because
PULNiX uses an interline transfer chip, a full frame of resolution
is obtainable.
Note: A full frame is not available in the shutter mode. Use
the PULNiX TM-9701 if full frame shuttering is required.

Mega-cycle chart
Fluorescent light box

MTF VIDEO OUT


(%)
( mV )
1200

400

20

200

70

0.5
50

1.0
100

1.5
150

2.0
200

2.5
250

3.0
300

4.0
400

5.0

6.0
500

( MHz )
600

( TV Lines )

TM-745E/TM-745i
TM-745E/TM-745i

General Description

Specifications

Dimensions
TM-765E/TM-765i
(CCIR)

TM-745E/TM-745i
(EIA)

Model
Imager
Pixel
Cell size
Scanning
Sync

TV resolution
S/N ratio
Min. illumination
Video output
AGC
Gamma
Lens mount
Power req.
Operating temp.
Vibration & shock
Size (W x H x L)
Weight
Power cable
Power supply
Auto iris connector
Functional options

118mm (Remote)

PULNiX

2/3" interline transfer CCD, HAD type


768 (H) x 493 (V)
756 (H) x 581 (V)
11 m x 13 m
11 m x 11 m
525 lines 60Hz,
625 lines 50Hz
2:1 interface
Internal/external auto switch PULNiX
HD/VD: 4.0 Vp-p, 4,7k
VD=interlace/non-interlace
HD=15.734KHz5%
HD=15.625KH5%
570 (H) x 350 (V)
560 (H) x 420 (V)
50dB min.
0.5 lux f=1.4 without IR cut filter
1.0 Vp-p composite video, 75 PULNiX
ON/OFF (default)
0.45/1.0 (default)
C-mount standard, mini-bayonet optional
12V DC, 350mA
-10C to 50C
Vibration: 7G, Shock: 70G
42mm x 32mm x 143mm
1.65" x 1.25" x 5.62"
200 grams (7 oz.)
12P-02
K25-12V or PD-12
PC-6P
See current price list for available options.

TM-745

130mm
143mm
M2 (x4)

PULNiX
25mm SQUARE

PATTERN

PULNiX

1/4-20 UNC -2B

25.5mm
45.5mm

PULNiX

PULNiX
32mm

47mm

42mm

REMOTE HEAD

C-mount

8mm

PULNiX

VIDEO
OUT
LENS

PWR IN
EXT SYNC

REAR PANEL

Pin Configuration

Automatic Shutter (TM-745i)


Automatic shuttering (i version) is controlled by a special
CPU in the camera which adjusts for optimal picture level based
on the video signal. This eliminates the need for costly and bulky
auto iris lenses. All shuttering is activated electronically with no
moving parts involved. The full shutter range from 1/60 sec. to

6-Pin Connector
1

1/31,000 sec. is utilized for the i version.

1
2
3
4
5
6
D0, D1, D2

D2
GND
Video
+12V (or 5V)
D0
D1
Shutter control

TM-745i VIDEO OUT VS SCENE ILLUMINATION


VIDEO OUT VS. SECENE ILLUMINATION
700mV

12-Pin Connector
600

1
2

9
10

500

3
400

11

12

6
5

300

200

1
2
3
4
5
6
7
8
9
10
11
12

GND
+12V
GND
Video
GND
Vinit
VD in
GND
HD in
N/C
Int.cont.
GND

TM-745E/TM-745i
TM-745E/TM-745i

0
100

1
10

2
10

3
10

4
10

105

(LUX)

Japan, Tokyo
Ogura Bldg, 1-11-14 Hongo,
Bunkyo-ku, Tokyo, 113-033
Tel: 81-3-5805-2455
Fax: 81-3-5805-8082
Kyoto Office
Tel: 81-75-592-2247
Fax: 81-75-591-2333

In Australia
PULNiX America Inc.
Unit 16, #35 Garden Road
Clayton, Vic 3168
Tel: 3-9546-0222
Fax: 3-9562-4892

United Kingdom
PULNiX Europe Ltd.
Aviary Court, Wade Road
Basingstoke, Hants RG24 8PE
Tel: 01256-475555
Fax: 01256-466268

Germany
PULNiX Europe Ltd.
ISO-9001
Siemensstrasse 12
Industrial Products Division
Cert. #A3942 RVC
D-63755 Alzenau
PULNiX America Inc. Tel: 408-747-0300
Germany
1330 Orleans Drive
Tel: 800-445-5444
Tel: 49(0)6023-9625-0
Sunnyvale, CA 94089 Fax: 408-747-0660
Fax: 49(0)6023-9625-11
Email: imaging@pulnix.com
www.pulnix.com

TM-745E/TM-745i/1197

100

Lens Info

Specs
Catalog #s

List Price
$204.00
Specifications
Focal Length

8-16mm

Iris Range

F/1.6 to Close

Iris Operation

Manual

Focus Operation

Manual

Mount

1/3" Angle of View (Wide/Telephoto)

33.2 x 24.9/17.3 x 13.1

1/2" Angle of View (Wide/Telephoto)

44.0 x 33.2/22.9 x 17.3

2/3" Angle of View (Wide/Telephoto)

59.8 x 45.3/30.8 x 23.6

Effective Diameter (Front/Rear Lens)

26.0mm/9.4mm

Minimum Object Distance

39.4 in. (1.0m)

Back Focus

10.85mm (in air)

Filter Size

M35.5 P=0.5

Maximum Diameter

1.6 in. (40mm)

Overall Length

2.0 in. (51mm)

Weight

3.4 oz. (96 grams)

Catalog Number
23VM816

Specifications subject to change without notice.


Copyright 2002 Tamron USA, Incorporated. All rights reserved.
Tamron USA, Inc - 10 Austin Blvd., Commack, NY 11725 631-858-8400 Fax: 631-543-5666

Literatur
[Ack84]

F. Ackermann. Digital image correlation: performance and potential application


in photogrammetry. Photogrammetric Record, 64(11):429439, 1984.

[AHB87]

K. S. Arun, T. Huang, and S. D. Blostein. Least-Squares Fitting of Two 3D Point Sets. IEEE Trans. on Pattern Recognition and Machine Intelligence
(PAMI), 9(5):698700, 1987.

[Aza03]

P. Azad. Entwurf, Aufbau und Kalibrierung eines 3D-Laser-Scanners fr mediu


zinische Anwendungen. Institut fr Rechnerentwurf und Fehlertoleranz (IRF),
u
Universitt Karlsruhe, 2003.
a

[BM92]

P. Besl and N. McKay. A Method for Registration of 3-D Shapes. IEEE Trans.
on Pattern Recognition and Machine Intelligence (PAMI), 14(2):239256, 1992.

[Br01]
a

T. Brunl. Parallel Image Processing. Springer, Berlin, 2001.


a

[BS98]

J. Batlle and E. Mouaddib J. Salvi. Recent progress in coded structured light as


a technique to solve the correspondence problem: A survey. Pattern Recognition,
31(7):963982, 1998.

[DA98]

N. DApuzzo. Automated photogrammetric measurement of human faces. International Archives of Photogrammetry and Remote Sensing, 32(B5):402407,
1998.

`
[DBCM02] F. Devernay, O. Bantiche, and E. Coste-Mani`re. Structured light on dynamic
e
scenes using standard stereoscopy algorithms. 2002.
[Der]

Derksen. Lichttechnik. http://www.derksen.de.

[DWJ98]

C. Dorai, J. Weng, and A. Jain. Registration and Integration of Multiple Object


Views for 3D Model Construction. IEEE Trans. on Pattern Recognition and
Machine Intelligence (PAMI), 20(1):8389, 1998.

[ELF97]

D. W. Eggert, A. Lorusso, and R. B. Fisher. Estimating 3-D rigid body transformations: A comparison of four major algorithms. Machine Vision and Applications, 9(5/6):272290, 1997.

[Gru85]

A. W. Gruen. Adaptive Least Squares Correlation: A powerful image matching


technique. South African Journal of Photogrammetry, Remote Sensing and Cartography, 14(3):175187, 1985.

[Gh01]
u

Jens Ghring. Dense 3-D surface acquisition by structured light using o-the-shelf
u
components. Proceedings of SPIE, 4309:220231, 2001.

[HKRW02] H. Hoppe, C. Kbler, J. Raczkowsky, and H. Wrn. Ein neues und leicht zu
u
o
implementierendes Modell zur przisen Kalibration von Kameras und Videoproa
jektoren. Bildverarbeitung fr die Medizin (BVM), pages 229232, 2002.
u
[Hor87]

B. K. P. Horn. Closed-form solution of absolute orientation using unit quaternions. Journal of the Optical Society of America A, 4(4):629642, 1987.

[HR98]

P. Hbert and M. Rioux. Toward a hand-held laser range scanner: Integrating


e
observation-based motion compensation. SPIE Proceedings of IS&T Symposium
on Electronic Imaging, 1998.
91

[HR01]

O. Hall-Holt and S. Rusinkiewicz. Stripe Boundary Codes for Real-Time


Structured-Light Range Scanning of Moving Objects. Int. Conf. on Computer
Vision, pages 359366, 2001.

[HS02]

T. Huckle and S. Schneider. Numerik fr Informatiker. Springer, Berlin, 2002.


u

[Kita]

Kitware. VTK. http://public.kitware.com/VTK/index.php.

[Kitb]

Kitware.
VTK File Formats.
formats.pdf.

[Koe83]

M. Koecher. Lineare Algebra und analytische Geometrie. Springer, Berlin, 1983.

[LLH00]

J. Luck, C. Little, and W. Ho. Registration of Range Data Using a Hybrid Simulated Annealing and Iterative Closest Point Algorithm. International Conference
on Robotics & Automation, 2000.

[Luh00]

T. Luhmann. Nahbereichsphotogrammetrie: Grundlagen, Methoden und Anwendungen. Wichmann, Heidelberg, 2000.

[OS]

OraMetrix and Syrinx. Patente: US 6,413,084 B1, US 6,359,680 B1.

[PA82]

J. L. Posdamer and M. D. Altschuler. Surface measurement by space-encoded


projected beam systems. 18(1):117, 1982.

http://public.kitware.com/VTK/pdf/le-

[RHHL02] S. Rusinkiewicz, O. Hall-Holt, and M. Levoy. Real-Time 3D Model Acquisition.


ACM Transactions on Graphics, 21(3):438446, 2002.
[RL01]

S. Rusinkiewicz and M. Levoy. Ecient Variants of the ICP Algorithm. Proceedings of the Third Int. Conf. on 3D Digital Imaging and Modeling, pages 145152,
2001.

[SHB99]

M. Sonka, V. Hlavac, and R. Boyle. Image Processing, Analysis, and Machine


Vision. International Thomson Publishing, 1999.

[SPB04]

J. Salvi, J. Pags, and J. Batlle. Pattern Codication Strategies in Structured


e
Light Systems. Pattern Recognition, 2004.

[Tsa87]

R. Y. Tsai. A Versatile Camera Calibration Technique for High-Accuracy 3D


Machine Vision Metrology Using O-the-Shelf TV Cameras and Lenses. IEEE
Journal of Robotics and Automation, RA-3(4), 1987.

[TV98]

E. Trucco and A. Verri. Introductory Techniques for 3-D Computer Vision. Prentice Hall, 1998.

[VO90]

P. Vuylsteke and A. Oosterlinck. Range Image Acquisition with a Single BinaryEncoded Light Pattern. IEEE Transactions on Pattern Analysis and Machine
Intelligence, 12(2):148164, 1990.

[WS91]

M. Walker and L. Shao. Estimating 3-D location parameters using dual number
quatemions. CVGIP: Image Understanding, 54(3):358367, 1991.

92