Beruflich Dokumente
Kultur Dokumente
a
Fakultt fr Informatik
a u
Institut fr Rechnerentwurf und Fehlertoleranz (IRF)
u
Lehrstuhl Prof. Dr.-Ing. R. Dillmann
Diplomarbeit
von
Pedram Azad
19. Juni 2003 18. Dezember 2003
Referent:
Korreferent:
Betreuer:
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
Inhaltsverzeichnis
Abbildungsverzeichnis
iii
Tabellenverzeichnis
iv
Algorithmenverzeichnis
1 Einfuhrung
1.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Ansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3 Gliederung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1
1
1
2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
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
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
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
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
73
86
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
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
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
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.
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
2.2
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
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
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
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
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.
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 :
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
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]
2.2.4
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
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]
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
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.
2.3
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
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
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
(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
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
17
3.2
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
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)
(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
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
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
(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
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
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
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)
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
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
(25)
wobei diese Schreibweise meint, dass die Rotation R und die Translation t auf jeden Punkt aus
(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
1
np
np
Die Dierenz zwischen zwei aufeinander folgenden Iterationen ist hinreichend klein.
Die maximale Anzahl der erlaubten Iteration wurde erreicht.
(R, t) = min
R,t k=1
P := R P + t
R := R R
t := t + t
end for
3.6.2
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
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
M=
pi yi
i=1
(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
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
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)
(36)
xd = a(nd n0 ) + b(md m0 )
(37)
xu = a(nu n0 ) + b(mu m0 ),
(38)
(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)
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)
(44)
(45)
29
(46)
(47)
(48)
(49)
(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
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 =
(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)
=
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 ] .
(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)
32
33
4.2
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
35
4.3
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
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
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
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
4.4.2
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.
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
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
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
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
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 =
(68)
(69)
(70)
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
44
4.6
4.6.1
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
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
49
5.1.1
Kamera
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
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
51
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
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.
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.
55
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
56
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
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
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
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
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
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).
62
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 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,
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
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 =
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
69
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
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)
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
73
"CorrelationImageProcessor.h"
"Common/Defines.h"
"Interfaces/DataManagerInterface.h"
"Common/Helpers.h"
int
int
int
int
int
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
#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;
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();
}
*****************************************************************
Author: Pedram Azad
Date:
1.9.2003
*****************************************************************
Seite 1/10
//
//
//
//
correlationimageprocessor.cpp
*****************************************************************
CorrelationImageProcessor.cpp Implementation of
CCorrelationImageProcessor
*****************************************************************
//
//
//
//
//
//
pHelper += m_nWidth;
ShowPixel(j * TILESIZE_BINARIZE + x,
i * TILESIZE_BINARIZE + y, 255 * pHelper[x],
255 * pHelper[x], 255 * pHelper[x]);
return 0;
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;
// *****************************************************************
// FindSeed
// *****************************************************************
#if USE_GRUEN_FOR_SCAN
return (min <= MAX_SUM_SSD_BIN) && LeastSquaresCorrelation(i, j);
#else
return min <= MAX_SUM_SSD_BIN;
#endif
}
// *****************************************************************
// FindCorrelation
// *****************************************************************
correlationimageprocessor.cpp
if (FindMatch(x, y))
{
m_pDataManagerInterface>AddElement(x + a0, y + b0);
}
else
m_pDataManagerInterface>AddElement(NaN, NaN);
correlationimageprocessor.cpp
double threshold = (max min > 20) ? 0.5 * (min + max) : 255;
2/5
Seite 4/10
Seite 5/10
a0 = best_a0;
b0 = best_b0;
return sum;
offset += diff2;
3/5
Seite 6/10
// *****************************************************************
// SSDFast
// *****************************************************************
// *****************************************************************
// SSD
// *****************************************************************
correlationimageprocessor.cpp
correlationimageprocessor.cpp
a0 = best_a0;
b0 = best_b0;
// *****************************************************************
// FindMatch
// *****************************************************************
correlationimageprocessor.cpp
Seite 7/10
a1
a2
b1
b2
=
=
=
=
1;
0;
0;
1;
offset += diff2;
gx;
gx *
gx *
gy;
gy *
gy *
x;
y;
x;
y;
int i = 0;
offset = sy * m_nWidth + sx diff3;
for (y = 0; y < TILESIZE; y++)
{
for (x = 0; x < TILESIZE; x++)
correlationimageprocessor.cpp
// 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;
ATA[y][x] = sum;
double sum = 0;
offset += diff1;
}
// </resample>
=
=
=
=
=
=
i++;
offset++;
A[i][0]
A[i][1]
A[i][2]
A[i][3]
A[i][4]
A[i][5]
double gx = m_pResampledPicture[offset + 1]
m_pResampledPicture[offset];
double gy = m_pResampledPicture[offset + m_nWidth]
m_pResampledPicture[offset];
correlationimageprocessor.cpp
double
double
double
double
// *****************************************************************
// LeastSquaresCorrelation
// *****************************************************************
correlationimageprocessor.cpp
return (sum & 0xff) + ((sum & 0xff00) >> 8) + ((sum & 0xff0000) >> 16) +
((sum & 0xff000000) >> 24);
4/5
Seite 8/10
//
a0
a1
a2
b0
b1
b2
add differences
+= xx[0];
+= xx[1];
+= xx[2];
+= xx[3];
+= xx[4];
+= xx[5];
double xx[GRUEN_PARAMETERS];
for (j = GRUEN_PARAMETERS1; j >= 0; j)
{
double sum = yy[j];
offset++;
offset += diff2;
correlationimageprocessor.cpp
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];
correlationimageprocessor.cpp
nError = 0;
for (y = 0; y < TILESIZE; y++)
{
for (x = 0; x < TILESIZE; x++)
{
int c = m_pResampledPicture[offset] m_pTemplate[offset];
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
5/5
Seite 10/10
// *****************************************************************
// 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
*****************************************************************
*****************************************************************
//
//
//
//
//
Seite 1/7
icp.cpp
icp.cpp
= ppTargetPoints[i][0];
= ppTargetPoints[i][1];
= ppTargetPoints[i][2];
for (i = 0;
{
double x
double y
double z
if (xsize <= 0 || xsize > maxdim || ysize <= 0 || ysize > maxdim)
return;
if (y > ymax)
ymax = y;
if (y < ymin)
ymin = y;
if (x > xmax)
xmax = x;
if (x < xmin)
xmin = x;
if (y > ymax)
ymax = y;
if (y < ymin)
ymin = y;
if (x > xmax)
xmax = x;
if (x < xmin)
xmin = x;
m_nLandmarks = 0;
1/4
Seite 2/7
icp.cpp
icp.cpp
idcounter++;
matrix[i][i] = 1.0;
finalMatrix[i][i] = 1.0;
*****************************************************************
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)
*****************************************************************
2/4
Seite 4/7
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);
//
//
//
//
//
//
icp.cpp
= ppSourcePoints[i][0];
= ppSourcePoints[i][1];
= ppSourcePoints[i][2];
double sum = 0;
Seite 3/7
x;
y;
z;
idcounter;
=
=
=
=
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]
dx += 0.5;
// perform transformation
for (j = 0; j < nSourcePoints; j++)
{
double x = ppSourcePoints[j][0];
double y = ppSourcePoints[j][1];
finalMatrix[0][3] += best_dx;
finalMatrix[1][3] += best_dy;
dy += 0.5;
// go
double best_dx = 0, best_dy = 0, dy = 1;
for (i = 0; i < 11; i++)
{
double dx = 1;
icp.cpp
// init
double min = 999999;
Seite 5/7
icp.cpp
3/4
Seite 6/7
icp.cpp
double z = ppSourcePoints[j][2];
delete [] ppOriginalSourcePoints[j];
delete [] ppOriginalSourcePoints;
icp.cpp
Seite 7/7
icp.cpp
4/4
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
// 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);
//
//
//
//
return 0;
if (dShiftX == NaN)
{
// add to point grid
m_pointGrid[y_pos][x_pos][2] = NaN;
scanmanager.cpp
return 0;
and A.GetTransposed() * b
* A10 + A20 * A20;
* A10 + A21 * A20;
* A11 + A21 * A21;
b1 + A20 * b2;
b1 + A21 * b2;
// 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
scanmanager.cpp
Seite 1/5
#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
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++;
}
if (m_nLastPoints > 0)
{
// run icp
bRet = m_pICP>ICP(m_ppPointList, m_nPoints, m_ppLastPointList,
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];
scanmanager.cpp
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;
scanmanager.cpp
Seite 3/5
return true;
m_nPoints = 0;
// now render
m_pVisualizer>Render();
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
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];
scanmanager.cpp
Seite 5/5
3/3
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
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
100
AGC OFF
Gamma=1
1000
TM-745E
(Enhancer ON)
80
800
60
600
TM-745E
(Enhancer OFF)
XC-77
Integration
TM-745
40
Mega-cycle chart
Fluorescent light box
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
TM-745
130mm
143mm
M2 (x4)
PULNiX
25mm SQUARE
PATTERN
PULNiX
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
6-Pin Connector
1
1
2
3
4
5
6
D0, D1, D2
D2
GND
Video
+12V (or 5V)
D0
D1
Shutter control
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
26.0mm/9.4mm
Back Focus
Filter Size
M35.5 P=0.5
Maximum Diameter
Overall Length
Weight
Catalog Number
23VM816
Literatur
[Ack84]
[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]
[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
[BS98]
[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]
[DWJ98]
[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]
[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]
[HR01]
[HS02]
[Kita]
[Kitb]
Kitware.
VTK File Formats.
formats.pdf.
[Koe83]
[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]
[OS]
[PA82]
http://public.kitware.com/VTK/pdf/le-
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]
[SPB04]
[Tsa87]
[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