Einsteigerguide: Einführung in die trilineare Interpolation.

Trilinear ist eine gerade Erweiterung der bilinearen Interpolationstechnik.

Sie kann als lineare Interpolation zweier bilinearer Interpolationen (eine für die Vorderseite der Zelle und eine für die Rückseite) betrachtet werden. Zur Berechnung von e und f verwenden wir zwei bilineare Interpolationen.

Zur Berechnung von g interpolieren wir linear e und f entlang der z-Achse (mit tz, der z-Koordinate des Abtastpunktes g).

Die trilineare Interpolation hat die gleichen Stärken und Schwächen wie das 2D-Pendant. Es ist ein schnell und einfach zu implementierender Algorithmus, aber er liefert keine sehr glatten Ergebnisse. Für Volumen-Rendering oder Fluidsimulationen, bei denen eine sehr große Anzahl von Lockups in 3D-Grids durchgeführt wird, es ist jedoch immer noch eine sehr gute Wahl.

Hier finden Sie einfaches Beispiel einer trilinearen Interpolation auf einem Grid. Beachten Sie, dass die Ergebnisse wie bei der bilinearen Interpolation als eine Reihe von Operationen (Zeilen xx bis xx) oder als Summe der 8 Ecken von Zellen mit einigen Koeffizienten (Zeile xx bis xx) berechnet werden können.

Copy to Clipboard

template<typename T> 
class Grid 
{ 
public: 
    unsigned nvoxels; // number of voxels (cube) 
    unsigned nx, ny, nz; // number of vertices 
    Vec3<T> *data; 
    Grid(unsigned nv = 10) : nvoxels(nv), data(NULL) 
    { 
        nx = ny = nz = nvoxels + 1; 
        data = new Vec3[nx * ny * nz]; 
        for (int z = 0; z < nz + 1; ++z) { 
            for (int y = 0; y < ny + 1; ++y) { 
                for (int x = 0; x < nx + 1; ++x) { 
                    data[IX(x, y, z)] = Vec3(drand48(), drand48(), drand48()); 
                } 
            } 
        } 
    } 
    ~Grid() { if (data) delete [] data; } 
    unsigned IX(unsigned x, unsigned y, unsigned z) 
    { 
        if (!(x < nx)) x -= 1; if (!(y < ny)) y -= 1; if (!(z < nz)) z -= 1; 
        return x * nx * ny + y * nx + z; 
    } 
    Vec3<T> interpolate(const Vec3<T>& location) 
    { 
        T gx, gy, gz, tx, ty, tz; 
        unsigned gxi, gyi, gzi; 
        // remap point coordinates to grid coordinates
        gx = location.x * nvoxels; gxi = int(gx); tx = gx - gxi; 
        gy = location.y * nvoxels; gyi = int(gy); ty = gy - gyi; 
        gz = location.z * nvoxels; gzi = int(gz); tz = gz - gzi; 
        const Vec3<T> & c000 = data[IX(gei, gyi, gzi)]; 
        const Vec3<T> & c100 = data[IX(gxi + 1, gyi, gzi)]; 
        const Vec3<T> & c010 = data[IX(gxi, gyi + 1, gzi)]; 
        const Vec3<T> & c110 = data[IX(gxi + 1, gyi + 1, gzi)]; 
        const Vec3<T> & c001 = data[IX(gxi, gyi, gzi + 1)]; 
        const Vec3<T> & c101 = data[IX(gxi + 1, gyi, gzi + 1)]; 
        const Vec3<T> & c011 = data[IX(gxi, gyi + 1, gzi + 1)]; 
        const Vec3<T> & c111 = data[IX(gxi + 1, gyi + 1, gzi + 1)]; 
#if 1 
        Vec3<T> e = bilinear<Vec3<T> >(tx, ty, c000, c100, c010, c110); 
        Vec3<T> f = bilinear<Vec3<T> >(tx, ty, c001, c101, c011, c111); 
        return e * ( 1 - tz) + f * tz; 
#else 
        return 
            (T(1) - tx) * (T(1) - ty) * (T(1) - tz) * c000 + 
            tx * (T(1) - ty) * (T(1) - tz) * c100 + 
            (T(1) - tx) * ty * (T(1) - tz) * c010 + 
            tx * ty * (T(1) - tz) * c110 + 
            (T(1) - tx) * (T(1) - ty) * tz * c001 + 
            tx * (T(1) - ty) * tz * c101 + 
            (T(1) - tx) * ty * tz * c011 + 
            tx * ty * tz * c111; 
#endif 
    } 
}; 
 
template<typename T> 
void testTrilinearInterpolation() 
{ 
    Grid<T> grid; 
    for (unsigned i = 0; i < 1000; ++i) { 
        // create a random location
        Vec3<T> result = grid.interpolate(Vec3(drand48(), drand48(), drand48())); 
    } 
}

Vielen Dank für ihren Besuch.

Einsteigerguide: Einführung in die trilineare Interpolation.

Leave A Comment

Link zur Datenschutzerklärung