Bildverarbeitung ohne OpenCV | python

Michael Zippo

Wir wissen, dass OpenCV für die Arbeit mit Bildern weit verbreitet ist und dafür eine Vielzahl von Funktionen bietet. Aber was ist, wenn wir Bilddateien verarbeiten möchten, ohne eine externe Bibliothek wie OpenCV zu verwenden? Sehen wir uns an, wie wir das machen können.

Bildskalierung (unter Verwendung der Nächster-Nachbar-Interpolation):

Nächste-Nachbar-Interpolation — Dies ist die einfachste Art zu interpolieren. Diese Methode bestimmt einfach das "nächste" benachbarte Pixel und nimmt einen Wert für seine Intensität.

Stellen Sie sich ein kleines Bild vor, dessen Breite w und dessen Höhe — h, dass wir von der Breite p auf die Breite q wechseln wollen, unter der Annahme, dass p > m und q > n. Jetzt brauchen wir zwei Skalierungskonstanten:

scale_x = p / w scale_y = q / h

Nun iterieren wir einfach über alle Pixel im Ausgabebild, wobei wir uns auf die Originalpixel beziehen kopieren von. Skalierung unserer Kontrollvariablen mit scale_x und scale_y und Rundung der resultierenden skalierten Indexwerte.

Visuelle Darstellung:
Das Bild hat 3X3 Pixel (insgesamt 9 Pixel), wenn wir nun die Bildgröße auf 6X6 erhöhen wollen, dann sollten nach dem nächstgelegenen Nachbaralgorithmus 6/3 (dh 2) Pixel den gleichen RGB-Wert wie das Wertpixel haben zum Originalbild.

Programm zur Bildskalierung:

< /tbody>

# mit matplotlib und numpy

import matplotlib.image as img

import numpy als npy

# Bildposition lesbar bereitstellen

m = img.imread ( "taj.png " );

# Definition der Länge des Originalbildes

w , h = m.shape [: 2 < Codeklasse = "einfach">];

# xNew und yNew sind die neue Breite und
# erforderliche Bildhöhe
nach der Skalierung

xNew = int (w * 1 / 2 );

yNew = int (h * 1 / 2 );

# Skalierungsfaktor berechnen
# mehr als 2 Pixel arbeiten

xScale = xNew / (w - 1 );

yScale = yNew / (h - 1 );

# Verwendung von numpy unter Verwendung der xNew-Matrix
# Breite und neue Höhe mit
# 4 Attribute [alpha, B, G, B] Werte ‚Äã‚Äã

newImage = npy.zeros ([xNew, yNew, 4 ]);

für i in range (xNew - 1 ):

for j in range (yNew - 1 ):

newImage [ i + 1 , j + 1 ] = m [ 1 + int (i / xScale),

1 + int (j / yScale)]

# Bild nach Skalierung speichern

img.imsave ( `scaled.png ` , newImage);

Ausgabe:

Grauskala des Bildes:

Using the mean Value-Methode betont diese Methode die Intensität eines Pixels, anstatt zu zeigen, aus welchen RGB-Werten es besteht. Wenn wir den durchschnittlichen RGB-Wert berechnen und ihm den RGB-Wert für ein Pixel zuweisen, kann es keine Farbe erzeugen, da der RGB-Wert des Pixels gleich ist, da alle Farben aufgrund eines unterschiedlichen RGB-Verhältnisses erzeugt werden Werte, da in diesem Fall das Verhältnis 1: 1: 1 wäre. Daher sieht das gerenderte Bild wie ein graues Bild aus.

Visuelle Darstellung:

Graustufen-Bildprogramm:

  # mit NumPy 
 import   numpy as npy 

 # using matplotlib 
  import   matplotlib.image as img 
 
 # Statistiken verwenden, um den Durchschnitt zu importieren 
 # um den Durchschnitt zu berechnen 
 aus   Statistiken   import   bedeuten 

 m   =   img.imread (  "taj.png"  ) 

 # definiert die Breite und Höhe der Originalbild 
  w, h   =   m .shape [:   2  ] 

 # neue Bilddimension mit 4 Attributen pro Pixel 
 newImage   =   npy.zeros ([w, h,   4  ]) 
  print   (w) 
 print   (h) 

 für   i   im   Bereich   (w): 
 für   j   im   Bereich   (h): 
 # RGB-Verhältnis liegt zwischen 0 und 1 
  lst   =   [  float   (m [i] [j] [  0  ]),   float   (m [i] [j] [  1  ]),   float   (m [i] [j] [  2  ])] 
   avg   =   float   ( mean (lst) ) 
 newImage [i] [j] [  0  ]   =   avg 
 newImage [i] [j] [  1   ]   =   avg 
   newImage [i] [j] [  2  ]   =   avg 
 newImage [i] [j] [  3  ]   =   1   # Alphawert muss sein 1 

 # Bild speichern mit imsave 
 img.imsave (  `grayedImage.png`  , newImage)

Ausgabe:

Zuschneiden eines Bildes:

Zuschneiden entfernt im Wesentlichen unerwünschtes Pixel. Dies kann erreicht werden, indem das erforderliche Pixel in einem anderen Bildraster platziert wird, dessen Größe nach dem Zuschneiden der erforderlichen entspricht.

Betrachten Sie ein Bild mit einer Größe von 10 √ó 10 Pixel, und wenn wir wollen nur die Mitte eines Bildes mit einer Größe von 4 √ó 4 Pixeln beschneiden, dann müssen wir Pixelwerte ‚Äã‚Äã von (10-4) / 2, beginnend bei (3, 3) bis zu 4 Pixeln sammeln in x-Richtung und 4 Pixel in y-Richtung.

Visuelle Darstellung:

Bildbeschneidung:

   # matplotlib und numpy verwenden 
 import   matplotlib.image as img 
 import   numpy as npy 

  # Bild in Variable lesen m 
 m   =   img.imread (   "taj.png"  ) 

 # Definition der Bildgröße Breite (w) Höhe (h) 
 w, h   =   m.form [:   2  ] 

 # Erforderliche Bildgröße nach dem Zuschneiden 
 xNew   =   int   (w   *   1   /   4  ) 
 yNew   =   int   (h   *   1   /   4  ) 
 newImage   =   npy.zeros ([xNeu, yNeu,   4  ]) 
 
 # Druckbreite Quellbildhöhe 
 print   (w)  
  print   (h) 

 für   i   im   Bereich   (  1  , xNew): 
   for   j   im   Bereich   (  1  , yNew): 
   # Zuschneiden von 100 auf 100 Pixel des Originalbildes 
   newImage [i, j]   =   m [  100   +   i,   100   +   j] 

 # Bild speichern 
 img.imsave (  `cropped.png`  , newImage)

Ausgabe: