MINT lernen

Abituraufgaben: Verlustfrei oder mit Verlust

Zwei Abituraufgaben — Speicherformate beurteilen und Quantisieren mit Lauflänge in Java verbinden.

Dein Fortschritt:
0 / 0 Aufgaben
1

Bilder für die Schülerzeitung

13 BEAFB I–II

Die Schülerzeitung veröffentlicht Fotos, Ergebnistabellen und das Schullogo auf ihrer Webseite. Die Redaktion möchte Speicherplatz sparen, ohne dass Leserinnen und Leser Qualitätsverluste bemerken.

  1. Nennen Sie je zwei Merkmale verlustfreier und verlustbehafteter Kompression. (3 BE)
  2. Eine Kamera liefert Fotos mit 4000 × 3000 Pixeln und 24 Bit Farbtiefe; als JPEG sind sie 3,6 MB groß. Berechnen Sie die unkomprimierte Größe, das Kompressionsverhältnis und die prozentuale Datenersparnis (1 MB = 10⁶ Byte). (4 BE)
  3. Erläutern Sie, warum JPEG bei Fotos stark spart, beim Schullogo mit scharfer Schrift aber sichtbare Artefakte erzeugt. (3 BE)
  4. Legen Sie für das Klassenfoto, die Tabelle mit den Wettkampfergebnissen und das Schullogo jeweils ein geeignetes Speicherformat begründet fest. (3 BE)

Hinweise

Hinweis zu Aufgabe a)
Was passiert mit dem Original? Was wird entfernt?
Hinweis zu Aufgabe b)
Pixel · 24 Bit, durch 8 für Byte.
Hinweis zu Aufgabe c)
Was nimmt das Auge bei Fotos kaum wahr — und was bei Schrift sehr wohl?
Hinweis zu Aufgabe d)
Exakt nötig oder genügt die Wahrnehmung?

Erwartungshorizont

Erwartungshorizont zu Aufgabe a)

Verlustfrei: Original bitgenau wiederherstellbar; entfernt nur Redundanz (z. B. Lauflänge, Huffman, PNG). Verlustbehaftet: Original nicht wiederherstellbar; entfernt zusätzlich Irrelevanz, spart dadurch deutlich mehr (z. B. JPEG, MP3).

Erwartungshorizont zu Aufgabe b)

\(4000\cdot3000\cdot24=288\,000\,000\) Bit \(=36\) MB. Kompressionsverhältnis \(\tfrac{3{,}6}{36}=0{,}1=10\,\%\), Datenersparnis \((1-0{,}1)\cdot100\,\%=90\,\%\).

Erwartungshorizont zu Aufgabe c)

Fotos enthalten feine Helligkeits- und Farbschwankungen (Rauschen, Verläufe), die das Auge kaum unterscheidet; JPEG rundet sie grob, ohne dass es auffällt. Ein Logo hat harte Kanten und große einfarbige Flächen: Das Runden der feinen Details erzeugt Säume und Flecken an den Kanten, die sofort sichtbar sind. Für solche Grafiken ist PNG (verlustfrei, Lauflänge-ähnliche Verfahren) kleiner und exakt.

Erwartungshorizont zu Aufgabe d)

Klassenfoto: JPEG (verlustbehaftet, starke Ersparnis, Verlust unsichtbar). Tabelle: verlustfrei (z. B. als Text/CSV oder ZIP), jede Zahl muss stimmen. Logo: PNG (verlustfrei, große Flächen gut komprimierbar, keine Artefakte).

2

Erst runden, dann packen

16 BEAFB II–III

Ein Bildbearbeitungsprogramm speichert Graustufenbilder als int[][] bild mit Werten von 0 (schwarz) bis 255 (weiß). Vor dem verlustfreien Packen mit Lauflänge sollen die Werte auf weniger Stufen gerundet werden.

  1. Implementieren Sie eine Methode static int quantisiere(int wert, int stufen), die einen Grauwert 0 … 255 auf die nächstgelegene von stufen gleichmäßig verteilten Stufen rundet (bei 4 Stufen: 0, 85, 170, 255). (4 BE)
  2. Implementieren Sie eine Methode static int laeufe(int[] zeile), die die Anzahl der Läufe einer Bildzeile zurückgibt. (4 BE)
  3. Gegeben ist die Zeile 34 36 35 120 118 121 119 240 238 240 241 239. Lauflänge speichert je Paar 4 Bit Anzahl plus den Wert. Analysieren Sie den Speicherbedarf ohne und mit vorherigem Runden auf 4 Stufen (2 Bit). (4 BE)
  4. Zeigen Sie, dass zweimaliges Quantisieren mit derselben Stufenzahl dasselbe Ergebnis liefert wie einmaliges, und beurteilen Sie damit die Aussage „Jedes erneute verlustbehaftete Speichern verschlechtert ein Bild.“ (4 BE)

Hinweise

Hinweis zu Aufgabe a)
Erst die Nummer der Stufe bestimmen, dann zurückrechnen. Rechnen Sie mit 255.0, damit nicht ganzzahlig geteilt wird.
Hinweis zu Aufgabe b)
Jeder Wechsel zwischen Nachbarn beginnt einen neuen Lauf; die leere Zeile hat 0 Läufe.
Hinweis zu Aufgabe c)
Läufe zählen, dann Läufe · (4 + b) Bit; Vergleich mit 12 · 8 Bit Rohdaten.
Hinweis zu Aufgabe d)
Was liefert quantisiere für einen Wert, der schon eine Stufe ist?

Erwartungshorizont

Erwartungshorizont zu Aufgabe a)
public static int quantisiere(int wert, int stufen) {
    int stufe = (int) Math.round(wert * (stufen - 1) / 255.0);   // Nummer der nächsten Stufe
    return (int) Math.round(stufe * 255.0 / (stufen - 1));        // zurück auf 0 … 255
}

Beispiel: quantisiere(130, 4): \(130\cdot3/255\approx1{,}53\) → Stufe 2 → 170.

Erwartungshorizont zu Aufgabe b)
public static int laeufe(int[] zeile) {
    if (zeile.length == 0) {
        return 0;
    }
    int anzahl = 1;
    for (int i = 1; i < zeile.length; i++) {
        if (zeile[i] != zeile[i - 1]) {
            anzahl++;                           // neuer Lauf beginnt
        }
    }
    return anzahl;
}
Erwartungshorizont zu Aufgabe c)

Ohne Runden: 12 Läufe (keine gleichen Nachbarn) → \(12\cdot(4+8)=144\) Bit, mehr als die 96 Bit Rohdaten. Gerundet: 0 0 0 85 85 85 85 255 255 255 255 255 → 3 Läufe → \(3\cdot(4+2)=18\) Bit, \(k=\tfrac{18}{96}\approx18{,}8\,\%\). Preis: Abweichungen bis 36 (z. B. 36 → 0).

Erwartungshorizont zu Aufgabe d)

Nach dem ersten Aufruf ist der Wert genau eine Stufe \(s\cdot\tfrac{255}{q-1}\). Beim zweiten Aufruf ergibt \(\text{wert}\cdot\tfrac{q-1}{255}=s\) exakt, also wieder dieselbe Stufe — nichts ändert sich (für alle 256 Werte und alle Stufenzahlen 2 … 256 per Programm geprüft). Die Aussage gilt deshalb nicht allgemein: Verschlechterung entsteht erst, wenn zwischen zwei Speichervorgängen bearbeitet oder mit anderen Einstellungen gerundet wird, wie bei JPEG üblich (Generationsverlust).