“Standard” RVB en niveaux de Gris de Conversion

Je suis en train d'écrire un convertisseurs algorithme qui prend une image JPEG et retourne sa PGM (Portable à Carte Grise) version.
Le problème est que je ne peux pas comprendre comment le "officielle" JPG->PGM convertitors de travail en termes de la valeur à affecter à la finale du pixel (je suppose, 0->255) en commençant par le classique format RGB.

Au début, j'ai utilisé cette formule (c'est la même que celle utilisée par OpenCV est CV_RGB2GRAY de conversion):

0.30*R + 0.59*G + 0.11*B = val

J'ai écrit un code simple pour tester mes résultats: il prend une couleur de l'image et de sa version PGM (déjà convertis à l'aide de GIMP). Puis il convertit la couleur de l'image à l'aide de la formule précédente. L'objectif est d'avoir une image en niveaux de gris qui est le pixel-à-pixel égal à la PGM entrée.

À ce stade, il ne retourne pas les mêmes valeurs. Pouvez-vous m'aider?

Avez-vous déjà eu un coup d'oeil à wikipédia: niveaux de Gris?
Êtes-vous sûr que c'est ce qu'il fait? Que faire si il décode seulement l'axe de l'avion et ignore la couleur-les coefficients? Vous auriez un bruit différent, et ces facteurs peuvent être différentes.
Désolé, je ne comprends pas votre post

OriginalL'auteur TheUnexpected | 2013-07-12

  1. 13

    Le problème est que je ne peux pas comprendre comment le "officielle" JPG->PGM convertitors de travail en termes de la valeur à affecter à la finale du pixel (je suppose, 0->255) en commençant par le classique format RGB.

    Il y a probablement un réglage du gamma dans la conversion de ceux "officiels" sont les outils de l'aide.
    C'est, ce n'est pas seulement une transformation linéaire.

    Voir Wikipédia cette section pour plus de détails: de la Conversion des couleurs en niveaux de gris

    Je crois que vous voulez utiliser la formule pour Csrgb.
    L'essayer et voir si elle correspond à des résultats que vous attendez.

    Fondamentalement, vous aurez à le faire:

    1. Prendre R, G, B couleur (dans [0,1] gamme)
      • Si ils sont dans la gamme 0..255 au lieu de cela, il suffit de diviser par 255.0
    2. Calculer Clinear = 0.2126 R + 0.7152 G + 0.0722 B
      • Il est probable que la transformation linéaire appliquant avant
    3. Calculer Csrgb selon c'est la formule, basée sur Clinear
      • C'est le non linéaire gamma correction de pièce, vous avez été absent
      • Découvrez ce WolframAlpha parcelle
      • Csrgb = 12.92 Clinear quand Clinear <= 0.0031308
      • Csrgb = 1.055 Clinear1/2.4 - 0.055 quand Clinear > 0.0031308
    J'ai mis à jour la réponse un peu à épeler les étapes exactes à suivre, depuis la page de Wikipedia pourrait être un peu cryptique si vous n'êtes pas familier avec certains de la couleur de base de la science.
    J'ai également ajouté un WolframAlpha complot pour vous afin que vous puissiez voir la non-linéaires de la forme de la correction de gamma.
    Timothée, s'il vous plaît corrigez-moi si je me trompe, mais je pense que après l'étape (1) que vous avez à transformer les valeurs d'intensité linéaire, depuis quand vous prenez les valeurs RVB à partir d'un fichier, ils sont déjà gamma-codé avec la puissance 1/2.4. Donc, vous devez d'abord supprimer cet encodage par application de la transformation avec la puissance de 2,4, et c'est seulement alors que les étapes (2) et (3) de votre réponse. Est ce que le droit?
    Vous êtes correct. C'est développer, trouver linéaire de luminance, puis de compresser.

    OriginalL'auteur Timothy Shields

  2. 4

    À harold de point sur le "Y" d'avion: couleur standard Jpeg sont codées à l'aide de la YCbCr palette, où Y est la composante de luminance (c'est à dire la luminosité) et Cb et Cr sont le bleu de différence et rouge de la différence des composants chromatiques. Donc, une façon de transformer un JPEG en couleur en niveaux de gris est simplement déposer les composantes Cb et Cr.

    Il y a un utilitaire appelé jpegtran que ne peut le faire sans perte, à l'aide de la -grayscale option. (La perte de la partie serait vraiment seulement affaire si vous voulais retrouver avec un JPEG et pas de PGM, pour éviter perte de génération.) En tout cas, ce serait sans doute le moyen le plus rapide pour faire cette transformation, parce qu'il n'a même pas de décoder l'image en pixels, beaucoup moins de faire des maths sur chacun d'eux.

    OriginalL'auteur Robert Fleming

  3. 1

    En théorie, avec un peu de pixels (3, dans ce cas), vous pouvez déterminer ce que leur algorithme est en train de faire.
    Juste choisissez vos trois pixels (p1, p2, p3), leur valeur RVB et leurs PGM de la valeur de gris, et vous avez:

    RedConstant * p1.redValue + GreenConstant * p1.greenValue + BlueConstant * p1.blueValue = p1.grayValue

    RedConstant * p2.redValue + GreenConstant * p2.greenValue + BlueConstant * p2.blueValue = p2.grayValue

    RedConstant * p3.redValue + GreenConstant * p3.greenValue + BlueConstant * p3.blueValue = p3.grayValue.

    Alors de résoudre ce problème ("equation solver" ou quelque chose) et de voir quels sont les constantes qu'ils utilisent.

    Merci mais, non, ça ne fonctionne pas. J'ai mis 3 valeurs de pixel et de résoudre un des trois équations du système. Il en résulte trois constantes qui sont bonnes pour les équations et pas pour un quatrième pixel.
    1) Êtes-vous sûr que vous avez choisi la même pixels RVB et de la valeur de gris? 2) de cet article: tannerhelland.com/3643/grayscale-image-algorithm-vb6 j'ai vu qu'ils étaient plusieurs RVB-PGM algorithme. Toutes les essayer et d'essayer de découvrir qui est utilisé. Bonne chance!
    Que faire si je vous dis que je n'ai pas trouvé de méthode valide?
    Eh bien, GIMP probablement utiliser leurs propres bizarre algorithme, quel est le réel but de tenter de recréer exactement leur convertisseur?
    Le processus de PGM la conversion est une sous-partie d'un algorithme. Après quelques tests, j'ai vu que les résultats de cet algorithme sont mieux si j'utilise un "GIMP" PGM image d'entrée, et pas une version simplifiée créée avec toutes ces méthodes. J'ai donc bien que le vrai PGM format décrit les valeurs des pixels d'une manière qui semblent être plus... "gérable" par mon algorithme. J'ai aussi essayé de regarder GIMP code, j'ai trouvé une possible conversion de point, mais il n'est pas lisible...

    OriginalL'auteur Fabinout

  4. 1

    ALGORITHME SIMPLE POUR CONVERTIR IMAGE RVB EN NIVEAUX DE GRIS DANS OPENCV PYTHON!

    J'ai utilisé les commentaires donc le code est auto-explicatif.Mais il fonctionne rapidement.

    import cv2
import numpy as np
img1 = cv2.imread('opencvlogo.png')
row,col,ch = img1.shape
g = [ ]  #the list in which we will stuff single grayscale pixel value inplace of 3 RBG values
#this function converts each RGB pixel value into single Grayscale pixel value and appends that value to list 'g'
def rgb2gray(Img):
    global g
    row,col,CHANNEL = Img.shape
    for i in range(row) :
        for j in range(col):
        a =      (   Img[i,j,0]*0.07  +  Img[i,j,1]*0.72 +    Img[i,j,2] *0.21   ) #the algorithm i used id , G =  B*0.07 + G*0.72 + R* 0.21
                                                                                   #I found it online
        g.append(a)
rgb2gray(img1)  #convert the img1 into grayscale
gr = np.array(g)  #convert the list 'g' containing grayscale pixel values into numpy array
cv2.imwrite("test1.png" , gr.reshape(row,col)) #save the image file as test1.jpg

    J'ai DONC utilisé ce fichier image ...“Standard” RVB en niveaux de Gris de Conversion

    Mon programme générés à la suite de fichier en niveaux de Gris ..

    “Standard” RVB en niveaux de Gris de Conversion

    Parcourir tous les pixels dans le code Python, d'effectuer le calcul en Python et en ajoutant le résultat dans une liste uniquement pour la convertir à un tableau numpy est lente comme l'enfer (et utilise environ 4 à 8 fois plus de mémoire que la solution optimale). Puisque vous avez déjà numpy, vous pouvez effectuer tout calcul sur le côté C à l'aide de la radiodiffusion, de la manière la plus rapide et évite les pertes de mémoire.
    Donc, après le chargement de l'image, le tout peut être réduit à gr = img1[:,:,0]*0.07 + img1[:,:,1]*0.72 + img1[:,:,2]*0.21 cv2.imwrite("test1.png", gr). Sur ma machine de votre code avec votre image 0.41 secondes, mon code 0.06; la différence est encore plus dramatique, avec des images plus grandes.

    OriginalL'auteur bad programmer

  5. 0

    Convertit un seul pixel d'entrée dans le modèle colorimétrique RVB par défaut d'un gris unique pixel.

    /* Convertation function 
 * @param x    the horizontal pixel coordinate
 * @param y    the vertical pixel coordinate
 * @param rgb  the integer pixel representation in the default RGB color model
 * @return a gray pixel in the default RGB color model.*/

    public int filterRGB(int x, int y, int rgb) {
    //Find the average of red, green, and blue.
    float avg = (((rgb >> 16) & 0xff) /255f +
                 ((rgb >>  8) & 0xff) /255f +
                  (rgb        & 0xff) /255f) /3;
    //Pull out the alpha channel.
    float alpha = (((rgb >> 24) & 0xff) /255f);

    //Calculate the average.
    //Formula: Math.min(1.0f, (1f - avg) /(100.0f /35.0f) + avg);
    //The following formula uses less operations and hence is faster.
    avg = Math.min(1.0f, 0.35f + 0.65f * avg);
    //Convert back into RGB.
   return (int) (alpha * 255f) << 24 |
          (int) (avg   * 255f) << 16 |
          (int) (avg   * 255f) << 8  |
          (int) (avg   * 255f);
}

    OriginalL'auteur Tomka Koliada

  6. -2

    Méthode de la moyenne est le plus simple. Vous avez juste à prendre la moyenne des trois couleurs. Depuis sa une image RVB, donc cela signifie que vous devez ajouter r à g avec b, puis le diviser par 3 pour obtenir vos propres niveaux de gris de l'image.

    Sa fait de cette façon.

    Grayscale = (R + G + B /3)

    Si vous avez une image en couleur comme l'image ci-dessus et que vous souhaitez les convertir en niveaux de gris à l'aide de méthode de la moyenne.

    OriginalL'auteur