2x1=10

because numbers are people, too
Persönliches
Fotografie
Programmierung
    • Fliptri/Flipquad Image Filtering

      Neugierig und etwas gelang­weilt kam ich heute auf die Idee, auszupro­bieren, was wohl passieren würde, wenn man die bei­den Super­sam­pling-Ver­fahren Flip­tri und Flipquad als Fil­ter eines beste­hen­den Bildes inter­pretiert. Resul­tat des Abends: Wir reden nicht darüber.

      Grundlage

      Bei­den Ver­fahren liegt zugrunde, dass zur Erzeu­gung eines Pix­els mehrere umgebende (Sub-)Pixel aus­gew­ertet wer­den, wobei das Muster der Auswer­tung für anliegende Bild­punk­te hor­i­zon­tal und/oder ver­tikal gespiegelt — geflippt — wird. Die bei­den Ver­fahren unter­schei­den sich dabei lediglich hin­sichtlich der Anzahl der Sam­pling­punk­te.

      Anschaulich­er in der Grafik: Jew­eils drei Sam­pling­punk­te (rot) ergeben einen Bild­punkt (blau) bei Flip­tri; Bei Flipquad sind es vier Sam­pling­punk­te pro Bild­punkt.

      Visualisierung von Fliptri und Flipquad

      Der resul­tierende Bild­punkt B ist dabei schlichtweg die gewichtete Summe aller Sam­pling­punk­te S:


      \begin{align}
      B = \frac{1}{N} \sum \limits_{i=1}^N S_i
      \end{align}

      Implementierung in Matlab

      Fliptri

      Zu jedem Punkt müssen drei umgebende Pix­el aufgenom­men wer­den. Im unge­spiegel­ten Fall liegen diese an den Koor­di­nat­en (x-1, y-1), (x, y+1) und (x+1, y). Wie aus der Abbil­dung zu erken­nen ist, müssen die X- und Y-Koor­di­nat­en (genauer: Deren Off­sets -1, 0 und +1) für jede ger­ade Zeile gespiegelt wer­den, was man durch fol­gen­den Kun­st­griff erre­icht:

      x_sample = x_offset*(-1)^x + x;
      y_sample = y_offset*(-1)^y + y;
      

      Der Rest ist schnell erledigt:

      function pixel = fliptri(x, y, rgb)
      
          %   1   2   3
          % +---+---+---+
          % | X |   |   |
          % +---+---+---+
          % |   |   | X |
          % +---+---+---+
          % |   | X |   |
          % +---+---+---+
          coords = [ -1  0 +1;  % X
                     -1 +1  0]; % Y
      
          N = length(coords);
      
          % Flip 
          sgn_x = (-1)^x;
          sgn_y = (-1)^y;
      
          % Sample
          for s=1:N
              sample(s, 1:3) = rgb( ...
                       x+coords(1,s)*sgn_x, ...
                       y+coords(2,s)*sgn_y, ...
                       1:3);
          end
      
          % Combine
          pixel = sum(sample) / N;
      end
      

      Zulet­zt muss das Bild noch geladen und gefiltert wer­den. (Da die Größe des gedacht­en Fil­terk­er­nels der Größe drei entspricht, müssen die Start- und Endin­dizes jew­eils um den Wert 1 reduziert wer­den.)

      % Load the image
      rgb = imread('aliased.png');
      
      % Sample the image
      imagesize   = size(rgb);
      width       = imagesize(1);
      height      = imagesize(2);
      rgb_sampled = uint8(zeros(imagesize));
      for y=2:height-1
          for x=2:width-1
              rgb_sampled(x, y, 1:3) = fliptri(x, y, rgb);
          end
      end
      

      Flipquad

      Ana­log zum Flip­tri funk­tion­iert der Flipquad-Algo­rith­mus, allerd­ings ist die Off­setko­r­rek­tur hier vom Wert zwei, und es wer­den vier, statt drei Werten ver­ar­beit­et:

      function pixel = flipquad(x, y, rgb)
      
          %   1   2   3   4   5
          % +---+---+---+---+---+
          % |   | X |   |   |   |
          % +---+---+---+---+---+
          % |   |   |   |   | X |
          % +---+---+---+---+---+
          % |   |   |   |   |   |
          % +---+---+---+---+---+
          % | X |   |   |   |   |
          % +---+---+---+---+---+
          % |   |   |   | X |   |
          % +---+---+---+---+---+
      
          coords = [ -2 -1 +1 +2;  % X
                     -1 +2 -2 +1]; % Y  
      
          N = length(coords);
      
          % Flip 
          sgn_x = (-1)^x;
          sgn_y = (-1)^y;
      
          % Sample
          sample = zeros(3,3);
          for s=1:N
              sample(s, 1:3) = rgb( x+coords(1,s)*sgn_x, ...
                                    y+coords(2,s)*sgn_y, ...
                                    1:3);
          end
      
          % Combine
          pixel = sum(sample) / N;
      end
      

      Der Rest funk­tion­iert wie gehabt.

      Das Ergebnis

      Ernüchternd scheiße.

      Originalbild

      Fliptri-gefiltertes Bild

      Fliptri-gefilterte Version des Rerferenzbildes

      Flipquad-gefiltertes Bild

      Fliptri-gefilterte Version des Rerferenzbildes

      Und das war das.

      Wie ich ein­gangs bere­its erwäh­nte: … — aber wenig­stens war man dabei. Prost.

      November 4th, 2011 GMT +2 von
      Markus
      2011-11-4T03:58:08+02:00 2018-03-4T14:44:01+02:00 · 0 Kommentare
      Matlab
      MATLAB Image Processing

      Hinterlasse einen Kommentar

      Hier klicken, um das Antworten abzubrechen.

    1. « newer
    2. 1
    3. …
    4. 33
    5. 34
    6. 35
    7. 36
    8. 37
    9. 38
    10. 39
    11. …
    12. 43
    13. older »
    • Kategorien

      • .NET
        • ASP.NET
        • Core
        • DNX
      • Allgemein
      • Android
      • Data Science
      • Embedded
      • FPGA
      • Humor
      • Image Processing
      • Kalman Filter
      • Machine Learning
        • Caffe
        • Hidden Markov Models
        • ML Summarized
        • Neural Networks
        • TensorFlow
      • Mapping
      • MATLAB
      • Robotik
      • Rust
      • Signal Processing
      • Tutorial
      • Version Control
    • Neueste Beiträge

      • Summarized: The E-Dimension — Why Machine Learning Doesn’t Work Well for Some Problems?
      • Use your conda environment in Jupyter Notebooks
      • Building OpenCV for Anaconda Python 3
      • Using TensorFlow’s Supervisor with TensorBoard summary groups
      • Getting an image into and out of TensorFlow
    • Kategorien

      .NET Allgemein Android ASP.NET Caffe Core Data Science DNX Embedded FPGA Hidden Markov Models Humor Image Processing Kalman Filter Machine Learning Mapping MATLAB ML Summarized Neural Networks Robotik Rust Signal Processing TensorFlow Tutorial Version Control
    • Tags

      .NET Accelerometer Anaconda Bitmap Bug Canvas CLR docker FPGA FRDM-KL25Z FRDM-KL26Z Freescale git Gyroscope Integration Drift Intent J-Link Linear Programming Linux Magnetometer Matlab Mono Naismith OpenCV Open Intents OpenSDA Optimization Pipistrello Player/Stage PWM Python Sensor Fusion Simulink Spartan 6 svn tensorflow Tilt Compensation TRIAD ubuntu Windows Xilinx Xilinx SDK ZedBoard ZYBO Zynq
    • Letzte Kommetare

      • Lecke Mio bei Frequency-variable PWM generator in Simulink
      • Vaibhav bei Use your conda environment in Jupyter Notebooks
      • newbee bei Frequency-variable PWM generator in Simulink
      • Markus bei Using TensorFlow’s Supervisor with TensorBoard summary groups
      • Toke bei Using TensorFlow’s Supervisor with TensorBoard summary groups
    • Blog durchsuchen

    • November 2011
      M D M D F S S
      « Apr   Nov »
       123456
      78910111213
      14151617181920
      21222324252627
      282930  
    • Self

      • Find me on GitHub
      • Google+
      • Me on Stack­Ex­change
      • Ye olde blog
    • Meta

      • Anmelden
      • Beitrags-Feed (RSS)
      • Kommentare als RSS
      • WordPress.org
    (Generiert in 0,386 Sekunden)

    Zurück nach oben.