OpenCV küszöbérték Pythonban a cv2.threshold() segítségével

Bevezetés

A küszöbérték egy egyszerű és hatékony technika a kép alapvető szegmentálására és binarizálására (bináris képpé alakítására), ahol a pixelek vagy 0 or 1 (Vagy 255 ha egész számokat használ ezek ábrázolására).

Jellemzően a küszöbértéket használhatja egyszerű háttér-előtér szegmentálás végrehajtására egy képen, és ez minden képponthoz egy egyszerű technika változataira csapódik le:

if pixel_value > threshold:
    pixel_value = MAX
else:
    pixel_value = 0

Ezt a lényeges folyamatot ún Bináris küszöbérték. Now – there are various ways you can tweak this general idea, including inverting the operations (switching the > jele a < jel), beállításával a pixel_value hoz threshold a maximális/0 érték helyett (csonkításként ismert), megtartva a pixel_value itself if it’s above the threshold or if it’s below the threshold.

Mindezek kényelmesen implementálva vannak az OpenCV-ben:

• cv2.THRESH_BINARY
• cv2.THRESH_BINARY_INV
• cv2.THRESH_TRUNC
• cv2.THRESH_TOZERO
• cv2.THRESH_TOZERO_INV

… respectively. These are relatively “naive” methods in that hey’re fairly simple, don’t account for context in images, have knowledge of what shapes are common, etc. For these properties – we’d have to employ much more computationally expensive and powerful techniques.

Now, even with the “naive” methods – néhány heurisztikákat lehet bevezetni a jó küszöbök megtalálásához, ezek közé tartozik az Otsu-módszer és a Triangle-módszer:

• cv2.THRESH_OTSU
• cv2.THRESH_TRIANGLE

Az egyetlen küszöbértékkel kapcsolatos alapvető küszöbértékekkel kapcsolatos problémák megoldásának másik módja a adaptív küszöbérték amely a kép minden kis régiójára alkalmaz egy küszöbértéket, nem pedig globálisan.

Egyszerű küszöbölés OpenCV-vel

Thresholding in OpenCV’s Python API is done via the cv2.threshold() method – which accepts an image (NumPy array, represented with integers), the threshold, maximum value and thresholding method (how the threshold és a maximum_value használt):

img = cv2.imread('objects.jpg')

img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)


blurred = cv2.GaussianBlur(img, (7, 7), 0)

ret, img_masked = cv2.threshold(blurred, 220, 255, cv2.THRESH_BINARY)

A visszatérési kód csak az alkalmazott küszöbérték:

print(f"Threshold: {ret}") 

Itt, hiszen a küszöb 220 and we’ve used the THRESH_BINARY method – every pixel value above 220 -re fog növekedni 255, míg minden alatta lévő pixelérték 220 -ra lesz leeresztve 0, creating a black and white image, with a “mask”, covering the foreground objects.

Why 220? Knowing what the image looks like allows you to make some approximate guesses about what threshold you can choose. In practice, you’ll rarely want to set a manual threshold, and we’ll cover automatic threshold selection in a moment.

Let’s plot the result! OpenCV windows can be a bit finicky, so we’ll plot the original image, blurred image and results using Matplotlib:

fig, ax = plt.subplots(1, 3, figsize=(12, 8))
ax[0].imshow(img)
ax[1].imshow(blurred)
ax[2].imshow(img_masked)

Küszöbösítési módszerek

As mentioned earlier, there are various ways you can use the threshold and maximum value in a function. We’ve taken a look at the binary threshold initially. Let’s create a list of methods, and apply them one by one, plotting the results:

methods = [cv2.THRESH_BINARY, cv2.THRESH_BINARY_INV, cv2.THRESH_TRUNC, cv2.THRESH_TOZERO, cv2.THRESH_TOZERO_INV]
names = ['Binary Threshold', 'Inverse Binary Threshold', 'Truncated Threshold', 'To-Zero Threshold', 'Inverse To-Zero Threshold']

def thresh(img_path, method, index):
    img = cv2.imread(img_path)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    blurred = cv2.GaussianBlur(img, (7, 7), 0)
    ret, img_masked = cv2.threshold(blurred, 220, 255, method)

    fig, ax = plt.subplots(1, 3, figsize=(12, 4))
    fig.suptitle(names[index], fontsize=18)
    ax[0].imshow(img)
    ax[1].imshow(blurred)
    ax[2].imshow(img_masked)
    plt.tight_layout()

for index, method in enumerate(methods):
    thresh('coins.jpeg', method, index)

THRESH_BINARY és a THRESH_BINARY_INV egymás inverzei, és binarizálnak egy képet közöttük 0 és a 255, hozzárendelve őket a háttérhez, illetve az előtérhez, és fordítva.

THRESH_TRUNC között binarizálja a képet threshold és a 255.

THRESH_TOZERO és a THRESH_TOZERO_INV között binarizálni 0 és az aktuális pixelérték (src(x, y)). Let’s take a look at the resulting images:

These methods are intuitive enough – but, how can we automate a good threshold value, and what does a “good threshold” value even mean? Most of the results so far had non-ideal masks, with marks and specks in them. This happens because of the difference in the reflective surfaces of the coins – they’re not uniformly colored due to the difference in how ridges reflect light.

Bizonyos mértékig leküzdhetjük ezt, ha jobb globális küszöböt találunk.

Automatikus/Optimalizált Thresholding OpenCV-vel

OpenCV employs two effective global threshold searching methods – Otsu’s method, and the Triangle method.

Otsu’s method assumes that it’s working on bimodális images. Bi-modal images are images whose color histograms only contain two peaks (i.e. has only two distinct pixel values). Considering that the peaks each belong to a class such as a “background” and “foreground” – the ideal threshold is right in the middle of them.

Kép jóváírás: https://scipy-lectures.org/

A Gauss-féle elmosódásokkal bimodálisabbá tehet néhány képet, de nem mindegyiket.

Egy alternatív, sokszor jobban teljesítő algoritmus a háromszög algoritmus, amely kiszámítja a szürkeszintű hisztogram maximuma és minimuma közötti távolságot, és vonalat húz. Azt a pontot választjuk küszöbnek, ahol az a vonal maximálisan távol van a hisztogram többi részétől:

Both of these assume a greyscaled image, so we’ll need to convert the input image to gray via cv2.cvtColor():

img = cv2.imread(img_path)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (7, 7), 0)

ret, mask1 = cv2.threshold(blurred, 0, 255, cv2.THRESH_OTSU)
ret, mask2 = cv2.threshold(blurred, 0, 255, cv2.THRESH_TRIANGLE)

masked = cv2.bitwise_and(img, img, mask=mask1)

Let’s run the image through with both methods and visualize the results:

methods = [cv2.THRESH_OTSU, cv2.THRESH_TRIANGLE]
names = ['Otsu Method', 'Triangle Method']

def thresh(img_path, method, index):
    img = cv2.imread(img_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (7, 7), 0)

    ret, img_masked = cv2.threshold(blurred, 0, 255, method)
    print(f"Threshold: {ret}")

    fig, ax = plt.subplots(1, 3, figsize=(12, 5))
    fig.suptitle(names[index], fontsize=18)
    ax[0].imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    ax[1].imshow(cv2.cvtColor(gray, cv2.COLOR_BGR2RGB))
    ax[2].imshow(cv2.cvtColor(img_masked, cv2.COLOR_BGR2RGB))

for index, method in enumerate(methods):
    thresh('coins.jpeg', method, index)

Here, the triangle method outperforms Otsu’s method, because the image isn’t bi-modal:

import numpy as np

img = cv2.imread('coins.jpeg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (7, 7), 0)

histogram_gray, bin_edges_gray = np.histogram(gray, bins=256, range=(0, 255))
histogram_blurred, bin_edges_blurred = np.histogram(blurred, bins=256, range=(0, 255))

fig, ax = plt.subplots(1, 2, figsize=(12, 4))

ax[0].plot(bin_edges_gray[0:-1], histogram_gray)
ax[1].plot(bin_edges_blurred[0:-1], histogram_blurred)

However, it’s clear how the triangle method was able to work with the image and produce a more satisfying result.

Az OpenCV Thresholding korlátai

Thresholding with OpenCV is simple, easy and efficient. Yet, it’s fairly limited. As soon as you introduce colorful elements, non-uniform backgrounds and changing lighting conditions – global thresholding as a concept becomes too rigid.

A képek általában túl összetettek ahhoz, hogy egyetlen küszöb is elegendő legyen, és ez részben megoldható adaptív küszöbérték, ahol sok helyi küszöbértéket alkalmaznak egyetlen globális helyett. Bár korlátozott, az adaptív küszöbérték sokkal rugalmasabb, mint a globális küszöbérték.

Következtetés

Az elmúlt években a bináris szegmentációt (mint amit itt tettünk) és a többcímkés szegmentációt (ahol tetszőleges számú osztályt kódolhat) sikeresen modellezték mély tanulási hálózatokkal, amelyek sokkal erősebbek és rugalmasabbak. Ezenkívül globális és helyi kontextust is kódolhatnak az általuk szegmentált képekbe. A hátránya az, hogy adatokra van szükség a képzésükhöz, valamint időre és szakértelemre.

For on-the-fly, simple thresholding, you can use OpenCV. For accurate, production-level segmentation, you’ll want to use neural networks.

Továbblépve – Gyakorlati mélytanulás a számítógépes látáshoz

Érdeklődő természete arra készteti, hogy tovább menjen? Javasoljuk, hogy tekintse meg nálunk Tanfolyam: „Practical Deep Learning for Computer Vision with Python”.

Újabb számítógépes látás tanfolyam?

Nem végezzük az MNIST számjegyek osztályozását vagy az MNIST divatot. Régen kiszolgálták a részüket. Túl sok tanulási erőforrás összpontosít az alapvető adatkészletekre és alapvető architektúrákra, mielőtt a fejlett feketedoboz-architektúrákra hagyná a teljesítmény terhét.

Mi arra szeretnénk koncentrálni demisztifikáció, gyakorlatiasság, megértés, intuíció és a valódi projektek. Tanulni akar hogyan tudsz változtatni? Elvezetjük Önt az agyunk képfeldolgozási módjától a mellrák kutatási szintű mélytanulási osztályozójának megírásáig a mély tanulási hálózatokig, amelyek „hallucinálnak”, gyakorlati munkán keresztül megtanítjuk az alapelveket és az elméletet, felkészítve a know-how és eszközök ahhoz, hogy szakértővé váljon a mélytanulás alkalmazásában a számítógépes látás megoldásában.

Mi van benne?

• A látás első alapelvei és hogyan lehet a számítógépeket „látni” tanítani
• A számítógépes látás különböző feladatai és alkalmazásai
• A szakma eszközei, amelyek megkönnyítik a munkáját
• Adatkészletek keresése, létrehozása és felhasználása számítógépes látáshoz
• A konvolúciós neurális hálózatok elmélete és alkalmazása
• Tartományeltolódás, együttes előfordulás és egyéb torzítások kezelése az adatkészletekben
• Transzfer Tanulás és mások képzési idejének és számítási erőforrásainak felhasználása az Ön javára
• Korszerű emlőrák osztályozó felépítése és betanítása
• Hogyan alkalmazzunk egy egészséges adag szkepticizmust a mainstream ötletekhez, és hogyan értsük meg a széles körben elfogadott technikák következményeit
• A ConvNet „koncepcióterének” megjelenítése t-SNE és PCA segítségével
• Esettanulmányok arról, hogy a vállalatok hogyan használják a számítógépes látástechnikákat a jobb eredmények elérése érdekében
• Megfelelő modellértékelés, látens tér vizualizáció és a modell figyelmének azonosítása
• Domainkutatás végzése, saját adatkészletek feldolgozása és modelltesztek létrehozása
• Élvonalbeli architektúrák, az ötletek fejlődése, mi teszi őket egyedivé és hogyan valósítsuk meg őket
• KerasCV – WIP-könyvtár a legkorszerűbb csővezetékek és modellek létrehozásához
• Hogyan elemezze és olvassa el a dolgozatokat, és saját maga hajtsa végre azokat
• Modellek kiválasztása az alkalmazástól függően
• Végpontok közötti gépi tanulási folyamat létrehozása
• Tájkép és intuíció a tárgyfelismeréshez a gyorsabb R-CNN-ekkel, RetinaNetekkel, SSD-kkel és YOLO-val
• Példány és szemantikai szegmentáció
• Valós idejű objektumfelismerés a YOLOv5 segítségével
• YOLOv5 objektumdetektorok képzése
• Transzformátorokkal való munkavégzés KerasNLP-vel (ipari erősségű WIP-könyvtár)
• Transformers integrálása ConvNetekkel a képek feliratainak létrehozásához
• Deepdream
• Deep Learning modell optimalizálása számítógépes látáshoz