Jet palette de niveaux de gris

J'ai un jet palette de couleurs:

et je voudrais savoir s'il existe un moyen de convertir en niveaux de gris. Je ne peux pas utiliser la moyenne en raison maximale et la valeur minimale passe de la même couleur grise. Ou si il y a une certaine façon de se convertir à une autre palette de couleurs.

Je ne peux pas trouver sur Google une fonction pour convertir. MATLAB utilise quelque chose qui s'appelle rgb2ind mais j'aimerais connaître la formule.

Jet est unanimement considéré comme l'un des pires carte des couleurs disponibles, en dépit de sa popularité...

OriginalL'auteur PerroNoob | 2011-09-16

9

Permettez-moi d'abord de créer une image indexée à l'aide de la Jet palette de couleurs:
```
img = repmat(uint8(0:255), 100, 1);
cmap = jet(256);

imshow(img, 'Colormap',cmap)
```
À la simplicité de la conversion à l'aide d'IND2GRAY produit est le suivant:
```
J = ind2gray(img,cmap);
imshow(J)
```
Que vous avez exprimé, le min/max convergent vers la même valeur. De ce que j'ai compris, vous êtes à la recherche à la carte le jet palette de couleurs à linéairement passer de l'obscurité à la lumière des nuances de gris. Pour cela, on peut réorganiser l'aide de la valeur de la teinte de laquelle nous avons, avec le RGB2HSV fonction. Comparez les points suivants à l'encontre de l'original de la carte des couleurs:
```
[~,idx] = sortrows(rgb2hsv(cmap), -1);  %# sort by Hue
C = gray(256);
C = C(idx,:);

imshow(img, 'Colormap',C)
```
OriginalL'auteur Amro
3

créer l'image dans MATLAB
```
image(1:64);axis off;colormap(jet);
```
enregistrer l'image au format tiff, rogner les bords avec un Pinceau et de l'enregistrer en tant que '\directorypath\jetmage.tiff'.

charger l'image dans MATLAB
```
jetmage=imread('\\directorypath\jetmage.tiff');
```
obtenir la taille de l'image
```
[szX,szY,szZ]=size(jetmage);
```
obtenir une ligne de l'image pour chaque couleur, le rouge, le vert et le bleu.
```
r=reshape(jetmage(uint8(szX/2),:,1),[szY,1]);
g=reshape(jetmage(uint8(szX/2),:,2),[szY,1]);
b=reshape(jetmage(uint8(szX/2),:,3),[szY,1]);
```
tracer le profil d'intensité de chaque couleur pour cette ligne.
```
plot(r,'r-');hold on;
plot(g,'g-');hold on;
plot(b,'b-');hold on;
```
La parcelle doit être quelque chose comme:

vous pouvez utiliser la matrice de [r,g,b] que le look-up-table ou sur la base de cette
trouver un moyen d'obtenir la "formule" de la matrice [r,g,b]

OriginalL'auteur teng
0

rgb2ind convertit les valeurs RVB de chaque pixel dans les indices à l'intérieur d'une carte de la couleur. Si vous utilisez les 2 entrées de la version avec une carte de la couleur d'entrée, puis il va chercher la couleur la plus proche dans la carte de la couleur qui correspond à chaque pixel. Ce sera essentiellement vous donner un numéro unique pour chaque pixel, plutôt que d'une valeur RVB.

Par exemple, si vous chargez votre image
```
RGB = imread(imagefilename);
```
puis, depuis le Jet de la couleur de la carte retournée par jet, alors vous pouvez obtenir les données indexées à l'aide de
```
mapsize = 256;
map = jet(mapsize);
ind = rgb2ind(RGB, map);
```
Vous pouvez afficher l'image à l'aide de n'importe quelle couleur de la carte
```
colormap(map)
image(ind)
colormap('gray')
```
Ne pas utiliser imagesc parce qu'il peut s'étendre la plage dynamique de votre image de façon inacceptable.

OriginalL'auteur Nzbuu

Python de mise en œuvre de la réponse donnée par teng (en supposant un défaut matplotlib jetmap).

import pylab as plt
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
def PIL2array(img):
return numpy.array(img.getdata(),
numpy.uint8).reshape(img.size[1], img.size[0], 3)
def array2PIL(arr, size):
mode = 'RGBA'
arr = arr.reshape(arr.shape[0]*arr.shape[1], arr.shape[2])
if len(arr[0]) == 3:
arr = numpy.c_[arr, 255*numpy.ones((len(arr),1), numpy.uint8)]
return Image.frombuffer(mode, size, arr.tostring(), 'raw', mode, 0, 1)
def return_x(y,color,direction):
if color == "blue" and direction == "up":
m = (4.0 + 6.0/11.0)
c = 0.5
elif color == "blue" and direction == "down":
m = -3.226
c = 2.097
elif color == "green" and direction == "up":
m = 4.0
c = -0.5
elif color == "green" and direction == "down":
m = -3.704
c = 3.370
elif color == "red" and direction == "up":
m = 3.223
c = -1.129
elif color == "red" and direction == "down":
m = -4.545
c = 5.041
else:
print "Returning y:: INCORRECT OPTIONS"
m = 1
c = 0
return (y-c)/m 
# x >= y
def big_equal(x,y):
return x > y or np.allclose(x,y)
# x <= y
def less_equal(x,y):
return x < y or np.allclose(x,y)
def convert_jet_to_grey(img_array,n):
new_image = np.zeros((img_array.shape[0],img_array.shape[1]))
for i in range(img_array.shape[0]):
for j in range(img_array.shape[1]):
pixel_blue = img_array[i,j,2]
pixel_green = img_array[i,j,1]
pixel_red = img_array[i,j,0]
if (pixel_blue < 1) and big_equal(pixel_blue,0.5) and less_equal(pixel_green,0.5) :
#print "a1"
#print "i,j = ",i,",",j
new_image[i,j] = return_x(pixel_blue,"blue","up")**n
elif np.allclose(pixel_blue,1.0) and big_equal(pixel_green,0):
#print "b1"
#print "i,j = ",i,",",j
new_image[i,j] = return_x(pixel_green,"green","up")**n
elif (pixel_blue < 1) and big_equal(pixel_blue,0.4) and big_equal(pixel_green,0.5):
#print "c1"
#print "i,j = ",i,",",j
new_image[i,j] = return_x(pixel_green,"blue","down")**n
elif (pixel_red < 1) and big_equal(pixel_red,0.4) and big_equal(pixel_green,0.5):
#print "c2"
#print "i,j = ",i,",",j
new_image[i,j] = return_x(pixel_green,"red","up")**n
elif np.allclose(pixel_red,1.0) and big_equal(pixel_green,0):
#print "b2"
#print "i,j = ",i,",",j
new_image[i,j] = return_x(pixel_green,"green","down")**n
elif (pixel_red < 1) and big_equal(pixel_red,0.5) and less_equal(pixel_green,0.5):
#print "a2"
#print "i,j = ",i,",",j
new_image[i,j] = return_x(pixel_blue,"red","down")**n
else:
print "Leaving 0:: NOT A JET IMAGE"
return new_image
def main():
img = Image.open('test.jpg')
arr = PIL2array(img)
img_new = convert_jet_to_grey(arr/255.0,1)
imgplot = plt.imshow(img_new)
plt.show()
if __name__ == '__main__':
main()

OriginalL'auteur trienko

Vous devez vous connecter pour publier un commentaire.