7
votes

TRACE MATPLOTLIB Petite image sans rééchantillonnage

J'essaie de tracer une petite image en python à l'aide de Matplotlib et souhaiterais que les axes affichés aient la même forme que la matrice numpie qu'il a été générée à partir de, c'est-à-dire que les données ne doivent pas être rénovées. En d'autres termes, chaque entrée de la matrice doit correspondre à un pixel (ou à des zones) à l'écran. Cela semble trivial, mais même après le chalutage d'Internet pendant tout ce temps, je ne peux pas sembler le faire fonctionner:

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm

X = np.random.rand(30,40)

fig = plt.figure()
fig.add_axes(aspect="equal",extent=[0, X.shape[1], 0, X.shape[0]])
ax = fig.gca()
ax.autoscale_view(True, False, False)
ax.imshow(X, cmap = cm.gray)

plt.show()

python matplotlib

4 commentaires

On dirait que le code que vous avez fourni est le problème que vous voulez, la forme rectangulaire (40x30) est conservée dans l'image tracée et les limites de l'axe sont assorties à la forme de l'image. Est-ce que je manque quelque chose dans votre question?

Désolé, mon phrasé est déroutant. Ce qui m'intéresse est quelque chose comme la fonctionnalité Imshow dans Matlab, où le nombre de pixels de l'écran correspond au nombre d'entrées dans la matrice, c'est-à-dire que les axes ne sont pas rémunérés pour correspondre à la taille de la figure.

Voulez-vous dire une image sans interpolation? Si tel est le cas, changez simplement dans votre code imshow avec Matshow ou Ajouter interpolation = "le plus proche" comme paramètre sur la fonction Imshow.


                                        
                                                                            Merci, cela empêche une interpolation lisse, mais comment puis-je réduire la taille des axes afin que la figure reflète la faible résolution de l'image? Il semble toujours que cela semble être sauvé pour correspondre à la taille de la figure.



                                    
                    4 Réponses :
                    
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Je ne suis pas sûr de comprendre votre question complètement. Cela signifie-t-il que vous voulez l'axe X entre 0 et x.Shape [1] et l'axe Y entre 0 et X.Shape [0]? Dans ce cas, ce code devrait faire l'affaire:  xxx  
 espère qu'il aide                                   

                                                                    
                                    
                                    
                                        3 commentaires
                                        
                                                                                            
                                                    Merci, je suis désolé si ma question était confuse. J'essaie de faire quelque chose comme Imshow à Matlab, où les axes à l'intérieur de la figure ont la même taille que la matrice, par ex. Chaque pixel à l'écran correspond à une entrée de la matrice. Les réponses ci-dessus et refroient la matrice pour correspondre à la taille de la figure.                                                
                                                
                                                                                            
                                                    Je viens de trouver un poteau smiliaire sur Stackoverflow, ils utilisent l'argument d'interpolation d'Imshow: AX.IMSHOW (x, CMAP = cm.Gray, étendue = (0, x.shape [0], 0, x.Shape [0]) , interpolation = 'le plus proche') Voici le lien  Stackoverflow.com/Questtions/6323737/...                                                 
                                                
                                                                                            
                                                    Merci, en utilisant l'interpolation voisine la plus proche, c'est bien, mais je voudrais aussi que les axes soient petits, c'est-à-dire que cela reflète de manière plus étroitement la taille réelle de la matrice. À l'heure actuelle, il semble que les axes soient toujours repoussés pour correspondre à la taille de la figure.                                                
                                                
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Si vous connaissez la résolution native de votre image, vous pouvez définir l'argument DPI sur ce que vous voulez dans le  plt.figure (dpi = valeur) . .

 Vous pouvez trouver plus d'informations sur l'ajustement de la taille de l'image sur ce  lien .                                 


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    3
 votes
                                
                            
                            
                                
                                     Vous pouvez utiliser l'extrait de code suivant pour convertir un tableau en un Pil ( bibliothèque d'imagerie Python  A >). L'image résultante aura la même taille que la matrice d'entrée. Il peut être affiché ou sauvegardé comme une image. 
from PIL import Image
from numpy import linspace, array, fromfunction, sin, cos
from matplotlib import cm


# scale array between vmin and vmax and encode it to uint8 (256 values)
def scale(arr, vmin, vmax):
    return (255*(arr - vmin)/(vmax - vmin)).clip(0, 255).astype('uint8')

# convert a matplotlib colormap into a PIL palette
def getpalette(cmap):
    return (255.*array(map(lambda x: cmap(x)[0:3], linspace(0., 1.,256))).ravel()).astype('int')


# a sample array
data = fromfunction(lambda i,j: cos((i+j)/50)*sin(i/50.), (200, 300), dtype='float')

# convert the float array to a PIL image
im = Image.fromarray(scale(data, 0, 1))
im.putpalette(getpalette(cm.jet))
im.save('test.png') # or im.show()

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    5
 votes
                                
                            
                            
                                
                                     J'ai eu le même problème moi-même. Si le  interpolation = 'le plus proche'  code> option sur  imshow  code> n'est pas assez bon, si votre objectif principal est de voir brut, non échelonné, non interpolé, non interpolé, Muked à propos de pixels dans Matplotlib, vous ne pouvez pas battre  figIMage  code> IMHO. Démo: 
import numpy as np
import numpy.random
import matplotlib.pyplot as plt

a=256*np.random.rand(64,64)

f0=plt.figure()
plt.imshow(a,cmap=plt.gray())
plt.suptitle("imshow")

f1=plt.figure()
plt.figimage(a,cmap=plt.gray())
plt.suptitle("figimage")

plt.show()

                                

                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    Au cas où quelqu'un se demande, la seule façon de pouvoir obtenir Figimage de travailler sans quoi que ce soit sur la parcelle, à l'exception de l'image de l'ordinateur portable Ipython consistait à ajouter un jeu de axes vide ("éteint") avant le PLT.Show (), Akin à ce message S / O:  Stackoverflow.com/Questions/9295026/... . Sinon, cela n'a tout simplement rien tracé.