Erkennen Sie mit Python Objekte einer bestimmten Farbe und Größe

Introduction Ich wollte so etwas ↓ ↓ ↓

Die Figur ist zu billig.

Wenn verbalisiert, ** Erkennen Sie Objekte einer bestimmten Farbe und Größe anhand von Bildern, auf denen Objekte verschiedener Farben und Größen angezeigt werden. ** Ich wollte das machen.

Ich denke, es gibt bereits viele ausgezeichnete Kommentarartikel, aber wenn ich diese nicht schreibe, werde ich sie bald vergessen und sie als Memorandum schreiben.

Zunächst aus der Schlussfolgerung

Das Bild wird in den folgenden 4 Schritten verarbeitet

1. Binarisierung basierend auf Farbinformationen

2. Kontur erkennen

3. Fallklassifizierung nach Größe

4. Überlagern Sie den Umriss des Originalbilds

Code

** 1. Binarisierung basierend auf Farbinformationen ** ** 2. Kontur erkennen **

import cv2
import numpy as np

#Bild"hoge.jpg "Lesen
#Das gleiche Bild wird zweimal mit verschiedenen Variablen gelesen. Eins (img_c) für "Bildverarbeitung",
#Der andere (img_c_Da Ursprung) ist "zur Anzeige über dem Umriss".

filename = "hoge.jpg "

input_img = filename
img_c = cv2.imread(input_img)
img_c_origin = cv2.imread(input_img)

#Vorbehandlung (Unschärfe)
#Zahlen sind angemessen
for i in range(2):
	img_c = cv2.GaussianBlur(img_c,(5,5),0)

#Separate Bildkanäle. cv2.Beachten Sie, dass die von imread gelesenen Bilder in der Reihenfolge "BGR" anstelle von "RGB" sind!
B, G, R = cv2.split(img_c)

#Es ist in jedem RGB-Kanal binärisiert.
#Es ist 1, wenn das Pixel die gewünschte Farbe hat, und andernfalls 0.

# -------- color condition ----------
R_low = 0
R_high = 100
G_low = 100
G_high = 200
B_low = 200
B_high = 250
# -----------------------------------

img_r_th = np.where((R < R_high) & (R > R_low), 1, 0)
img_g_th = np.where((G < G_high) & (G > G_low), 1, 0)
img_b_th = np.where((B < B_high) & (B > B_low), 1, 0)

#Multiplikation jedes Elements, keine Matrixmultiplikation. Ich mag es, weil ich das kann.
#Logisches UND(AND)Es ist ein Bild zu machen. Um das erkannte Objekt weiß zu machen, wird es am Ende mit 255 multipliziert.
img_th = img_r_th * img_g_th * img_b_th * 255

#Cast to uint8 zur Verwendung als Argument für die nächsten findCOntours.
img_th = np.uint8(img_th)

#Erkennt Konturen.
contours = cv2.findContours(img_th, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[0]

Aus dem Grund, warum Bildunschärfe (Vorverarbeitung) erforderlich ist, war die "Vorverarbeitung" im folgenden Artikel hilfreich. Einführung in OpenCV für maschinelles Lernen

Dieses Mal verwende ich RGB aus verschiedenen Gründen, aber es gibt auch eine Möglichkeit, es mit HSV zu erkennen. Es ist intuitiv, nicht wahr? Objektkonturerkennung

Klicken Sie hier für Details zur Konturerkennung Gliederung: Erster Schritt

Obwohl ich verschiedene Dinge geschrieben habe, wird der Bereich um die Konturerkennung fast kopiert. Weil es dumm ist ...

** 3. Fall nach Größe ** ** 4. Auf dem Originalbild überlagert angezeigt **

# -------- scale condition ----------
Area_th_min = 1
Area_th_max = 1000
# -----------------------------------

#Definieren Sie eine Liste zum Speichern der gewünschten Konturen
Active_contours = []

#Wenn Sie eine Kontur in contourArea eingeben, wird der Bereich des von der Kontur umgebenen Bereichs zurückgegeben.
#Damit nur aktive Objekte einer bestimmten Größe (Gliederung)_In Konturen lagern.
for cont in contours:
	if cv2.contourArea(cont) > Area_th_min and cv2.contourArea(cont) < Area_th_max:
		Active_contours.append(cont)

#Mit drowContours können Sie Konturen auf einem Bild überlagern.
#Einzelheiten finden Sie oben unter "Gliederung: Erster Schritt".
cont_img = cv2.drawContours(img_c_origin, Active_contours, -1, (255,0,0), 3)

#Konvertieren Sie "BGR" zur Anzeige in "RGB".
cont_img = cv2.cvtColor(cont_img, cv2.COLOR_BGR2RGB)

** Ganzer Code **

detect_color.py

import cv2
import numpy as np
import matplotlib.pyplot as plt

#[[User specified parameters]]

# ------- color condition ----------
R_low = 200
R_high = 250
G_low = 60
G_high = 110
B_low = 80
B_high = 120
# -----------------------------------

# ------- scale condition -----------
Area_th_min = 1200
Area_th_max = 10000
# -----------------------------------


# Step 1 ---------------------------
filename = "hoge.jpg "

input_img = filename
img_c = cv2.imread(input_img)
img_c_origin = cv2.imread(input_img)

for i in range(2):
	img_c = cv2.GaussianBlur(img_c,(5,5),0)

B, G, R = cv2.split(img_c)

img_g_th = np.where((G < G_high) & (G > G_low), 1, 0)
img_b_th = np.where((B < B_high) & (B > B_low), 1, 0)
img_r_th = np.where((R < R_high) & (R > R_low), 1, 0)

img_th = img_r_th * img_g_th * img_b_th * 255
img_th = np.uint8(img_th)

# Step 2 ---------------------------
contours = cv2.findContours(img_th, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[0]

# Step 3 ---------------------------
Active_contours = []

for cont in contours:
	if cv2.contourArea(cont) > Area_th_min and cv2.contourArea(cont) < Area_th_max:
		Active_contours.append(cont)

# Step 4 ---------------------------
cont_img = cv2.drawContours(img_c_origin, Active_contours, -1, (255,0,0), 3)

cont_img = cv2.cvtColor(cont_img, cv2.COLOR_BGR2RGB)
img_c_origin = cv2.cvtColor(img_c_origin, cv2.COLOR_BGR2RGB)

# ------------- show images ------------- 
plt.gray()

plt.subplot(1,2,1)
plt.imshow(img_th, vmin=0, vmax=255, interpolation = 'none')
plt.title('Threshold')

plt.subplot(1,2,2)
plt.imshow(cont_img, interpolation = 'none')
plt.title('Contour')

plt.show()
# ----------------------------------------

Eigentlich verwenden

Der obige Code gibt bereits einen Bereich von R, G, B an. Wenn Sie hier das wahnsinnig coole Logo von "The Demon Girl Next Door", dem englischen Titel von "Machikado Mazoku", als Eingabebild angeben ...

Es wird nur das rosa "G" erkannt. Im Schwellenwertbild wurden alle rosa Bereiche erkannt, aber aufgrund der Klassifizierung nach Größe blieb nur G übrig.

Übrigens denke ich, dass dieses Logo schwarz für Shamiko und pink für Pfirsich steht, aber was ist mit ... Sie können Machikado Mazoku auf Amapura sehen, also lasst uns alle sehen.

Das Ende