Sie sind auf Seite 1von 65

Ingenieurmathematik 1

INGENIEURMATHEMATIK 4. Kurseinheit
Autor: Prof. Dr. Edgar Jäger

Interpolation
und Approximation

Die vorliegende Kurseinheit beschäftigt sich mit verschiedenen Inter-


polations- und Approximationstechniken. Zur Demonstration der
verschiedenen Interpolationstechniken werden grafische Benutzer-
oberflächen (GUI) in MATLAB erstellt.
Ingenieurmathematik 2

EINFÜHRUNG

In dieser Kurseinheit lernen Sie verschiedene Methoden zur Interpolation and Appro-
ximation kennen. Gegenstand der Interpolation sind Funktion, Kurven in Ebene und
Raum und Flächen.
Lernziel

Für die Bearbeitung dieses Studienbriefs sollten Sie etwa 20 Stunden einplanen.

Lernzeit

Ingenieurmathematik 3

INHALT

1 Einleitung.................................................................................................................... 4

2 Lineare Interpolation................................................................................................. 6
2.1 Polynominterpolation ............................................................................................ 7
2.1.1 Berechnung des Interpolationspolynoms...................................................... 8

3 Spline-Interpolation ................................................................................................. 17
3.1 Minimaleigenschaft von Splines ......................................................................... 19
3.2 Anwendungen von Splines .................................................................................. 19
3.3 Trigonometrische Interpolation ........................................................................... 20
3.3.1 Reelle Trigonometrische Interpolation....................................................... 20
3.3.2 Komplexe Trigonometrische Interpolation ................................................ 27
3.3.3 Anwendung: Datenglättung........................................................................ 30
3.4 Bernstein-Polynome, Bézier-Darstellung von Polynomen .................................. 35
3.4.1 Bézier-Darstellung ..................................................................................... 37
3.5 Kurven................................................................................................................. 37
3.5.1 Parameterdarstellung einer Kurve .............................................................. 38
3.5.2 Parametrische kubische Splines ................................................................. 40
3.5.3 Bézier-Darstellung einer Kurve.................................................................. 42
3.6 Zweidimensionale Interpolation und Approximation.......................................... 52
3.6.1 Zweidimensionale lineare Interpolation ..................................................... 52
3.6.2 Bilineare Interpolation................................................................................ 53
3.6.3 Zweidimensionale Bikubische Splines....................................................... 54
3.6.4 Anwendung: Vergrößern digitaler Bilder................................................... 58

4 Zusammenfassung.................................................................................................... 64

5 Literatur.................................................................................................................... 65
Ingenieurmathematik 4

1 EINLEITUNG

Eine Größe, die sich kontinuierlich ändert, ist oft nur an endlich vielen Stellen bekannt,
z. B. durch Messungen. Man möchte nun die Größe aus den zugänglichen Daten rekon-
struieren.

Interpolation kommt auch zur Anwendung, wenn ein digitales Bild vergrößert werden
soll. Ein solches Bild lässt sich durch eine Funktion B darstellen, welche einem gegebe-
nen Pixel seinen Farbwert zuordnet. Hat das Bild 100 x 100 Pixel, so ist die Funktion B
gegeben durch

B: {0,1,...,99} x {0,1,...,99} --> IR,

B(i,j) = Farbe von Pixel (i,j)

Wird nun das Bild mit Faktor 10 vergrößert, so ist diese Abbildung durch eine Abbil-
dung

~
B : {0,1,...,999} × {0,1,...,999} → IR

zu ersetzen. Die naive Vorgehensweise

~
(1.1) B (i, j ) = B (round (i / 10), round ( j / 10))

führt zu unbefriedigenden Ergebnissen:


Ingenieurmathematik 5

Abbildung 1: Vergrößerung durch stückweise konstante Fortsetzung

Hier wurde eine Interpolation auf durch stückweise konstante Fortsetzung vorgenom-
men: Rundet man ab, so liefert Pixel (50,50) im Originalbild den Farbwert für die Pixel
(500+i,500+j) (i=-4,...,5, j=-4,...,5) im vergrößerten Bild.

Professionelle Foto-Bearbeitungsprogramme verwenden anstelle dieser Primitivinterpo-


lation differenzierbare Funktionen. Am häufigsten wird kubische Spline-Interpolation
eingesetzt [SCHWEIZER(2002)].
Ingenieurmathematik 6

2 L I N E A R E I N T E R P O L AT I O N

Das einfachste Interpolationsverfahren ist die lineare Interpolation. Der Funktionswert


an einer Zwischenstelle t zwischen zwei Stützstellen x1 und x 2 wird gewonnen, indem
der Wert auf der Verbindungsgeraden zwischen den gegebenen Punkten ( x1 , y1 ) und
( x 2 , y 2 ) genommen wird.

Abbildung 2: Lineare Interpolation

Hier ergibt sich also der Wert an der Zwischenstelle durch

y 2 − y1
(1.2) f (t ) = f ( x1 ) + (t − x1 )
x 2 − x1
Ingenieurmathematik 7

2.1 P OLYNOMINTERPOLATION
Ein Nachteil der linearen Interpolation sind die Knicke an den Stützstellen. Die Funkti-
on, die sich durch stückweise lineare Interpolation ergibt, ist an den Stützstellen nicht
differenzierbar:

Abbildung 3: Stückweise lineare Interpolation

Dieser Nachteil besteht bei der Polynominterpolation nicht.

SATZ (INTERPOLATIONSPLOYNOM)
Sind ( x i , y i ) (i=0, 1, 2,..., N) gegeben mit xi ≠ x j (i ≠ j) , so gibt es genau ein
Polynom p vom Grad N mit p ( xi ) = y i (i=0, 1, 2,..., N).
Ingenieurmathematik 8
Bekanntlich ist eine Gerade (Polynom vom Grad 1) durch zwei Punkte eindeutig be-
stimmt. Obiger Satz verallgemeinert diesen Sachverhalt.

2.1.1 B ERECHNUNG DES I NTERPOLATIONSPOLYNOMS


Sei p ( x) = a 0 + a1 x + a 2 x 2 + ... + a N x N .
Bei gegebenen ( x i , y i ) (i=0, 1, 2,..., N) ergibt sich folgendes LGS für die Koeffizien-
ten:

p( xi ) = a0 + a1 xi + a 2 xi + ... + a N xi = y i (i=0,1,...,N)
2 N
(2.1)

Mit der Matrix

 x1N x1N −1 ... x1 1  aN   y0 


 N     
 x2 x 2N −1 ... x 2 1  a N −1   y1 
V = .  r   r  
 . . ... .  und den Vektoren a = . , y = .
   
 . . . ... .  .   . 
 N N −1   a  y 
 xN xN ... x N 1  0   N

Mit der letzten Spalte beginnen!! Koeffizienten in umgekehrter Reihenfolge!!

ergibt sich das LGS

r r
(2.2) Va = y .

Die Matrix V heißt Vandermonde-Matrix und kann mit der MATLAB-Funktion van-
der erzeugt werden:

x-Werte der Stützstellen x=[ 1 3 4 5];

vander(x)
ans =
1 1 1 1
Vandermonde-Matrix 27 9 3 1
64 16 4 1
125 25 5 1
Ingenieurmathematik 9

Die Lösung des LGS (2.2) liefert die Koeffizienten des Interpolationspolynoms.

Einfacher lässt sich das Interpolynom mit der MATLAB-Funktion polyfit


bestimmen. polyfit berechnet das Polynom, welches die vorgegebenen Punkte
im quadratischen Mittel am Besten annähert. Haben wir N+1 Punkte, und ist ein
Polynom vom Grad N gesucht, so erfüllt das Interpolationspolynom diese Aufgabe
exakt.

BEISPIEL 1: MATLAB-PROGRAMM „POLYNOMINTERPOLATION“ MIT


GRAFISCHER OBERFLÄCHE
Wir schreiben ein MATLAB-Programm mit grafischer Oberfläche, welches dem Benut-
zer ermöglicht, die zu interpolierenden Punkte per Mausklick einzugeben. Das Interpo-
lationspolynom, dessen Grad durch die Anzahl der vorgegebenen Punkte bestimmt ist,
wird gezeichnet.

Lösung:
Jeder Komponente eines MATLAB GUI1 (z. B. Buttons, Listboxes, Textfelder,...) ist
eine oder mehrere sog. Callback-Funktionen zugeordnet. Diese Callback-Funktionen
werden durch Aktionen des Benutzers aktiviert (z. B. Drücken eines Buttons, Maustaste
betätigen,...). Callback-Funktionen enthalten die Reaktionen auf Ereignisse [MATH-
WORKS(2006)].

1
GUI Graphical User Interface
Ingenieurmathematik 10

MATLAB GUI Develop- guide


ment Environment starten

Im Guide Quick Start


Fenster kann man zwischen
verschiedenen Vorlagen für
die die GUI-Entwicklung
wählen.

Wir wählen Blank GUI, also eine leere Vorlage


Ingenieurmathematik 11

Der Bereich im Innern des


Fensters ist der sog. Layout-
Bereich. Auf diesem können
Bedienelemente angeordnet
werden. Wird die Bedien-
oberfläche gestartet, so sieht
der Benutzer diesen Bereich.

Außerhalb des Layout-


Bereichs sind Werkzeugleis-
ten angeordnet.

Wir wählen aus der Werkzeugpalette durch Anklicken das Werkzeug Achsen (Axes) und platzieren es auf dem Lay-
out-Bereich, indem wir dort den Bereich, den die Achsen einnehmen sollen, durch Ziehen festlegen.
Ingenieurmathematik 12

Nun legen wir die Eigenschaften der Achsen fest. Die x-Achse soll fest auf den Bereich [0 10] eingestellt sein. Die y-
Achse soll den Bereich [-10 10] abdecken. Dazu klicken wir mit der rechten Maustaste auf den Bereich axes1 und
wählen Property Inspector. Dieser zeigt alle Eigenschaften des selektierten Bereichs an. Ferner lassen sich hier
Eigenschaften ändern.

Wir wählen die Eigenschaft XLim und stellen die Begrenzungen für x ein. Dabei wird XLimMode automatisch auf
manual umgestellt. Mit YLim verfahren wir analog.
Ingenieurmathematik 13

Nun soll der Bereich, der durch die Achsen festgelegt ist, auf Mausklicks reagieren. Dazu klicken wir den Bereich
wieder mit der rechten Maustaste an und wählen View Callbacks-->ButtonDownFcn. Nun werden wir aufgefordert,
das Layout zu speichern. Gibt man einen Dateinamen ein, so wird das Layout in einer Datei mit Endung .fig gespei-
chert. Der zugehörige Programmcode befindet sich in einer Datei gleichen Namens mit Endung .m . Diese M-File
mit dem Programmcode wird nun automatisch geöffnet, und im Editor erscheint bereits die Funktion für die Behand-
lung eines Mausklicks:

% --- Executes on mouse press over axes background.


function axes1_ButtonDownFcn(hObject,
axes1_ButtonDownFcn eventdata, handles)
% hObject handle to axes1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

Hier können wir die Anweisungen einfügen, die ausgeführt werden sollen, wenn der Benutzer auf dem entsprechen-
den Bereich eine Maustaste drückt. Zum Test geben wir hier folgende Zeile ein:

msgbox(‚hallo’);

Durch Drücken der Schaltfläche im GUI-Fenster (.fig) oder durch Drücken von im M-File Editor kann
das Programm ausgeführt werden.

Nun soll die in der Aufgabe geforderte Funktionalität implementiert werden. Dazu benötigen wir die Information, an
welcher Stelle die Maustaste gedrückt wurde. Dies ermitteln wir
Ingenieurmathematik 14

mouse = get(hObject,'currentpoint');

Dabei ist hObject das Handle für das aktuelle Objekt. Dieses wird als Übergabeparameter in die Callback-
Funktion übertragen. Mit get fragen wir Eigenschaften ab. Hier handelt es sich um die Eigenschaft current-
point, welche die aktuelle Mausposition, bezogen auf die x-y-Achsen, angibt.
Mit

hold on;
plot(mouse(1,1),mouse(1,2),'ro');

wird an den angeklickten Stellen ein rotes ‚o’ gezeichnet.

Nun soll zu den angeklickten Punkten das Interpolationspolynom berechnet und gezeichnet werden. Dazu müssen
wir uns die Punkte merken. Hierfür verwenden wir globale Variable. Diese sollten beim Start des Programms initiali-
siert werden. Die Funktion xxx_OpeningFcn wird immer unmittelbar bevor die grafische Oberfläche sichtbar
wird aufgerufen. Dies ist eine geeignete Stelle für Initialisierungen:

function test1_OpeningFc
OpeningFcn(hObject,
OpeningFc eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to test1 (see VARARGIN)
global points; % Vektor mit geklickten Punkten
global numberOfPoints; % Anzahl geklickter Punkte
points = zeros(2,20);
numberOfPoints = 0;

In der Mausklick-Funktion greifen wir auf diese globalen Variablen zu:

function axes1_ButtonDownFcn
ButtonDownFcn(hObject,
ButtonDownFcn eventdata, handles)
% hObject handle to axes1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
global points;
global numberOfPoints;
mouse = get(hObject,'currentpoint');
numberOfPoints = numberOfPoints + 1;
points(1,numberOfPoints) = mouse(1,1); % x-Koordinate
points(2,numberOfPoints) = mouse(1,2); % y-Koordinate
x = points(1,1:numberOfPoints);
y = points(2,1:numberOfPoints);
Ingenieurmathematik 15

hold on;
plot(x,y,'ro');

Nun können wir das Interpolationspolynom berechnen und zeichnen:

if numberOfPoints >= 2
[p,s]=polyfit(x,y,numberOfPoints-1),
t=0:.01:10;
plot(t,polyval(p,t));
end

Unser Fenster wird nun sehr schnell mit den Interpolationspolynomen gefüllt. Daher löschen wir das vorige Interpo-
lationspolynom, ehe wir das neue zeichnen. Ferner sichern wir unser Programm noch dahingehen ab, dass bei Errei-
chen der maximalen Punktezahl von vorn begonnen wird:

function axes1_ButtonDownFcn
ButtonDownFcn(hObject,
ButtonDownFcn eventdata, handles)
% hObject handle to axes1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
global points;
global numberOfPoints;
mouse = get(hObject,'currentpoint');
numberOfPoints = numberOfPoints + 1;
points(1,numberOfPoints) = mouse(1,1); % x-Koordinate
points(2,numberOfPoints) = mouse(1,2); % y-Koordinate
x = points(1,1:numberOfPoints);
y = points(2,1:numberOfPoints);
hold on;
c = get(gca,'children'); % gca: current axes
delete( c(1:length(c)));
plot(x,y,'ro');
if numberOfPoints >= 2
[p,s]=polyfit(x,y,numberOfPoints-1),
t=0:.01:10;
plot(t,polyval(p,t));
end
if numberOfPoints == 20
msgbox('Maximalzahl Punte erreicht.');
numberOfPoints = 0;
end
Ingenieurmathematik 16

Nun bauen wir noch eine Reset-Schaltfläche ein, mit der wir die Anzahl der Stützstellen auf 0 setzen können. Dazu
platzieren wir einen Pushbutton auf der Layout-Fläche, klicken auf dem Pushbutton die rechte Maustaste und wählen
Property Inspector. Eigenschaft String legt die Beschriftung der Schaltfläche fest. Hier geben wir Reset ein. Die
zugehörige Callback-Funktion ist automatisch erzeugt und kann nach Speichern editiert werden:

function pushbutton1_Callback(hObject,
pushbutton1_Callback eventdata, handles)
% hObject handle to pushbutton1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
global numberOfPoints;
numberOfPoints = 0;
Ingenieurmathematik 17

3 S P L I N E - I N T E R P O L AT I O N

Interpolationspolynome haben die unangenehme Eigenschaft, dass sie mit zunehmen-


dem Grad und damit mit zunehmender Anzahl Stützstellen zwischen den Stützstellen i.
a. heftiger zu oszillieren neigen. Das macht Interpolationspolynome in vielen Fällen
unbrauchbar.

Man erhält i. d. R. wesentlich bessere Ergebnisse, wenn man die gegebenen Punkte
stückweise unter Verwendung von Polynomen niederen Grades interpoliert. Diese Idee
wird bei den sog. kubischen Splines verfolgt.

Spline ist die englische Bezeichnung für biegsame Holzlatten, wie sie im Schiffsbau
verwendet werden.

Bei gegebenen Punkten ( x i , y i ) (i=0,1,..,N) mit x 0 < x 1 < ... < x N setzen wir die
Spline-Funktion g auf dem Intervall [x i , x i + 1 ] als Polynom dritten Grades an:

(3.1) g i ( x) = a i + bi x + ci x 2 + d i x 3 ( x ∈ [x i , x i +1 ]) , i=0,1,...,N-1

Wir „kleben“ also N Polynome vom Grad drei aneinander. Dabei sollen folgende Be-
dingungen erfüllt sein:

1. g i ( xi ) = y i (i=0,1,...,N-1)
2. g i ( xi +1 ) = y i +1 (i=0,1,...,N-1)
′ ′
3. g i ( xi +1 ) = g i +1 ( xi +1 ) (i=0,1,...,N-2)
″ ″
4. g i ( xi +1 ) = g i +1 ( xi +1 ) (i=0,1,...,N-2)

Die kubische Spline-Interpolation, die sich durch

 g 0 ( x) (x ∈ [x 0 , x1 ])
 g ( x) (x ∈ [x , x ])

(3.2) S ( x) =  1 1 2

 ...
 g N −1 ( x) (x ∈ [x N -1 , x N ])
Ingenieurmathematik 18
ergibt, geht also durch sämtliche vorgegebenen Punkte und ist an den Stützstellen
zweimal stetig differenzierbar.

Die Bedingungen 1. bis 4. stellen 4N-2 Bedingungen für die 4N Unbekannten Koeffi-
zienten dar. Um das System eindeutig lösbar zu machen, benötigen wir zwei weitere
Bedingungen. Man erhält somit ein LGS mit 4N Gleichungen für die 4N unbekannten
Koeffizienten.

Häufig fordert man

″ ″
(3.3) g 0 ( x0 ) = g N −1 ( x N ) = 0 .
Spline-Interpolationen, die diese Zusatzbedingung erfüllen, heißen natürliche kubische
Splines.

Die MATLAB-Funktion spline verwendet anstelle von (3.3) die sog. not-a-knot-
Bedingung, bei der die äußeren drei Punkte jeweils durch ein Polynom dritten Grades
interpoliert werden:

(3.4) g 0 ( x) = g 1 ( x) (x ∈ [x 0 , x 2 ]), g N −2 ( x) = g N −1 ( x) (x ∈ [x N-2 , x N ])

BEISPIEL: ANWENDUNG DER MATLAB-FUNKTION SPLINE

x=0:10;
Stützstellen: Grob abgetasteter Sinus
y=sin(x);

Stellen, an denen Werte interpoliert werden sollen t=0:.05:10;

Splines berechnen yy=spline(x,y,t);

Ergebnis zeichnen plot(x,y,t,yy) ;


Ingenieurmathematik 19
Alternativ kann man bei spline die Ableitungen an den beiden Randpunkten vorge-
ben. Ferner bietet MATLAB die Möglichkeit, mit der Funktion interp1 eine Spline-
Interpolation durchzuführen.

3.1 M INIMALEIGENSCHAFT VON S PLINES


Splines haben eine angenehme Eigenschaft, die sie für viele Anwendungen attraktiv
macht. Salopp formuliert, kommen Splines den Kurven am nächsten, die man von Hand
durch eine gegebene Punktemenge zeichnen würde. Genauer gilt für eine Spline-
Funktion folgende Eigenschaft: Ist f irgendeine hinreichend glatte Funktion, welche die
vorgegebenen Punkte interpoliert und S eine Spline-Interpolation, so gilt:

xN xN

∫ S ′′( x) dx ≤ ∫ f ′′( x ) dx
2 2
(3.5)
x0 x0

Das bedeutet, dass die Spline-Funktion die kleinste mittlere Krümmung unter allen
interpolierenden Funktionen liefert. Da das obige Integral ein Maß für die Energie ist,
die erforderlich ist, um einen Stab zu biegen, kann man obige Ungleichung auch so
interpretieren, dass der Spline einen elastischen Stab mit minimaler Energie durch die
vorgegebenen Punkte bringt.

3.2 A NWENDUNGEN VON S PLINES


 Achterbahn-Konstruktion: Splines kommen bei der Achterbahn-
Konstruktion zum Einsatz. Der deutsche Achterbahn-Konstrukteur Werner
Stengel kam auf diese Idee: "Ja, in den alten Tagen wurden Achterbahnen mit
Zirkel und Lineal entworfen. Man hat einen Kreis gewählt, wo man bergab
fährt, nach dem Kreis ist man eine gerade gefahren, und nach dieser Geraden
wieder in einen Kreis. Man kann erkennen, das ist keine natürliche Bewegung,
denn wenn ich von der Geraden hier in den Kreis reinfahre, ist das eine kriti-
sche Stelle, ich werde schlagartig mit der dreifachen Belastung belastet, und
so eine Linie wie hier finden sie in der Natur gar nicht. [...]. Die Spline-
Funktionen machen so einen natürlichen Bewegungsablauf möglich, das man
z.B. beim Olympia-Looping einen Looping mit einem Glas Wasser in der Hand
fahren könnte, ohne einen Tropfen zu verschütten.“ [DEUTSCHE WEL-
LE(2005)].
 Hochgeschwindigkeitstrecken der Eisenbahn: Bei der exakten Verlegung
der Schienen kommen ebenfalls Splines zum Einsatz.
Ingenieurmathematik 20
 CNC-Software enthält i. d. R. Spline-Interpolation


Aufgabe
AUFGABE SB4-1: POLYNOM-UND SPLINEINTERPOLATION

Schreiben Sie ein MATLAB-Programm mit grafischer Oberfläche, welches dem Benutzer ermöglicht, die zu 
interpolierenden Punkte per Mausklick einzugeben. 15 Punkte
Zwei Radio Buttons sollen die Auswahl zwischen Polynominterpolation und Splineinterpolation ermögli-
chen.

3.3 T RIGONOMETRISCHE I NTERPOLATION

3.3.1 R EELLE T RIGONOMETRISCHE I NTERPOLATION


Wir gehen von dem Spezialfall aus, dass 2n+1 äquidistante Stützstellen
2πk
xk = (k=0,1,...,2n) mit zugehörigen Werten y k (k=0,1,...,2n)
2n + 1
gegeben sind. Äquidistante Stützstellen kommen in der Praxis sehr häufig vor. Wird ein
analoges Signal erfasst, so geschieht dies meist dadurch, dass das Signal mit einer be-
stimmten Rate abgetastet wird. Auf diese Weise kommen äquidistante Stützpunkte
zustande. Die Normierung auf das Intervall [0, 2π] lässt sich durch eine entsprechend
Skalierung der Zeit immer erreichen.

Gesucht ist das sog. trigonometrische Interpolationspolynom zu den vorgegebenen


Daten ( x k , y k ) , d. h. eine Funktion der Form

n
+ ∑ [a k cos(kx) + bk sin(kx)] ,
a0
(3.6) p( x) =
2 k =1

mit p ( x k ) = y k (k=0,1,...,2n).
Ingenieurmathematik 21

SATZ: TRIGONOMETRISCHES INTERPOLATIONSPOLYNOM


Das trigonometrische Interpolationspolynom hat die Koeffizienten

2 2n
(3.7a) ak = ∑ y j cos(kx j )
2n + 1 j = 0
(k=0,1,...,n)

2 2n
(3.7b) bk = ∑ y j sin(kx j ) (k=1,2,...,n)
2n + 1 j = 0

Der Algorithmus von Goertzel [VERFÜRTH(2005)] gestattet eine effiziente Berech-


nung der Koeffizienten und eine effiziente Auswertung des trigonometrischen Interpola-
tionspolynoms.

ALGORITHMUS VON GOERTZEL


Berechne

2 2n
a0 = ∑ yj
2n + 1 j =0

Für k=1,...,n:

c = cos( x k ), cc = 2c, s = sin( x k )

Mit u 2 n +1 = u 2 n+ 2 = 0 berechne für j=2n, 2n-1,...,1:

u j = y j + cc ⋅ u j +1 − u j + 2

Damit:

ak =
2
( y0 + c ⋅ u1 − u 2 )
2n + 1
(k=1,...,n)
2
bk = ⋅ s ⋅ u1
2n + 1
Ingenieurmathematik 22

Auswertung des trigonometrischen Polynoms an einer Stelle x* :

Setze

u n +1 = u n + 2 = 0, c = cos( x * ), cc = 2c, s = sin( x * )

Berechne für j=n,n-1,...,1:

u j = a j + cc ⋅ u j +1 − u j + 2

1
Dann gilt: p( x * ) = a 0 + c ⋅ u1 − u 2 + s ⋅ u1
2

MATLAB-Code für trigonometrische Interpolation

Berechnung der Koeffizienten: Datei trigoInt.m

function koeff = trigoInt(y)


trigoInt
%
% Trigonometrische Interpolation an den Stützstellen
% xk=2*pi*k/(2n+1), k=0,...,2n
%
% Eingabeparameter: y : Zeilenvektor der Werte an den Stellen xk
% Länge von y: 2n+1
%
% Rückgabewerte: koeff: Koeffizienten des trigonometrischen
% Interpolationspolynoms
% 1. Zeile: a0,a1,...,an
% 2. Zeile: 0, b1,...,bn
%
nn=size(y);
m=nn(2); % m = 2n+1; m-1=2n
n = (m-1)/2;
h=2*pi/m; % Abstand der Stützstellen
x=zeros(1,m);
Ingenieurmathematik 23

for i=2:m
x(i)=h*(i-1); % Stützstellen
end
hold off;
plot(x,y,'ro');
hold on;
z=x(1,2:n+1);
c=cos(z);
cc=2*c;
s=sin(z);
u = zeros(n,m+1);
% a0 = koeff(1,1)
% a1 = koeff(1,2),...
% b1 = koeff(2,2), b2 =koeff(2,3),...
koeff=zeros(2,n+1);
koeff(1,1)=0; % a0 = koeff(1,1)
for j=1:m
koeff(1,1)=koeff(1,1)+y(j);
end
koeff(1,1)=koeff(1,1)*2/m; % a0

for k=1:n
for j=m-1:-1:1
u(k,j)=y(j+1)+cc(k)*u(k,j+1)-u(k,j+2);
end
koeff(1,k+1)=(y(1)+c(k)*u(k,1)-u(k,2))*2/m; %ak
koeff(2,k+1)=s(k)*u(k,1)*2/m; % bk
end

Auswertung der trigonometrischen Interpolation: Datei trigoIntValue.m

function values = trigoIntValue(x,y)


trigoIntValue
%
% Berechnet den Wert der trigonometrischen Interpolation
% an der Stelle x
%
% Eingabeparameter: x: Stellen, an denen interpoliert werden soll
% (Zeilenvektor)
% y: Zeilenvektor der Werte an den Stellen
% xk=2*pi*k/(2n+1), k=0,...,2n
% Länge von y: 2n+1
Ingenieurmathematik 24
%
% Rückgabewerte: Werte an den Stellen x
%
koeff = trigoInt(y);

nn=size(y);
m=nn(2); % m = 2n+1
n = (m-1)/2;
ww=size(x);
w=ww(2);
u=zeros(w,n+2);
c=cos(x);
cc=2*c;
s=sin(x);
values=zeros(ww);
r=zeros(ww);
for i=1:w
for j=n:-1:1
u(i,j)=koeff(2,j+1)+cc(i)*u(i,j+1)-u(i,j+2);
end
r(i)=s(i)*u(i,1);
for j=n:-1:1
u(i,j)=koeff(1,j+1)+cc(i)*u(i,j+1)-u(i,j+2);
end
values(i) = 0.5*koeff(1,1)+c(i)*u(i,1)-u(i,2)+r(i);
end

ANWENDUNGSBEISPIELE

>> h=2*pi/5;
>> xx=0:h:2*pi-h;
>> y=sin(xx)+cos(xx);
>> x=0:.01:2*pi;
>> plot(x,trigoIntValue(x,y))
Ingenieurmathematik 25

>> y=rand(1,5);
>> x=0:.01:2*pi;
>>plot(x,trigoIntValue(x,y));

>> y=rand(1,21);
>> x=0:.01:2*pi;
>>plot(x,trigoIntValue(x,y));
Ingenieurmathematik 26

Ist die Anzahl der Stützstellen eine Zweierpotenz, so lässt sich die trigonometrische
Interpolation besonders effizient mit der sog. schnellen Fourier-Transformation (FFT,
Fast Fourier Transform) berechnen. Diese wird mit der MATLAB-Funktion fft
durchgeführt.


Aufgabe
AUFGABE SB4-2: HOCH-UND TIEFPASSFILTER

Schreiben Sie ein MATLAB-Programm mit grafischer Oberfläche, welches zunächst die

Funktion 15 Punkte

f(x) = x (0 ≤ x ≤ 0.5), f(x) = x - 0.5 (0.5< x ≤ 1)

an 101 Stützstellen trigonometrisch interpoliert.


Der Benutzer soll nun die minimale Frequenz und die maximale Frequenz eingeben
können. Entsprechend der Eingabe werden die Koeffizienten (3.7) des trigonometrischen
Polynoms 0 gesetzt und das trigonometrische Interpolationspolynom (3.6) geplottet.
Dazu ist insbesondere eine der Funtionen trigoInt() oder trigoIntValue() zu
modifizieren.
Ingenieurmathematik 27

3.3.2 K OMPLEXE T RIGONOMETRISCHE I NTERPOLATION


Die MATLAB-Funktion fft geht von der komplexen Formulierung des
trigonometrischen Interpolationsproblems aus:

KOMPLEXE FORMULIERUNG DER TRIGONOMETRISCHEN INTERPO-


LATION

Gegeben sind n äquidistante Stützpunkte (x , y ) (j=0,1,...,n-1) mit x


j j j = j
T
. Die
n
y j können komplexe Zahlen sein.

Gesucht ist eine Funktion der Form

− iαkx
1 n−1
y ( x) = ∑ Yk e ,
n k =0

welche an den Stützstellen mit den y j übereinstimmt.

Nimmt man an, dass die n gegebenen Stützpunkte Teil einer periodischen Funktion mit
der Periode T sind, so ergibt sich aus der Forderung, dass auch y(x) T-periodisch sein

soll, α = . Die Fourier-Koeffizienten sind gegeben durch
T

n−1 2πkj
i
Yk = ∑ y j e n
(k=0,1,...,n-1)
j =0

Die Berechnung der Yk aus den y j nennt man Fourier-Transformation (FT). Die
Auswertung von

2πkj
−i
1 n−1
y ( x j ) = ∑ Yk e
n

n k =0

bei gegebenen Yk heißt inverse Fourier-Transformation (IFT).


Ingenieurmathematik 28

3.3.2.1 Spezialfall: Reelle Stützwerte


Hat man reelle Stützwerte y j gegeben, so ergibt sich

2πkj
n −1 i n−1
 2πkj 2πkj 
Yk = ∑ y j e n
=∑ y j  cos + i sin ,
j =0 j =0  n n 
und für die konjugiert komplexen Fourier-Koeffizienten

n −1
 2πkj 2πkj 
Yk = ∑ y j  cos − i sin 
j =0  n n 
Damit folgt:

n −1
2π (n − k ) j 2π (n − k ) j 
Yn−k = ∑ y j  cos − i sin =
j =0  n n 
n −1
  2πkj   2πkj  
= ∑ y j  cos 2π −  − i sin  2π −   = Yk
j =0   n   n 

Es gilt also die Symmetriebedingung

(S) Yn−k = Yk (k=1,...,n-1)

Für n=5 gilt bedeutet dies z. B.

Y1 = Y4 , Y2 = Y3 , Y1 = Y4 ,

und für n=6 ergibt sich

Y1 = Y5 , Y2 = Y4 , Y3 = Y3 ,

also ist in diesem Fall Y3 reell.

Sind umgekehrt die Stützwerte y j reell und gilt (S), so ist die IFT reell:
Ingenieurmathematik 29

i
Mit ω =e n
gilt:
2π 2πk
i (n − k ) ) 2πi
−i 2kπ 2kπ
z =ω n− k
=e n
=e e n
= ω − k = cos(− ) + i sin(− )= z.
n n

Fall1: n gerade, also n = 2m. Dann ist Ym reell, und es folgt

2πkj
n −1 −i
1 1 n−1 1
y ( x j ) = ∑ Yk e = ∑ Yk ω −kj = [Y0 + Y1ω − j + Yn−1ω − j ( n−1) +
n

n k =0 n k =0 n
Y2ω −2 j + Yn−2ω − j ( n−2) + ... + Ym−1ω −( m−1) j + Ym+1ω −( m+1) j + Ymω −mj ]
1
= [Y0 + Y1ω − j + Yn−1ω j + Y2ω −2 j + Yn−2ω 2 j + ... + Ym−1ω −( m−1) j + Ym+1ω ( m −1) j + Ymω −mj ]
n
1
= [Y0 + Y1ω − j + Y1ω j + Y2ω −2 j + Y2ω 2 j + ... + Ym−1ω −( m−1) j + Ym−1ω ( m−1) j + Ymω −mj ]
n
[ ]
m −1
1
= [Y0 + ∑ Yk ω − jk + Yk ω jk + Ymω −mj ]
n k =1

m −1  − jk
1  2 jkπ 2 jkπ   2 jkπ 2 jkπ 
= [Y0 + ∑ Yk  cos( ) − i sin( ) + Yk  cos( ) + i sin( )  + Ymω −mj ]
n 
k =1   n n   n n 
m −1
2 jkπ 2 jkπ 
= [Y0 + ∑ (Yk + Yk ) cos( ) + i (− Yk + Yk )sin(
1 
) + Ym (−1) − j ] ∈ IR
n k =1  n n 

Fall 2: n ungerade, also n = 2m+1. Dann folgt


Ingenieurmathematik 30
2m
1 1
y( x j ) = ∑
n k =0
Yk ω −kj = [Y0 + Y1ω − j + Yn−1ω − j ( n−1) +
n
Y2ω −2 j + Yn−2ω − j ( n−2) + ... + Ym−1ω −( m−1) j + Ym+ 2ω −( m+ 2) j + Ymω −mj + Ym+1ω −( m+1) j ]

[ ]
m
1
= [Y0 + ∑ Yk ω − jk + Yk ω jk ]
n k =1

m  − jk
1  2 jkπ 2 jkπ   2 jkπ 2 jkπ 
= [Y0 + ∑ Yk  cos( ) − i sin( )  + Yk  cos( ) + i sin( )  ]
n k =1 
  n n   n n 
2 jkπ 2 jkπ 
[Y0 + ∑ (Yk + Yk ) cos( ) + i (− Yk + Yk )sin(
1 m

= ) ] ∈ IR
n k =1  n n 

3.3.3 A NWENDUNG : D ATENGLÄTTUNG


Als Beispiel betrachten wir folgende Funktion im Intervall [0, 4]:

x
− 1 
f ( x) = e 2e − 2( x −1) + 3e −( x −3) + sin(10 x)
2 2
2
(#)
 3 
[SORMANN(2006)].

function f=testfn(x)
f=exp(-x/2).*(2*exp(-2*(x-1).^2)+3*exp(-2*(x-3).^2)+sin(10*x)/3);
Ingenieurmathematik 31

Abbildung 4: Testfunktion f(x) (#)

Wir überlagern nun obige Funktion mit zufälligen Störungen:

>> h=4/64;
>> xx=0:h:4-h;
>> y=testfn(xx);
>> z=y+.1-0.2*rand(1,64)
Ingenieurmathematik 32

Abbildung 5: Funktion (#) mit Störungen

FFT für ungestörtes Signal und für gestörtes Signal, jeweils an 64 äquidistanten Stützstellen abgetastet:

>> yClean = testfn(xx); % Werte ungestört


>> uClean = fft(yClean); % FFT für ungestörte Werte
>> plot(abs(uClean));
>> uDirty = fft(z); % FFT für gestörte Werte
>> plot(abs(uDirty),'r');
Ingenieurmathematik 33

Abbildung 6: Beträge der komplexen Fourier-Koeffizienten

Wie man sieht, wirken sich die Zufallsstörungen so aus, dass im mittleren Frequenzbereich von Null verschiedene
Koeffizienten auftreten. Es liegt nahe, das Signal durch Unterdrücken der mittleren Frequenzen zu glätten:

>>k0=12;
>>for i=k0+1:64-k0+1
>> uDirty(i)=0
>>end
>> yCleaned = ifft(uDirty); % inverse FFT
>> plot(real(yCleaned),’r’); % Realteil der inversen FT
>> hold on;
>> plot(y,’r’); % zum Vergleich: Original-Funktion
Ingenieurmathematik 34

Abbildung 7: Original-Funktion, gestörte Werte und Glättung


Ingenieurmathematik 35

3.4 B ERNSTEIN -P OLYNOME , B ÉZIER -D ARSTELLUNG VON P OLYNOMEN


Nach dem binomischen Lehrsatz gilt:
n
n n
1 = ((1 − t ) + t ) = ∑  (1 − t ) n− k t k = ∑ Bkn (t )
n

k =0  k  k =0

mit den Bernstein-Polynomen vom Grad n bezüglich des Intervalls [0, 1]


n
Bkn (t ) =  (1 − t ) n − k t k
k 
Bernstein-Polynome haben folgende Eigenschaften:

k
1. Bkn (t ) hat in [0, 1] genau ein Maximum, und zwar bei t max = .
n
2. t=0 ist k-fache Nullstelle vonBkn (t )
3. t=1 ist (n-k)-fache Nullstelle von Bkn (t )
4. Die Bernstein-Polynome genügen der Rekursionsformel
Bkn (t ) = tBk −1,n −1 (t ) + (1 − t ) Bk ,n −1 (t )
B0 n (t ) = (1 − t ) B0,n −1 (t )
Bnn (t ) = tBn−1, n−1 (t )
Ingenieurmathematik 36

BEISPIEL: BERNSTEIN-POLYNOME FÜR N=4

B04 (t ) = (1 − t ) , B03 (t ) = (1 − t ) , B02 (t ) = (1 − t ) , B01 (t ) = (1 − t ) , B00 (t ) = 1


4 3 2 1

B11 (t ) = t , B22 (t ) = t 2 , B33 (t ) = t 3 , B44 (t ) = t 4


B12 (t ) = tB01 (t ) + (1 − t ) B11 (t ) = t (1 − t ) + t 2 ,
B13 (t ) = tB02 (t ) + (1 − t ) B12 (t )
B14 (t ) = tB03 (t ) + (1 − t ) B13 (t ),
B23 (t ) = tB02 (t ) + (1 − t ) B12 (t )
B24 (t ) = tB13 (t ) − (1 − t ) B23 (t )
B34 (t ) = tB23 (t ) + (1 − t ) B33 (t )

Abbildung 8: Berstein-Polynome 4. Grades


Ingenieurmathematik 37

3.4.1 B ÉZIER -D ARSTELLUNG


Jedes Polynom p vom Grad n lässt sich als Linearkombination der Bernstein-Polynome
darstellen:
n
(B) p (t ) = ∑ β k Bkn (t )
k =0

(B) heißt Bézier2-Darstellung von p. Die β k heißen Bézier-Koeffizienten und die


Punkte (i/k, β k ) Bézier-Punkte.

3.5 K URVEN
In CAD-Anwendungen hat man häufig das Problem, Kurven darzustellen, die durch
vorgegebene Punkte gehen müssen.

Industrieroboter müssen häufig möglichst genau Bahnen (Trajektorien) verfolgen,


wobei zusätzlich eine konstante Bahngeschwindigkeit gefordert sein kann. Dies ist z.
B. beim Bahnschweißen, Entgraten und beim Kleberauftrag der Fall.
Die Bewegung kann von Punkt zu Punkt erfolgen, d. h. es ist eine Reihe von Raum-
punkten

(xi , yi , z i ) (i=1,2,...,k)

zu vorgegebenen Zeitpunkten t1 , t 2 ,..., t k mit vorgegebenen Geschwindigkeiten


v1 , v 2 ,..., v k zu durchlaufen. Die Bewegung soll dabei ruckfrei sein, d. h. die zweite
Ableitung der Interpolationsfunktion (Beschleunigung) soll stetig sein.

2
Bézier, Pierre: Französischer Mathematiker (1910-1999). Beschrieb 1960 die nach
ihm benannte Bézier-Kurve, die von seinem damaligen Arbeitgeber Renault zur Gestal-
tung von Karosserieformen eingesetzt wurde.
Ingenieurmathematik 38
3.5.1 P ARAMETERDARSTELLUNG EINER K URVE
Eine Parameterdarstellung einer Kurve in der Ebene bzw. im Raum hat die Form
 x(t ) 
r  x(t )  r  
r (t ) =   bzw. r (t ) =  y (t ) 
 y (t )   z (t ) 
 

BEISPIEL: PARAMETERDARSTELLUNGEN VON KURVEN

>>t=0:.01:10;
>> plot(5*cos(t),5*sin(t))

 x(t )   5 cos(t ) 
  =  
 y (t )   5 sin(t ) 
Kreis um (0,0) mit Radi-
us 5

 x(t )   5e −0.1t cos(t ) 


  =  −0.1t 
 y (t )   5e sin(t )  >> t=0:.01:40;
Logarithmische Spirale >> plot(5*exp(-0.1*t).*cos(t),5*exp(-0.1*t).*sin(t));
Ingenieurmathematik 39

>> t=0:.01:20;
>> plot3(1+2*t,-2*t,-1+3*t);

 x(t )   1   2 
     
 y (t )  =  0  + t  − 2 
 z (t )   − 1  3 
     
Gerade
Ingenieurmathematik 40

>> t=0:.01:40;
>> plot3(cos(t),sin(t),t);

 x(t )   cos(t ) 
   
 y (t )  =  sin(t ) 
 z (t )   t 
   
zylindrische Spirale (He-
lix, Schraubenlinie)

3.5.2 P ARAMETRISCHE KUBISCHE S PLINES


Die oben diskutierten Spline-Funktionen können eingesetzt werden, um eine glatte
Kurve durch eine Reihe von gegebenen Punkten zu legen, wobei auch die Zeitpunkte,
zu denen die Punkte passiert werden sollen, gegeben sein können. Dabei werden einfach
Splines für jede Komponente berechnet.

BEISPIEL: PUNKTE AUF DER ZYLINDRISCHEN SPIRALE VORGEGEBEN

 x(t )   x(t i )   cos(t i ) 


     
Gesucht ist eine parametrische Spline-Kurve  y (t )  mit  y (t i )  =  sin(t i ) 
 z (t )   z (t )   t 
   i   i 

>> % vorgegebene Punkte


>>t=0:5:40 ;
>> x=cos(t);
>> y=sin(t);
Ingenieurmathematik 41

>> z=t;
>>tt=0:.01:40; % an diesen Stellen sollen die Kurvenpunkte berechnet werden
>> xx = spline(t,x,tt);
>> yy=spline(t,y,tt);
>> zz=spline(t,z,tt);
>> plot3(xx,yy,zz,'r');
>> hold on;
>> plot3(x,y,z,'*');
>>
Ingenieurmathematik 42


Aufgabe
AUFGABE SB4-3: SPLINE-INTERPOLATIONSKURVE

In der Datei points.mat sind 26 Punkte (xi , yi ) (i=1,2,...,26) binär gespeichert. Mit 
load points.mat werden die Variablen x und y mit den entsprechenden Werten 10 Punkte
geladen.

In der Ebene soll eine Bahn abgefahren werden, bei der die Punkte in der gegebenen
 i −1
2

Reihenfolge durchlaufen werden. Dabei soll der i-te Punkt nach t i = 10  Se-
 25 
kunden durchlaufen werden (i=1,…,26), so dass der letzte Punkt nach 10 Sekunden er-
reicht ist. Die Bahn zwischen den Punkten soll durch eine Spline-Kurve gegeben sein.

An welcher Stelle befindet man sich nach 5 Sekunden?

3.5.3 B ÉZIER -D ARSTELLUNG EINER K URVE


r r
Sind n+1 Kontrollpunkte3 bi ∈ IR 2 bzw. bi ∈ IR 3 gegeben, so heißt

r n r
P(t ) = ∑ bk Bkn (t )
k =0
r
die durch die Punkte bi erzeugte Bézier-Kurve. Die Bkn (t ) sind dabei die Bernstein-
Polynome n-ten Grades.

Es gilt:

r n r r r n r r
P(0) = ∑ bk Bkn (0) = b0 , P(1) = ∑ bk Bkn (1) = bn
k =0 k =0

Die Bézier-Kurve interpoliert also die Endpunkte. Ferner zeigt der Tangentialvektor in
den Endpunkten in Richtung des Verbindungsvektors der ersten bzw. letzten beiden
Kontrollpunkte.

3
Eigentlich: Ortsvektoren von Kontrollpunkten
Ingenieurmathematik 43

Im Fall von 2 Kontrollpunkten ergibt die Bézier-Kurve die Verbindungsstrecke der


beiden Punkte. Bei drei Kontrollpunkten liegt die Bézier-Kurve im Innern des von den
drei Punkten ausgespannten Dreiecks. Diese Eigenschaft lässt sich auf beliebig viele
Kontrollpunkte verallgemeinern: Die Bézier-Kurve bewegt sich in der sog. konvexen
Hülle der Kontrollpunktmenge.

Wird ein Kontrollpunkt geändert, so ändert sich in der Bézier-Kurve nur der zugehörige
Summand.

3.5.3.1 Der Algorithmus von de Casteljau


Aus der Rekursion für die Bernstein-Polynome lässt sich ein Algorithmus zu r Berech-
nung von Bézier-Kurven ableiten (z. B. [BABOVSKY, NEUNDORF(2006)]:
Ingenieurmathematik 44

ALGORITHMUS VON DE CASTELJAU


r r
Gegeben seien die n+1 Kontrollpunkte bi ∈ IR 2 bzw. bi ∈ IR 3 (i=0,1,...,n). Gesucht ist die zugehörige Bézier-
Kurve.
r r
1. Setze b j0 (t ) = b j (j=0,1,...,n)
r r r
2. Berechne für r=1,...,n und j=0,...,n-r: b jr (t ) = (1 − t )b jr −1 (t ) + tb jr+−11
r
Dann ist b0n (t ) die Bézier-Kurve zu den gegebenen Kontrollpunkten.

BEISPIEL 3: MATLAB-PROGRAMM „BÉZIER-KURVEN“ MIT GRAFI-


SCHER OBERFLÄCHE
Wir schreiben ein MATLAB-Programm mit grafischer Oberfläche, welches dem Benut-
zer ermöglicht, die Kontrollpunkte per Mausklick einzugeben. Die Kontrollpunkte wer-
den durch einen Polygonzug („Kontrollpolygon“) verbunden, und es wird die zugehöri-
ge Bézier-Kurve gezeichnet. Klickt man auf einen schon vorhandenen Kontrollpunkt, so
kann man diesen an eine andere Stelle ziehen.

Lösung:
Ingenieurmathematik 45

Algorithmus von de Casteljau: Datei bezier.m

function b=bezier(t,controlPoints)
%
% Berechnet die Bezier-Kurve zu den Kontrollpunkten p1,...,p(n+1)
% an der Stelle t
%
% Eingabeparameter: t Zeitpunkt
% controlPoints Matrix mit n+1 Kontrollpunkten
% Die Kontrollpunkte sind die Spalten der
% Matrix
%
% Rückgabewert: b Bezierkurve an der Stelle t
%

n = size(controlPoints); % 1. Index: 2 (ebene Kurve) oder 3 (räumliche Kurve)


% 2. Index: Anzahl Kontrollpunkte
numPoints = n(2)-1;
br = controlPoints;
bb = br; % bj0
for r=1:numPoints
br = zeros(n(1),numPoints-r+1);
for j=1:numPoints-r+1
br(:,j) = (1-t)*bb(:,j)+t*bb(:,j+1);
end
bb = br;
end
b=bb;

Erzeugen Sie ein leeres GUI. Ordnen Sie Achsen auf dem Fenster an, und stellen Sie XLimMode und YLimMode
auf manual ein. Wählen Sie als Einheit (Units) normalized. Ergänzen Sie Callbacks für das gesamte Fenster (View-
>Figure Callbacks) für die Ereignisse WindowButtonUp (Maustaste losgelassen) und WindowButtonMotion
(Mausbewegung).

function varargout = bezierDemo(varargin)


bezierDemo
% BEZIERDEMO M-file for bezierDemo.fig
% BEZIERDEMO, by itself, creates a new BEZIERDEMO or raises the existing
% singleton*.
Ingenieurmathematik 46

%
% H = BEZIERDEMO returns the handle to a new BEZIERDEMO or the handle to
% the existing singleton*.
%
% BEZIERDEMO('CALLBACK',hObject,eventData,handles,...) calls the local
% function named CALLBACK in BEZIERDEMO.M with the given input arguments.
%
% BEZIERDEMO('Property','Value',...) creates a new BEZIERDEMO or
% raises the
% existing singleton*. Starting from the left, property value pairs are
% applied to the GUI before bezierDemo_OpeningFunction gets called. An
% unrecognized property name or invalid value makes property application
% stop. All inputs are passed to bezierDemo_OpeningFcn via varargin.
%
% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one
% instance to run (singleton)".
%
% See also: GUIDE, GUIDATA, GUIHANDLES

% Edit the above text to modify the response to help bezierDemo

% Last Modified by GUIDE v2.5 06-Nov-2006 17:01:40

% Begin initialization code - DO NOT EDIT


gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @bezierDemo_OpeningFcn, ...
'gui_OutputFcn', @bezierDemo_OutputFcn, ...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin & isstr(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end

if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
Ingenieurmathematik 47

end
% End initialization code - DO NOT EDIT

% --- Executes just before bezierDemo is made visible.


function bezierDemo_OpeningFcn(hObject,
bezierDemo_OpeningFcn eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to bezierDemo (see VARARGIN)

% Choose default command line output for bezierDemo


handles.output = hObject;
global points;
global numPoints;
numPoints = 0;
points= zeros(2,100);
global dragIndex;
dragIndex = -1;

% Update handles structure


guidata(hObject, handles);

% UIWAIT makes bezierDemo wait for user response (see UIRESUME)


% uiwait(handles.figure1);

% --- Outputs from this function are returned to the command line.
function varargout = bezierDemo_OutputFcn(hObject,
bezierDemo_OutputFcn eventdata, handles)
% varargout cell array for returning output args (see VARARGOUT);
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Get default command line output from handles structure


varargout{1} = handles.output;
Ingenieurmathematik 48

% --- Executes on mouse press over figure background, over a disabled or


% --- inactive control, or over an axes background.
function figure1_WindowButtonDownFcn(hObject,
figure1_WindowButtonDownFcn eventdata, handles)
% hObject handle to figure1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
global points;
global numPoints;
global dragIndex;

mouse = get(gca,'currentPoint');
p = [mouse(1,1);mouse(1,2)];

dragIndex = check(p, points,numPoints);


fprintf('dragIndex: %d',dragIndex);
if dragIndex == -1
numPoints = numPoints+1;
points(1,numPoints) = mouse(1,1);
points(2,numPoints) = mouse(1,2);
end
hold on;

c = get(gca,'children');
delete( c(1:length(c)));
x = points(1,1:numPoints);
y = points(2,1:numPoints);
plot(x,y,'ro');
plot(x,y,'b');

controlPoints=points(:,1:numPoints);
t = 0:0.01:1;
y = zeros(2,101);
for i=1:101
y(:,i) = bezier(t(i),controlPoints);
end
plot(y(1,:),y(2,:),'g');

% --- Executes on mouse motion over figure - except title and menu.
Ingenieurmathematik 49

function figure1_WindowButtonMotionFcn
figure1_WindowButtonMotionFcn(hObject,
ionFcn eventdata, handles)
% hObject handle to figure1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
global dragIndex;
global points;
global numPoints;

if dragIndex >= 1
c = get(gca,'children');
delete( c(1:length(c)));

mouse = get(gca,'currentPoint');

p = [mouse(1,1);mouse(1,2)];
% fprintf('\nDrag: %f %f',p(1),p(2));

points(:,dragIndex)=p;

x = points(1,1:numPoints);
y = points(2,1:numPoints);
plot(x,y,'ro');
plot(x,y,'b');
controlPoints=points(:,1:numPoints);
t = 0:0.01:1;
y = zeros(2,101);
for i=1:101
y(:,i) = bezier(t(i),controlPoints);
end
plot(y(1,:),y(2,:),'g');
end
% --- Executes on mouse press over figure background, over a disabled or
% --- inactive control, or over an axes background.
function figure1_WindowButtonUpFcn(hObject,
figure1_WindowButtonUpFcn eventdata, handles)
% hObject handle to figure1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
global dragIndex;
dragIndex = -1;
Ingenieurmathematik 50

Funktion zum Test, ob ein schon vorhandener Punkt geklickt wird: Datei check.m

function index = check(p,xySet,


check maxIndex)
%
% Prüft, ob der Punkt (x,y) in der
% Menge xySet enthalten ist
%
% Eingabeparameter: p: Koordinaten des zu prüfenden Punktes
% (Spaltenvektor)
% xySet: Matrix der Punkte. Ein Punkt ist als
% Spaltenvektor abgelegt
% maxIndex: Nur die Spalten 1...maxIndex von xySet
% werden durchsucht
%
% Rückgabewert: index des Punktes in xySet, falls Punkt gefunden,
% -1 sonst
n = size(xySet);
res = -1;
for i=1:maxIndex
dist = norm(p-xySet(:,i));
if dist < 0.05
res = i;
% fprintf('\nTreffer: %d',res);
break;
end
end
index = res;

Zieht man einen Punkt, so flackert das Fenster. Das Flackern wird abgestellt, wenn bei den figure Eigenschaften
DoubleBuffering auf On gesetzt wird.
Ingenieurmathematik 51
Wie man sieht, sind Bézier-Kurven sehr gut kontrollierbar. Deshalb werden sie sie in
der Computergrafik häufig zur Konstruktion von Freiformkurven verwendet. Auch das
in WINDOWS enthaltene Zeichenprogramm PAINTBRUSH und das Zeichenpro-
gramm von OpenOffice unterstützen Bézier-Kurven.

Man kann zum Zweck der Interpolation auch mehrere Bézier-Kurven zusammensetzen.
Ingenieurmathematik 52

3.6 ZWEIDIMENSIONALE I NTERPOLATION UND A PPROXIMATION

3.6.1 Z WEIDIMENSIONALE LINEARE I NTERPOLATION


Die lineare Interpolation lässt sich leicht auf den zweidimensionalen Fall übertragen.

2.5 (x1,y1,f(x1,y1))
(x1,y0,f(x1,y0))
2

1.5 (x,y,g(x,y))

0.5
(x0,y0,f(x0,y0))
0
3
2
1.8
2.5 1.6
y 1.4
1.2 x
2 1

Abbildung 9: Lineare Interpolation in zwei Variablen

Ist die Funktion f an drei Punkten ( x0 , y 0 ), ( x1 , y 0 ), ( x1 , y1 ) bekannt, so ergibt sich


der interpolierte Wert für ( x, y ) ∈ [x 0 , x1 ]× [ y 0 , y1 ] gemäß

f ( x1 , y 0 ) − f ( x0 , y 0 ) f ( x1 , y1 ) − f ( x1 , y 0 )
g ( x, y ) = f ( x 0 , y 0 ) + ( x − x 0 ) + ( y − y0 )
x1 − x0 y1 − y 0
Dies ist die 3-Punkte-Form einer Ebene. Der Wert der linearen Interpolation am vierten
Punkt ist festgelegt. Daher ist diese Methode nicht geeignet zur Interpolation einer
Punktmenge, die auf einem Gitter gegebene ist.
Ingenieurmathematik 53

3.6.2 B ILINEARE I NTERPOLATION


Sind die Werte von f an vier Punkten ( x0 , y 0 ), ( x1 , y 0 ), ( x0 , y1 ), ( x1 , y1 ) bekannt,
so wird bei der bilinearen Interpolation wie folgt vorgegangen, um einen Interpolati-
[ ] [ ]
onswert an einer Stelle ( x, y ) ∈ x 0 , x1 × y 0 , y1 zu berechnen:
1. Lineare Interpolation in x:
f ( x1 , y 0 ) − f ( x0 , y 0 )
z1 ( x ) = f ( x 0 , y 0 ) + ( x − x 0 )
x1 − x0
f ( x1 , y1 ) − f ( x0 , y1 )
z 2 ( x) = f ( x0 , y1 ) + ( x − x0 )
x1 − x0
2. Lineare Interpolation in y:
z 2 ( x ) − z1 ( x )
b ( x , y ) = z1 ( x ) + ( y − y 0 )
y1 − y 0

Abbildung 10: Bilineare Interpolation


Ingenieurmathematik 54

Insgesamt erhält man:

f ( x1 , y 0 ) − f ( x0 , y 0 )
b( x, y ) = f ( x 0 , y 0 ) + ( x − x 0 ) +
x1 − x0
f ( x1 , y1 ) − f ( x0 , y1 ) f ( x1 , y 0 ) − f ( x0 , y 0 )
f ( x0 , y1 ) + ( x − x0 ) − f ( x 0 , y 0 ) − (x − x0 )
x1 − x 0 x1 − x 0
( y − y0 )
y1 − y 0
f ( x0 , y 0 )( x1 − x0 )( y1 − y 0 ) + ( x − x0 )( y1 − y 0 )( f ( x1 , y 0 ) − f ( x0 , y 0 )) + ( y − y 0 )( x1 − x0 ) f ( x 0 , y1 )
= +
(x1 − x0 )( y1 − y0 )
(x − x0 )( y − y0 )( f ( x1 , y1 ) − f (x0 , y1 )) − (x1 − x0 )( y − y0 ) f ( x0 , y 0 ) − (x − x0 )( y − y 0 )( f ( x1 , y 0 ) − f (x0 , y 0 ))
(x1 − x0 )( y1 − y 0 )
f ( x0 , y 0 )[( x1 − x0 )( y1 − y 0 ) − (x − x0 )( y1 − y 0 ) − ( x1 − x0 )( y − y 0 ) + ( x − x0 )( y − y 0 )]
= +
(x1 − x0 )( y1 − y0 )
f ( x 0 , y1 )[( y − y 0 )( x1 − x0 ) − (x − x0 )( y − y 0 )] f ( x1 , y 0 )[( x − x0 )( y1 − y 0 ) − ( x − x0 )( y − y 0 )]
+ +
(x1 − x0 )( y1 − y0 ) (x1 − x0 )( y1 − y 0 )
f ( x1 , y1 )[(x − x0 )( y − y 0 )]
=
(x1 − x0 )( y1 − y0 )
f ( x0 , y 0 )[( x1 − x )( y1 − y )] + f ( x0 , y1 )[( y − y 0 )( x1 − x )]
= +
(x1 − x0 )( y1 − y 0 )
f ( x1 , y 0 )[( x − x0 )( y1 − y )] + f ( x1 , y1 )[( x − x 0 )( y − y 0 )]
(x1 − x0 )( y1 − y 0 )

3.6.3 Z WEIDIMENSIONALE B IKUBISCHE S PLINES


Problemstellung: Gesucht ist eine möglichst glatte Fläche, die durch eine vorgegebene
Menge von Punkten ( xi , y j , u ij ) geht, wobei die ( x i , y j ) ein Rechteckgitter bilden:

a = x0 < x1 < ... < x n = b, c = y 0 < y1 < ... < y m = d


Ingenieurmathematik 55

Abbildung 11: Rechteckgitter

Die bikubische Splinefunktion S = S(x,y) wird durch folgende Eigenschaften definiert


[ENGELN-MÜLLGES, REUTTER(1990)]:

1. S ( xi , y j ) = u ij (i=0,...,n, j=0,...,m)
2. S ist stetig differenzierbar
∂2S
3. ist stetig
∂x∂y
4. In jedem Teilrechteck Rij = {( x, y ) : xi ≤ x ≤ xi +1 , y j ≤ y ≤ y j +1 } ist S
durch ein bikubisches Polynom pij gegeben:
3 3
pij ( x, y ) = ∑∑ a ijks ( x − xi ) k ( y − y j ) s
k =0 s =0

5. Zusätzlich erfüllt S noch bestimmte Randbedingungen. Häufig werden be-


stimmte partielle Ableitungen von S vorgegeben:
Ingenieurmathematik 56
∂S
( xi , y j ) = qij = aij 01
∂y
∂S
( xi , y j ) = pij = aij10
∂x
∂2S
( xi , y j ) = rij = a ij11
∂x∂y

Durch die obigen Bedingungen ist die bikubische Splinefunktion eindeutig bestimmt.

Die MATLAB-Funktion interp2 führt eine bikubische Interpolation durch:

Grobes Gitter >> [x,y]=meshgrid(-3:1:3);

Beispiel-Funktion auf
>> z=peaks(x,y);
grobem Gitter

Feines Gitter >> [xFine,yFine]=meshgrid(-3:.25:3);

>> zLin = interp2(x,y,z,xFine,yFine,'linear');


Lineare Interpolation >> mesh(x,y,z);
auf feinem Gitter >> hold on;
>> mesh(xFine,yFine,zLin+10);
Ingenieurmathematik 57

Abbildung 12: Lineare Interpolation

>> zBicubic = interp2(x,y,z,xFine,yFine,'spline');


Bikubische Interpola- >> mesh(x,y,z);
tion auf feinem Gitter >> hold on;
>> mesh(xFine,yFine,zBicubic+10);
Ingenieurmathematik 58

Abbildung 13: Bikubische Splineinterpolation

3.6.4 A NWENDUNG : V ERGRÖßERN DIGITALER B ILDER

orig = imread('test.jpg');
orig = double(orig); % in double-Werte umwandeln
size(orig)
ans =

Bild laden
670 1000 3
% Erster Index : Anzahl Zeilen
% Zweiter Index: Anzahl Spalten
% Dritter Index: 1: Rot 2: Grün 3: Blau
image(orig/255); % Bei double-Bild: Farben zwischen 0 und 1
Ingenieurmathematik 59

Abbildung 14: Original-Bild

breite = size(orig,2)
breite =
1000
Gitter, auf
dem das Ori- hoehe = size(orig,1)
ginal defi- hoehe =
niert ist: 670

[xOrig,yOrig]=meshgrid(1:breite,1:hoehe);

Bereich, der
vergrößert [xZoom,yZoom]=meshgrid(350:.2:450,350:.2:450);
werden soll:

Zoom mit % Jede Farbe einzeln


Interpolati- z1(:,:,1)=interp2(xOrig,yOrig,orig(:,:,1),xZoom,yZoom,'nearest');
onsmethode z1(:,:,2)=interp2(xOrig,yOrig,orig(:,:,2),xZoom,yZoom,'nearest');
‚nearest’ z1(:,:,3)=interp2(xOrig,yOrig,orig(:,:,3),xZoom,yZoom,'nearest');
Ingenieurmathematik 60

(stückweise image(z1/255);
konstant) >>

Abbildung 15: Vergrößerung mit Interpolationsmethode 'nearest'

z2(:,:,1)=interp2(xOrig,yOrig,orig(:,:,1),xZoom,yZoom,'spline');
z2(:,:,2)=interp2(xOrig,yOrig,orig(:,:,2),xZoom,yZoom,'spline');
z2(:,:,3)=interp2(xOrig,yOrig,orig(:,:,3),xZoom,yZoom,'spline');
Zoom mit % Hier ist nicht garantiert, dass alle Werte zwischen 0 und 255
Interpolati- % liegen
onsmethode totalMin = min(min(min(z2)));
‚spline’ z2=z2-totalMin;
totalMax = max(max(max(z2))) ;

image(z2/totalMax)
Ingenieurmathematik 61

Abbildung 16: Vergrößerung mit Interpolationsmethode 'Spline'

Professionelle Bildbearbeitungsprogramme unterstützen bikubische Splines. In man-


chen Fällen findet man weitere Spezialvarianten wie sog. S-Splines.
Ingenieurmathematik 62

AUFGABE SB4-4: BIKUBISCHE/BILINEARE INTERPOLATION

Erzeugen Sie eine Anwendung mit grafischer Oberfläche, welche die bikubische und die 
bilineare Interpolation demonstriert. Aufgabe

Mit zwei Radio Buttons soll zwischen bilinearer und bikubischer Interpolation umge-
schaltet werden können.

20 Punkte
Als Ausgangspunkt soll die Ebene durch die 16 Punkte (x , y ,0) = (i − 1, j − 1,0)
i j

(i=1,...,4, j=1,...,4) dienen.

Ihr Programm soll mit 16 Radio Buttons die Auswahl des Punktes, dessen z-Koordinate
verändert werden soll, ermöglichen. Die z-Koordinate soll mit einem Schieberegler
zwischen -5 und +5 verändert werden können. Wird der Schieberegler betätigt, so soll
sofort die interpolierte Fläche auf dem Gitter (i * 0.25, j * 0.25) (i,j=0,...,12) geplottet
werden.

Anleitung: Leider unterstützt MATLAB 6.5 noch nicht das Konzept der Button Group,
welches es erlaubt, mehrere Radio Buttons logisch zu einer Gruppe zusammenzufassen,
so dass bei Drücken eines Buttons automatisch alle anderen Buttons der Gruppe in den
Zustand „AUS“ gehen. Dieses Verhalten muss bei MATLAB 6.5 noch „zu Fuß“ pro-
grammiert werden.

Wenn Sie also MATLAB 6.5 benutzen, gehen Sie wie folgt vor:

Legen Sie dazu in der OpeningFcn eine globale Variable an, welche die Handles der
Radio Buttons enthält:

global hRadioButtons;
hRadioButtons = zeros(1,16);

In der Callback-Funktion jedes Radio Button wird das zugehörige Handle beim ersten
Aufruf initialisiert:

function radiobutton1_Callback(hObject, eventdata,


handles)
Ingenieurmathematik 63

% hObject handle to radiobutton1 (see GCBO)


% eventdata reserved - to be defined in a future
version of MATLAB
% handles structure with handles and user data
(see GUIDATA)

% Hint: get(hObject,'Value') returns toggle state of


radiobutton1
global hRadioButtons;
if hRadioButtons(1) == 0
hRadioButtons(1) = hObject;
end

Rufen Sie ferner in der Callback-Funktion eines Buttons folgende Funktion auf:

update(hRadioButtons,i); % i: Index des Radio Button

Dabei setzt die Funktion update (Datei update.m) alle Buttons außer einem auf „AUS“:

function update(hRadioButtons,i)
% Alle Buttons außer dem i-ten auf “AUS” setzen
for k=1:16
if hRadioButtons(k) == 0
continue;
end
set(hRadioButtons(k),'Value',0);
end
set(hRadioButtons(i),'Value',1);
Ingenieurmathematik 64

4 Z U S A M M E N FA S S U N G

In diesem Kapitel wurden verschiedene Verfahren der Interpolation vorgestellt. Bei der
Interpolation wird stets verlangt, dass die konstruierte Funktion durch alle vorgegebe-
nen Punkte geht. Lineare Interpolation ist die einfachste Variante. An den Stützstellen
ist die stückweise lineare Interpolation nicht differenzierbar. Zur Konstruktion glatter
Kurven greift man daher oft auf andere Verfahren zurück. Die Polynominterpolation
liefert zwar glatte Funktionen, neigt aber mit wachsender Anzahl Stützstellen zu starken
Oszillationen. Daher werden in der Praxis häufig kubische Splines eingesetzt. Diese
setzen sich aus Polynomen vom Grad 3 zusammen und kommen damit dem, was man
intuitiv unter einer möglichst glatten interpolierenden Kurve versteht, sehr nahe.

Das Konzept der kubischen Splines lässt sich auch auf Kurven in Ebene und Raum
sowie auf Flächen übertragen.

Bézier-Kurven sind ein Beispiel für die Konstruktion von Freihand-Kurven. Hier geht
es weniger um Interpolation als darum, die Form einer Kurven möglichst gut kontrollie-
ren zu können.
Ingenieurmathematik 65

5 L I T E R AT U R

Schweizer, J.: Numerik für Bioinformatiker. 2002


http://homepages.uni-tuebingen.de/juergen.schweizer/nfb.html
(zuletzt besucht am 27.10.2006)
MathWorks: Building GUIs with MATLAB. 2006.
www.mathworks.com/access/helpdesk/help/pdf_doc/matlab/buildgui.pdf
(zuletzt besucht am 01.11.2006)

Deutsche Welle: Achterbahn. Projekt Zukunft.


http://www.deutsche-welle.de/dw/article/0,2144,1789282,00.html
(zuletzt besucht am 02.11.2006)

Babovsky, H., Neundorf, W.: Numerische Approximation von Funktionen


(Mathematische Methoden des Computer Aided Geometric Design). TU Ilme-
nau, 2006.
http://www3.tu-ilmenau.de/
/site/phys/fileadmin/template/ifm/user/Neundorf/Dokumente/Lehre/num_app/n
um_app.pdf
(zuletzt besucht am 05.11.2006)

Engeln-Müllges, G., Reutter, F.: Formelsammlung zur Numerischen Mathema-


tik mit C-Programmen. BI Wissenschaftsverlag, 2. Aufl., 1990.

Sormann, H.: Numerische Methoden in der Physik. 2006


http://itp.tugraz.at/LV/sormann/NumPhysik/Skriptum/kapitel3.pdf
(zuletzt besucht am 09.11.2006)

Verfürth, R.: Einführung in die Numerische Mathematik. Vorlesungsskriptum Sommer-


semester 2005. Ruhr-Universität Bochum.
http://www.ruhr-uni-bochum.de/num1/skripten/Numerik_Einfuehrung.pdf
(zuletzt besucht am 08.11.2006)