जवाबों:
एक सामान्य प्रक्रिया विकिपर मास्किंग पर विकिपीडिया लेख में रखी गई है :
आप एक गाऊसी स्मूथिंग फ़िल्टर का उपयोग करते हैं और स्मूथ किए गए संस्करण को मूल छवि से हटाते हैं (भारित तरीके से ताकि एक स्थिर क्षेत्र का मान स्थिर रहे)।
की एक तेज संस्करण प्राप्त करने के लिए frameमें image: (दोनों cv::Mat)
cv::GaussianBlur(frame, image, cv::Size(0, 0), 3);
cv::addWeighted(frame, 1.5, image, -0.5, 0, image);
वहाँ पैरामीटर कुछ आप अपने लिए समायोजित करने की आवश्यकता है।
वहाँ भी लाप्लासियन शार्पनिंग है, आपको उस पर कुछ खोजना चाहिए जब आप Google।
आप एक साधारण कर्नेल और फ़िल्टर 2 डी फ़ंक्शन की कोशिश कर सकते हैं , जैसे कि पायथन में:
kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
im = cv2.filter2D(im, -1, kernel)
विकिपीडिया में कुछ और उदाहरणों के साथ गुठली का अच्छा अवलोकन है - https://en.wikipedia.org/wiki/Kernel_(image_processing)
इमेज प्रोसेसिंग में, एक कर्नेल, कनवल्शन मैट्रिक्स या मास्क एक छोटा मैट्रिक्स होता है। इसका उपयोग धुंधलापन, तेज करने, उभारने, धार का पता लगाने और बहुत कुछ करने के लिए किया जाता है। यह एक कर्नेल और एक छवि के बीच एक कनविक्शन करके पूरा किया जाता है।
आप OpenCV डॉक्यूमेंटेशन में "अनशर मास्क" एल्गोरिदम का उपयोग करके छवि को तेज करने के बारे में एक नमूना कोड पा सकते हैं ।
के मूल्यों को बदलने sigma, threshold, amountअलग परिणाम दे देंगे।
// sharpen image using "unsharp mask" algorithm
Mat blurred; double sigma = 1, threshold = 5, amount = 1;
GaussianBlur(img, blurred, Size(), sigma, sigma);
Mat lowContrastMask = abs(img - blurred) < threshold;
Mat sharpened = img*(1+amount) + blurred*(-amount);
img.copyTo(sharpened, lowContrastMask);
आप एक अनशर मास्क का उपयोग करके एक छवि को तेज कर सकते हैं । आप यहां अनशेप मास्किंग के बारे में अधिक जानकारी पा सकते हैं । और यहाँ OpenCV का उपयोग करके पायथन कार्यान्वयन है:
import cv2 as cv
import numpy as np
def unsharp_mask(image, kernel_size=(5, 5), sigma=1.0, amount=1.0, threshold=0):
"""Return a sharpened version of the image, using an unsharp mask."""
blurred = cv.GaussianBlur(image, kernel_size, sigma)
sharpened = float(amount + 1) * image - float(amount) * blurred
sharpened = np.maximum(sharpened, np.zeros(sharpened.shape))
sharpened = np.minimum(sharpened, 255 * np.ones(sharpened.shape))
sharpened = sharpened.round().astype(np.uint8)
if threshold > 0:
low_contrast_mask = np.absolute(image - blurred) < threshold
np.copyto(sharpened, image, where=low_contrast_mask)
return sharpened
def example():
image = cv.imread('my-image.jpg')
sharpened_image = unsharp_mask(image)
cv.imwrite('my-sharpened-image.jpg', sharpened_image)
amountबस तेज करने की मात्रा है। उदाहरण के लिए, amount1.0 के डिफ़ॉल्ट मान की तुलना में 2.0 में से एक तेज छवि देता है। thresholdकम विपरीत मुखौटा के लिए दहलीज है। दूसरे शब्दों में, जिन पिक्सल के लिए इनपुट और धुंधली छवियों के बीच का अंतर कम है threshold, वे अपरिवर्तित रहेंगे।
कोई भी छवि विभिन्न आवृत्तियों के संकेतों का एक संग्रह है। उच्च आवृत्तियाँ किनारों को नियंत्रित करती हैं और निम्न आवृत्तियाँ छवि सामग्री को नियंत्रित करती हैं। किनारों का निर्माण तब होता है जब एक पिक्सेल मान से दूसरे पिक्सेल मान जैसे 0 और 255 में आसन्न सेल में एक तेज संक्रमण होता है। स्पष्ट रूप से एक तेज बदलाव है और इसलिए बढ़त और उच्च आवृत्ति है। एक छवि को तेज करने के लिए इन बदलावों को और बढ़ाया जा सकता है।
एक तरीका छवि के साथ स्व-निर्मित फ़िल्टर कर्नेल को समझाने का है।
import cv2
import numpy as np
image = cv2.imread('images/input.jpg')
kernel = np.array([[-1,-1,-1],
[-1, 9,-1],
[-1,-1,-1]])
sharpened = cv2.filter2D(image, -1, kernel) # applying the sharpening kernel to the input image & displaying it.
cv2.imshow('Image Sharpening', sharpened)
cv2.waitKey(0)
cv2.destroyAllWindows()
इसके उज्ज्वल संस्करण से छवि के धुंधले संस्करण को घटाने का एक और तरीका है। यह छवि को तेज करने में मदद करता है। लेकिन सावधानी के साथ किया जाना चाहिए क्योंकि हम सिर्फ पिक्सेल मूल्यों को बढ़ा रहे हैं। एक स्केल पिक्सेल मूल्य 190 की कल्पना करें, जिसे 2 के वजन से गुणा करने पर 380 बनता है, लेकिन अधिकतम स्वीकार्य पिक्सेल रेंज के कारण इसे 255 पर ट्रिम किया जाता है। यह जानकारी की हानि है और छवि को धोया जाता है।
addWeighted(frame, 1.5, image, -0.5, 0, image);इस विषय में स्पष्टता के लिए, कुछ बिंदुओं को वास्तव में बनाया जाना चाहिए:
छवियों को तेज करना एक बीमार समस्या है। दूसरे शब्दों में, धुंधलापन एक नुकसानदायक ऑपरेशन है, और इससे वापस जाना सामान्य रूप से संभव नहीं है।
एकल छवियों को तेज करने के लिए, आपको किसी तरह की बाधाओं (मान्यताओं) को जोड़ने की जरूरत है कि आप किस तरह की छवि चाहते हैं, और यह कैसे धुंधला हो गया है। यह प्राकृतिक छवि आंकड़ों का क्षेत्र है। इन आंकड़ों को धारदार तरीके से या उनके एल्गोरिदम में स्पष्ट रूप से धारित करने के दृष्टिकोण (गहरी शिक्षा सबसे निहित कोडित होने के नाते)। डीओजी या लाप्लासियन पिरामिड अपघटन के कुछ स्तरों के अप-वेटिंग का सामान्य दृष्टिकोण , जो कि ब्रायन बर्न्स के जवाब का सामान्यीकरण है, मानता है कि एक गाऊसी धुंधला छवि को दूषित करता है, और भार कैसे किया जाता है, इस पर मान्यताओं से जुड़ा है के साथ शुरू करने के लिए छवि में।
सूचना के अन्य स्रोत अच्छी तरह से पेश किए गए समस्या को तेज कर सकते हैं। जानकारी के ऐसे सामान्य स्रोत एक चलती हुई वस्तु या बहु-दृश्य सेटिंग का वीडियो है। उस सेटिंग में पैनापन आमतौर पर सुपर-रिज़ॉल्यूशन कहा जाता है (जो इसके लिए एक बहुत बुरा नाम है, लेकिन यह अकादमिक सर्कल में फंस गया है)। हुई है OpenCV में सुपर संकल्प तरीकों एक लंबे समय के बाद से .... हालांकि वे आम तौर पर न काम है कि अच्छी तरह के लिए वास्तविक समस्याओं पिछले मैं उन्हें बाहर की जाँच की। मुझे उम्मीद है कि गहरी शिक्षा ने यहाँ भी कुछ अद्भुत परिणाम उत्पन्न किए हैं। हो सकता है कि कोई व्यक्ति उस टिप्पणी पर पोस्ट करेगा जो वहां से योग्य है।
एक छवि को तेज करने के लिए हम फ़िल्टर का उपयोग कर सकते हैं (पिछले कई उत्तरों में)
kernel = np.array([[-1, -1, -1],[-1, 8, -1],[-1, -1, 0]], np.float32)
kernel /= denominator * kernel
यह सबसे अधिक होगा जब भाजक 1 होगा और वृद्धि के रूप में घटेगा (2.3 ..)
सबसे अधिक उपयोग किया जाता है जब हर 3 होता है।
नीचे कार्यान्वयन है।
kernel = np.array([[-1, -1, -1],[-1, 8, -1],[-1, -1, 0]], np.float32)
kernel = 1/3 * kernel
dst = cv2.filter2D(image, -1, kernel)