Bild von kostenlospik
NumPy ist ein robustes Software zur Bildverarbeitung in Python. Es ermöglicht Ihnen, Bilder mithilfe von Array-Operationen zu bearbeiten. Dieser Artikel untersucht verschiedene Bildverarbeitungstechniken mit NumPy.
Importieren von Bibliotheken
Wir müssen die erforderlichen Bibliotheken importieren: PIL, NumPy und Matplotlib. PIL wird zum Öffnen von Bildern verwendet. NumPy ermöglicht effiziente Array-Operationen und Bildverarbeitung. Matplotlib wird zum Visualisieren von Bildern verwendet
import numpy as np
from PIL import Picture
import matplotlib.pyplot as pltBild zuschneiden
Wir definieren Koordinaten, um den Bereich zu markieren, den wir aus dem Bild ausschneiden möchten. Das neue Bild enthält nur den ausgewählten Teil und verwirft den Relaxation.
# Load the picture utilizing PIL (Python Imaging Library)
img = Picture.open('cat.jpg')
# Convert the picture to a NumPy array
img_array = np.array(img)
# Outline the cropping coordinates
y1, x1 = 1000, 1000 # Prime-left nook of ROI
y2, x2 = 2500, 2000 # Backside-right nook of ROI
cropped_img = img_array(y1:y2, x1:x2)
# Show the unique picture and the cropped picture
plt.determine(figsize=(10, 5))
# Show the unique picture
plt.subplot(1, 2, 1)
plt.imshow(img_array)
plt.title('Authentic Picture')
plt.axis('off')
# Show the cropped picture
plt.subplot(1, 2, 2)
plt.imshow(cropped_img)
plt.title('Cropped Picture')
plt.axis('off')
plt.tight_layout()
plt.present()
Bild drehen
Wir drehen das Bildarray um 90 Grad gegen den Uhrzeigersinn mit NumPys ‚rot90‘ Funktion.
# Load the picture utilizing PIL (Python Imaging Library)
img = Picture.open('cat.jpg')
# Convert the picture to a NumPy array
img_array = np.array(img)
# Rotate the picture by 90 levels counterclockwise
rotated_img = np.rot90(img_array)
# Show the unique picture and the rotated picture
plt.determine(figsize=(10, 5))
# Show the unique picture
plt.subplot(1, 2, 1)
plt.imshow(img_array)
plt.title('Authentic Picture')
plt.axis('off')
# Show the rotated picture
plt.subplot(1, 2, 2)
plt.imshow(rotated_img)
plt.title('Rotated Picture (90 levels)')
plt.axis('off')
plt.tight_layout()
plt.present()
Bild umdrehen
Wir verwenden NumPy’s ‚fliplr‘ Funktion zum horizontalen Spiegeln des Bildarrays.
# Load the picture utilizing PIL (Python Imaging Library)
img = Picture.open('cat.jpg')
# Convert the picture to a NumPy array
img_array = np.array(img)
# Flip the picture horizontally
flipped_img = np.fliplr(img_array)
# Show the unique picture and the flipped picture
plt.determine(figsize=(10, 5))
# Show the unique picture
plt.subplot(1, 2, 1)
plt.imshow(img_array)
plt.title('Authentic Picture')
plt.axis('off')
# Show the flipped picture
plt.subplot(1, 2, 2)
plt.imshow(flipped_img)
plt.title('Flipped Picture')
plt.axis('off')
plt.tight_layout()
plt.present() 
Negativ eines Bildes
Das Negativ eines Bildes entsteht durch Umkehrung seiner Pixelwerte. Bei Graustufenbildern wird der Wert jedes Pixels vom Most (255 bei 8-Bit-Bildern) abgezogen. Bei Farbbildern geschieht dies separat für jeden Farbkanal.
# Load the picture utilizing PIL (Python Imaging Library)
img = Picture.open('cat.jpg')
# Convert the picture to a NumPy array
img_array = np.array(img)
# Examine if the picture is grayscale or RGB
is_grayscale = len(img_array.form) < 3
# Operate to create unfavorable of a picture
def create_negative(picture):
if is_grayscale:
# For grayscale photos
negative_image = 255 - picture
else:
# For coloration photos (RGB)
negative_image = 255 - picture
return negative_image
# Create unfavorable of the picture
negative_img = create_negative(img_array)
# Show the unique and unfavorable photos
plt.determine(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.imshow(img_array)
plt.title('Authentic Picture')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(negative_img)
plt.title('Unfavorable Picture')
plt.axis('off')
plt.tight_layout()
plt.present() 
Bild binarisieren
Durch die Binärisierung wird ein Bild in Schwarzweiß umgewandelt. Jeder Pixel wird basierend auf einem Schwellenwert als schwarz oder weiß markiert. Pixel, die kleiner als der Schwellenwert sind, werden zu 0 (schwarz) und Pixel, die darüber liegen, zu 255 (weiß).
# Load the picture utilizing PIL (Python Imaging Library)
img = Picture.open('cat.jpg')
# Convert the picture to grayscale
img_gray = img.convert('L')
# Convert the grayscale picture to a NumPy array
img_array = np.array(img_gray)
# Binarize the picture utilizing a threshold
threshold = 128
binary_img = np.the place(img_array < threshold, 0, 255).astype(np.uint8)
# Show the unique and binarized photos
plt.determine(figsize= (10, 5))
plt.subplot(1, 2, 1)
plt.imshow(img_array, cmap='grey')
plt.title('Authentic Grayscale Picture')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(binary_img, cmap='grey')
plt.title('Binarized Picture (Threshold = 128)')
plt.axis('off')
plt.tight_layout()
plt.present() 
Farbraumkonvertierung
Bei der Farbraumkonvertierung wird ein Bild von einem Farbmodell in ein anderes umgewandelt. Dies geschieht durch Ändern der Anordnung der Pixelwerte. Wir verwenden eine gewichtete Summe der RGB-Kanäle, um ein Farbbild in ein Graustufenbild umzuwandeln.
# Load the picture utilizing PIL (Python Imaging Library)
img = Picture.open('cat.jpg')
# Convert the picture to a NumPy array
img_array = np.array(img)
# Grayscale conversion system: Y = 0.299*R + 0.587*G + 0.114*B
gray_img = np.dot (img_array(..., :3), (0.299, 0.587, 0.114))
# Show the unique RGB picture
plt.determine(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.imshow(img_array)
plt.title('Authentic RGB Picture')
plt.axis('off')
# Show the transformed grayscale picture
plt.subplot(1, 2, 2)
plt.imshow(gray_img, cmap='grey')
plt.title('Grayscale Picture')
plt.axis('off')
plt.tight_layout()
plt.present() 
Pixelintensitätshistogramm
Das Histogramm zeigt die Verteilung der Pixelwerte in einem Bild. Zur Berechnung des Histogramms wird das Bild in ein eindimensionales Array umgewandelt.
# Load the picture utilizing PIL (Python Imaging Library)
img = Picture.open('cat.jpg')
# Convert the picture to a NumPy array
img_array = np.array(img)
# Compute the histogram of the picture
hist, bins = np.histogram(img_array.flatten(), bins=256, vary= (0, 256))
# Plot the histogram
plt.determine(figsize=(10, 5))
plt.hist(img_array.flatten(), bins=256, vary= (0, 256), density=True, coloration="grey")
plt.xlabel('Pixel Depth')
plt.ylabel('Normalized Frequency')
plt.title('Histogram of Grayscale Picture')
plt.grid(True)
plt.present() 
Maskierungsbild
Beim Maskieren eines Bildes werden Teile anhand von Regeln angezeigt oder ausgeblendet. Mit 1 markierte Pixel bleiben erhalten, während mit 0 markierte Pixel ausgeblendet werden.
# Load the picture utilizing PIL (Python Imaging Library)
img = Picture.open('cat.jpg')
# Convert the picture to a NumPy array
img_array = np.array(img)
# Create a binary masks
masks = np.zeros_like(img_array(:, :, 0), dtype=np.uint8)
heart = (img_array.form(0) // 2, img_array.form(1) // 2)
radius = min(img_array.form(0), img_array.form(1)) // 2 # Enhance radius for an even bigger circle
rr, cc = np.meshgrid(np.arange(img_array.form(0)), np.arange(img_array.form(1)), indexing='ij')
circle_mask = (rr - heart (0)) ** 2 + (cc - heart (1)) ** 2 < radius ** 2
masks(circle_mask) = 1
# Apply the masks to the picture
masked_img = img_array.copy()
for i in vary(img_array.form(2)): # Apply to every coloration channel
masked_img(:,:,i) = img_array(:,:,i) * masks
# Displaying the unique picture and the masked picture
plt.determine(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.imshow(img_array)
plt.title('Authentic Picture')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(masked_img)
plt.title('Masked Picture')
plt.axis('off')
plt.tight_layout()
plt.present() 
Einpacken
Dieser Artikel zeigte verschiedene Möglichkeiten zur Bildverarbeitung mit NumPy. Wir verwendeten PIL, NumPy und Matplotlib, um Bilder zuzuschneiden, zu drehen, zu spiegeln und zu binarisieren. Darüber hinaus lernten wir, Bildnegative zu erstellen, Farbräume zu ändern, Histogramme zu erstellen und Masken anzuwenden.
Jayita Gulati ist eine Enthusiastin für maschinelles Lernen und technische Autorin, die von ihrer Leidenschaft für die Erstellung von Modellen für maschinelles Lernen angetrieben wird. Sie hat einen Grasp-Abschluss in Informatik von der Universität Liverpool.