Erkennung von Graustufenbildern mit .Net

Question

Ich scanne Dokumente in JPG-Bilder. Der Scanner muss alle Seiten in Farbe oder alle Seiten in Schwarz-Weiß scannen. Da viele meiner Seiten farbig sind, muss ich alle Seiten in Farbe scannen. Nach dem Scannen möchte ich die Bilder mit .Net untersuchen und versuchen zu erkennen, welche Bilder schwarz-weiß sind, damit ich diese Bilder in Graustufen umwandeln und Speicherplatz sparen kann.

Weiß jemand, wie man ein Graustufenbild mit .Net erkennt?

Bitte lassen Sie es mich wissen.

Answer 1

Wenn Sie keine entsprechende Bibliothek finden, können Sie versuchen, eine große Anzahl (oder alle) der Pixel eines Bildes zu erfassen und zu sehen, ob ihre r-, g- und b-Werte innerhalb eines bestimmten Schwellenwerts liegen (den Sie empirisch oder als Einstellung festlegen können). Wenn dies der Fall ist, ist das Bild ein Graustufenbild.

Ich würde auf jeden Fall den Schwellenwert für einen Test etwas größer als 0 machen, obwohl ... so würde ich nicht testen r = g, zum Beispiel, aber (abs(r-g) < e), wo e ist Ihre Schwelle. Auf diese Weise können Sie die Zahl der falsch-positiven Farben gering halten... denn ich vermute, dass Sie ansonsten eine anständige Zahl erhalten, es sei denn, Ihr Originalbild und die Scan-Techniken geben genau Graustufen.

Answer 2

Ein einfacher Algorithmus zur Prüfung auf Farbe: Gehen Sie das Bild Pixel für Pixel in einer verschachtelten for-Schleife durch (Breite und Höhe) und prüfen Sie, ob die RGB-Werte der Pixel gleich sind. Wenn dies nicht der Fall ist, hat das Bild Farbinformationen. Wenn Sie alle Pixel durchlaufen, ohne auf diese Bedingung zu stoßen, dann haben Sie ein Graustufenbild.

Überarbeitung mit einem komplexeren Algorithmus:

In der ersten Version dieses Beitrags habe ich einen einfachen Algorithmus vorgeschlagen, der davon ausgeht, dass Pixel Graustufen sind, wenn die RGB-Werte der einzelnen Pixel gleich sind. So RGBs von 0,0,0 oder 128,128,128 oder 230,230,230 würden alle als grau testen, während 123,90,78 nicht. Einfach.

Hier ist ein Codeschnipsel, der auf eine Abweichung von Grau testet. Die beiden Methoden sind ein kleiner Teil eines komplexeren Prozesses, sollten aber genug Rohcode liefern, um bei der ursprünglichen Frage zu helfen.

/// <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 3

Eine schnellere Version. Test mit einem Schwellenwert von 8. arbeiten gut für meine

Verwendung:

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;
}

Haben Sie ein schnelleres Modell?

Answer 4

Da JPEG Metadaten unterstützt, sollten Sie zunächst prüfen, ob Ihre Scannersoftware spezielle Daten auf den gespeicherten Bildern ablegt und ob Sie sich auf diese Informationen verlassen können.

Answer 5

El Antwort, die ich in der Python-Sektion gepostet habe könnte hilfreich sein. Bilder, die man z. B. im Internet findet und die ein Mensch als Graustufen ansehen würde, haben oft nicht die gleichen R-, G- und B-Werte. Man braucht eine Berechnung der Varianz und eine Art Stichprobenverfahren, damit man nicht eine Million Pixel überprüfen muss. Die von Paul angegebene Lösung basiert auf der maximalen Differenz, so dass ein einziges rotes Pixel eines Scanners ein Graustufenbild in ein Nicht-Graustufenbild verwandeln kann. Die von mir gepostete Lösung erreichte bei 13.000 Bildern eine Genauigkeit von 99,1 % und eine Wiedererkennung von 92,5 %.