Bayer bestellt Dithering

Question

Ich bin ein Plugin für Paint.net aktualisieren, die ich vor ein paar Monaten, es Simulieren Farbtiefe genannt, und es reduziert die Anzahl der Farben im Bild auf die gewählte BPP und für eine lange Zeit gehabt haben inklusive Dithering aber nie bestellt Dithering und ich dachte, es eine schöne Ergänzung zu haben wäre, dass nützlich in so für ich begann etwas im Internet zu suchen, endete ich hier auf dieser Wiki-Seite nach oben http://en.wikipedia.org/wiki/Ordered_dithering und versuchte, in der Pseudo wie geschrieben zu tun Code

for (int y = 0; x < image.Height; y++) 
{ 
    for (int x = 0; x < image.Width; x++) 
    { 
     Color color = image.GetPixel(x, y); 
     color.R = color.R + bayer8x8[x % 8, y % 8]; 
     color.G = color.G + bayer8x8[x % 8, y % 8]; 
     color.B = color.B + bayer8x8[x % 8, y % 8]; 
     image.SetPixel(x, y, GetClosestColor(color, bitdepth); 
    } 
} 

aber das Ergebnis ist viel zu hell, so habe ich beschlossen, wieder die Wiki-Seite zu überprüfen und dann sehe ich, dass es rechts von der Schwelle Karte ein „1/65“ ist, das hat mich sowohl Fehler zu denken diffundierend (ja ich weiß, komisch huh?) und teile den Wert, den ich von bayer8x8[x % 8, y % 8] mit 65 bekomme und multipliziere dann den Wert mit den Farbkanälen, aber entweder waren die Ergebnisse chaotisch oder noch zu hell (wie ich mich erinnere), aber die Ergebnisse waren nichts wie ich habe ich woanders gesehen, entweder zu hell, zu high contrast oder zu unordentlich und ich habe nichts wirklich nützliches gefunden, das durch das internet sucht, also weiß jemand, wie ich dieses bayer dithering richtig arbeiten lassen kann?

Vielen Dank im Voraus, Kekse

Answer 1

Try this:

color.R = color.R + bayer8x8[x % 8, y % 8] * GAP/65; 

Hier GAP sollte der Abstand zwischen den beiden nächstgelegenen Farbschwellen sein. Dies hängt von den Bits pro Pixel ab.

Zum Beispiel, wenn man das Bild konvertiert 4 Bit für die rote Komponente jeden Pixel zu verwenden, gibt es 16 Stufen von Rot insgesamt. Sie sind: R = 0, R = 17, R = 34, ... R = 255. So würde GAP seine 17.

Answer 2

eine Lösung gefunden, levels ist die Menge an Farben der Zielbilder haben sollten und d ist die Divisor (dies ist normalisiert von meinem Code (die paint.net Klassen) auf einfache Bitmap editting verwendet mit GetPixel und SetPixel)

private void ProcessDither(int levels, int d, Bitmap image) 
    { 
     levels -= 1; 
     double scale = (1.0/255d); 
     int t, l; 

     for (int y = rect.Top; y < rect.Bottom; y++) 
     { 
      for (int x = rect.Left; x < rect.Right; x++) 
      { 
       Color cp = image.GetPixel(x, y); 

       int threshold = matrix[y % rows][x % cols]; 

       t = (int)(scale * cp.R * (levels * d + 1)); 
       l = t/d; 
       t = t - l * d; 
       cp.R = Clamp(((l + (t >= threshold ? 1 : 0)) * 255/levels)); 

       t = (int)(scale * cp.G * (levels * d + 1)); 
       l = t/d; 
       t = t - l * d; 
       cp.G = Clamp(((l + (t >= threshold ? 1 : 0)) * 255/levels)); 

       t = (int)(scale * cp.B * (levels * d + 1)); 
       l = t/d; 
       t = t - l * d; 
       cp.B = Clamp(((l + (t >= threshold ? 1 : 0)) * 255/levels)); 

       image.SetPixel(x, y, cp); 
      } 
     } 
    } 

    private byte Clamp(int val) 
    { 
     return (byte)(val < 0 ? 0 : val > 255 ? 255 : val); 
    } 

Answer 3

Ich glaube nicht, dass mit Ihrem ursprünglichen Algorithmus (aus Wikipedia) etwas falsch ist. Die Helligkeitsdisparität ist wahrscheinlich ein Artefakt des Monitor-Gamma. Prüfen Sie Joel Yliluoma's Positional Dithering Algorithm, den Anhang zu Gamma-Korrektur von diesem Artikel über einen Dithering-Algorithmus erfunden von Joel Yliluoma (http://bisqwit.iki.fi/story/howto/dither/jy/#Appendix%201GammaCorrection) eine Erklärung für die Wirkung zu sehen (NB: Seite ist recht grafik schwer).

übrigens vielleicht der (scheinbar Public-Domain) Algorithmus in diesem Artikel beschrieben kann die Lösung für Ihr Problem ...