Jet colormap in scala di grigi

Question

ho una mappa di colori a getto:

e vorrei sapere se c'è un modo per convertire in scala di grigi. Non posso usare la media perché il valore massimo e minimo va allo stesso colore grigio. O se c'è un modo per convertire in un'altra tavolozza di colori.

Non riesco a trovare su Google una funzione per convertirlo. MATLAB usa qualcosa chiamato rgb2ind ma vorrei conoscere la formula.

Answer 1

Prima mi permette di creare un'immagine indicizzata utilizzando la mappa colori Jet:

img = repmat(uint8(0:255), 100, 1); 
cmap = jet(256); 

imshow(img, 'Colormap',cmap) 

La conversione semplice utilizzando IND2GRAY produce il seguente:

J = ind2gray(img,cmap); 
imshow(J) 

Come hai espresso , il minimo/massimo convergono allo stesso valore. Da quello che ho capito, stai cercando di mappare la mappa dei colori del getto per passare linearmente da sfumature di grigio a leggere. Per questo, possiamo reorder using the hue value che otteniamo con la funzione RGB2HSV. Confrontare il seguente contro la mappa colore originale:

[~,idx] = sortrows(rgb2hsv(cmap), -1); %# sort by Hue 
C = gray(256); 
C = C(idx,:); 

imshow(img, 'Colormap',C) 

Answer 2

creare l'immagine in MATLAB

image(1:64);axis off;colormap(jet); 

salvare l'immagine come TIFF, affiorano i confini con il pennello e salvare come '\ DirectoryPath \ jetmage.tiff'.

carico l'immagine in MATLAB

jetmage=imread('\\directorypath\jetmage.tiff'); 

dimensioni immagine get

[szX,szY,szZ]=size(jetmage); 

ottenere una fila di immagine per ciascun colore, rosso, verde e blu.

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]); 

tracciare il profilo di intensità per ciascun colore per quella riga.

plot(r,'r-');hold on; 
plot(g,'g-');hold on; 
plot(b,'b-');hold on; 

La trama deve essere qualcosa in questo modo:

è possibile utilizzare array di [r,g,b] come il look-up-table o base su quel trovare un modo per ottenere la 'formula 'dall'array [r,g,b]

Answer 3

rgb2ind converte i valori RGB per ciascun pixel in indici all'interno di una mappa colori. Se si utilizza la versione a 2 ingressi con un input della mappa dei colori, quindi cercherà il colore più vicino nella mappa dei colori corrispondente a ciascun pixel. Questo fondamentalmente ti darà un singolo numero per ogni pixel, piuttosto che un valore RGB.

Ad esempio, se si carica l'immagine

RGB = imread(imagefilename); 

poi, dal momento che la mappa dei colori Jet viene restituito dalla jet, quindi è possibile ottenere i dati indicizzati utilizzando

mapsize = 256; 
map = jet(mapsize); 
ind = rgb2ind(RGB, map); 

È quindi possibile visualizzare l'immagine utilizzando qualsiasi mappa dei colori

colormap(map) 
image(ind) 
colormap('gray') 

Non utilizzare imagesc perché e può allungare la gamma dinamica della tua immagine in modo inaccettabile.

Answer 4

implementazione di Python della risposta data dal teng (assumendo una jetmap matplotlib default).

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()