Es ist nicht möglich, einen genauen Schwellenwert für ein Bild mit einem hellen Fleck zu erhalten

Question

Ich versuche einen riesigen hellen Fleck in einem Bild zu erkennen. So wie ich es tue, ist, ich bin Umwandlung es zuerst COLOR_BGR2HLS_FULL, den grünen Kanal zu nehmen und die Anwendung GuassianBlur, um es wie so und dann ich THRESH_OTSU bin mit dem schwellen Bild zu erhalten, und dann zeichnet die Kontur:

self.result = cv2.cvtColor(self.result_array_color, cv2.COLOR_BGR2HLS_FULL) 
self.result = self.result[:,:,1] 
self.result = cv2.GaussianBlur(self.result,(25,25), 0) 

hier ist, was das erhaltene Bild wie folgt aussieht:

Und hier ist es, was das gewünschte Bild aussehen soll:

Auch meine Art, dies zu tun, stimmt nicht mit allen Bildern ähnlicher Art überein. Gibt es einen besseren Weg, den Sie vorschlagen könnten?

Vielen Dank!

Answer 1

Nein, ich habe keine anderen Techniken verwendet, um die Gefäße zu entfernen. Dilate ist der Maximalwert in einem Bereich und Erode ist der Minimalwert. Ich benutze Dilate und Erode Radius 32 und HighPass Radius 128.

Der Code ist in C#:

public byte[] Dilate(byte[] image, int width, int height, int radius) 
{ 
    byte[] temp = new byte[image.Length]; 
    byte[] result = new byte[image.Length]; 

    //Dilate by X 
    for (int y = 0; y < height; y++) 
     for (int x = 0; x < width; x++) 
     { 
      byte v = 0; 
      for (int i = x - radius; i <= x + radius; i++) 
       if (i >= 0 && i < width) 
        v = Math.Max(v, image[i + y * width]); 
      temp[x + y * width] = v; 
     } 

    //Dilate by Y 
    for (int y = 0; y < height; y++) 
     for (int x = 0; x < width; x++) 
     { 
      byte v = 0; 
      for (int i = y - radius; i <= y + radius; y++) 
       if (i >= 0 && i < height) 
        v = Math.Max(v, temp[x + i * width]); 
      result[x + y * width] = v; 
     } 

    return result; 
} 

public byte[] Erode(byte[] image, int width, int height, int radius) 
{ 
    byte[] temp = new byte[image.Length]; 
    byte[] result = new byte[image.Length]; 

    //Dilate by X 
    for (int y = 0; y < height; y++) 
     for (int x = 0; x < width; x++) 
     { 
      byte v = 255; 
      for (int i = x - radius; i <= x + radius; i++) 
       if (i >= 0 && i < width) 
        v = Math.Min(v, image[i + y * width]); 
      temp[x + y * width] = v; 
     } 

    //Dilate by Y 
    for (int y = 0; y < height; y++) 
     for (int x = 0; x < width; x++) 
     { 
      byte v = 255; 
      for (int i = y - radius; i <= y + radius; y++) 
       if (i >= 0 && i < height) 
        v = Math.Min(v, temp[x + i * width]); 
      result[x + y * width] = v; 
     } 

    return result; 
} 

public byte[] HighPass(byte[] image, int width, int height, float radius) 
{ 
    byte[] smooth = GaussSmooth(image, width, height, (byte)radius); 
    byte[] result = new byte[image.Length]; 

    for (int y = 0; y < height; y++) 
     for (int x = 0; x < width; x++) 
     { 
      result[x + y * width] = (byte)(128 + image[x + y * width] - smooth[x + y * width]); 
     } 

    return result; 
} 

Answer 2

Nun, habe ich dieses Ergebnis zu erreichen:

Anfangsbild (ich nicht das Original hatte so entfernte ich die grüne Linie von Ihnen):

Verwenden GREEN Kanal für Verarbeitung:

Dann Dilate verwenden und Filter mit quadratischen Fenstern mit ra Erodieren dius 32 für Schiffe, zu entfernen:

Nach Dilate

Nach

Die Licht-Entstörfilter Erodieren (oder Hochpassfilter - Division durch Gauss glatten des Bildes), um Bild mehr Klar :

Und schließlich ein Schwellen

Sie auch die endgültige Maske

glätten

Und wieder Verwendung Schwelle glatter Ergebnis zu erhalten: