Contour/imshow parcelle irrégulière X Y Z

J'ai des données en X, Y, Z format où tous sont des tableaux 1D, et Z est l'amplitude de mesure à coordonnées (X,Y). J'aimerais vous montrer ce que les données de contour ou "imshow complot" où les contours/couleur représente la valeur de Z (amplitude).

La grille pour les mesures et X et Y s'sont espacés de manière irrégulière.

Merci beaucoup,

len(X)=100

len(Y)=100

len(Z)=100

Éventuellement en double: stackoverflow.com/questions/3242382/...
votre tenté quelque chose? vous avez obtenu toutes les erreurs?
L'autre post, l'accent est mis principalement sur l'interpolation des données irrégulières en 2D. Je n'ai pas besoin/envie d'interpolation.

OriginalL'auteur Scientist | 2014-11-18

  1. 39

    Ne plt.tricontourf(x,y,z) satisfaire vos exigences?

    Il sera tracé de contours pour irrégulièrement espacés de données (non rectiligne de la grille).

    Vous pouvez également regarder dans plt.tripcolor().

    import numpy as np
import matplotlib.pyplot as plt
x = np.random.rand(100)
y = np.random.rand(100)
z = np.sin(x)+np.cos(y)
f, ax = plt.subplots(1,2, sharex=True, sharey=True)
ax[0].tripcolor(x,y,z)
ax[1].tricontourf(x,y,z, 20) # choose 20 contour levels, just to show how good its interpolation is
ax[1].plot(x,y, 'ko ')
ax[0].plot(x,y, 'ko ')
plt.savefig('test.png')

    Contour/imshow parcelle irrégulière X Y Z

    oui en effet, mais encore l'intrigue est trop rugueux. Je suis à la recherche des moyens de rendre une apparence plus douce. Merci!
    lorsque j'utilise tripcolor et aussi avoir de la parcelle (aléatoire) des points, j'ai généré, je vois qu'il ne peut pas être plus précis: une bonne triangulation est faite, et ces plaques sont ensuite remplies sur la base des valeurs dans les nœuds de l'triangles.
    Oliver, je vous remercie pour votre contribution. Je vais la pousser et voir si je peux ré-organiser les tableaux 1d, de sorte que le plt.le contour de l'utiliser.
    il n'est pas nécessaire de réorganiser les valeurs de plt.contour. Il suffit de regarder tricontourf (comme illustré dans la figure) ou tricontour (si vous n'aimez pas les contours).
    Pensé à une solution: Par l'augmentation de la "largeur" option dans tricontour, le lissage peut être atteint. Acclamations...

    OriginalL'auteur Oliver W.

  2. 2

    (Code Source @ la fin...)

    Voici un peu de bonbons pour les yeux que j'ai produit à jouer avec un peu tout ça. Il explore le fait qu'une transformation linéaire d'un meshgrid est encore un meshgrid. I. e. sur la gauche de l'ensemble de mes parcelles, je suis en train de travailler avec des coordonnées X et Y pour un 2-d (entrée) de la fonction. Sur la droite, je veux travailler avec (AVG(X, Y), Y-X) coordonne pour la même fonction.

    J'ai joué un peu avec meshgrids en natif les coordonnées et les transformer en meshgrids pour les autres coordonnées. Fonctionne très bien si la transformation est linéaire.

    Pour les deux derniers graphiques, j'ai travaillé avec l'échantillonnage aléatoire pour répondre directement à votre question.

    Voici les images avec setlims=False:
    Contour/imshow parcelle irrégulière X Y Z

    Et la même chose avec setlims=True:
    Contour/imshow parcelle irrégulière X Y Z

    import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
def f(x, y):
return y**2 - x**2
lim = 2
xlims = [-lim , lim]
ylims = [-lim, lim]
setlims = False
pde = 1
numpts = 50
numconts = 20
xs_even = np.linspace(*xlims, num=numpts)
ys_even = np.linspace(*ylims, num=numpts)
xs_rand = np.random.uniform(*xlims, size=numpts**2)
ys_rand = np.random.uniform(*ylims, size=numpts**2)
XS_even, YS_even = np.meshgrid(xs_even, ys_even)
levels = np.linspace(np.min(f(XS_even, YS_even)), np.max(f(XS_even, YS_even)), num=numconts)
cmap = sns.blend_palette([sns.xkcd_rgb['cerulean'], sns.xkcd_rgb['purple']], as_cmap=True)
fig, axes = plt.subplots(3, 2, figsize=(10, 15))
ax = axes[0, 0]
H = XS_even
V = YS_even
Z = f(XS_even, YS_even)
ax.contour(H, V, Z, levels, cmap=cmap)
ax.plot(H.flatten()[::pde], V.flatten()[::pde], linestyle='None', marker='.', color='.75', alpha=0.5, zorder=1, markersize=4)
if setlims:
ax.set_xlim([-lim/2., lim/2.])
ax.set_ylim([-lim/2., lim/2.])
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_title('Points on grid, contour')
ax = axes[1, 0]
H = H.flatten()
V = V.flatten()
Z = Z.flatten()
ax.tricontour(H, V, Z, levels, cmap=cmap)
ax.plot(H.flatten()[::pde], V.flatten()[::pde], linestyle='None', marker='.', color='.75', alpha=0.5, zorder=1, markersize=4)
if setlims:
ax.set_xlim([-lim/2., lim/2.])
ax.set_ylim([-lim/2., lim/2.])
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_title('Points on grid, tricontour')
ax = axes[0, 1]
H = (XS_even + YS_even) / 2.
V = YS_even - XS_even
Z = f(XS_even, YS_even)
ax.contour(H, V, Z, levels, cmap=cmap)
ax.plot(H.flatten()[::pde], V.flatten()[::pde], linestyle='None', marker='.', color='.75', alpha=0.5, zorder=1, markersize=4)
if setlims:
ax.set_xlim([-lim/2., lim/2.])
ax.set_ylim([-lim, lim])
ax.set_xlabel('AVG')
ax.set_ylabel('DIFF')
ax.set_title('Points on transformed grid, contour')
ax = axes[1, 1]
H = H.flatten()
V = V.flatten()
Z = Z.flatten()
ax.tricontour(H, V, Z, levels, cmap=cmap)
ax.plot(H.flatten()[::pde], V.flatten()[::pde], linestyle='None', marker='.', color='.75', alpha=0.5, zorder=1, markersize=4)
if setlims:
ax.set_xlim([-lim/2., lim/2.])
ax.set_ylim([-lim, lim])
ax.set_xlabel('AVG')
ax.set_ylabel('DIFF')
ax.set_title('Points on transformed grid, tricontour')
ax=axes[2, 0]
H = xs_rand
V = ys_rand
Z = f(xs_rand, ys_rand)
ax.tricontour(H, V, Z, levels, cmap=cmap)
ax.plot(H[::pde], V[::pde], linestyle='None', marker='.', color='.75', alpha=0.5, zorder=1, markersize=4)
if setlims:
ax.set_xlim([-lim/2., lim/2.])
ax.set_ylim([-lim/2., lim/2.])
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_title('Points random, tricontour')
ax=axes[2, 1]
H = (xs_rand + ys_rand) / 2.
V = ys_rand - xs_rand
Z = f(xs_rand, ys_rand)
ax.tricontour(H, V, Z, levels, cmap=cmap)
ax.plot(H[::pde], V[::pde], linestyle='None', marker='.', color='.75', alpha=0.5, zorder=1, markersize=4)
if setlims:
ax.set_xlim([-lim/2., lim/2.])
ax.set_ylim([-lim, lim])
ax.set_xlabel('AVG')
ax.set_ylabel('DIFF')
ax.set_title('Points random transformed, tricontour')
fig.tight_layout()

    OriginalL'auteur 8one6

  3. 0
    xx, yy = np.meshgrid(x, y)
plt.contour(xx, yy, z)

    N'est pas grave si ils sont espacés de manière irrégulière, le contour de la 3d et des parcelles nécessitent un meshgrid.

    Z doit être en deux dimensions dans ce cas. Ne fonctionne pas avec des tableaux 1d.
    Êtes-vous sûr que vous ne voulez pas un lines3d intrigue? Ressemble plus à ce que vos données est construit pour
    positive. J'ai besoin d'un tracé de contour. Quand je dis qu'ils sont des tableaux 1d, je ne dis pas que tous les éléments sont triés et représentent une ligne. x-y faire un nice-espacés de manière irrégulière - grille, chaque point ayant un correspondant de la valeur de Z.
    Si Z est 1-D des données, il est tout simplement pas aller travailler sur un tracé de contour. Par définition, le contour des pots requre Z de valeurs d'une matrice 2d. Pensez-y, chaque valeur de votre point de contour doit exister à certains points x et y, donc elle doit être en 2d. Mais 3 1-d les lignes peuvent être tracées comme lines3d: matplotlib.org/mpl_toolkits/mplot3d/tutorial.html Sinon, vous allez avoir besoin de vos données Z en fonction de X et Y.
    Ah je vois le drapeau tricolore de l'intrigue fonctionne pour ce type de données!

    OriginalL'auteur Adam Hughes

  4. 0

    Eh bien, si vous êtes prêt à s'écarter de Python dans son concurrent, R, j'ai juste remis un paquet à CRAN (qui devrait être disponible demain ou le jour suivant), qui conduit de contournement de sur la non-régulière des grilles -- le suivant peut être réalisé en quelques lignes de code:

    library(contoureR)
set.seed(1)
x = runif(100)
y = runif(100)
z = sin(x) + cos(y)
df = getContourLines(x,y,z,binwidth=0.0005)
ggplot(data=df,aes(x,y,group=Group)) + 
geom_polygon(aes(fill=z)) + 
scale_fill_gradient(low="blue",high="red") + 
theme_bw()

    Qui produit le texte suivant:

    Contour/imshow parcelle irrégulière X Y Z

    Si vous voulez une grille régulière, et ne peut se permettre un peu de temps de calcul:

    x = seq(0,1,by=0.005)
y = seq(0,1,by=0.005)
d = expand.grid(x=x,y=y)
d$z = with(d,sin(x) + cos(y))
df = getContourLines(d,binwidth=0.0005)
ggplot(data=df,aes(x,y,group=Group)) + 
geom_polygon(aes(fill=z)) + 
scale_fill_gradient(low="blue",high="red") + 
theme_bw()

    Contour/imshow parcelle irrégulière X Y Z

    Des bords flous ci-dessus, je sais comment le résoudre et devrait être corrigé pour la prochaine version du logiciel....

    OriginalL'auteur Nicholas Hamilton