Sie sind auf Seite 1von 77

MMK

Lehrstuhl für
Mensch-Maschine-Kommunikation Technische Universität München
Ordinarius: Prof. Dr.-Ing. habil. G. Rigoll

Technische Universität München

Matlab-Praktikum zur Vorlesung

Signaltheorie
G. Rigoll

Stand: Oktober 2019


1

Wichtiges

Dieses Dokument besteht aus den folgenden Teilen:

• Kurzanleitung zum Start des Matlab-Praktikums

• alle 4 klausurrelevanten Versuche des Matlab-Praktikums (alle Angaben und Lösungen wie
in Matlab)

• den nicht unmittelbar klausurrelevanten Exkurs zur Bildbearbeitung mit Matlab

Der Vorteil des Dokuments besteht darin, dass Sie nicht jedes Mal den gewünschten Versuch
starten müssen, wenn Sie etwas nachschauen wollen. Außerdem haben Sie hier die Möglichkeit
gezielt nach einzelnen Aufgaben zu suchen. Nutzen Sie dazu auch den Index am Ende des
Dokuments.

ABER: Dieses Dokument soll nicht das Praktikum in Matlab ersetzen. Wie Sie sicherlich
bereits aus anderen Programmiersprachen wissen, lernt man diese nicht durch das Lesen von
Dokumenten. Das selbstständige Lösen der Aufgaben (und Ausprobieren) ist essentiell für das
Verständnis der Funktionsweise von Matlab. Des Weiteren enthält dieses Dokument nicht die
Hinweise, welche im Matlab-Praktikum über den Befehl hint (siehe Weitere Hinweise:) aufgeru-
fen werden können. Zusätzlich zu diesem Praktikum wird es auch einige Zentralübungen geben,
die sich mit einigen Aufgaben aus dem Praktikum intensiv beschäftigt.

Dieses Manuskript ist ohne Gewähr!

Layout: (c) Lehrstuhl für Mensch-Maschine-Kommunikation


www.mmk.ei.tum.de

Aktualität: Oktober 2019

Ausgabe: 2. Ausgabe für Praktikumsversion 19.1

Dieses Werk ist urheberrechtlich geschützt.

Alle Rechte, auch die der Übersetzung, des Nachdrucks und der Vervielfältigung, vorbehalten.
Kein Teil dieses Werkes darf ohne rechtliche Genehmigung des Lehrstuhls für Mensch-Maschine-
Kommunikation der TU-München in irgendeiner Form (Fotokopien, Mikrofilm oder ein anderes
Verfahren), auch nicht für Zwecke der Unterrichtsgestaltung, reproduziert oder unter Verwen-
dung elektronischer Systeme verbreitet, vervielfältigt oder verarbeitet werden.
(c) Lehrstuhl für Mensch-Maschine-Kommunikation, Technische Universität München, 2019

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


2

Inhaltsverzeichnis

0 Kurzanleitung zum Start des Matlab-Praktikums 5

1 Versuch: Grundlagen 7
Aufgabe 1: Task 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Aufgabe 2a: Task 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Aufgabe 2b: Task 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Aufgabe 2c: Task 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Aufgabe 2d: Task 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Aufgabe 3: Task 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Klausuraufgabe 1: Task 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Klausuraufgabe 2: Task 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Klausuraufgabe 3: Task 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2 Versuch: Faltung 15
Aufgabe 1a: Task 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Aufgabe 1b: Task 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Aufgabe 1c: Task 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Aufgabe 1d: Task 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Aufgabe 2a: Task 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Aufgabe 2b: Task 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Aufgabe 2c: Task 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Aufgabe 3a: Task 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Aufgabe 3b: Task 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Aufgabe 3c: Task 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Aufgabe 4a: Task 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Aufgabe 4b: Task 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Klausuraufgabe 1: Task 13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Klausuraufgabe 2: Task 14 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3 Versuch: Fourier Transformation 25


Aufgabe 1a: Task 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Aufgabe 1b: Task 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Aufgabe 1c: Task 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Aufgabe 1d: Task 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Aufgabe 1e: Task 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Aufgabe 1f: Task 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Aufgabe 1g: Task 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Aufgabe 1h: Task 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Aufgabe 2a: Task 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


3

Aufgabe 2b: Task 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33


Aufgabe 2c: Task 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Aufgabe 2d: Task 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Aufgabe 2e: Task 13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Aufgabe 2f: Task 14 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Aufgabe 2g: Task 15 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Aufgabe 2h: Task 16 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Aufgabe 2i: Task 17 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Aufgabe 2j: Task 18 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Aufgabe 2k: Task 19 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Aufgabe 3a: Task 20 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Aufgabe 3b: Task 21 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Aufgabe 3c: Task 22 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Aufgabe 3d: Task 23 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Aufgabe 3e: Task 24 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Aufgabe 3f: Task 25 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Aufgabe 3g: Task 26 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Aufgabe 3h: Task 27 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Klausuraufgabe 1: Task 28 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Klausuraufgabe 2: Task 29 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Klausuraufgabe 3: Task 30 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

4 Versuch: Laplace- und z-Transformation 47


Aufgabe 1a: Task 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Aufgabe 1b: Task 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Aufgabe 1c: Task 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Aufgabe 2a: Task 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Aufgabe 2b: Task 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Aufgabe 2c: Task 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Aufgabe 2d: Task 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Aufgabe 2e: Task 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Aufgabe 3a: Task 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Aufgabe 3b: Task 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Aufgabe 3c: Task 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Aufgabe 3d: Task 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Aufgabe 3e: Task 13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Aufgabe 3f: Task 14 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Aufgabe 3g: Task 15 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Aufgabe 3h: Task 16 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Ende der Versuche: Task 17 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Klausuraufgabe 1: Task 18 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


4

Klausuraufgabe 2: Task 19 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Klausuraufgabe 3: Task 20 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

5 Exkurs: Bildverarbeitung 59
Aufgabe 1a: Task 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Aufgabe 1b: Task 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Aufgabe 1c: Task 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Aufgabe 1d: Task 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Aufgabe 2a: Task 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Aufgabe 2b: Task 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Aufgabe 2c: Task 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Aufgabe 2d: Task 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Aufgabe 2e: Task 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Aufgabe 3a: Task 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Aufgabe 3b: Task 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Aufgabe 3c: Task 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Ende des Exkurses: Task 13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

Index 76

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


5

0 Kurzanleitung zum Start des Matlab-Praktikums

Dieses Kapitel hilft Ihnen dabei, das Matlab-Praktikum zu starten und einen kurzen Überblick
über dessen Funktionen zu erhalten. Alle weiteren detaillierteren Erklärungen folgen dann im
Praktikum selbst. Um das Matlab-Praktikum starten zu können, müssen Sie folgende Schritte
durchführen:

• Installieren Sie Matlab. Für das Praktikum sind folgende Toolboxen wichtig:

– Signal Processing Toolbox

– Image Processing Toolbox

– Symbolic Math Toolbox

• Laden Sie das Matlab-Praktikum in Moodle herunter

• Starten Sie Matlab und navigieren Sie zum gespeicherten Ordner

• Starten Sie das Matlab-Skript indem sie task eingeben und Enter drücken

Erläuterungen:

Matlab installieren Sie erhalten Matlab gratis über die TUM Campus-Lizenz. Alle nötigen
Schritte dazu sind unter https://matlab.rbg.tum.de/ detailliert beschrieben. Vergessen Sie
nicht die o.g. gennanten Toolboxen zu installieren. Das Matlab-Praktikum wurde unter Win-
dows, Mac OS und Linux getestet. Sie können Ihr Betriebssystem also frei wählen. Beachten
Sie, dass das Praktikum nicht mit Octave funktioniert!

Praktikum herunterladen Loggen Sie sich auf Moodle ein und navigieren Sie zur Vorlesung
Signaltheorie. Im Bereich Materialien steht ein separater Ordner zur Verfügung, in dem die un-
terschiedlichen Versuche abgelegt sind. Laden Sie den kompletten Ordner ”Matlab”herunter.

Matlab starten Starten Sie zunächst Matlab (Sie benötigen keine Administratorrechte). An-
schließend sehen Sie auf der linken Seite eine dem Explorer nachempfundene Ordnerstruktur.
Dort navigieren Sie zu dem Ordner, den Sie im vorangegangenen Schritt heruntergeladen ha-
ben (z.B. v1). Wenn Sie sich im richtigen Ordner befinden, sollten 4 Dateien sichtbar werden:
task.p, done.p, hint.p und solution.p.

Praktikum starten In der Mitte sehen Sie eine Konsole, welche mit dem Token ’>>’ gekenn-
zeichnet ist. Tippen Sie dort task ein und bestätigen Sie mit Enter. Geschafft!

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


6

Weitere Hinweise:

• Möchten Sie eine spezifische Aufgabe bzw. Teilaufgabe starten oder wiederholen, so müssen
sie die Funktion task(n) eingeben (n entspricht dabei die Tasknummer der jeweiligen
Aufgabe). Zum Beispiel:
(Versuch 3) Aufgabe 3 c: Task 10; −→ task(10)

• Wenn Sie komplett von vorne beginnen und sämtlichen gespeicherten Fortschritt löschen
möchten, können Sie task(0) ausführen.

• Sollte Ihnen das Ergebnis der Aufgaben nicht direkt einfallen, so können Sie mit dem Befehl
hint(1), hint(2), usw. Hinweise für die Lösung erhalten. Die Hinweise sind nummeriert.
Der Befehl hint(1) zeigt den ersten Hinweis an, mit hint(2) gelangen Sie zum zweiten
Hinweis, und so weiter. Sie können sich so viele Hinweise anschauen, wie Sie möchten.
Wenn Sie sich im Command Window befinden, können Sie übrigens mit der Pfeiltaste
nach oben zu früheren Befehlen zurückkehren.

• Falls Sie partout nicht weiterkommen, können Sie sich die Musterlösung über den Befehl
solution anzeigen lassen. Die Musterlösung wird jedoch erst freigeschaltet, wenn Sie sich
bereits alle Hinweise angesehen haben.

• Sobald Sie das Praktikum starten, wird eine Datei progress.mat angelegt. Diese speichert
regelmäßig Ihren Fortschritt im Praktikum. Es ist daher ratsam, diese Datei nicht zu
verändern oder zu löschen, sofern Sie nicht von vorne beginnen möchten.

• Falls es Probleme mit der Darstellung von Umlauten oder Sonderzeichen gibt, kann Ihnen
der Befehl clear all weiterhelfen. Starten Sie danach erneut den task.

Wichtig:

Wenn Sie Fragen oder Probleme haben, schauen Sie auf Moodle in das zugehörige Forum
Signaltheorie/-darstellung und zögern Sie nicht, ggf. ein neues Thema zu erstellen. Das
Forum wird von den Zentralübungsleitern aktiv betreut. Außerdem können Sie sich mit Ihren
Kommilitonen austauschen und sich gegenseitig weiterhelfen. Bitte nutzen Sie diese Plattform,
da so alle Studenten davon profitieren können!

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


7

1 Versuch: Grundlagen

Matlab ist zu Teilen in C++ und Java geschrieben. Im Unterschied zu diesen Sprachen ist Matlab
eine geskriptete Sprache. Das bedeutet, dass kein Kompiliervorgang zur separaten Übersetzung
des Codes in Maschinencode erforderlich ist. Im Umkehrschluss kann jede Zeile ’on-the-fly’ durch
Markierung des Codes und F9 ausgeführt werden. Dies bietet viele Vorteile, aber auch einige
Nachteile.

Eine kleine Auswahl an Vor- und Nachteilen wird im folgenden kurz gegenübergestellt:

+ Code kann schnell ausgeführt und getestet werden

+ Code kann in sehr kleinen Schritten entwickelt werden

+ Code ist maschinenunabhängig und portabel

+ Fehlersuche und Debugging ist deutlich einfacher

+ Einsteigerfreundlichkeit

– oft nicht so Hardware-effizient wie C++ (insb. for-Schleifen und funktionale Syntax)

– höhere Fehleranfälligkeit bei großen Projekten (z.B. keine statische Typsicherheit)

– nicht auf jeder Plattform verfügbar (z.B. Mikrocontroller)

Auf der linken Seite des Matlab-Programms sehen Sie eine dem Explorer nachempfundene Ord-
nerstruktur. Diese dient der Navigation innerhalb des Dateisystems und ermöglicht eine intuitive
Verwaltung von Dateien und Ordnern.

Auf der rechten Seite des Matlab-Programms sehen Sie den globalen Workspace und darin de-
finierte Variablen. Zurzeit ist dieser noch leer. Wenn Sie im mittleren Bereich, dem Command
Window, eine neue Variable definieren, zum Beispiel x = 10 eintippen und Enter drücken, er-
scheint im rechten Workspace eine neue Variable mit dem Namen x und dem Wert (Value)
10. Das Zeichen ’=’ weist den Wert auf seiner rechten Seite der Variablen zu seiner linken zu.
Drücken Sie Enter, damit x = 10 automatisch eingegeben wird.

>> x = 10;

Sobald die Einführung abgeschlossen ist und der Text ”Drücken Sie eine beliebige Taste
zum Fortfahren...” nicht mehr angezeigt wird, erscheint das oben eingegebene x im rechten
Workspace.

Mit einem Doppelklick darauf können Sie es sich dann genauer anschauen. Sie werden sehen,
dass der Wert von x in einer Tabelle geschrieben ist. Dies liegt daran, dass Matlab alle Variablen
als Matrizen speichert. Das macht hier natürlich noch keinen Sinn, weil unser x nur eine einzige
Zahl, ein Skalar, ist. Wenn man aber mit Matrizen der Größe 100 × 100 rechnet, ist es oft ganz
praktisch, sich die Variable als Tabelle anzeigen zu lassen.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


8

Der eigentliche Code in Matlab wird in der Hauptkonsole in der Bildschirmmitte ausgeführt.
Doppelpfeile >> zeigen dabei an, dass Matlab alle Befehle erfolgreich abgeschlossen hat und auf
eine weitere Eingabe wartet.
Damit ist die Einführung abgeschlossen!

Aufgabe 1: Task 1

Bevor Sie Ihren eigenen Matlab-Code schreiben, beginnen wir noch mit einer kurzen Vorstel-
lung der grundlegenden Matlab-Syntax und der wichtigsten Befehle. Dazu folgen nun ein paar
intuitive Beispiele:

>> %Kommentar: die folgenden 3 Schreibweisen sind äquivalent!


>> Zeilenvektor = [1, 3, 5, 7];
>> Zeilenvektor = 1:2:7;
>> Zeilenvektor = linspace(1,7,4);

Der erste Befehl schreibt die vier Zahlen direkt in eine Zeile. Die Kommata zwischen den Zahlen
bedeuten, dass die nächste Zahl in der Tabelle/Matrix eine Position weiter rechts (also in der
nächsten Spalte) stehen soll und können auch weggelassen werden.

Der zweite Befehl sagt folgendes aus: ’Erstelle mir einen Zeilenvektor, der von 1 (linke Zahl)
bis 7 (rechte Zahl) geht, mit der Schrittweite 2 (mittlere Zahl).’ Es wird also wieder der Vektor
( )
1 3 5 7 erzeugt.

Der dritte Befehl sagt folgendes aus: ’Erstelle mir einen Vektor mit 4 Elementen (rechte Zahl) der
von 1 (linke Zahl) bis 7 (mittlere Zahl) geht, wobei der Abstand zweier benachbarter Elemente
( )
immer identisch ist.’ Erneut wird also der Vektor 1 3 5 7 erzeugt.

Das abschließende Semikolon am Ende jeder Zeile ist optional und sorgt dafür, dass die Ausgabe
des Ergebnisses auf der Konsole unterdrückt wird. Insbesondere bei größeren Datenmengen ist
es sinnvoll, dies zu unterbinden. Direkt in der gleich folgenden Aufgabe werden Sie mit den
obigen Befehlen einen 1000-elementigen Vektor erstellen. Natürlich wollen Sie sich nicht alle
1000 Elemente anzeigen lassen. Wenn Sie das doch tun wollen, dann können Sie sich wie bereits
erwähnt mit einem Doppelklick auf die entsprechende Variable im Workspace alle Vektorelemente
in einer Tabelle anzeigen lassen.

Für Debugging-Zwecke kann es machnmal aber durchaus nützlich sein, ein schnelles Feedback
zu bekommen.

Aufgabe
Erstellen Sie einen Zeilenvektor mit dem Namen t mit 1000 äquidistanten Werten zwischen 0
und 10! Sobald Sie denken, dass Sie die Aufgabe erfüllt haben, geben Sie done ein und bestätigen
Sie mit Enter. Das Skript überprüft automatisch Ihre Lösung und gibt gegebenfalls Feedback
zu Verbesserungsvorschlägen.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


9

Lösung
Zunächst sollte man erkennen, dass die Aufgabe nur mühsam mittels der Doppelpunktsyntax
’start:step:end’ lösbar ist, da man hier zunächst die exakte Schrittweite bestimmen muss.
Eine elegantere Lösung ist daher die Verwendung der Funktion linspace:

>> t = linspace(0,10,1000);

Aufgabe 2a: Task 2

MATLAB steht als Abkürzung für ’MATrix LABoratory’. Insofern ist es nur wenig verwunder-
lich, dass Matlab eine Stärke für Matrix-Operationen hat. Oft sind Programme dadurch nah an
einer mathematischen Beschreibung des Problems. Am besten lässt sich dies an einem Beispiel
illustrieren:

>> t = linspace(0,10,1000);
>> x = t.*sin(2*pi*t);

Beachten Sie, wie der Code komplett ohne Schleifen auskommt. Die Funktion sin erkennt au-
tomatisch, ob t ein Vektor ist (oder eine Matrix, etc.) und berechnet entsprechend den Sinus
für jeden Wert in t. Der ’.*’-Operator entspricht einer elementweisen Multiplikation. Dies ist
notwendig, um zwischen inneren bzw. äußeren Produkten unterscheiden zu können. Selbstver-
ständlich funktioniert dies auch für Divisionen mittels ’./’-Operator.

Hier wird also mit sin(2*pi*t) ein neuer Vektor erzeugt, der genauso lang ist wie der Zeilenvek-
tor t. Für das i-te Element des neuen Vektors wird das i-te Element des Zeitvektors genommen,
mit 2π multipliziert und an die Sinusfunktion weitergegeben. Das Resultat davon ist das i-te
Element des neuen Vektors.

Die elementweise Multiplikation ’.*’ bedeutet, dass jetzt noch jedes Element des neuen Vektors
sin(2πt) mit dem entsprechenden Element des t-Vektors multipliziert wird. Das Ergebnis ist,
davon können Sie sich gerne selbst überzeugen, wieder ein Zeilenvektor der gleichen Länge.

Hätten wir stattdessen x = t*sin(2*π*t) geschrieben (also ohne den Punkt vor der Multi-
plikation), hätte Matlab dies als Vektormultiplikation aufgefasst - was bei zwei Zeilenvektoren
allerdings einen Syntax-Fehler darstellt, da sich diese nicht als inneres oder äußeres Produkt
multiplizieren lassen.
Es folgt nun eine äquivalente Umsetzung mithilfe einer for-Schleife

>> t = linspace(0,10,1000);
>> x = zeros(size(t));
>> for iter = 1:length(t)
>> x(iter) = t(iter)*sin(2*pi*t(iter));
>> end

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


10

Machen Sie sich keine Sorgen, wenn Sie diesen Code nicht im Detail verstehen, im Laufe des
Praktikums werden Sie Schritt für Schritt alles Nötige lernen. Was Sie allerdings bereits erkennen
sollten, ist, dass die zweite Version wesentlich schwieriger zu lesen ist. Sie ist außerdem um
ein Vielfaches langsamer. Dies illustriert deutlich die Notwendigkeit, seine Programme in einer
Matlab-freundlichen Art und Weise zu programmieren. Mit der folgenden Aufgabe sollen Ihnen
diese Überlegungen näher gebracht werden.

Aufgabe
Im Folgenden gehen wir von dimensionslosen Größen aus. Erzeugen Sie analog zum Signal x
aus dem obigen ersten Beispiel ein gleichwertiges Signal y mit um einen Faktor 3 verringerter
Amplitude und einer Frequenz von 4. Berechnen Sie y mit einer zeitlichen Auflösung von min-
destens 0.01 zwischen 0 und 10 und stellen Sie das Signal in einem Plot (einem Graphen) dar.
Vergessen Sie nicht, die Achsen angemessen zu beschriften (Punktabzug in der Klausur!).

Bitte beachten Sie (auch in den folgenden Aufgaben), dass Sie die sich in Matlab öffnenden
Fenster mit den Plots nicht schließen dürfen, da die automatische Auswertung darauf zugreift.
Wenn Sie nicht mehr benötigt werden, dann werden diese Fenster automatisch geschlossen.
Sie können die Fenster aber natürlich minimieren. Achten Sie darauf, dass, wenn Sie nach dem
Minimieren etwas am Plot ändern (z.B. die Beschriftungen umbenennen), dies im bereits offenen
Fenster geändert wird und kein neues Fenster geöffnet wird.

Um alle Variablen im aktuellen Workspace zu löschen, kann der Befehl clear verwendet werden.

Lösung
Möglicherweise ist Ihnen aufgefallen, dass die Variable t aus der vorangegangenen Aufga-
benstellung nicht exakt die Vorgaben erfüllt. Sie sollten sich für die Klausur einprägen, was
die Unterschiede zwischen dem Doppelpunkt-Operator und der Funktion linspace sind,
um in jeder Situation die optimale Variante auswählen zu können. Ferner sollte Ihnen der
Unterschied zwischen Frequenz und Kreisfrequenz klar sein.

>> t = 0:0.01:10;
>> y = t/3 .* sin(8*pi*t);
>> plot(t,y);
>> xlabel('t');
>> ylabel('y(t)');
>> title('Das Signal y(t)');

Aufgabe 2b: Task 3

Nachdem Sie jetzt in der Lage sind Vektoren in Matlab zu erstellen und grundlegende Opera-
tionen mit Matrizen durchzuführen, möchten wir uns nun die Erstellung von Matrizen genauer
anschauen:

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


11

Eine Matrix wird im Command Window mit eckigen Klammern erstellt. Dabei geht man zei-
lenweise vor. Die einzelnen Elemente einer Zeile werden durch ein Leerzeichen oder durch ein
Komma getrennt. Um eine neue Zeile zu beginnen, wird ein Semikolon verwendet.

Aufgabe
Speichern Sie folgende Matrix in die Variable A:
 
1 −3 4
 
 3 −2 1
−1 2 1

Lösung
>> A = [1, -3, 4; 3, -2, 1; -1, 2, 1];

Aufgabe 2c: Task 4

Um Zeit beim Eintippen von besonders häufigen Matrizen zu sparen, gibt es auch Funktionen
mit denen man Matrizen erstellen kann. Übergibt man ihnen mehrere durch Kommata getrenn-
te Werte, wird eine Matrix mit so vielen Dimensionen erstellt, wie man dem Befehl Zahlen
übergeben hat. Die Anzahl der Komponenten in einer Dimension ist gleich dem entsprechenden
Übergabewert.

Eine Ausnahme dazu ist, wenn man nur einen einzigen Wert übergibt - dann wird eine quadra-
tische Matrix dieser Größe erzeugt. Wie Sie sicherlich bereits ahnen können, erstellt der Befehl
zeros eine Matrix, welche ausschließlich aus Nullen besteht. Der Befehl ones funktioniert analog
zu zeros nur, dass er in jede Matrixkomponente eine 1 statt einer 0 schreibt.

Aufgabe
Erstellen Sie nun eine 3×3 Matrix aus Nullen und eine 2×4×3 Matrix aus Einsen und speichern
Sie diese in die Variablen nullmatrix und einsmatrix.

Lösung
>> nullmatrix = zeros(3); % äquivalent: nullmatrix = zeros(3,3);
>> einsmatrix = ones(2,4,3);

Aufgabe 2d: Task 5

Mit dem Befehl eye kann man eine Einheitsmatrix erstellen. Übergibt man nur einen Wert, so ist
diese quadratisch. Übergibt man zwei ungleiche Werte, z.B. eye(2,3) dann ist die resultierende
Matrix ein Ausschnitt aus der Einheitsmatrix mit hier 2 Zeilen und 3 Spalten.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


12

Aufgabe
Verwenden Sie die vorgestellten Funktionen, um möglichst einfach folgende 10 × 10 Matrix
aufzubauen und in die Variable matrix zu schreiben:

 
7 3 3 3 0 0 0 0 0 0
 
3 7 3 3 0 0 0 0 0 0
 
3 0
 3 7 3 0 0 0 0 0 
 
3 3 3 7 0 0 0 0 0 0
 
0 0
 0 0 0 7 0 0 0 0 
 
0 0 0 0 0 7 0 0 0 0
 
0 0
 0 0 0 0 0 7 0 0 
 
0 0 0 0 0 0 0 7 0 0
 
0 0
 0 0 0 0 0 0 0 7 
0 0 0 0 0 0 0 0 0 7

Lösung
>> a = 7*eye(10,10);
>> untermatrix = 3*(ones(4,4) - eye(4,4));
>> b = [untermatrix, zeros(4,6); zeros(6,10)];
>> matrix = a + b;

Aufgabe 3: Task 6

In dieser Aufgabe soll nun eine einfache Verschiebung und zeitliche Skalierung eines Signals
erfolgen. Hierzu gibt es prinzipiell zwei Lösungsansätze.

1. Änderung des Signals bei gleicher Zeitachse

2. Änderung der Zeitachse bei identischem Signal

Für welche Lösung man sich entscheidet, ist abhängig von der Anwendung. Man sollte sich
vor allem darüber im Klaren sein, dass es unterschiedliche Betrachtungsweisen desselben Pro-
blems geben kann. In den meisten Fällen ist eine der beiden Varianten deutlich näher an der
tatsächlichen Problemstellung und daher zu bevorzugen.

Im obigen Beispiel ist Variante zwei recheneffizienter, da keine Neuberechnung des Signals ge-
tätigt werden muss. Mit zunehmender Signalkomplexität werden solche Vergleiche durchaus
relevant. Ein Vorteil des ersten Ansatzes hingegen ist, dass der dargestellte Zeitachsenabschnitt
unverändert ist. In einigen Fällen kann dies wünschenswert sein. Selbstverständlich lassen sich
die Ansätze auch kombinieren, indem sowohl Zeitachse als auch das Signal neu bestimmt werden.

Aufgabe
Erstellen Sie zunächst einen Signalvektor y(t) nach der folgenden Vorschrift:

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


13

{
t
2 für − 2 ≤ t ≤ 2
y(t) =
0 sonst

Verwenden Sie für das Zeitintervall mindestens 4000 Stützstellen zwischen −4 und 4 einschließ-
lich. Anschließend soll das Signal nach folgender Vorschrift verschoben bzw. skaliert werden:

z(t) = y(−2t + 4)

Implementieren Sie die Funktion z(t) einmal mit Ansatz 1) und einmal mit Ansatz 2), so dass
der folgende Code jeweils die korrekte Ausgabe liefert:

>> plot(t,z); % Ansatz 1)


>> plot(tau,y); % Ansatz 2)

In anderen Worten, bestimmen Sie z und tau mithilfe von t und y.

Lösung
Zunächst muss das unveränderte Signal y bestimmt werden:
>> t = linspace(-4,4,4000);
>> y = zeros(size(t));'
>> window = abs(t)<=2;
>> y(window) = t(window)/2;

Ansatz 1):
>> z = zeros(size(t));
>> window = abs(-2*t+4)<=2;
>> z(window) = (-2*t(window)+4)/2;

Ansatz 2):
>> tau = -t/2+2;

Zur Verifikation können wir nochmals die jeweiligen Plots darstellen (optional).
>> figure(1);
>> plot(t,z);
>> xlabel('t');
>> ylabel('z(t)');
>> title('Das Signal z(t)');
>> figure(2);
>> plot(tau,y);
>> xlabel('tau');
>> ylabel('y(tau)');
>> title('Das Signal y(tau)');

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


14

Klausuraufgabe 1: Task 7

Wie viele Elemente hat der Vektor t?

>> t = linspace(0,1,1000);

Lösung
Der Vektor t hat genau 1000 Elemente.

Klausuraufgabe 2: Task 8
( )
Erzeugen Sie mit Matlab einen Vektor y nach der Vorschrift y(t) = si πt + π2 . Verwenden Sie
diskrete Stützstellen im Abstand von 0.02 im Interval [−5, 5]. Stellen Sie das Signal y daraufhin
in einem geeigneten Plot in Matlab dar.
Hinweis: si(x) = sin(x)
x

Lösung
Beachten Sie, dass die ’Definitionslücke’ (Division durch Null) für die si( )-Funktion in diesem
Beispiel noch repariert werden muss!
» t = :0.02:5;
» tau=pi*t+pi/2;
» y = sin(tau)./(tau);
» y(tau==0) = 1;
» plot(t,y);
» xlabel(’t’);
» ylabel(’y(t)’);
» title(’Das Signal y(t)’);

Klausuraufgabe 3: Task 9

Nennen Sie zwei mögliche Ansätze, mit deren Hilfe das Signal y in Matlab zeitlich verschoben
und skaliert werden kann. Erläutern Sie nur das Konzept, es ist kein Code erforderlich.

Lösung
1) Änderung des Signals bei gleicher Zeitachse
2) Änderung der Zeitachse bei identischem Signal

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


15

2 Versuch: Faltung

Grundlagen der Faltung:


Die Faltung ist ein mathematischer Operator, der zwei Funktionen f (t) und g(t) auf eine dritte
Funktion f (t) ∗ g(t) abbildet.

(a) Mathematische Definition

(b) Veranschaulichung der Faltung

Abbildung 1: Faltung [?]

Das Signal g(t) wird an der y-Achse gespiegelt und langsam über das Signal f (t) ’geschoben’
und mit diesem multipliziert. Nach einer Integration über das Produkt erhält man die Faltung
der beiden Signale.

In der Signaltheorie hat die Faltung eine große Bedeutung, weil sich damit jedes Signal als
gewichtete Summe von Impulsen darstellen lässt.

Für die Signalverarbeitung mit linearen, zeitinvarianten Systemen (LTI-Systemen) ist die Fal-
tung noch wichtiger. Man kann ein LTI-System eindeutig durch ein einziges Signal, die sogenann-
te Impulsantwort (system response) beschreiben. Die Impulsantwort h(t) ist das Ausgangssignal
(Output), wenn das System am Eingang (Input) mit einem einzigen kurzen Impuls angeregt
wird. Kennt man die Impulsantwort eines Systems, so kann man seine Reaktion auf ein beliebi-
ges Eingangssignal x(t) durch eine einfache Faltung x(t) ∗ h(t) berechnen. Besonders anschaulich
wird dies durch das folgende Video von Herrn Prof. Loviscach von der Fachhochschule Bielefeld
dargestellt: Faltungssatz.
Damit ist diese Einführung abgeschlossen!

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


16

Aufgabe 1a: Task 1

Erstellen Sie zunächst einen Rechteckimpuls x der Höhe 2, welcher innerhalb eines Zeitinter-
valls −5 ≤ t ≤ 5 (mit 1001 Stützstellen) von −2 (eingeschlossen) bis 2 (ausgeschlossen) geht.
Erstellen Sie dafür zuerst einen geeigneten Zeitvektor t. Als nächstes erstellen Sie den Vektor
x als Vektor der gleichen Länge mit ausschließlich Nullen als Elemente. Jetzt können Sie alle
Elemente zwischen −2 (eingeschlossen) und 2 (ausgeschlossen) auf den Wert 2 (die gewünschte
Höhe) setzen.

Lösung
Genau wie in Aufgabe 3 des ersten Versuches erzeugen wir zuerst mithilfe des Befehls
linspace einen Zeitvektor, der, wie in der Aufgabenstellung gewünscht, von −5 bis 5 geht
und die Länge 1001 hat.

>> t = linspace(-5,5,1001);

Als nächstes erzeugen wir den Signalvektor x, der die gleiche Länge wie unser Zeitvektor
haben muss. Dies liegt daran, dass jedem Wert des Zeitvektors genau ein Wert unseres
Signals zugeordnet werden soll. Vorerst setzen wir alle Werte des Signalvektors mithilfe des
Befehls zeros auf 0.

>> x = zeros(size(t));

Über den Betrag können wir aus dem Zeitvektor einen Bereich window herausschneiden, der
sich von −2 (eingeschlossen) bis 2 (ausgeschlossen) erstreckt...

>> window = t >= -2 & < 2;

...und unserem Signal x innerhalb dieses Bereichs die gewünschte Höhe des Rechteckimpulses
zuordnen.

>> x(window) = 2;

Anmerkung: Natürlich hätten die letzten beiden Schritte auch in einem einzigen Schritt
funktioniert:

>> x(t >= -2 & t <= 2) = 2;

Nochmals zusammengefasst:

>> t = linspace(-5,5,1001);
>> x = zeros(size(t));
>> window = t >= -2 & < 2;
>> x(window) = 2;

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


17

Aufgabe 1b: Task 2

Erstellen Sie nun einen Rechteckimpuls y der Höhe 3, welcher sich ebenfalls innerhalb des Zeit-
intervalls −5 ≤ t ≤ 5 (wieder mit 1001 Stützstellen) von −2 bis 2 erstreckt. Verwenden Sie dafür
die Funktion rectpuls(T,W).
Hinweis: wie Sie bereits gelernt haben, kann man mithilfe von help Befehl herausfinden, wie
ein unbekannter Befehl zu verwenden ist.

Lösung
Mit der Funktion rectpuls kann man sich viel Aufwand sparen. Man muss lediglich als
Parameter übergeben, auf welchem Zeitvektor das Rechteck liegen soll (in unserem Fall
also t) sowie die gewünschte Breite (von −2 bis 2 wäre das also die Breite 4). Mit einem
entsprechenden Vorfaktor kann man die Höhe des Rechteckimpulses auf den geforderten
Wert setzen (hier: Höhe = 3):

>> y = 3*rectpuls(t,4);

Aufgabe 1c: Task 3

Dieses Praktikum ist so konzipiert, dass Ihre Ergebnisse so oft wie möglich gespeichert werden.
Es kann dennoch vorkommen, dass Sie Ihre Ergebnisse manuell speichern wollen.

Damit Sie nicht nochmals alle bereits gelösten Aufgaben wiederholen müssen, können Sie die
Befehle save und load verwenden, um einen Zwischenstand zu speichern und wieder zu la-
den. Geben Sie dafür einfach save('speicherpunkt') ein. Sie werden sehen, dass dadurch im
Current Folder auf der linken Seite eine neue Datei mit Namen ’speicherpunkt.mat’ erschienen
ist. In dieser Datei sind Ihre Variablen aus dem Workspace gespeichert. Mit einem einfachen
Klick darauf sehen Sie die in der .mat-Datei gespeicherten Variablen in einem kleinen Bereich
unterhalb des Current Folders.

Mit einem Doppelklick oder mit dem Befehl load('speicherpunkt') können Sie die gespei-
cherten Variablen in Ihren Workspace laden. Der übergebene Name, hier ’speicherpunkt’ ist
natürlich beliebig, Sie müssen nur darauf achten, ihn als string zu übergeben.

Wenn Sie also in Zukunft eine Pause einlegen wollen, sollten Sie Ihre Variablen mit save spei-
chern, bevor Sie Matlab schließen. Wenn Sie weiterarbeiten möchten, müssen Sie dann lediglich
Matlab öffnen, in den gewünschten Versuchsordner navigieren, mit task Ihre aktuelle Aufgabe
starten und mit load Ihre gespeicherten Variablen wiederherstellen.

Aufgabe
Verwenden Sie nun den Befehl tripuls(t,w), um einen Dreiecksimpuls z der Breite 4 und der
Höhe 4 zu generieren. Das Zeitintervall sei weiterhin beizubehalten.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


18

Lösung
Ganz analog ist die Funktion tripuls zu verwenden. Mit den Parametern übergibt man
wieder den grundlegenden Zeitvektor sowie die gewünschte Breite des Rechteckimpulses.
Der Vorfaktor bestimmt erneut die Höhe.

>> z = 4*tripuls(t,4);

Aufgabe 1d: Task 4

Um gleichzeitig mehrere Schaubilder übersichtlich darstellen zu können, gibt es in Matlab den


Befehl subplot. Dieser Befehl erzeugt eine figure (Rahmen), welche man gleichmäßig mit axes
(Diagrammen/Graphen) füllen kann.

>> subplot(zeilen,spalten,index);

Mit den Parametern zeilen und spalten kann man angeben, mit wie vielen Zeilen und Spalten
die figure mit den Graphen gefüllt werden soll. Der index läuft zeilenweise von links oben nach
rechts unten.

Aufgabe
Erstellen Sie nun eine figure und fügen Sie die drei oben erstellten Funktionen als Subplots in
diese ein. Die Subplots sollen in einer 2 × 3 Matrix angeordnet werden. Damit man die Graphen
besser erkennen kann, können Sie innerhalb des plot-Befehls mit LineWidth die Linienbreite
auf 2.0 stellen. Färben Sie zudem den ersten Rechtecksimpuls rot, den zweiten cyan und den
Dreiecksimpuls grün ein. Verwenden Sie den Befehl axis, um nur den Bereich −4 < x < 4 und
−1 < y < 4 anzeigen zu lassen. Geben Sie zuletzt den einzelnen Subplots mithilfe von title
entsprechende Überschriften und vergessen Sie nicht, die Achsen zu beschriften (Erinnerung:
Punktabzug in der Klausur!).

Lösung
>> figure;
>> subplot(2,3,1);
>> plot(t,x,'r','LineWidth',2.0);
>> axis([-4,4,-1,4]);
>> title('Rechteck (window)');
>> xlabel('Zeit t');
>> ylabel('x(t)');

>> subplot(2,3,2);
>> plot(t,y,'c','LineWidth',2.0);
>> axis([-4,4,-1,4]);

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


19

>> title('Rechteck (rectpuls)');


>> xlabel('Zeit t');
>> ylabel('y(t)');

>> subplot(2,3,3);
>> plot(t,z,'g','LineWidth',2.0);
>> axis([-4,4,-1,4]);
>> title('Dreieck (tripuls)');
>> xlabel('Zeit t');
>> ylabel('z(t)');

Aufgabe 2a: Task 5

Wie in anderen Programmiersprachen gibt es auch in Matlab Kontrollstrukturen wie die Ver-
zweigungsbefehle if und switch sowie die Schleifenbefehle for und while. Exemplarisch wollen
wir uns hier die for-Schleife genauer ansehen.

Man verwendet die for-Schleife, wenn man einen Befehl mehrfach ausführen will und schon zu
Beginn die gewünschte Anzahl von Iterationen kennt. For-Schleifen haben in Matlab folgende
Form:

>> for schleifenindex = vektor


>> befehl(e)
>> end

Aufgabe
Versuchen Sie nun, wie es der Lehrer des kleinen Gauß verlangte, die Summe der Zahlen von
1 bis 100 zu berechnen und speichern Sie das Ergebnis in die Variable summe. Verzichten Sie
dabei auf die von Gauß gefundene Formel und verwenden Sie stattdessen eine for-Schleife.

Lösung
>> summe = 0;
>> for i = 1:100
>> summe = summe + i;
>> end

Dieselbe Rechnung kann übrigens auch (wesentlich umständlicher) mit einer while-Schleife
implementiert werden:

>> summe = 0;
>> i = 1;

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


20

>> grenze = 100;


>> while i <= grenze
>> summe = summe + i;
>> i = i + 1;
>> end

Aufgabe 2b: Task 6

Verwenden Sie nun die for-Schleifen, um eine Faltung faltung_xy der Signale x und y, also
der beiden Rechteckimpulse, in Matlab zu implementieren. Die Formel aus der Einführung kann
Ihnen dabei helfen.

Lösung
Zunächst bereitet man die Signale vor:

>> width = length(x) + length(y) - 1;


>> t2 = linspace(-10,10,width);
>> x2 = [x, zeros(1, width-length(x))];
>> y2 = [y, zeros(1, width-length(y))];
>> faltung_xy = zeros(1, width);

Im Anschluss wird entsprechend über die Vektoren iteriert:

>> for i = 1:width


>> for j = 1:i
>> faltung_xy(i) = faltung_xy(i) + x2(j) * y2(i - j + 1);
>> end
>> end

Aufgabe 2c: Task 7

Fügen Sie den Graphen der Faltung als subplot an 4. Stelle zu Ihrer figure hinzu. Verwenden
Sie die Farbe Magenta und die Linienbreite 2.0. Sie können hier auch wieder eine Achsens-
kalierung vornehmen (Befehl axis). Vergessen Sie nicht, dem neuen Subplot einen geeigneten
Titel und sinnvolle Achsenbeschriftung zu geben (für fehlende Achsenbeschriftung gibt es
Punktabzug in der Klausur!).

Lösung
>> % Erinnerung:

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


21

>> % t2 = linspace(-10,10,length(faltung_xy));
>> subplot(2,3,4);
>> plot(t2,faltung_xy,'m','LineWidth',2.0);

>> axis([-4,4,-1,2500]);
>> title('Faltung x*y (for)');
>> xlabel('Zeit t')
>> ylabel('Faltung x(t)*y(t)');

Aufgabe 3a: Task 8

Wie Sie sicherlich bemerkt haben, ist diese Art der Faltungsberechnung sehr zeitaufwändig. Wie
auch schon bei den Rechtecks- und Dreiecksimpulsen gibt es zum Glück auch bei der Faltung
eine vordefinierte Funktion, der man lediglich die zu faltenden Signale/Funktionen übergibt und
die Faltung der beiden als Ergebnis erhält:

>> conv(signal1, signal2);

Der Funktionsname stammt von ”convolution”, dem englischen Fachbegriff für die Faltung.

Aufgabe
Verwenden Sie nun den conv-Befehl, um die Signale x und y zu falten. Die resultierende Variable
conv_xy soll als 5. Subplot in die figure eingefügt werden. Setzen Sie wieder die Linienbreite
auf 2.0, die Farbe auf schwarz. Denken Sie wieder an Titel sowie Achsenbeschriftung (letztmalige
Erinnerung: Punktabzug in der Klausur!).

Lösung
>> conv_xy = conv(x,y);
>> subplot(2,3,5);
>> plot(t2,conv_xy,'black','Linewidth',2.0);
>> axis([-4,4,-1,2500]);
>> title('Faltung conv(x,y)');
>> xlabel('Zeit t');
>> ylabel('Faltung x(t)*y(t)');

Aufgabe 3b: Task 9

Wiederholen Sie das obige Vorgehen, um eine Faltung conv_yz der Signale y und z zu berechnen
und diese als sechsten und letzten Subplot in die figure einzusetzen. Verwenden Sie erneut eine
Linienbreite von 2.0 und blau als Linienfarbe.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


22

Lösung
>> subplot(2,3,6);
>> conv_yz = conv(y,z);
>> plot(t2,conv_yz,'b','Linewidth',2.0);
>> axis([-4,4,-1,2500]);
>> title('Faltung conv(y,z)');
>> xlabel('Zeit t');
>> ylabel('Faltung y(t)*z(t)');

Aufgabe 3c: Task 10

Vergleichen Sie den Faltungsplot der zwei Rechteckimpulse x und y mit Ihren Kenntnissen aus
der Vorlesung. Überlegen Sie, woher diese Diskrepanz kommt und korrigieren Sie diese, indem
Sie einen Vektor faltung_xy_korrigiert erstellen, so dass das Ergebnis wieder der Vorlesung
entspricht!

Lösung
Je feiner der Vektor t gewählt wird, desto mehr Abtastwerte werden von den Rechtecken ver-
wendet. Vergleicht man den Code der Faltung als Schleife mit der Formel für die zeitdiskrete
Faltung, stellt man fest, dass eigentlich nur ein Wert pro Einheitsintervall [0, 1) zulässig ist.
Um diesen Fehler zu korrigieren, muss also die Auflösung des Zeitvektors t berücksichtigt
werden. Wenn beispielsweise 500 Abtastwerte pro Einheitsintervall (Ende ausgeschlossen)
vorhanden sind, wird das Ergebnis der Faltung um den Faktor 500 zu groß sein.

In unserem Fall werden 10 Einheitsintervalle abgedeckt bei insgesamt 1001 Abtastwerten


(Anfang und Ende eingeschlossen). Unser Korrekturfaktor ist also 10/(1001 − 1) = 0.01.
Wenn wir nun diesen Wert mit der Höhe h des Dreiecks faltung_xy - also mit 2000 -
multiplizieren, erhalten wir h = 2400 · 0.01 = 24. Dies entspricht nun der Höhe, die wir nach
den anfänglichen Vorüberlegungen erwartet hätten.

>> faltung_xy_korrigiert = faltung_xy * 0.01;

Aufgabe 4a: Task 11

Die Befehle tic und toc haben in Matlab die Funktion einer Stoppuhr. Mit dem Befehl tic
startet man die Zeitmessung und mit

>> stop = toc;

schreibt man die vergangene Zeit in die Variable stop. Man kann also die Zeit ermitteln, die

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


23

der Computer für die Berechnung eines Abschnitts benötigt, indem man tic vor dem zu unter-
suchenden Code und toc nach dem Code aufruft.

Aufgabe
Verwenden Sie nun tic und toc, um zu berechnen, wie lange Ihr Computer für die Faltung von
x und y mithilfe von for-Schleifen benötigt.
Schreiben Sie die benötigte Zeit in die Variable zeit_schleife.

Sie können für die Berechnung der Faltung folgenden Code übernehmen:

>> % t2 = linspace(-10,10,2001);
>> % width = length(t2);
>> % x2 = [x, zeros(1,width-length(x))];
>> % y2 = [y, zeros(1,width-length(y))];
>> % faltung_xy = zeros(1,width);

>> for i = 1:width


>> for j = 1:i
>> faltung_xy(i) = faltung_xy(i) + x2(j) * y2(i-j+1);
>> end
>> end

Lösung
>> tic;
>> for i=1:width
>> for j=1:i
>> faltung_xy(i) = faltung_xy(i) + x2(j)*y2(i-j+1);
>> end
>> end
>> zeit_schleife = toc;

Aufgabe 4b: Task 12

Gehen Sie analog vor, um die Dauer für die Berechnung der conv-Funktion auf x und y zu
ermitteln. Speichern Sie die benötigte Zeit in die Variable zeit_funktion. Vergleichen Sie die
beiden Berechnungszeiten. Was fällt Ihnen auf?

Lösung
>> tic;
>> conv_xy = conv(x,y);
>> zeit_funktion = toc;

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


24

Wenn man die beiden Zeitwerte vergleicht, erkennt man, dass die Berechnung einer Faltung
mithilfe der vordefinierten Funktion conv um ein Vielfaches schneller ist, als die manuelle
Berechnung über for-Schleifen.
Dies ist kein Sonderfall! Vordefinierte Matlab-Funktionen sind numerisch optimiert, das
heißt, sie benötigen minimale Rechen- und Speicherkapazitäten. Wenn man ein Matlab-
Programm schreiben möchte, sollte man deshalb immer zuerst herausfinden, ob es dafür
nützliche Funktionen gibt.

Klausuraufgabe 1: Task 13

Schreiben Sie Matlab-Code, der einen um den Ursprung zentrierten Rechteckimpuls der Breite
4 und Höhe 2 erzeugt. Verwenden Sie den Bereich −3 ≤ t ≤ 3 mit exakt 5000 Stützstellen.
Stellen Sie den Impuls anschließend geeignet in einer Grafik dar!

Lösung
» t = linspace(-3,3,5000);
» r = 2*rectpuls(t,4);
» plot(t,r);
» xlabel(’t’);
» ylabel(’2[u(t+2)-u(t-2)]’);
» title(’Rechteck’);

Klausuraufgabe 2: Task 14

Mit welcher Funktion kann man in Matlab eine Faltung zweier Zeitsignale x(t) und y(t) berech-
nen? Auf was ist dabei zu achten?

Lösung
Man kann die Funktion conv() verwenden, z.B.:

>> conv(x,y);

Abhängig von der Auflösung des verwendeten Zeitvektors muss das Ergebnis noch skaliert
werden.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


25

3 Versuch: Fourier Transformation

In diesem Versuch widmen wir uns der Diskreten Fourier Transformation (DFT). Wir lernen
anhand von Audiosignalen, wie Signale allgemein in Matlab dargestellt werden können und
wie man mit ihnen arbeiten kann. In der letzten Aufgabe dieses Versuches wenden wir die
Erkenntnisse aus den beiden ersten Aufgaben an, um ein Audiosignal mithilfe der DFT genauer
zu analysieren.
Dabei werden Sie anhand konkreter Anwendungen Einblicke erhalten, wie diese Methoden in
der Praxis eingesetzt werden.

Signale liegen auf Computern in zeitdiskreter Form vor. Das bedeutet, dass sie keine stetigen
Kurven sind, sondern nur zu bestimmten, diskreten Zeitpunkten Werte enthalten. Dies hängt
unter anderem damit zusammen, wie die meisten Signale erzeugt werden. Signale haben ihren
Ursprung oft in der physikalischen Welt; Sprachsignale sind beispielsweise Druckschwankungen
in der Luft, die als Schallwellen von einem Mikrofon gemessen werden können. Das Mikro-
fon misst dabei in kurzen Zeitabständen die Lautstärke des Sprachsignals. Am Ende liegt das
Sprachsignal also als Tabelle vor, in der jedem Mess- bzw. Abtastzeitpunkt ein Lautstärkewert
zugeordnet ist. Dies gilt ebenso für viele andere Arten von Signalen. Sie existieren als physi-
kalische Größe, die zeitdiskret gemessen werden kann, dies nennt man Abtastung. Nach dem
Abtastvorgang liegt das Signal als Tabelle (oder Vektor) von Zahlenwerten vor. Nur noch die
Beschriftung der Spalten sagt etwas über den Ursprung des Signals aus. Hierbei liegt die wohl
wichtigste Erkenntnis der Signaldarstellung und Signalverarbeitung:

Signale können in einer einheitlichen Form als Tabelle von abgetasteten Werten dargestellt wer-
den, unabhängig von der physikalischen Größe, die sie beschreiben (Lautstärke, Temperatur,
Druck, ...).

Oft lassen sich diese Wertefolgen mithilfe einer mathematischen Funktion beschreiben. Da die
anfangs verschiedenartigen Signale nun in einer einheitlichen Form dargestellt werden können,
werden sie auch einheitlich mithilfe von mathematischen Operationen bearbeitet. Man kann al-
so ein mathematisches Instrumentarium zusammenstellen, mit dem sich sämtliche Formen von
Signalen analysieren lassen. Diese allgemeinen Werkzeuge bilden die Grundlage der Signalver-
arbeitung.

Grundlagen zur Fourier-Ttransformation:


Mithilfe der Fourier-Transformation (FT) lassen sich kontinuierliche Signale in ihr kontinu-
ierliches Spektrum zerlegen. Die Diskrete Fourier-Transformation (DFT) hingegen bildet ein
zeitdiskretes, endliches (periodisch fortgesetztes) Signal auf ein diskretes Frequenzspektrum ab.
Wie wir im folgenden Versuch sehen werden, wird die DFT verwendet, um die Frequenzen und
Amplituden eines abgetasteten Signals zu bestimmen.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


26

(a) Kontinuierliche
Fourier-Transformation [?]

(b) Grafische Veranschaulichung[?]

Abbildung 2: Fourier-Transformation

Sehen Sie sich die Grafik genau an und versuchen Sie zu erkennen, wie das rot hinterlegte
Zeitsignal in mehrere Sinussignale mit unterschiedlichen Frequenzen zerlegt wird. Diese drei
Frequenzen korrespondieren mit den drei Maxima im blau hinterlegten Frequenzspektrum.

Aufgabe 1a: Task 1

Mithilfe der diskreten Fourier Transformation lässt sich ein Signal in seine Bestandteilen aus
Sinus- und Cosinusfunktionen zerlegen. Um dies genauer zu untersuchen, werden wir uns zuerst
ein solches Signal aus mehreren trigonometrischen Basisfunktionen zusammensetzen und uns
dann ansehen, wie man mithilfe der DFT aus diesem Signal die Basisfunktionen zurückgewinnen
kann.

Aufgabe
Erstellen Sie zunächst die drei Cosinus-Signale a, b und c:

• Die Funktion a habe die Amplitude 3, die Frequenz 20 und eine Phase von 0.2.

• Die Funktion b habe die Amplitude 1, die Frequenz 30 und eine Phase von −0.3.

• Die Funktion c habe die Amplitude 2, die Frequenz 40 und eine Phase von 2.4.

Die Funktionen sollen dabei zeitdiskret (d.h. abgetastet) vorliegen. Später werden wir uns noch
genauer mit der Abtastung von Signalen beschäftigen. An dieser Stelle ist nur wichtig, den
grundlegenden Mechanismus der Abtastung zu verstehen. Die Abtastfrequenz fs sei hier 100.
Das bedeutet, dass 100 Mal pro Sekunde abgetastet wird. Unser Zeitvektor in Matlab besitzt
also eine Auflösung von 0.01.

Verwenden Sie für die Aufgabe den folgenden Zeitvektor t.

>> fs = 100;
>> t = 0 : 1/fs : 1.5-1/fs;

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


27

Lösung
>> % fs = 100;
>> % t = 0 : 1/fs : 1.5-1/fs;
>> a = 3*cos(2*pi*20*t + 0.2);
>> b = cos(2*pi*30*t - 0.3);
>> c = 2*cos(2*pi*40*t + 2.4);

Aufgabe 1b: Task 2

Setzen Sie nun die einzelnen Basisfunktionen zu einem Gesamtsignal x zusammen. Öffnen Sie
eine figure, die in zwei Spalten und zwei Zeilen unterteilt sein soll, und setzen Sie den Graphen
von x an die Stelle links oben.

Lösung
>> x = a + b + c;
>> figure;
>> subplot(2,2,1);
>> plot(t,x);
>> xlabel('t');
>> ylabel('x(t)');
>> title('Das Signal x(t)');

Aufgabe 1c: Task 3

Wenn man den Befehl plot auf ein diskretes Signal anwendet, wird es interpoliert und als
zusammenhängende Kurve dargestellt. Korrekter wäre es, das Signal als Aneinanderreihung
seiner einzelnen Werte darzustellen. Dafür verwendet man den Befehl stem.

Aufgabe
Setzen Sie den Graphen von x, der sich mit dem Befehl stem ergibt, an die rechte obere Ecke
Ihrer figure und wählen Sie eine diskrete Zeitachse beginnend mit n = 1!

Lösung
>> subplot(2,2,2);
>> stem(x);
>> xlabel('n');
>> ylabel('x[n]');
>> title('Das Signal x[n]');

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


28

Aufgabe 1d: Task 4

Der Befehl, mit dem in Matlab die Diskrete Fourier Transformation (DFT) durchgeführt wird,
heißt fft. Der Befehl steht für Fast Fourier Transform (FFT), welcher ein besonders effizienter
Algorithmus ist, um die DFT zu berechnen. Häufig werden deshalb FFT und DFT synonym
verwendet, da heutzutage praktisch jede DFT als FFT implementiert ist.

Abbildung 3: Fast Fourier-Transformation

Zunächst wird das kontinuierliche Zeitsignal x(t) in n Samples abgetastet. Damit lässt sich das
Integral der kontinuierlichen FT (Gleichung 1) in eine Summe (Gleichung 2) über alle Samples
umformulieren.
Aufgrund der nur zu diskreten Zeiten vorhandenen Daten wird die DFT nur für Vielfache der

Grundfrequenz ω = nT (siehe Gleichung 3) ausgewertet. Damit kann Gleichung 2 in die Formel
für die FFT (Gleichung 4) umgeschrieben werden. Gleichung 5 ist die Formel der inversen FFT.
Das erste Element im Frequenzbereich X[1] entspricht dem Gleichanteil bzw. dem Mittelwert
des diskreten Signals x[i].

Aufgabe
Berechnen Sie die DFT des Signals x und speichern Sie das Ergebnis in der Variablen X. Ver-
gleichen Sie die Länge der Signalvektoren x und X und auch die Wertebereiche.

Lösung
>> X = fft(x);

Sowohl das ursprüngliche Signal x als auch dessen Diskrete Fourier Transformierte X be-
stehen aus 150 Komponenten. Während die Komponenten von x reellwertig sind, sind die
Komponenten von X komplexe Zahlen.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


29

Aufgabe 1e: Task 5

Wie Sie in der letzten Teilaufgabe herausgefunden haben, sind die Werte von X alle komplex.
Außerdem sollte ihnen aufgefallen sein, dass viele Werte in X betragsmäßig sehr klein sind. Falls
Sie dies noch nicht erkannt haben, schauen Sie sich die Elemente von X mit einem Doppelklick
auf X oben rechts in einer Tabelle an.

Komplexe Zahlen lassen sich auf zwei Arten darstellen:

1. durch Real- und Imaginärteil

2. durch Betrag und Phase

In der Signalverarbeitung wird meist die zweite Darstellungsart bevorzugt. Unser X hat momen-
tan jedoch noch die erste Darstellungsart mit Real- und Imagniärteil.

Aufgabe
Die sehr kleinen Betragswerte in X sind eigentlich exakt Null und entstehen durch numerische
Ungenauigkeiten (bedingt durch die Quantisierung) bei der Berechnung der FFT. Dieses un-
erwünschte Quantisierungsrauschen hat insbesondere auf die Phase einen großen Einfluss, da
dort quasi-zufällige Werte entstehen, obwohl eigentlich gar kein Signal exisitert. Sie müssen also
zunächst das Quantisierungsrauschen in X entfernen. Setzen Sie dazu alle Werte in X auf Null,
deren Betrag kleiner als 10−10 ist.

Plotten Sie anschließend den Betrag und die Phase des duch die DFT erhaltenen Signals X in
die zweite Zeile Ihrer figure. Der Graph zum Betrag soll sich im linken subplot befinden, der
zur Phase rechts. Erstellen Sie dafür zunächst zwei neue Vektoren X_betrag und X_phase.

Hilfreiche Befehle für diese Aufgabe sind abs und angle.

Lösung
Zunächst wird das Quantisierungsrauschen entfernt:

>> X(abs(X) < 1e-10) = 0;

Anschließend werden Betrag und Phase bestimmt und jeweils in die figure eingefügt:

>> X_betrag = abs(X);


>> X_phase = angle(X);

>> subplot(2,2,3);
>> stem(X_betrag,'r');
>> xlabel('Frequenz-Bins');
>> ylabel('Betrag');
>> title('Der Betrag von X');
>> subplot(2,2,4);
>> stem(X_phase,'g');

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


30

>> xlabel('Frequenz-Bins');
>> ylabel('Phase');
>> title('Die Phase von X');

Aufgabe 1f: Task 6

Mithilfe der Betrags- und Phasengraphen kann man nun wieder auf die Eigenschaften des An-
fangssignals x zurückschließen. In der Praxis stellt sich dieses Problem häufig folgendermaßen:

Ein unbekanntes Signal ist gegeben (oft in Form von Abtastpunkten) und man möchte nun
herausfinden, welche Frequenzanteile im Signal vorhanden und wie stark diese ausgeprägt sind.
Außerdem möchte man herausfinden, mit welchem Phasenwinkel sie behaftet sind.

In unserem Beispiel kennen wir die genaue Funktion, und damit alle Frequenzen, Amplituden
und Phasen des Signals bereits. Dies dient hier nur zum Zweck der Überprüfung. Wir nehmen
also an, dass der Vektor x ein Signal aus Abtastpunkten sei, welches von uns genauer untersucht
werden soll. Den ersten Schritt sind wir bereits gegangen, indem wir die DFT von x berechnet
und als Betrags- und Phasendiagramm dargestellt haben.

Das Betragsspektrum sagt aus, welche Frequenzwerte (x-Achse) wie stark (y-Achse) im Ur-
sprungssignal vorhanden sind. Nur sind die Achsen noch nicht korrekt skaliert. Auf der x-Achse
stehen nicht direkt die Frequenzen, sondern sogenannte ”Bins”. Nach dem Abtasttheorem von
Nyquist und Shannon ist die höchste rekonstruierbare Frequenz fg = f2s . Das bedeutet, dass die
linke Hälfte der Bins die Frequenzen von einschließlich 0 bis ausschließlich f2s = 50 Hz darstellen.
Also repräsentiert ein Bin jeweils ein Frequenzband von 50 2
75 Hz = 3 Hz.

Alle Bins nach der Grenze fg = f2s = 50 Hz repräsentieren nicht wirklich höhere Frequenzen (das
ist schließlich nach Nyquist-Shannon nicht möglich!), sondern die jeweils gespiegelten negativen
Frequenzen. Konkret heißt dies, dass der 76-te Bin nicht 50 23 Hz, sondern −50 Hz darstellt. Der
nächste Bin entsprechend −49 13 Hz, und so weiter bis zum 150-ten Bin für − 23 Hz.

Augabe
Führen Sie nun einen neuen skalierten Frequenzvektor s ein, welcher die oben beschriebene
Problematik berücksichtigt und korrigieren Sie entsprechend die Frequenzachse (Abszisse) im 3.
Subplot.

Lösung
>> s = [0 : 2/3 : 50-2/3, -50 : 2/3 : -2/3];
>> % s = 2/3 * [0 : 74, -75 : 1 : -1]; Alternative:

>> subplot(2,2,3);
>> stem(s,X_betrag,'r');

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


31

>> xlabel('Frequenzanteile in Hz');


>> ylabel('Amplitude');
>> title('Die Amplitude von X');
>> subplot(2,2,4);
>> stem(s,X_phase);
>> xlabel('Frequenzanteile in Hz');
>> ylabel('Phase');
>> title('Die Phase von X');

Aufgabe 1g: Task 7

Schauen Sie sich das Betragsspektrum genauer an. Sie werden erkennen, dass es auf der linken
Seite aus drei Spitzen besteht, die rechts gespiegelt sind. Wenn die erste Spitze bei 20 Hz ist,
so ist die gespiegelte Spitze bei −20 Hz. Diese Spitzen im Betragsspektrum repräsentieren die
drei unterschiedlichen im Signal gefundenen Sinus- bzw. Cosinus-Signale, welche wir ursprüng-
lich hinzugefügt hatten. Die Amplituden dieser Schwingungen entsprechen nicht den erwarteten
Amplitudenwerten. Dies liegt daran, dass sich die DFT für kleiner werdende Abtast-Abstände
immer mehr an eine zeitkontinuierliche FT annähert. Dadurch wird aus einem anfänglichen
Delta-Impuls mehr und mehr ein Dirac-Impuls mit unendlicher Höhe.

Aufgabe
Natürlich wird der Wert ∞ dabei nie erreicht, aber dieser Vergleich verdeutlicht den Übergang
von DFT zur FT und umgekehrt. Um diesen Unterschied zu kompensieren, wollen wir eine andere
Skalierung der Werte vornehmen. Bestimmen Sie dazu die drei Spitzenwerte im Betragsspektrum
und vergleichen Sie diese mit den tatsächlichen Amplituden der Teilsignale von x.

Mit welchem Korrekturfaktor korrektur muss man das Spektrum von X_betrag demnach mul-
tiplizieren, damit das Signal die tatsächlichen Amplituden der Signale widerspiegelt?
Speichern Sie diesen Korrekturfaktor in der Variable korrektur und korrigieren Sie damit
X_betrag und entsprechend den dritten Subplot.

Lösung
>> amplitude1 = X_betrag(s==20); % Tatsächlich: 225, Erwartet: 3
>> amplitude2 = X_betrag(s==30); % Tatsächlich: 75, Erwartet: 1
>> amplitude3 = X_betrag(s==40); % Tatsächlich: 150, Erwartet: 2

>> % Daraus folgt:


>> korrektur = 1/75;
>> X_betrag = X_betrag*korrektur;
>> subplot(2,2,3);

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


32

>> stem(s,X_betrag,'r');
>> xlabel('Frequenzanteile in Hz');
>> ylabel('Korrigierte Amplitude');
>> title('Die korrigierte Amplitude von X');

Es ist übrigens kein Zufall, dass der Korrekturfaktor genau der halben Länge des Vektors
entspricht. Mit einem Blick auf die Dokumentation des Befehls fft wird auch klar, warum!

>> doc fft

Aufgabe 1h: Task 8

Natürlich kann man auch Signale aus dem Frequenzbereich zurück in den Zeitbereich transfor-
mieren. Dies geschieht über die Inverse Diskrete Fourier Transformation (IDFT), die in Matlab
mit dem Befehl ifft durchgeführt wird.

Aufgabe
Verwenden Sie die Funktion ifft, um das Signal X aus dem Frequenzbereich in den Zeitbereich
zurück zu transformieren, und speichern Sie das resultierende Signal in der Variablen x_zurueck.
Setzen Sie einen Graphen des neuen Signals auf Position 2 der figure und vergleichen Sie es
mit dem ursprünglichen Signal x.

Lösung
>> x_zurueck = ifft(X);
>> subplot(2,2,2);
>> plot(t, x_zurueck);
>> xlabel('t');
>> ylabel('x(t)');
>> title('Rücktransformiertes Signal');

Aufgabe 2a: Task 9

In dieser zweiten Teilaufgabe wollen wir uns am Beispiel von Audiosignalen eine Art von Signalen
genauer anschauen und lernen, wie man damit in Matlab arbeiten kann [?].

Im Ordner zu Versuch 3 finden Sie drei verschiedene Audiodateien (drums, guitar und bass) mit
der geläufigen Endung wav [?]. Mit dem Befehl

>> [drums,fs] = audioread('drums.wav');

können Sie die Audiodatei drums.wav in Matlab einlesen und in der Variablen drums speichern.
Wie bei allen Variablen können Sie sich danach durch einen Doppelklick auf drums im Workspace

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


33

von Matlab die Variable in Form einer Tabelle genauer ansehen. Dabei werden Sie erkennen,
dass die Variable drums des eingelesenen Audiosignals genau aus einer Spalte von Zahlen besteht.
Alternativ kann man dies auch mit dem Befehl size(drums) herausfinden:

>> size(drums) = 1182873 1

Die erste Zahl steht für die Anzahl der Elemente in der ersten Dimension (die Anzahl der Zeilen)
und die zweite Zahl steht für die Anzahl der Elemente in der zweiten Dimension (die Anzahl
der Spalten). Die Anzahl der Spalten des drums-Signals ist damit also 1, das bedeutet: drums
ist ein Spaltenvektor.

Eindimensionale Signale (z.B. Audiosignale f (t)) werden in Matlab als Vektoren gespeichert;
zweidimensionale Signale (z.B. Bilder f (x, y)) als 2D-Matizen; dreidimensionale Signale (z.B.
Videos f (x, y, t)) als 3D-Matrizen. Die Elemente der Vektoren/Matrizen sind dabei jeweils die
gemessenen/abgetasteten physikalischen Größen des Signals. Bei Audiosignalen also die Laut-
stärke und bei Bildern die Intensität.

Die Tabelle der Variable drums wurde erzeugt, indem das Audiosignal mit der Abtastfrequenz-
quenz fs abgetastet wurde. Das heißt, dass in jeder Sekunde die Lautstärke des Signals 44100
mal gemessen, auf einen Wert zwischen -1 und 1 normiert und anschließend in die Tabelle ge-
schrieben wurde.

Aufgabe
Speichern Sie nun, wie oben gezeigt, die Audiodatei drums.wav in die Variable drums.
Die Funktion audioread übergibt neben dem Signalvektor auch noch die dem Signal zugrunde
liegende Abtastfrequenz, die Sie in die Variable fs speichern sollen.

Lösung
>> [drums, fs] = audioread('drums.wav');

Aufgabe 2b: Task 10

Man kann sich in Matlab Audiosignale auch direkt anhören. Häufig wird dafür der Befehl sound
verwendet. Wir wollen in diesem Versuch jedoch den mächtigeren Matlab-Befehl audioplayer(signal,
fs) verwenden, da man damit das Abspielen auch stoppen kann.

Aufgabe
Spielen Sie sich mit den folgenden Befehlen das Signal drums vor. Natürlich sollten Sie stop(player1)
erst eingeben, wenn Sie die Audiowiedergabe beenden wollen.

>> player1 = audioplayer(drums, fs);


>> play(player1)
>> % nun etwas warten
>> stop(player1)

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


34

Lösung
>> player1 = audioplayer(drums,fs);
>> play(player1);
>> % nun etwas warten
>> stop(player1);

Aufgabe 2c: Task 11

Berechnen Sie die Dauer des Audiosignals drums in Sekunden und speichern Sie es in eine
Variable mit dem Namen dauer.

Erstellen Sie daraufhin einen Vektor drums_track, der auf dem drums-Signal basiert, aber nur
vom Beginn der 11. Sekunde bis zum Ende der 20. Sekunde geht (jeweils einschließlich!).
Der Vektor drums_track ist demzufolge genau 10 Sekunden lang.

Lösung
>> dauer = length(drums)/fs;
>> drums_track = drums(fs*10+1 : fs*20);

Aufgabe 2d: Task 12

Plotten Sie nun drums_track. Sie müssen hier nicht unbedingt einen Zeitvektor erstellen, wenn
dem plot-Befehl kein Zeitvektor übergeben wird, so wird der Vektor gegen seinen Index geplot-
tet.

Lösung
>> plot(drums_track);
>> xlabel('Abtastwerte');
>> ylabel('normierte Lautstärke');
>> title('Die normierte Lautstärke des Audiosignals

Sie können im plot wunderbar erkennen, wie nacheinander verschiedene Töne gespielt werden
und danach langsam abklingen. Wenn Sie möchten, können Sie mit das verkürzte Signal
abspielen lassen:

>> player1_track = audioplayer(drums_track,fs);


>> play(player1_track);

Währenddessen können Sie anhand des Plots vergleichen, an welcher Stelle sich das Signal
gerade befindet. Hören Sie die gleiche Anzahl an Tönen, wie sie im Plot erkennbar sind?

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


35

Aufgabe 2e: Task 13

Wir haben vorhin festgestellt, dass Audiosignale in Matlab als Vektoren gespeichert werden, die
die normierten Lautstärken zu den jeweiligen Abtastzeitpunkten enthalten. Vektoren können als
eindimensionale Matrizen betrachtet werden - und auf die Behandlung eben dieser ist Matlab
optimiert, was sich wiederum im Namen Matrix Laboratory widerspiegelt.

Aufgabe
Die wohl einfachste Operation, die man mit Vektoren durchführen kann, ist die Multiplikation
mit einem Skalar. Überlegen Sie sich, was wohl mit dem Audiosignal geschieht, wenn Sie es mit
dem Faktor 4 multiplizieren. Wird man den Unterschied heraushören können?

Testen Sie daraufhin Ihre Vermutung, indem Sie das Signal drums_track mit 4 multiplizieren
und in der Variable drums_mal4 abspeichern. Dieses neue Signal können Sie dann abspielen,
indem Sie einen neuen audioplayer mit dem Namen player2 erstellen und diesen mit der
play-Funktion abspielen.

Lösung
>> drums_mal4 = 4*drums_track;
>> player2 = audioplayer(drums_mal4,fs);
>> play(player2);
>> % hörbar lauteres Signal
>> stop(player2);

Aufgabe 2f: Task 14

Nachdem wir die Lautstärke unseres Soundtracks verändert haben, wollen wir nun die Abspielge-
schwindigkeit verändern. Dies lässt sich durch eine Änderung der Abtastfrequenz im Audioplayer
erreichen, ohne dabei tatsächlich die Abtastrate des Signals zu verändern.

Aufgabe
Wenn die Abtastfrequenz des Audioplayers verdoppelt wird, wird der Soundtrack dann lang-
samer oder schneller abgespielt? Stellen sie zuerst eine Vermutung auf und prüfen Sie diese
mit einem player3, indem Sie der Funktion audioplayer neben dem drums_track-Signal die
doppelte Abtastfrequenz übergeben. Speichern Sie ihre Antwort, also entweder ’schneller’ oder
’langsamer’ in einer neuen Variable ergebnis. Die einfachen Anführungszeichen sind nötig, um
zu kennzeichnen, dass es sich um einen String und nicht um einen Variablennamen handelt.

Lösung
>> player3 = audioplayer(drums_track,2*fs);
>> play(player3);

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


36

>> % Signal anhören


>> stop(player3);
>> ergebnis = 'schneller';

Wenn in einer Sekunde zweimal so viele Abtastpunkte abgespielt werden, ist man in der
Hälfte der Zeit bereits am Ende des Signal-Vektors angelangt. Demnach wird das Audiosignal
doppelt so schnell abgespielt.

Aufgabe 2g: Task 15

Wenn Sie sich an die Vorlesung ’Lineare Algebra’ aus dem ersten Semester erinnern, dann
wissen Sie, dass zwei elementare Operationen mit Vektoren die Skalarmultiplikation und die
Vektoraddition sind. Die Skalarmultiplikation haben wir bereits kennengelernt. Durch sie wird
die Lautstärke eines Audiosignals verändert.

Aufgabe
Nun wollen wir uns der Vektoraddition widmen. Dafür benötigen wir nun die anderen beiden
Audiosignale bass.wav und guitar.wav. Lesen Sie zunächst diese beiden Signale analog zur Auf-
gabe 2a) mit dem Befehl audioread ein und speichern Sie diese in den Variabeln bass und
guitar ab.

Da wir nur Vektoren gleicher Länge addieren können, müssen wir zunächst jeweils einen Ab-
schnitt aus den beiden Audiosignalen herausschneiden, der genauso viele Abtastwerte besitzt,
wie unser drums_track. Erstellen Sie nun also zwei Vektoren guitar_track und bass_track,
die wieder vom Beginn der 11. Sekunde bis zum Ende der 20. Sekunde gehen.

Lösung
>> guitar = audioread('guitar.wav');
>> bass = audioread('bass.wav');
>> guitar_track = guitar(fs*10+1 : fs*20);
>> bass_track = bass(fs*10+1 : fs*20);

Aufgabe 2h: Task 16

Addieren Sie nun die drei Signale drums_track, guitar_track und bass_track und speichern
Sie das Ergebnis in der neuen Variablen composition. Erstellen Sie einen player4 mit dem
Signal von composition und fs und hören Sie sich das Resultat an.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


37

Lösung
>> composition = drums_track + guitar_track + bass_track;
>> player4 = audioplayer(composition,fs);
>> play(player4);
>> % Komposition anhören
>> stop(player4);

Aufgabe 2i: Task 17

Weil diese Komposition so schön ist, wollen wir, dass sie gleich dreimal wiederholt wird. Erstellen
Sie eine Variable comp_repeat, in der sich die Variable composition dreimal wiederholt.
Dafür stehen Ihnen grundsätzlich 2 verschiedene Möglichkeiten zur Verfügung:

1. Mehrfache Aneinanderreihung des Vektors composition

2. Addition von entsprechend verzögerten Vektoren composition

Aufgabe
Zunächst soll Variante 2 anhand eines einfachen Beispiels durchgeführt werden: Gegeben sei ein
Signal x = (1:4)'. Verzögern Sie das Signal um 4 Stellen und speichern Sie es in der Variablen
y. Anschließend addieren sie die Signale x und y, um das Signal z zu erhalten. Dieses Signal soll
dann einer Wiederholung des Signals x entsprechen.

Nutzen Sie danach eine der beiden Techniken, um composition dreimal zu wiederholen und in
comp_repeat zu speichern. Erstellen Sie dann einen player5 und hören Sie sich das Resultat
an.

Lösung
>> x = (1:4)';
>> y = [zeros(4,1); x];
>> z = [x; zeros(4,1)] + y;

>> comp_repeat = [composition; composition; composition];

>> player5 = audioplayer(comp_repeat,fs);


>> play(player5);
>> % Signal anhören
>> stop(player5);

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


38

Aufgabe 2j: Task 18

Alternativ hätte man für die Verkettung des Signals composition auch den Matlab-Befehl
repmat(A,M,N) verwenden können. Wie der Name andeutet, wiederholt repmat die Matrix A in
einem M×N Raster. In unserem Fall wäre die Lösung mit repmat:

>> repmat(composition,3,1);

Aufgabe
Die folgende Aufgabe soll Ihnen die Anwendung des repmat-Befehls näherbringen: Erzeugen Sie
eine Matrix D, welche wechselnde Einträge 1 und −1 besitzt, bei einer Gesamtgröße von 200×200
Elementen. Nutzen Sie dafür den soeben vorgestellten Befehl repmat.

Lösung
>> D = repmat([1, -1; -1, 1], 100, 100);

Aufgabe 2k: Task 19

Ein weiterer wichtiger Befehl ist B = reshape(A,sz).


Damit lässt sich die Matrix A in eine Matrix B mit einer anderen Dimension umwandeln. Der
Vektor sz gibt dabei die Dimension von B an - also sz = size(B);. Dabei muss beachtet
werden, dass die Anzahl der Elemente von A und B übereinstimmen.

Einen Sonderfall des reshape-Befehls kennen Sie bereits - den Colon-Operator (:). Dieser kann
mithilfe des reshape-Befehls folgendermaßen dargestellt werden:

>> B = reshape(A,[numel(A),1]);

Mit der Funktion numel(A) wird die Anzahl der Elemente der Matrix A ausgelesen.

Aufgabe
Erstellen Sie eine Matrix E, deren Elemente von links nach rechts jeweils um 2 zunehmen. Die
Matrix soll mit 0 starten, 13 Zeilen und 17 Spalten besitzen. Wenn das Ende einer Zeile erreicht
wurde, so geht es in der darauffolgenden Zeile wieder von vorne los. Die folgende Matrix illustriert
diese Eigenschaften für 4 Zeilen und 5 Spalten:
 
0 2 4 6 8
 
10 12 14 16 18
 
20 22 24 26 28
 
30 32 34 36 38

Ein hilfreicher Befehl für diese Aufgabe ist transpose(A), der auch kurz mit A.’ angewendet
werden kann. Im Unterschied zu dem ähnlichen Befehl ctranspose(A) (Kurzschreibweise A')
wird keine zusätzliche komplexe Konjugation durchgeführt. Für reelle Zahlen sind die beiden

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


39

Befehle allerdings identisch.

Lösung
>> k = 0 : 2 : 2*13*17-2;
>> E = reshape(k,[17 13]);
>> E = E';

Da Matlab mit dem Befehl reshape die Werte spaltenweise in die neue Matrix schreibt,
muss die neue Matrix anschließend transponiert werden. Um die gewünschten 13 Zeilen
und 17 Spalten zu erhalten, müssen die Werte des Vektors in eine Matrix mit 17 Zeilen
und 13 Spalten geschrieben werden. Durch die Transponierung erhält die Matrix dann die
gewünschten 13 Zeilen und 17 Spalten.

Aufgabe 3a: Task 20

In dieser Aufgabe werden wir die diskrete Fourier Transformation auf ein Musik- und auf ein
Sprachsignal anwenden und damit an die Praxis angelehnte Operationen durchführen. Im Ordner
von Versuch 3 finden Sie die Audiodateien composition.wav und mahlzeit.wav. Die erste Datei
ist das kurze Musikstück aus der letzten Teilaufgabe; mahlzeit.wav ist eine Datei, in der das
Wort ”Mahlzeit”gesprochen wird. Speichern Sie die beiden Signale in die Variablen musik (mit
Abtastrate fs1) und sprache (mit Abtastrate fs2).

Da beide Signale sehr kurz sind, können Sie anstelle eines audioplayers zum Vorspielen den
Befehl sound verwenden, dem Sie das Signal und die entsprechende Abtastrate übergeben müs-
sen.

Lösung
>> [musik,fs1] = audioread('composition.wav');
>> [sprache,fs2] = audioread('mahlzeit.wav');

>> sound(musik,fs1);
>> sound(sprache,fs2);

Aufgabe 3b: Task 21

Wenn Signale übertragen werden, kommt es meist zu Störungen, die sich auf der Empfänger-
seite als Rauschen bemerkbar machen. Wir werden im Folgenden unsere beiden Signale mit
einem Rauschsignal beaufschlagen, um danach zeigen zu können, wie man es mit Methoden der
digitalen Signalverarbeitung wieder ”herausrechnen”kann.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


40

Aufgabe
Erstellen Sie die zwei verrauschten Signale rauschmusik und rauschsprache, indem Sie mit dem
Befehl randn additives weißes gauß’sches Rauschen erzeugen (Englisch: additive white gaussian
noise, kurz AWGN) und auf die Signale musik und sprache addieren. Im Grunde handelt es sich
um ein Modell, bei dem das Rauschen durch eine gaußverteilte (d.h. normalverteilte) Signalam-
plitude dargestellt wird. Hören Sie sich die beiden verrauschten Signale an. Das Rauschen wird
Ihnen vielleicht von Radios oder alten Mobiltelefonen vertraut sein.
1
Anmerkung: Skalieren Sie das Rauschen jeweils auf 10 der Amplitude, damit es nicht so laut
ist!

Lösung
>> rauschmusik = musik + 0.1*randn(size(musik));
>> sound(rauschmusik,fs1);

>> rauschsprache = sprache + 0.1*randn(size(sprache));


>> sound(rauschsprache,fs2);

Aufgabe 3c: Task 22

Erzeugen Sie eine neue figure mit der Aufteilung 2 × 2, in deren oberen Zeile Sie die ursprüng-
lichen Signale musik und sprache plotten. Setzen Sie jeweils die Graphen der verrauschten
Signale zum Vergleich darunter. Beschriften Sie alle Signalverläufe aussagekräftig!

Lösung
>> figure;
>> subplot(2,2,1);
>> plot(musik);
>> xlabel('Abtastpunkte');
>> ylabel('Signalamplitude');
>> title('musik');

>> subplot(2,2,2); >> plot(sprache);


>> xlabel('Abtastpunkte');
>> ylabel('Signalamplitude');
>> title('sprache');

>> subplot(2,2,3);
>> plot(rauschmusik);
>> xlabel('Abtastpunkte');
>> ylabel('Signalamplitude');
>> title('rauschmusik');

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


41

>> subplot(2,2,4);
>> plot(rauschsprache);
>> xlabel('Abtastpunkte');
>> ylabel('Signalamplitude');
>> title('rauschsprache');

Aufgabe 3d: Task 23

Im Folgenden werden wir die Methoden der digitalen Signalverarbeitung verwenden, um das
Rauschen in unseren verrauschten Signalen wieder zu reduzieren.

Berechnen Sie dazu jeweils die diskrete Fourier-Transformation der Signale musik und rauschmusik.
Speichern Sie die Ergebnisse der Fourier-Transformation von musik in der Variable X1 und von
rauschmusik in X2 ab.

Erstellen Sie anschließend eine 3×2 figure und plotten Sie die Amplituden-Spektren an die Stel-
len 1 (X1) und 3 (X2). Vergleichen Sie die beiden Spektren, indem Sie die Lupe im Menübereich
verwenden. Versuchen Sie, die folgenden Fragen zu beantworten:

1. Wie macht sich die Addition des Rauschsignals im Spektrum bemerkbar?

2. Können Sie mithilfe Ihrer Beobachtung eine Vermutung aufstellen, wie man das Rauschen
deutlich abschwächen könnte?

Wiederholen Sie die Aufgabe für die Signale sprache und rauschsprache, deren Fourier-Transformierte
Sie in die Variablen Y1 und Y2 speichern und an Position 2 und 4 der figure setzen sollen.

Lösung
>> X1 = fft(musik);
>> X2 = fft(rauschmusik);
>> figure;
>> subplot(3,2,1);
>> plot(abs(X1));
>> xlabel('Frequenz-Bins');
>> ylabel('Amplitude');
>> title('musik, X1');
>> subplot(3,2,3);
>> plot(abs(X2));
>> xlabel('Frequenz-Bins');
>> ylabel('Amplitude');
>> title('rauschmusik, X2');

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


42

>> Y1 = fft(sprache);
>> Y2 = fft(rauschsprache);
>> subplot(3,2,2);
>> plot(abs(Y1));
>> xlabel('Frequenz-Bins');
>> ylabel('Amplitude');
>> title('sprache, Y1');
>> subplot(3,2,4);
>> plot(abs(Y2));
>> xlabel('Frequenz-Bins');
>> ylabel('Amplitude');
>> title('rauschsprache, Y2');

Aufgabe 3e: Task 24

Eine anschaulichere Darstellung des Spektrums ergibt sich, wenn man die Komponente der
Null-Frequenz in die Mitte des Graphen setzt. Das bedeutet, dass man die rechte Seite mit
den negativen Frequenzen nach links schiebt, so wie wir es aus der Vorlesung gewohnt sind.
Matlab liefert dafür die Funktion fftshift, welche ein Spektrum als Argument nimmt und
dieses automatisch um die Null-Frequenz zentriert.

Aufgabe
Zentrieren Sie damit X2, speichern Sie das Ergebnis in die Variable X2_sym und setzen Sie X2_sym
an die 5. Position ihrer aktuellen figure. Führen Sie dieselben Schritte mit Y2 durch und setzen
Sie das Ergebnis Y2_sym an die Position 6.

Lösung
>> X2_sym = fftshift(X2);
>> subplot(3,2,5);
>> plot(abs(X2_sym));
>> xlabel('Frequenz-Bins');
>> ylabel('Signalamplitude');
>> title('rauschmusik sym');

>> Y2_sym = fftshift(Y2);


>> subplot(3,2,6);
>> plot(abs(Y2_sym));
>> xlabel('Frequenz-Bins');
>> ylabel('Signalamplitude');

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


43

>> title('rauschsprache sym');

Aufgabe 3f: Task 25

Beim Betrachten des Spektrums des anfänglichen Musik-Signals ist auffällig, dass auf der linken
Seite der Großteil der Frequenzanteile zwischen den Bins 1 und 30.000 liegt, bzw. im zugehörigen
Frequenzband für die negativen Frequenzen.
Beim Spektrum der verrauschten Musik hingegen sind auch darüber hinaus noch deutliche Fre-
quenzanteile zu erkennen. Eine naheliegende Methode, um das Rauschen zu reduzieren, ist die
Anwendung eines Tiefpassfilters. Damit können die höheren Frequenzanteile entfernt werden,
sodass das verrauschte Signalspektrum nach der Filterung wieder dem ursprünglichen Signal
ähnelt.

Aufgabe
Setzen Sie nun alle Frequenz-Komponenten des verrauschten Signals X2 zwischen Bin 30.000
(ausschließlich) und dem zugehörigen Bin für die negative Frequenz (ausschließlich) zu 0. Stellen
Sie das Ergebnis auf Position 3 in der figure dar.

Wenn man das Spektrum von sprache (Y1) ansieht, erkennt man analog, dass die meisten
Frequenzanteile zwischen den Bins 1 und 2.150 liegen. Setzen Sie auch hier alle höheren Frequenz-
Bins von Y2 auf 0 und stellen Sie das Ergebnis an Stelle 4 der figure dar.

Lösung
>> t1 = linspace(1,441001,441001);
>> X2(30001:end-30000) = 0;
>> subplot(3,2,3)
>> plot(abs(X2))
>> xlabel('Frequenz-Bins');
>> ylabel('Signalamplitude');
>> title('Gefilterte rauschmusik, X2')

>> Y2(2151:end-2150) = 0;
>> subplot(3,2,4);
>> plot(abs(Y2));
>> xlabel('Frequenz-Bins');
>> ylabel('Signalamplitude');
>> title('Gefilterte rauschsprache, Y2');

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


44

Aufgabe 3g: Task 26

Transformieren Sie die gefilterten Signale X2 und Y2 zurück in den Zeitbereich und speichern
Sie sie in den Variablen x und y. Überschreiben Sie diese Variablen sogleich mit ihren jeweiligen
Realteilen und hören Sie sich die resultierenden Signale an.

Hören Sie sich zum Vergleich auch die entsprechenden verrauschten Signale rauschmusik und
rauschsprache an. Können Sie die Reduzierung des Rauschens heraushören?

Achten Sie darauf, dass das Rauschen sehr viel tiefer geworden ist (kein Wunder, da wir alle
hochfrequenten Anteile entfernt haben).

Plotten Sie die rücktransformierten Signale auf die Positionen 5 und 6 Ihrer figure und verglei-
chen Sie sie mit den ursprünglichen Signalverläufen. Wenn auch natürlich nicht perfekt, sehen die
rücktransformierten Signale den ursprünglichen Signalen musik und sprache deutlich ähnlicher,
als es die beiden verrauschten Signale tun.

Lösung
>> x = real(ifft(X2));
>> y = real(ifft(Y2));

>> % Signale anhören:


>> sound(x,fs1);
>> sound(rauschmusik,fs1);
>> sound(y,fs2);
>> sound(rauschsprache,fs2);

>> % Signale plotten:


>> subplot(3,2,5);
>> plot(x);
>> xlabel('Abtastpunkte');
>> ylabel('Signalamplitude');
>> title('Rücktransformiertes Signal x');
>> subplot(3,2,6);
>> plot(y);
>> xlabel('Abtastpunkte');
>> ylabel('Signalamplitude');
>> title('Rücktransformiertes Signal y');

Aufgabe 3h: Task 27

Bei welchem der beiden Signaltypen (Musiksignal oder Sprachsignal) hat Ihrer Meinung nach
die Entfernung des Rauschens besser funktioniert? Woran könnte das gelegen haben?

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


45

Lösung
Sprache ist im Normalfall viel tiefer und im Spektrum weniger gestreut als Musik. Bei den
Amplitudenspektren von musik und sprache ist das gut sichtbar. Deswegen konnten wir
das Sprachsignal feiner filtern als das Musiksignal und das Rauschen besser entfernen.

Vielleicht haben Sie auch schon selbst erlebt, dass man Sprache über ein Mobiltelefon sehr
viel besser verstehen kann als Musik. Dies liegt daran, dass Mobilfunkkanäle eine starke
Tiefpasscharakteristik aufweisen (zur Einsparung von wertvoller Bandbreite).

Klausuraufgabe 1: Task 28

Es seien zwei Audiosignale x und y gegeben. Schreiben Sie Matlab-Code, welcher beide Vektoren
additiv überlagert und als ein neues Aufiosignal z speichert. Geben Sie das neue Audiosignal
anschließend auf den Lautsprechern mithilfe von Matlab wieder. Sie dürfen annehmen, dass x
und y Spaltenvektoren sind und jeweils mit der gleichen Frequenz fs abgetastet wurden.

Lösung
>> m = max(length(x),length(y));
>> z = [x; zeros(m-length(x),1)] + [y; zeros(m-length(y),1)];
>> sound(z,fs);

Klausuraufgabe 2: Task 29

Der folgende Matlab-Code sei gegeben:

>> x = audioread('audio.wav',44100);
>> X = abs(fft(x));
>> plot(X);
>> xlabel('Frequenz');
>> ylabel('Betrag');
>> title('Der Betrag des Audiosignals');

Skizzieren Sie qualitativ, wie das Amplitudensprektrum X in Matlab aussieht. Nehmen Sie dafür
an,dass das Abtasttheorem erfüllt ist. Benennen Sie außerdem beide Achsen mithilfe von Matlab-
Code!

Lösung
Für diese Aufgabe gibt es keine Musterlösung, aber Sie können Ihre Lösung beispielsweise
mit den Teilaufgaben in Aufgabe 3 vergleichen.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


46

Klausuraufgabe 3: Task 30

Nennen Sie ein einfaches Verfahren, um weißes Rauschen in einem Audiosignal zu reduzieren.

Lösung
Tiefpassfilterung.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


47

4 Versuch: Laplace- und z-Transformation

Aufgabe 1a: Task 1

In Matlab kann man nicht nur numerisch, sondern auch symbolisch rechnen. Das bedeutet,
dass statt mit konkreten (numerischen) Werten mit Variablen gerechnet wird. Wie wir in
dieser Aufgabe sehen werden, sind in Matlab viele mathematische Gleichungen und Funktio-
nen vordefiniert, weshalb das Programm für uns die Berechnungen und Vereinfachungen über-
nehmen kann. Neu zu definierende Variablen werden dafür (ohne Kommata getrennt) hinter
den syms-Befehl geschrieben. Die Syntax ist also ähnlich der des doc-Befehls oder des help-
Befehls. Alternativ bietet Matlab aber auch eine andere Schreibweise mit Strings an, nämlich
syms(string1,string2,...).

Aufgabe
Erstellen Sie nun folgende symbolische Variablen: a, b, c und alpha. Die Reihenfolge, in der Sie
die Variablen hinter syms schreiben, ist egal.

Definieren Sie danach a als den Cosinus von alpha und b als den Sinus von alpha. Die Variable
c sei die Summe aus den Quadraten von a und b.

Lösung
>> syms a b c alpha
>> a = cos(alpha);
>> b = sin(alpha);
>> c = a^2 + b^2;

Aufgabe 1b: Task 2

Mit dem simplify-Befehl können symbolische Gleichungen automatisch von Matlab vereinfacht
werden. Vereinfachen Sie den Term c und speichern Sie den vereinfachten Term wieder unter
dem gleichen Namen ab. Was fällt Ihnen auf?

Lösung
>> c = simplify(c); % c = 1

Aufgabe 1c: Task 3

Natürlich kann man in die resultierenden Terme auch numerische Werte einsetzen. Sie kennen
dieses Vorgehen sicherlich aus Übungsaufgaben von Vorlesungen, in denen viele physikalische
Formeln verwendet werden. Dort ist es oft sinnvoller, zuerst die gegebenen Formeln umzuformen,

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


48

ineinander einzusetzen und zu vereinfachen, bevor man am Ende die Zahlenwerte berechnet. Dies
verringert Rundungsfehler und ermöglicht ein tieferes Verständnis der Zusammenhänge zwischen
Variablen.

In Matlab wird für das Einsetzen von numerischen Werten in symbolische Terme der Befehl
subs verwendet. Wie Sie sicherlich bereits vermuten, steht dessen Name für ’substituieren’ (=
ersetzen).

Aufgabe
π
Verwenden Sie den subs-Befehl, um in dem Term a für alpha den numerischen Wert 3 einzu-
setzen. Speichern Sie das Ergebnis in die Variable eingesetzt.

Lösung
>> eingesetzt = subs(a, alpha, pi/3); % eingesetzt = 1/2

Aufgabe 2a: Task 4

In dieser Aufgabe werden wir uns mit dem Einheitssprung, dem Dirac-Impuls und der sym-
bolischen Integration sowie Differentiation beschäftigen. Der Einheitssprung wird in Matlab
durch die Funktion heaviside erzeugt. Diese Funktion liefert den Rückgabewert 0, wenn ihr
Übergabeattribut kleiner als 0 ist.

Ist der Übergabewert größer als 0, liefert die Funktion, wie aus der Vorlesung bekannt, eine 1.
Für den Grenzwert 0 gibt heaviside den Wert 0.5 zurück. Diese leicht abgewandelte Definition
des Einheitssprungs soll uns aber zunächst nicht stören.
Sie können den Einheitssprung natürlich auch plotten:

>> t = linspace(-2,2,1000);
>> plot(t,heaviside(t));

Alternativ kann man in Matlab eine Funktion, die von nur einer einzigen Variablen abhängt, auch
mit dem Befehl fplot grafisch darstellen. Dafür muss man jedoch zuvor das Übergabeattribut
der Funktion als symbolische Variable definieren. Zusätzlich zur darzustellenden Funktion kann
man dem Befehl fplot auch den Bereich übergeben, der angezeigt werden soll.

Aufgabe
Erstellen Sie eine neue figure der Größe 3 × 1 und setzen Sie einen Einheitssprung bei t = 0 an
die oberste Position. Dabei sei t eine symbolische Variable. Wählen Sie sowohl hier als auch bei
allen folgenden Plots in dieser Aufgabe den Anzeigebereich zwischen −2 und 2. Da fplot die
figure nicht automatisch beschriftet, müssen Sie die Achsen noch beschriften und einen Titel
angeben.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


49

Lösung
>> syms t
>> figure;
>> subplot(3,1,1);
>> fplot(heaviside(t), [-2, 2]);
>> title('Der Einheitssprung');
>> xlabel('t');
>> ylabel('u(t)');

Aufgabe 2b: Task 5

Setzen Sie nun einen Einheitssprung bei t = 1 an die zweite Position der figure.

Lösung
>> % syms t
>> subplot(3,1,2);
>> fplot(heaviside(t - 1), [-2, 2]);
>> title('Der verschobene Einheitssprung');
>> xlabel('t');
>> ylabel('u(t-1)');

Aufgabe 2c: Task 6

Mithilfe der beiden vorherigen Einheitssprünge können Sie nun ein Rechteckssignal zwischen
t = 0 und t = 1 erzeugen und dieses an die dritte Position der figure setzen.

Lösung
>> % syms t
>> subplot(3,1,3);
>> fplot(heaviside(t) - heaviside(t-1),[-2,2]);
>> title('Ein Rechtecksignal');
>> xlabel('t');
>> ylabel('u(t)-u(t-1)');

Aufgabe 2d: Task 7

Der Matlab-Befehl für den Dirac-Impuls δ(t) heißt dirac. Diese Funktion liefert für den Über-
gabewert 0 den Rückgabewert Inf für Infinity (= unendlich). Für alle anderen Übergabewerte

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


50

liefert die dirac-Funktion den Wert 0.

Aufgabe
Welcher Zusammenhang besteht zwischen dem Einheitssprung und dem Dirac-Impuls?

Überprüfen Sie Ihre Überlegung, indem Sie die beiden Variablen ableitung_einheitssprung
und integral_dirac erstellen. Dabei sei integral_dirac das symbolische Integral des Dirac-
Impulses mit der Variable t und ableitung_einheitssprung die Ableitung des Einheitssprungs,
ebenfalls mit der symbolischen Variable t.

Das Ergebnis von integral_dirac wird vermutlich nicht Ihren Erwartungen entsprechen. Über-
legen Sie sich inwiefern sich das von Matlab berechnete Ergebnis von Ihrem erwarteten Ergebnis
unterscheidet und versuchen Sie dafür eine Erklärung zu finden. Womöglich helfen Ihnen die
Beispiele in der Dokumentation des dirac-Befehls weiter.

Versuchen Sie, die notwendigen Befehle durch eine kurze Recherche in der Dokumentation selbst
zu finden.

Wenn Sie in Zukunft Matlab verwenden, werden Ihnen nur in den seltensten Fällen die Befehle
vorab mitgeteilt, die Sie verwenden müssen. Meistens wissen Sie lediglich, welches Ziel Sie er-
reichen wollen, der Weg dorthin ist jedoch unklar und hängt davon ab, welche Funktionalitäten
Ihnen Matlab zur Verfügung stellt. An dieser Stelle ist Erfahrung mit möglichst vielen Matlab-
Befehlen wertvoll. Kann man noch nicht auf eigene Erfahrung zurückgreifen, ist oftmals eine
Internetrecherche angebracht.

Sollten Sie dabei weitere Unterstützung benötigen, werden Ihnen die Hinweise Hilfestellung
geben.

Lösung
>> % syms t
>> integral_dirac = int(dirac(t)); % = sign(t)/2 [neue Matlab-Versionen]
>> % = heaviside(t) [alte
Matlab-Versionen]
>> ableitung_einheitssprung = diff(heaviside(t)); % = dirac(t)

Die Lösung sign(t)/2 entspricht nicht exakt der heaviside-Funktion. Wenn Sie die Werte
vergleichen, werden Sie schnell herausfinden, dass das Ergebnis mit 0.5 addiert werden muss,
um die heaviside-Funktion zu erzeugen.
Das liegt daran, dass die int-Funktion keine Integrationskonstanten berücksichtigt.

Aufgabe 2e: Task 8

Erzeugen Sie zum Abschluss ein Signal s mit der symbolischen Variable t, welches aus der
Überlagerung eines Dirac-Impulses bei t = 1 und eines Einheitssprungs bei t = −1 besteht.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


51

Stellen Sie den Verlauf von s und des Integrals von s mithilfe des fplot-Befehls jeweils im
Bereich zwischen t = −2 und t = 2 in einer neuen 2 × 1 figure dar.

Was fällt Ihnen bei der Darstellung auf?

Lösung
>> % syms t
>> figure;
>> s = dirac(t-1) + heaviside(t+1);
>> subplot(2,1,1);
>> fplot(s,[-2,2]);
>> title('Das Signal s');
>> xlabel('t');
>> ylabel('s(t)');
>> subplot(2,1,2);
>> fplot(int(s),[-2,2]);
>> title('Das Integral vom Signal s');
>> xlabel('t');
>> ylabel('int(s(t))');

Es fällt auf, dass der Dirac-Impuls im ersten Subplot nicht sichtbar ist. Es lässt sich schlussfol-
gern, dass Matlab nicht das ideale Werkzeug für die Darstellung von Dirac-Impulsen ist.

Aufgabe 3a: Task 9

In der Vorlesung wurde Ihnen bereits erklärt, wie wichtig Transformationen für die Signaltheorie
sind. In der Mathematik gibt es eine Vielzahl von verschiedenen Transformationen. Glücklicher-
weise genügt es jedoch für die Anwendung in der Elektro- und Informationstechnik, sich auf
einige wenige Transformationen zu beschränken. Zu den wichtigsten darunter zählen:

• die Sinus- und Cosinus-Transformationen (werden nicht behandelt)

• die Fourier-Transformation (FT, ZDFT, DFT, FFT, usw.)

• die Laplace-Transformation

• die z-Transformation

In dieser Aufgabe wollen wir uns mit der symbolischen Anwendung dieser Transformationen
beschäftigen, genau so, wie es von Ihnen in vielen Übungsaufgaben verlangt wird. Damit wird
Ihnen ein Werkzeug zur Verfügung stehen, Ergebnisse zu Aufgaben aus der Vorlesung und/oder
Übung mit Matlab zu verifizieren.

Aufgabe

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


52

Erstellen Sie zunächst ein Signal x1 welches von der symbolischen Variablen t abhängt. Dieses
Signal sei das Produkt aus den folgenden 3 Faktoren:
t
– e2 ,

– cos (πt) und

– einem Einheitssprung an der Stelle t = 0.

Berechnen Sie die Laplace-Transformierte X1, indem Sie den Befehl laplace verwenden.

Bei Transformationen hat man es häufig mit Brüchen zu tun. Um diese in Matlab übersichtlicher
anzuzeigen, kann man den Befehl pretty verwenden. Denken Sie außerdem daran, dass Sie
Ergebnisse mit simplify zuvor vereinfachen können.

Lösung
>> % syms t
>> x1 = exp(t/2)*cos(pi*t)*heaviside(t);
>> X1 = laplace(x1);
>> pretty(simplify(X1));
>> % X1 = (s - 1/2)/((s - 1/2)^2 + pi^2)

Hinweis: Im Gegensatz zur Vorlesung berechnet Matlab ausschließlich die unilaterale Laplace-
Transformation (laplace) wie Gleichung 7.4 im Skript auf Seite 70.


X+ (s) = x(t) · e−st
n=0

Probieren Sie doch einmal aus was passiert, wenn sie die heaviside-Funktion weglassen und die
Laplace-Transformation in Matlab durchführen.

Aufgabe 3b: Task 10

Erstellen Sie das Signal x2, welches mit x1 identisch ist, bis auf den Unterschied, dass der erste
Term eine e-Funktion mit Argument MINUS 2t ist. Berechnen Sie auch von diesem Ausdruck
die Laplace-Transformierte X2.

Lösung
>> % syms t
>> x2 = exp(-t/2)*cos(pi*t)*heaviside(t);
>> X2 = laplace(x2);
>> pretty(simplify(X2));
>> % X2 = (s + 1/2)/((s + 1/2)^2 + pi^2)

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


53

Herzlichen Glückwunsch, Sie haben gerade Aufgabe 1 a) auf Seite 46 des Übungsskriptes mithilfe
von Matlab gelöst!

Sie sehen, dass sich Matlab bereits jetzt als nützliches Werkzeug für die Signaltheorie erweist.
Wenn Sie in Zukunft (beispielsweise während der Klausurvorbereitung) Transformationen von
Hand berechnen, können Sie Ihre Lösungen problemlos mit Matlab auf deren Korrektheit über-
prüfen.

Aufgabe 3c: Task 11

Die inverse Laplace-Transformation wird mit dem Befehl ilaplace durchgeführt. Verwenden Sie
4s2
diesen Befehl, um den Term X = 3s+2 in den Zeitbereich zu transformieren. Den Einheitssprung
im Zeitbereich dürfen Sie hier ausnahmsweise vernachlässigen. Für die Klausur muss dieser ggf.
berücksichtigt werden, sofern nicht anders vermerkt! Nennen Sie den resultierenden Ausdruck x.

Lösung
>> syms s % wichtig!
>> X = 4*s^2/(3*s + 2);
>> x = ilaplace(X);
>> pretty(simplify(x));
>> % x = (16*exp(-(2*t)/3))/27 - (8*dirac(t))/9 + (4*dirac(1, t))/3
>> % angepasst an VL: x = (16*exp(-(2*t)/3))/27 - (8*dirac(t))/9 +
(4*dirac(1, t))/3 * heaviside(t)

Wie Sie sehen handelt es sich bei der Lösung um eine beidseitige Funktion, obwohl dies mit nur
einer Polstelle gar nicht möglich sein kann. Der Grund dafür ist, dass Matlab nur mit kausalen
Signalen arbeitet. Korrekterweise müssen wir deshalb diese Lösung noch mit heaviside(t)
multiplizieren.

Aufgabe 3d: Task 12

Bevor wir uns der z-Transformation widmen können, müssen wir einen weiteren Unterschied
zwischen Vorlesung und Matlab beachten. Matlab definiert den Einheitssprung (heaviside(n))
wie folgt: 
 1
 2 für n = 0
heaviside(n) = 1 für n > 0


0 für n < 0

Analog zur Laplace-Transformation berechnet Matlab ausschließlich die unilaterale z-Transformation

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


54

(ztrans) wie Gleichung 8.5 im Skript auf Seite 76.




X+ (z) = x[n]z −n
n=0

Um diese Unterschiede zu kompensieren und eine Lösung im Einklang mit der Vorlesung bzw.
Übung zu erhalten, muss man sich eines Tricks bedienen.

Signale, welche mit einem nicht verschobenen Einheitssprung u[n] multipliziert werden, müs-
sen in Matlab direkt ohne Verwendung der heaviside-Funktion z-transformiert werden. Wäh-
rend bei der Laplace-Transformation die anders definierte Sprungfunktion u(t) keine Auswirkun-
gen auf das Ergebnis hat (der andere Wert ist lediglich in einem infinitesimal schmalen Bereich
und kann bei der Integration vernachlässigt werden, vgl. Task 9), hat im Zeitdiskreten der an-
dere Wert an der Sprungstelle u[0] erhebliche Auswirkungen. Um zeitdiskrete Signale dennoch
mit Hilfe der unilateralen ztrans-Funktion transformieren zu können, nutzen wir aus, dass
die Eigenschaft dieser (Summierung von 0 bis ∞) einer Multiplikation mit dem Einheitssprung
u[n] entspricht. Der Trick ist also die Signale immer so umzuwandeln, dass wir diese ohne Ver-
wendung der heaviside-Funktion transformieren können - also mit Beginn im Ursprung und
rechtsseitig.

Aufgabe
Verwenden Sie den Befehl ztrans, um das Signal x1 [n] = (−1)n · u[n] in den Frequenzbereich
zu transformieren. Benennen Sie das Resultat X1. Denken Sie daran, dass Sie das Ergebnis mit
simplify vereinfachen können. Testen Sie anschließend auch den Befehl pretty.

Lösung
>> syms n % wichtig!
>> x1 = (-1)^n; % u[n] kann vernachlässigt werden
>> X1 = ztrans(x1);
>> pretty(simplify(X1));
>> % X1 = z/(z+1)

Testen Sie doch einmal, was passiert, wenn Sie vor der z-Transformation x1 mit der heaviside-
Funktion multiplizieren. Sie werden sehen, dass sich das Ergebnis von unserer Lösung unter-
scheidet.

Aufgabe 3e: Task 13

Nun soll die z-Transformation von x2 [n] = 2 · (− 12 )n−1 · u[n − 2] berechnet werden (Übungsskript
Seite 50 Aufgabe 1a.2)). Benennen Sie das Ergebnis X2.

In dieser Aufgabe haben wir nun ein Signal welches mit u[n − 2] multipliziert wird. Um den in

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


55

der vorherigen Aufgabe genannten Trick anwenden zu können, müssen wir das Signal erst in den
Ursprung verschieben und anschließend im z-Bereich wieder zurückschieben.

Lösung
>> >> syms z % wichtig für Verschiebung
>> x2 = -1 * (-1/2)^n; % angepasste Form
>> X2 = z^-2 * ztrans(x2); % Verschiebung um 2 durch * z^-2
>> pretty(simplify(X2));
>> % X2 = -1/(z*(z + 1/2))

In den beiden letzten Beispielen liefert sowohl die unilaterale als auch die bilaterale Transforma-
tion identische Werte, da x[n] = 0 für n < 0. Hat das Signal jedoch Werte x[n] ̸= 0 für n < 0 -
also ist das Signal nicht kausal - sind diese nicht identisch. In der Klausur geben wir zusätzlich
an, ob Sie das Signal unilateral oder bilateral in Matlab transformieren sollen.

Um die bilaterale z-Transformation in Matlab berechnen zu können, muss man das Signal im
Zeitbereich spiegeln und dann ggf. in den Ursprung schieben. Achten Sie hier besonders auf die
Reihenfolge beim anschließenden Zurückspiegeln und -schieben im z-Bereich.

Hinweis: Bei der bilateralen Laplace-Transformation (laplace) verfährt man genauso wie bei
der z-Transformation.

Aufgabe 3f: Task 14


z
Berechnen Sie die inverse z-Transformation von X3 (z) = 2 mit dem Befehl iztrans.
(z − 1)2
Speichern Sie das Ergebnis in x3. Den Einheitssprung im Zeitbereich dürfen Sie hier ausnahms-
weise vernachlässigen. Für die Klausur muss dieser ggf. berücksichtigt werden, sofern nicht anders
vermerkt!

Lösung
>> % syms z
>> X3 = 2*z/(z - 1)^2;
>> x3 = iztrans(X3);
>> pretty(simplify(x3));
>> % x3 = 2*n
>> % angepasst an VL: x3 = 2*n*u[n]

Aufgabe 3g: Task 15

Natürlich lässt sich auch die Fouriertransformation symbolisch berechnen. Dazu gibt es die
Befehle fourier und ifourier.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


56

Überprüfen Sie die Korrektheit des auf Seite 68 Aufgabe 1 gegebenen FT-Paares für a = 1:

x4 (t) = u(t + 1) − u(t − 1)

Lösung
>> % syms t
>> x4 = heaviside(t + 1) - heaviside(t - 1);
>> X4 = fourier(x4);
>> pretty(simplify(X4));
>> % X4 = 2*sin(w)/w
>> % was nach unserer Definition 2*si(w) entspricht

Aufgabe 3h: Task 16

Validieren Sie nun die andere Transformationsrichtung dieses FT-Paares, diesmal jedoch mit
ebenfalls symbolisch behandeltem a, indem Sie den Term X5 (ω) = 2 sin(aω)
ω mit dem Befehl
ifourier zurück in den Zeitbereich transformieren.

Lösung
>> syms a w
>> X5 = 2*sin(a*w)/w;
>> x5 = ifourier(X5,w,t); % die Angabe von t verhindert, dass Matlab das
Ergbnis als Funktion von x ausgibt
>> pretty(simplify(x5));
>> % x5 = heaviside(a + t) - heaviside(t - a);

Dieser Term entspricht genau dem im Übungsskript gegebenen Term im Zeitbereich.


Das angegebene FT-Paar ist somit korrekt.

Ende der Versuche: Task 17

Herzlichen Glückwunsch! Damit sind wir am Ende dieses Versuchs und des unmittelbar klau-
surrelevanten Teils des Matlab-Praktikums angekommen. Wir möchten uns sehr herzlich bei
Ihnen für Ihr Interesse und Ihr Durchhaltevermögen bedanken und hoffen, dass das Praktikum
für Sie interessant und lehrreich war.

Sollte es uns gelungen sein, in Ihnen die Begeisterung für die Signaldarstellung und Signal-
verarbeitung zu wecken, dann weisen wir Sie gerne auf das weitere Angebot des Lehrstuhls
für Mensch-Maschine-Kommunikation hin, einschließlich der Vielzahl an Forschungsthemen, die

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


57

dort im Rahmen einer Ingenieurspraxis oder einer Bachelorarbeit bearbeitet werden können.
Nähere Informationen finden Sie auf unserer Homepage.

Wir gehen davon aus, dass Sie nach Beendigung dieses Praktikums die Grundlagen von Matlab
gut verinnerlicht haben. Sie sollten nun in der Lage sein, die Möglichkeiten, die diese Program-
mierumgebung bietet, auch in anderen Vorlesungen und Praktika zu nutzen. Die fortwährende
Benutzung von Matlab in verschiedenen Kontexten ist eine sichere Methode, um Ihre Fähigkeiten
noch weiter zu verbessern.

Zusätzlich möchten wir Sie auf das Buch MATLAB-Simulink-Stateflow: Grundlagen, Toolboxen,
Beispiele von Anne Angermann, Michael Beuschel, Martin Rau und Ulrich Wohlfahrt hinweisen,
welches auch in der Bibliothek zu finden ist und eine sehr intensive Einführung in Matlab bietet.
Alle vier Autoren bieten eine Vorlesung an der Fakultät EI der TU München an:

Simulation mit SIMULINK/MATLAB.

Wir, das Praktikums-Team, wünschen Ihnen ein weiterhin erfolgreiches Studium!

Es folgen nun anschließend wie gewohnt Beispielaufgaben, wie sie auch in der Klausur vorkom-
men könnten. Danach finden Sie mit Versuch 5 einen Exkurs, der Ihnen die Bildbearbeitung mit
Matlab etwas näher bringt.

Klausuraufgabe 1: Task 18

Schreiben Sie MATLAB-Code, der die symbolische Z-Transformation von folgendem Signal be-
rechnet. Vereinfachen Sie das Ergebnis mithilfe von MATLAB so weit wie möglich.
( )n (π )
1
x[n] = cos n u[n − 2]
3 4

Lösung
>> syms n z
>> x = 1/9*(1/3) ^n*cos(pi/4*n + pi/2);
>> X = simplify(z^-2 * ztrans(x));

Klausuraufgabe 2: Task 19

Beschreiben Sie in eigenen Worten, wie MATLAB den Konvergenzbereich der LT bei dem Befehl
ilaplace berücksichtigt.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


58

Lösung
MATLAB verwendet für die inverse Laplacetransformation automatisch das kleinste σ für
welches die LT konvergiert, so dass für alle Pole p gilt:

Re(p) < σ (rechtsseitige Sequenz)

Vergleiche:

>> doc ilaplace

Klausuraufgabe 3: Task 20

Schreiben Sie MATLAB-Code, der die folgende Funktion im Bereich −4 ≤ t ≤ 6 im ersten


Subplot einer 2 × 1 figure darstellt. Erstellen Sie einen 2. Subplot, welcher das Integral −∞
bis t der Funktion darstellt.
[ t 2
]
x(t) = e−( 2 ) + u(t) · u(t + 2)

Lösung
>> syms t
>> x = (exp(-(t/2)^2) + heaviside(t)) * heaviside(t+2);
>> subplot(2,1,1);
>> fplot(x,[-4,6]);
>> title('Das Signal x(t)');
>> xlabel('t');
>> ylabel('x(t)');
>> subplot(2,1,2);
>> fplot(int(x),[-4,6]);
>> title('Das Integral vom Signal x(t)');
>> xlabel('t');
>> ylabel('int(x(t))');

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


59

5 Exkurs: Bildverarbeitung

Hinweis:
Dieser Exkurs ist nicht unmittelbar klausurrelevant!

In diesem Versuch werden wir einen Exkurs zu den Grundlagen der digitalen Bildverarbeitung
unternehmen. Da es sich um einen Exkurs handelt, werden wir gleichzeitig noch einmal einige
wichtige Grundlagen wiederholen.

In der ersten Aufgabe werden wir beispielsweise sehen, dass (Farb-)Bilder in Matlab als Matri-
zen gespeichert werden. Der Name ’Matlab’ signalisiert bereits, wie wichtig Matrizen in dieser
Programmiersprache sind. Deshalb werden wir an dieser Stelle einen kleinen ’Exkurs im Exkurs’
durchführen und die weitere Funktionen und Operatoren für Matrizen kennenlernen.

In der zweiten Aufgabe wird Ihnen gezeigt, wie der Kontrast von Bildern erhöht werden kann.

Ziel der dritten Aufgabe ist die Einführung von alternativen Farbräumen sowie die Transforma-
tion von Farbbildern dorthin. Dabei wird auch das YIQ-Farbsystem besprochen werden, welches
mit der Einführung des Farbfernsehens festgelegt wurde und die Eigenschaft hat, dass es wei-
terhin auch für Schwarz-Weiß-Fernseher kompatibel ist bzw. war.

Aufgabe 1a: Task 1

Im 3. Versuch haben wir gesehen, dass Signale auch mehrdimensional sein können. Während
Audiosignale eindimensional sind, sind Bilder zweidimensionale Signale; Farbbilder sogar dreidi-
mensionale Signale. In Matlab werden Bilder deshalb im Gegensatz zu den Audiosignalen nicht
in Vektoren, sondern in Matrizen gespeichert.

Bei Grauwert-Bildern entspricht jedes Pixel des Bildes einem Eintrag in der Bild-Matrix dessen
Wert die Intensität (= Helligkeit) des Pixels anzeigt. Hohe Intensitätswerte repräsentieren helle
Bildstellen, niedrige Intensitätswerte entsprechend dunkle Bereiche.

Bei Farbbildern werden jedem Pixel drei Werte zugeordnet, die für die Intensitäten der Grund-
farben Rot, Grün und Blau stehen. Die Matrizen von Farbbildern besitzen deshalb noch eine
dritte Dimension der Länge 3.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


60

Abbildung 4: Lena Söderberg, Playboys 1972 [?]

Verwenden Sie den Befehl imread, um das Bild lena.jpg in die Variable lena zu schreiben. Da
das Bild im aktuellen Ordner liegt, brauchen Sie keinen absoluten Pfad angeben. Der String
’lena.jpg’ genügt als Übergabeattribut (vergessen Sie die einfachen Anführungszeichen nicht!).
Mit dem Befehl imshow können Sie sich das in lena gespeicherte Bild ansehen.

Aufgabe
Betrachten Sie die Matrix lena. Aus wie vielen Pixeln besteht das Bild? Speichern Sie die Lösung
in die Variable pixelanzahl. Von welchem Datentyp sind die einzelnen Einträge der Matrix?
Speichern Sie die höchstmöglichen Eintrag in die Variable max_wert und den niedrigstmöglichen
Eintrag in die Variable min_wert. Bei der Beantwortung der Fragen hilft ein Blick auf den
Workspace oder die Verwendung des Befehls whos.

Anmerkung:
Das in diesem Versuch verwendete Bild von Lena Söderberg ist übrigens äußerst bekannt in der
Bildverarbeitung. Bei dem Bild handelt es sich nämlich um einen Ausschnitt einer Aufnahme aus
der Novemberausgabe des Playboys 1972, mit über 7 Millionen verkauften Exemplaren übrigens
die meistverkaufte Playboyausgabe jeher. Wer die Geschichte von Lena noch nicht kennt, erfährt
die Hintergründe unter dem folgenden Link

Lösung
>> lena = imread('lena.jpg');
>> imshow(lena);
>> pixelanzahl = 512*512; % 262144
>> min_wert = 0;
>> max_wert = 255; % 2^8-1
>> whos

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


61

Aufgabe 1b: Task 2

Im Laufe dieses Praktikums haben Sie bereits einige Funktionen (wie ctranspose, repmat,
reshape, transpose usw.) kennengelernt, welche auf eine Matrix angewendet werden können.
Weitere Funktionen sind rank, det, inv und eig, die den Rang, die Determinante, die Inverse
und die Eigenwerte der Matrix berechnen. Um herauszufinden, ob unsere Matrix A invertierbar
ist, können wir folgenden Code schreiben:

>> if(det(A)~=0) % Negationsoperator:~


>> fprintf('Die Matrix A ist invertierbar.');
>> else
>> fprintf('Die Matrix A ist nicht invertierbar.');
>> end

Die Verwendung der Kontrollstruktur if funktioniert in Matlab genauso wie in anderen Pro-
grammiersprachen. Nach if muss eine Bedingung stehen, bei deren Erfüllung der nachfolgende
Code ausgeführt wird. Ansonsten wird der Code, der nach else steht, ausgeführt. In unse-
rem Beispiel wird mit dem Ungleichheitszeichen ’~=’ getestet, ob die Determinante der Matrix
ungleich 0 ist. Das Ende der if-Ausführung wird mit einem end signalisiert.

Aufgabe
Wie Sie in der Vorlesung zur Linearen Algebra gelernt haben, ist eine Matrix genau dann in-
vertierbar, wenn ihre Determinante ungleich 0 ist. Verwenden Sie die vorgestellten Funktionen
und Operationen, um folgendes lineares Gleichungssystem zu lösen:

x − 3y + 4z = 1
3x − 2y + z = 1
− x + 2y + z = 4

Speichern Sie den Lösungsvektor zum obigen Gleichungssystem in die Variable x.

Lösung
>> % A = [1,-3,4;3,-2,1;-1,2,1];

>> if(det(A) ~= 0)
>> fprintf('Die Matrix A ist invertierbar.\n\n');
>> else
>> fprintf('Die Matrix A ist nicht invertierbar.\n\n');
>> end

>> b = [1;1;4];
>> x = inv(A)*b;

Anmerkung:

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


62

Da das Lösen von Gleichungssystemen eine der Kernfunktionen von Matlab ist und die
Berechnung der Inverse aufwändig ist, gibt es dafür extra eigene Operationen:

matrix right division: schreibe A\b statt inv(A)*b


matrix left division: schreibe b/A statt b*inv(A)

Aufgabe 1c: Task 3

Nach diesem kurzen Exkurs in die Matrizenrechnung in Matlab geht es nun wieder zurück zur
Bildverarbeitung.

Wir haben bereits gesehen, dass Bilder als Matrizen dargestellt werden. Grauwertbilder sind
zweidimensional - jede Komponente entspricht einem Bildpunkt und ihr Wert kennzeichnet die
Intensität des Bildpunktes. Farbbilder besitzen noch eine dritte Dimension der Größe 3. Bei
ihnen werden jedem Pixel Intensitäten für die Farben Rot, Grün und Blau zugeordnet. Deshalb
werden sie auch RGB-Bilder genannt.

Aufgabe
Erstellen Sie eine neue figure der Größe 3 × 3. Setzen Sie das Bild von Lena auf die erste
Position. Anstelle von plot müssen Sie hier den Befehl imshow verwenden.

Setzen Sie danach die einzelnen Farbkomponenten-Bilder von lena auf Positionen 4 bis 6. Er-
stellen Sie dafür die 3D-Matrizen lena_rot, lena_gruen und lena_blau, die jeweils nur aus
der entsprechenden Farbkomponente bestehen. Geben Sie den Bildern in ihrer figure jeweils
einen Namen mithilfe von title.

Lösung
>> figure
>> subplot(3,3,1);
>> imshow(lena);
>> title('Lena');

>> lena_rot = zeros(size(lena),'uint8');


>> lena_rot(:,:,1) = lena(:,:,1);
>> subplot(3,3,4);
>> imshow(lena_rot);
>> title('Rote Farbkomponente');

>> lena_gruen = zeros(size(lena),'uint8');


>> lena_gruen(:,:,2) = lena(:,:,2); >> subplot(3,3,5);
>> imshow(lena_gruen);
>> title('Grüne Farbkomponente');

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


63

>> lena_blau = zeros(size(lena),'uint8');


>> lena_blau(:,:,3) = lena(:,:,3);
>> subplot(3,3,6);
>> imshow(lena_blau);
>> title('Blaue Farbkomponente');

Aufgabe 1d: Task 4

Wie wir in Versuch 3 bei den Sprachsignal-Vektoren gesehen haben, können wir auch mit den
Bildmatrizen mathematische Operationen durchführen. Verwenden Sie die drei Farbkomponenten-
Matrizen, um das ursprüngliche Bild wiederherzustellen und in die Variable lena_add zu schrei-
ben. Setzen Sie es an Position 2 der figure.

Aufgabe
Man kann auch einzelne Farbkomponenten stärker gewichten. Erstellen Sie eine Matrix lena_rotstich
deren Rotanteile mit dem Faktor 2 gewichtet sind und setzen Sie sie an Position 3.

Aus jeder RGB-Bildmatrix lässt sich außerdem auch eine Bildmatrix mit Grauwerten berechnen.
Speichern Sie diese in die Variable lena_gray und setzen Sie sie an Stelle 7 der figure. Die In-
tensität eines Grauwert-Pixels soll sich jeweils aus einem Drittel der einzelnen Farbkomponenten
zusammensetzen.

Lösung
>> lena_add = lena_rot + lena_gruen + lena_blau;
>> subplot(3,3,2);
>> imshow(lena_add);
>> title('Rekonstruiert');

>> lena_rotstich = 2*lena_rot + lena_gruen + lena_blau;


>> subplot(3,3,3);
>> imshow(lena_rotstich);
>> title('Rotstich');

>> lena_gray = uint8(sum(lena/3,3));


>> subplot(3,3,7);
>> imshow(lena_gray);
>> title('Grauwertbild');

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


64

Aufgabe 2a: Task 5

Bereits in Versuch 2 haben wir gesehen, dass es in Matlab vordefinierte Funktionen gibt, die
bestimmte Operationen sehr viel schneller ausführen, als selbst geschriebene Implementierungen.

Diese Funktionen sind in sogenannten Toolboxen gebündelt, die jeweils für einen bestimmten
Anwendungsbereich stehen. In diesem Praktikum verwenden wir die Signal Processing Toolbox
sowie die Image Processing Toolbox (in diesem Versuch verwendet). Die Funktionen rectpuls,
tripuls oder conv stammen beispielsweise alle aus der Signal Processing Toolbox. Für alle
Toolboxen gibt es umfangreiche Dokumentationen, die man im Browser (zum Beispiel für die
Signal Processing Toolbox) oder über die Eingabe von doc im Command Window einsehen kann.

Wie Sie sich wahrscheinlich bereits denken können, gibt es in der Image Processing Toolbox
auch eine Funktion, um aus einem RGB-Bild ein Grauwertbild zu erstellen und sich somit die
aufwändige Implementierung aus der letzten Teilaufgabe zu sparen.

Aufgabe
Verwenden Sie den Befehl rgb2gray, um ein Grauwertbild lena_grau zu erzeugen, und dieses
an Position 1 einer neuen 2 × 4 figure darzustellen.

Lösung
>> figure
>> lena_grau = rgb2gray(lena);
>> subplot(2,4,1);
>> imshow(lena_grau);
>> title('Grauwertbild (rg2gray)');

Aufgabe 2b: Task 6

Eine Möglichkeit, sich bestimmte Informationen über ein Grauwertbild anzeigen zu lassen, ist
das sogenannte Grauwerthistogramm. Dabei handelt es sich um ein Diagramm, welches für jeden
Grauwert angibt, wie häufig dieser im Bild vorkommt.

Ein uint8-Grauwertbild, also ein Bild mit 256 verschiedenen Grauwert-Intensitäten, hat im Grau-
werthistogramm auf der Abszisse 256 Bins, die je nach Häufigkeit des entsprechenden Grauwer-
tes im Bild unterschiedlich stark ’gefüllt’ sind. Dunkle Bilder haben besonders hohe Werte im
niedrigen Intensitätsbereich, wohingegen es sich für helle Bilder genau andersherum verhält.

Der Matlab-Befehl, um ein Grauwerthistogramm zu einer Bild-Matrix zu berechnen, lautet


imhist. Speichern Sie das Histogramm von lena_grau in die Variable lena_histo. Statt die
Histogrammverteilung lena_histo mit einem separaten Befehl zu plotten, kann man direkt den
Befehl imhist(lena_grau) (ohne Rückgabewert) verwenden.

Aufgabe

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


65

Setzen Sie das Grauwerthistogramm von lena_grau auf Position 5 der figure. Belassen Sie den
Fokus im 5. Subplot.

Lösung
>> lena_histo = imhist(lena_grau);
>> subplot(2,4,5);
>> imhist(lena_grau);
>> title('Grauwerthistogramm');

Aufgabe 2c: Task 7

Für die digitale Bildverarbeitung ist es besonders interessant, dass man diese Grauwertvertei-
lungen mithilfe von Transformationen verändern kann.

Im Histogramm von lena_grau können Sie sehen, dass das Bild weder besonders dunkle, noch
besonders helle Grauwerte besitzt. Das Bild nutzt das vorhandene Intensitätsspektrum also
schlecht aus. Mit der von Matlab bereitgestellten Transformationsfunktion imadjust kann dies
korrigiert werden. Dabei findet intern eine Histogrammdehnung statt.

Aufgabe
Erstellen Sie eine neue Variable lena_adjust und speichern Sie darin das durch die Histo-
grammdehnung bearbeitete Bild. Setzen Sie das neue Bild an Position 2 der figure und dessen
gedehntes Histogramm an Position 6. Belassen Sie den Fokus im 6. Subplot.

Vergleichen Sie das ursprüngliche Bild mit dem bearbeiteten. Was hat sich verändert?

Lösung
>> lena_adjust = imadjust(lena_grau);
>> subplot(2,4,2);
>> imshow(lena_adjust);
>> title('Angepasst (imadjust)');

>> subplot(2,4,6);
>> imhist(lena_adjust);
>> title('Angepasstes Histogramm');

Wie sie sicherlich erkennen können, hat sich der Kontrast stark erhöht. Dies liegt an der
besseren Nutzung des Grauwertbereichs. Sie können das Fenster Ihrer figure übrigens auch
größer ziehen oder maximieren, um die Veränderung besser sehen zu können.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


66

Aufgabe 2d: Task 8

Eine weitere Grauwerttransformation ist die Histogrammangleichung, deren Ziel eine Gleichver-
teilung der Grauwerte ist. Das bedeuted, dass alle Grauwerte im Bild gleich häufig verwendet
werden. Damit wird der zur Verfügung stehende Grauwertbereich informationstheoretisch opti-
mal genutzt.

Aufgabe
Der Matlab-Befehl für die Histogrammangleichung lautet histeq. Erzeugen Sie damit ein neues
Bild lena_equal und stellen Sie es an Position 3. Das angeglichene Histogramm des neuen Bildes
soll auf Position 7 gesetzt werden. Belassen Sie wieder den 7. Subplot im Fokus.

Lösung
>> lena_equal = histeq(lena_grau);
>> subplot(2,4,3);
>> imshow(lena_equal);
>> title('Ausgeglichen (histeq)');

>> subplot(2,4,7);
>> imhist(lena_equal);
>> title('Ausgeglichenes Histogramm');

Wie sie sicherlich erkennen können, hat sich auch hier der Kontrast stark erhöht. Im His-
togramm sieht man, dass der gesamte Grauwertbereich ausgenutzt wird und die Verteilung
gleichmäßiger ist.

Aufgabe 2e: Task 9

Wenn man einen bestimmten Grauwert als Schwellwert definiert und alle Grauwerte darunter
∧ ∧
auf die Intensität 0 (= Schwarz) und alle darüber auf die Intensität 255 (= Weiß) abbildet,
erhält man ein Schwarz-Weiß-Bild.

Um ein Grauwertbild in ein Schwarz-Weiß-Bild zu transformieren, stellt die Image Processing


Toolbox den Befehl im2bw zur Verfügung. Man kann diesem Befehl neben einem Bild (RGB- oder
Grauwertbild) auch ein weiteres Attribut level übergeben, welches für den relativen Schwellwert
steht und entscheidet, ob eine Intensivität auf Schwarz oder Weiß abgebildet wird. Wenn, wie in
unserem Fall, kein Schwellwert übergeben wird, wird standardmäßig die Hälfte des maximalen
Grauwertes verwendet.

Aufgabe
Verwenden Sie den Befehl im2bw, um lena_grau in ein Schwarz-Weiß-Bild lena_bw zu verwan-
deln und stellen Sie dieses auf Position 4 dar. Setzen Sie das Histogramm des neuen Bildes auf
Position 8 und überprüfen Sie, ob tatsächlich nur die Intensitäten Schwarz und Weiß verwendet

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


67

werden. Belassen Sie den Fokus im 8. Subplot.

Lösung
>> lena_bw = im2bw(lena_grau);
>> subplot(2,4,4);
>> imshow(lena_bw);
>> title('Schwarz-Weiß (im2bw)');

>> subplot(2,4,8);
>> imhist(lena_bw);
>> title('Schwarz-Weiß Histogramm');

Aufgabe 3a: Task 10

Die Darstellung von Farbbildern durch Rot-, Grün- und Blauanteile ist deshalb so beliebt, da
sie in etwa der Farbempflindlichkeit der unterschiedlichen Zapfentypen im menschlichen Auge
entspricht. Das Farbbild entsteht dann aus der additiven Überlagerung der Grundfarben. Von der
N.T.S.C.(National Television Systems Commitee) wurden die Primärfarben in ihrer spektralen
Verteilung so festgelegt, dass sie den gemittelten Spektren gängiger Phosphortypen damaliger
Röhrenbildschirme entsprechen.

Bei moderneren Monitoren wird dass Bild ebenfalls durch additive Überlagerung von Rot, Grün
und Blau erzeugt. Jedoch werden diese dort anderes erzeugt.

Beispielsweise wird die Orientierung von Flüssigkristallen (englisch: liquid crystal [display],
LC[D]) mithilfe von Dünnschichttransistoren (englisch: thin-film transistor, TFT) verändert.
Die neu angeordneten Flüssigkristalle ändern die Durchlässigkeit von polarisiertem Licht, wel-
ches mit einer Hintergrundbeleuchtung und mit Polarisationsfiltern erzeugt wird. Das bedeutet,
dass die Lichtquelle auch bei einem schwarzen Bild konstant leuchtet und lediglich die Licht-
durchlässigkeit des Displays reguliert wird. Allerdings gibt es meist einen residualen Lichtstrom,
der die dunklen Bereiche verfälscht. Es kann also i.d.R. kein idealer Schwarzwert erreicht wer-
den. Bei LED-Bildschirmen wird die Hintergrundbeleuchtung daher mit LEDs erzeugt. welche
häufig für unterschiedliche Bildbereiche individuell angesteuert werden können. Dadurch wird
der Schwarzwert und somit der Kontrast deutlich verbessert.

Die OLED-Technologie erlaubt sogar die pixelgenaue Aktivierung von organischen Leuchtdi-
oden. Dies ermöglicht nahezu perfekte Schwarzwerte, allerdings ist die Herstellung (noch) et-
was teurer. Auf kleineren Displays findet bereits häufiger OLED-Technologie, beispielsweise auf
Smartphones. Neben der hohen Bildqualität ist ein weiterer Vorteil dieser Technologie, dass die
OLED-Strukturen auch auf flexiblem Material aufgebracht werden können (z.B. durch Druck-
verfahren).

Hohes Forschungsinteresse besteht zurzeit auch bei sogenannten Quantum Dot (QD) Displays.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


68

Anstatt die Grundfarben Rot, Grün und Blau zu verwenden, kann man Farbbilder auch in
anderen Farbräumen darstellen. Eines dieser alternativen Farbsysteme ist das YUV-System,
welches sich im europäischen Raum und seit den 1970ern auch in Amerika durchgesetzt hat. In
Amerika wurde zuvor das YIQ-System verwendet, bei welchem die Farbebene gegenüber dem
YUV-Farbmodell um 33◦ im Uhrzeigersinn gedreht ist.
Das YUV-Farbmodell verwendet zur Darstellung der Farbinformation die Luminanz (Lichtstärke
pro Fläche) Y und zwei Chrominanzanteile U und V, die für die Farbanteile stehen. Das System
ist durch PAL- und NTSC-Normen standardisiert und kann aus dem RGB-System durch eine
einfache Matrixmultiplikation berechnet werden:
 
0.2990 0.5870 0.1140
 
RGB2Y U V = −0.1480 −0.2890 0.4370
0.6150 −0.5150 −0.1000

Multipliziert man diese Matrix an einen 3 × 1 RGB-Vektor, der die Farbanteile eines Pixels
enthält, so erhält man den entsprechenden 3 × 1 YUV-Vektor. Die Komponenten in der ersten
Zeile der Transformationsmatrix sagen also aus, wie sich der Luminanzanteil Y aus den RGB-
Anteilen zusammensetzt. Man sieht, dass die Farbe Grün den mit Abstand größten Anteil zur
Gesamthelligkeit beiträgt. Dies hängt damit zusammen, dass der Mensch evolutionsbedingt für
die Farbe Grün am empflindlichsten ist.

Matlab kann Bilder nicht nur im uint8 sondern auch im double Format verarbeiten. In dieser
Aufgabe werden wir das double Format verwenden. Im Gegensatz zum uint8 Format hat jeder
Farbwert im double Format einen kontinuierlichen Wertebereich von 0 bis 1 (jeweils eingeschlos-
sen).

Erstellen Sie vier 3 × 1 Vektoren rotRGB, gruenRGB, blauRGB und weissRGB im double Format,
die jeweils die RGB-Anteile für einen roten, grünen, blauen und weißen Bildpunkt enthalten.

Aufgabe
Verwenden Sie die gegebene Matrix RGB2YUV um die drei Primärfarben in das YUV-System zu
transformieren und speichern Sie die Resultate in die Variablen
rotYUV, gruenYUV, blauYUV und weissYUV.

Lösung
>> rotRGB = [1; 0; 0];
>> gruenRGB = [0; 1; 0];
>> blauRGB = [0; 0; 1];
>> weissRGB = [1; 1; 1];

>> RGB2YUV = [0.299, 0.587, 0.114; -0.148, -0.289, 0.437; 0.615, -0.515,
-0.1];

>> rotYUV = RGB2YUV*rotRGB;

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


69

>> gruenYUV = RGB2YUV*gruenRGB;


>> blauYUV = RGB2YUV*blauRGB;
>> weissYUV = RGB2YUV*weissRGB;

Aufgabe 3b: Task 11

Die Verwendung des YUV-Systems hat für die Übertragung bzw. Speicherung von Bildern ge-
genüber dem RGB-System zwei entscheidende Vorteile:

1. Die Chrominanzanteile UV können mit geringerer Auflösung gespeichert werden, da Farb-


unterschiede die subjektive Bildqualität weniger beeinflussen als Intensitätsunterschiede.
Dies geht unmittelbar aus dem ungleichen Farbsehen des menschlichenAuges hervor. Un-
ter anderem nutzen Kompressionsverfahren wie beispielsweise JPEG oder MPEG diesen
Mechanismus aus.

2. Da im Y-Anteil die Luminanz des Signals enthalten ist, können analoge S/W-Fernseher
für analoges Farbfernsehen rückwärtskompatibel verwendet werden. Heutzutage ist dieser
Punkt natürlich nicht mehr relevant.

Ein anderes Helligkeits-Farbigkeits-Modell ist das YCbCr-Farbmodell, welches für das Digital-
fernsehen nach der PAL-Norm entwickelt wurde. Natürlich gibt es für die verschiedenen Farb-
transformationen auch entsprechende Funktionen in der Image Processing Toolbox. Um vom
RGB- zum YCbCr-System zu wechseln, kann man die Funktion rgb2ycbcr verwenden.

Der nachfolgende Matlab-Code transformiert jedes Pixel des Bildes lena aus dem RGB-System
in das YCbCr-System. Danach wird aus den Y-Komponenten ein Grauwertbild aufgebaut.

>> graubild = zeros(512,512);

>> for i = 1:512


>> for j = 1:512
>> R = lena(i,j,1);
>> G = lena(i,j,2);
>> B = lena(i,j,3);
>> farbeRGB = im2double([R,G,B]);
>> farbeYCbCr = rgb2ycbcr(farbeRGB);
>> graubild(i,j) = farbeYCbCr(1);
>> end
>> end

>> graubild = im2uint8(graubild);

Die obige Implementierung ist äußerst umständlich und benötigt sehr viel (!) Rechenzeit. Es
kann sein, dass der Code mehrere Minuten für die Ausführung benötigt. Wie wir bereits von den

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


70

vorangegangenen Versuchen wissen, ist Matlab nicht für die Programmierung mit for-Schleifen
optimiert. Schreiben Sie eine elegantere Implementierung, indem Sie vektorisiert arbeiten. Das
heißt, arbeiten Sie mit Vektoren und Matrizen statt mit for-Schleifen. Nennen Sie das resultie-
rende uint8-Grauwertbild graubild.

Eine kleine Optimierung wurde bereits implementiert.


Durch die Initialisierung der Matrix graubild mit Nullen, muss in der for-Schleife die Ma-
trix nicht ständig um Zeilen bzw. Spalten erweitert werden. Die Initialisierung von Variabeln,
die in einer unvermeidbaren for-Schleife ihre Größe ändern, ist eine einfache Möglichkeit die
Ausführung des Codes zu beschleunigen.

Aufgabe
Diese Aufgabe soll Ihnen nochmals näher bringen, wie man Matlab-Code vektorisieren kann.
Versuchen Sie dafür Schritt für Schritt vorzugehen und zu überlegen, welche Operationen ver-
einfacht werden können.

Lösung
1) Extraktion des Graubilds

Bei genauerer Prüfung wird deutlich, dass das Graubild nichts weiter als die ersten Kompo-
nenten jedes Pixels im neuen Bild ist. Diese lassen sich mit dem Doppelpunktoperator an-
stelle einer Schleife extrahieren. Dazu müssen lediglich die Zwischenergebnisse farbeYCbCr
innerhalb der Schleife zwischengespeichert werden. Dies kann man z.B. mithilfe einer neuen
Matrix bildYCbCr tun:

>> graubild = zeros(512,512);


>> bildYCbCr = zeros(512,512,3,'uint8'); % Initialisierung der neuen Variable

>> for i = 1:512


>> for j = 1:512
>> R = lena(i,j,1);
>> G = lena(i,j,2);
>> B = lena(i,j,3);
>> farbeRGB = im2double([R,G,B]);
>> bildYCbCr(i,j,:) = im2uint8(rgb2ycbcr(farbeRGB)); % RGB -> YCbCr
>> end
>> end

>> graubild = bildYCbCr(:,:,1); % Extraktion des Graubilds in nur einem


Schritt
>> graubild = im2uint8(graubild);

Auf den ersten Blick hat dies den Code sogar verkompliziert. Wie wir allerdings gleich
feststellen werden, sind dadurch nun andere Vereinfachungen ermöglicht worden.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


71

2) Konvertierung in YCbCr

Innerhalb der for-Schleifen findet nun ausschließlich die Konvertierung der RGB-Farben in
den YCbCr-Raum statt. Wie bereits im 2. Hinweis angegeben, ist die Funktion rgb2ycbcr
bereits nativ in Matlab vektorisiert. Das heißt, wir können anstelle der for-Schleifen eine
einzige Zeile schreiben:

>> graubild = zeros(512,512);


>> bildYCbCr = zeros(512,512,3,'uint8');

>> bildYCbCr = rgb2ycbcr(lena); % ehemalig for-Schleifen

>> graubild = bildYCbCr(:,:,1);


>> graubild = im2uint8(graubild);

3) Feintuning

Als letzten Punkt kann man dann noch die nun unnötig gewordenen Null-Initialisierungen
und die Konvertierungen zu anderen Datentypen entfernen, da rgb2ycbcr den Datentyp
nicht verändert. Man erhält:

>> bildYCbCr = rgb2ycbcr(lena);


>> graubild = bildYCbCr(:,:,1);

Optional kann man zur Validierung dann noch eine Darstellung in einer figure erzeugen:

>> figure;
>> imshow(graubild);
>> title('Graubild (Y-Komponente)');

Man sollte aus dieser Musterlösung mitnehmen, dass die nativen Matlab-Funktionen sehr
mächtige Werkzeuge sind, deren Verwendung manchmal ein bisschen Geschick oder zumin-
dest Nachdenken erfordert. Voreilige Implementierungen sind sonst unnötig langsam und
ineffizient!

Aufgabe 3c: Task 12

Es existieren außer den RGB-, YUV-, YIQ und YCbCr-Farbmodellen noch viele andere, welche
wiederum für bestimmte Zwecke besonders geeignet sind. Der Bezugspunkt, von dem aus alle
anderen kartesischen Systeme definiert sind, ist das XYZ-Farbsystem der Commission Interna-
tionale de l’Éclairage, auch bekannt als CIE. Der XYZ-Vektor wird durch Multiplikation mit
der entsprechenden Transformationsmatrix aus einem RGB-Farbvektor berechnet:
 
0.4900 0.3100 0.2000
 
T = 0.1770 0.8130 0.0100
0 0.0100 0.9900

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


72

Die XYZ-Darstellung hat keinen physikalischen Hintergrund, sie dient nur der Vereinheitlichung
und Normierung. Man bezeichnet XYZ deshalb auch als die virtuellen Normvalenzen.

Verantwortlich für die Chrominanz ist lediglich das Verhältnis der Koordinaten zueinander,
während die Summe der Komponenten eines RGB- bzw. eines XYZ-Vektors die Intensität angibt
(Luminanz). Um also unabhängig von der Intensität zu werden, führt man luminanznormierte
Koordinaten ein:

X Y Z
x= , y= , z=
X +Y +Z X +Y +Z X +Y +Z

Wie sich leicht zeigen lässt, ergibt sich aus der Normierung die folgende Eigenschaft:

x+y+z =1

D.h., jeweils eine Koordinate lässt sich aus den anderen beiden berechnen. Um den Farbraum
graphisch darzustellen, wählt man die Koordinaten x und y aus und erhält die sogenannte C.I.E.
Normtafel, in der sich alle wahrnehmbaren Chrominanzen darstellen lassen.

Unten sehen Sie die C.I.E.-Normtafel. Die dreistelligen Zahlen an den Begrenzungslinien des
Farbfeldes bezeichnen Wellenlängen monochromatischen Lichtes in nm. Der Punkt E ist der
Weißpunkt.

Abbildung 5: CIE Normtafel [?]

Prinzipiell ist eine Luminanzkorrektur auch in anderen Farbräumen möglich, der Farbraum XYZ
ist aber der einzige kartesische Farbraum, in dem alle sichtbaren Farben im positiven Bereich
der Koordinatenachsen liegen (denn mit diesem Ziel wurde er definiert).

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


73

Aufgabe
Stellen Sie die RGB-Grundfarben und Weiß im XYZ-System dar (rotXYZ, gruenXYZ, blauXYZ,
weissXYZ), sowie durch die luminanznormierten Koordinatenvektoren aus x- und y-Anteilen
(rotxy, gruenxy, blauxy, weissxy). Versuchen Sie nach Möglichkeit vektorisierten Code zu
schreiben. Zwei Zeilen pro Farbe sind ausreichend. Vergleichen Sie Ihre Ergebnisse mit den
Farb-Positionen auf der Normtafel.

Lösung
>> rotXYZ = T*rotRGB;
>> rotxy = rotXYZ(1:2)/sum(rotXYZ);

>> gruenXYZ = T*gruenRGB;


>> gruenxy = gruenXYZ(1:2)/sum(gruenXYZ);

>> blauXYZ = T*blauRGB;


>> blauxy = blauXYZ(1:2)/sum(blauXYZ);

>> weissXYZ = T*weissRGB;


>> weissxy = weissXYZ(1:2)/sum(weissXYZ);

Ende des Exkurses: Task 13

Neben der Bilddarstellung auf Fernseher- und Computermonitoren ist das Maschinelle Sehen
(englisch: Computer Vision) ein wichtiges Anwendungsgebiet der Bildverarbeitung, welches zu-
nehmend an Bedeutung gewinnt. Maschinell sehende Systeme werden derzeit vor allem in in-
dustriellen Hertellungsprozessen in den Bereichen Automatisierungstechnik und Qualitätssiche-
rung eingesetzt. Aber auch für selbstfahrende Autos und autonome Roboter ist das Gebiet von
grundlegender Bedeutung. Mithilfe von zunehmender Rechenleistung sind heutzutage viele Al-
gorithmen bereits für Privatanwender interessant. Im Bereich der 3D-Bildverarbeitung bietet
beispielsweise Microsoft Kinect einen günstigen Einstiegspunkt für Consumer.

Eine Aufgabenstellung, wie sie beispielsweise in der Industrie häufiger vorkommt, ist die Form-
und Maßprüfung eines Produkts. Zentral dafür ist die Möglichkeit, Kanten in einem Kamerabild
detektieren zu können. Die Image Processing Toolbox in Matlab stellt zu diesem Zweck die
Funktion edge bereit, welche ein Grauwertbild benötigt und daraus ein binäres Bild produziert,
mit einer 1 überall dort, wo Kanten gefunden wurden.

Um Kanten im Bild zu finden, verwendet edge sogennante Kantendetektionsfilter. Ein Beispiel


für solch ein Filter ist der Sobel-Operator. Die Grundlage für das Sobelfilter ist eine Faltung
des Bildes mit einer 3 × 3 Filtermatrix, die aus dem Originalbild ein Gradienten-Bild erzeugt.
Weitere Kantenfilter wie das Prewitt- oder das Cannyfilter werden ebenfalls von edge zur
Verfügung gestellt. Den Typ des Filters kann man der edge-Funktion dabei einfach als zweites
Argument als String übergeben.

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


74

Wenn Sie sich in diesem Gebiet weiter vertiefen möchten empfehlen wir folgende Vorlesung im
Master:

Multidimensional Digital Signal Processing

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


75

Index
Audiosignal, 32, 37 load, 17
Aufgabe starten, 6 numel, 38
ones, 11
Befehle play, 33, 35
’backslash’, 62 plot, 10
abs, 29 pretty, 52
angle, 29 randn, 40
audioplayer, 33, 35 rank, 61
audioread, 32, 36 real, 44
axis, 18 rectpuls, 17, 64
clear, 10 repmat, 38
conv, 21, 64 reshape, 38
cos, 26, 47 save, 17
ctranspose, 38 simplify, 47, 52
det, 61 sin, 47
diff, 50 size, 33, 38
dirac, 49, 50 sound, 39
doc, 31, 47, 64 stem, 27
eig, 61 stop, 33
exp, 52 subplot, 18
eye, 11 subs, 48
fft, 28, 41 syms, 47
fftshift, 42 tic toc, 22
figure, 13, 18, 27 title, 18
for-Schleife, 9, 19 transpose, 38
fourier, 55 tripuls, 17, 64
fplot, 48, 50 while-Schleife, 19
fprintf, 61 xy Label, 10, 20
heaviside, 48, 50 zeros, 11
help, 17, 47 ztrans, 54
if/else, 61
DFT, 25, 26, 28, 39
ifft, 32, 44
DFT Amplitude Korrektur, 31
ifourier, 56
DFT Bins Korrektur, 30
ilaplace, 53
Dirac, 50
int, 50
inv, 61 Elementweise Multiplikation, 9
iztrans, 55 Exkurs
LineWidth, 18 3D Matrizen, 62
linspace, 8, 9, 16, 20 Befehle

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie


76

histeq, 66 IZT, 55
im2bw, 66
laplace, 52
imadjust, 65
Laplace-Transformation ’LT’, 52
imhist, 64
LTI-Systeme, 15
imread, 60
Lösen GS, 62
imshow, 60, 62
rgb2gray, 64 MATLAB
whos, 60 Installation, 5
Bildverarbeitung, 60 Starten, 5
Graubild Erzeugung, 64 Matrix Erstellung, 11
Histogramme, 65 Matrizenrechnung, 62
Lena Söderberg, 60
Schwarz-Weiß Bilder, 67 Negationsoperator, 61
XYZ-System, 71
progress.mat, 6
YCbCr, 69
YUV-System, 68 Rauschen enfernen, 29
Faltung, 15, 20
Semikolon, 8
Faltung Korrektur, 22
Skalarmultiplikation, 35
FFT, 28
Symbolische Variablen, 47
Fragen, 6
Frequenzbins, 30 Toolboxen, 5
FT, 25, 55
Vektoren, 2-D und 3-D Matrizen, 33
Heaviside-Funktion, 48 Vektormultiplikation, 9
IDFT, 32 Vektorschreibweise, 8
IFFT, 44
Workspace, 7
IFT, 55
ILT, 53 Z-Transformation ’ZT’, 53
Impulsantwort, 15 Zeitliche Skalierung, 12

TUM, Lehrstuhl für MMK Matlab-Praktikum für Signaltheorie