Comment effectuer l'interpolation bilinéaire en Python

Je voudrais effectuer blinear interpolation à l'aide de python.
Exemple gps point pour lequel je tiens à interpoler la hauteur est de:

B = 54.4786674627
L = 17.0470721369

à l'aide de quatre points adjacents avec des coordonnées connues et les valeurs de hauteur:

n = [(54.5, 17.041667, 31.993), (54.5, 17.083333, 31.911), (54.458333, 17.041667, 31.945), (54.458333, 17.083333, 31.866)]

et voici mon essai primitif:

import math
z00 = n[0][2]
z01 = n[1][2]
z10 = n[2][2]
z11 = n[3][2]
c = 0.016667 #grid spacing
x0 = 56 #latitude of origin of grid
y0 = 13 #longitude of origin of grid
i = math.floor((L-y0)/c)
j = math.floor((B-x0)/c)
t = (B - x0)/c - j
z0 = (1-t)*z00 + t*z10
z1 = (1-t)*z01 + t*z11
s = (L-y0)/c - i
z = (1-s)*z0 + s*z1

où z0 et z1

z01  z0  z11

     z
z00  z1   z10

Je reçois 31.964 mais d'autres logiciels, je reçois 31.961.
Est mon script correct?
Pouvez-Vous fournir une autre approche?

Vous avez des erreurs d'arrondi et vous êtes arrondi??? Qu'advient-il si vous supprimez floor?
Ce sont L et B? Les coordonnées du point à partir duquel vous souhaitez interpoler?
la nostalgie c'est vrai
Une note de latitude et de longitude ne sont pas coordonnées planaires, de sorte que ce résultat ne sera pas vous obtenir ce que vous voulez si vous avez affaire à de grandes distances.

OriginalL'auteur daikini | 2011-12-28

Voici une réutilisables fonction que vous pouvez utiliser. Il comprend des doctests et de validation des données:

def bilinear_interpolation(x, y, points):
    '''Interpolate (x,y) from values associated with four points.

    The four points are a list of four triplets:  (x, y, value).
    The four points can be in any order.  They should form a rectangle.

        >>> bilinear_interpolation(12, 5.5,
        ...                        [(10, 4, 100),
        ...                         (20, 4, 200),
        ...                         (10, 6, 150),
        ...                         (20, 6, 300)])
        165.0

    '''
    # See formula at:  http://en.wikipedia.org/wiki/Bilinear_interpolation

    points = sorted(points)               # order points by x, then by y
    (x1, y1, q11), (_x1, y2, q12), (x2, _y1, q21), (_x2, _y2, q22) = points

    if x1 != _x1 or x2 != _x2 or y1 != _y1 or y2 != _y2:
        raise ValueError('points do not form a rectangle')
    if not x1 <= x <= x2 or not y1 <= y <= y2:
        raise ValueError('(x, y) not within the rectangle')

    return (q11 * (x2 - x) * (y2 - y) +
            q21 * (x - x1) * (y2 - y) +
            q12 * (x2 - x) * (y - y1) +
            q22 * (x - x1) * (y - y1)
           ) / ((x2 - x1) * (y2 - y1) + 0.0)

Vous pouvez exécuter le test de code en ajoutant:

if __name__ == '__main__':
    import doctest
    doctest.testmod()

De l'exécution de l'interpolation sur votre jeu de données produit:

>>> n = [(54.5, 17.041667, 31.993),
         (54.5, 17.083333, 31.911),
         (54.458333, 17.041667, 31.945),
         (54.458333, 17.083333, 31.866),
    ]
>>> bilinear_interpolation(54.4786674627, 17.0470721369, n)
31.95798688313631

Excellente solution, merci.
+1 pour le génie logiciel.
Hettinger Merci beaucoup pour cette réponse. Pourquoi ne pas scipy.interpolate.interp2d de travail dans ce cas? N'est-ce pas le interp2d également une interpolation bilinéaire, car il "une Interpolation sur une grille 2-D" (source: docs.scipy.org/doc/scipy-0.14.0/reference/generated/...) ?
Autant que je sache, c'est la méthode d'interpolation bilinéaire lorsque vous utilisez kind=linear. Empiriquement, j'ai aussi comparé les résultats entre cette réponse et interp2d avec kind=linear -- ils sont exactement les mêmes.

OriginalL'auteur Raymond Hettinger

Ne sais pas si cela aide beaucoup, mais j'obtiens une valeur différente lors de l'interpolation linéaire en utilisant scipy:

>>> import numpy as np
>>> from scipy.interpolate import griddata
>>> n = np.array([(54.5, 17.041667, 31.993),
                  (54.5, 17.083333, 31.911),
                  (54.458333, 17.041667, 31.945),
                  (54.458333, 17.083333, 31.866)])
>>> griddata(n[:,0:2], n[:,2], [(54.4786674627, 17.0470721369)], method='linear')
array([ 31.95817681])

Je Vous remercie pour Votre réponse.
griddata interpole linéairement dans un simplex (triangle) plutôt que de bilinearly dans un rectangle; cela signifie qu'il est en train de faire de la triangulation (Delaunay?) d'abord.

OriginalL'auteur jterrace

3

Vous pouvez également vous reporter à la interp fonction dans matplotlib.

OriginalL'auteur dgorissen

Inspiré de ici, je suis venu avec l'extrait de code suivant. L'API est optimisé pour la réutilisation d'un grand nombre de fois la même table:

from bisect import bisect_left

class BilinearInterpolation(object):
    """ Bilinear interpolation. """
    def __init__(self, x_index, y_index, values):
        self.x_index = x_index
        self.y_index = y_index
        self.values = values

    def __call__(self, x, y):
        # local lookups
        x_index, y_index, values = self.x_index, self.y_index, self.values

        i = bisect_left(x_index, x) - 1
        j = bisect_left(y_index, y) - 1

        x1, x2 = x_index[i:i + 2]
        y1, y2 = y_index[j:j + 2]
        z11, z12 = values[j][i:i + 2]
        z21, z22 = values[j + 1][i:i + 2]

        return (z11 * (x2 - x) * (y2 - y) +
                z21 * (x - x1) * (y2 - y) +
                z12 * (x2 - x) * (y - y1) +
                z22 * (x - x1) * (y - y1)) / ((x2 - x1) * (y2 - y1))

Vous pouvez l'utiliser comme ceci:

table = BilinearInterpolation(
    x_index=(54.458333, 54.5), 
    y_index=(17.041667, 17.083333), 
    values=((31.945, 31.866), (31.993, 31.911))
)

print(table(54.4786674627, 17.0470721369))
# 31.957986883136307

Cette version n'a pas de contrôle d'erreur et vous serez confronté à des problèmes si vous essayez de l'utiliser à la limite de l'index (ou au-delà). Pour la version complète du code, y compris la vérification des erreurs et en option de l'extrapolation, regardez ici.

OriginalL'auteur pmav99

2

Je pense que le point de faire une floor fonction, c'est que généralement vous êtes à la recherche d'interpoler une valeur dont les coordonnées se trouve entre deux discrète coordonnées. Cependant vous semblez avoir les vrai valeurs des coordonnées des points les plus proches, ce qui rend mathématiques simples.
```
z00 = n[0][2]
z01 = n[1][2]
z10 = n[2][2]
z11 = n[3][2]

# Let's assume L is your x-coordinate and B is the Y-coordinate

dx = n[2][0] - n[0][0] # The x-gap between your sample points
dy = n[1][1] - n[0][1] # The Y-gap between your sample points

dx1 = (L - n[0][0]) / dx # How close is your point to the left?
dx2 = 1 - dx1              # How close is your point to the right?
dy1 = (B - n[0][1]) / dy # How close is your point to the bottom?
dy2 = 1 - dy1              # How close is your point to the top?

left = (z00 * dy1) + (z01 * dy2)   # First interpolate along the y-axis
right = (z10 * dy1) + (z11 * dy2)

z = (left * dx1) + (right * dx2)   # Then along the x-axis
```
Il pourrait y avoir un peu de logique erronée dans la traduction de votre exemple, mais l'essentiel, c'est que vous pouvez le poids de chaque point de base sur la façon de beaucoup plus près, il est à l'interpolation but que de ses autres voisins.

N'êtes-vous pas oublier de diviser left, right et z par dy1+dy2, dy1+dy2 et dx1+dx2 respectueusement?
Je ne suis pas sûr de savoir pourquoi vous ferais ça. dx1, dx2, dy1, et dy2 sont tous normalisés supplémentaire des valeurs entre 0 et 1 (dy1+dy2 est toujours égal à 1) depuis dx est la distance totale entre le voisin et le voisin de droite, et de même pour dy.
Oh, désolé. Ils sont déjà normalisées.
la nostalgie, je ne sais pas si c'est clair que le but est d'interpoler la valeur de la hauteur pour un point donné, ce qui est d'environ 31 mètres selon les hauteurs de points adjacents 31.993, 31.911, 31.945, 31.866.
aspiration Merci pour Votre réponse.

OriginalL'auteur machine yearning

Vous devez vous connecter pour publier un commentaire.