OpenCV ile Yüz Tanıma Bölüm 3-2

derin öğrenme, makine öğrenmesi, opencv, python 4 Yanıt »

Ara 182018

OpenCV ile Yüz Tanıma Bölüm 3-2

Önceki yazımda veri setimizi nasıl oluşturacağımızı anlatmıştım.

Bu kez veri setimizi Keras kullanarak eğiteceğiz. Sonra da yeni resimleri bu eğitilmiş veri setini kullanarak sınıflandıracağız.

3. ADIM – EĞİTİM

Projemize örnek olarak aldığımız çalışmada Adrian, Keras modellemesi için SmallerVGGNet sınıfını kullanıyor. Ben onun yerine daha basit bir model kullandım (vgg_like). Eğer isterseniz yazının sonundaki Referanslar bölümünde yer alan linkleri kullanarak SmallerVGGNet kodlarına ulaşabilirsiniz.

Lafı uzatmadan eğitim betiğimize geçelim. Betiğimizin adı: train.py

from keras.preprocessing.image import ImageDataGenerator
from keras.optimizers import Adam
from keras.preprocessing.image import img_to_array
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from smallervggnet import SmallerVGGNet

from imutils import paths
import numpy as np
import random
import pickle
import cv2
import os
import time
from keras.models import Sequential
from keras.layers.normalization import BatchNormalization
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.layers.core import Activation
from keras.layers.core import Flatten
from keras.layers.core import Dropout
from keras.layers.core import Dense
from keras.optimizers import SGD

import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

def vgg_like():
    model = Sequential()
    model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(96, 96, 3)))
    model.add(Conv2D(32, (3, 3), activation='relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.25))

    model.add(Conv2D(64, (3, 3), activation='relu'))
    model.add(Conv2D(64, (3, 3), activation='relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.25))

    model.add(Flatten())
    model.add(Dense(256, activation='relu'))
    model.add(Dropout(0.5))
    model.add(Dense(3, activation='softmax'))
    return model

t0=time.time()
EPOCHS = 100
INIT_LR = 1e-3
BATCH_SIZE = 32
IMAGE_DIMS = (96, 96, 3)

data = []
labels = []

print("Geçen süre: ",time.time()-t0)
print("İmajlar yükleniyor...")
imagePaths = sorted(list(paths.list_images("data")))
print(imagePaths)
random.seed(42)
random.shuffle(imagePaths)

for imagePath in imagePaths:
    image = cv2.imread(imagePath)
    image = cv2.resize(image, (IMAGE_DIMS[1], IMAGE_DIMS[0]))
    image = img_to_array(image)
    data.append(image)

    # etiketler dosya adından oluşturuluyor
    label = imagePath.split(os.path.sep)[-2]
    labels.append(label)

print(labels)
# piksel değerleri [0, 1] olarak dönüştürülüyor
data = np.array(data, dtype="float") / 255.0
labels = np.array(labels)
print("matrix: {:.2f}MB".format(
    data.nbytes / (1024 * 1000.0)))

# etiketler sayısallaştırılıyor
lb = LabelBinarizer()
labels = lb.fit_transform(labels)

# veri eğitim ve test için ayrıştırılıyor
(trainX, testX, trainY, testY) = train_test_split(data,
                                labels, test_size=0.2, random_state=42)

# veri çoğullama için imaj üreteci oluşturuluyor
aug = ImageDataGenerator(rotation_range=25, width_shift_range=0.1,
                         height_shift_range=0.1, shear_range=0.2, zoom_range=0.2,
                         horizontal_flip=True, fill_mode="nearest")

print("Geçen süre: ",time.time()-t0)
print("Model derleniyor...")
# model = SmallerVGGNet.build(width=IMAGE_DIMS[1], height=IMAGE_DIMS[0],
#                     depth=IMAGE_DIMS[2], classes=len(lb.classes_))

# SmallerVGGNet yerine daha basit bir model kullanıyorum
model = vgg_like()

print("Geçen süre: ",time.time()-t0)
print("Model Özeti")
print(model.summary())
with open("model_ozet.txt","w") as of:
    model.summary(print_fn=lambda x: of.write(x+'\n'))

# opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
opt = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)   # daha iyi sonuç veriyor
print("Geçen süre: ",time.time()-t0)
model.compile(loss="categorical_crossentropy", optimizer=opt,
              metrics=["accuracy"])

# train the network
print("Geçen süre: ",time.time()-t0)
print("Ağ eğitiliyor...")
H = model.fit_generator(
    aug.flow(trainX, trainY, batch_size=BATCH_SIZE),
    validation_data=(testX, testY),
    steps_per_epoch=len(trainX) // BATCH_SIZE,
    epochs=EPOCHS, verbose=1)

print("Geçen süre: ",time.time()-t0)
print("Model kaydediliyor...")
model.save("yesilcam.model")

print("Geçen süre: ",time.time()-t0)
print("Etiketler kaydediliyor...")
f = open("etiket.pickle", "wb")
f.write(pickle.dumps(lb))
f.close()

print("Geçen süre: ",time.time()-t0)
print("Kayıp ve doğruluk grafikleri çiziliyor")
# eğitimdeki kayıp ve doğruluğun çizimi
plt.style.use("ggplot")
plt.figure()
N = EPOCHS
plt.plot(np.arange(0, N), H.history["loss"], label="train_loss")
plt.plot(np.arange(0, N), H.history["val_loss"], label="val_loss")
plt.plot(np.arange(0, N), H.history["acc"], label="train_acc")
plt.plot(np.arange(0, N), H.history["val_acc"], label="val_acc")
plt.title("Training Loss and Accuracy")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend(loc="upper left")
plt.savefig("plot.png")
print("Toplam süre: ",time.time()-t0)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

from keras.preprocessing.image import ImageDataGenerator

from keras.optimizers import Adam

from keras.preprocessing.image import img_to_array

from sklearn.preprocessing import LabelBinarizer

from sklearn.model_selection import train_test_split

from smallervggnet import SmallerVGGNet

from imutils import paths

import numpy as np

import random

import pickle

import cv2

import os

import time

from keras.models import Sequential

from keras.layers.normalization import BatchNormalization

from keras.layers.convolutional import Conv2D

from keras.layers.convolutional import MaxPooling2D

from keras.layers.core import Activation

from keras.layers.core import Flatten

from keras.layers.core import Dropout

from keras.layers.core import Dense

from keras.optimizers import SGD

import matplotlib

matplotlib.use("Agg")

import matplotlib.pyplot as plt

def vgg_like():

model = Sequential()

model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(96, 96, 3)))

model.add(Conv2D(32, (3, 3), activation='relu'))

model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Dropout(0.25))

model.add(Conv2D(64, (3, 3), activation='relu'))

model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Dropout(0.25))

model.add(Flatten())

model.add(Dense(256, activation='relu'))

model.add(Dropout(0.5))

model.add(Dense(3, activation='softmax'))

return model

t0=time.time()

EPOCHS = 100

INIT_LR = 1e-3

BATCH_SIZE = 32

IMAGE_DIMS = (96, 96, 3)

data = []

labels = []

print("Geçen süre: ",time.time()-t0)

print("İmajlar yükleniyor...")

imagePaths = sorted(list(paths.list_images("data")))

print(imagePaths)

random.seed(42)

random.shuffle(imagePaths)

for imagePath in imagePaths:

image = cv2.imread(imagePath)

image = cv2.resize(image, (IMAGE_DIMS[1], IMAGE_DIMS[0]))

image = img_to_array(image)

data.append(image)

# etiketler dosya adından oluşturuluyor

label = imagePath.split(os.path.sep)[-2]

labels.append(label)

print(labels)

# piksel değerleri [0, 1] olarak dönüştürülüyor

data = np.array(data, dtype="float") / 255.0

labels = np.array(labels)

print("matrix: {:.2f}MB".format(

data.nbytes / (1024 * 1000.0)))

# etiketler sayısallaştırılıyor

lb = LabelBinarizer()

labels = lb.fit_transform(labels)

# veri eğitim ve test için ayrıştırılıyor

(trainX, testX, trainY, testY) = train_test_split(data,

labels, test_size=0.2, random_state=42)

# veri çoğullama için imaj üreteci oluşturuluyor

aug = ImageDataGenerator(rotation_range=25, width_shift_range=0.1,

height_shift_range=0.1, shear_range=0.2, zoom_range=0.2,

horizontal_flip=True, fill_mode="nearest")

print("Geçen süre: ",time.time()-t0)

print("Model derleniyor...")

# model = SmallerVGGNet.build(width=IMAGE_DIMS[1], height=IMAGE_DIMS[0],

# depth=IMAGE_DIMS[2], classes=len(lb.classes_))

# SmallerVGGNet yerine daha basit bir model kullanıyorum

model = vgg_like()

print("Geçen süre: ",time.time()-t0)

print("Model Özeti")

print(model.summary())

with open("model_ozet.txt","w") as of:

model.summary(print_fn=lambda x: of.write(x+'\n'))

# opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)

opt = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) # daha iyi sonuç veriyor

print("Geçen süre: ",time.time()-t0)

model.compile(loss="categorical_crossentropy", optimizer=opt,

metrics=["accuracy"])

# train the network

print("Geçen süre: ",time.time()-t0)

print("Ağ eğitiliyor...")

H = model.fit_generator(

aug.flow(trainX, trainY, batch_size=BATCH_SIZE),

validation_data=(testX, testY),

steps_per_epoch=len(trainX) // BATCH_SIZE,

epochs=EPOCHS, verbose=1)

print("Geçen süre: ",time.time()-t0)

print("Model kaydediliyor...")

model.save("yesilcam.model")

print("Geçen süre: ",time.time()-t0)

print("Etiketler kaydediliyor...")

f = open("etiket.pickle", "wb")

f.write(pickle.dumps(lb))

f.close()

print("Geçen süre: ",time.time()-t0)

print("Kayıp ve doğruluk grafikleri çiziliyor")

# eğitimdeki kayıp ve doğruluğun çizimi

plt.style.use("ggplot")

plt.figure()

N = EPOCHS

plt.plot(np.arange(0, N), H.history["loss"], label="train_loss")

plt.plot(np.arange(0, N), H.history["val_loss"], label="val_loss")

plt.plot(np.arange(0, N), H.history["acc"], label="train_acc")

plt.plot(np.arange(0, N), H.history["val_acc"], label="val_acc")

plt.title("Training Loss and Accuracy")

plt.xlabel("Epoch #")

plt.ylabel("Loss/Accuracy")

plt.legend(loc="upper left")

plt.savefig("plot.png")

print("Toplam süre: ",time.time()-t0)

İşin içine eğitim girince bir sürü kütüphane ve modüle ihtiyaç duyuyoruz. Kullanacağımız kütüphaneler hakkında kabaca da olsa, bilgi sahibi olduğunuzu umuyorum. Yoksa bu yazıyı 1000-1500 kelimelik bir hacme sığdırmak olanaksız hale gelirdi.

İlk 27 satırımızda matplotlib, keras, sklearn, imutils, numpy, random, pickle, cv2 ve os kütüphanelerimizi içe aktarıyoruz. smallervggnet kütüphanesini de belki kullanırsınız diye listeden çıkarmadım.

Modeli daha basit tutmak amacıyla vgg_like() fonksiyonunu tanımladım. (VGGNet, 2014 yılındaki Imagenet Büyük Ölçekli Görsel Tanıma Yarışmasında çok iyi performans gösteren bir yapay sinir ağıdır. VGG (Visual Geometry Group) Oxford Üniversitesi Mühendislik Bilimleri Bölümünün bir alt birimidir.)

Eğitim için Doğrusal(Sequential) bir model kullanıyoruz – satır 30
Görsellerimiz 96×96 boyutlu ve 3 renk kanalına sahip.
Modelimize ilk önce bir Conv2D katmanı uyguluyoruz – satır 31
İkinci katmanımız yine Conv2D – satır 32
Üçüncü katmanda MaxPooling2D var – satır 33
34. satırdaki Dropout ile %25’lik giriş bilgisini devre dışı bırakıyoruz (overfitting engelleme).

Benzer işlemleri bir kez daha tekrarlıyoruz. Ama boyutlamalar biraz farklı. satır 36-39

Son aşamada modelimize önce Flatten(), sonra Dense() uyguluyoruz. satır 41-42
Dropout oranımız %50 satır 43
Son işlemimiz her zamanki gibi ‘softmax’ satır 44
45.satırda modelimizi geri döndürüyoruz.

47. satırda işlem başlangıç zamanını t0 olarak not ediyoruz. Bu değişkeni belirli aşamalarda geçen süreyi belirtmek için kullanacağız.

Satır 48-51’de sabitlerimizi tanımlıyoruz.

data ve labels boş birer listedir. satır 53-54

58. satırda görsel dosya yollarımızı bir listede topluyoruz (imagePaths).

imagePaths listesinin satırlarını karıştırırken, sonraki denemelerde de aynı rasgele değerleri elde edebilmek için seed değerini 42 olarak belirliyoruz. satır 60 (Bu değer herhangi bir başka sayı da olabilir. Önemli olan hep aynı başlatma değerini kullanmak.)

63. satırda görsel dosyalarını işlemeye başlıyoruz.
Dosyayı okuyoruz – satır 64
İmajı 96×96 olarak yeniden boyutlandırıyoruz – satır 65
İmajı bir dizi (array) haline dönüştürüyoruz – satır 66
Ve imaj dizisini data listesine ekliyoruz – satır 67

Dosya yolundan etiket bilgisini (sanatçı_kodu) ayrıştırıyoruz – satır 70
Etiket bilgisini labels listesine ekliyoruz – satır 71

data listesini elemanları 0 veya 1 olacak şekilde bir numpy dizisine çeviriyoruz – satır 75
Aynı şekilde labels listesini de bir numpy dizisi haline getiriyoruz – satır 76

Satır 81-82’de etiketleri sayısallaştırıyoruz.

Satır 85-86: data ve labels dizi elemanlarının %20’sini test, geri kalanını eğitim için ayırıyoruz.

Veri sayımız kısıtlı olduğu için data çoğullama (augmentation) işlemi yaptırıyoruz – satır 89-91 (Çoğullama sırasında döndürme, kaydırma, yükseklik değiştirme, kesme, büyütme ve yatay aynalama (flip) işlemleri yapılacak.)

Modelimizi vgg_like() fonksiyonu ile oluşturuyoruz – satır 99

model.summary(), model katmanlarımızın değişimini ayrıntılı bir şekilde açıklıyor. Bu özeti hem ekrana, hem de dosyaya kaydediyoruz. – satır 102-105

Optimizasyon işlemi için Adam da yaygın bir şekilde kullanılıyor. Benim yaptığım denemelerde SGD daha iyi sonuçlar almamı sağladı. Her ikisini de deneyebilirsiniz. Satır 108

110. satırda modelimizi derliyoruz.

Eğitim işlemleri (satır 116-120) için bir kaç dakika bekliyoruz.

Eğitim tamamlandığında, önce modelimizi (satır 124), sonra da etiketlerimizi (satır 128-130) kaydediyoruz.

Son aşama olarak, eğitim işlemlerimiz sırasında hesaplanan kayıp ve doğruluk değerlerini grafiğe döküyor ve plot.png adıyla kaydediyoruz. – satır 135-146

Artık sınıflandırma işlemlerimize geçebiliriz. Ama daha önce model özetimize kısaca bir göz atsak iyi olacak:

Model Özeti
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d_1 (Conv2D)            (None, 94, 94, 32)        896       
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 92, 92, 32)        9248      
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 46, 46, 32)        0         
_________________________________________________________________
dropout_1 (Dropout)          (None, 46, 46, 32)        0         
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 44, 44, 64)        18496     
_________________________________________________________________
conv2d_4 (Conv2D)            (None, 42, 42, 64)        36928     
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 21, 21, 64)        0         
_________________________________________________________________
dropout_2 (Dropout)          (None, 21, 21, 64)        0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 28224)             0         
_________________________________________________________________
dense_1 (Dense)              (None, 256)               7225600   
_________________________________________________________________
dropout_3 (Dropout)          (None, 256)               0         
_________________________________________________________________
dense_2 (Dense)              (None, 3)                 771       
=================================================================
Total params: 7,291,939
Trainable params: 7,291,939
Non-trainable params: 0
_________________________________________________________________

Model Özeti

_________________________________________________________________

Layer (type) Output Shape Param #

=================================================================

conv2d_1 (Conv2D) (None, 94, 94, 32) 896

_________________________________________________________________

conv2d_2 (Conv2D) (None, 92, 92, 32) 9248

_________________________________________________________________

max_pooling2d_1 (MaxPooling2 (None, 46, 46, 32) 0

_________________________________________________________________

dropout_1 (Dropout) (None, 46, 46, 32) 0

_________________________________________________________________

conv2d_3 (Conv2D) (None, 44, 44, 64) 18496

_________________________________________________________________

conv2d_4 (Conv2D) (None, 42, 42, 64) 36928

_________________________________________________________________

max_pooling2d_2 (MaxPooling2 (None, 21, 21, 64) 0

_________________________________________________________________

dropout_2 (Dropout) (None, 21, 21, 64) 0

_________________________________________________________________

flatten_1 (Flatten) (None, 28224) 0

_________________________________________________________________

dense_1 (Dense) (None, 256) 7225600

_________________________________________________________________

dropout_3 (Dropout) (None, 256) 0

_________________________________________________________________

dense_2 (Dense) (None, 3) 771

=================================================================

Total params: 7,291,939

Trainable params: 7,291,939

Non-trainable params: 0

_________________________________________________________________

Conv2D katman çıkış boyutlarında 2 piksellik küçülme yaratıyor.
MaxPooling2D ise (2,2) oranları ile her iki yönde boyutları yarıya indiriyor.
Flatten işlemi katmanı tek boyutlu bir diziye dönüştürür.
Dropout input değerlerinden bir bölümünü işlem dışı bırakır. Böylece overfitting olasılığı azalır.

4. ADIM – SINIFLANDIRMA

from keras.preprocessing.image import img_to_array
from keras.models import load_model
import numpy as np
import imutils
import pickle
import cv2
import os

# imajlar
imajlar = ["c_arkin2.jpg","s_alisik6.jpg","t_soray2.jpg"]

def check_image(image,output,imaj):
    image = cv2.resize(image, (96, 96))
    image = image.astype("float") / 255.0
    image = img_to_array(image)
    image = np.expand_dims(image, axis=0)

    print("Ağ yükleniyor...")
    model = load_model("yesilcam.model")
    lb = pickle.loads(open("etiket.pickle", "rb").read())

    print("İmaj sınıflandırılıyor...")
    proba = model.predict(image)[0]
    idx = np.argmax(proba)
    label = lb.classes_[idx]

    filename = imaj[imaj.rfind(os.path.sep) + 1:]
    correct = "tamam" if filename.rfind(label) != -1 else "hata"

    mesaj = "{}: {:.2f}% ({})".format(label, proba[idx] * 100, correct)
    output = imutils.resize(output, width=400)
    cv2.putText(output, mesaj, (10, 25), cv2.FONT_HERSHEY_SIMPLEX,
                0.7, (0, 255, 0), 2)

    print("{}".format(label))
    cv2.imshow("Sonuç", output)
    cv2.imwrite(imaj,output)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

if __name__ == "__main__":
    for imaj in imajlar:
        image = cv2.imread("kontrol/"+imaj)
        output = image.copy()
        check_image(image,output,imaj)

from keras.preprocessing.image import img_to_array

from keras.models import load_model

import numpy as np

import imutils

import pickle

import cv2

import os

# imajlar

imajlar = ["c_arkin2.jpg","s_alisik6.jpg","t_soray2.jpg"]

def check_image(image,output,imaj):

image = cv2.resize(image, (96, 96))

image = image.astype("float") / 255.0

image = img_to_array(image)

image = np.expand_dims(image, axis=0)

print("Ağ yükleniyor...")

model = load_model("yesilcam.model")

lb = pickle.loads(open("etiket.pickle", "rb").read())

print("İmaj sınıflandırılıyor...")

proba = model.predict(image)[0]

idx = np.argmax(proba)

label = lb.classes_[idx]

filename = imaj[imaj.rfind(os.path.sep) + 1:]

correct = "tamam" if filename.rfind(label) != -1 else "hata"

mesaj = "{}: {:.2f}% ({})".format(label, proba[idx] * 100, correct)

output = imutils.resize(output, width=400)

cv2.putText(output, mesaj, (10, 25), cv2.FONT_HERSHEY_SIMPLEX,

0.7, (0, 255, 0), 2)

print("{}".format(label))

cv2.imshow("Sonuç", output)

cv2.imwrite(imaj,output)

cv2.waitKey(0)

cv2.destroyAllWindows()

if __name__ == "__main__":

for imaj in imajlar:

image = cv2.imread("kontrol/"+imaj)

output = image.copy()

check_image(image,output,imaj)

Sınıflandırma işlemlerinde eğitim aşamasında kullanmadığımız görsellerden yararlanacağız. Her sanatçı için birer görsel seçtik ve bunları kontrol klasörünün altına kopyaladık.

İlk 7 satırda gerekli kütüphaneleri içeri aktarıyoruz.

imajlar listesi sınıflandıracağımız fotoğrafları tutuyor. satır 10

Sınıflandırma işlemlerini check_image() fonksiyonu ile yapacağız (satır 12). Her görsel ayrı ayrı işleme sokulacak.

Satır 13-16’da imajımızı 96×96 piksel boyutlarına küçültüyor ve modelimize uygun bir numpy dizisine dönüştürüyoruz.

Satır 19 ve 20’de eğitim sonunda kaydettiğimiz model ve etiket bilgilerini belleğe alıyoruz.

Modele göre bulunan tahmin ve olası doğruluk derecesini saptıyor; etiket değerini alıyoruz. satır 23-25

Sınıflandırma sonucunu genişliğini 400 pikselle sınırlandırdığımız imajımızın üzerine işliyoruz. satır 28-33

İşlenmiş imajı ekranda gösterip diske kaydettikten sonra bir tuşa basılmasını bekliyoruz. satır 35-38

Tuşa basıldığında belleği temizliyoruz: satır 39

check_image() fonksiyonumuzu her resim için ayrı ayrı çağıran döngümüz satır 42-45 arasında.

Elde ettiğim görüntüler aşağıda:

SmallerVGGNet kullanarak yaptığım denemelerde daha yüksek sayısal doğruluk oranlarına ulaştım ama, yapılan tahminlerin pek çoğu aslında hatalıydı. Bu, veri kümemizin çok dar olmasından kaynaklanmış olabilir.

Aynı eğitim setini yüz saptama fonksiyonlarıyla birlikte kullanarak grup fotoğraflarından çoklu yüz tanıma işlemleri gerçekleştirmek mümkün olabilir.

Açıklamalara böyle bir blog yazısında daha kapsamlı bir şekilde girmek mümkün olmuyor. Sorularınız varsa, yorum alanından iletebilirsiniz.

Bu tür çalışmalar çok geniş bir kapsama alanına sahip. Yapılan işlemler ve elde edilen sonuçlar deneysel nitelikte. Bu yüzden, bu tür konulara ilgi duyuyorsanız, siz de kendi modellerinizi geliştirin. Mümkünse veri kümeleri oluşturun. Deneyin. Yorumlayın.

Elbette hala öğrenecek çok şey var. Ama yapabileceğimiz şeyler de pek çok…

Önemli olan, hangi düzeyde olursak olalım, deneysel bakış açımızı yitirmemek ve hevesimizi kaybetmemek… Hata yapmak bizi korkutmasın. Hatalar, kullanmasını bilenler için en etkin yol göstericilerdir.

Yeni yazılarda buluşmak üzere…

Beni izlemeye devam edin.

Ahmet Aksoy

Referanslar:
https://github.com/kjaisingh/pokemon-classifier/blob/master/pyimagesearch/smallervggnet.py
https://www.pyimagesearch.com/2018/04/16/keras-and-convolutional-neural-networks-cnns/
https://hackernoon.com/learning-keras-by-implementing-vgg16-from-scratch-d036733f2d5
http://www.robots.ox.ac.uk/~vgg/research/very_deep/

OpenCV ile Yüz Tanıma Bölüm 3-1

derin öğrenme, makine öğrenmesi, opencv, python 2 Yanıt »

Ara 172018

OpenCV ile Yüz Tanıma Bölüm 3-1

Bu yazımda 3 Yeşilçam emektarının fotoğraflarını içeren küçük bir veri setini oluşturmak için gerekli işlemleri ele alacağım. Eğitim ve sınıflandırma işlemleri ise bir sonraki yazımın konusu olacak.

Orijinal kodları yine PyimageSearch web sitesinden edinmek mümkün. Adrian, anime karakterleri kullanmış. Ben ise Yeşilçam karakterlerini tercih ettim. Ayrıca kodları biraz daha basitleştirdim ve gerekli yerlerini Türkçeleştirdim.

Veri seti için Google üzerinden ulaşabildiğim fotoğrafların sayısı hiç ummadığım kadar düşük çıktı. Oysa çok fazla fotoğrafa ulaşabileceğimi umuyordum. Bu proje için 3 sanatçımızın toplam 147 farklı fotoğrafına ulaşabildim. Sayının azlığına rağmen sınıflandırma değerleri fena değil.

Projemizde 4 ayrı betiğimiz var:
1- Dosyadaki linklerin okunup, ilgili imaj dosyalarının internetten indirilip kaydedilmesi
2- Kaydedilen dosyaların denetlenerek, içeriği aynı olan dosyaların teke düşürülmesi
3- Veri setinin eğitilmesi
4- Eğitilmiş veri seti bilgilerini kullanarak örnek dosyaların sınıflandırılması

VERİ SETİMİZİ OLUŞTURMAK

Sanatçılarımız: Türkan Şoray, Sadri Alışık ve Cüneyt Arkın. Amacım sadece çalışma yöntemini örneklemek olduğu için sayıyı daha fazla arttırmadım. Belki ileride, bu veri setini genişletip çok daha zengin ve işlevsel bir projeye dönüştürmek mümkün olabilir.

1. ADIM – VERİ SETİNİN OLUŞTURULMASI

İnternet üzerinden ulaştığım görsel linklerini, “linkler.txt” isimli bir metin dosyasına kaydettim. Bu dosyayı linkler.txt adresinden indirebilir veya tamamen kendiniz oluşturabilirsiniz.
Dosya yapısı şöyle:
sanatçı_kodu,link1
sanatçı_kodu,link2
…
Sanatçı kodları aynı zamanda data klasörünün içindeki klasörlerin de adlarıdır. O nedenle kodlarda Türkçe karakter kullanmadım. Kodlar ve klasör isimleri şu şekildedir:
c_arkin
s_alisik
t_soray

Betik kodlarını kısa tutmak için data klasörünü ve onun altındaki klasörleri kendim oluşturdum.

Önce ilk betiğimizi (resim_indir.py) inceleyelim:

import cv2
from skimage import io

filename='linkler.txt'
ok=0
hata=0
kac={}
with open(filename) as f:
    for sat in f.readlines():
        sat = sat.strip()
        if len(sat)>3:
            if sat[0]=='#':continue
            ss=sat.split(',')
            kim=ss[0]
            url=ss[1]
            if len(ss)>2:url+=ss[2]
            try:
                print(kim,url)
                if kim not in kac.keys():
                    kac[kim]=1
                image=io.imread(url)
                image=cv2.cvtColor(image,cv2.COLOR_RGB2BGR)
                cv2.imshow('image',image)
                if cv2.waitKey(1) & 0xff == 27: break
                ok+=1
                # kaydet
                while True:
                    if kac[kim]>100:break
                    try:
                        dosya=f"data/{kim}/{kac[kim]:04}.jpg"
                        cv2.imwrite(dosya,image)
                        kac[kim]+=1
                        break
                    except Exception as e:
                        kac[kim]+=1
                        print(kac[kim])
            except:
                hata+=1
                print("hata: ",hata)

cv2.destroyAllWindows()

import cv2

from skimage import io

filename='linkler.txt'

ok=0

hata=0

kac={}

with open(filename) as f:

for sat in f.readlines():

sat = sat.strip()

if len(sat)>3:

if sat[0]=='#':continue

ss=sat.split(',')

kim=ss[0]

url=ss[1]

if len(ss)>2:url+=ss[2]

try:

print(kim,url)

if kim not in kac.keys():

kac[kim]=1

image=io.imread(url)

image=cv2.cvtColor(image,cv2.COLOR_RGB2BGR)

cv2.imshow('image',image)

if cv2.waitKey(1) & 0xff == 27: break

ok+=1

# kaydet

while True:

if kac[kim]>100:break

try:

dosya=f"data/{kim}/{kac[kim]:04}.jpg"

cv2.imwrite(dosya,image)

kac[kim]+=1

break

except Exception as e:

kac[kim]+=1

print(kac[kim])

except:

hata+=1

print("hata: ",hata)

cv2.destroyAllWindows()

skimage kütüphanesi, imaj dosyalarımızı doğrudan internet üzerinden okuyabilmek için gerekli. Ancak bu kütüphane RGB renk sistemini kullanıyor. Bu yüzden 22 nolu satır ile renk sistemini OpenCV’nin kullandığı BGR sistemine çeviriyoruz.

Linkleri tutan dosyamızın adı “linkler.txt”.

Sorunsuz okunan dosya sayısını tutmak için ok, sorunluları saymak içinse hata değişkenlerini kullanıyoruz.

kac sözlük değişkeni, her sanatçı için dosya isimlerini ayrı ayrı sayılaştırmamızı sağlıyor.

Satırları tek tek okuyoruz. # ile başlayan veya boyu 3 karakterden kısa olan satırları atlıyoruz.

İşlenecek satırları “,” ile parçalıyoruz. İlk parçada sanatçı kodu bulunuyor. Normalde ikinci parçanın link adresini tutması lazım. Ancak, sayıları az olsa da, bazı link adreslerinde “,” işaretinin kullanıldığına rastlayabiliriz. Bu nedenle -eğer varsa- 3. parçayı 2. parçaya ekleyerek doğru adresi elde ediyoruz.

17. satırda başlattığımız try bloğu, hatalı okumalardan kaçınmamızı sağlıyor.

kim değişkeni sanatçı kodunu, url ise imaj adresini saklıyor.

kac anahtarları içinde kim stringi yoksa, ilk kez tanımlanacak demektir. Başlangıç değeri olarak 1 atıyoruz.

21. satırda dosyamızı internet üzerinden okuyor; 2. satırda renk sistemini BGR haline çeviriyor ve 23. satırda okuduğumuz imajı görselleştiriyoruz.

24. satırdaki tuş kontrolü, gerektiğinde, Esc tuşuna basarak döngüyü kırabilmemizi sağlıyor. Bu satır aynı zamanda görselleştirme işlemleri için de gerekli.

27-36 satırlarını kullanarak dosyayı data klasörü altındaki sanatçı klasörüne (kim) kaydediyoruz. Dosya isimlendirmesinde bir çakışma olması ihtimalini dikkate alıyor, ama bu sayının 100’den fazla olmasına izin vermiyoruz. (Dikkat! Eğer kendi veri setinizi oluşturacaksanız, kullanacağınız link sayısını dikkate almak için bu sınırı değiştirmeniz gerekebilir.)

41. satırda son işlem olarak bilgisayar belleğini temizliyoruz.

İmajlar farklı boyutlarda olduğu için işlenmeleri farklı süreler gerektirebiliyor.

(Not: Çalışmalarımı Pycharm üzerinde yapıyor ve çalıştırıyorum. Ancak bu betiği terminal üzerinden çalıştırmak zorunda kaldım. Aynı durum sizin başınıza da gelebilir. Betiği çalıştırmak için Pycharm’ın terminal modunu kullanabilirsiniz.)

2. ADIM – İMAJ TEKRARLARININ ÖNLENMESİ

Bu betiğimizde doğrudan md5 hesaplamak yerine imagehash kütüphanesindeki dhash() metodunu uyguluyoruz. Bu metod hash hesabını imajları belli bir boyuta indirip gri renge çevirdikten sonra yapıyor. Yeniden boyutlandırma biraz zaman alıyor olsa da sonuçlar daha güvenilir.

"""
imaj_dup_check.py
aynı klasördeki aşırı benzer dosyalar temizleniyor
"""

import os
from PIL import Image
import imagehash

def hash(f):
    image = Image.open(f)
    return str(imagehash.dhash(image))

def tekrar_sil(path):
    if not os.path.isdir(path):
        print('Belirtilen klasör mevcut değil!')
    else:
        hash_dict = {}
        for root, dirs, files in os.walk(path):
            for f in files:
                if not hash(os.path.join(root, f)) in hash_dict:
                    hash_dict.update({hash(os.path.join(root, f)): [os.path.join(root, f)]})
                else:
                    hash_dict[hash(os.path.join(root, f))].append(os.path.join(root, f))
        for key in hash_dict:
            while len(hash_dict[key]) > 1:
                for item in hash_dict[key]:
                    print(item," siliniyor...")
                    os.remove(item)
                    hash_dict[key].remove(item)
        print('Tamam!')

if __name__ == '__main__':
    tekrar_sil("data")

"""

imaj_dup_check.py

aynı klasördeki aşırı benzer dosyalar temizleniyor

"""

import os

from PIL import Image

import imagehash

def hash(f):

image = Image.open(f)

return str(imagehash.dhash(image))

def tekrar_sil(path):

if not os.path.isdir(path):

print('Belirtilen klasör mevcut değil!')

else:

hash_dict = {}

for root, dirs, files in os.walk(path):

for f in files:

if not hash(os.path.join(root, f)) in hash_dict:

hash_dict.update({hash(os.path.join(root, f)): [os.path.join(root, f)]})

else:

hash_dict[hash(os.path.join(root, f))].append(os.path.join(root, f))

for key in hash_dict:

while len(hash_dict[key]) > 1:

for item in hash_dict[key]:

print(item," siliniyor...")

os.remove(item)

hash_dict[key].remove(item)

print('Tamam!')

if __name__ == '__main__':

tekrar_sil("data")

İkinci betiğimizde os, PIL ve imagehash kütüphanelerini kullanıyoruz.

hash() fonksiyonumuzda okuma işlemini PIL.Image modülü ile gerçekleştiriyor ve elde edilen imaja imagehash.dhash() işlemini uyguluyoruz. (Doğrudan md5 hesabı yaptığımızda birbirine çok benzer bazı imajlar gözden kaçabiliyor.)

Tekrarlanan imaj dosyaları tekrar_sil() fonksiyonunun içinde temizleniyor.

19. satırda path değişkenimizle aktarılan klasör yolu bir döngü yapısı içinde kök, klasör ve dosya bileşenlerine ayrıştırılıyor ve her bir dosya için hash() değeri hesaplanıp, hash_dict sözlük değişkeninde saklanıyor. Eğer eşdeğer hash değeri (key) bulunursa, aynı anahtarın karşılığına mükerrer dosyanın adı ekleniyor. Böylece len(hash_dict[k]) değeri birden büyük olan kayıtlar, mükerrer dosyaları tutuyor.

25-30 satırları mükerrer dosyaların silinmesini sağlıyor.

34. satırda data klasörünü işleme sokuyoruz. Böylece onun altındaki tüm klasör ve dosyaları taramış oluyoruz.

Sizi daha fazla yormamak ve veri setini hazırlamanız zaman tanımak için bu yazıyı burada kesiyorum. Bir sonraki yazımda, oluşturduğumuz veri setini önce eğiteceğiz, sonra da eğitim setinde yer almayan kontrol görsellerinin kime ait olduğunu sorgulayacağız.

Beni izlemeye devam edin.

Ahmet Aksoy

Referanslar:

https://www.pyimagesearch.com/

OpenCV ile Yüz Tanıma Bölüm 2

makine öğrenmesi, opencv, python 25 Yanıt »

Ara 092018

OpenCV ile Yüz Tanıma Bölüm 2

Bu bölümde 3 ayrı betik kullanıyoruz:
1- veri toplama: 01_face_dataset.py
2- eğitim: 02_face_training.py
3- uygulama: 03_face_recognition.py

Orijinal kodlara https://www.hackster.io/mjrobot/real-time-face-recognition-an-end-to-end-project-a10826 adresinden ulaşabilirsiniz.

Ben veri kümesini yeniden oluşturdum. Türkçe karakterlerin görüntülenebilmesi için gerekli düzenlemeyi yaptım ve bazı mesajları Türkçeleştirdim.

İlk betikte input() komutunu # ile devre dışı bıraktım. Yeni bir yüz tanıtırken face_id sayısını doğrudan tanımladım. Örneğimizde 4 yüz tanımlı. Her yüz için 30 kare dataset klasörüne kaydedildi. Siz de kendi verilerinizi kaydetmeli ve eğitmelisiniz.

# 01_face_dataset.py
import cv2
import os
cam = cv2.VideoCapture(0)
cam.set(3, 640) # set video width
cam.set(4, 480) # set video height
face_detector = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')
# For each person, enter one numeric face id
# face_id = input('\n enter user id end press <return> ==>  ')
face_id = 1
print("\n [INFO] Initializing face capture. Look at the camera and wait ...")
# Initialize individual sampling face count
count = 0

while(True):
    ret, img = cam.read()
    # img = cv2.flip(img, -1) # flip video image vertically
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    faces = face_detector.detectMultiScale(gray, 1.3, 5)
    for (x,y,w,h) in faces:
        cv2.rectangle(img, (x,y), (x+w,y+h), (255,0,0), 2)
        count += 1
        # Save the captured image into the datasets folder
        cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", gray[y:y+h,x:x+w])
        cv2.imshow('image', img)
    k = cv2.waitKey(100) & 0xff # Press 'ESC' for exiting video
    if k == 27:
        break
    elif count >= 30: # Take 30 face sample and stop video
         break
# Do a bit of cleanup
print("\n [INFO] Exiting Program and cleanup stuff")
cam.release()
cv2.destroyAllWindows()

# 01_face_dataset.py

import cv2

import os

cam = cv2.VideoCapture(0)

cam.set(3, 640) # set video width

cam.set(4, 480) # set video height

face_detector = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')

# For each person, enter one numeric face id

# face_id = input('\n enter user id end press <return> ==> ')

face_id = 1

print("\n [INFO] Initializing face capture. Look at the camera and wait ...")

# Initialize individual sampling face count

count = 0

while(True):

ret, img = cam.read()

# img = cv2.flip(img, -1) # flip video image vertically

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

faces = face_detector.detectMultiScale(gray, 1.3, 5)

for (x,y,w,h) in faces:

cv2.rectangle(img, (x,y), (x+w,y+h), (255,0,0), 2)

count += 1

# Save the captured image into the datasets folder

cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", gray[y:y+h,x:x+w])

cv2.imshow('image', img)

k = cv2.waitKey(100) & 0xff # Press 'ESC' for exiting video

if k == 27:

break

elif count >= 30: # Take 30 face sample and stop video

break

# Do a bit of cleanup

print("\n [INFO] Exiting Program and cleanup stuff")

cam.release()

cv2.destroyAllWindows()

İlk betiğimizde cv2 ve os kütüphanelerini kullanıyoruz.

Görüntüleri webcam üzerinden elde edeceğiz. Görüntülerimizin eni 640, yüksekliği 480 piksel olarak tanımlandı (satır 5 ve 6).

7 nolu satırda cepheden yüz sınıflandırıcısını tanımlıyoruz.

face_id yüz görüntülerini eğiteceğimiz kullanıcı numarasını belirtiyoruz. Eğer input() satırını kullanmak isterseniz 9.satırın başındaki # işaretini silip, 10. satırın başına # eklemelisiniz.

count değişkenini görüntü sayısını takip etmek için kullanacağız.

Kayıt işlemlerimiz 15. satırdaki sonsuz while döngüsüyle başlıyor.

16. satırda kamera görüntüsünü alıyoruz. ret değişkeni işlevsizdir. Bu değişken video dosyasından okuma yaparken işimize yarıyor.

Görüntü karesini griye çevirip içindeki yüzleri saptıyoruz. (Satır 18 ve 19.)

Aslında her karede sadece 1 kişiye ait tek bir yüz bulunmalı. Yine de burada bir döngü kullanıyoruz. Aslında döngüdeki enbüyük dikdörtgeni seçsek daha doğru olurdu. Ama kodu gereksiz yere uzatmamak için bu tür ayrıntılara girmiyoruz.

Yakalanan her yüz için count değerini 1 arttırıyor (satır 22) ve yüz görüntüsünü dataset klasörüne kaydediyoruz. Kaydedilen görüntünün boyutları yüzün boyutları ile aynı. Yani webcam tarafından yakalanan görüntünün tümünü kullanmıyoruz. (Satır 24)

25.satırda kamera görüntüsünü (tamamını) ekrana yansıtıyoruz.

k değişkeni ile 100 milisaniye içinde bir tuşa basılıp basılmadığını kontrol ediyoruz.

Eğer ‘Esc’ tuşuna basıldıysa (sayısal karşılığı 27 olan tuş) döngüyü kırıyor, basılmadıysa bu kez count değerinin 30’u aşıp aşmadığını denetliyoruz. Sayı 30’u aştıysa döngüyü yine kırıyoruz. Çünkü her kişi için 30 görüntü kaydediyoruz.

Son iki satırda kamerayı serbest bırakıyor ve belleği temizliyoruz.

“dataset” klasörünün içine bakarsanız, verdiğiniz kullanıcı numarasına karşılık gelen 30 adet resim göreceksiniz.

Kullanıcı sayısını (yüz görüntülerini kaydedeceğiniz kişi sayısını) istediğiniz kadar arttırabilirsiniz. (Elbette en az bir kişi olmalı!)

Verilerimizi tamamladığımızda işimiz bitmiyor. Şimdi bu veri kümesini eğitmemiz lazım. İkinci betiğimizin işlevi bu!

import cv2
import numpy as np
from PIL import Image
import os
# Path for face image database
path = 'dataset'
recognizer = cv2.face.LBPHFaceRecognizer_create()
detector = cv2.CascadeClassifier("Cascades/haarcascade_frontalface_default.xml");
# function to get the images and label data
def getImagesAndLabels(path):
    imagePaths = [os.path.join(path,f) for f in os.listdir(path)]
    faceSamples=[]
    ids = []
    for imagePath in imagePaths:
        PIL_img = Image.open(imagePath).convert('L') # convert it to grayscale
        img_numpy = np.array(PIL_img,'uint8')
        id = int(os.path.split(imagePath)[-1].split(".")[1])
        faces = detector.detectMultiScale(img_numpy)
        for (x,y,w,h) in faces:
            faceSamples.append(img_numpy[y:y+h,x:x+w])
            ids.append(id)
    return faceSamples,ids
print ("\n [INFO] Training faces. It will take a few seconds. Wait ...")
faces,ids = getImagesAndLabels(path)
recognizer.train(faces, np.array(ids))
# Save the model into trainer/trainer.yml
recognizer.write('trainer/trainer.yml') # recognizer.save() worked on Mac, but not on Pi
# Print the numer of faces trained and end program
print("\n [INFO] {0} faces trained. Exiting Program".format(len(np.unique(ids))))

import cv2

import numpy as np

from PIL import Image

import os

# Path for face image database

path = 'dataset'

recognizer = cv2.face.LBPHFaceRecognizer_create()

detector = cv2.CascadeClassifier("Cascades/haarcascade_frontalface_default.xml");

# function to get the images and label data

def getImagesAndLabels(path):

imagePaths = [os.path.join(path,f) for f in os.listdir(path)]

faceSamples=[]

ids = []

for imagePath in imagePaths:

PIL_img = Image.open(imagePath).convert('L') # convert it to grayscale

img_numpy = np.array(PIL_img,'uint8')

id = int(os.path.split(imagePath)[-1].split(".")[1])

faces = detector.detectMultiScale(img_numpy)

for (x,y,w,h) in faces:

faceSamples.append(img_numpy[y:y+h,x:x+w])

ids.append(id)

return faceSamples,ids

print ("\n [INFO] Training faces. It will take a few seconds. Wait ...")

faces,ids = getImagesAndLabels(path)

recognizer.train(faces, np.array(ids))

# Save the model into trainer/trainer.yml

recognizer.write('trainer/trainer.yml') # recognizer.save() worked on Mac, but not on Pi

# Print the numer of faces trained and end program

print("\n [INFO] {0} faces trained. Exiting Program".format(len(np.unique(ids))))

İkinci -eğitim- betiğimizde opencv ve os yanısıra numpy ve pillow kütüphanelerini kullanıyoruz.

Veri klasörümüzün adı ‘dataset’. Bu bilgiyi path değişkeninde tutuyoruz.

Veri kümemizin eğitimini cv2.face.LBPHFaceRecognizer_create() komutuyla oluşturduğumuz recognizer (satır 7) üzerinden yapacağız.

Görüntülerdeki yüz alanlarını ayırmak için yine ‘haarcascade_frontalface_default.xml’ filtresinden yararlanacağız. Filtre değişkenimizin adı: detector. (satır 8)

Görüntü etiketlerimizi almak için getImagesAndLabels() fonksiyonunu kullanıyoruz.

ImagePaths listesi, path klasörü içinde yer alan dosyaların listesidir.

faceSamples listesi yüz görüntülerini, ids listesi ise her bir görüntünün etiketini tutacak.

imagePaths listesindeki her bir elemanı (dosya adını) kullanarak ilgili resmi okuyup griye dönüştürüyor ve PIL_img değişkenine atıyoruz (satır 15). Sonra bu görüntüleri 8 bitlik pozitif tamsayılardan oluşan bir numpy dizisi (array) haline dönüştürüyoruz (satır 16).

17 numaralı satırda, dosya adından kişi numarasını ayırıp, bir tam sayı olarak id değişkenine atıyoruz.

img_numpy görüntü numpy dizisinde bulunan yüz alanlarını bulup faces listesine atıyoruz. Yüzleri içeren listeyi döngüye sokup her bir görüntüyü faceSamples, ona karşılık gelen etiketi ise ids listesine ekliyoruz.

Fonksiyonumuz faceSamples ve ids listelerini döndürüyor.

24 numaralı satırda faces ve ids listeleri oluşturuluyor.

25 nolu satırda ise veri kümemizi eğitiyoruz.

Eğitilmiş veriseti bilgileri 27. satırda trainer klasörü içindeki trainer.yml dosyasına kaydediliyor. Bu dosyayı son betiğimizdeki görüntüleri sınıflandırırken kullanacağız.

Son betiğimiz şöyle:

# 03_face_recognition.py

import cv2
import numpy as np
from PIL import Image, ImageDraw, ImageFont

# UTF-8 string printing enabled
def print_utf8_text(image, xy, text, color):  # utf-8 characters
    fontName = 'FreeSerif.ttf'  # 'FreeSansBold.ttf' # 'FreeMono.ttf' 'FreeSerifBold.ttf'
    font = ImageFont.truetype(fontName, 24)  # select font
    img_pil = Image.fromarray(image)  # convert image to pillow mode
    draw = ImageDraw.Draw(img_pil)  # prepare image
    draw.text((xy[0],xy[1]), text, font=font,
              fill=(color[0], color[1], color[2], 0))  # b,g,r,a
    image = np.array(img_pil)  # convert image to cv2 mode (numpy.array())
    return image

recognizer = cv2.face.LBPHFaceRecognizer_create()
recognizer.read('trainer/trainer.yml')
cascadePath = "Cascades/haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascadePath);
font = cv2.FONT_HERSHEY_SIMPLEX
# initiate id counter
id = 0
# names related to ids: example ==> Marcelo: id=1,  etc
# names = ['None', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']
names = ['None', 'Ahmet','Toygar','Nilden','Nilüfer']
# Initialize and start realtime video capture
cam = cv2.VideoCapture(0)
cam.set(3, 1000)  # set video widht
cam.set(4, 800)  # set video height
# Define min window size to be recognized as a face
minW = 0.1 * cam.get(3)
minH = 0.1 * cam.get(4)
while True:
    ret, img = cam.read()
    # img = cv2.flip(img, -1)  # Flip vertically
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    faces = faceCascade.detectMultiScale(
        gray,
        scaleFactor=1.2,
        minNeighbors=5,
        minSize=(int(minW), int(minH)),
    )
    for (x, y, w, h) in faces:
        cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
        id, confidence = recognizer.predict(gray[y:y + h, x:x + w])
        # Check if confidence is less them 100 ==> "0" is perfect match
        if (confidence < 100):
            id = names[id]
            confidence = "  {0}%".format(round(100 - confidence))
        else:
            id = "bilinmiyor"
            confidence = "  {0}%".format(round(100 - confidence))

        color = (255,255,255)
        img=print_utf8_text(img,(x + 5, y - 25),str(id),color)
        # cv2.putText(img, str(id), (x + 5, y - 5), font, 1, (255, 255, 255), 2)
        cv2.putText(img, str(confidence), (x + 5, y + h - 5), font, 1, (255, 255, 0), 1)

    cv2.imshow('camera', img)
    k = cv2.waitKey(10) & 0xff  # Press 'ESC' for exiting video
    if k == 27 or k==ord('q'):
        break
# Do a bit of cleanup
print("\n [INFO] Programdan çıkıyor ve ortalığı temizliyorum")
cam.release()
cv2.destroyAllWindows()

# 03_face_recognition.py

import cv2

import numpy as np

from PIL import Image, ImageDraw, ImageFont

# UTF-8 string printing enabled

def print_utf8_text(image, xy, text, color): # utf-8 characters

fontName = 'FreeSerif.ttf' # 'FreeSansBold.ttf' # 'FreeMono.ttf' 'FreeSerifBold.ttf'

font = ImageFont.truetype(fontName, 24) # select font

img_pil = Image.fromarray(image) # convert image to pillow mode

draw = ImageDraw.Draw(img_pil) # prepare image

draw.text((xy[0],xy[1]), text, font=font,

fill=(color[0], color[1], color[2], 0)) # b,g,r,a

image = np.array(img_pil) # convert image to cv2 mode (numpy.array())

return image

recognizer = cv2.face.LBPHFaceRecognizer_create()

recognizer.read('trainer/trainer.yml')

cascadePath = "Cascades/haarcascade_frontalface_default.xml"

faceCascade = cv2.CascadeClassifier(cascadePath);

font = cv2.FONT_HERSHEY_SIMPLEX

# initiate id counter

id = 0

# names related to ids: example ==> Marcelo: id=1, etc

# names = ['None', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']

names = ['None', 'Ahmet','Toygar','Nilden','Nilüfer']

# Initialize and start realtime video capture

cam = cv2.VideoCapture(0)

cam.set(3, 1000) # set video widht

cam.set(4, 800) # set video height

# Define min window size to be recognized as a face

minW = 0.1 * cam.get(3)

minH = 0.1 * cam.get(4)

while True:

ret, img = cam.read()

# img = cv2.flip(img, -1) # Flip vertically

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

faces = faceCascade.detectMultiScale(

gray,

scaleFactor=1.2,

minNeighbors=5,

minSize=(int(minW), int(minH)),

)

for (x, y, w, h) in faces:

cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)

id, confidence = recognizer.predict(gray[y:y + h, x:x + w])

# Check if confidence is less them 100 ==> "0" is perfect match

if (confidence < 100):

id = names[id]

confidence = " {0}%".format(round(100 - confidence))

else:

id = "bilinmiyor"

confidence = " {0}%".format(round(100 - confidence))

color = (255,255,255)

img=print_utf8_text(img,(x + 5, y - 25),str(id),color)

# cv2.putText(img, str(id), (x + 5, y - 5), font, 1, (255, 255, 255), 2)

cv2.putText(img, str(confidence), (x + 5, y + h - 5), font, 1, (255, 255, 0), 1)

cv2.imshow('camera', img)

k = cv2.waitKey(10) & 0xff # Press 'ESC' for exiting video

if k == 27 or k==ord('q'):

break

# Do a bit of cleanup

print("\n [INFO] Programdan çıkıyor ve ortalığı temizliyorum")

cam.release()

cv2.destroyAllWindows()

Kamera görüntülerindeki yüzleri yakalayıp kime ait olduklarını belirten betiğimiz bu. Kullanacağımız kütüphaneler opencv, numpy ve pillow.

print_utf8_text() fonksiyonunu bir önceki yazımda anlatmıştım. Türkçe karakterleri bu fonksiyon aracılığıyla bastırıyoruz.

Yüz tanıma nesnemiz recognizer‘a trainer.yml dosyası aracılığıyla eğitilmiş verisetimizi yüklüyoruz (satır 18 ve 19).

Canlı kamera görüntülerindeki yüzleri de yine haarcascade_frontalface_default.xml filtresi aracılığıyla yakalayacağız. Filtre değişkenimiz faceCascade (satır 20 ve 21).

22 nolu satırda orijinal betikte kullanılan font tanımlanıyor. Biz bu fontu da kullanacağız.

Kişi numaraları id değikeninde tutulacak. (Satır 24)

Etiketleri (isimleri) ise names listesiyle tanımlıyoruz.

Web kamerasının görüntüsünü cam değişkenine aktarıyoruz ve görüntü boyutlarını 1000 ve 800 piksel olarak ayarlıyoruz. (Bu değerleri 640 ve 480 olarak da bırakabilirdik.)

minW ve minH değişkenleri yakalanan yüz dikdörtgenlerinin boyutu için alt sınır değerleridir (satır 33 ve 34). Bu değerleri kendi ortamınıza göre değiştirebilirsiniz.

35 nolu satırda sonsuz döngümüz başlıyor.

36. satırda kamera görüntüsünü okuyor, 38. satırda bu görüntüyü grileştiriyoruz.

40 nolu satırda görüntü karesindeki tüm yüzleri yakalıyor; 46. satırda ise bu yüz dikdörtgenlerini bir döngü içinde işleme sokuyoruz.

recognizer.predict() metodu id ve confidence değerlerini döndürüyor. id kişi numarası; confidence ise yapılan saptamanın tahmini doğruluk oranıdır (satır 48).

id ve confidence değişkenlerini print için uygun hale getiriyoruz (satır 50-55).

58 nolu satırda kişi ismini UTF-8 kullanarak (Türkçe karakterleri doğru şekilde yansıtarak), 60 nolu satırda ise belirtilen kişinin tahmini doğruluk oranını standart font ile görüntüye işliyoruz.

Görüntünün ekrana yansıtılması 62 nolu satırda.

Döngümüz yine Esc veya q tuşlarından birine basıldığında kırılıyor.

Döngü kırıldığında web kamerayı sonlandıyor ve belleği temizliyoruz (satır 68-69).

Bu betiğin çalışmasını gösteren örnek video aşağıda.

Bu yazı, açıklamaları olabildiğince kısa tutsam da biraz uzunca oldu. Umarım yeterince açıklayıcıdır. Sorularınız için yorum alanını kullanabilirsiniz.

Bir sonraki yazımda yine yüz tanıma olacak. Ancak veri kümemizi oluşturmak ve eğitmek için farklı yöntemler kullanacağız.

Beni izlemeye devam edin.

Ahmet Aksoy

OpenCV ile Yüz Tanıma Bölüm 1

opencv, python 8 Yanıt »

Ara 062018

OpenCV ile Yüz Tanıma Bölüm 1

Yüz tanıma biraz geniş kapsamlı bir konu. Öncelikle incelediğimiz görselde bulunan olası “yüz”leri, daha sonra da gerekiyorsa bu yüzlerin “kim”e ait olduğunu saptamak sözkonusu. Ya da yüzlerin üzerindeki yüz, göz, kaş, burun, kulak gibi elemanların (facial features) belirlenmesi… O yüzden bu konuyu tek bir yazıyla değil, ardışık birkaç yazıyla ele alacağım.

İlk bölümde bir fotoğraf karesinde kaç adet “yüz” bulunduğunu saptayacağız.

Çeşitli beden parçalarını filtre etmek amacıyla kullanılan en yaygın araçlardan biri “haar cascade” sınıflandırıcılarıdır. Yazının sonunda bu “.xml” uzantılı dosyalara ulaşabileceğiniz çeşitli linkler bulacaksınız. Hatta isterseniz, kendi sınıflandırıcılarınızı bile eğitebilirsiniz. (Ben şimdilik bu maceraya kalkışmıyorum. Elde yeterince hazır kaynak var.)

Ele alacağımız “face_count.py” betiğindeki temel filtremiz “haarcascade_frontalface_default.xml”. Bu filtre genellikle çok verimli çalışıyor. Ancak imaj boyutları yeterince büyük değilse bazı hatalı (false positive) sonuçlar döndürebiliyor. Bu sorunu kısmen de olsa aşabilmek için “it_contains_eyes()” isimli bir fonksiyon tanımladım. Bu fonksiyon saptanan yüz alanının içinde göz, burun veya dudak olup olmadığını araştırıyor. Bulamazsa, yüz bulgusunun hatalı olduğunu geriye “False” döndürerek bildiriyor.

Ben 3 ayrı fotoğrafı döngü içinde test ettirdim. Siz de kendi istediğiniz fotoğrafları kullanabilirsiniz.

Orijinal koda ilave ettiğim bir değişiklik de UTF-8 fontlarını destekleyen Pillow kütüphanesini kullanarak hazırladığım print_utf8_text() fonksiyonudur. Böylece Türkçe karakterleri bastırmak da mümkün. OpenCV’nin putText() fonksiyonu sadece ASCII fontları destekliyor. Bu nedenle Türkçe karakterler basılamıyor.

Kodların içinde İngilizce açıklamalar kullandım. Çünkü bu seri tamamlandığında github üzerinden ve İngilizce olarak paylaşmayı düşünüyorum. İngilizce bilmeyen arkadaşlar zaten buradaki yazılardan aynı açıklamaları fazlasıyla edinebilecekler.

Gelelim kodlarımızın açıklamalarına:

# original code from: https://techtutorialsx.com/2017/05/02/python-opencv-face-detection-and-counting/
# face_count.py
# faces also checked for the existence of eyes, lips and nose
# Instead of ascii fonts, utf-8 fonts are used

import numpy as np
import cv2
from PIL import Image, ImageDraw, ImageFont

# original code from: https://techtutorialsx.com/2017/05/02/python-opencv-face-detection-and-counting/

# face_count.py

# faces also checked for the existence of eyes, lips and nose

# Instead of ascii fonts, utf-8 fonts are used

import numpy as np

import cv2

from PIL import Image, ImageDraw, ImageFont

Betiğimizde numpy ve cv2 yanında PIL kütüphanesini de kullanacağız. Böylece UTF-8 destekli FreeType fontları üzerinden Türkçe karakterli mesajları da basabileceğiz.

faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')
eyeCascade = cv2.CascadeClassifier('Cascades/haarcascade_eye.xml')
smileCascade = cv2.CascadeClassifier('Cascades/haarcascade_smile.xml')
noseCascade = cv2.CascadeClassifier('Cascades/haarcascade_mcs_nose.xml')

no_check = False

faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')

eyeCascade = cv2.CascadeClassifier('Cascades/haarcascade_eye.xml')

smileCascade = cv2.CascadeClassifier('Cascades/haarcascade_smile.xml')

noseCascade = cv2.CascadeClassifier('Cascades/haarcascade_mcs_nose.xml')

no_check = False

“haarcascade” dosyalarını “Cascades” isimli klasörün altında topladım. Bu betikte 4 farklı sınıflandırıcı kullanacağız. Sırasıyla yüz (cepheden), göz, gülümseme (dudak) ve burun.

“nocheck” değişkeni True olursa, fazladan göz, dudak ve burun kontrolü yapılmaması için it_contains_eyes() fonksiyonu işlem yapmadan True döndürerek devre dışı kalacaktır. Bu değer False olursa, ek kontrollerin yapılmasına izin veriliyor demektir.

def print_text(image):  # only english characters
    cv2.putText(image, "Belirlenen yüz sayısı: " + str(faces.shape[0]), (0, image.shape[0] - 10),
                cv2.FONT_HERSHEY_TRIPLEX, 0.5, (0, 0, 0), 1)

def print_text(image): # only english characters

cv2.putText(image, "Belirlenen yüz sayısı: " + str(faces.shape[0]), (0, image.shape[0] - 10),

cv2.FONT_HERSHEY_TRIPLEX, 0.5, (0, 0, 0), 1)

OpenCV string basımı için putText() metodunu kullanıyor. Bu metodun kullanabildiği HERSHEY fontları sadece ASCII karakterleri destekliyor. Eğer sadece İngilizce veya ASCII karakterler içeren mesajlar kullanacaksanız print_text() fonksiyonu size yetecektir.

def print_utf8_text(image, text, color):  # utf-8 characters
    fontName = 'FreeSerif.ttf'  # 'FreeSansBold.ttf' # 'FreeMono.ttf' 'FreeSerifBold.ttf'
    font = ImageFont.truetype(fontName, 18)  # select font
    img_pil = Image.fromarray(image)  # convert image to pillow mode
    draw = ImageDraw.Draw(img_pil)  # prepare image
    draw.text((0, image.shape[0] - 30), text, font=font,
              fill=(color[0], color[1], color[2], 0))  # b,g,r,a
    image = np.array(img_pil)  # convert image to cv2 mode (numpy.array())
    return image

def print_utf8_text(image, text, color): # utf-8 characters

fontName = 'FreeSerif.ttf' # 'FreeSansBold.ttf' # 'FreeMono.ttf' 'FreeSerifBold.ttf'

font = ImageFont.truetype(fontName, 18) # select font

img_pil = Image.fromarray(image) # convert image to pillow mode

draw = ImageDraw.Draw(img_pil) # prepare image

draw.text((0, image.shape[0] - 30), text, font=font,

fill=(color[0], color[1], color[2], 0)) # b,g,r,a

image = np.array(img_pil) # convert image to cv2 mode (numpy.array())

return image

OpenCV doğrudan UTF-8 desteklemediği için Pillow kütüphanesini devreye sokarak FreeType fontlarını kullanabiliyoruz.
Örnekte ‘FreeSerif.ttf’ fontunu kullandım. Siz bir başka fontu tercih edebilirsiniz.
ImageFont.truetype() metodu ile font adını ve boyutunu belirliyoruz.
OpenCV ve Pillow farklı imaj sistemleri kullanıyor. Image.fromarray() metodunu kullanarak OpenCV formatlı imajı Pillow sistemine uygun biçime dönüştürüyoruz. Sonra da bu imajı bir Draw() nesnesi haline çevirip, text mesajımızı da bu nesnenin draw.text() metoduyla görüntünün üzerine işliyoruz.
Son aşamada işlenmiş görüntüyü yine bir numpy.array() biçimine dönüştürerek OpenCV’nin kullandığı formata aktarıyoruz. Fonksiyonumuz, üzerine text mesajı işlenmiş görüntüyü geri döndürüyor.

# Check whether face contains any of eyes, lips and nose
def it_contains_eyes(frame, gray, x, y, w, h):
    if no_check: return True
    roi_gray = gray[y:y + h, x:x + w]

    eyes = eyeCascade.detectMultiScale(
        roi_gray,
        scaleFactor=1.05,
        minNeighbors=3,
        minSize=(20, 20)
    )
    count = 0
    for (ex, ey, ew, eh) in eyes:
        count += 1
    if count > 1:
        return True

    smiles = smileCascade.detectMultiScale(
        roi_gray,
        scaleFactor=1.5,
        minNeighbors=5,
        minSize=(3, 3)
    )
    if len(smiles) > 0: return True

    noses = noseCascade.detectMultiScale(
        roi_gray,
        scaleFactor=1.5,
        minNeighbors=5,
        minSize=(3, 3)
    )
    if len(noses) > 0: return True

    return False

# Check whether face contains any of eyes, lips and nose

def it_contains_eyes(frame, gray, x, y, w, h):

if no_check: return True

roi_gray = gray[y:y + h, x:x + w]

eyes = eyeCascade.detectMultiScale(

roi_gray,

scaleFactor=1.05,

minNeighbors=3,

minSize=(20, 20)

)

count = 0

for (ex, ey, ew, eh) in eyes:

count += 1

if count > 1:

return True

smiles = smileCascade.detectMultiScale(

roi_gray,

scaleFactor=1.5,

minNeighbors=5,

minSize=(3, 3)

)

if len(smiles) > 0: return True

noses = noseCascade.detectMultiScale(

roi_gray,

scaleFactor=1.5,

minNeighbors=5,

minSize=(3, 3)

)

if len(noses) > 0: return True

return False

Eğer no_check değişkenimiz True değerine sahipse, it_contains_eys() fonksiyonumuz başka bir işlem yapmadan True değeri döndürür. Böylece ek kontrol yapılmaz.
Aksi halde önce roi_gray tanımlanır. Bu, “yüz” olarak tesbit edilen dikdörtgen yüzeydir.
İlk kontrol olarak bu alanın içindeki olası “göz”ler araştırılır. Parametreler deneyseldir. Çalışmanız için en uygun değerleri deneyerek bulmanız gerekebilir.
41-45 satırları arasında göz sayısını buluyor, bu sayı sıfırdan büyükse True değeri döndürerek geri dönüyoruz. Aynı satırları if len(eyes)>0: return True olarak kısaltmak da mümkün.
Diğer smiles (gülümseme-dudak) ve noses (burun) kontrolleri de aynı mantıkla çalışıyor.
Bu fonksiyonun temel amacı şudur: Bir yüzün içinde en azından 2 göz, bir dudak veya bir burun olmalıdır. Eğer hiçbiri yoksa, yüz hatalı saptanmıştır.

imageNames = ['toplu.jpg', 'maviboncuk.jpg', 'mt_aday.jpg']
for imageName in imageNames:
    image = cv2.imread(imageName)

    grayImage = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    faces = faceCascade.detectMultiScale(grayImage)

    print(type(faces))

imageNames = ['toplu.jpg', 'maviboncuk.jpg', 'mt_aday.jpg']

for imageName in imageNames:

image = cv2.imread(imageName)

grayImage = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

faces = faceCascade.detectMultiScale(grayImage)

print(type(faces))

Ben bu betikte 3 ayrı imaj kullandım. İlk başta scaleFactor=1.5, minNeighbors=5, minSize(20,20) kullandım. Daha sonra deneme-yanılma yöntemiyle yukarıdaki değerlere ulaştım. Siz de deneyin.
Döngü içinde isimlerini verdiğim imaj dosyaları sırayla okunup image değişkenine atanıyor. Buradan da görüntünün gri bir kopyası oluşturuluyor. Gri görüntüler üzerinde sayısal işlem yapmak çok daha hızlı sonuçlar veriyor.
faceCascade.detectMultiScale(grayImage) metodu bize imaj içinde bulduğu yüz koordinatlarını veriyor (sol üst köşe x, sol üst köşe y, genişlik ve yükseklik). Konsol ekranına type(faces) değerini bastırıyoruz.

    if len(faces) == 0:
        print("Yüz bulunamadı")
    else:
        print(faces)
        print(faces.shape)
        print("Belirlenen yüz sayısı: " + str(faces.shape[0]))

        say = 0
        for (x, y, w, h) in faces:
            if it_contains_eyes(image, grayImage, x, y, w, h):
                say += 1
                cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 1)

        cv2.rectangle(image, ((0, image.shape[0] - 25)), (270, image.shape[0]), (255, 255, 255), -1)
        # print_text()
        text = "Belirlenen yüz sayısı: " + str(say)  # , (0, image.shape[0] - 10)
        color = (0, 0, 0)
        image = print_utf8_text(image, text, color)

        cv2.imshow('Imaj', image)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

if len(faces) == 0:

print("Yüz bulunamadı")

else:

print(faces)

print(faces.shape)

print("Belirlenen yüz sayısı: " + str(faces.shape[0]))

say = 0

for (x, y, w, h) in faces:

if it_contains_eyes(image, grayImage, x, y, w, h):

say += 1

cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 1)

cv2.rectangle(image, ((0, image.shape[0] - 25)), (270, image.shape[0]), (255, 255, 255), -1)

# print_text()

text = "Belirlenen yüz sayısı: " + str(say) # , (0, image.shape[0] - 10)

color = (0, 0, 0)

image = print_utf8_text(image, text, color)

cv2.imshow('Imaj', image)

cv2.waitKey(0)

cv2.destroyAllWindows()

Eğer faces içinde hiç bilgi yoksa, görüntü üzerinde hiç yüz bulunamadı demektir. Bunu “Yüz bulunamadı” mesajıyla raporluyoruz.
Eğer faces içinde yüz koordinatları mevcutsa, -bilgi için- bulunan koordinatlar ile eleman boyutunu ve bu bilgiyi kullanarak ek filtre uygulanmamış yüz sayısını konsol ekranına bastırıyoruz.
Bulunan dikdörtgenlere it_contains_eyes() fonksiyonu ile ek denetimleri uyguluyoruz. Denetim atlanıyorsa veya aranan ek bilgiler bulunduysa o dikdörtgenin kenarlarını görüntünün üzerine çiziyor ve bulunan yüz sayısını tutan count değişkeninin değerini bir arttırıyoruz.
Tüm yüzler tarandıktan sonra “Belirlenen yüz sayısı: ” mesajımızın kolay görünebilir olması için altına beyaz bir zemin bastırıyoruz. (satır 88)
90-92 satırlarında bulunan yüz sayısını ifade eden mesajımız görüntünün üzerine işleniyor ve 94 numaralı satırda sonucu görüntülüyoruz.
Eğer UTF-8 yerine sadece ASCII fontlar kullanacaksanız 89 nolu satırı aktif hale getirip 90-92 satırlarını devre dışı bırakmanız yeterlidir.
Döngünün devam etmesi için herhangi bir tuşa basmamız gerek.
Tuşa bastığımızda ortalığı temizliyor ve varsa bir sonraki imaja geçiyoruz. Yeni imaj yoksa döngüyü ve betiği sonlandırıyoruz.

Tüm kodlar bir bütün olarak aşağıda:

# original code from: https://techtutorialsx.com/2017/05/02/python-opencv-face-detection-and-counting/
# face_count.py
# faces also checked for the existence of eyes, lips and nose
# Instead of ascii fonts, utf-8 fonts are used

import numpy as np
import cv2
from PIL import Image, ImageDraw, ImageFont

faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')
eyeCascade = cv2.CascadeClassifier('Cascades/haarcascade_eye.xml')
smileCascade = cv2.CascadeClassifier('Cascades/haarcascade_smile.xml')
noseCascade = cv2.CascadeClassifier('Cascades/haarcascade_mcs_nose.xml')

no_check = False

def print_text(image):  # only english characters
    cv2.putText(image, "Belirlenen yüz sayısı: " + str(faces.shape[0]), (0, image.shape[0] - 10),
                cv2.FONT_HERSHEY_TRIPLEX, 0.5, (0, 0, 0), 1)

def print_utf8_text(image, text, color):  # utf-8 characters
    fontName = 'FreeSerif.ttf'  # 'FreeSansBold.ttf' # 'FreeMono.ttf' 'FreeSerifBold.ttf'
    font = ImageFont.truetype(fontName, 18)  # select font
    img_pil = Image.fromarray(image)  # convert image to pillow mode
    draw = ImageDraw.Draw(img_pil)  # prepare image
    draw.text((0, image.shape[0] - 30), text, font=font,
              fill=(color[0], color[1], color[2], 0))  # b,g,r,a
    image = np.array(img_pil)  # convert image to cv2 mode (numpy.array())
    return image

# Check whether face contains any of eyes, lips and nose
def it_contains_eyes(frame, gray, x, y, w, h):
    if no_check: return True
    roi_gray = gray[y:y + h, x:x + w]

    eyes = eyeCascade.detectMultiScale(
        roi_gray,
        scaleFactor=1.05,
        minNeighbors=3,
        minSize=(20, 20)
    )
    count = 0
    for (ex, ey, ew, eh) in eyes:
        count += 1
    if count > 1:
        return True

    smiles = smileCascade.detectMultiScale(
        roi_gray,
        scaleFactor=1.5,
        minNeighbors=5,
        minSize=(3, 3)
    )
    if len(smiles) > 0: return True

    noses = noseCascade.detectMultiScale(
        roi_gray,
        scaleFactor=1.5,
        minNeighbors=5,
        minSize=(3, 3)
    )
    if len(noses) > 0: return True

    return False

imageNames = ['toplu.jpg', 'maviboncuk.jpg', 'mt_aday.jpg']
for imageName in imageNames:
    image = cv2.imread(imageName)

    grayImage = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    faces = faceCascade.detectMultiScale(grayImage)

    print(type(faces))

    if len(faces) == 0:
        print("Yüz bulunamadı")
    else:
        print(faces)
        print(faces.shape)
        print("Belirlenen yüz sayısı: " + str(faces.shape[0]))

        say = 0
        for (x, y, w, h) in faces:
            if it_contains_eyes(image, grayImage, x, y, w, h):
                say += 1
                cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 1)

        cv2.rectangle(image, ((0, image.shape[0] - 25)), (270, image.shape[0]), (255, 255, 255), -1)
        # print_text()
        text = "Belirlenen yüz sayısı: " + str(say)  # , (0, image.shape[0] - 10)
        color = (0, 0, 0)
        image = print_utf8_text(image, text, color)

        cv2.imshow('Imaj', image)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

# original code from: https://techtutorialsx.com/2017/05/02/python-opencv-face-detection-and-counting/

# face_count.py

# faces also checked for the existence of eyes, lips and nose

# Instead of ascii fonts, utf-8 fonts are used

import numpy as np

import cv2

from PIL import Image, ImageDraw, ImageFont

faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')

eyeCascade = cv2.CascadeClassifier('Cascades/haarcascade_eye.xml')

smileCascade = cv2.CascadeClassifier('Cascades/haarcascade_smile.xml')

noseCascade = cv2.CascadeClassifier('Cascades/haarcascade_mcs_nose.xml')

no_check = False

def print_text(image): # only english characters

cv2.putText(image, "Belirlenen yüz sayısı: " + str(faces.shape[0]), (0, image.shape[0] - 10),

cv2.FONT_HERSHEY_TRIPLEX, 0.5, (0, 0, 0), 1)

def print_utf8_text(image, text, color): # utf-8 characters

fontName = 'FreeSerif.ttf' # 'FreeSansBold.ttf' # 'FreeMono.ttf' 'FreeSerifBold.ttf'

font = ImageFont.truetype(fontName, 18) # select font

img_pil = Image.fromarray(image) # convert image to pillow mode

draw = ImageDraw.Draw(img_pil) # prepare image

draw.text((0, image.shape[0] - 30), text, font=font,

fill=(color[0], color[1], color[2], 0)) # b,g,r,a

image = np.array(img_pil) # convert image to cv2 mode (numpy.array())

return image

# Check whether face contains any of eyes, lips and nose

def it_contains_eyes(frame, gray, x, y, w, h):

if no_check: return True

roi_gray = gray[y:y + h, x:x + w]

eyes = eyeCascade.detectMultiScale(

roi_gray,

scaleFactor=1.05,

minNeighbors=3,

minSize=(20, 20)

)

count = 0

for (ex, ey, ew, eh) in eyes:

count += 1

if count > 1:

return True

smiles = smileCascade.detectMultiScale(

roi_gray,

scaleFactor=1.5,

minNeighbors=5,

minSize=(3, 3)

)

if len(smiles) > 0: return True

noses = noseCascade.detectMultiScale(

roi_gray,

scaleFactor=1.5,

minNeighbors=5,

minSize=(3, 3)

)

if len(noses) > 0: return True

return False

imageNames = ['toplu.jpg', 'maviboncuk.jpg', 'mt_aday.jpg']

for imageName in imageNames:

image = cv2.imread(imageName)

grayImage = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

faces = faceCascade.detectMultiScale(grayImage)

print(type(faces))

if len(faces) == 0:

print("Yüz bulunamadı")

else:

print(faces)

print(faces.shape)

print("Belirlenen yüz sayısı: " + str(faces.shape[0]))

say = 0

for (x, y, w, h) in faces:

if it_contains_eyes(image, grayImage, x, y, w, h):

say += 1

cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 1)

cv2.rectangle(image, ((0, image.shape[0] - 25)), (270, image.shape[0]), (255, 255, 255), -1)

# print_text()

text = "Belirlenen yüz sayısı: " + str(say) # , (0, image.shape[0] - 10)

color = (0, 0, 0)

image = print_utf8_text(image, text, color)

cv2.imshow('Imaj', image)

cv2.waitKey(0)

cv2.destroyAllWindows()

Betiğin çalışmasını aşağıdaki videodan izleyebilirsiniz:

Bir sonraki yazımda kişi yüzlerini ismen tanıyan bir sistemi nasıl eğiteceğimizi ele alacağım.

Ahmet Aksoy

https://techtutorialsx.com/2017/05/02/python-opencv-face-detection-and-counting/
https://github.com/voidstellar/haar-cascade-files
https://github.com/opencv/opencv/tree/master/data/haarcascades
http://alereimondo.no-ip.org/OpenCV/34
https://www.instructables.com/id/Create-OpenCV-Image-Classifiers-Using-Python/
https://medium.com/@a5730051/train-dataset-to-xml-file-for-cascade-classifier-opencv-43a692b74bfe

OpenCV ile Portakalın Peşinde

opencv, python 4 Yanıt »

Ara 032018

OpenCV ile Portakalın Peşinde

Bu yazımda bir önceki yazımda ele aldığım kodlardan yararlanacak, sadece bir kaç küçük değişiklik yapacağım.
Bu kez çember içine alarak işaretlediğimiz nesnenin (portakalın) merkez noktasını izlenebilir hale getireceğiz. İzlemeyi, en son ardışık 50 merkez noktasını çizgilerle birbirine birleştirerek yapacağız.

Bu betikte 2 kütüphaneye daha gereksinim var: collections ve numpy.

collections kütüphanesinin deque sınıfı her iki ucundan eleman eklenebilen ve önceden belirtilmişse maksimum eleman saısı sabit kalan nesneler üretir. Numpy kütüphanesini ise izleme çizgilerinin kalınlığını hesaplarken karekök almada kullanacağız. Onun yerine math kütüphanesini de kullanabilirdik ama, bu tür çalışmalarda numpy‘yi el altında tutmamızda büyük yarar var.

Bu kez kaynak kodları bir bütün halinde vereceğim. Sadece önceki örnekle karşılaştırdığımızda değişen satırları açıklamam yeterli olacak.

Kodlar aşağıda. Açıklamaları da onun altına ekledim.

import cv2
import imutils
from collections import deque
import numpy as np

video_file = ''  # ''ab03.mp4'  # if given frames are read from file
WIDTH = 800  # width of the windows
NO_OF_POINTS=50
# ONLY_MAX = False  # if True only the max circle is drawn
GREEN_RANGE = ((29, 86, 6), (64, 255, 255))
RED_RANGE = ((139, 0, 0), (255, 160, 122))
BLUE_RANGE = ((110, 50, 50), (130, 255, 255))
ORANGE_RANGE = ((160, 100, 47), (179, 255, 255))
YELLOW_RANGE = ((10, 100, 100), (40, 255, 255))

colorLower, colorUpper = YELLOW_RANGE  # select color range

if len(video_file) == 0:
    kamera = cv2.VideoCapture(0)  # default web camera=0
else:
    kamera = cv2.VideoCapture(video_file)  # read from file

pts= deque(maxlen=NO_OF_POINTS)
cv2.namedWindow('frame')
cv2.moveWindow('frame', 10, 10)  # 'frame' window position
# cv2.namedWindow('mask')
# cv2.moveWindow('mask', WIDTH + 50, 10)  # 'mask' window position
while True:
    (ok, frame) = kamera.read()

    # if filename is given but frames cannot be read then exit
    if len(video_file) > 0 and not ok:
        break

    frame = imutils.resize(frame, WIDTH)
    hsv = cv2.GaussianBlur(frame, (25,25), 0)
    hsv = cv2.cvtColor(hsv, cv2.COLOR_BGR2HSV)

    mask = cv2.inRange(hsv, colorLower, colorUpper)
    mask = cv2.erode(mask, None, iterations=3)
    mask = cv2.dilate(mask, None, iterations=3)
    mask_copy = mask.copy()

    contours = cv2.findContours(mask_copy, cv2.RETR_EXTERNAL,
                                cv2.CHAIN_APPROX_SIMPLE)[-2]
    center = None

    if len(contours) > 0:
        cmax = max(contours, key=cv2.contourArea)
        for ctr in contours:
            (x, y), radius = cv2.minEnclosingCircle(cmax)
            mts = cv2.moments(cmax)
            center = int(mts['m10']/mts['m00']),int(mts['m01']/mts['m00'])
            if radius >= 40:  # draw circle if radius>40 px
                cv2.circle(frame, (int(x), int(y)),
                           int(radius), (255, 255, 0), 4)
            pts.appendleft(center)
            # draw tracked points in deque
            for i in range(1,len(pts)):
                if pts[i] and pts[i-1]:
                    # thickness=3
                    thickness = int(np.sqrt(NO_OF_POINTS / float(i + 1)) * 1.1)
                    cv2.line(frame,pts[i-1],pts[i],(0,255,255),thickness)


    cv2.imshow("frame", frame)
    # cv2.imshow("mask", mask)

    key = cv2.waitKey(1) & 0xFF
    if key == ord('q') or key == 27:
        break

# release all objects and free memory
kamera.release()
cv2.destroyAllWindows()

import cv2

import imutils

from collections import deque

import numpy as np

video_file = '' # ''ab03.mp4' # if given frames are read from file

WIDTH = 800 # width of the windows

NO_OF_POINTS=50

# ONLY_MAX = False # if True only the max circle is drawn

GREEN_RANGE = ((29, 86, 6), (64, 255, 255))

RED_RANGE = ((139, 0, 0), (255, 160, 122))

BLUE_RANGE = ((110, 50, 50), (130, 255, 255))

ORANGE_RANGE = ((160, 100, 47), (179, 255, 255))

YELLOW_RANGE = ((10, 100, 100), (40, 255, 255))

colorLower, colorUpper = YELLOW_RANGE # select color range

if len(video_file) == 0:

kamera = cv2.VideoCapture(0) # default web camera=0

else:

kamera = cv2.VideoCapture(video_file) # read from file

pts= deque(maxlen=NO_OF_POINTS)

cv2.namedWindow('frame')

cv2.moveWindow('frame', 10, 10) # 'frame' window position

# cv2.namedWindow('mask')

# cv2.moveWindow('mask', WIDTH + 50, 10) # 'mask' window position

while True:

(ok, frame) = kamera.read()

# if filename is given but frames cannot be read then exit

if len(video_file) > 0 and not ok:

break

frame = imutils.resize(frame, WIDTH)

hsv = cv2.GaussianBlur(frame, (25,25), 0)

hsv = cv2.cvtColor(hsv, cv2.COLOR_BGR2HSV)

mask = cv2.inRange(hsv, colorLower, colorUpper)

mask = cv2.erode(mask, None, iterations=3)

mask = cv2.dilate(mask, None, iterations=3)

mask_copy = mask.copy()

contours = cv2.findContours(mask_copy, cv2.RETR_EXTERNAL,

cv2.CHAIN_APPROX_SIMPLE)[-2]

center = None

if len(contours) > 0:

cmax = max(contours, key=cv2.contourArea)

for ctr in contours:

(x, y), radius = cv2.minEnclosingCircle(cmax)

mts = cv2.moments(cmax)

center = int(mts['m10']/mts['m00']),int(mts['m01']/mts['m00'])

if radius >= 40: # draw circle if radius>40 px

cv2.circle(frame, (int(x), int(y)),

int(radius), (255, 255, 0), 4)

pts.appendleft(center)

# draw tracked points in deque

for i in range(1,len(pts)):

if pts[i] and pts[i-1]:

# thickness=3

thickness = int(np.sqrt(NO_OF_POINTS / float(i + 1)) * 1.1)

cv2.line(frame,pts[i-1],pts[i],(0,255,255),thickness)

cv2.imshow("frame", frame)

# cv2.imshow("mask", mask)

key = cv2.waitKey(1) & 0xFF

if key == ord('q') or key == 27:

break

# release all objects and free memory

kamera.release()

cv2.destroyAllWindows()

3 ve 4 numaralı satırlarımızda yeni kütüphaneleri içe aktarıyoruz.

7. satırdaki WIDTH değerini 800 yaptım. Çünkü bu kez sadece bir pencereyi görselleştireceğiz.

8. satırda NO_OF_POINTS = 50 satırını ekledim. Bu sabit, merkez noktalarından kaç tanesini izleyeceğimizi belirliyor. Sayıyı azaltırsak izleme çizgilerimiz daha kısa, çoğaltırsak daha uzun olacaktır.

9. satırdaki ONLY_MAX artık kullanılmayacak. Çünkü sadece tek bir nesneyi (en büyük olanı) izleyeceğiz.

36. satıra kadar bir değişiklik yok. Burada frame isimli çerçevenin görüntüsünü cv2.GaussianBlur() metoduyla yumuşatıyoruz. Bu sayede görüntülerdeki renk dağılımları çok keskin hatlar oluşturmuyor. Aslında bizim örneğimizde bu metodu kullanmasak da olur.

46. satırda center değişkenini tanımlıyoruz. Bu değişken her görüntü karesinde yakalanan en büyük çemberin merkez noktasını tutacak.

49. satırdaki cmax değişeni en büyük alana sahip kontur değerlerini tutuyor.

51. satırda cmax’ı içine alan en küçük çembere ait merkez ve yarıçap bilgilerini buluyoruz.

52 ve 53. satırlarda şeklimizin ağırlık merkezini hesaplatıyoruz. Aslında bunun yerine center = (int(x),int(y)) kullansak da pek bir şey değişmeyecektir. Deneyebilirsiniz.

57-63 arası satırlarda yeni merkez noktamızı pts’ye ilk eleman olarak ekliyoruz. Böylece tüm elemanlar birer sıra sağ kayıyor ve en sondaki eleman siliniyor.

62. satırdaki thickness hesabı, çizgi kalınlığının, konumuna bağlı olarak değişmesini sağlıyor. Olayı basitleştirmek istersek onun yerine thickness=3 gibi bir satır kullanabiliriz. Elbette bu durumda çizgilerimizin kalınlığı sabit olur.

Son değişikliğimiz, 67.satırı devre dışı bırakmak. Böylece mask çerçevesini görünmez yapıyoruz.

Videoda kodların çalışır halini görebilirsiniz.

Bu yazıyı daha fazla uzatmayacağım. Çünkü ana fikirde bir önceki örneğimize göre önemli bir değişiklik yok. Ama istersek eğlenmek için bazı değişklikler yapabiliriz.

Örneğin ben cizgi kalınlıklarını biraz abartıp, rengini de kırmızı yaptım. Aşağıdaki videoda bu değişikliği görebilirsiniz. Siz de pts (deque) eleman sayısını azaltabilir veya çoğaltabilir, çizgi renkleriyle oynayabilirsiniz. Ya da renk aralıklarını değiştirerek farklı nesneleri izleyebilir veya web kamera yerine bir video dosyası kullanabilirsiniz (elinizde uygun bir video varsa).

Bir sonraki yazımda yüz tanıma konusunu yeniden ele alacağım.

Beni izlemeye devam edin.

Ahmet Aksoy

OpenCV ile Portakallar ve Elmalar

opencv, python Yanıt yok »

Ara 022018

OpenCV ile Portakallar ve Elmalar

Bu yazıda işleyeceğim kodların orijinal halini yine PyImageSearch sitesinde bulabilirsiniz. “ball tracking pyimagesearch” sözcüklerini Google’da aratırsanız, konuyla ilgili sayfalara kolayca ulaşırsınız.

Orijinal kodlarda izlediğimiz yuvarlağın (renkli topun) merkez noktasına ait koordinatlardaki değişimler görsel olarak izlenebiliyor. Benim aşağıda vereceğim kodlarda ise merkez noktası yerine, belirlediğimiz renk aralığının grileştirilerek maskelenmiş izdüşümünü ikinci çerçeveden izleyeceğiz.

(Not: Bir sonraki yazımda merkez noktalarının izlenmesi konusunu da ele alacağım. Ama dilerseniz bu kodları geliştirmeyi şimdiden bir ödev olarak üstlenebilirsiniz.)

OpenCV ile nesneleri izlemede kullanılan en basit yöntem, HSV renk sistemine uygun bir renk aralığını kullanmaktır. Çünkü HSV renk sistemi bu tür bir çalışmaya RGB veya BGR renk sistemlerine kıyasla çok daha yatkındır. Eğer renk sistemleriyle ilgili daha çok ayrıntıya ulaşmak isterseniz, internetteki pek çok kaynak size yardımcı olacaktır.

HSV terimi (Hue Saturation Value) sözcüklerinin ilk harflerini birleştirerek oluşturulmuştur. Hue renk tonlarını, saturation doygunluk oranını ve value parlaklık düzeyini ifade eder. OpenCV kütüphanesinde hue değerleri 0-179, diğerleri 0-255 arası değerler alır.

Şimdi kodlarımızı incelemeye başlayalım:

import cv2
import imutils

1 2	import cv2 import imutils

Örnek kodumuz için sadece cv2 ve imutils kütüphanelerini kullanacağız.

video_file = '' # ''ab03.mp4'  # if given frames are read from file
WIDTH = 600  # width of the windows
ONLY_MAX=False  # if True only the max circle is drawn
GREEN_RANGE = ((29,86,6),(64,255,255))
RED_RANGE = ((139,0,0),(255,160,122))
BLUE_RANGE = ((110,50,50),(130,255,255))
ORANGE_RANGE = ((160,100,47),(179,255,255))
YELLOW_RANGE = ((10,100,100),(40,255,255))

colorLower,colorUpper = YELLOW_RANGE  # select color range

video_file = '' # ''ab03.mp4' # if given frames are read from file

WIDTH = 600 # width of the windows

ONLY_MAX=False # if True only the max circle is drawn

GREEN_RANGE = ((29,86,6),(64,255,255))

RED_RANGE = ((139,0,0),(255,160,122))

BLUE_RANGE = ((110,50,50),(130,255,255))

ORANGE_RANGE = ((160,100,47),(179,255,255))

YELLOW_RANGE = ((10,100,100),(40,255,255))

colorLower,colorUpper = YELLOW_RANGE # select color range

Web kamera görüntülerini kullanmak istiyorsak video_file string değeri boş olmalıdır. Eğer buraya bir video dosyasının erişim adresini yazarsak, web kamera yerine o videonun görüntüleri kullanılır.

WIDTH sabiti, pencerelerimizin genişliğini belirler. İstediğimiz gibi değiştirebiliriz.

ONLY_MAX sabiti False olarak tanımlanırsa, bulunan tüm sınır çizgileri (kontur) dikkate alınır. Bu değer True olarak verilirse, sadece alanı en büyük olan nesnenin çevre çizgisi çizilir.

Renk aralıkları için farklı opsiyonlar tanımladım. Kodu çalıştırmadan önce istediğiniz aralığı seçebilirsiniz. Örneğin YELLOW_RANGE aralığını kullanırsanız alt HSV değerler (10,100,100), üst değerler ise (40,255,255) olur.

if len(video_file) == 0:
    kamera = cv2.VideoCapture(0)  # default web camera=0
else:
    kamera = cv2.VideoCapture(video_file) # read from file

cv2.namedWindow('frame')
cv2.moveWindow('frame',10,10)  # 'frame' window position
cv2.namedWindow('mask')
cv2.moveWindow('mask',WIDTH+50,10)  # 'mask' window position

if len(video_file) == 0:

kamera = cv2.VideoCapture(0) # default web camera=0

else:

kamera = cv2.VideoCapture(video_file) # read from file

cv2.namedWindow('frame')

cv2.moveWindow('frame',10,10) # 'frame' window position

cv2.namedWindow('mask')

cv2.moveWindow('mask',WIDTH+50,10) # 'mask' window position

video_file değişkenimizin uzunluğu sıfıra eşitse, içinde bir dosya adı yok demektir. Bu durumda web kamerayı etkinleştiriyoruz. İlk web kameranın karşılığı “0”dır. İkinci bir kamera tanımlarsanız, değeri “1” olur.

Örneğimizde yanyana 2 farklı pencere açacağız: frame ve mask. “mask” penceresi, “frame” penceresinin tam sağında yer alacak. Eğer bu yerleştirmeyi yapmazsak, pencereler üst üste açılacak; ikisini birden izleyebilmek için fare ile yerleşimi düzenlemek zorunda kalacaktık. (Not: cv2.moveWindow() parametreleri için kendi bilgisayarınızda biraz farklı değerler vermeniz gerekebilir.)

while True:
    (ok, frame) = kamera.read()

    # if filename is given but frames cannot be read then exit
    if len(video_file)>0 and not ok:
        break

    frame = imutils.resize(frame,WIDTH)
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    
    mask = cv2.inRange(hsv, colorLower, colorUpper)
    mask = cv2.erode(mask, None, iterations=3)
    mask = cv2.dilate(mask, None, iterations=3)
    mask_copy = mask.copy()

while True:

(ok, frame) = kamera.read()

# if filename is given but frames cannot be read then exit

if len(video_file)>0 and not ok:

break

frame = imutils.resize(frame,WIDTH)

hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

mask = cv2.inRange(hsv, colorLower, colorUpper)

mask = cv2.erode(mask, None, iterations=3)

mask = cv2.dilate(mask, None, iterations=3)

mask_copy = mask.copy()

Ön tanımlarımızı yaptıktan ve pencere yerleşimlerini belirledikten sonra asıl işlemlerin içinde yer aldığı sonsuz döngüyü başlatıyoruz.

kamera.read() komutu, web kamera veya video dosyasından hangisini belirlediysek oradan bir çerçeveyi okuyor. Eğer ok değeri False ise ve dosya adı tanımlanmış ise okunacak çerçeve kalmadı demektir. Bu yüzden break komutuyla döngüyü sonlandırırız. Aksi halde işlenmesi gereken bir çerçeve okundu demektir.

Çerçeve boyutlarımızı WIDTH sabitine göre yeniden düzenledikten sonra frame isimli çerçevemizi HSV renk sistemine göre dönüştürüp, hsv isimli değişkene atarız. “frame” isimli çerçevemizin renk sistemi BGR’dir.

hsv isimli çerçeveden colorLower ve colorUpper renk değerlerine göre filtrelenen yeni çerçeveyi bu kez mask değişkenine atarız. Bu çerçeveye önce erode(), sonra da dilate() metodlarını uyguladıktan sonra bir de kopyasını alıp, çerçeve içinde yer alan nesne kenar çizgilerini (konturları) belirlemede kullanmak üzere mask_copy değişkenine atarız. (Not: erode() ve dilate() metodlarını kullanmadan önce mask çerçevemize GaussianBlur() metodu uygulayarak görüntüyü yumuşatmak daha güzel bir görsel etki yaratabilir. Bir sonraki yazımda bu metodu da örnekleyeceğim.)

    contours = cv2.findContours(mask_copy, cv2.RETR_EXTERNAL,
                                cv2.CHAIN_APPROX_SIMPLE)[-2]
    
    if len(contours)>0:
        for ctr in contours:
            if ONLY_MAX:
                cmax = max(contours, key=cv2.contourArea)
                (x,y), radius = cv2.minEnclosingCircle(cmax)
            else:
                (x, y), radius = cv2.minEnclosingCircle(ctr)

            if radius >= 40: # draw circle if radius>40 px
                cv2.circle(frame, (int(x), int(y)),
                           int(radius), (0, 255, 255), 4)

    cv2.imshow("frame", frame)
    cv2.imshow("mask", mask)
    
    key = cv2.waitKey(4) & 0xFF
    if key==ord('q') or key==27:
        break

contours = cv2.findContours(mask_copy, cv2.RETR_EXTERNAL,

cv2.CHAIN_APPROX_SIMPLE)[-2]

if len(contours)>0:

for ctr in contours:

if ONLY_MAX:

cmax = max(contours, key=cv2.contourArea)

(x,y), radius = cv2.minEnclosingCircle(cmax)

else:

(x, y), radius = cv2.minEnclosingCircle(ctr)

if radius >= 40: # draw circle if radius>40 px

cv2.circle(frame, (int(x), int(y)),

int(radius), (0, 255, 255), 4)

cv2.imshow("frame", frame)

cv2.imshow("mask", mask)

key = cv2.waitKey(4) & 0xFF

if key==ord('q') or key==27:

break

contours listesi çerçevemizde yer alan tüm konturları içerir.

Eğer kontur listesi boş değilse, hepsini tek tek işleme sokarız.

ONLY_MAX sabitimiz True olarak tanımlandıysa her çerçevede sadece bir tek (en büyük) kontur belirlenir. Aksi halde yarıçapı 40 pikselden büyük olan tüm çemberleri kullanacağız demektir.

Konturlarımızı circle() metoduyla frame isimli çerçevemize işledikten sonra hem orijinal frame isimli çerçevemizi, hem de mask çerçevemizi görüntüleriz.

waitKey() metodumuz 4 milisaniyelik bir süre içinde basılacak tuşları dinler. Eğer ‘q’ veya ‘Esc’ tuşlarından birine basılmışsa, döngünün kırılmasını sağlar.

# release all objects and free memory
kamera.release()
cv2.destroyAllWindows()

# release all objects and free memory

kamera.release()

cv2.destroyAllWindows()

Döngü kırıldığında kamera nesnesini serbest bırakır ve açılmış tüm pencereleri kapatarak belleği temizleriz.

Örnek kodumuzun tamamı aşağıda:

import cv2
import imutils

video_file = '' # ''ab03.mp4'  # if given frames are read from file
WIDTH = 600  # width of the windows
ONLY_MAX=False  # if True only the max circle is drawn
GREEN_RANGE = ((29,86,6),(64,255,255))
RED_RANGE = ((139,0,0),(255,160,122))
BLUE_RANGE = ((110,50,50),(130,255,255))
ORANGE_RANGE = ((160,100,47),(179,255,255))
YELLOW_RANGE = ((10,100,100),(40,255,255))

colorLower,colorUpper = YELLOW_RANGE  # select color range

if len(video_file) == 0:
    kamera = cv2.VideoCapture(0)  # default web camera=0
else:
    kamera = cv2.VideoCapture(video_file) # read from file

cv2.namedWindow('frame')
cv2.moveWindow('frame',10,10)  # 'frame' window position
cv2.namedWindow('mask')
cv2.moveWindow('mask',WIDTH+50,10)  # 'mask' window position
while True:
    (ok, frame) = kamera.read()

    # if filename is given but frames cannot be read then exit
    if len(video_file)>0 and not ok:
        break

    frame = imutils.resize(frame,WIDTH)
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    
    mask = cv2.inRange(hsv, colorLower, colorUpper)
    mask = cv2.erode(mask, None, iterations=3)
    mask = cv2.dilate(mask, None, iterations=3)
    mask_copy = mask.copy()
    
    contours = cv2.findContours(mask_copy, cv2.RETR_EXTERNAL,
                                cv2.CHAIN_APPROX_SIMPLE)[-2]
    
    if len(contours)>0:
        for ctr in contours:
            if ONLY_MAX:
                cmax = max(contours, key=cv2.contourArea)
                (x,y), radius = cv2.minEnclosingCircle(cmax)
            else:
                (x, y), radius = cv2.minEnclosingCircle(ctr)

            if radius >= 40: # draw circle if radius>40 px
                cv2.circle(frame, (int(x), int(y)),
                           int(radius), (0, 255, 255), 4)

    cv2.imshow("frame", frame)
    cv2.imshow("mask", mask)
    
    key = cv2.waitKey(4) & 0xFF
    if key==ord('q') or key==27:
        break

# release all objects and free memory
kamera.release()
cv2.destroyAllWindows()

import cv2

import imutils

video_file = '' # ''ab03.mp4' # if given frames are read from file

WIDTH = 600 # width of the windows

ONLY_MAX=False # if True only the max circle is drawn

GREEN_RANGE = ((29,86,6),(64,255,255))

RED_RANGE = ((139,0,0),(255,160,122))

BLUE_RANGE = ((110,50,50),(130,255,255))

ORANGE_RANGE = ((160,100,47),(179,255,255))

YELLOW_RANGE = ((10,100,100),(40,255,255))

colorLower,colorUpper = YELLOW_RANGE # select color range

if len(video_file) == 0:

kamera = cv2.VideoCapture(0) # default web camera=0

else:

kamera = cv2.VideoCapture(video_file) # read from file

cv2.namedWindow('frame')

cv2.moveWindow('frame',10,10) # 'frame' window position

cv2.namedWindow('mask')

cv2.moveWindow('mask',WIDTH+50,10) # 'mask' window position

while True:

(ok, frame) = kamera.read()

# if filename is given but frames cannot be read then exit

if len(video_file)>0 and not ok:

break

frame = imutils.resize(frame,WIDTH)

hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

mask = cv2.inRange(hsv, colorLower, colorUpper)

mask = cv2.erode(mask, None, iterations=3)

mask = cv2.dilate(mask, None, iterations=3)

mask_copy = mask.copy()

contours = cv2.findContours(mask_copy, cv2.RETR_EXTERNAL,

cv2.CHAIN_APPROX_SIMPLE)[-2]

if len(contours)>0:

for ctr in contours:

if ONLY_MAX:

cmax = max(contours, key=cv2.contourArea)

(x,y), radius = cv2.minEnclosingCircle(cmax)

else:

(x, y), radius = cv2.minEnclosingCircle(ctr)

if radius >= 40: # draw circle if radius>40 px

cv2.circle(frame, (int(x), int(y)),

int(radius), (0, 255, 255), 4)

cv2.imshow("frame", frame)

cv2.imshow("mask", mask)

key = cv2.waitKey(4) & 0xFF

if key==ord('q') or key==27:

break

# release all objects and free memory

kamera.release()

cv2.destroyAllWindows()

Videoda kodların nasıl çalıştığı örnekleniyor. Tenis topu yerine elma ve portakal kullandım. Siz de isterseniz sarı renkler içeren başka nesneler kullanabilirsiniz.

mask çerçevesini görselleştirmek yerine sadece asıl çerçevedeki alanın veya alanların çember ile işaretlenmesini kullanabilir; ya da yakaladığımız nesnenin merkez koordinatlarındaki değişimi izlenebilir hale getirebiliriz.

Bu işlem için kendiniz doğrudan uğraşabilir ya da PyImageSearch sitesindeki örnekten veya benzer başka örneklerden yararlanabilirsiniz. (Bir sonraki yazımda bu konuyu ele alacağım.)

Yeni yazılarımdan anında haberdar olmak isterseniz sitemize abone olun.

Ahmet Aksoy

OpenCV Kurulumu

opencv, python Yanıt yok »

Kas 282018

OpenCV Kurulumu

Bu yazımda Ubuntu 18.04 üzerinde OpenCV kurulumunu ele alacağım. Kurulum bir sanal ortam üzerinde gerçekleşecek. Böylelikle farklı paketler arasında uyumsuzluk yaşama olasılığını en aza indirgeyeceğiz.

İşe, sistemimize virtualenv kurmakla başlayalım:

$ sudo apt update
$ sudo apt -y dist-upgrade
$ /usr/bin/python3 -m pip install virtualenv virtualenvwrapper
$ gedit ~/.bashrc

$ sudo apt update

$ sudo apt -y dist-upgrade

$ /usr/bin/python3 -m pip install virtualenv virtualenvwrapper

$ gedit ~/.bashrc

Aşağıdaki satırları ~/.bashrc dosyasına ekle ve dosyayı kaydedip çık.

export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
source /usr/local/bin/virtualenvwrapper.sh

export WORKON_HOME=$HOME/.virtualenvs

export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3

source /usr/local/bin/virtualenvwrapper.sh

Virtualenv paketinin kurulumunu böylece tamamlamış olduk.

Şimdi “ocv” isimli sanal sistemimizi tanımlayalım ve onun üzerine OpenCV’yi kuralım:

$ mkvirtualenv ocv -p /usr/bin/python3
$ workon ocv
(ocv) $ pip install opencv-python
(ocv) $ pip install opencv-contrib-python

$ mkvirtualenv ocv -p /usr/bin/python3

$ workon ocv

(ocv) $ pip install opencv-python

(ocv) $ pip install opencv-contrib-python

Yaptığımız kurulum işlemlerini doğrulayalım:

$ cd ~
$ workon ocv
(ocv) $ python
>>> import cv2
>>> cv2.__version__
'3.4.4'
>>> quit()
(ocv) $

$ cd ~

$ workon ocv

(ocv) $ python

>>> import cv2

>>> cv2.__version__

'3.4.4'

>>> quit()

(ocv) $

Sizin yaptığımız kurulumun OpenCV sürüm numarası farklı olabilir. Ama herhangi bir hata mesajı almamış olmalısınız.
Terminalinizdeki görüntü aşağıdakine benzemelidir:

Kurulumu kaynak kodlarını kullanarak yapmak mümkün. Ama bu konuyu uzatmak istemiyorum.

https://linuxize.com/post/how-to-install-opencv-on-ubuntu-18-04/ adresinde gerekli tüm ayrıntıları “Install OpenCV from source” başlığı altında bulabilirsiniz.

Şimdi önceki yazımda verdiğim küçük örneği biraz daha basitleştirerek denetleyelim.

Ben metin editörü olarak gedit kullanmayı tercih ediyorum. Siz de kendi tercihinizi kullanarak kodlayabilirsiniz. Dosyamızın adını “kamerakontrol.py” koyalım.

İlk komutlarımızı vermek için yeni bir komut penceresi açalım:

$ cd ~
$ workon ocv
(ocv) $ gedit kamerakontrol.py

$ cd ~

$ workon ocv

(ocv) $ gedit kamerakontrol.py

Aşağıdaki satırları “kamerakontrol.py” dosyasına yazıp kaydedelim.

import cv2
cap = cv2.VideoCapture(0)
cap.set(3 ,640) # set Width
cap.set(4 ,480) # set Height
while(True):
    ret, frame = cap.read()
    cv2.imshow('frame', frame)
 
    k = cv2.waitKey(30) & 0xff
    if k == 27 or k==ord('q'): # press 'ESC' or 'q' to quit
        break
cap.release()
cv2.destroyAllWindows()

import cv2

cap = cv2.VideoCapture(0)

cap.set(3 ,640) # set Width

cap.set(4 ,480) # set Height

while(True):

ret, frame = cap.read()

cv2.imshow('frame', frame)

k = cv2.waitKey(30) & 0xff

if k == 27 or k==ord('q'): # press 'ESC' or 'q' to quit

break

cap.release()

cv2.destroyAllWindows()

Şimdi betiğimizi çalıştıralım:

(ocv) $ python kamerakontrol.py

1	(ocv) $ python kamerakontrol.py

Eğer web kameranız açıksa, şimdi ekrandan kendinize bakıyor olmalısınız.

“q” veya “Esc” tuşlarına basarak betiği durdurun.

Herhangi bir hata mesajı almadıysanız, komut pencereniz aşağıdaki gibi görünecektir:

Artık “ocv” sanal ortamını etkinleştirdiğinizde, OpenCV betiklerinizi istediğiniz gibi çalıştırabilirsiniz. Sanal ortamdan çıkmak istediğiniz zaman deactivate komutu vermeniz yeterlidir.

Gördüğünüz gibi, OpenCV Kurulumu oldukça kolay bir işlemdir.

Soru veya yorumlarınız için aşağıdaki yorum alanını kullanabilirsiniz.

Beni izlemeye devam edin.

Ahmet Aksoy

OpenCV ile Yüz Saptama

opencv, python Yanıt yok »

Kas 272018

OpenCV ile Yüz Saptama

Bir önceki -ilk- yazımı tasarlarken bir “yüz saptama” (face detection) örneği vermeyi planlamıştım. Ama sonra fikrimi değiştirip, daha basit bir örnekle yetindim.

Oysa şimdi görüyorum ki, bu yazıları okuyan/okuyacak bir çok arkadaş için o yazı biraz basit kalmış olabilir.

O yüzden “yüz saptama” kodlarını da hemen paylaşayım istedim.

Bu amaçla cv2.CascadeClassifier() metodunun kullanacağı haarcascade_frontalface_default.xml dosyasına ihtiyacımız olacak. Bu dosyayı https://github.com/opencv/opencv/tree/master/data/haarcascades adresinden indirebilirsiniz. Aynı adreste sadece “yüz saptama” değil, pek çok beden parçasını tanımaya yönelik dosya mevcut. Gerek duyduğunuzda onları da bu adresten indirebilirsiniz.

Şimdilik sadece haarcascade_frontalface_default.xml dosyasını indirip, çalışma klasörümüzün içinde oluşturacağımız Cascades isimli klasöre kopyalayalım.

Yeni kodlarımız aşağıda. (Orijinal kodları https://www.hackster.io/mjrobot/real-time-face-recognition-an-end-to-end-project-a10826 adresinde bulabilirsiniz.)

import cv2
faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')
cap = cv2.VideoCapture(0)
cap.set(3,640) # set Width
cap.set(4,480) # set Height
while True:
    ret, img = cap.read()
    # img = cv2.flip(img, -1)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    faces = faceCascade.detectMultiScale(
        gray,
        scaleFactor=1.2,
        minNeighbors=5,
        minSize=(20, 20)
    )
    for (x,y,w,h) in faces:
        cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
        roi_gray = gray[y:y+h, x:x+w]
        roi_color = img[y:y+h, x:x+w]
    cv2.imshow('frame',img)

    #for (x,y,w,h) in faces:
    #    cv2.rectangle(gray,(x,y),(x+w,y+h),(255,0,0),2)
    #    roi_gray = gray[y:y+h, x:x+w]
    #    roi_color = img[y:y+h, x:x+w]
    #cv2.imshow('gray',gray)
    k = cv2.waitKey(1) & 0xff
    if k == 27 or k==ord('q'): # press 'ESC' or 'q' to quit
        break
cap.release()
cv2.destroyAllWindows()

import cv2

faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')

cap = cv2.VideoCapture(0)

cap.set(3,640) # set Width

cap.set(4,480) # set Height

while True:

ret, img = cap.read()

# img = cv2.flip(img, -1)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

faces = faceCascade.detectMultiScale(

gray,

scaleFactor=1.2,

minNeighbors=5,

minSize=(20, 20)

)

for (x,y,w,h) in faces:

cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)

roi_gray = gray[y:y+h, x:x+w]

roi_color = img[y:y+h, x:x+w]

cv2.imshow('frame',img)

#for (x,y,w,h) in faces:

# cv2.rectangle(gray,(x,y),(x+w,y+h),(255,0,0),2)

# roi_gray = gray[y:y+h, x:x+w]

# roi_color = img[y:y+h, x:x+w]

#cv2.imshow('gray',gray)

k = cv2.waitKey(1) & 0xff

if k == 27 or k==ord('q'): # press 'ESC' or 'q' to quit

break

cap.release()

cv2.destroyAllWindows()

Kodlarımızın büyük bölümünü bir önceki yazımda paylaşmıştım.

Öncelikle yeni indirdiğimiz dosyayı kullanıyor ve oluşan nesneyi faceCascade değişkenine atıyoruz.

Görüntümüz yine öntanımlı webcam üzerinden geliyor ve bu görüntüyü 640×480 olarak yeniden boyutlandırıyoruz.

Sonsuz döngümüzün içinde her görüntü karesini img değişkenine aktarıyor, sonra bu görüntünün gri bir kopyasını oluşturarak gray değişkeninde saklıyoruz.

Grileştirme, “kenar saptama” (edge detection) gibi işlemleri kolaylaştıran bir yaklaşımdır. İşlenecek veri miktarını azaltarak değişim hızının artmasını sağlar.

Görüntümüzün içinde birden fazla “yüz” olabilir. faceCascade.detectMultiScale() metoduyla yakaladığımız tüm yüzleri faces değişkeninde saklıyor ve bu yüzlere ait kareleri bir döngü içinde görüntümüzün üzerine işliyoruz.

Dikkat ederseniz, yüz bilgileri (x,y,w,h) şeklinde dönüyor. Yani sol üst köşenin koordinatları (x,y), genişlik w ve yükseklik h.

İstersek aynı işlemleri gray görüntümüze de uygulayabiliriz. (İlgili satırlardaki # işaretlerini kaldırmanız yeterlidir. Böylece hem renkli, hem de gri görüntülerimiz olur.)

Sonsuz döngümüz yine ‘Esc’ veya ‘q’ butonlarına basıldığında kırılıyor.

Döngü kırıldığında “cap” nesnesini serbest bırakıyor ve belleği temizliyoruz.

Peki sadece webcam ile çalışmamız zorunlu mu?

Elbette hayır!

Görüntüleri bir video dosyasından da alabiliriz. Sadece aşağıdaki gibi bir değişiklik yapmak yeterlidir:

# cap = cv2.VideoCapture(0)
cap = cv2.VideoCapture('video_dosyasi.mp4')

1 2	# cap = cv2.VideoCapture(0) cap = cv2.VideoCapture('video_dosyasi.mp4')

Kullanacağınız video dosyasını ya çalışma klasörüne koyun, ya da tam adresini vermeyi unutmayın.

Bu yazıyı araya sıkıştırdım. O yüzden de “kurulum” bilgilerini bir sonraki yazıya ötelemiş oldum.

Beni izlemeye devam edin.

Ahmet Aksoy

OpenCV ile Dünyayı Yeniden Keşfetmek

makine öğrenmesi, opencv, python, raspberry pi, tensorflow Yanıt yok »

Kas 272018

OpenCV ile Dünyayı Yeniden Keşfetmek

OpenCV kütüphanesi’ni 1999 yılında Intel’den Gary Bradsky başlattı ve ilk sürümü 2000 yılında yayınlandı. Daha sonra bu çalışmalara Vadim Pisarevsky de katıldı. Halen OpenCV’nin Bilgisayar Görmesi ve Makina Öğrenmesi çalışmalarına yönelik desteği artarak devam etmektedir. (1)

OpenCV kütüphanesi hem C++, Python ve Java gibi dilleri; hem de Linux, Windows, OS X, Android ve iOS gibi platformları desteklemektedir. Kütüphane çalışmaları açık kaynaklıdır ve https://www.opencv.org/ sitesi üzerinden paylaşılmaktadır. Son sürüm OpenCV 4.0, 20 Kasım 2018 tarihinde duyurulmuştur.

Kütüphane ile ilgili daha ayrıntılı bilgilere ulaşmak isterseniz, kendi sitesine bir göz atmanızda yarar görüyorum.

Söz konusu kütüphanenin pratik kullanımına yönelik güzel örnekler paylaşan bir site daha var: https://www.pyimagesearch.com/ Her ne kadar arka planda kitap ve kurs pazarlaması bulunsa da, açık şekilde paylaşılan kod ve açıklamaları mutlaka izlemenizi öneririm. Olanaklarınız elveriyorsa Adrian Rosebrock’un kitaplarını almayı, ya da online kurslarına katılmayı düşünebilirsiniz. Elbette bunun için yeterli düzeyde İngilizce bilgisine ihtiyacınız olacak.

Bu ve izleyen bazı yazılarımda PyImageSearch veya benzer siteler tarafından paylaşılan kimi kodları temel alan bazı çalışmalar yayınlamayı düşünüyorum. Bu çalışmaları test ettiğim bilgisayarımda Ubuntu 18.04 işletim sistemi yüklü. Python sürümü 3.6. GPU destekli Tensorflow kurulumundaki sorunları aşmak için gerektiğinde Anaconda da kullanıyorum. IDE sistemim: güncel Pycharm Community sürümü. Örneklerde kullandığım OpenCV sürümü 3.4.3.

Adrian Rosebrock, betiklerinde komut modunu kullanmayı seviyor. Bense parametreleri dışarıdan vermek yerine betiğin içine gömmeyi daha fazla tercih ediyorum. Ayrıca, çok mecbur kalmadıkça ekrana print ettirdiğim ifadelerde geçen Türkçe karakterlerin “olması gerektiği gibi” görünmesini de önemsiyorum.

Lafı daha fazla uzatmadan ilk örneğimizi kodlayalım. Bu örnek bir başka siteden: https://www.hackster.io/mjrobot/real-time-face-recognition-an-end-to-end-project-a10826

import cv2
cap = cv2.VideoCapture(0)
cap.set(3 ,640) # set Width
cap.set(4 ,480) # set Height
while(True):
    ret, frame = cap.read()
    # frame = cv2.flip(frame, -1) # Flip camera vertically
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    cv2.imshow('frame', frame)
    cv2.imshow('gray', gray)

    k = cv2.waitKey(30) & 0xff
    if k == 27 or k==ord('q'): # press 'ESC' or 'q' to quit
        break
cap.release()
cv2.destroyAllWindows()

import cv2

cap = cv2.VideoCapture(0)

cap.set(3 ,640) # set Width

cap.set(4 ,480) # set Height

while(True):

ret, frame = cap.read()

# frame = cv2.flip(frame, -1) # Flip camera vertically

gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

cv2.imshow('frame', frame)

cv2.imshow('gray', gray)

k = cv2.waitKey(30) & 0xff

if k == 27 or k==ord('q'): # press 'ESC' or 'q' to quit

break

cap.release()

cv2.destroyAllWindows()

Betiğimiz webcam görüntülerini tarayıp ekrana yansıtmaktadır.

cap = cv2.VideoCapture(0) satırı, varsayılan webcam cihazını aktif hale getirerek, görüntüleri yakalamasını sağlamaktadır.

cap.set() metodu ile görüntünün en ve yükseklik değerleri belirleniyor.

Sonsuz while döngümüzün içinde görüntü yakalama işlemi cap.read() metodu tarafından gerçekleştirilmekte ve “frame” değişkenine aktarılmaktadır. “ret” değeri okuma işleminin başarılı olup olmadığını saptamaktadır.

cv2.flip() metodu, webcam görüntünüz tepetaklak ise işe yarayacaktır. Eğer webcam görüntünüz normalse, bu satırı -benim yaptığım gibi- devre dışı bırakmanız gerekir.

gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) satırı ile “frame” görüntüsünü “GRİ” renge çeviriyoruz.

cv2.COLOR_BGRGRAY parametresindeki “BGR” harfleri (B)lue-(G)reen-(R)ed (mavi-yeşil-kırmızı) kelimelerinden türetilmiştir. OpenCV RGB yerine BGR renk sistemini kullanmaktadır.

cv2.imshow() metodu imajları görünür hale getirmek için kullanılır. “frame” ve “gray” imajlarını ayrı ayrı görselleştiriyoruz.

OpenCV sisteminde olay yakalama mekanizması cv2.waitkey() metodu ile başlatılır. Bu metod kullanılmazsa ne görüntüleme, ne de tuş yakalama olayları gerçekleşebilir.

Döngüyü kırmak için ‘Esc’ veya ‘q’ tuşlarını tanımlıyoruz. Bu tuşlardan herhangi biri tıklandığında döngümüz kırılıyor; cap nesnesi sebest bırakılıyor ve oluşturulan tüm pencereler bellekten temizleniyor.

Eğer istersek görüntü karelerini webcam cihazımız yerine herhangi bir video dosyasından da aynı şekilde okuyabiliriz. Sonraki yazılarımda bu tür örnekleri de ele alacağım.

Örnek betiğimizden gördüğümüz gibi, OpenCV işlerimizi olağanüstü derecede kolaylaştırmaktadır.

Bu kütüphaneyi bir PC veya dizüstü üzerinde olduğu gibi, Raspberry Pi gibi mikro bilgisayarlar üzerinde de çalıştırabilmekteyiz. Bu konuyu da daha sonra ele alacağım.

Eğer bilgisayarınızda OpenCV zaten kuruluysa, örneğimizi de kolayca çalıştırmış olmalısınız.

Ama bu kütüphaneyi ilk kez kuracaksanız, işiniz o kadar kolay olmayabilir. Çünkü bu kütüphane çok geniş bir alana el attığı için pek çok başka kütüphanenin varlığına ihtiyaç duyar. Öncelikle bu kütüphanelerin kurulup hazır hale getirilmesi gerekiyor.

Bu yazıyı daha fazla uzatmamak için OpenCV kurulumunu bir sonraki yazımda ele alacağım.

Beni izlemeye devam edin.

Ahmet Aksoy

(1) – https://docs.opencv.org/3.4/d0/de3/tutorial_py_intro.html