Przetwarzanie obrazu bez OpenCV | pyton

Michael Zippo

Wiemy, że OpenCV jest szeroko stosowany do pracy z obrazami i ma do tego szeroki zakres funkcji. Ale co, jeśli chcemy przetwarzać pliki obrazów bez korzystania z zewnętrznej biblioteki, takiej jak OpenCV. Zobaczmy, jak możemy to zrobić.

Skalowanie obrazu (przy użyciu interpolacji najbliższego sąsiada):

Interpolacja najbliższego sąsiada — jest to najłatwiejszy sposób interpolacji. Ta metoda po prostu określa „najbliższy” sąsiedni piksel i przyjmuje wartość jego intensywności.

Rozważ mały obrazek o szerokości w i wysokości — h chcemy zmienić szerokość z p na szerokość q, zakładając, że p>gt; miq > n. Teraz potrzebujemy dwóch stałych skalowania:

scale_x = p / w scale_y = q / h

Teraz po prostu iterujemy po wszystkich pikselach w obrazie wyjściowym, odnosząc się do oryginalnych pikseli, które kopiujesz z. skalowanie naszych zmiennych kontrolnych za pomocą scale_x i scale_y oraz zaokrąglanie wynikowych skalowanych wartości indeksu.

Reprezentacja wizualna:
Obraz ma 3X3 piksele (łącznie 9 pikseli), teraz jeśli chcemy zwiększyć rozmiar obrazu do 6X6, to zgodnie z najbliższym algorytmem sąsiednim 6/3 (czyli 2) piksele powinny mieć taką samą wartość RGB jak wartość piksela do oryginalnego obrazu.

Program do skalowania obrazów:

< /tbody>

# przy użyciu matplotlib i numpy

import matplotlib.image jako img

importuj numpy as npy

# podaj czytelną lokalizację obrazu

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

# określenie długości oryginalnego obrazu

w , h = m.shape [: 2 < klasa kodu = "zwykły">];

# xNew i yNew to nowa szerokość i
# wymagana wysokość obrazu
po skalowaniu

xNew = int (w * 1 / 2 );

yNew = int (h * 1 / 2 );

# oblicz współczynnik skalowania
# działa więcej niż 2 piksele

xScale = xNew / (w - 1 );

yScale = yNew / (h - 1 < /kod> );

# używając numpy, biorąc macierz xNew
# szerokość i nowa wysokość z
# 4 atrybuty [alfa, B, G, B] wartości „Ęã‚Ęã

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

for i w range (xNew - 1 ):

for j w zakresie (yNew - 1 ):

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

1 + int (j / yScale)]

# Zapisz obraz po skalowaniu

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

Wyjście:

Skala szarości obrazu:

Korzystanie ze średniej metoda wartości, ta metoda podkreśla intensywność piksela, zamiast pokazywać, z czego składa się wartość RGB. Kiedy obliczymy średnią wartość RGB i przypiszemy jej wartość RGB do piksela, ponieważ wartość RGB piksela jest taka sama, nie będzie w stanie stworzyć żadnego koloru, ponieważ wszystkie kolory są generowane ze względu na inny stosunek RGB wartości, ponieważ w tym przypadku stosunek wynosiłby 1:1:1. Dlatego renderowany obraz będzie wyglądał jak szary obraz.

Reprezentacja wizualna:

Program do obsługi obrazów w skali szarości:

  # używając NumPy 
 importuj   numpy as npy 

 # using matplotlib 
  import   matplotlib.image jako img 
 
 # użyj statystyk do zaimportowania średniej 
 # do obliczenia średniej 
 from   statystyki   import   oznacza 

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

 # określ szerokość i wysokość obraz oryginalny 
  w, h   =   m .shape [:   2  ] 

 # nowy wymiar obrazu z 4 atrybutami na piksel 
 newImage   =   npy.zeros ([w, h,   4  ]) 
  print   (w) 
 drukuj   (h) 

 for   i   w   zakresie   (w): 
 for   j   w   zakresie   (h): 
 # Współczynnik RGB będzie wynosić od 0 do 1 
  lst   =   [  float   (m [i] [j] [  0  ]),   float   (m [i] [j] [  1  ]),   float   (m [i] [j] [  2  ])] 
   średnia   =   float   (średnia (lst) ) 
 newImage [i] [j] [  0  ]   =   avg 
 newImage [i] [j] [  1   ]   =   avg 
   newImage [i] [j] [  2  ]   =   avg 
 newImage [i] [j] [  3  ]   =   1   # wartość alfa musi być 1 

 # Zapisz obraz za pomocą imsave 
 img.imsave (  `grayedImage.png`  , newImage)

Wyjście:

Przycinanie obrazu:

Przycinanie zasadniczo usuwa niechciany piksel. Można to zrobić, umieszczając wymagany piksel w innej siatce obrazów, której rozmiar odpowiada wymaganym po przycięciu.

Rozważ obraz o rozmiarze 10 √ 10 pikseli i jeśli chcemy wykadrować tylko środek obrazu o rozmiarze 4 × 4 piksele, następnie musimy zebrać wartości pikseli ‚od (10-4) / 2, zaczynając od (3, 3) do 4 pikseli w kierunku x i 4 piksele w kierunku y.

Reprezentacja wizualna:

Przycinanie obrazu:

   # using matplotlib i numpy 
 import   matplotlib.image jako img 
 import   numpy as npy 

  # odczyt obrazu w zmiennej m 
 m   =   img.imread (   "taj.png"  ) 

 # definicja rozmiaru obrazu szerokość (w) wysokość (h) 
 w, h   =   m.shape [:   2  ] 

 # wymagany rozmiar obrazu po przycięciu 
 xNew   =   int   (w   *   1   /   4  ) 
 yNew   =   int   (h   *   1   /   4  ) 
 newImage   =   npy.zeros ([xNew, yNew,   4  ]) 
 
 # szerokość wydruku wysokość obrazu źródłowego 
 print   (w)  
  print   (h) 

 for   i   in   range   (  1  , xNew): 
   for   j   w   zakres   (  1  , yNew): 
   # przytnij od 100 do 100 pikseli oryginalnego obrazu 
   newImage [i, j]   =   m [  100   +   i,   100   +   j] 

 # zapisz obraz 
 img.imsave (  `cropped.png`  , newImage) 
Wyjście: