Wie Graustufen Bildmaske auf ein RGB-Bild in Java

Question

anwenden Ich wurde empfohlen, diese Frage von einem anderen zu trennen. Hier ist das Original:

How to change white background for black

Nach einigen Bildprozesse i ein binäres Bild zu erhalten, aber die Grenzen sind so hart, so dass ich eine Gaußsche Filter anwenden ein weiches, eins zu bekommen. Das Ergebnis ist ein Graustufenbild. Ich muss dieses Bild als eine Maske für ein anderes anwenden, keiner von ihnen hat einen Alpha-Kanal, so dass eine Mischung von Farben ohne diesen Wert gemacht werden muss. Ich verwende Marvin Framework die Arbeit zu tun, aber Marvin hat kein Plugin für sie, und ich habe so codieren, das ist es:

@Override public void process(MarvinImage _imageIn, MarvinImage _imageOut, MarvinAttributes attrOut, MarvinImageMask _mask, boolean previewMode) { 

    MarvinImage mask = _imageIn; 
    MarvinImage image = _imageOut; 

    for(int y=0; y<mask.getHeight(); y++){ 
     for(int x=0; x<mask.getWidth(); x++){ 

      //ya que está en grayscale, los 3 valores son los mismos 
      int r1 = mask.getIntComponent0(x, y); 
      int g1 = mask.getIntComponent1(x, y); 
      int b1 = mask.getIntComponent2(x, y); 

      int r2 = image.getIntComponent0(x, y); 
      int g2 = image.getIntComponent1(x, y); 
      int b2 = image.getIntComponent2(x, y); 

      //al color de salida, le asignamos la luminicencia de la imagen mascara 
      int r = 0, g = 0, b = 0; 
      if(r1 > 0 || r2 > 0){ 
       r = r1*r2/Math.max(r1, r2); 
      } 

      if(g1 > 0 || g2 > 0){ 
       g = g1*g2/Math.max(g1, g2); 
      } 

      if(b1 > 0 || b2 > 0){ 
       b = b1*b2/Math.max(b1, b2); 
      } 

      image.setIntColor(x, y, r, g, b); 
     } 
    } 
} 

Aber dieser Code hat einen kleinen Fehler, die ich nicht lösen konnte. Wenn das RGB-Bild weiß ist, wird das Farbergebnis nicht sehr gut kombiniert, es wird nicht dunkler. Was ich suche, ist etwas, was man mit Gimp erreichen kann, wo es ein 2-Layer-Bild gibt, das untere ist das RGB-Bild und das obere ist die Graustufenmaske, dann verwenden wir in dieser Ebene die Funktion color zu alpha die weiße Farbe als Ziel. Das Ergebnis ist die nächste:

Whit der Algorithmus ist der nächste:

Der Unterschied ziemlich obious ist. Hier sind die beiden Originalbilder für die Prüfung:

Answer 1

Sie müssen nur mit dem Maske eine Alpha-Kombination aus dem Bild zu tun. Grundsätzlich ist der Ausgabebildpixel ist:

output_image (x, y) = input_image (x, y) * PI + mask_image (x, y) * PM

Wo PI und PM ist der Prozentsatz des Eingangs und Maskenbilder jeweils in dem Ausgangspixel. PI + PM = 1 (100%)

Beispiel:

Für schwarze Pixel in der Maske:

PM = 1 - (grayscalePixel/255) → 1 - (0/255) = 1

Für weißen Pixel:

PM = 1 - (grayscalePixel/255) → 1 - (255/255) = 0

Für ein graues Pixel:

PM = 1 - (grayscalePixel/255) → 1 - (127/255) = 0.5

Endlich:

PI = 1 - PM;

OUTPUT 1:

Quellcode:

public class GrayScaleMask { 

    public GrayScaleMask(){ 

     MarvinImage image = MarvinImageIO.loadImage("./res/grayscaleMask_input.png"); 
     MarvinImage mask = MarvinImageIO.loadImage("./res/grayscaleMask_mask.png"); 
     grayscaleMask(image.clone(), image, mask); 
     MarvinImageIO.saveImage(image, "./res/grayscaleMask_output.png"); 
    } 

    private void grayscaleMask(MarvinImage image, MarvinImage imageOut, MarvinImage mask){ 
     int r1,r2,g1,g2,b1,b2; 
     double maskGray, factorMask, factorImage; 
     for(int y=0; y<image.getHeight(); y++){ 
      for(int x=0; x<image.getWidth(); x++){ 
       r1 = image.getIntComponent0(x, y); 
       g1 = image.getIntComponent1(x, y); 
       b1 = image.getIntComponent2(x, y); 
       r2 = mask.getIntComponent0(x, y); 
       g2 = mask.getIntComponent1(x, y); 
       b2 = mask.getIntComponent2(x, y); 
       maskGray = (r2*0.21)+(g2*0.72)+(b2*0.07); 
       factorMask = 1-(maskGray/255); 
       factorImage = 1-factorMask; 
       imageOut.setIntColor(x, y, (int)(r1*factorImage+r2*factorMask), 
              (int)(g1*factorImage+g2*factorMask), 
              (int)(b1*factorImage+b2*factorMask)); 

      } 
     } 
    } 

    public static void main(String[] args) { 
     new GrayScaleMask(); System.exit(0); 
    } 
} 

OUTPUT 2:

Sie können die Maske j verdunkeln ust, bevor es die Kombination:

r2 = (int)(r2*0.3); 
    g2 = (int)(g2*0.3); 
    b2 = (int)(b2*0.3); 
    imageOut.setIntColor(x, y, (int)((r1*factorImage+r2*factorMask)), 
           (int)((g1*factorImage+g2*factorMask)), 
           (int)((b1*factorImage+b2*factorMask)));