Rilevamento delle immagini in scala di grigi con .Net

Question

Sto analizzando i documenti in immagini JPG. Lo scanner deve eseguire la scansione di tutte le pagine come colore o tutte le pagine in bianco e nero. Poiché molte delle mie pagine sono a colori, devo eseguire la scansione di tutte le pagine come colore. Una volta completata la scansione, vorrei esaminare le immagini con .Net e provare a rilevare quali immagini sono in bianco e nero in modo da poter convertire tali immagini in scala di grigi e salvare in memoria.

Qualcuno sa come rilevare un'immagine in scala di grigi con .Net?

Per favore fatemi sapere.

Answer 1

Un semplice algoritmo per verificare il colore: Cammina l'immagine pixel per pixel in un ciclo annidato per larghezza e altezza e verifica se i valori RGB del pixel sono uguali. Se non lo sono, l'immagine ha informazioni sul colore. Se lo fai completamente attraverso tutti i pixel senza incontrare questa condizione, allora hai un'immagine in scala di grigi.

Revisione con un algoritmo più complesso:

Nel primo giro di questo post ho proposto un semplice algoritmo che presuppone che i pixel sono scala di grigi se RGB di ciascun pixel sono valori sono uguali. Quindi RGBs di 0,0,0 o 128,128,128 o 230,230,230 verrebbero tutti testati come grigio mentre 123,90,78 non lo farebbero. Semplice.

Ecco uno snippet di codice che verifica una varianza dal grigio. I due metodi sono una piccola sottosezione di un processo più complesso ma dovrebbero fornire abbastanza codice raw per aiutare con la domanda originale.

/// <summary> 
/// This function accepts a bitmap and then performs a delta 
/// comparison on all the pixels to find the highest delta 
/// color in the image. This calculation only works for images 
/// which have a field of similar color and some grayscale or 
/// near-grayscale outlines. The result ought to be that the 
/// calculated color is a sample of the "field". From this we 
/// can infer which color in the image actualy represents a 
/// contiguous field in which we're interested. 
/// See the documentation of GetRgbDelta for more information. 
/// </summary> 
/// <param name="bmp">A bitmap for sampling</param> 
/// <returns>The highest delta color</returns> 
public static Color CalculateColorKey(Bitmap bmp) 
{ 
    Color keyColor = Color.Empty; 
    int highestRgbDelta = 0; 

    for (int x = 0; x < bmp.Width; x++) 
    { 
     for (int y = 0; y < bmp.Height; y++) 
     { 
      if (GetRgbDelta(bmp.GetPixel(x, y)) <= highestRgbDelta) continue; 

      highestRgbDelta = GetRgbDelta(bmp.GetPixel(x, y)); 
      keyColor = bmp.GetPixel(x, y); 
     } 
    } 

    return keyColor; 
} 

/// <summary> 
/// Utility method that encapsulates the RGB Delta calculation: 
/// delta = abs(R-G) + abs(G-B) + abs(B-R) 
/// So, between the color RGB(50,100,50) and RGB(128,128,128) 
/// The first would be the higher delta with a value of 100 as compared 
/// to the secong color which, being grayscale, would have a delta of 0 
/// </summary> 
/// <param name="color">The color for which to calculate the delta</param> 
/// <returns>An integer in the range 0 to 510 indicating the difference 
/// in the RGB values that comprise the color</returns> 
private static int GetRgbDelta(Color color) 
{ 
    return 
     Math.Abs(color.R - color.G) + 
     Math.Abs(color.G - color.B) + 
     Math.Abs(color.B - color.R); 
} 

Answer 2

Se non riesci a trovare una libreria per questo, si potrebbe provare afferrare un gran numero (o tutti) dei pixel per l'immagine e vedere se le loro R, G, B e valori sono entro un certo soglia (che potresti impostare empiricamente o avere come impostazione) l'una dell'altra. Se lo sono, l'immagine è in scala di grigi.

Definirei la soglia per un test un po 'più grande di 0, anche se ... quindi non testerei r = g, ad esempio, ma (abs (rg) < e) dove e è la soglia . In questo modo puoi mantenere bassi i tuoi falsi positivi di colore ... come sospetto che altrimenti otterrai un numero decente, a meno che l'immagine originale e le tecniche di scansione non diano esattamente in scala di grigi allo .

Answer 3

Poiché JPEG supporta i metadati, è necessario innanzitutto verificare se il software dello scanner inserisce alcuni dati speciali sulle immagini salvate e se è possibile fare affidamento su tali informazioni.

Answer 4

Il answer I posted in the python section potrebbe essere utile. Immagini che trovi ad es. sul web che un essere umano considererebbe la scala di grigi spesso non hanno valori R, G, B identici. Hai bisogno di un calcolo della varianza e qualche tipo di processo di campionamento in modo da non dover controllare un milione di pixel. La soluzione fornita da Paul si basa sulla massima differenza, quindi un singolo artefatto di pixel rossi da uno scanner potrebbe trasformare un'immagine in scala di grigi in non-scala di grigi. La soluzione che ho postato ha ottenuto una precisione del 99,1% e un richiamo del 92,5% su 13.000 immagini.

Answer 5

Una versione più veloce. Prova con una soglia di 8. funzionare bene per il mio

Usa:

bool grayScale; 
Bitmap bmp = new Bitmap(strPath + "\\temp.png"); 
grayScale = TestGrayScale(bmp, 8); 
if (grayScale) 
    MessageBox.Show("Grayscale image"); 


/// <summary>Test a image is in grayscale</summary> 
/// <param name="bmp">The bmp to test</param> 
/// <param name="threshold">The threshold for maximun color difference</param> 
/// <returns>True if is grayscale. False if is color image</returns> 
public bool TestGrayScale(Bitmap bmp, int threshold) 
{ 
    Color pixelColor = Color.Empty; 
    int rgbDelta; 

    for (int x = 0; x < bmp.Width; x++) 
    { 
     for (int y = 0; y < bmp.Height; y++) 
     { 
      pixelColor = bmp.GetPixel(x, y); 
      rgbDelta = Math.Abs(pixelColor.R - pixelColor.G) + Math.Abs(pixelColor.G - pixelColor.B) + Math.Abs(pixelColor.B - pixelColor.R); 
      if (rgbDelta > threshold) return false; 
     } 
    } 
    return true; 
} 

Hai un uno più veloce?

Answer 6

Penso che questo approccio dovrebbe richiedere il codice minimo, è stato testato su jpegs. bImmagine sotto è una matrice di byte.