Luxeria Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen:
tutorial:image

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen RevisionVorhergehende Überarbeitung
Nächste Überarbeitung		Vorhergehende Überarbeitung
tutorial:image [2015/07/26 13:29] – [Relative Häufigkeit] ninuxtutorial:image [2015/07/26 15:04] (aktuell) – [Beispiel] ninux
Zeile 168: Zeile 168:
 [count, value] = imhist(Image); [count, value] = imhist(Image);
 relCount = count/numel(Image); relCount = count/numel(Image);
 +</code>
 +
 +==== Kummulative Häufigkeit ====
 +Die kummulative Häufigkeit beschreibt den prozentualen Anteil der Pixel welche den Graustufenwert unterschreiten. Die y-Achse der kummulativen Häufigkeit ist also limitiert von 0 bis 1. Die Aussage welche gemacht werden kann ist, dass y% des Bildes einen Graustufenwert kleiner als x aufweist. Die Aussage kann auch umgedreht werden mit der Subtraktion von 1. Wenn also beispielsweise 30% der Pixel einen Graustufenwert kleiner als 128 haben, dann kann die Aussage getroffen werden, dass ''1 - 0.3 = 0.7 = 70%'' aller Pixel einen Wert höher als 128 haben.
 +
 +Um die kummulative Häufigkeit eines Bildes zu erhalten muss die kummulative Summe berechnet werden der relativen Häufigkeit wie im Folgenden gezeigt wird
 +
 +<code octave>
 +[count, value] = imhist(Image);
 +relCount = count/numel(Image);
 +cumCount = cumsum(relCount);
 +</code>
 +
 +==== Mittelwert ====
 +Der (arithmetische) Mittelwert gibt den Wert an, der sich bei Summierung aller Werte dividiert duch die Anzahl Werte ergibt (sozusagen den Schwerpunkt).
 +
 +In Octave kann der Mittelwert (engl. 'mean') eines Arrays bzw. Vecotrs mit der Funktion ''mean()'' ermittelt werden. Bilder sind jedoch ein 2D-Array bzw. eine Matrix und somit kommt abgeleitete Funktion ''mean2()'' zum Einsatz.
 +
 +<code octave>
 +grayMean = mean2(Image);
 +</code>
 +
 +==== Standardabweichung ====
 +Die Standardabweichung ist ein statistisches Mass für die Streuung. Es beschreibt eine mittlere Abweichung vom Mittelwert. Ein kleiner Wert bedeutet, dass viele Werte nahe beieinander liegen beim Mittelwert. Ein grosser Wert bedeutet dagegen, dass die Werte weit verstreut sind. Ein Bild mit vielen Abstufungen wird also eine grosse Standardabweichung aufweisen, ein eintöniges Bild eine kleine Standardabweichung.
 +
 +<code octave>
 +grayStdDev = std2(Image);
 +</code>
 +
 +==== Beispiel 3 ====
 +Das [[https://github.com/luxeria/foip/blob/master/src/chapter_01/exercise_03.m| Beispiel 3]] zeigt auf wie das Histogramm eines Bildes ermittelt wird als auch die absolute, relative und kummulative Häufigkeit von Pixelwerten.
 +
 +<code octave>
 +% load the image
 +Image = imread(imageSource);
 +     
 +% get histogramm results and do some calculations
 +[count, value] = imhist(Image);
 +        
 +relCount = count/numel(Image);    % calculate relative counts
 +cumCount = cumsum(relCount);      % calculate cumulative count
 +        
 +grayMean   = mean2(Image);        % calculate mean (2D)
 +grayStdDev = std2(Image);         % calculate standard deviation (2D)
 +</code>
 +
 +===== Quantisierung =====
 +Die Quantisierung eines Bildes gibt an, wie fein abgestuft die Pixelwerte sind in Anzahl Bit. Eine Quantisierung mit 8 Bit hat also eine Abstufung der Grauwerte in 256 Schritten, 6 Bit in 64 Schritten, 4 Bit in 16 Schritten usw.
 +
 +Um ein gegebenes Bild gröber abzustufen z.B von 8 Bit auf 4 Bit, müssen die Pixelwerte dividiert werden durch die Stufendifferenz (8 Bit - 4 Bit = 4 Bit = 16), gerundet auf ganze Zahlen und danach wieder multipliziert werden mit der Stufendifferenz um die richtige Helligkeit zurück zu erhalten.
 +
 +==== Veranschaulichung vom Informationsverlust ====
 +Bei der Division und Rundung geht Information verloren, d.h. bei diesem Schritt findet die eigentliche Umwandlung statt. Angenommen wir haben eine Zeile von Pixelwerten zwischen 100 und 120. Es gibt also 20 Abstufungen der Werte.
 +
 +    100   101   102   103   104   105
 +    106   107   108   109   110   111
 +    112   113   114   115   116   117
 +    118   119   120
 +
 +Dividiert man nun diese durch 16 (4 Bit) und rundet die Ergebnisse so befinden sich die Lösungen in einem Zahlenraum zwischen 25 und 30. Dies sind lediglich 5 Abstufungen statt wie vorher 20. Multipliziert man nun diese Werte wieder mit 16 so ergibt sich
 +
 +    96    96    96    96    96    96
 +    96    96    96    96    96    96
 +    112   112   112   112   112   112
 +    112   112   112 
 +
 +Diese Werte haben nun zwar die Richtigen Helligkeitsstufen damit das Bild einigermassen richtig aussieht, jedoch geht die Detailträue deutlich zurück.
 +
 +==== Beispiel 4 ====
 +Das [[https://github.com/luxeria/foip/blob/master/src/chapter_01/exercise_04.m| Beispiel 4]] zeigt wie ein Bild von 8 Bit auf 6, 4, und 2 Bit qantisiert wird.
 +
 +<code octave>
 +% load the image
 +Image = imread(imageSource);
 +        
 +% create the reduced images
 +Image8bit = Image;
 +Image6bit = floor(Image8bit/4)*4;
 +Image4bit = floor(Image8bit/16)*16;
 +Image2bit = floor(Image8bit/64)*64;
 +</code>
 +
 +===== Rasterung =====
 +Die Rasterung beschreibt die räumliche Auflösung (Pixelzahl) eines Bildes (im Gegensatz dazu die Quantisierung, welche die Abstufung der Pixelwerte beschreibt).
 +
 +Diese kann im Octave mittel der Funktion ''imresize()'' verändert werden.
 +
 +==== Beispiel 5 ====
 +
 +Das [[https://github.com/luxeria/foip/blob/master/src/chapter_01/exercise_05.m| Beispiel 5]] zeigt wie ein Bild umgewandelt werden kann auf eine andere Auflösung.
 +
 +<code octave>
 +% load the image
 +Image = imread(imageSource);
 +        
 +% create reduced images
 +Image1 = Image;
 +Image2 = imresize(Image1, 0.5);
 +Image3 = imresize(Image2, 0.5);
 +</code>
 +
 +===== LUT - look up table =====
 +Eine LUT (look up table) wird verwendet für die Zuordnung von Pixelwerten. Die Idee und Operation dazu ist relativ simpel. Für jeden Pixelwert gibt es genau einen korresponiderenden Eintag in einer Tabelle (LUT) welcher übernommen wird. Der gelesene Wert im Original dient dabei als Index für die Tabelle (LUT). Es findet also eine lineare und eindeutige Zuordnung von Werten statt beim Anwenden einer LUT.
 +
 +Im Folgenden ein Prinzipbeispiel einer invertierenden LUT
 +    
 +    LUT Index   0  1  2  3  4  5  6  7  8
 +    LUT Wert    8  7  6  5  4  3  2  1  0
 +    
 +    ----
 +    
 +    Image
 +            0   1   1   2   3
 +            1   1   2   3   4
 +            2   3   3   4   5
 +            4   4   5   6   7
 +            5   6   7   8   8
 +            
 +    apllyLUT(Image)
 +            8   7   7   6   5
 +            7   7   6   5   4
 +            6   5   5   4   3
 +            4   4   3   2   1
 +            3   2   1   0   0
 +
 +==== Beispiel 6 ====
 +Das [[https://github.com/luxeria/foip/blob/master/src/chapter_01/exercise_06.m|Beispiel 6]] zeigt wie verschiedene LUT definiert and angewendet werden.
 +
 +<code>
 +% load the image
 +Image = imread(imageSource);
 +        
 +% define look-up-table (LUT)
 +LUT_inverse = uint8([255:-1:0]);
 +LUT_bright  = uint8([0:255].*2);
 +LUT_special = uint8(horzcat([0:1:64], [64:2:((255-64)*2+62)]));
 +        
 +% apply LUTs
 +ImageInverse = intlut(Image, LUT_inverse);
 +ImageBright  = intlut(Image, LUT_bright);
 +ImageSpecial = intlut(Image, LUT_special);
 </code> </code>
tutorial/image.1437917390.txt.gz · Zuletzt geändert: 2015/07/26 13:29 von ninux
Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki