Filtrowanie dwuliniowe

Powiększony fragment bitmapy, w której użyto (od lewej) filtrowania najbliższego sąsiada, filtrowania biliniowego i filtrowania bikubicznego

Filtrowanie dwuliniowe, filtrowanie biliniowe (ang. bilinear filtering) – technika znana z grafiki komputerowej mająca na celu poprawę jakości wyświetlania tekstur – polega ona na obliczaniu wartości (interpolacji) pomiędzy dyskretnymi punktami w teksturze zwanymi tekselami. Dzięki tej metodzie wyświetlane tekstury stają się gładsze.

Opis metody

Wartość w punkcie P jest obliczana na podstawie dwuliniowej interpolacji pomiędzy narożnymi punktami Q

Dwuwymiarowa tekstura w grafice komputerowej najczęściej jest reprezentowana jako dwuwymiarowa tablica teksli – punktów, których atrybutem jest np. kolor. Tego typu bitmapa ma określoną rozdzielczość, a wyświetlanie jej na ekranie komputera, polega na tym, że każdemu pikselowi przydzielany jest odpowiedni teksel. Najprostszą metodą takiego mapowania jest zastosowanie metryki najbliższego sąsiada (ang. nearest neighbour), czyli dla danego piksela wybierany jest najbliższy teksel. Niestety przy powiększeniu takiej tekstury widoczne stają się prostokątne obszary reprezentujące odpowiednie teksle. Aby temu zapobiec, stosuje się filtrowanie dwuliniowe, polegające na interpolacji wartości pomiędzy punktami reprezentującymi teksele.

Niech dla danego piksela na ekranie obliczony zostanie punkt $(x,y)$ w przestrzeni tekstury. Niech odpowiednie punkty reprezentujące teksle będą znajdowały się odpowiednio w punktach $Q_{11}=(x_{1},y_{1}),$ $Q_{12}=(x_{1},y_{2}),$ $Q_{21}=(x_{2},y_{1}),$ $Q_{22}=(x_{2},y_{2})$ oraz:

$x_{1}\leqslant x\leqslant x_{2},$

$y_{1}\leqslant y\leqslant y_{2}.$

Wówczas obliczona wartość tekstury w punkcie $(x,y)$ będzie wynosić:

$Q(x,y)=Q_{11}uv+Q_{12}u(1-v)+Q_{21}(1-u)v+Q_{22}(1-u)(1-v),$

gdzie $u={\frac {x-x_{1}}{x_{2}-x_{1}}},$ zaś $v={\frac {y-y_{1}}{y_{2}-y_{1}}}.$

Przykład implementacji

W języku C procedura filtrowania dwuliniowego może zostać zaimplementowana następująco:

double getBilinearFilteredPixelColor( Texture tex, double u, double v )
{
    u *= tex.size;
    v *= tex.size;
    int x = floor(u);
    int y = floor(v);
    double u_ratio = u - x;
    double v_ratio = v - y;
    double u_opposite = 1 - u_ratio;
    double v_opposite = 1 - v_ratio;
    double result = ( tex[x][y] * u_opposite + tex[x+1][y] * u_ratio ) * v_opposite +
        ( tex[x][y+1] * u_opposite + tex[x+1][y+1] * u_ratio ) * v_ratio;
    return result;
}

Zobacz też

• filtrowanie anizotropowe
• filtrowanie trójliniowe
• teksturowanie

Bibliografia

• Foley J.D., Van Dam A., Feiner S.K., Hughes J.F., Phillips R.L.: Introduction to Computer Graphics, Addison-Wesley Longman Publishing Co. Inc., 1994.