High-Pass-Filter für die Bildverarbeitung in python mithilfe von scipy/numpy

Ich bin derzeit Studium der Bildverarbeitung. In Scipy, ich weiß, es ist ein median-filter in Scipy.signal. Kann mir jemand sagen ob es einen filter ähnlich wie high-pass-filter?

Danke

InformationsquelleAutor Hold_My_Anger | 2011-05-23

  1. 42

    "High pass filter" ist ein sehr allgemeiner Begriff. Es gibt eine unendliche Anzahl von verschiedenen "highpass-Filter", die die unterschiedlichsten Dinge tun (z.B. ein edge-dectection-filter, wie bereits erwähnt, ist technisch ein highpass (die meisten sind eigentlich ein bandpass-filter), hat aber eine sehr unterschiedliche Wirkung aus, was Sie wohl im Sinn hatte.)

    Jedenfalls auf die meisten der Fragen, die Sie haben zu Fragen, sollten Sie wahrscheinlich Blick in scipy.ndimage statt scipy.filter, vor allem, wenn du wirst arbeiten mit grossen Bildern (ndimage kann Vorform-Operationen, einsparen von Arbeitsspeicher).

    Als ein einfaches Beispiel, das zeigen ein paar verschiedene Möglichkeiten, Dinge zu tun:

    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()

    High-Pass-Filter für die Bildverarbeitung in python mithilfe von scipy/numpy

    Danke für das tolle Skript! Ich lernte eine Menge über convolve() und matplotlib und auch Python. (Ich hatte keine Ahnung, so etwas wie "Handlung.ich" könnte funktionieren.)
    ist das nicht ein Gauß-filter ein low-pass-filter?
    Ja, aber wenn Sie abziehen, die Gauß-Tiefpass aus dem Originalbild, Sie bekommen eine gleichwertige highpass-filter. Das ist es, was bezeichnet wird als "GAUSS-Hochpass". (Haben Sie einen Blick auf die Kommentare über den code für dieses Teil.)
    Angesichts der Rückkehr von convolve, ist es möglich die dx-und dy?

    InformationsquelleAutor Joe Kington

  2. 4

    Einem einfachen high-pass filter:

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

    Den Sobel-operator ist ein weiteres einfaches Beispiel.

    In der Bildverarbeitung diese Art von Filter werden oft als die "edge-detectors" - die Wikipedia-Seite war OK auf das Letzte mal ich überprüft.

    Wahr ist, dass der Laplace-operator wird oft als ein edge-Detektor. Traurig, wirklich, denn das ist es nicht. Es ist wirklich gut bei der Erkennung von Linien und Punkten, die nicht so viel Kanten (wie in: es gibt nicht eine hohe Reaktion an den Rändern, es tendiert zu null werden).

    InformationsquelleAutor Martin Thompson

  3. 1

    scipy.filter enthält eine große Anzahl von generischen Filter. So etwas wie die iirfilter Klasse kann so konfiguriert werden, ergeben die typische Tschebyscheff oder Buttworth digitale oder analoge high-pass-Filter.

    InformationsquelleAutor talonmies

  4. 0

    Hier ist, wie können wir design-ein 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()

    Original Bild

    High-Pass-Filter für die Bildverarbeitung in python mithilfe von scipy/numpy

    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 -

    High-Pass-Filter für die Bildverarbeitung in python mithilfe von scipy/numpy

    (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()

    Blockieren Sie niedrige Frequenzen im Spektrum

    High-Pass-Filter für die Bildverarbeitung in python mithilfe von scipy/numpy

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

    Ausgabe Bild nach der Anwendung des HPF

    High-Pass-Filter für die Bildverarbeitung in python mithilfe von scipy/numpy

    InformationsquelleAutor Sandipan Dey

  5. 0

    Können Sie mit einem Gauß-filter, wie es gibt viel Schärfe, als eine Reine HPF, für die Verwendung einer einfachen HPF Sie können 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 __name__ == "__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()

    Verwendung der Gauß-filter, fügen Sie einfach die Gaußsche Unschärfe auf Ihr Bild

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

    Dann minus vom original Bild

    g_hpf = image - blurred

    Original-code, entnommen aus : Bild Schärfen per Hochpass-Filter mit Python und OpenCV

    InformationsquelleAutor Mohd Shibli

Schreibe einen Kommentar