2x1=10

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.

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

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

Flipquad-gefiltertes Bild

Und das war das.

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