webentwicklung-frage-antwort-db.com.de

Hochpassfilter für die Bildverarbeitung in Python mit scipy/numpy

Ich studiere gerade Bildverarbeitung. In Scipy weiß ich, dass es in Scipy.signal einen Medianfilter gibt. Kann mir jemand sagen, ob es einen Filter gibt, der dem Hochpassfilter ähnelt?

Vielen Dank

17
Hold_My_Anger

"Hochpassfilter" ist ein sehr allgemeiner Begriff. Es gibt unendlich viele verschiedene "Hochpassfilter", die sehr unterschiedliche Dinge tun (z. B. ist ein Edge-Dectection-Filter, wie bereits erwähnt, technisch ein Hochpassfilter (die meisten sind eigentlich ein Bandpassfilter), hat jedoch einen ganz anderen Effekt als Sie wahrscheinlich Habe dran gedacht.)

Auf jeden Fall sollten Sie, basierend auf den meisten Fragen, die Sie gestellt haben, wahrscheinlich nach scipy.ndimage anstelle von scipy.filter suchen, insbesondere wenn Sie mit großen Bildern arbeiten (ndimage kann Vor-Ort-Operationen durchführen Speicher sparen). 

Als ein grundlegendes Beispiel, zeigen wir einige verschiedene Vorgehensweisen:

import matplotlib.pyplot as plt
import numpy as np
from scipy import ndimage
import Image

def plot(data, title):
    plot.i += 1
    plt.subplot(2,2,plot.i)
    plt.imshow(data)
    plt.gray()
    plt.title(title)
plot.i = 0

# Load the data...
im = Image.open('lena.png')
data = np.array(im, dtype=float)
plot(data, 'Original')

# A very simple and very narrow highpass filter
kernel = np.array([[-1, -1, -1],
                   [-1,  8, -1],
                   [-1, -1, -1]])
highpass_3x3 = ndimage.convolve(data, kernel)
plot(highpass_3x3, 'Simple 3x3 Highpass')

# A slightly "wider", but sill very simple highpass filter 
kernel = np.array([[-1, -1, -1, -1, -1],
                   [-1,  1,  2,  1, -1],
                   [-1,  2,  4,  2, -1],
                   [-1,  1,  2,  1, -1],
                   [-1, -1, -1, -1, -1]])
highpass_5x5 = ndimage.convolve(data, kernel)
plot(highpass_5x5, 'Simple 5x5 Highpass')

# Another way of making a highpass filter is to simply subtract a lowpass
# filtered image from the original. Here, we'll use a simple gaussian filter
# to "blur" (i.e. a lowpass filter) the original.
lowpass = ndimage.gaussian_filter(data, 3)
gauss_highpass = data - lowpass
plot(gauss_highpass, r'Gaussian Highpass, $\sigma = 3 pixels$')

plt.show()

enter image description here

43
Joe Kington

Ein einfacher Hochpassfilter ist:

-1 -1 -1
-1  8 -1
-1 -1 -1

Der Sobel-Operator ist ein weiteres einfaches Beispiel.

In der Bildverarbeitung werden diese Arten von Filtern häufig als "Kantendetektoren" bezeichnet - die Wikipedia-Seite war bei diesem letzten Mal in Ordnung, als ich nachgesehen habe.

4
Martin Thompson

scipy.filter enthält eine große Anzahl generischer Filter. Etwas wie die Klasse iirfilter kann so konfiguriert werden, dass die typischen digitalen oder analogen Hochpassfilter von Chebyshev oder Buttworth erzielt werden.

1
talonmies

So erstellen wir einen HPF mit scipy fftpack

from skimage.io import imread
import matplotlib.pyplot as plt
import scipy.fftpack as fp

im = np.mean(imread('../images/lena.jpg'), axis=2) # assuming an RGB image
plt.figure(figsize=(10,10))
plt.imshow(im, cmap=plt.cm.gray)
plt.axis('off')
plt.show()

Originalbild

 enter image description here

F1 = fftpack.fft2((im).astype(float))
F2 = fftpack.fftshift(F1)
plt.figure(figsize=(10,10))
plt.imshow( (20*np.log10( 0.1 + F2)).astype(int), cmap=plt.cm.gray)
plt.show()

Frequenzspektrum mit FFT

 enter image description here

(w, h) = im.shape
half_w, half_h = int(w/2), int(h/2)

# high pass filter
n = 25
F2[half_w-n:half_w+n+1,half_h-n:half_h+n+1] = 0 # select all but the first 50x50 (low) frequencies
plt.figure(figsize=(10,10))
plt.imshow( (20*np.log10( 0.1 + F2)).astype(int))
plt.show()

Niedrige Frequenzen im Spektrum blockieren

 enter image description here

im1 = fp.ifft2(fftpack.ifftshift(F2)).real
plt.figure(figsize=(10,10))
plt.imshow(im1, cmap='gray')
plt.axis('off')
plt.show()

Ausgabebild nach dem Anwenden des HPF

 enter image description here

1
Sandipan Dey

Sie können einen Gauß'schen Filter verwenden, da er viel schärfer ist als ein reiner HPF. Bei Verwendung eines einfachen HPF können Sie den folgenden Code verwenden

import numpy as np
import cv2
from scipy import ndimage

class HPF(object):
    def __init__(self, kernel, image):
        self.kernel = np.array(kernel)
        self.image = image

    def process(self):
        return ndimage.convolve(self.image, self.kernel)


if __== "__main__":
    #enter ur image location
    image = cv2.imread("images/test2.jpg", 0)
    kernel3x3 = [[-1,-1,-1],[-1,8,-1],[-1,-1,-1]]
    kernel5x5 = [[-1, -1, -1, -1, -1],
    [-1, 1, 2, 1, -1],
    [-1, 2, 4, 2, -1],
    [-1, 1, 2, 1, -1],
    [-1, -1, -1, -1, -1]]

    hpf1 = HPF(kernel3x3, image)
    hpfimage1 = hpf1.process()
    hpf2 = HPF(kernel5x5, image)
    hpfimage2 = hpf2.process()
    cv2.imshow("3x3",hpfimage1)
    cv2.imshow("5x5",hpfimage2)
    cv2.waitKey()
    cv2.destroyAllWindows()

Um den Gaußschen Filter zu verwenden, fügen Sie einfach die Gaußsche Unschärfe Ihrem Bild hinzu

blurred = cv2.GaussianBlur(image, (11, 11), 0)

Minus es dann vom ursprünglichen Bild

g_hpf = image - blurred

Ursprünglicher Code aus: Bildschärfung durch Hochpassfilter mit Python und OpenCV

0
Mohd Shibli