Computerholographie - der Fam. Partheil aus Biedenkopf-Wallau

Städtisches Gymnasium Bad Laasphe
Computerholographie
Facharbeit
von Michael Partheil
im Leistungskurs Physik
Fachlehrer: Herr Bernshausen
Abgabetermin: 01.03.2005
Schuljahr 2004/2005

Vorwort
Zum Thema Holographie ist bereits viel geschrieben worden: Jugend-Forscht-
Arbeiten, Facharbeiten, Bücher für interessierte Laien, uvm. Wer sich mit
herkömmlicher Holographie beschäftigen möchte, findet hierzu einiges an
Material.
Diese Facharbeit spezialisiert sich deshalb auf ein Untergebiet der Holographie,
zu dem noch nicht sehr viel publiziert worden ist: die Computerholographie.
Dies ist allerdings nicht der einzige Grund, warum ich mich gegen eine Arbeit
über „normale“ Holographie entschieden habe: Es ist zwar ein sehr schönes
Hobby, Hologramme selber anzufertigen, aber auch ein sehr kostspieliges und
umständliches: Man benötigt spezielles holographisches Filmmaterial sowie
einen leistungsstarken Laser, beides ist nicht nur teuer, sondern auch schwer
zu beschaffen. Computerholographie hingegen kommt mit einem
herkömmlichen Dokumentenfilm, einem Computer und einer Kamera aus.
Das Hauptproblem war einmal, dass ich kein geeignetes Programm zur
Berechnung der Hologramme finden konnte, und zum anderen, dass ich
keinerlei Erfahrung mit der Entwicklung von Filmen hatte.
Das erste Problem habe ich gelöst, indem ich selber ein solches Programm
entwickelt habe. Zum Thema Filmentwicklung habe ich mich mithilfe von
Literatur informiert, sowie Tipps von „Profis“ bekommen, und nach einigen
Fehlversuchen hat die Entwicklung dann auch geklappt. Für die Herstellung von
Computerhologrammen sind also keinerlei Vorkenntnisse nötig!
2

Inhalt
1 Einführung 5
1.1 Geschichte der Holographie 5
1.2 Unterschiedliche Hologramm-Arten 6
1.2.1 Transmissionshologramme 6
1.2.2 Weißlichtreflexionshologramme 7
1.2.3 Regenbogenhologramme 7
2 Physik der Holographie 8
2.1 Aufnahme und Betrachtung von
Transmissionshologrammen 8
2.2 Funktionsweise an Beispielen erklärt 10
2.2.1 Aufnahme eines Hologramms 10
2.2.2 Rekonstruktion eines Hologramms 12
2.2.3 Pseudoskopische Bilder 15
2.3 Mathematische Erklärung 16
2.3.1 Aufnahme eines Hologramms 16
2.3.2 Rekonstruktion eines Hologramms 19
3 Computerholographie 20
3.1 Grundlagen der Computerholographie 21
3.2 Probleme bei der Computerholographie 21
3.3 Berechnung von Computerhologrammen 22
3.3.1 Zufallsphasen 23
3.3.2 Kontrasterhöhung 24
3.4 Fotoarbeiten 24
Anhang A: Beigefügte Materialien 26
Anhang B: Bedienung des CGH-Programms 27
Anhang C: Literaturverzeichnis 29
Anhang D: Selbstständigkeitserklärung 30
Anhang E: Quelltext des CGH-Programms 31
AuswahlListener.java 31
BerechnungsFortschrittListener.java 31
CGHMain.java 31
DynamicHelpListener.java 32
EigenschaftenEditorControl.java 33
ErgebnisDialog.java 34
3

HelpViewer.java 38
HologrammEditor.java 39
InterferenzMuster.java 47
MainShell.java 51
NullEditor.java 59
ObjektEditor.java 60
ObjektPunkt.java 60
ObjektPunktEditor.java 61
ObjektPunktPosListener.java 65
Photo.java 65
Simulation.java 66
SimulationEditor.java 67
SWTUtils.java 72
TextInputDialog.java 72
TextPseudoObjekt.java 76
VollBildDialog.java 76
4

1 Einführung
Das Wort „Hologramm“ besteht aus den zwei Silben „holo“ und „gramm“. Sie
sind eine Anlehnung an die griechischen Wörter hólo „ganz, völlig“ und grámma
„Nachricht“. Übersetzt bedeutet „Hologramm“ also „Ganze Nachricht“. Und dies
beschreibt die Holographie auch schon sehr gut. Im Gegensatz zur normalen
Photographie können mit ihr nämlich nicht nur zweidimensionale sondern
dreidimensionale Bilder aufgenommen werden. In einem Hologramm sind alle
Informationen, die bei der Aufnahme verfügbar waren, also auch die Tiefe,
gespeichert. Deshalb kann ein Hologramm mit gutem Gewissen als „ganzes“
Abbild beschrieben werden.
Diese Dreidimensionalität wird dadurch erreicht, dass nicht wie bei der
herkömmlichen Photographie die Intensität des vom aufzunehmenden Objekt
kommenden Lichtes aufgezeichnet wird, sondern mithilfe eines speziellen
Aufnahmeverfahrens auch die Richtung des Lichtstrahles. Bei der Wiedergabe
werden alle bei der Aufnahme gespeicherten Lichtstrahlen rekonstruiert und
ihre Summe bildet dann das holographische Bild. Da beide Augen des
Betrachters ein etwas gegeneinander versetztes Bild liefern, kann das Gehirn
so die Tiefe berechnen. Ein Hologramm ist somit keine optische Täuschung,
sondern eine reale Rekonstruktion des aufgenommenen Gegenstandes.
1.1 Geschichte der Holographie
Die Grundlagen der Holographie wurden im Jahr 1948 von dem am 5. Juni
1900 in Budapest geborenen, aber später nach Großbritannien emigrierten
Physiker Dennis Gabor (Abbildung 1) entdeckt.
Er suchte nach einer Möglichkeit, die damals noch unbedeutende
Elektronenmikroskopie zu verbessern und wollte dazu zunächst eine Methode
entwickeln, um alle Informationen eines Lichtstrahles, d.h. sowohl seine
Intensität als auch Phase, speichern zu können. Diesem Verfahren gab er den
Namen Holographie. Aufgrund fehlender Lichtquellen mit großer Kohärenzlänge
fand seine Entdeckung allerdings kaum Anwendung: Sie taugte weder zur
Verbesserung von Elektronenmikroskopen noch zur Aufnahme von
dreidimensionalen Bildern. Seine Entdeckung gewann erst 1962 mit der
Erfindung des Lasers an Bedeutung, da der Laser im Gegensatz zu normalen
5

Lichtquellen eine große Kohärenzlänge besitzt und sich damit für die Aufnahme
von Hologrammen eignet.
Dennis Gabor erhielt 1971 für die Erfindung der Holographie den Nobelpreis für
Physik.
Abbildung 1: Dennis Gabor (1900-1979) entdeckte das Prinzip der Holographie (aus
[HE95])
1.2 Unterschiedliche Hologramm-Arten
Im Laufe der Zeit haben Forscher verschiedene Variationen des ursprünglichen
Verfahrens zur Holographie entwickelt. Mittlerweile gibt es eine ganze Reihe
von verschiedenen Arten von Hologrammen. Drei davon sollen im Folgenden
kurz vorgestellt werden.
1.2.1 Transmissionshologramme
Ein Laserlichttransmissionshologramm ist eine leicht lichtdurchlässige Platte
oder Folie. Bei der Betrachtung des Hologramms wird es von der einen Seite
mit einem aufgeweiteten Laserstrahl beschienen, der Beobachter befindet sich
6

auf der gegenüberliegenden Seite. Der Strahl dringt durch das Hologramm und
erzeugt auf der anderen Seite das rekonstruierte Bild. In der Optik wird der
Durchgang von Licht durch eine Substanz als Transmission bezeichnet. Daher
kommt der Name dieser Art von Hologramm.
Der Nachteil von Transmissionshologrammen ist die Schwierigkeit bei der
Betrachtung: Sie können nur mithilfe eines geeigneten Lasers betrachtet
werden. Trotz dieses Nachteils sind Transmissionshologramme in Forschung
und Technik weit verbreitet, da sie eine sehr große Schärfentiefe aufweisen.
1.2.2 Weißlichtreflexionshologramme
Wegen der komplizierten Beleuchtung von Transmissionshologrammen findet
man in Ausstellungen meistens Weißlichtreflexionshologramme. Dieser
Hologrammtyp kann mit normalem, d.h. weißem Licht rekonstruiert werden. Der
Betrachter und die Lichtquelle befinden sich dabei auf derselben Seite des
Hologramms.
Dieser Hologrammtyp wurde 1963 von dem russischen Wissenschaftler Yurii N.
Denisyuk erfunden und wird deshalb auch manchmal als „Denisyuk-
Hologramm“ bezeichnet.
1.2.3 Regenbogenhologramme
Ein Regenbogenhologramm kann, genau wie das Weißlicht-
reflexionshologramm, mit weißem Licht betrachtet werden. Der Unterschied ist,
dass ein Regenbogenhologramm keine Tiefe besitzt. Bewegt man das
Hologramm, sieht man nicht den Gegenstand von der Seite, sondern es ändert
sich die Farbe des Gegenstandes entsprechend der Farbfolge des
Regenbogens.
Regenbogenhologramme wurden erstmals im Jahr 1969 von dem
amerikanischen Forscher S. Benton hergestellt.
7

2 Physik der Holographie
Die Funktionsweise von Hologrammen ist recht einfach zu erklären. Dazu
werden keine komplizierten physikalischen Sachverhalte benötigt; als einzige
Vorkenntnisse werden das Prinzip der Interferenz und die Beugung von Licht
am Doppelspalt vorausgesetzt.
Alle folgenden Beschreibungen beziehen sich auf das Transmissionshologramm,
da es quasi der „Urvater“ aller Hologramme ist. Alle anderen
Hologrammtypen funktionieren nach demselben Prinzip.
Zunächst wird beschrieben, wie Transmissionshologramme auf herkömmliche
Art und Weise aufgenommen werden können. Hierbei soll lediglich das Prinzip
verdeutlicht werden, auf praktische Besonderheiten wird nicht eingegangen. In
Kapitel 2.2 folgt dann eine von mathematischen Formeln losgelöste
Beschreibung der Grundlagen der Holographie anhand von Beispielen. Diese
Zusammenhänge können allerdings nicht nur in Experimenten beobachtet
werden, sondern auch mathematisch korrekt bewiesen und erklärt werden. Dies
ist der Inhalt von Kapitel 2.3.
2.1 Aufnahme und Betrachtung von
Transmissionshologrammen
Das Prinzip der Aufnahme eines Transmissionshologramms ist in Abbildung 2
dargestellt:
Der Strahl eines Lasers, typischerweise ein roter Helium-Neon-Laser mit 1 mW
bis 5 mW Leistung wird durch eine Linse aufgeweitet und mithilfe eines
Strahlenteilers in zwei Strahlen geteilt. Der eine Strahl beleuchtet das
aufzunehmende Objekt und wird deshalb Objektstrahl genannt. Der zweite
Strahl wird direkt auf den Film geleitet und heißt Referenzstrahl. Seine Funktion
wird in den folgenden Kapiteln näher erläutert.
In der Praxis wird der beschriebene Aufbau so heutzutage nicht mehr benutzt,
da die Verwendung des Strahlenteilers Stabilitätsprobleme mit sich bringt.
8

Abbildung 2: Aufnahme eines Transmissionshologramms
Die Wiedergabe des Hologramms beschreibt Abbildung 3.
Bei der Wiedergabe strahlt der aufgeweitete Laserstrahl durch das Hologramm
hindurch und erzeugt auf der anderen Seite des Films das rekonstruierte Bild.
Es ist darauf zu achten, dass der bei der Wiedergabe verwendete Laser
dieselbe Wellenlänge besitzt wie der bei der Aufnahme benutzte Laser.
Abbildung 3: Wiedergabe eines Transmissionshologramms
9

2.2 Funktionsweise an Beispielen erklärt
2.2.1 Aufnahme eines Hologramms
Bei der Aufnahme eines Hologramms treffen sowohl Referenz- als auch die
Objektwelle auf das Filmmaterial. Die Objektwelle ist dabei der Strahl, der von
dem aufzunehmenden Objekt reflektiert wird. Er beinhaltet also die
Informationen, die in dem Hologramm gespeichert und später wiedergegeben
werden sollen. Der Referenzstrahl hingegen trifft immer gleichmäßig aus
demselben Winkel unverändert auf den Film. Er beinhaltet somit als einzige
Information die Phase des Strahls des verwendeten Lasers. Wie wir im
Folgenden sehen werden, ist diese Information, die in der herkömmlichen
Photographie nicht vorhanden ist, sehr wichtig für die Funktion des
Hologramms. Natürlich ist die Phase der Referenzwelle nicht zwingend dieselbe
wie die des Objektstrahles, da die Weglängen normalerweise nicht identisch
sind, was allerdings kein Problem darstellt.
Bei der Aufnahme interferieren nun der Objekt- und der Referenzstrahl
miteinander und bilden ein Interferenzmuster. Dieses Muster wird auf dem Film
gespeichert. Es ist sehr fein, nämlich im Bereich der Wellenlänge des
verwendeten Lasers, also nur wenige Nanometer. Deshalb muss für
herkömmliche Holographie auch spezielles Filmmaterial verwendet werden, da
selbst hochauflösende Dokumentenfilme wie z.B. der Technical Pan von Kodak
nur eine Auflösung von 300 bis 400 Linienpaare pro Millimeter (Lp/mm)
besitzen, holographisches Filmmaterial wie der Holotest-Film von Agfa
hingegen kann bis zu 6.000 Lp/mm abbilden.
In Abbildung 4 ist eine Momentaufnahme dargestellt, wenn gerade ein
Wellenberg der Referenzwelle auf den Film trifft. Die Wellen sind hier
näherungsweise als Geraden dargestellt. Die Objektwelle trifft mit einem relativ
großen Winkel auf den Film. Überall dort, wo auch ein Wellenberg der
Objektwelle auf den Film trifft, wird der Film stark belichtet, da der Berg durch
den Berg der Referenzwelle sogar noch verstärkt wird. Trifft hingegen ein
Wellental der Objektwelle auf den Film, bleibt er dort unbelichtet, weil ein
Wellental der Objektwelle und ein Wellenberg der Referenzwelle Dunkelheit
ergeben.
10

Auf dem Film entsteht also eine Abfolge von hellen und dunklen Stellen. Wichtig
für die Holographie ist nun der Abstand zwischen den unbelichteten,
lichtdurchlässigen Stellen.
Abbildung 4: Momentaufnahme bei der Aufnahme eins Hologramms (Wellenberge sind
Linien; Täler gestrichelt) (aus [HE95])
In Abbildung 5 ist dieselbe Situation dargestellt wie in Abbildung 4, allerdings
trifft die Objektwelle jetzt mit einem kleineren Winkel auf den Film. Wie man
sieht, ist hier der Abstand zwischen den unbelichteten Stellen größer als bei
einem Objektstrahl, der mit großem Winkel auftrifft. Man könnte also folgende
These aufstellen: Je kleiner der Winkel zwischen der Objektwelle und dem Film
ist, desto größer ist der Abstand zwischen den lichtdurchlässigen Stellen.
Es könnte noch eingewendet werden, dass bei der Aufnahme ja nicht immer ein
Wellenberg der Referenzwelle auf den Film trifft, da Licht ja eine Schwingung
ist. Eine halbe Wellenlänge später würde beispielsweise ein Wellental auf den
Film treffen.
Man muss allerdings beachten, dass sich die Phase der Objektwelle ja auch
ändert und zwar mit derselben Geschwindigkeit wie die der Referenzwelle. Trifft
nun eine halbe Wellenlänge nach der dargestellten Situation ein
Referenzwellental auf den Film, so ist an den Stellen, wo vorher ein Tal der
Objektwelle war nun ein Berg. Ein Referenzwellental und ein Objektwellenberg
ergeben allerdings genau wie vorher Dunkelheit und damit eine unbelichtete
Stelle.
11

Abbildung 5: Momentaufnahme, die Objektwelle trifft mit einem kleineren Winkel auf den
Film als in Abbildung 4 (aus [HE95])
Im Folgenden wird nun gezeigt, dass bei der Wiedergabe derselbe
Zusammenhang zwischen dem Winkel der Objektwelle und dem Abstand der
lichtdurchlässigen Stellen gilt. Damit wäre gezeigt, dass ein Objektstrahl bei der
Wiedergabe den Film mit genau demselben Winkel verlässt, in dem er bei der
Aufnahme auf den Film getroffen ist. Natürlich gibt es bei einem richtigen
Hologramm nicht nur eine Objektwelle sondern sehr viele. Das Hologramm
vermag es aber, alle Objektstrahlen in genau dem der Aufnahme
entsprechenden Winkel wieder abzugeben. Bei der Wiedergabe wird also die
komplette Welle, die vom Objekt ausgeht, rekonstruiert.
2.2.2 Rekonstruktion eines Hologramms
Ein belichtetes Hologramm ist im Grunde ein mehr oder weniger enges Muster
aus durchsichtigen und undurchsichtigen Linien. Wird das Hologramm bei der
Wiedergabe von der einen Seite mit Licht bestrahlt, so bilden sich nach dem
Huygensschen Prinzip hinter jeder der lichtdurchlässigen Öffnungen
kreisförmige Elementarwellen (siehe auch Abbildung 6).
Bei der Wiedergabe entstehen also im Takt mit den auf das Hologramm
treffenden Strahlen hinter jeder lichtdurchlässigen Stelle Elementarwellen.
Diese Elementarwellen interferieren nun miteinander. Dabei gibt es mehrere
Möglichkeiten: Es können sich Elementarwellen überlagern, die alle aus der
selben Welle entstanden sind (0. Maximum). Dies ist allerdings uninteressant,
da die entstehende Wellenfront genau parallel zum Hologramm wegläuft, also
genau eine Rekonstruktion des Belichtungsstrahls darstellt.
12

Interessanter ist es, wenn Elementarwellen interferieren, die von Öffnung zu
Öffnung jeweils um einen Takt des Belichtungsstrahls später entstanden sind
(1. Maximum). Die entstehenden Wellen sind in Abbildung 6 dargestellt.
Natürlich gibt es auch noch weitere Maxima (2. Maximum, 3. Maximum, usw.),
diese spielen in der Holographie jedoch nur eine geringe Rolle.
Abbildung 6: Wiedergabe eines Musters mit geringem Spaltabstand: Die Strahlen gehen
mit einem großen Winkel ab (aus [HE95])
In Abbildung 7 ist nun dieselbe Situation gezeigt, allerdings ist hier der
Spaltabstand größer als in Abbildung 6. Man sieht: Die rekonstruierte Welle
verlässt das Hologramm mit einem kleineren Winkel. Man könnte also
vermuten: Je größer der Spaltabstand ist, desto kleiner ist der Winkel der
rekonstruierten Welle, die das Hologramm verlässt.
13

Abbildung 7: Wiedergabe eines Musters mit großem Spaltabstand: Die Strahlen gehen
mit einem kleinen Winkel ab (aus [HE95])
Wir erinnern uns nun an Kapitel 2.2.1: Dort wurde über den Zusammenhang
zwischen Objektwelle und Spaltabstand bei der Aufnahme gesagt, dass der
Spaltabstand größer wird, je kleiner der Winkel der Objektwelle ist. Bei der
Wiedergabe sorgt ein großer Spaltabstand auch wiederum für einen kleinen
Winkel.
Dies macht plausibel, dass ein Hologramm die Objektwelle der Aufnahme bei
der Wiedergabe komplett rekonstruiert.
14

2.2.3 Pseudoskopische Bilder
In Kapitel 2.2.2 wurde gesagt, dass die ursprüngliche Objektwelle durch den
Zusammenschluss von Elementarwellen zustande kommt, deren Radien von
Spalt zu Spalt größer werden (von links nach rechts gesehen).
Genaugenommen schließen sich aber auch die Wellen zusammen, deren
Radien von links nach rechts kleiner werden (siehe Abbildung 8). Dieser
Zusammenschluss ergibt ein „umgestülptes“ Bild, ähnlich einem Gipsabdruck.
Dieses Bild nennt man „pseudoskopisch“.
In der Praxis versucht man, durch geeignete Positionierung des Objektes zu
erreichen, dass die rekonstruierten Objektwellen das Hologramm mit einem
möglichst großen Winkel verlassen, damit sich das „richtige“ und das
pseudoskopische Bild bei der Betrachtung nicht überlagern.
Abbildung 8: Entstehung des pseudoskopischen Bilds (aus [HE95])
15

2.3 Mathematische Erklärung
In Kapitel 2.2 wurde die grundlegende Funktionsweise von Hologrammen
anhand von Beispielen erläutert. In diesem Kapitel soll nun gezeigt werden,
dass die aufgestellten Vermutungen nicht nur in unseren Beispielen bestätigt
wurden, sondern auch mathematisch bewiesen werden können.
Die Gesetzmäßigkeiten werden an dem Hologramm eines Punktes gezeigt, ein
komplexeres Objekt stellt man sich als Zusammensetzung mehrere Punkte vor,
ähnlich einem Rasterbild in einer Zeitung. Das Hologramm eines Punktes wird
auch „Fresnelsche Zonenplatte“ genannt (Abbildung 9).
Abbildung 9: Fresnelsche Zonenplatte
2.3.1 Aufnahme eines Hologramms
Wie in Kapitel 2.2.1 beschrieben, interferieren bei der Aufnahme Objekt- und
Referenzwelle miteinander und bilden so ein Muster von lichtdurchlässigen und
lichtundurchlässigen Linien. Wichtig ist der Abstand zwischen den
lichtdurchlässigen Linien. Dieser wird im folgenden mit dem Buchstaben b
16

ezeichnet. Des weiteren wird der Winkel, den Referenz- und Objektstrahl an
der Fotoplatte einschließen, α genannt.
Es wird zunächst davon ausgegangen, dass der aufzunehmende Punkt sehr
weit entfernt ist, die Strahlen verlaufen also (näherungsweise) parallel.
Aus Abbildung 10 kann man nun folgenden Zusammenhang zwischen dem
Winkel α und b ablesen:
sin( α ) =
λ
b
Stellt man diese Formel nach b um, so erhält man:
λ
b =
sin(α )
Da die Wellenlänge immer konstant ist, ist der Spaltabstand b also umgekehrt
proportional zum Sinus von α.
Abbildung 10: Winkelzusammenhänge bei der Aufnahme eines Hologramms mit weit
entferntem Objekt (parallele Wellenfronten) (nach [FO00])
17

In Abbildung 11 ist nun dargestellt, was passiert, wenn ein nahes Objekt
aufgenommen wird, die Objektwellenfronten also kreisförmig auf den Film
treffen. Auch hier gilt der oben erkannte Zusammenhang, nur ist α für jeden
Punkt des Filmes anders. Deshalb ergibt sich kein regelmäßiges Muster mit
immer demselben b wie in Abbildung 10, sondern ein ständig anderer
Spaltabstand. Dadurch wird auch die Tiefe des Objektes gespeichert.
Abbildung 11: Aufnahme bei kreisförmigen Objektwellen (nahes Objekt) (nach [FO00])
18

2.3.2 Rekonstruktion eines Hologramms
Ein belichtetes Hologramm besteht aus lichtdurchlässigen und
lichtundurchlässigen Linien, es besteht also im Grunde aus sehr vielen
Doppelspalten (optisches Gitter). Hinter jedem dieser Doppelspalte mit dem
jeweiligen Spaltabstand b interferieren nun die entstehenden Elementarwellen
und bilden ein Interferenzmuster mit mehreren Maxima. In der Holographie hat
nur das 1. Maximum eine Bedeutung.
Der Winkel β des Strahles, der ein Maximum darstellt, steht nun in folgender
Beziehung zum Spaltabstand b, wobei k eine natürliche Zahl größer oder gleich
0 ist und die Ordnung des Maximums beschreibt, in unserem Fall also 1:
k * λ
sin( β ) = (Formel für Maxima bei der Interferenz am Doppelspalt)
b
Um einen bestimmten Winkel β bei der Rekonstruktion zu erreichen, muss der
Spaltabstand b also die folgende Länge besitzen:
λ
b =
sin( β )
Diese Gleichung setzt man nun mit der in Kapitel 2.3.1 für die Aufnahme
aufgestellten Formel gleich:
λ λ
=
sin( α)
sin( β )
Die Wellenlänge sowie der Sinus kürzen sich weg, es bleibt: α = β
Der Winkel bei der Aufnahme entspricht also dem Winkel bei der
Rekonstruktion, wenn der Spaltabstand b derselbe ist.
Das Pseudoskopische Bild kann damit erklärt werden, dass sich bei der
Rekonstruktion das 1. Maximum nicht nur mit dem Winkel β, sondern auch noch
mit -β bildet.
19

3 Computerholographie
Nachdem im vorigen Kapitel erklärt wurde, wie Hologramme aufgenommen
werden und wie sie funktionieren, stellt sich nun vielleicht die Frage, wofür
Hologramme überhaupt gut sind. Als „normaler“ Mensch kommt man meist nur
in Ausstellungen mit Hologrammen in Kontakt. In der Industrie wird Holographie
hauptsächlich für zwei Zwecke genutzt. Der erste ist die sogenannte
Interferometrie, ein Verfahren, um Materialverformungen im Nanometer-Bereich
messen zu können. Der zweite Verwendungszweck sind holographischoptische
Elemente (HOEs). Dahinter steht folgende Idee: Im vorherigen Kapitel
wurde das Hologramm eines Punktes behandelt. Dieses Hologramm ist im
Grunde eine Sammellinse, deren Brennpunkt genau an der Stelle des Punktes
liegt. Mithilfe der Holographie kann man nun Linsen erzeugen, die mit normalen
optischen Mittel nur sehr schwer oder gar nicht herzustellen wären, z.B. eine
Linse mit zehn verschiedenen Brennpunkten an völlig unterschiedlichen Stellen
mit jeweils unterschiedlichen Brennweiten. Solche HOEs sind z.B. in
Strichcode-Lesern in Supermärkten oder auch in CD-Spielern und Brennern.
Für die Herstellung von HOEs, die in der Industrie und Forschung eine sehr
wichtige Rolle spielen, wird heutzutage hauptsächlich Computerholographie
eingesetzt.
Im Folgenden werden die in Computerholographie-Programmen verwendeten
Algorithmen erklärt, und beschrieben, wie man aus dem berechneten
Interferenzmuster ein „richtiges“ und funktionierendes Hologramm herstellen
kann. Diese Arbeit beschreibt nur sogenannte Fresnelhologramme, da diese die
zugrundeliegende Physik am klarsten zeigen und zudem auch von den
optischen Eigenschaften her sehr gut sind. Andere Hologrammtypen wie z.B.
Detourphasen-Hologramme oder Fourierhologramme sind lediglich
Abwandelungen des Prinzips der Fresnelhologramme, um Probleme wie
schlechte Bildschirme o.ä. zu umgehen.
20

3.1 Grundlagen der Computerholographie
Um ein computergeneriertes Hologramm (engl. „Computer Generated
Hologram“: CGH) herzustellen, muss als erstes ein Objekt vorhanden sein,
welches holographiert werden soll. Man rastert hierzu das Objekt in einzelne
Punkte auf, ähnlich den Bildern in Zeitungen. Der Computer berechnet dann,
was sich auf der Filmplatte für ein Interferenzmuster bilden würde, wenn der
Referenzstrahl und alle Objektstrahlen von den zugehörigen Objektpunkten
miteinander interferieren. Das Interferenzmuster wird nun auf dem Bildschirm
angezeigt und mithilfe einer Kamera auf einen Film übertragen. 1 Hierbei wird
das Muster auch gleichzeitig photographisch verkleinert, damit es feiner ist und
somit eine stärkere Beugung ermöglicht. Der Film kann dann genau wie ein
herkömmliches Transmissionshologramm betrachtet werden.
3.2 Probleme bei der Computerholographie
Das Problem bei der Computerholographie liegt nicht bei der Berechnung der
Hologramme; heutige Computer sind so leistungsfähig, dass selbst komplexe
Objekte innerhalb weniger Minuten berechnet werden können.
Das Problem ist, dass das Interferenzmuster bei Hologrammen sehr fein ist. Bei
der normalen Holographie werden deshalb hochauflösende Spezialfilme mit bis
zu 6.000 Linienpaaren pro Millimeter (Lp/mm) verwendet. Bei der
Computerholographie ist allerdings nicht das Filmmaterial das Problem,
sondern die geringe Auflösung des Bildschirms. Es sollte also vor dem
photographieren des Hologramms vom Bildschirm die größte Auflösung
eingestellt werden. 2 Bei der Computerholographie ist es deshalb auch nicht
nötigt, teuren Spezialfilm zu verwenden, normales Filmmaterial wie der Kodak
Technical Pan (300 bis 400 Lp/mm) reichen völlig aus.
Ein weiteres Problem ist folgendes: Um die Berechnung zu vereinfachen und zu
beschleunigen, wählt man den Referenzstrahl so, dass er auf dem kompletten
Hologramm die Phase Null hat, also genau senkrecht auf den Film trifft.
Befindet sich nun auch das Objekt genau in der Mitte des Hologramms, wird es
bei der Rekonstruktion vom Beleuchtungsstrahl verdeckt. Bei der normalen
Holographie lässt man deshalb den Referenzstrahl immer seitlich auf das
1 In der Industrie werden Computerhologramme mithilfe von Laser-Plottern hergestellt.
2 Alle Hologramme, die im Rahmen dieser Arbeit angefertigt wurden, wurden mit einer
Auflösung von 1280 * 1024 Pixel berechnet und angezeigt.
21

Hologramm fallen. Eine solche Anordnung nennt man „Off Axis“. Um trotzdem
nicht auf den rechentechnischen Vorteil eines senkrechten Referenzstrahles
verzichten zu müssen, sollte sich das Objekt am Rand des Hologramms
befinden, aber nicht zu weit, da die Beugungskraft des Hologramms aufgrund
der geringen Bildschirmauflösung nicht sehr hoch ist.
3.3 Berechnung von Computerhologrammen
Im Rahmen dieser Facharbeit wurde ein Computerprogramm zur Berechnung
von Computerhologrammen entwickelt. Die folgenden Ausführungen beziehen
sich auf den in diesem Programm implementierten Algorithmus. Auf eine
Optimierung des Berechnungsalgorithmuses wurde absichtlich verzichtet, um
die zugrundeliegenden Prinzipien nicht zu verschleiern. Das Programm stellt
also hinsichtlich der Berechnungsgeschwindigkeit sicherlich nicht das „non plus
ultra“ dar.
Um zu verstehen, wie das Programm funktioniert, muss man sich klarmachen,
wie Hologramme in der Wirklichkeit entstehen: Auf jeden Punkt des
Hologramms trifft bei der Aufnahme der Referenzstrahl, sowie von jedem der
Objektpunkte ein Strahl. Diese Strahlen treffen alle mit einer unterschiedlichen
Phase auf den Schirm, die von der Wellenlänge und der Entfernung des
Punktes zu der entsprechenden Stelle auf dem Hologramm abhängt. Die Phase
wird dargestellt als Winkel im Bogenmaß. Ein Wellenberg hat also die Phase
π 3
, ein Wellental π und die Phase Null ist π oder 0. Die Auslenkung bei
2
2
gegebener Phase kann also folgendermaßen berechnet werden: Auslenkung =
MaxAmplitude * sin(Phase). Die Auslenkung ist nun ein Wert zwischen
MaxAmplitude und -MaxAmplitude.
Interferenz bedeutet nichts weiter, als dass alle Auslenkungen addiert werden.
Würden beispielsweise zwei Strahlen auf einen Punkt treffen, der einen mit
einem Wellenberg und der andere mit einem Tal, so würde sich für die
Gesamtauslenkung an dieser Stelle des Films ergeben: Gesamtauslenkung =
MaxAmplitude + (-MaxAmplitude) = 0.
Um die Phase zu berechnen, wird noch die Entfernung des Punktes zur
entsprechenden Stelle auf dem Hologramm benötigt. Hierzu kann folgende, aus
der Geometrie bekannte Formel verwendet werden, wobei X, Y und Z die
22

Koordinaten des Objektpunktes, von dem der Strahl ausgeht, sind, und x und y
die Koordinaten auf dem Film:
Entfernung = − + − +
2
2 2
( x X ) ( y Y)
Z
Die Phase wird nun berechnet mit:
Entfernung
Phase =
* 2 * π
Lambda
Das Programm berechnet nun für jede Stelle des Hologramms die Summe der
Auslenkungen aller Strahlen, die auf diese Stelle fallen. Der Referenzstrahl
braucht nicht beachtet zu werden, da er auf dem ganzen Hologramm eine
Phase von 0 hat, d.h. senkrecht auf das Hologramm fällt.
Die Berechnung ist in der Datei InterferenzMuster.java implementiert (siehe
Anhang E: Quelltext des CGH-Programms).
Dieses berechnete Muster ist allerdings noch nicht auf einem Bildschirm
darstellbar, da dieser nur Werte zwischen 0 (schwarz) und 255 (weiß) anzeigen
kann. Die summierten Auslenkungen müssen also noch auf Werte zwischen 0
und 255 umgerechnet werden, was in der Datei Photo.java erfolgt (siehe
Anhang E: Quelltext des CGH-Programms).
3.3.1 Zufallsphasen
In der Realität besitzen alle Objekte eine gewisse Oberflächenrauhigkeit.
Dadurch ist die Entfernung zweier Objektpunkte zur Filmplatte selbst bei
Punkten mit derselben Tiefe minimal verschieden. Diese Rauhigkeit sorgt für
einen größeren Kontrast bei dem berechneten Hologramm.
Um die Oberflächenrauhigkeit zu simulieren, berechnet das Programm für jeden
Punkt einen zufälligen Phasenwert und addiert diesen zu jedem von dem Punkt
ausgehenden Strahl dazu.
23

3.3.2 Kontrasterhöhung
Die berechneten Hologramme weisen häufig einen sehr geringen mittleren
Kontrast auf, sie wirken sehr flau. Das kommt daher, dass die meisten
Helligkeitswerte im Mittelbereich liegen und sich nur wenig voneinander
unterscheiden. Die extremen Helligkeitswerte nehmen nur sehr wenige Pixel
an.
Deshalb wurde in das Programm die Möglichkeit eingebaut, den Kontrast der
Hologramme zu verstärken. Hierzu wird der Abstand aller Helligkeitswerte vom
Durchschnittswert um 1,5 vergrößert. Bei Pixeln, die vorher schon bereits sehr
extreme Helligkeitswerte besaßen, kann der Helligkeitswert eventuell nicht um
diesen Abstand vergrößert werden, hier findet eine Über- bzw. Unterbelichtung
statt. Dieses „Abschneiden“ von extremen Helligkeitswerten wird auch als
„Clipping“ bezeichnet.
Fresnelhologramme sind relativ unempfindlich gegen Clipping, selbst wenn bis
zu 20 % der Pixel betroffen sind 1 .
3.4 Fotoarbeiten
Nachdem das Interferenzmuster nun berechnet worden ist, muss es auf einen
Film übertragen werden, der dann holographisch wirken kann.
Hierzu wird das Muster auf dem Bildschirm angezeigt und dann mit einer
Kamera ein Foto von dem Bildschirm gemacht. Der Bildschirm sollte beim
Photographieren auf eine Größe von ungefähr 1 cm Breite und 0,75 cm Höhe
verkleinert werden, damit die Beugungskraft des Musters möglichst groß ist. Bei
einem 50 mm-Objektiv stellt man dazu die Kamera ungefähr 1,5 Meter vom
Bildschirm entfernt auf einem Stativ auf.
Außerdem sollte die Belichtungszeit so lange wie möglich sein, um eine große
Schärfe zu erzielen sowie um Probleme durch Bildschirmflimmern zu umgehen.
Als ideale Belichtungszeit bei kleinster Blende (16) wurde 1 Sekunde ermittelt.
Die Entwicklung des Filmes erfolgt genauso wie die Entwicklung eines
„normalen“ Photos und muss, zumindest bis zum Fixieren, bei kompletter
Dunkelheit erfolgen.
1 Bei den Hologrammen, die im Rahmen dieser Facharbeit angefertigt wurden, wurde der
Kontrast so erhöht, dass das Clipping etwa bei 20 % lag.
24

Zum Entwickeln wurde Dokumol (Verdünnung 1+9, Entwicklungszeit ca. 5
Minuten) und zum Fixieren Superfix (Verdünnung 1+7, Fixierzeit ca. 5 Minuten),
beides von der Firma Tetenal, verwendet. Danach wird das Hologramm
mindestens 3 Minuten in Wasser geschwenkt, um alle Chemikalien
rauszuwaschen. Am Ende hält man das Negativ noch einige Zeit in eine
Spülmittellösung. Diese Lösung wirkt wie ein Netzmittel, d.h. sie verhindert die
Entstehung von Kalkflecken beim Trocknen.
Das Hologramm kann nun mit der in Kapitel 2.1 beschriebenen Methode
betrachtet werden. Setzt man als Laser einen Laserpointer ein, ist es meistens
nicht nötig, den Strahl mit einer Linse aufzuweiten, da der Strahl eines
Laserpointers bereits einen sehr großen Durchmesser aufweist.
Abbildung 12: Das "Fotolabor"
25

Anhang A: Beigefügte Materialien
• Drei Hologramme (Filmnegative)
• Eine CD mit folgendem Inhalt:
• Alle verwendeten digitalen Quellen
• Diese Arbeit im Acrobat PDF-Format
• Der Quelltext der entwickelten Software
• Das lauffähige Programm (Windows-Version)
• Eine Readme-Datei, in der die Installation und der Start der Software
erläutert werden
• Die Simulationsdateien sowie berechneten Interferenzmuster der
beigefügten Hologramme
26

Anhang B: Bedienung des CGH-Programms
Abbildung 13: Oberfläche des Programms
Objekteigenschaften
Hologramm-Editor
Hier werden die Eigenschaften des im Hologramm-
Editor ausgewählten Punkts angezeigt. Wenn im
Editor kein Punkt selektiert ist, werden die
Eigenschaften der Simulation angezeigt.
Der Editor zeigt das zu holographierende
Punktmuster an.
Der ausgewählte Punkt ist rot, alle anderen schwarz.
Der selektierte Punkt kann mit gedrückter Maustaste
verschoben werden.
Die grauen Striche zeigen die Begrenzung der
Hologrammfläche, es ist allerdings, wie in der Grafik,
auch möglich, Buchstaben außerhalb der
Hologrammfläche zu platzieren.
27

Toolbar
Neu
Öffnen
Speichern
Punkt Hinzufügen
Text Hinzufügen
Punkt Löschen
Berechnen
Info
Beenden
Setzt die Simulation auf
Standardwerte zurück, das
Programm ist nun in dem
selben Zustand wie nach
einem Neustart.
Öffnet eine gespeicherte
Simulation oder ein bereits
berechnetes
Interferenzmuster.
Speichert die Simulation in
eine Datei.
Schaltet den Editor in den
Punkt-Eingabe-Modus: An der
Stelle des nächsten
Mausklicks wird ein neuer
Punkt erzeugt.
Öffnet einen Dialog, in dem
man einen Text angeben
kann. An der Stelle des
nächsten Mausklicks wird der
Text als Punktmuster
eingefügt.
Löscht den im Editor
ausgewählten Punkt.
Berechnet das
Interferenzmuster und zeigt es
in einem neuen Fenster an.
Zeigt eine kurze
Programminfo.
Beendet das Programm. Eine
evtl. noch laufende
Berechnung wird
abgebrochen.
28

Anhang C: Literaturverzeichnis
Bücher
[HE86]: Heiß, Peter: Holographie-Fibel, Hologramme verstehen und
selbermachen; Hückelhoven 1986
[HE95]: Heiß, Peter: Die neue Holographie-Fibel; Hückelhoven 1986, 1995
[ME95]: Meyers Lexikonred. (Hrsg): Schülerduden Physik; Mannheim, Leipzig,
Wien, Zürich, 1995
[WE00]: Weltbild: Der Brockhaus; Mannheim 2000
Internet-Quellen
[ME97]: Meyer, Michael: Facharbeit Holographie, Einführung in die
Holographie, Beschreibung der Anfertigung von einfachen
Hologrammen; www.holography.de; Stand: Dezember 2004
[FO00]: Fouquier, Alex: Facharbeit Holographie; ap.physik.uni-
konstanz.de/Literatur/mirror/Holographie/Facharbeit_Alex-
Fouquier/Holographie_Facharbeit_Alex-Fouquier.pdf; Stand:
Dezember 2004
[FF97]: Fritz, Haimo/Ferri, Lucilla Croce, Fraunhofer Institut für Graphische
Datenverarbeitung: Erzeugung von computergenerierten Hologrammen
mit Hilfe eines hochauflösenden Laserbelichters;
www.inigraphics.net/ini-ccc/projects/holographie/interfer.pdf, Stand:
Januar 2005
Verwendete Software
Zum Entwickeln des Computerholographieprogramms wurde das Java 2 SDK
Version 1.4.1 verwendet, Copyright 2002 Sun Microsystems, Inc.
Das Programm verwendet für die Graphische Oberfläche das Standard Widget
Toolkit, Copyright (c) 2000, 2004 IBM Corporation and others.
29

Anhang D: Selbstständigkeitserklärung
Ich versichere, dass ich diese Facharbeit selbständig angefertigt habe. Neben
den angegebenen Quellen und Materialien habe ich keine weiteren Hilfsmittel
benutzt.
Biedenkopf-Wallau, den 19.02.2005
Michael Partheil
30

Anhang E: Quelltext des CGH-Programms
AuswahlListener.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import java.util.*;
/** Interface für Objekte, die informiert werden wollen, wenn sich die
Auswahl im HologrammEditor geändert hat. Diese Objekte müssen mit
addAuswahlListener dem HologrammEditor hinzugefügt werden */
public interface AuswahlListener extends EventListener
{
/** Diese Methode wird aufgerufen, wenn sich die Auswahl geändert
hat. sender ist der HologrammEditor und neueAuswahl die neue
Auswahl, entweder ein Objekt vom Typ ObjektPunkt oder vom
Typ Simulation */
public void auswahlGeaendert(Object sender, Object neueAuswahl);
}
BerechnungsFortschrittListener.java
import java.util.*;
/** Implementierende Klassen können sich mit addFortschrittListener
bei einem InterferenzMuster registrieren und werden über den
Fortgang der Berechnung informiert */
public interface BerechnungsFortschrittListener extends EventListener
{
public static final int BERECHNUNG_BEENDET = -1;
/** Diese Methode wird aufgerufen, wenn sich der Fortschritt der
Berechnung des InterferenzMusters geändert hat. aktuelleSpalte ist
die Spalte, die gerade berechnet wird oder BERECHNUNG_BEENDET,
wenn
die Berechnung fertig ist und gesamtSpalten ist die Zahl der
Spalten,
die insgesamt zu berechnen sind.
Achtung: Diese Methode läuft in dem Thread, in dem auch die
Berechnung
läuft, also nicht zwangsläufig im GUI-Thread! */
public void berechnungsFortschritt(int aktuelleSpalte, int
gesamtSpalten);
}
CGHMain.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import org.eclipse.swt.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;
/** Hauptklasse, startet das Programm */
public class CGHMain
31

{
/** Das Display dieser Anwendung. Sollte nicht geschrieben werden */
public static Display display;
/** Main-Methode, öffnet eine MainShell und ruft waitForClose() auf.
Evtl. wird Sleak geöffnet, wenn die Eigenschaft cgh.useSleak
gesetzt ist */
public static void main(String[] args)
{
if (System.getProperty("cgh.useSleak") != null)
{
DeviceData data = new DeviceData();
data.tracking = true;
display = new Display(data);
Sleak sleak = new Sleak();
sleak.open();
}
else
display = new Display();
}
}
MainShell mainShell = new MainShell();
if (args.length >= 1)
{
mainShell.open(args[0]);
}
mainShell.waitForClose();
display.dispose();
DynamicHelpListener.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import org.eclipse.swt.events.*;
import org.eclipse.swt.widgets.*;
/** Diese Klasse setzt einen Hilfe-Text im HelpViewer, wenn die Maus
über ein Control bewegt wird, bei dem dieser DynamicHelpListener
mit addMouseTrackListener registriert wurde */
public class DynamicHelpListener extends MouseTrackAdapter
{
private String hilfeText;
private HelpViewer helpViewer;
public static void addToAll(Composite addTo, HelpViewer viewer,
String hilfeText)
{
DynamicHelpListener l = new DynamicHelpListener(viewer,
hilfeText);
Control[] children = addTo.getChildren();
addTo.addMouseTrackListener(l);
for (int i=0; i

}
soll und hilfeText ist der Text */
public DynamicHelpListener(HelpViewer viewer, String hilfeText)
{
super();
if (viewer == null || hilfeText == null)
throw new IllegalArgumentException("parameter ist null");
this.hilfeText = hilfeText;
helpViewer = viewer;
}
/** Vorgabe aus MouseTrackListener */
public void mouseEnter(MouseEvent evt)
{
helpViewer.setHilfe(hilfeText);
}
/** Vorgabe aus MouseTrackListener */
public void mouseExit(MouseEvent evt)
{
helpViewer.setHilfe("");
}
EigenschaftenEditorControl.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import org.eclipse.swt.*;
import org.eclipse.swt.custom.*;
import org.eclipse.swt.widgets.*;
/** GUI-Klasse, die einen Editor für die Auswahl im HologrammEditor
bereitstellt.
Je nach Auswahl wird entweder ein SimulationEditor oder ein
ObjektPunktEditor-Objekt
verwendet */
public class EigenschaftenEditorControl extends Composite implements
AuswahlListener
{
private StackLayout layout;
private ObjektEditor nullEditor;
/** Konstruktor. editorFuer ist der HologrammEditor, dessen Auswahl
editiert werden
soll. Dieser EigenschaftEditorControl registriert sich automatisch
bei dem HologrammEditor
als AuswahlListener. helpViewer ist der HelpViewer der Anwendung
*/
public EigenschaftenEditorControl(Composite parent, HologrammEditor
editorFuer, HelpViewer helpViewer)
{
super(parent, SWT.NONE);
layout = new StackLayout();
setLayout(layout);
new SimulationEditor(this, editorFuer, helpViewer);
new ObjektPunktEditor(this, editorFuer, helpViewer);
nullEditor = new NullEditor(this);
33

}
layout.topControl = nullEditor;
setObjekt(null);
editorFuer.addAuswahlListener(this);
/** Vorgabe aus AuswahlListener */
public void auswahlGeaendert(Object sender, Object auswahl)
{
setObjekt(auswahl);
}
/** Speichert die Eigenschaften des vorher bearbeiteten Objektes und
startet die Editierung eines neuen Objektes. obj sollte entweder
vom
Typ Simulatoin oder ObjektPunkt sein oder eine andere Klasse, für
die
ein ObjektEditor vorhanden ist. */
public void setObjekt(Object obj)
{
ObjektEditor alterEditor = (ObjektEditor)layout.topControl;
alterEditor.speichereEigenschaften();
}
Control[] editoren = getChildren();
for (int i=0; i

import org.eclipse.swt.widgets.*;
/** Dialog, der ein InterferenzMuster anzeigt und Möglichkeiten zum
Verändern
des Kontrastes und zum Speichern anbietet */
public class ErgebnisDialog extends Dialog
{
private Photo photo;
private Image img;
private Image imgIcon;
private ScrolledComposite canvasScroller;
private Canvas canvasAnzeige;
private Button btnVollbild;
private Button btnSpeichern;
private Button btnKontrastErhoehen;
private Button btnSchliessen;
public ErgebnisDialog(Shell parent, Photo photo)
{
super(parent, SWT.NONE);
this.photo = photo;
}
public void open()
{
final Display display = CGHMain.display;
img = new Image(display, photo.getImageData());
final Shell shell = new Shell(getParent(), SWT.DIALOG_TRIM |
SWT.APPLICATION_MODAL | SWT.RESIZE);
shell.setText("Hologramm");
imgIcon = new Image(display,
getClass().getResourceAsStream("ergebnis.ico"));
shell.setImage(imgIcon);
canvasScroller = new ScrolledComposite(shell, SWT.BORDER |
SWT.H_SCROLL | SWT.V_SCROLL);
canvasScroller.setAlwaysShowScrollBars(true);
canvasAnzeige = new Canvas(canvasScroller, SWT.NO_REDRAW_RESIZE);
canvasAnzeige.addPaintListener(new PaintListener()
{
public void paintControl(PaintEvent evt)
{
evt.gc.drawImage(img, 0, 0);
}
} );
canvasAnzeige.setLocation(0, 0);
canvasAnzeige.setSize(img.getBounds().width,
img.getBounds().height);
canvasScroller.setContent(canvasAnzeige);
Composite buttonBar = new Composite(shell, SWT.NONE);
RowLayout layout = new RowLayout(SWT.HORIZONTAL);
layout.spacing = 5;
layout.marginWidth = 5;
layout.marginHeight = 5;
buttonBar.setLayout(layout);
btnVollbild = new Button(buttonBar, SWT.PUSH);
35

tnVollbild.setText("&Vollbildanzeige");
btnSpeichern = new Button(buttonBar, SWT.PUSH);
btnSpeichern.setText("&Speichern");
btnKontrastErhoehen = new Button(buttonBar, SWT.PUSH);
btnKontrastErhoehen.setText("&Kontrast erhöhen");
btnSchliessen = new Button(buttonBar, SWT.PUSH);
btnSchliessen.setText("S&chließen");
shell.setLayout(new FormLayout());
FormData fd;
fd = new FormData(canvasAnzeige.getSize().x,
canvasAnzeige.getSize().y);
fd.left = new FormAttachment(0);
fd.top = new FormAttachment(0);
fd.right = new FormAttachment(100);
fd.bottom = new FormAttachment(buttonBar);
canvasScroller.setLayoutData(fd);
fd = new FormData();
fd.left = new FormAttachment(0);
fd.right = new FormAttachment(100);
fd.bottom = new FormAttachment(100);
buttonBar.setLayoutData(fd);
btnVollbild.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
if (! display.getBounds().equals(img.getBounds()))
{
if (SWTUtils.messageBox(shell, SWT.ICON_QUESTION |
SWT.YES | SWT.NO, "Vollbildanzeige",
"Die Abmessungen des Hologramms (in Pixeln) und die
ihres Bildschirmes sind verschieden.\n"+
"Es empfiehlt sich, ein Hologramm, das vom Bildschirm
abphotografiert werden soll, in der\n"+
"selben Auflösung berechnen zu lassen wie die des
Bildschirmes, also z. B. 1024*768 Pixel.\n"+
"Trotzdem anzeigen?") == SWT.NO)
return;
}
VollBildDialog vbd = new VollBildDialog(shell, img);
vbd.open();
}
} );
btnSpeichern.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
FileDialog fd = new FileDialog(shell, SWT.SAVE);
fd.setFilterExtensions(new String[]{ "*.bmp", "*.gif",
"*.*" });
fd.setFilterNames(new String[]{ "Windows Bitmap (*.bmp)",
"Compuserve GIF-Bild (*.gif)", "Alle Dateien" });
fd.setText("Hologramm als Bild speichern");
String filename = null;
if ((filename = fd.open()) != null)
36

}
} );
{
}
int format = SWT.IMAGE_BMP;
if (filename.toUpperCase().endsWith(".GIF"))
format = SWT.IMAGE_GIF;
ImageLoader il = new ImageLoader();
il.data = new ImageData[]{ photo.getImageData() };
il.save(filename, format);
btnKontrastErhoehen.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
final float FAKTOR = 1.5f;
int clipping = 0;
ImageData id = photo.getImageData();
double durchschnitt = photo.getDurchschnittsPixel();
for (int x=0; x

}
}
{
if (! display.readAndDispatch())
display.sleep();
}
img.dispose();
imgIcon.dispose();
HelpViewer.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import org.eclipse.swt.*;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;
/** Control, um einen Hilfetext anzuzeigen */
public class HelpViewer extends Composite
{
private Display display = CGHMain.display;
private Image imgHelp;
private Label lblImage;
private Label lblUeberschrift;
private Label lblHilfe;
public HelpViewer(Composite parent)
{
super(parent, SWT.BORDER);
}
macheGui();
setHilfe(null);
/** Zeigt einen Hilfetext. Ist der hilfeText null oder "" wird eine
Erklärung
über den HelpViewer selber angezeigt */
public void setHilfe(String hilfeText)
{
if ((hilfeText != null) && (! hilfeText.equals("")))
lblHilfe.setText(hilfeText);
else
lblHilfe.setText("Hier werden nähere Informationen zu dem
Element des Programmes angezeigt, "+
"das sich gerade unter dem Mauszeiger befindet.");
}
public String getHilfe()
{
return lblHilfe.getText();
}
private void macheGui()
{
imgHelp = new Image(display,
getClass().getResourceAsStream("help.gif"));
38

lblImage = new Label(this, SWT.NONE);
imgHelp.setBackground(lblImage.getBackground());
lblImage.setImage(imgHelp);
lblUeberschrift = new Label(this, SWT.NONE);
lblUeberschrift.setText("Dynamische Hilfe");
final Font f = new Font(display,
lblUeberschrift.getFont().getFontData()[0].getName(),
lblUeberschrift.getFont().getFontData()[0].getHeight(),
SWT.BOLD);
lblUeberschrift.setFont(f);
lblUeberschrift.addDisposeListener(new DisposeListener()
{
public void widgetDisposed(DisposeEvent evt)
{
f.dispose();
}
} );
}
}
lblHilfe = new Label(this, SWT.WRAP);
lblHilfe.setText("");
GridLayout layout = new GridLayout(2, false);
setLayout(layout);
GridData gd;
gd = new GridData();
gd.horizontalAlignment = SWT.CENTER;
lblImage.setLayoutData(gd);
gd = new GridData();
lblUeberschrift.setLayoutData(gd);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.verticalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
gd.grabExcessVerticalSpace = true;
gd.horizontalSpan = 2;
lblHilfe.setLayoutData(gd);
HologrammEditor.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import org.eclipse.swt.*;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;
import java.util.*;
/** Visuelle Editierung eines Punkmusters (zu holographierendes
Objekt) */
public class HologrammEditor extends Canvas
{
private Simulation simulation;
39

private Object auswahl;
private java.util.List auswahlListeners;
private java.util.List posListeners;
private Display display;
private Point dpcm;
private static final int MODE_SELECT = 1;
private static final int MODE_ADD = 2;
private static final int MODE_MOVE = 3;
private int mode = MODE_SELECT;
private TextPseudoObjekt textObjekt = null;
private static final int BUCHSTABEN_ABSTAND = 3;
private final Point[][] BUCHSTABEN_MUSTER = {
{ new Point(3, 0), new Point(2, 2), new Point(1, 4), new Point(0,
6), new Point(4, 2), new Point(5, 4), new Point(6, 6), new Point(3, 4)
}, // A
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 0), new Point(2, 3), new Point(2, 6), new Point(4,
1), new Point(4, 5) }, // B
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 0), new Point(4, 0), new Point(2, 6), new Point(4, 6)
}, // C
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 0), new Point(3, 2), new Point(3, 4), new Point(2, 6)
}, // D
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 0), new Point(4, 0), new Point(2, 3), new Point(4,
3), new Point(2, 6), new Point(4, 6) }, // E
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 0), new Point(4, 0), new Point(2, 3), new Point(4, 3)
}, // F
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 0), new Point(4, 0), new Point(2, 4), new Point(4,
4), new Point(2, 6), new Point(4, 6) }, // G
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 3), new Point(4, 0), new Point(4, 2), new Point(4,
4), new Point(4, 6) }, // H
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6) }, // I
{ new Point(2, 0), new Point(2, 2), new Point(2, 4), new Point(1,
6), new Point(0, 4) }, // J
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 3), new Point(4, 2), new Point(5, 0), new Point(4,
4), new Point(5, 6) }, // K
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 6), new Point(4, 6) }, // L
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 2), new Point(3, 4), new Point(4, 2), new Point(6,
0), new Point(6, 2), new Point(6, 4), new Point(6, 6) }, // M
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 2), new Point(3, 4), new Point(5, 0), new Point(5,
2), new Point(5, 4), new Point(5, 6) }, // N
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 0), new Point(2, 6), new Point(4, 0), new Point(4,
2), new Point(4, 4), new Point(4, 6) }, // O
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 0), new Point(4, 0), new Point(4, 2), new Point(4,
4), new Point(2, 4) }, // P
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
40

6), new Point(2, 0), new Point(2, 6), new Point(4, 0), new Point(4,
2), new Point(4, 4), new Point(4, 6), new Point(5, 7) }, // Q
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 0), new Point(3, 2), new Point(2, 4), new Point(3, 6)
}, // R
{ new Point(0, 0), new Point(2, 0), new Point(4, 0), new Point(0,
2), new Point(2, 3), new Point(4, 4), new Point(0, 6), new Point(2,
6), new Point(4, 6) }, // S
{ new Point(0, 0), new Point(2, 0), new Point(4, 0), new Point(2,
2), new Point(2, 4), new Point(2, 6) }, // T
{ new Point(0, 0), new Point(0, 2), new Point(0, 4), new Point(0,
6), new Point(2, 6), new Point(4, 0), new Point(4, 2), new Point(4,
4), new Point(4, 6) }, // U
{ new Point(0, 0), new Point(1, 2), new Point(2, 4), new Point(3,
6), new Point(4, 4), new Point(5, 2), new Point(6, 0) }, // V
{ new Point(0, 0), new Point(1, 2), new Point(2, 4), new Point(3,
6), new Point(5, 4), new Point(7, 6), new Point(8, 4), new Point(9,
2), new Point(10, 0) }, // W
{ new Point(0, 0), new Point(1, 2), new Point(1, 4), new Point(0,
6), new Point(4, 0), new Point(3, 2), new Point(3, 4), new Point(4, 6)
}, // X
{ new Point(0, 0), new Point(1, 2), new Point(2, 4), new Point(2,
6), new Point(3, 2), new Point(4, 0) }, // Y
{ new Point(0, 0), new Point(2, 0), new Point(4, 0), new Point(3,
2), new Point(2, 3), new Point(1, 4), new Point(0, 6), new Point(2,
6), new Point(4, 6) } // Z
};
public HologrammEditor(Composite parent, Simulation simulation,
HelpViewer helpViewer)
{
super(parent, SWT.NO_REDRAW_RESIZE | SWT.NO_BACKGROUND);
this.simulation = simulation;
auswahl = simulation;
display = CGHMain.display;
Point dpi = display.getDPI();
dpcm = new Point(Math.round(dpi.x / 2.54f), Math.round(dpi.y /
2.54f));
auswahlListeners = new ArrayList();
posListeners = new ArrayList();
addMouseTrackListener(new DynamicHelpListener(helpViewer, "Im
Hologramm-Editor können Sie die einzelnen "+
"Objektpunkte der Simulation bearbeiten. Der ausgewälte Punkt
ist rot, ist keiner ausgewählt, ist "+
"die Auswahl die Simulation. Punkte können mit gedrückter
Maustaste verschoben werden."));
addPaintListener(new PaintListener()
{
public void paintControl(PaintEvent evt)
{
HologrammEditor.this.paintControl(evt);
}
});
addMouseListener(new MouseAdapter()
{
public void mouseDown(MouseEvent evt)
{
HologrammEditor.this.mouseDown(evt);
41

}
}
public void mouseUp(MouseEvent evt)
{
HologrammEditor.this.mouseUp(evt);
}
} );
addMouseMoveListener(new MouseMoveListener()
{
public void mouseMove(MouseEvent evt)
{
HologrammEditor.this.mouseMove(evt);
}
} );
/** Schaltet den Editor in den Punkteingabe-Modus.
An der Stelle wo als nächstes hingeklickt wird, wird ein PUnkt
eingefügt */
public void startePunktEingabe()
{
mode = MODE_ADD;
textObjekt = null;
}
/** Schaltet den Editor in den Texteingabe-Modus. An der Stelle, wo
als nächstes hingeklickt wird, wird der Text textObjekt eingefügt
*/
public void starteTextEingabe(TextPseudoObjekt textObjekt)
{
if (textObjekt == null)
throw new IllegalArgumentException("textObjekt ist null");
}
textObjekt.text = textObjekt.text.toUpperCase();
mode = MODE_ADD;
this.textObjekt = textObjekt;
private int buchstabenBreite(char c)
{
c = Character.toUpperCase(c);
if (c == ' ')
return 5;
if (c >= 'A' && c

{
}
auswahlListeners.remove(al);
private void fireAuswahlEvent()
{
for (Iterator it=auswahlListeners.iterator(); it.hasNext(); )
{
AuswahlListener al = (AuswahlListener)it.next();
al.auswahlGeaendert(this, auswahl);
}
}
public void addObjektPunktPosListener(ObjektPunktPosListener l)
{
posListeners.add(l);
}
public void removeObjektPunktPosListener(ObjektPunktPosListener l)
{
posListeners.remove(l);
}
private void fireObjektPunktPosEvent(ObjektPunkt punkt)
{
for (Iterator it=posListeners.iterator(); it.hasNext(); )
{
ObjektPunktPosListener l = (ObjektPunktPosListener)it.next();
l.punktPosGeaendert(this, punkt);
}
}
public void setSimulation(Simulation s)
{
if (simulation == null)
throw new IllegalArgumentException("simulation ist null");
simulation = s;
setAuswahl(simulation);
redraw();
}
public Simulation getSimulation()
{
return simulation;
}
public Object getAuswahl()
{
return auswahl;
}
public void setAuswahl(Object obj)
{
auswahl = obj;
redraw();
fireAuswahlEvent();
}
private void mouseMove(MouseEvent evt)
{
final Point klick = new Point(Math.round(evt.x /
simulation.anzeigeSkalierung),
Math.round(evt.y / simulation.anzeigeSkalierung));
43

selben wie in paintControl:
final int width = Math.round(dpcm.x * simulation.musterBreite);
final int height = Math.round(dpcm.y * simulation.musterHoehe);
final Point rand = new Point(Math.round(dpcm.x*0.25f),
Math.round(dpcm.y*0.25f)); // 1/4 cm Rand
final int imgWidth = width + 2*rand.x;
final int imgHeight = height + 2*rand.y;
}
// ist der Klick in der Zeichenfläche?
if (klick.x >= imgWidth || klick.y >= imgHeight)
return;
if (mode == MODE_MOVE && auswahl instanceof ObjektPunkt)
{
ObjektPunkt punkt = (ObjektPunkt)auswahl;
punkt.x = (float)(klick.x-rand.x+1) / (float)dpcm.x;
punkt.y = (float)(klick.y-rand.y+1) / (float)dpcm.y;
redraw();
}
private void mouseUp(MouseEvent evt)
{
final Point klick = new Point(Math.round(evt.x /
simulation.anzeigeSkalierung),
Math.round(evt.y / simulation.anzeigeSkalierung));
// selben wie in paintControl:
final int width = Math.round(dpcm.x * simulation.musterBreite);
final int height = Math.round(dpcm.y * simulation.musterHoehe);
final Point rand = new Point(Math.round(dpcm.x*0.25f),
Math.round(dpcm.y*0.25f)); // 1/4 cm Rand
final int imgWidth = width + 2*rand.x;
final int imgHeight = height + 2*rand.y;
// ist der Klick in der Zeichenfläche?
if (klick.x >= imgWidth || klick.y >= imgHeight)
return;
if (mode == MODE_ADD)
{
if (textObjekt == null)
{
ObjektPunkt punkt = new ObjektPunkt((float)(klick.x-rand.x+1)
/ (float)dpcm.x,
(float)(klick.y-rand.y+1) / (float)dpcm.y, 30.0f);
simulation.punktHinzufuegen(punkt);
setAuswahl(punkt);
redraw();
mode = MODE_SELECT;
}
else
{
String text = textObjekt.text;
float z = textObjekt.startZ;
for (int i=0; i

Point[] muster = BUCHSTABEN_MUSTER[buchstabe-'A'];
for (int j=0; j= imgWidth || klick.y >= imgHeight)
return;
if (mode == MODE_SELECT)
{
// ist da ein Punkt?
for (Iterator it=simulation.objektIterator(); it.hasNext(); )
{
ObjektPunkt punkt = (ObjektPunkt)it.next();
Point pos = new Point(rand.x + Math.round(punkt.x * dpcm.x)-
1, rand.y + Math.round(punkt.y * dpcm.y)-1);
if (klick.equals(pos))
{
// einen punkt gefunden, prüfen, ob der bereits gewählt
war, wenn ja, in move-mode schalten,
// ansonnsten den punkt auswählen
if (auswahl == punkt)
{
mode = MODE_MOVE;
45

kein
}
}
}
}
else
setAuswahl(punkt);
return;
}
// wenn wir hier sind, ist der Klick zwar auf der Fläche, aber
// PUnkt ist dort, also simulation auswählen:
setAuswahl(simulation);
private void paintControl(PaintEvent evt)
{
//setLocation(0, 0);
setSize(computeSize(SWT.DEFAULT, SWT.DEFAULT));
final int width = Math.round(dpcm.x * simulation.musterBreite);
final int height = Math.round(dpcm.y * simulation.musterHoehe);
final Point rand = new Point(Math.round(dpcm.x*0.25f),
Math.round(dpcm.y*0.25f)); // 1/4 cm Rand
final int imgWidth = width + 2*rand.x;
final int imgHeight = height + 2*rand.y;
final Color white = display.getSystemColor(SWT.COLOR_WHITE);
final Color black = display.getSystemColor(SWT.COLOR_BLACK);
final Color red = display.getSystemColor(SWT.COLOR_RED);
final Color gray = display.getSystemColor(SWT.COLOR_GRAY);
Image img = new Image(display, imgWidth, imgHeight);
GC gc = new GC(img);
// hintergrund zeichnen
gc.setBackground(white);
gc.fillRectangle(0, 0, imgWidth, imgHeight);
// "Koordinatensystem" zeichnen
gc.setForeground(gray);
gc.drawLine(0, rand.x-1, imgWidth-1, rand.x-1);
gc.drawLine(0, rand.x+height-1, imgWidth-1, rand.x+height-1);
gc.drawLine(rand.x-1, 0, rand.x-1, imgHeight-1);
gc.drawLine(rand.x+width-1, 0, rand.x+width-1, imgHeight-1);
// Pfeilchen zeichnen
gc.drawLine(imgWidth-1, rand.x-1, imgWidth-3, rand.x-3);
gc.drawLine(imgWidth-1, rand.x-1, imgWidth-3, rand.x+1);
gc.drawLine(imgWidth-3, rand.x-3, imgWidth-3, rand.x+1);
gc.drawLine(rand.x-1, imgHeight-1, rand.x-3, imgHeight-3);
gc.drawLine(rand.x-1, imgHeight-1, rand.x+1, imgHeight-3);
gc.drawLine(rand.x-3, imgHeight-3, rand.x+1, imgHeight-3);
// ObjektPunkte zeichnen
for (Iterator it=simulation.objektIterator(); it.hasNext(); )
{
ObjektPunkt punkt = (ObjektPunkt)it.next();
if (auswahl == punkt)
gc.setForeground(red);
else
gc.setForeground(black);
int x = rand.x + Math.round(punkt.x * dpcm.x) - 1;
46

}
int y = rand.y + Math.round(punkt.y * dpcm.y) - 1;
gc.drawPoint(x, y);
gc.dispose();
evt.gc.drawImage(img, 0, 0, imgWidth, imgHeight,
0, 0, imgWidth*simulation.anzeigeSkalierung,
imgHeight*simulation.anzeigeSkalierung);
img.dispose();
}
public Point computeSize(int wHint, int hHint, boolean changed)
{
// aus paintControl etc:
final int width = Math.round(dpcm.x * simulation.musterBreite);
final int height = Math.round(dpcm.y * simulation.musterHoehe);
final Point rand = new Point(Math.round(dpcm.x*0.25f),
Math.round(dpcm.y*0.25f)); // 1/4 cm Rand
final int imgWidth = width + 2*rand.x;
final int imgHeight = height + 2*rand.y;
final Point clientSize = new
Point(imgWidth*simulation.anzeigeSkalierung,
imgHeight*simulation.anzeigeSkalierung);
final Rectangle trim = computeTrim(0, 0, clientSize.x,
clientSize.y);
return new Point(trim.width, trim.height);
}
}
InterferenzMuster.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import java.util.*;
/** InterferenzMuster stellt das Muster dar, welches durch
das Interferieren von Lichtwellen, die von mehreren ObjektPunkten
ausgehen, entsteht. */
public class InterferenzMuster
{
private double[][] muster;
private ObjektPunkt[] objekt;
private float breiteVomPixel, hoeheVomPixel;
private double lambda;
private double minAmplitude;
private double maxAmplitude;
private boolean zufallsPhasen;
private List listeners;
/** Neues InterferenzMuster erstellen.
objekt ist das zu holographierende Objekt; zufallsPhasen bestimmt,
ob die
in den ObjektPunkten gespeicherten Zufallsphasen mit berechnet
werden sollen;
lambda ist die Wellenlänge des Lasers; breiteInPixel und
hoeheInPixel geben
(indirekt in Kombination mit musterBreite u. musterHoehe) die
47

Auflösung an
und musterBreite und musterHoehe sind die Abmessungen des Musters
in cm. */
public InterferenzMuster(ObjektPunkt[] objekt, boolean
zufallsPhasen, double lambda,
int breiteInPixel, int hoeheInPixel, float musterBreite, float
musterHoehe)
{
if (objekt == null)
throw new IllegalArgumentException("objekt ist null");
if (lambda

l)
{
}
listeners.remove(l);
private void fireFortschrittEvent(int aktuelleSpalte)
{
for (Iterator it=listeners.iterator(); it.hasNext();)
{
BerechnungsFortschrittListener l =
(BerechnungsFortschrittListener)it.next();
l.berechnungsFortschritt(aktuelleSpalte, muster.length);
}
}
/** Gibt ein Array mit den summierten Elongationen der Wellen
(Interferenzmuster)
zurück. Die Werte können auch negativ sein */
public double[][] getMuster()
{
return muster;
}
public ObjektPunkt[] getObjekt()
{
return objekt;
}
public double getLambda()
{
return lambda;
}
public double getMusterBreite()
{
return muster.length * breiteVomPixel;
}
public double getMusterHoehe()
{
return muster[0].length * hoeheVomPixel;
}
/** Die kleinste auftretende Amplitude, wird für die umrechnung in
in Hell-Dunkel Werte benötigt */
public double getMinAmplitude()
{
return minAmplitude;
}
/** Minimale Auslenkung, siehe getMinAmplitude() */
public double getMaxAmplitude()
{
return maxAmplitude;
}
private void berechneMuster()
{
for (int x=0; x

Photofläche (in Pixeln).
// Der Pixel, den wir hier an dieser Stelle gerade behandeln
ist P(x|y)
muster[x][y] = 0.0;
// Jetzt außerdem noch jeden Punkt des Objektes abklappern:
for (int obj=0; obj

MainShell.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import org.eclipse.swt.*;
import org.eclipse.swt.custom.*;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
import java.io.*;
import java.text.*;
import java.util.*;
/** Hauptfenster der Anwendung */
public class MainShell
{
private Shell shell;
private Display display;
private ToolBar toolBar;
private ToolItem tiNeu;
private ToolItem tiOeffnen;
private ToolItem tiSpeichern;
private ToolItem tiPunktHinzufuegen;
private ToolItem tiTextHinzufuegen;
private ToolItem tiPunktLoeschen;
private ToolItem tiBerechnen;
private ToolItem tiInfo;
private ToolItem tiBeenden;
private Image imgNeu;
private Image imgOeffnen;
private Image imgSpeichern;
private Image imgPunktHinzufuegen;
private Image imgTextHinzufuegen;
private Image imgPunktLoeschen;
private Image imgBerechnen;
private Image imgBerechnenDisabled;
private Image imgInfo;
private Image imgBeenden;
private Image imgIcon;
private HologrammEditor holoEditor;
private EigenschaftenEditorControl eigenschaftenEditor;
private HelpViewer helpViewer;
private ScrolledComposite holoEditorScroller;
public MainShell()
{
display = CGHMain.display;
shell = new Shell(display);
shell.setText("CGH");
imgIcon = new Image(display,
getClass().getResourceAsStream("cgh.ico"));
shell.setImage(imgIcon);
51

}
macheGui();
registriereListener();
shell.pack();
SWTUtils.centerShell(shell, null);
shell.open();
/** Öffnet eine Datei, ist die Endung .bmp oder .gif wird sie im
ErgebnisDialog geöffnet,
sonst im HologrammEditor */
public void open(String filename)
{
if (filename == null || filename.equals(""))
throw new IllegalArgumentException("filename ist ungültig");
if (filename.toUpperCase().endsWith(".BMP") ||
filename.toUpperCase().endsWith(".GIF"))
{
final ImageData data = new ImageData(filename);
double durchschnittTemp = 0.0;
for (int x=0; x

{
SWTUtils.messageBox(shell, SWT.ICON_ERROR | SWT.OK, "Öffnen",
"Fehler beim Öffnen: " + e);
}
if (sim != null)
{
holoEditor.setSimulation(sim);
holoEditor.setAuswahl(sim);
holoEditor.redraw();
}
}
private void registriereListener()
{
tiNeu.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
holoEditor.setSimulation(new Simulation());
holoEditor.setAuswahl(holoEditor.getSimulation());
holoEditor.redraw();
}
} );
tiOeffnen.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
FileDialog fd = new FileDialog(shell, SWT.OPEN);
fd.setFilterExtensions(new String[]{ "*.cgh", "*.bmp",
"*.gif", "*.*" });
fd.setFilterNames(new String[]{ "Hologramm-Datei (*.cgh)",
"Windows Bitmap (*.bmp)",
"Compuserve GIF-Bild (*.gif)", "Alle Dateien" });
String filename = null;
Simulation sim = null;
if ((filename = fd.open()) != null)
{
open(filename);
}
}
} );
tiSpeichern.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
FileDialog fd = new FileDialog(shell, SWT.SAVE);
fd.setFilterExtensions(new String[]{ "*.cgh", "*.*" });
fd.setFilterNames(new String[]{ "Hologramm-Datei (*.cgh)",
"Alle Dateien" });
String filename = null;
if ((filename = fd.open()) != null)
{
eigenschaftenEditor.speichereEigenschaften();
try
{
ObjectOutputStream oos = new ObjectOutputStream(new
FileOutputStream(filename));
oos.writeObject(holoEditor.getSimulation());
oos.close();
}
catch (IOException e)
{
SWTUtils.messageBox(shell, SWT.ICON_ERROR | SWT.OK,
53

"Speichern", "Fehler beim Speichern: " + e);
}
}
}
} );
tiPunktHinzufuegen.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
holoEditor.startePunktEingabe();
}
} );
tiTextHinzufuegen.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
TextInputDialog tid = new TextInputDialog(shell);
TextPseudoObjekt text = null;
if ((text = tid.open()) != null)
{
holoEditor.starteTextEingabe(text);
}
}
} );
tiPunktLoeschen.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
if (holoEditor.getAuswahl() instanceof ObjektPunkt)
{
holoEditor.getSimulation().punktLoeschen((ObjektPunkt)holoEditor.get
Auswahl());
holoEditor.setAuswahl(holoEditor.getSimulation());
holoEditor.redraw();
}
else
display.beep();
}
} );
tiBerechnen.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
tiBerechnen.setEnabled(false);
final Cursor waitCursor = new Cursor(display,
SWT.CURSOR_WAIT);
shell.setCursor(waitCursor);
eigenschaftenEditor.speichereEigenschaften();
Simulation sim = holoEditor.getSimulation();
final InterferenzMuster muster = new
InterferenzMuster(sim.getObjekt(), sim.zufallsPhasen, sim.lambda,
sim.breiteInPixel, sim.hoeheInPixel, sim.musterBreite,
sim.musterHoehe);
muster.addFortschrittListener(new
BerechnungsFortschrittListener()
{
public void berechnungsFortschritt(int aktuelleSpalte,
int gesamtSpalten)
{
if (aktuelleSpalte ==
BerechnungsFortschrittListener.BERECHNUNG_BEENDET)
{
54

display.asyncExec(new Runnable()
{
public void run()
{
Photo photo = new Photo(muster);
ErgebnisDialog ed = new
ErgebnisDialog(shell, photo);
ed.open();
tiBerechnen.setEnabled(true);
shell.setCursor(null);
waitCursor.dispose();
shell.setText("CGH");
}
} );
}
else
{
final String titel = "CGH - " +
NumberFormat.getPercentInstance().format((float)aktuelleSpalte /
(float)gesamtSpalten);
if (! display.isDisposed())
{
display.asyncExec(new Runnable()
{
public void run()
{
if (! shell.isDisposed())
shell.setText(titel);
}
} );
}
}
}
} );
muster.start();
}
} );
tiInfo.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
SWTUtils.messageBox(shell, SWT.ICON_INFORMATION | SWT.OK,
"Über das Programm...",
"CGH - Copyright © 2004-2005 Michael Partheil,
michael.partheil@gmx.de\n\n"+
"CGH ist ein Programm, welches Hologramme von
Punktmustern\n"+
"am Computer berechnet und anzeigt. Diese können dann
vom Bildschirm\n"+
"abphotografiert werden oder mit Hilfe von Plottern in
ein \"echtes\" Hologramm\n"+
"umgewandelt werden.\n"+
"Das Programm wurde im Rahmen einer Facharbeit im Fach
Physik am Städtischen\n"+
"Gymnasium Bad Laasphe entwickelt.");
}
} );
tiBeenden.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
shell.close();
}
55

}
} );
private void macheGui()
{
helpViewer = new HelpViewer(shell);
macheToolBar();
holoEditorScroller = new ScrolledComposite(shell, SWT.H_SCROLL |
SWT.V_SCROLL | SWT.BORDER);
holoEditorScroller.setAlwaysShowScrollBars(true);
holoEditor = new HologrammEditor(holoEditorScroller, new
Simulation(), helpViewer);
holoEditorScroller.setContent(holoEditor);
eigenschaftenEditor = new EigenschaftenEditorControl(shell,
holoEditor, helpViewer);
holoEditor.setAuswahl(holoEditor.getSimulation());
holoEditor.setLocation(0, 0);
holoEditor.setSize(holoEditor.computeSize(SWT.DEFAULT,
SWT.DEFAULT));
}
shell.setLayout(new FormLayout());
FormData fd;
fd = new FormData();
fd.left = new FormAttachment(0);
fd.right = new FormAttachment(100);
fd.top = new FormAttachment(0);
toolBar.setLayoutData(fd);
fd = new FormData();
fd.left = new FormAttachment(0);
fd.top = new FormAttachment(toolBar);
fd.bottom = new FormAttachment(100);
fd.right = new FormAttachment(eigenschaftenEditor);
holoEditorScroller.setLayoutData(fd);
fd = new FormData();
fd.top = new FormAttachment(toolBar);
fd.right = new FormAttachment(100);
//fd.bottom = new FormAttachment(100);
eigenschaftenEditor.setLayoutData(fd);
fd = new FormData();
fd.top = new FormAttachment(eigenschaftenEditor, 5);
fd.left = new FormAttachment(holoEditorScroller, 5);
fd.right = new FormAttachment(100, -5);
fd.bottom = new FormAttachment(100, -5);
helpViewer.setLayoutData(fd);
private void macheToolBar()
{
final String HELP_PROPERTY = "dynamicHelpText";
imgNeu = new Image(display,
getClass().getResourceAsStream("filenew.gif"));
imgOeffnen = new Image(display,
getClass().getResourceAsStream("open.gif"));
imgSpeichern = new Image(display,
getClass().getResourceAsStream("save_edit.gif"));
56

imgPunktHinzufuegen = new Image(display,
getClass().getResourceAsStream("add.gif"));
imgTextHinzufuegen = new Image(display,
getClass().getResourceAsStream("buchstaben.gif"));
imgPunktLoeschen = new Image(display,
getClass().getResourceAsStream("delete_edit.gif"));
imgBerechnen = new Image(display,
getClass().getResourceAsStream("berechnen.gif"));
imgBerechnenDisabled = new Image(display,
getClass().getResourceAsStream("berechnen_disabled.gif"));
imgInfo = new Image(display,
getClass().getResourceAsStream("info.gif"));
imgBeenden = new Image(display,
getClass().getResourceAsStream("exit.gif"));
toolBar = new ToolBar(shell, SWT.HORIZONTAL | SWT.FLAT |
SWT.WRAP);
tiNeu = new ToolItem(toolBar, SWT.PUSH);
tiNeu.setText("&Neu");
tiNeu.setImage(imgNeu);
tiNeu.setData(HELP_PROPERTY, "Setzt die Simulation auf
Standardwerte zurück. "+
"Achtung: Die aktuelle Simulation ist dann \"verloren\"!");
tiOeffnen = new ToolItem(toolBar, SWT.PUSH);
tiOeffnen.setText("Ö&ffnen");
tiOeffnen.setImage(imgOeffnen);
tiOeffnen.setData(HELP_PROPERTY, "Öffnet eine in Datei
gespeicherte Simulation oder ein bereits berechnetes "+
"Intereferenzmuster. Die Simulation kann dann bearbeitet und
berechnet werden. Änderungen haben auf die "+
"gespeicherte Simulation keinen Einfluss.");
tiSpeichern = new ToolItem(toolBar, SWT.PUSH);
tiSpeichern.setText("&Speichern");
tiSpeichern.setImage(imgSpeichern);
tiSpeichern.setData(HELP_PROPERTY, "Speichert die aktuelle
Simulation in eine Datei. "+
"Diese kann dann später wieder geöffnet und verändert
werden.");
new ToolItem(toolBar, SWT.SEPARATOR);
tiPunktHinzufuegen = new ToolItem(toolBar, SWT.PUSH);
tiPunktHinzufuegen.setText("Punkt &Hinzufügen");
tiPunktHinzufuegen.setImage(imgPunktHinzufuegen);
tiPunktHinzufuegen.setData(HELP_PROPERTY, "Um der Simulation einen
Objektpunkt hinzuzufügen, "+
"klicken Sie auf diesen Knopf und dann in den Hologramm-Editor.
An der Stelle, wo Sie "+
"die Mause wieder loslassen, wird ein neuer Punkt erzeugt.");
tiTextHinzufuegen = new ToolItem(toolBar, SWT.PUSH);
tiTextHinzufuegen.setText("&Text Hinzufügen");
tiTextHinzufuegen.setImage(imgTextHinzufuegen);
tiTextHinzufuegen.setData(HELP_PROPERTY, "Öffnet einen Dialog, in
dem Sie einen Text eingeben können. "+
"Klicken Sie dann in den Hologramm-Editor. An der Stelle, wo
Sie die Maus loslassen, wird der "+
"Text als Punktmuster eingefügt.");
tiPunktLoeschen = new ToolItem(toolBar, SWT.PUSH);
57

tiPunktLoeschen.setText("Punkt &Löschen");
tiPunktLoeschen.setImage(imgPunktLoeschen);
tiPunktLoeschen.setData(HELP_PROPERTY, "Entfernt den im Hologramm-
Editor ausgewählten Objektpunkt "+
"aus der Simulation. Ist kein Punkt ausgewählt, passiert
nichts.");
new ToolItem(toolBar, SWT.SEPARATOR);
tiBerechnen = new ToolItem(toolBar, SWT.PUSH);
tiBerechnen.setText("&Berechnen");
tiBerechnen.setImage(imgBerechnen);
tiBerechnen.setDisabledImage(imgBerechnenDisabled);
tiBerechnen.setData(HELP_PROPERTY, "Berechnet das Interferenz-
Muster des Hologrammes. "+
"Das Muster wird in einem neuen Fenster angezeigt. Die
Berechnung kann einige Zeit dauern!");
new ToolItem(toolBar, SWT.SEPARATOR);
tiInfo = new ToolItem(toolBar, SWT.PUSH);
tiInfo.setText("Inf&o");
tiInfo.setImage(imgInfo);
tiInfo.setData(HELP_PROPERTY, "Zeigt Informationen zum Programm
(Autor, etc.) an.");
new ToolItem(toolBar, SWT.SEPARATOR);
tiBeenden = new ToolItem(toolBar, SWT.PUSH);
tiBeenden.setText("B&eenden");
tiBeenden.setImage(imgBeenden);
tiBeenden.setData(HELP_PROPERTY, "Beendet das Programm. Die
Simulation wird nicht gespeichert, "+
"wollen Sie sie später weiter bearbeiten, müssen Sie sie vorm
Beenden abspeichern.");
toolBar.addMouseMoveListener(new MouseMoveListener()
{
public void mouseMove(MouseEvent evt)
{
ToolItem item = toolBar.getItem(new Point(evt.x, evt.y));
String help = null;
if ((item != null) && ((help =
(String)item.getData(HELP_PROPERTY)) != null))
helpViewer.setHilfe(help);
else
helpViewer.setHilfe(null);
}
} );
toolBar.addMouseTrackListener(new MouseTrackAdapter()
{
public void mouseExit(MouseEvent evt)
{
helpViewer.setHilfe(null);
}
} );
}
private String exceptionToString(Exception e)
{
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
58

}
e.printStackTrace(pw);
pw.close();
return sw.toString();
/** Die Event-Loop des Programmes */
public void waitForClose()
{
while (! shell.isDisposed())
{
try
{
if (! display.readAndDispatch())
display.sleep();
}
catch (Exception e)
{
e.printStackTrace();
SWTUtils.messageBox(shell, SWT.ICON_ERROR | SWT.OK,
"Unerwarteter Fehler", exceptionToString(e));
}
}
}
}
NullEditor.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import org.eclipse.swt.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
/** Dieser Editor wird im EigenschaftenEditorControl angezeigt, wenn
für die
Klasser der Auswahl kein anderer Editor verfügbar ist. Dieser Editor
zeigt einfach nur einen Hinweistext an */
public class NullEditor extends ObjektEditor
{
public NullEditor(Composite parent)
{
super(parent, null);
setLayout(new FillLayout());
new Label(this, SWT.CENTER).setText("Keine Eigenschaften
verfügbar");
}
public void editiereObjekt(Object obj)
{
}
public void speichereEigenschaften()
{
}
59

}
public Class getEditorFuer()
{
return null;
}
ObjektEditor.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import org.eclipse.swt.*;
import org.eclipse.swt.widgets.*;
/** Allgemeine Oberklasse für alle Objekte, die eine Auswahl editieren
können,
z.B. SimulationEditor oder ObjektPUnktEditor. Subklassen werden im
EigenschaftenEditorControl angezeigt */
public abstract class ObjektEditor extends Composite
{
protected HologrammEditor editorFuer;
}
public ObjektEditor(Composite parent, HologrammEditor editorFuer)
{
super(parent, SWT.NONE);
this.editorFuer = editorFuer;
}
/** Startet die editierung des Objektes obj */
public abstract void editiereObjekt(Object obj);
/** Speichert die editierten Eigenschaften im Objekt */
public abstract void speichereEigenschaften();
/** Welche Objekte kann dieser ObjektEditor bearbeiten? */
public abstract Class getEditorFuer();
/** Kann dieser ObjektEditor das Objekt obj bearbeiten?
(basiert auf getEditorFuer()) */
public boolean isEditorFuer(Object obj)
{
if (obj == null)
return false;
return getEditorFuer().equals(obj.getClass());
}
ObjektPunkt.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
/** Diese Klasse modelliert einen Punkt des zu holographierenden
Objektes */
public class ObjektPunkt implements java.io.Serializable
{
private static final long serialVersionUID = 1;
/** Die X-Koordinate des Objektpunktes in cm */
60

public float x;
/** Die Y-Koordinate des Objektpunktes in cm */
public float y;
/** Die Z-Koordinate (Tiefe) des Objektpunktes in cm */
public float z;
/** Die Amplitude (maximale Auslenkung) des von dem Objektpunktes
ausgehenden Strahles */
public float amplitude;
/** zufallsPhase wird zu jedem ausgehenden Strahl hinzuaddiert, um
eine Oberflächenrauhigkeit zu simulieren, die den Kontrast erhöht.
Der Wert ist: 0

private NumberFormat floatFormatter;
public ObjektPunktEditor(Composite parent, HologrammEditor
editorFuer, HelpViewer helpViewer)
{
super(parent, editorFuer);
floatFormatter = NumberFormat.getInstance();
floatFormatter.setMinimumFractionDigits(1);
floatFormatter.setMaximumFractionDigits(2);
macheGui();
SelectionListener sl = new SelectionAdapter()
{
public void widgetDefaultSelected(SelectionEvent evt)
{
speichereEigenschaften();
}
};
txtX.addSelectionListener(sl);
txtY.addSelectionListener(sl);
txtZ.addSelectionListener(sl);
txtAmplitude.addSelectionListener(sl);
editorFuer.addObjektPunktPosListener(this);
txtX.addMouseTrackListener(new DynamicHelpListener(helpViewer,
"Die X-Koordinate des ausgewählten Punktes "+
"in Zentimetern."));
txtY.addMouseTrackListener(new DynamicHelpListener(helpViewer,
"Die Y-Koordinate des ausgewählten Punktes "+
"in Zentimetern."));
txtZ.addMouseTrackListener(new DynamicHelpListener(helpViewer,
"Die Z-Koordinate (Entfernung von der "+
"Hologrammebene) in Zentimetern. Sollte zwischen 30 und 40 cm
sein."));
txtAmplitude.addMouseTrackListener(new
DynamicHelpListener(helpViewer, "Die Amplitude (maximale Auslenkung)
"+
"des Lichtstrahles, der von dem ausgewählten Punkt ausgeht.
Wichtig ist nicht der absolute Wert, "+
"sondern das Verhältnis zu den Amplituden der anderen
Punkten."));
}
public void punktPosGeaendert(Object sender, ObjektPunkt punkt)
{
if (this.punkt == punkt)
{
txtX.setText(floatFormatter.format(punkt.x));
txtY.setText(floatFormatter.format(punkt.y));
}
}
private void macheGui()
{
GridLayout layout = new GridLayout(2, false);
layout.marginWidth = 5;
layout.marginHeight = 5;
layout.verticalSpacing = 5;
layout.horizontalSpacing = 5;
setLayout(layout);
62

}
GridData gd;
Label lblDesc;
lblDesc = new Label(this, SWT.NONE);
lblDesc.setText("X-Koordinate [cm]:");
gd = new GridData();
gd.horizontalAlignment = SWT.END;
lblDesc.setLayoutData(gd);
txtX = new Text(this, SWT.BORDER | SWT.SINGLE);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
txtX.setLayoutData(gd);
lblDesc = new Label(this, SWT.NONE);
lblDesc.setText("Y-Koordinate [cm]:");
gd = new GridData();
gd.horizontalAlignment = SWT.END;
lblDesc.setLayoutData(gd);
txtY = new Text(this, SWT.BORDER | SWT.SINGLE);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
txtY.setLayoutData(gd);
lblDesc = new Label(this, SWT.NONE);
lblDesc.setText("Z-Koordinate (Tiefe) [cm]:");
gd = new GridData();
gd.horizontalAlignment = SWT.END;
lblDesc.setLayoutData(gd);
txtZ = new Text(this, SWT.BORDER | SWT.SINGLE);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
txtZ.setLayoutData(gd);
lblDesc = new Label(this, SWT.NONE);
lblDesc.setText("Amplitude:");
gd = new GridData();
gd.horizontalAlignment = SWT.END;
lblDesc.setLayoutData(gd);
txtAmplitude = new Text(this, SWT.BORDER | SWT.SINGLE);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
txtAmplitude.setLayoutData(gd);
public void editiereObjekt(Object obj)
{
if (! (obj instanceof ObjektPunkt))
throw new IllegalArgumentException("obj ist nicht vom Typ
ObjektPunkt");
if (obj == null)
throw new IllegalArgumentException("obj darf nicht null sein");
punkt = (ObjektPunkt)obj;
updateGui();
63

}
private void updateGui()
{
txtX.setText(floatFormatter.format(punkt.x));
txtY.setText(floatFormatter.format(punkt.y));
txtZ.setText(floatFormatter.format(punkt.z));
txtAmplitude.setText(floatFormatter.format(punkt.amplitude));
}
public void speichereEigenschaften()
{
if (punkt != null)
{
try
{
punkt.x =
floatFormatter.parse(txtX.getText().trim()).floatValue();
}
catch (ParseException e)
{
SWTUtils.messageBox(getShell(), SWT.ICON_WARNING | SWT.OK,
"Fehler", "X-Koordinate ist ungültig: " + e);
}
try
{
punkt.y =
floatFormatter.parse(txtY.getText().trim()).floatValue();
}
catch (ParseException e)
{
SWTUtils.messageBox(getShell(), SWT.ICON_WARNING | SWT.OK,
"Fehler", "Y-Koordinate ist ungültig: " + e);
}
try
{
punkt.z =
floatFormatter.parse(txtZ.getText().trim()).floatValue();
}
catch (ParseException e)
{
SWTUtils.messageBox(getShell(), SWT.ICON_WARNING | SWT.OK,
"Fehler", "Z-Koordinate ist ungültig: " + e);
}
try
{
punkt.amplitude =
floatFormatter.parse(txtAmplitude.getText().trim()).floatValue();
}
catch (ParseException e)
{
SWTUtils.messageBox(getShell(), SWT.ICON_WARNING | SWT.OK,
"Fehler", "Amplitude ist ungültig: " + e);
}
}
}
updateGui();
editorFuer.redraw();
public Class getEditorFuer()
{
64

}
}
return ObjektPunkt.class;
ObjektPunktPosListener.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import java.util.*;
/** Dieses interface wird implementiert, um Benachrichtigung darüber
zu
bekommen, wenn sich die Position eines ObjektPUnkts geändert hat */
public interface ObjektPunktPosListener extends EventListener
{
public void punktPosGeaendert(Object sender, ObjektPunkt punkt);
}
Photo.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import org.eclipse.swt.graphics.*;
/* Beschreibt die Hell-Dunkel-Verteilung, die auf einer Photoplatte
entstehen würde */
public class Photo
{
private double[][] muster;
private InterferenzMuster im;
private ImageData id;
private double durchschnittsPixel;
/** Leerer Konstruktor */
protected Photo()
{
}
/** Erstellt eine neue Photoplatte aus dem gegebenen (berechneten)
Interferenzmuster */
public Photo(InterferenzMuster im)
{
this.im = im;
muster = im.getMuster();
}
// Palette mit 256 Graustufen erzeugen
RGB[] rgbs = new RGB[256];
for (int i=0; i

** Gibt den Inhalt der Photoplatte als Bild zurück, das dann
dargestellt
werden kann */
public ImageData getImageData()
{
return id;
}
/** Gibt den Durchschnittswert aller Pixel zurück */
public double getDurchschnittsPixel()
{
return durchschnittsPixel;
}
/** Berechnung erfolgt dardurch, dass die summierten Elongationen
aus dem
InterferenzMuster (die auch negativ sein können!)umgerechnet
werden in
Werte zwischen 0 und 255, die dann den Helligkeitswert ergeben. */
private void berechnePhoto()
{
double streckFaktor = 255 / (im.getMaxAmplitude() -
im.getMinAmplitude());
durchschnittsPixel = 0;
for (int x=0; x

public int anzeigeSkalierung;
private List objekt;
public Simulation(boolean zufallsPhasen, double lambda, int
breiteInPixel, int hoeheInPixel,
float musterBreite, float musterHoehe, int anzeigeSkalierung)
{
this.zufallsPhasen = zufallsPhasen;
this.lambda = lambda;
this.breiteInPixel = breiteInPixel;
this.hoeheInPixel = hoeheInPixel;
this.musterBreite = musterBreite;
this.musterHoehe = musterHoehe;
}
}
this.anzeigeSkalierung = anzeigeSkalierung;
objekt = new ArrayList();
/** this(true, 633e-7, 640, 480, 1.0f, 0.75f, 6) */
public Simulation()
{
this(true, 633e-7, 640, 480, 1.0f, 0.75f, 6);
}
/** Einen punkt zur Simulation hinzufügen */
public void punktHinzufuegen(ObjektPunkt punkt)
{
objekt.add(punkt);
}
/** Einen ObjektPunkt wieder aus der Simulation entfernen */
public boolean punktLoeschen(ObjektPunkt punkt)
{
return objekt.remove(punkt);
}
/** Iterator über alle ObjektPunkte */
public Iterator objektIterator()
{
return objekt.iterator();
}
/** Alle ObjektPUnkte im Array zurückgeben */
public ObjektPunkt[] getObjekt()
{
return (ObjektPunkt[])objekt.toArray(new ObjektPunkt[0]);
}
SimulationEditor.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import org.eclipse.swt.*;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
67

import java.text.*;
/** Editor, wenn die Auswahl vom Typ Simulation ist */
public class SimulationEditor extends ObjektEditor
{
private Simulation simulation = null;
private Button cbZufallsPhasen;
private Text txtLambda;
private Text txtBreiteInPixel;
private Text txtHoeheInPixel;
private Text txtMusterBreite;
private Text txtMusterHoehe;
private Combo comboSkalierung;
private NumberFormat floatFormatter;
public SimulationEditor(Composite parent, HologrammEditor
editorFuer, HelpViewer helpViewer)
{
super(parent, editorFuer);
floatFormatter = NumberFormat.getInstance();
floatFormatter.setMinimumFractionDigits(1);
floatFormatter.setMaximumFractionDigits(2);
macheGui();
SelectionListener sl = new SelectionListener()
{
public void widgetSelected(SelectionEvent evt)
{
speichereEigenschaften();
}
public void widgetDefaultSelected(SelectionEvent evt)
{
speichereEigenschaften();
}
};
cbZufallsPhasen.addSelectionListener(sl);
txtLambda.addSelectionListener(sl);
txtBreiteInPixel.addSelectionListener(sl);
txtHoeheInPixel.addSelectionListener(sl);
txtMusterBreite.addSelectionListener(sl);
txtMusterHoehe.addSelectionListener(sl);
comboSkalierung.addSelectionListener(sl);
cbZufallsPhasen.addMouseTrackListener(new
DynamicHelpListener(helpViewer, "Bestimmt, ob zu den "+
"Auslenkungen der Lichtstrahlen auf der Hologrammebene ein
konstanter, aber für jeden Punkt "+
"anderer Phasenwert dazuaddiert werden soll. Dies erhöht den
Kontrast des "+
"Interferenzmusters."));
txtLambda.addMouseTrackListener(new
DynamicHelpListener(helpViewer, "Die Wellenlänge des virtuellen
Lasers, "+
"der zum Berechnen verwendet wird in Metern. Die Wellenlänge
muss auch der entsprechen, die bei der "+
"Rekonstruktion verwendet werden soll. Als Komma muss ein Punkt
verwendet werden."));
txtBreiteInPixel.addMouseTrackListener(new
68

DynamicHelpListener(helpViewer, "Die Breite des berechneten "+
"Interferenzmusters in Pixeln. Sollte der Breite des
Bildschirmes entsprechen, allerdings: "+
"je größer dieser Wert, desto länger dauert die Berechnung!"));
txtHoeheInPixel.addMouseTrackListener(new
DynamicHelpListener(helpViewer, "Die Höhe des berechneten "+
"Interferenzmusters in Pixeln. Sollte der Höhe des Bildschirmes
entsprechen, allerdings: "+
"je größer dieser Wert, desto länger dauert die Berechnung!"));
txtMusterBreite.addMouseTrackListener(new
DynamicHelpListener(helpViewer, "Die Breite, die das Hologramm "+
"nach dem Abphotographieren und Verkleinern haben soll in
Zentimetern."));
txtMusterHoehe.addMouseTrackListener(new
DynamicHelpListener(helpViewer, "Die Höhe, die das Hologramm "+
"nach dem Abphotographieren und Verkleinern haben soll in
Zentimetern."));
comboSkalierung.addMouseTrackListener(new
DynamicHelpListener(helpViewer, "Wieviel soll der Hologramm-Editor "+
"das Hologramm gegenüber der Originalgröße (Musterbreite x
Musterhöhe) vergrößern. Auf die Berechnung "+
"hat dies keinen Einfluss."));
}
private void macheGui()
{
GridLayout layout = new GridLayout(2, false);
layout.marginWidth = 5;
layout.marginHeight = 5;
layout.verticalSpacing = 5;
layout.horizontalSpacing = 5;
setLayout(layout);
GridData gd;
Label lblDesc;
cbZufallsPhasen = new Button(this, SWT.CHECK);
cbZufallsPhasen.setText("Zufallsphasen");
gd = new GridData();
gd.horizontalSpan = 2;
cbZufallsPhasen.setLayoutData(gd);
lblDesc = new Label(this, SWT.NONE);
lblDesc.setText("Wellenlänge [m]:");
gd = new GridData();
gd.horizontalAlignment = SWT.END;
lblDesc.setLayoutData(gd);
txtLambda = new Text(this, SWT.BORDER | SWT.SINGLE);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
txtLambda.setLayoutData(gd);
lblDesc = new Label(this, SWT.NONE);
lblDesc.setText("Breite in Pixeln:");
gd = new GridData();
gd.horizontalAlignment = SWT.END;
lblDesc.setLayoutData(gd);
txtBreiteInPixel = new Text(this, SWT.BORDER | SWT.SINGLE);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
69

gd.grabExcessHorizontalSpace = true;
txtBreiteInPixel.setLayoutData(gd);
lblDesc = new Label(this, SWT.NONE);
lblDesc.setText("Höhe in Pixeln:");
gd = new GridData();
gd.horizontalAlignment = SWT.END;
lblDesc.setLayoutData(gd);
txtHoeheInPixel = new Text(this, SWT.BORDER | SWT.SINGLE);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
txtHoeheInPixel.setLayoutData(gd);
lblDesc = new Label(this, SWT.NONE);
lblDesc.setText("Musterbreite [cm]:");
gd = new GridData();
gd.horizontalAlignment = SWT.END;
lblDesc.setLayoutData(gd);
txtMusterBreite = new Text(this, SWT.BORDER | SWT.SINGLE);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
txtMusterBreite.setLayoutData(gd);
lblDesc = new Label(this, SWT.NONE);
lblDesc.setText("Musterhöhe [cm]:");
gd = new GridData();
gd.horizontalAlignment = SWT.END;
lblDesc.setLayoutData(gd);
txtMusterHoehe = new Text(this, SWT.BORDER | SWT.SINGLE);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
txtMusterHoehe.setLayoutData(gd);
lblDesc = new Label(this, SWT.NONE);
lblDesc.setText("Editor Vergrößerung:");
gd = new GridData();
gd.horizontalAlignment = SWT.END;
lblDesc.setLayoutData(gd);
comboSkalierung = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY);
comboSkalierung.setItems(new String[]{ "2-fach", "4-fach", "6fach",
"8-fach", "10-fach" });
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
comboSkalierung.setLayoutData(gd);
}
public void editiereObjekt(Object obj)
{
if (! (obj instanceof Simulation))
throw new IllegalArgumentException("obj ist nicht vom Typ
Simulation");
if (obj == null)
throw new IllegalArgumentException("obj darf nicht null sein");
simulation = (Simulation)obj;
70

}
updateGui();
private void updateGui()
{
cbZufallsPhasen.setSelection(simulation.zufallsPhasen);
txtLambda.setText(""+(simulation.lambda/100));
txtBreiteInPixel.setText(""+simulation.breiteInPixel);
txtHoeheInPixel.setText(""+simulation.hoeheInPixel);
txtMusterBreite.setText(floatFormatter.format(simulation.musterBreit
e));
txtMusterHoehe.setText(floatFormatter.format(simulation.musterHoehe)
);
comboSkalierung.select((simulation.anzeigeSkalierung / 2)-1);
}
public void speichereEigenschaften()
{
if (simulation != null)
{
simulation.zufallsPhasen = cbZufallsPhasen.getSelection();
try
{
simulation.lambda =
Double.parseDouble(txtLambda.getText().trim())*100;
}
catch (NumberFormatException e)
{
SWTUtils.messageBox(getShell(), SWT.ICON_WARNING | SWT.OK,
"Fehler", "Wellenlänge ist ungültig: " + e);
}
try
{
simulation.breiteInPixel =
Integer.parseInt(txtBreiteInPixel.getText().trim());
}
catch (NumberFormatException e)
{
SWTUtils.messageBox(getShell(), SWT.ICON_WARNING | SWT.OK,
"Fehler", "Breite in Pixeln ist ungültig: " + e);
}
try
{
simulation.hoeheInPixel =
Integer.parseInt(txtHoeheInPixel.getText().trim());
}
catch (NumberFormatException e)
{
SWTUtils.messageBox(getShell(), SWT.ICON_WARNING | SWT.OK,
"Fehler", "Höhe in Pixeln ist ungültig: " + e);
}
try
{
simulation.musterBreite =
floatFormatter.parse(txtMusterBreite.getText().trim()).floatValue();
}
catch (ParseException e)
{
SWTUtils.messageBox(getShell(), SWT.ICON_WARNING | SWT.OK,
"Fehler", "Musterbreite ist ungültig: " + e);
}
71

try
{
simulation.musterHoehe =
floatFormatter.parse(txtMusterHoehe.getText().trim()).floatValue();
}
catch (ParseException e)
{
SWTUtils.messageBox(getShell(), SWT.ICON_WARNING | SWT.OK,
"Fehler", "Musterhöhe ist ungültig: " + e);
}
simulation.anzeigeSkalierung =
(comboSkalierung.getSelectionIndex()+1)*2;
}
}
}
updateGui();
editorFuer.redraw();
public Class getEditorFuer()
{
return Simulation.class;
}
SWTUtils.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;
public class SWTUtils
{
/** Zeigt eine MessageBox an */
public static int messageBox(Shell parent, int style, String title,
String message)
{
MessageBox msgBox = new MessageBox(parent, style);
msgBox.setMessage(message);
msgBox.setText(title);
return msgBox.open();
}
/** Zentriert shell auf centerOn. Wenn centerOn null ist, wird shell
auf dem Bildschirm zentriert */
public static void centerShell(Shell shell, Shell centerOn)
{
Rectangle rect = (centerOn == null ?
shell.getDisplay().getBounds() : centerOn.getBounds());
shell.setLocation((rect.width-shell.getBounds().width)/2+rect.x,
(rect.height-shell.getBounds().height)/2+rect.y);
}
}
TextInputDialog.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
72

michael.partheil@gmx.de
import org.eclipse.swt.*;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
import java.text.*;
/** Dieser Dialog wird angezeigt, wenn der Button "Text hinzufügen"
gewählt
wurde */
public class TextInputDialog extends Dialog
{
private TextPseudoObjekt result = null;
private Display display;
private Shell shell;
private Label lblMessage;
private Text txtEingabe;
private Button btnOk;
private Button btnAbbrechen;
private Label lblStartZ;
private Text txtStartZ;
private Label lblOffsetZ;
private Text txtOffsetZ;
private NumberFormat floatFormatter;
public TextInputDialog(Shell parent)
{
super(parent, SWT.NONE);
}
floatFormatter = NumberFormat.getInstance();
floatFormatter.setMinimumFractionDigits(1);
floatFormatter.setMaximumFractionDigits(2);
public TextPseudoObjekt open()
{
display = CGHMain.display;
shell = new Shell(getParent(), SWT.DIALOG_TRIM |
SWT.APPLICATION_MODAL);
shell.setText("Text Hinzufügen");
result = null;
macheGui();
btnOk.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
result = new TextPseudoObjekt(txtEingabe.getText(), 30f,
0.2f);
try
{
result.startZ =
floatFormatter.parse(txtStartZ.getText().trim()).floatValue();
}
catch (ParseException e)
{
SWTUtils.messageBox(shell, SWT.ICON_WARNING | SWT.OK,
73

"Fehler", "Starttiefe ist ungültig, verwende Standardwert 30.0: " +
e);
}
try
{
result.offsetZ =
floatFormatter.parse(txtOffsetZ.getText().trim()).floatValue();
}
catch (ParseException e)
{
SWTUtils.messageBox(shell, SWT.ICON_WARNING | SWT.OK,
"Fehler", "Tiefenoffset ist ungültig, verwende Standardwert 0.2: " +
e);
}
shell.close();
}
} );
btnAbbrechen.addSelectionListener(new SelectionAdapter()
{
public void widgetSelected(SelectionEvent evt)
{
shell.close();
}
} );
txtEingabe.addVerifyListener(new VerifyListener()
{
public void verifyText(VerifyEvent evt)
{
String text = evt.text;
StringBuffer ok = new StringBuffer();
}
}
} );
for (int i=0; i= 'A' && c = 'a' && c

txtEingabe = new Text(shell, SWT.BORDER | SWT.SINGLE);
txtEingabe.setText("");
/* Code für Positions-Group */
Group posGroup = new Group(shell, SWT.NONE);
posGroup.setText("Z-Koordinate (Tiefe)");
lblStartZ = new Label(posGroup, SWT.NONE);
lblStartZ.setText("Position des ersten Buchstabens:");
txtStartZ = new Text(posGroup, SWT.BORDER | SWT.SINGLE);
txtStartZ.setText(floatFormatter.format(30.0f));
lblOffsetZ = new Label(posGroup, SWT.NONE);
lblOffsetZ.setText("Offset für nachfolgende Buchstaben:");
txtOffsetZ = new Text(posGroup, SWT.BORDER | SWT.SINGLE);
txtOffsetZ.setText(floatFormatter.format(0.2f));
posGroup.setLayout(new GridLayout(2, false));
GridData gd;
gd = new GridData();
gd.horizontalAlignment = SWT.END;
lblStartZ.setLayoutData(gd);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
txtStartZ.setLayoutData(gd);
gd = new GridData();
gd.horizontalAlignment = SWT.END;
lblOffsetZ.setLayoutData(gd);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
txtOffsetZ.setLayoutData(gd);
/* Code für Knopf-Leiste: */
Composite buttonBar = new Composite(shell, SWT.NONE);
btnOk = new Button(buttonBar, SWT.PUSH);
btnOk.setText("&OK");
btnAbbrechen = new Button(buttonBar, SWT.PUSH);
btnAbbrechen.setText("&Abbrechen");
shell.setDefaultButton(btnOk);
RowLayout rl = new RowLayout();
rl.marginHeight = 0;
rl.marginWidth = 0;
rl.spacing = 5;
buttonBar.setLayout(rl);
// Layout für Shell:
shell.setLayout(new GridLayout(1, false));
//GridData gd;
gd = new GridData();
75

}
}
gd.horizontalAlignment = SWT.FILL;
gd.verticalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
lblMessage.setLayoutData(gd);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
txtEingabe.setLayoutData(gd);
gd = new GridData();
gd.horizontalAlignment = SWT.FILL;
gd.grabExcessHorizontalSpace = true;
posGroup.setLayoutData(gd);
gd = new GridData();
gd.horizontalAlignment = SWT.END;
buttonBar.setLayoutData(gd);
TextPseudoObjekt.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
/** Diese Klasse stellt einen Text dar, der eingefügt werden soll.
Es ist deshalb nur ein PseudoObjekt, da es nicht in die Simulation
eingefügt wird, sondern in mehrere ObjektPUnkte umgerechnet wird und
diese
dann eingefügt werden */
public class TextPseudoObjekt
{
public String text;
public float startZ;
public float offsetZ;
}
public TextPseudoObjekt(String text, float startZ, float offsetZ)
{
this.text = text;
this.startZ = startZ;
this.offsetZ = offsetZ;
}
VollBildDialog.java
// CGH - Copyright (C) 2004-2005 Michael Partheil,
michael.partheil@gmx.de
import org.eclipse.swt.*;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;
/** Zeigt ein Hologramm Vollbild an, zum abphotographieren */
public class VollBildDialog extends Dialog
{
private Image img;
76

private boolean zeigeHinweis = true;
public VollBildDialog(Shell parent, Image imgHolo)
{
super(parent, SWT.NONE);
img = imgHolo;
}
// Achtung: Der zurückgegebene Cursor muss "eigenverantwortlich"
disposed werden!!!!
// (kein reference-counting etc)
private static Cursor macheLeerenCursor()
{
PaletteData paletteData = new PaletteData(new RGB[] { new
RGB(0,0,0) , new RGB(255,255,255) });
ImageData sourceData = new ImageData(32,32,1,paletteData);
ImageData maskData = new ImageData(32,32,1,paletteData);
}
int[] cursorSource = new int[32*32];
for (int i=0; i

}
}
shell.addKeyListener(new KeyAdapter()
{
public void keyPressed(KeyEvent evt)
{
shell.close();
}
} );
display.timerExec(3000, new Runnable()
{
public void run()
{
if (! shell.isDisposed())
{
zeigeHinweis = false;
shell.redraw();
}
}
} );
shell.setBounds(display.getBounds());
shell.open();
while (! shell.isDisposed())
{
if (! display.readAndDispatch())
display.sleep();
}
leerCursor.dispose();
78