पायथन में छवि चिकनाई

Question

मैं एक इनपुट छवि को सुचारू बनाने के लिए एक साधारण कार्य लिखने की कोशिश करना चाहता था। मैं छवि और numpy पुस्तकालयों का उपयोग कर ऐसा करने की कोशिश कर रहा था। मैं सोच रहा था कि एक संकल्प मुखौटा का उपयोग इस समस्या का एक दृष्टिकोण होगा और मुझे पता है कि numpy में एक ठोस कार्य है।

मैं छवि को सुचारू बनाने के लिए numpy.convolve का उपयोग कैसे कर सकता हूं?

Answer 1

अच्छा सवाल! tcaswell यहां पोस्ट एक अच्छा सुझाव है, लेकिन आप इस तरह से बहुत कुछ नहीं सीखेंगे क्योंकि scipy आपके लिए सभी काम कर रहा है! चूंकि आपके प्रश्न में कहा गया था कि आप फ़ंक्शन फ़ंक्शन को लिखने और लिखना चाहते हैं, तो मैं आशा करता हूं कि आप इसे उम्मीद में मैन्युअल रूप से समझने के लिए थोड़ा और अधिक कच्चे और बुनियादी प्रकार का तरीका दिखाएंगे कि आप संकल्प आदि के पीछे गणित को बेहतर ढंग से समझेंगे, और फिर आप अपने विचारों और प्रयासों के साथ इसे सुधार सकते हैं!

नोट: आपको अलग-अलग आकार/कर्नेल के आकार के साथ अलग-अलग परिणाम मिलेंगे, एक गॉसियन सामान्य तरीका है लेकिन आप मज़ेदार (कोसाइन, त्रिकोण, इत्यादि) के लिए कुछ अन्य लोगों को आजमा सकते हैं। मैंने बस इसे जगह पर बनाया है, मुझे लगता है कि यह एक प्रकार का पिरामिड आकार वाला है।

import scipy.signal 
import numpy as np 
import matplotlib.pyplot as plt 

im = plt.imread('example.jpg') 
im /= 255. # normalise to 0-1, it's easier to work in float space 

# make some kind of kernel, there are many ways to do this... 
t = 1 - np.abs(np.linspace(-1, 1, 21)) 
kernel = t.reshape(21, 1) * t.reshape(1, 21) 
kernel /= kernel.sum() # kernel should sum to 1! :) 

# convolve 2d the kernel with each channel 
r = scipy.signal.convolve2d(im[:,:,0], kernel, mode='same') 
g = scipy.signal.convolve2d(im[:,:,1], kernel, mode='same') 
b = scipy.signal.convolve2d(im[:,:,2], kernel, mode='same') 

# stack the channels back into a 8-bit colour depth image and plot it 
im_out = np.dstack([r, g, b]) 
im_out = (im_out * 255).astype(np.uint8) 

plt.subplot(2,1,1) 
plt.imshow(im) 
plt.subplot(2,1,2) 
plt.imshow(im_out) 
plt.show() 

Answer 2

आप ndimage पर देखना चाहते हैं, जो scipy में एक मॉड्यूल है। इसमें कई फ़िल्टर फ़ंक्शन के रूप में सेट किए गए हैं, और मनमानी कर्नेल को घुमाने के लिए अच्छे रैपर हैं।

उदाहरण के लिए,

img_gaus = ndimage.filters.gaussian_filter(img, 2, mode='nearest') 

2.

आप एक मनमाना गिरी convolve चाहते हैं की सिग्मा के साथ एक guassian के साथ अपनी छवि convolves, का कहना है कि एक क्रॉस

k = np.array([[0, 1, 0], 
       [1, 1, 1], 
       [0, 1, 0]]) 

img2 = ndimage.convolve(img, k, mode='constant') 

इन कार्यों उच्च आयामों के लिए भी अच्छे हैं, इसलिए आप उच्च आयामों में डेटा को सुचारु बनाने के लिए लगभग समान कोड (केवल अपने कर्नेल के आयाम को स्केल कर सकते हैं) का उपयोग कर सकते हैं।

mode और cval पैरामीटर नियंत्रित करते हैं कि संकल्प आपकी छवि के किनारे पिक्सल के साथ कैसे काम करते हैं (किनारे पर पिक्सेल के लिए, कर्नेल को देखने की आवश्यकता वाले क्षेत्र का आधा हिस्सा मौजूद नहीं है, इसलिए आपको चुनना होगा अपनी छवि को पैड करने के लिए कुछ)।

1) आप के बाद से numpy एक 2D FFT है बदल देती है फूरियर के साथ संयुक्त घुमाव के सिद्धांत का उपयोग करके कर सकते हैं:

Answer 3

आप scipy का उपयोग नहीं करना चाहते, तो आप तीन विकल्प हैं।

2) आप एक अलग करने योग्य कर्नेल का उपयोग कर सकते हैं और फिर आप एक्स-दिशा में एक और दो दिशा में (दो तरंग स्थानांतरित) में दो 1 डी संकल्प कर सकते हैं, और यह वही देगा परिणाम 2 डी संकल्प के रूप में।

3) यदि आपके पास एक छोटा कर्नेल है, तो कहें, 3x3, संकल्प को गुणा और रकम के रूप में लिखना इतना आसान है। यह एक परेशानी की तरह लगता है लेकिन यह इतना बुरा नहीं है।

यदि आप scipy का उपयोग करना चाहते हैं, तो आप ngimage का उपयोग कर सकते हैं, क्योंकि tcaswell सुझाव देता है। scipy भी convolve2 डी है।