Numpy - Regrid avec Redémarrage de moyenne

Question

J'essaie d'implémenter quelque chose de similaire à ce qui a été répondu en this post à propos de la régénération en python. La question contenue dans cet article consistait à repeindre un tableau de telle sorte qu'une cellule de sortie contienne la moyenne de toutes les cellules d'entrée qui y ont contribué. Le problème était que chaque cellule d'entrée (je pense) contribue à une seule cellule de sortie - c'est-à-dire qu'il n'y a pas de véritable moyen de rendre compte du cas où une cellule d'entrée chevauche deux cellules de sortie. Je me demande s'il existe un moyen de généraliser cette méthode pour prendre en compte le chevauchement des cellules - si, par exemple, j'ai deux bacs d'entrée qui s'étendent de 0 à 1 et 1 à 2 et une cellule de sortie qui s'étend de 0,75 à 0,75 à 0,65. 2, je voudrais prendre une sorte de moyenne pondérée pour calculer la valeur dans la cellule de sortie qui reconnaît que la cellule d'entrée qui s'étendait de 1 à 2 devrait contribuer environ 4x plus à la cellule de sortie que celle qui s'étendait de 0 à 1.

Ce n'est pas une interpolation, en soi, mais à peu près toutes les méthodes que j'ai essayées de faire quelque chose de similaire l'utilisent. Le problème avec une interpolation directe vers le haut avec, par exemple, np.interp est que cette routine ignore simplement certains des points si plus d'une cellule d'entrée contribue à une cellule de sortie.

Answer 1

Je ne suis pas certain de ce que vous cherchez, mais je travaille sur quelque chose de similaire en ce moment. J'ai deux grilles de différences finies uniformes, et j'ai besoin de faire correspondre les informations de l'une à l'autre et inversement. Ce code convient à mes besoins. Cette fonction, x_to_x, crée une matrice, M, telle que je peux prendre le produit scalaire de M avec des données sur la grille a et produire des données sur la grille b.

def x_to_x(xa, da, xb, db): 
    a = np.tile(xa, (np.size(xb), 1)) 
    b = np.tile(xb, (np.size(xa), 1)).T 
    a_l = a - da/2 
    a_r = a + da/2 
    b_l = b - db/2 
    b_r = b + db/2 
    x_l = np.maximum(a_l, b_l) 
    x_r = np.minimum(a_r, b_r) 
    return np.maximum(x_r - x_l, 0.)/db 

Si vous avez une grille non uniforme, da et db pourrait être adapté d'être à quelque chose comme scalaires, par exemple, da = np.hstack(a[1:] - a[:-1], a[-1] - a[-2]).