1. Zuallererst

Üben Sie dies, um die technischen Möglichkeiten der Bildvorverarbeitung zu verbessern 100 Klopfen für die Bildverarbeitung !! Ich werde es mit Colaboratory machen, damit es einfach ist, loszulegen. Wir werden daran arbeiten, das Ziel in zwei Wochen zu erreichen. Ich werde es sorgfältig erklären. Bitte stellen Sie eine Frage! 001 - 010 ist der Link auf der rechten Seite Knock 100 Bildverarbeitung !! (001 - 010) Sorgfältig und sorgfältig 011 - 020 ist der Link auf der rechten Seite 100 Klopfen bei der Bildverarbeitung !! (011 - 020) Frühes Spiel

2. Vorbereitung

Eingeführte Bibliotheken usw. wie folgt.

`python`


#Bibliothek importieren
from google.colab import drive
import numpy as np
import matplotlib.pyplot as plt
import cv2
from google.colab.patches import cv2_imshow

#Laden von Bildern
img = cv2.imread('Bildpfad/imori.jpg')
img_noise = cv2.imread('Bildpfad/imori_noise.jpg')
img_dark = cv2.imread('Bildpfad/imori_dark.jpg')
img_gamma = cv2.imread('Bildpfad/imori_gamma.jpg')
#Graustufenbild
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray_noise = cv2.cvtColor(img_noise, cv2.COLOR_BGR2GRAY)
gray_dark = cv2.cvtColor(img_dark, cv2.COLOR_BGR2GRAY)
#Zur Bildspeicherung
OUT_DIR = 'Zielpfad ausgeben/OUTPUT/'

3. Erklärung

Q.21. Histogrammnormalisierung

Implementieren Sie die Histogrammnormalisierung. Es ist ersichtlich, dass das Histogramm eine Vorspannung aufweist. Wenn beispielsweise viele Pixel nahe 0 vorhanden sind, ist das Bild insgesamt dunkel, und wenn viele Pixel nahe 255 vorhanden sind, ist das Bild hell. Lokal vorgespannte Histogramme haben einen engen Dynamikbereich. Um das Bild für das menschliche Auge besser sichtbar zu machen, ist es daher erforderlich, eine Verarbeitung durchzuführen, beispielsweise das Histogramm zu normalisieren oder zu glätten. Diese Histogrammnormalisierung wird als Graustufentransformation bezeichnet, und wenn ein Bild mit einem Pixelwert von [c, d] in den Bereich von [a, b] konvertiert wird, kann dies durch die folgende Gleichung realisiert werden. Dieses Mal wird imori_dark.jpg in den Bereich von [0, 255] konvertiert.

`A21`


def hist_normalization(img, a=0, b=255):
    """
Histogrammnormalisierung
    params
    ----------------------------
    param1: numpy.Bild im ndarray-Format
    param2:Minimaler Wert des Histogrammbereichs
    param3:Maximalwert des Histogrammbereichs

    returns
    ----------------------------
    numpy.Bild im ndarray-Format
    """
	#Histogramm(rgb)Maximal- / Minimalwert von
    c = img.min()     # 60
    d = img.max()    # 141

    #Kopieren
    out = img.copy()

	#Normalisierung
    out = (b - a) / (d - c) * (out - c) + a
    out[out < a] = a
    out[out > b] = b
    out = out.astype(np.uint8)
    return out

#Holen Sie sich Bildhöhe, -breite und -farbe
H, W, C = img_dark.shape

#Histogrammnormalisierung
out = hist_normalization(img_dark)

#Zeigen Sie ein Histogramm an
plt.hist(out.ravel(), bins=255, rwidth=0.8, range=(0, 255))
plt.savefig("img21.png ")
plt.show()

![img21_.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/621150/52139d68-fc5d-0658-b887-7badda5ebcc9.png) Das Bild ist auch ziemlich klar.

Referenz: Hystertischer Teil 2: Abflachen des Histogramms.

Q.22. Histogrammbetrieb

Betreiben Sie den Durchschnittswert des Histogramms auf m0 = 128 und die Standardabweichung auf s0 = 52. Dies ist eine Operation, bei der das Histogramm flach geändert wird, anstatt den Dynamikbereich des Histogramms zu ändern. Um das Histogramm von Mittelwert m und Standardabweichung s in Mittelwert m0 und Standardabweichung s0 zu ändern, konvertieren Sie durch die folgende Gleichung.

`A22`


def hist_mani(img, m0=128, s0=52):
    """
Der Durchschnittswert des Histogramms ist m0=128, Standardabweichung s0=Bedienen Sie, um 52 zu sein

    params
    --------------------------------------
    param1: numpy.Bild im ndarray-Format
    param2:Durchschnittswert
    param3:Standardabweichung

    returns
    --------------------------------------
    numpy.Bild im ndarray-Format
    """
    #Durchschnittswert
    m = np.mean(img)
    #Standardabweichung
    s = np.std(img)

    #Kopie des Bildes
    out = img.copy()

    #Berechnen Sie nach der Formel
    out = s0 / s * (out - m) + m0
    out[out < 0] = 0
    out[out > 255] = 255
    out = out.astype(np.uint8)

    return out

#Bearbeiten Sie das Histogramm
out = hist_mani(img_dark)

#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans22_1.jpg', out)
#Bild anzeigen
cv2_imshow(out)
cv2.waitKey(0)
cv2.destroyAllWindows()

#Zeigen Sie ein Histogramm an
plt.hist(out.ravel(), bins=255, rwidth=0.8, range=(0, 255))
plt.savefig("img22_2.png ")
plt.show()

ファイル名

Referenz: Hystertischer Teil 2: Abflachen des Histogramms.

Q.23. Abflachen des Histogramms

Histogrammabflachung implementieren. Die Histogrammabflachung ist eine Operation zum Ändern des Histogramms in eine flache Form und eine Operation zum Ausgleichen der Histogrammwerte, ohne dass der oben erwähnte Durchschnittswert und die Standardabweichung erforderlich sind. Dies wird durch die folgende Gleichung definiert. S ... Gesamtzahl der Pixelwerte, Zmax ... Maximalwert der Pixelwerte, h (z) ... Frequenz der Dichte z

`A23`


def hist_equal(img, z_max=255):
    """
Graphitabflachung

    params
    --------------------------------------
    param1: numpy.Bild im ndarray-Format
    param2:Maximaler Pixelwert

    returns
    --------------------------------------
    numpy.Bild im ndarray-Format
    """

    #Holen Sie sich Bildhöhe, -breite und -farbe
    H, W, C = img.shape
    #Gesamtzahl der Pixelwerte(Bildhöhe x Bildbreite x Anzahl der Farben)
    S = H * W * C * 1.     # 49152.0
    #Kopie des Bildes
    out = img.copy()

    #Konzentrationsfrequenz
    sum_h = 0.

    #Bilddichte 0~Jede Frequenz bis zu 255
    for i in range(256):
        #Wo die Konzentrationen übereinstimmen
        ind = np.where(img==i)
        #Gleichmäßige Konzentrationsfrequenz
        sum_h += len(img[ind])
        #Histogrammwerte ausgleichen(Siehe die Formel)
        z_prime = z_max / S * sum_h
        out[ind] = z_prime
    
    out = out.astype(np.uint8)

    return out

#Bearbeiten Sie das Histogramm
out = hist_equal(img)

#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans23_1.jpg', out)
#Bild anzeigen
cv2_imshow(out)
cv2.waitKey(0)
cv2.destroyAllWindows()

#Zeigen Sie ein Histogramm an
plt.hist(out.ravel(), bins=255, rwidth=0.8, range=(0, 255))
plt.savefig("img23_2.png ")
plt.show()

ファイル名

Referenz: Hystertischer Teil 2: Abflachen des Histogramms.

Q.24. Gammakorrektur

Führen Sie eine Gammakorrektur (c = 1, g = 2,2) für imori_gamma.jpg durch. Die Gammakorrektur ist eine Korrektur, wenn Pixelwerte über ein Medium wie eine Kamera nicht linear konvertiert werden. Wenn das Bild so angezeigt wird, wie es auf einem Display oder dergleichen ist, wird der Bildschirm dunkel. Daher besteht der Zweck der Gammakorrektur darin, ein Bild ohne die Eigenschaften des Displays anzuzeigen, indem der RGB-Wert im Voraus erhöht wird. Die nichtlineare Umwandlung soll durch die folgende Gleichung erfolgen. X ist jedoch auf [0,1] normiert. c ... Konstante, g ... Gamma-Charakteristik (normalerweise 2.2) Daher wird die Gammakorrektur durch die folgende Gleichung durchgeführt.

`A24`


def gamma_correction(img, c=1, g=2.2):
    """
Gammakorrektur: So stellen Sie die Helligkeit des Bildes ein

    params
    --------------------------------------
    param1: numpy.Bild im ndarray-Format
    param2:Konstante
    param3:Gamma-Eigenschaften

    returns
    --------------------------------------
    numpy.Bild im ndarray-Format
    """

    #Kopie des Bildes
    out = img.copy().astype(np.float)
    #Teilen Sie durch 255(In Iin konvertieren)
    out /= 255.
    #Gammakorrekturformel
    out = (1/c * out) ** (1/g)

    #255 multiplizieren
    out *= 255
    out = out.astype(np.uint8)

    return out

#Gamma-Korrektur
out = gamma_correction(img_gamma)

#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans24.jpg', out)
#Bild anzeigen
cv2_imshow(out)
cv2.waitKey(0)
cv2.destroyAllWindows()

Referenz: Versuchen Sie Python!

Q.25 Interpolation des nächsten Nachbarn

Vergrößern Sie das Bild 1,5-mal durch Interpolation des nächsten Nachbarn. Der nächste Nachbar ist eine Methode, bei der das nächste Pixel wie beim Vergrößern des Bildes verwendet wird. Es ist einfach und die Verarbeitungsgeschwindigkeit ist schnell, aber die Bildqualität verschlechtert sich erheblich. Interpoliert durch die folgende Gleichung. Ich ... Bild nach Vergrößerung, ich ... Bild vor Vergrößerung, ein ... Vergrößerungsverhältnis, [] ... Rundung

`A25`


"""
Interpolation des nächsten Nachbarn
cv2.resize(src, dsize[, interpolation])
src Eingabebild
Bildgröße nach Änderung der Größe
Interpolation Interpolationsmethode(Cv2 für die Interpolation des nächsten Nachbarn.INTER_NEAREST)
"""
#Interpolation des nächsten Nachbarn
#Bildgröße nach Änderung: img.shape>>>(Höhe, Breite, Farbe)
out = cv2.resize(
    img, (int(img.shape[1]*1.5), int(img.shape[0]*1.5)), interpolation=cv2.INTER_NEAREST)

#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans25.jpg', out)
#Bild anzeigen
cv2_imshow(out)
cv2.waitKey(0)
cv2.destroyAllWindows()

Referenz: [[Python / OpenCV] Vergrößerung / Verkleinerung des Bildes (Interpolationsmethode für den nächsten Nachbarn, bilineare Interpolationsmethode, bikubische Interpolationsmethode)](https://algorithm.joho.info/programming/python/opencv-resize-nearest- interpolation-py /)

Q.26. Bi-lineare Interpolation

Vergrößern Sie das Bild 1,5-mal mit bi-linearer Interpolation. Die bi-lineare Interpolation ist eine Methode zur Ergänzung der umgebenden vier Pixel durch Gewichtung nach dem Abstand. Je größer der Rechenaufwand ist, desto länger ist die Verarbeitungszeit, aber die Verschlechterung der Bildqualität kann unterdrückt werden.

`A26`


"""
Bilineare Interpolationsmethode (Bi-lineare Interpolation) ist eine Interpolationsmethode, bei der die vier umgebenden Pixel verwendet werden.
cv2.resize(src, dsize[, interpolation])
src Eingabebild
Bildgröße nach Änderung der Größe
Interpolation Interpolationsmethode(Cv2 für die bilineare Interpolation.INTER_LINEAR)
"""
#Bilineare Interpolationsmethode
#Bildgröße nach Änderung: img.shape>>>(Höhe, Breite, Farbe)
out = cv2.resize(
    img, (int(img.shape[1]*1.5), int(img.shape[0]*1.5)), interpolation=cv2.INTER_LINEAR)

#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans26.jpg', out)
#Bild anzeigen
cv2_imshow(out)
cv2.waitKey(0)
cv2.destroyAllWindows()

Q.27 Bi-kubische Interpolation

Vergrößern Sie das Bild 1,5-mal mit bi-kubischer Interpolation. Die bi-kubische Interpolation ist eine Erweiterung der bi-linearen Interpolation, und die Interpolation wird von den umgebenden 16 Pixeln durchgeführt.

`A27`


"""
Das bikubische Interpolationsverfahren verwendet die Pixelwerte von 16 umgebenden Pixeln.
cv2.resize(src, dsize[, interpolation])
src Eingabebild
Bildgröße nach Änderung der Größe
Interpolation Interpolationsmethode(Cv2 für die bikubische Interpolation.INTER_CUBIC)
"""
#Bikubische Interpolation
#Bildgröße nach Änderung: img.shape>>>(Höhe, Breite, Farbe)
out = cv2.resize(
    img, (int(img.shape[1]*1.5), int(img.shape[0]*1.5)), interpolation=cv2.INTER_CUBIC)

#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans27.jpg', out)
#Bild anzeigen
cv2_imshow(out)
cv2.waitKey(0)
cv2.destroyAllWindows()

Q.28. Affinumwandlung (parallele Bewegung)

Verwenden Sie die affine Transformation, um das Bild parallel um +30 in x-Richtung und -30 in y-Richtung zu verschieben. Die Affintransformation ist eine Operation, bei der ein Bild mithilfe einer 3x3-Matrix transformiert wird.

`A28`


"""
Affin-Konvertierung
cv2.warpAffine(src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]])
Originalbild (NumPy Array ndarray) als erstes Argument
2 x 3-Konvertierungsmatrix (NumPy-Array ndarray) als zweites Argument,
Geben Sie im dritten Argument die Größe (Taple) des Ausgabebilds an.
"""
#Holen Sie sich Bildhöhe, -breite und -farbe
H, W, C = img.shape
#Parallelbewegung[[1,0,Bewegungsumfang in seitlicher Richtung],[0,1,Bewegungsumfang in vertikaler Richtung]]2x3 Matrix
M = np.float64([[1, 0, 30], [0,1,-30]])
#Affin-Konvertierung
out = cv2.warpAffine(img, M, (W, H))

#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans28.jpg', out)
#Bild anzeigen
cv2_imshow(out)
cv2.waitKey(0)
cv2.destroyAllWindows()

Referenz: [Python / OpenCV] Bild mit affiner Konvertierung drehen

Q.29. Affinumwandlung (Vergrößerung / Verkleinerung)

Verwenden Sie die affine Transformation, um (1) die Größe in x-Richtung 1,3-mal und in y-Richtung 0,8-mal zu ändern. Zusätzlich zu den Bedingungen (2) und (1) realisieren Sie gleichzeitig eine parallele Bewegung um +30 in x-Richtung und -30 in y-Richtung.

`A29`



def affine_expand(img, ratio_x, ratio_y):
    """
Mit affiner Umwandlung vergrößern

    params
    -------------------------------
    param1: numpy.Bild im ndarray-Format
    param2:X-Richtungsverhältnis
    param3:Verhältnis in y-Richtung

    returns
    -------------------------------
    numpy.Bild im ndarray-Format
    """
    #Bildhöhe und -breite
    H, W = img.shape[:2]
    #xy-Koordinaten np.Typ float32
    src = np.array([[0.0, 0.0],[0.0, 1.0],[1.0, 0.0]], np.float32)
    # x,y Multiplizieren Sie jedes Verhältnis
    dest = src.copy()
    dest[:,0] *= ratio_x
    dest[:,1] *= ratio_y
    """
Generieren Sie eine Transformationsmatrix für die affine Transformation: cv2.getAffineTransform(src, dest)
    src:Koordinaten von 3 Punkten vor der Konvertierung
    dest:Geben Sie die Koordinaten der drei Punkte nach der Konvertierung mit dem NumPy-Array ndarray an
    """
    affine = cv2.getAffineTransform(src, dest)
    """
Affin-Konvertierung
    cv2.warpAffine(src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]])
Originalbild (NumPy Array ndarray) als erstes Argument
2 x 3-Konvertierungsmatrix (NumPy-Array ndarray) als zweites Argument,
Geben Sie im dritten Argument die Größe (Taple) des Ausgabebilds an.
    INTER_LANCZOS4 - Lanczos-Interpolation unter Verwendung des Nachbarschaftsbereichs von 8 × 8
    """
    return cv2.warpAffine(img, affine, (int(W*ratio_x), int(H*ratio_y)), cv2.INTER_LANCZOS4) #Es kann auch eine Interpolationsmethode angegeben werden


#Mit affiner Umwandlung vergrößern
out = affine_expand(img, 1.3, 0.8)
#Parallelbewegung[[1,0,Bewegungsumfang in seitlicher Richtung],[0,1,Bewegungsumfang in vertikaler Richtung]]2x3 Matrix
H, W = out.shape[:2]
M = np.float64([[1, 0, 30], [0,1,-30]])
out2 = cv2.warpAffine(out, M, (W, H))

#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans29_1.jpg', out)
cv2.imwrite(OUT_DIR + 'ans29_2.jpg', out2)

#Bild anzeigen
cv2_imshow(out)
cv2_imshow(out2)
cv2.waitKey(0)
cv2.destroyAllWindows()

Referenz: Affin-Konvertierung vollständig verstehen

Q.30. Affinumwandlung (Rotation)

(1) Mit der affinen Transformation um 30 Grad gegen den Uhrzeigersinn drehen. (2) Erstellen Sie ein Bild, sodass so wenig schwarze Bereiche wie möglich vorhanden sind, indem Sie die Mittelkoordinaten mit einem Bild fixieren, das mit der Affin-Transformation um 30 Grad gegen den Uhrzeigersinn gedreht wurde. (Wenn Sie jedoch eine einfache affine Konvertierung durchführen, wird das Bild abgeschnitten, sodass Sie kreativ sein müssen.)

`A30`


def affin_rotate(img, x, y, theta, scale):
    """
Mit affiner Umwandlung drehen

    params
    -------------------------------
    param1: numpy.Bild im ndarray-Format
    param2:X-Koordinate der Drehachse
    param3:Y-Koordinate der Rotationsachse
    param4:Drehwinkel
    param5:Drehwinkel / Vergrößerung

    returns
    -------------------------------
    numpy.Bild im ndarray-Format
    """

    """
Affintransformation, die eine zweidimensionale Rotation darstellt
    cv2.getRotationMatrix2D(center, angle, scale)
    center:Koordinaten, die den Ursprung der Rotation darstellen
    angle:Drehwinkel (Grad Grad, nicht Bogenmaß)
    scale:Vergrößerungs- / Verkleinerungsverhältnis.
    """
    #Berechnung der Rotationsumwandlungsmatrix
    R = cv2.getRotationMatrix2D((x, y), theta, scale)
    """
Affin-Konvertierung
    cv2.warpAffine(src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]])
Originalbild (NumPy Array ndarray) als erstes Argument
2 x 3-Konvertierungsmatrix (NumPy-Array ndarray) als zweites Argument,
Geben Sie im dritten Argument die Größe (Taple) des Ausgabebilds an.
    cv2.INTER_CUBIC:Bikubisch
    """
    #Affin-Konvertierung
    dst = cv2.warpAffine(img, R, gray.shape,
                        flags=cv2.INTER_CUBIC)

    return dst

#Mittelkoordinaten des Bildes
oy, ox = int(img.shape[0]/2), int(img.shape[1]/2)

#30 Grad gegen den Uhrzeigersinn drehen
out1 = affin_rotate(img, 0, 0, 30, 1)
#Feste Mittelkoordinaten mit einem um 30 Grad gegen den Uhrzeigersinn gedrehten Bild
out2 = affin_rotate(img, ox, oy, 30, 1)

#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans30_1.jpg', out1)
cv2.imwrite(OUT_DIR + 'ans31_2.jpg', out2)

#Bild anzeigen
cv2_imshow(out1)
cv2_imshow(out2)
cv2.waitKey(0)
cv2.destroyAllWindows()

Referenz: Geometrische Konvertierung mit Python, OpenCV (Affin-Konvertierung, Projektionskonvertierung usw.) Referenz: [Python / OpenCV] Bild mit affiner Transformation drehen

Impressionen

Es fühlt sich an, als würde das Niveau allmählich steigen. Versuchen Sie, so viel wie möglich in OpenCV zu implementieren.

[PYTHON] 100 Klopfen bei der Bildverarbeitung !! (021-030) Ich möchte eine Pause machen ...

1. Zuallererst

2. Vorbereitung

python

3. Erklärung

Q.21. Histogrammnormalisierung

A21

Q.22. Histogrammbetrieb

A22

Q.23. Abflachen des Histogramms

A23

Q.24. Gammakorrektur

A24

Q.25 Interpolation des nächsten Nachbarn

A25

Q.26. Bi-lineare Interpolation

A26

Q.27 Bi-kubische Interpolation

A27

Q.28. Affinumwandlung (parallele Bewegung)

A28

Q.29. Affinumwandlung (Vergrößerung / Verkleinerung)

A29

Q.30. Affinumwandlung (Rotation)

A30

Impressionen

`python`

`A21`

`A22`

`A23`

`A24`

`A25`

`A26`

`A27`

`A28`

`A29`

`A30`