OpenCV का उपयोग करके रीयल-टाइम वीडियो स्थिरीकरण कैसे कार्यान्वित करें

वीडियो स्थिरीकरण एक ऐसी तकनीक है जो वीडियो फुटेज में अवांछित गति और झटकों को कम करती है। हैंडहेल्ड शूटिंग, कंपन और गति सभी कैमरे की गति को अस्थिर कर सकते हैं। वीडियो स्थिरीकरण एक सहज दिखने वाला वीडियो तैयार करता है।

वीडियो स्थिरीकरण का प्राथमिक लक्ष्य लगातार फ़्रेमों के बीच कैमरे की गति का अनुमान लगाना है। फिर प्रक्रिया फ़्रेम को संरेखित करने के लिए उचित परिवर्तन लागू कर सकती है। यह कथित हलचल को कम करता है।

अपना वातावरण स्थापित करना

से शुरू एक आभासी वातावरण बनाना यह सुनिश्चित करने के लिए कि प्रोग्राम को चलाने के लिए आपके द्वारा इंस्टॉल किए गए पैकेज मौजूदा पैकेजों के साथ टकराव न करें। फिर आवश्यक लाइब्रेरी स्थापित करने के लिए इस टर्मिनल कमांड को चलाएँ:

पाइप ओपनसीवी-पायथन numpy स्थापित करें

यह कमांड NumPy और OpenCV लाइब्रेरी स्थापित करता है। NumPy संख्यात्मक कार्यों के लिए उपकरण प्रदान करता है जबकि OpenCV कंप्यूटर विज़न कार्यों से संबंधित है।

पूर्ण स्रोत कोड a में उपलब्ध है गिटहब रिपॉजिटरी.

आवश्यक पुस्तकालयों को आयात करना और तीन महत्वपूर्ण कार्यों को परिभाषित करना

एक नई पायथन फ़ाइल बनाएं और इसे अपनी पसंद का नाम दें। स्क्रिप्ट की शुरुआत में NumPy और OpenCV लाइब्रेरी आयात करें।

आयात Numpy जैसा एनपी
आयात सीवी2

इन पुस्तकालयों को आयात करने से आप अपने कोड में उनके कार्यों का उपयोग करने में सक्षम होंगे।

इसके बाद, तीन कार्यों को परिभाषित करें जो स्थिरीकरण प्रक्रिया के लिए महत्वपूर्ण होंगे।

कैलकुलेट_मूविंग_एवरेज फ़ंक्शन

एक फ़ंक्शन बनाएं और उसे नाम दें गणना_चलती_औसत. यह फ़ंक्शन आपके द्वारा निर्दिष्ट त्रिज्या का उपयोग करके दिए गए वक्र की चलती औसत की गणना करेगा। यह एक निर्दिष्ट विंडो आकार और एक समान कर्नेल के साथ एक कनवल्शन ऑपरेशन को नियोजित करता है। यह चलती औसत प्रक्षेपवक्र में उतार-चढ़ाव को सुचारू करने में मदद करती है।

डीईएफ़गणना_चलती_औसत(वक्र, त्रिज्या):
# किसी दिए गए त्रिज्या का उपयोग करके वक्र की गतिमान औसत की गणना करें
 विंडो_आकार = 2 * त्रिज्या + 1
 कर्नेल = np.ones (विंडो_साइज़) / विंडो_साइज़
 कर्व_पैडेड = np.lib.pad (वक्र, (त्रिज्या, त्रिज्या), 'किनारा')
 स्मूथेड_कर्व = np.convolve (वक्र_पैडेड, कर्नेल, मोड ='वही')
 चिकना_वक्र = चिकना_वक्र[त्रिज्या:-त्रिज्या]
वापस करना चिकना_वक्र

फ़ंक्शन एक सहज वक्र लौटाता है। यह वक्र में शोर और उतार-चढ़ाव को कम करने में मदद करता है। यह स्लाइडिंग विंडो के भीतर मानों का औसत निकालकर ऐसा करता है।

स्मूथ_ट्रैजेक्टरी फ़ंक्शन

एक अन्य फ़ंक्शन बनाएं और उसे नाम दें सहज_प्रक्षेप पथ. यह फ़ंक्शन प्रक्षेपवक्र के प्रत्येक आयाम पर चलती औसत को लागू करेगा। यह मूल प्रक्षेपवक्र की एक सुचारु प्रतिलिपि बनाकर इसे प्राप्त करेगा। इससे वीडियो की स्थिरता में और सुधार होगा.

डीईएफ़सहज_प्रक्षेप पथ(प्रक्षेपवक्र):
# प्रत्येक आयाम पर चलती औसत का उपयोग करके प्रक्षेपवक्र को सुचारू करें
 स्मूथेड_ट्रैजेक्टरी = एनपी.कॉपी (प्रक्षेपवक्र)
के लिए मैं में श्रेणी(3):
 स्मूथ_ट्रैजेक्टरी[:, i] = कैलकुलेट_मूविंग_एवरेज(
 प्रक्षेपवक्र[:, i],
 त्रिज्या=SMOOTHING_RADIUS
 )
वापस करना स्मूथ_प्रक्षेपवक्र

सहज_प्रक्षेप पथ फ़ंक्शन एक सुचारु प्रक्षेपवक्र लौटाता है।

फिक्स_बॉर्डर फ़ंक्शन

एक अंतिम फ़ंक्शन बनाएं और उसे नाम दें फिक्स_बॉर्डर. यह फ़ंक्शन रोटेशन और स्केलिंग ट्रांसफ़ॉर्मेशन लागू करके फ़्रेम की सीमा को ठीक करेगा। यह इनपुट फ्रेम लेता है, उसके आकार की गणना करता है, एक परिवर्तन मैट्रिक्स का निर्माण करता है, और फ्रेम में परिवर्तन लागू करता है। अंत में, यह निश्चित फ़्रेम लौटाता है।

डीईएफ़फिक्स_बॉर्डर(चौखटा):
# रोटेशन और स्केलिंग ट्रांसफ़ॉर्मेशन लागू करके फ़्रेम बॉर्डर को ठीक करें
 फ़्रेम_आकार = फ़्रेम.आकार

 मैट्रिक्स = cv2.getRotationMatrix2D(
 (फ़्रेम_आकार[1] / 2, फ़्रेम_आकार[0] / 2),
0,
1.04
 )
 फ्रेम = cv2.warpAffine (फ्रेम, मैट्रिक्स, (frame_shape[1], फ़्रेम_आकार[0]))
वापस करना चौखटा

फिक्स_बॉर्डर फ़ंक्शन यह सुनिश्चित करता है कि स्थिर फ़्रेमों में स्थिरीकरण प्रक्रिया के कारण होने वाली कोई सीमा कलाकृतियाँ न हों।

वीडियो स्थिरीकरण आरंभ करना और इनपुट लेना

उस त्रिज्या को सेट करके प्रारंभ करें जिसका प्रक्षेपवक्र स्मूथिंग फ़ंक्शन उपयोग करेगा।

स्मूथिंग_रेडियस = 50

फिर, उस अस्थिर वीडियो के वीडियो पथ से गुजरें जिसे आप स्थिर करना चाहते हैं।

# इनपुट वीडियो फ़ाइल खोलें
# अपने वेबकैम का उपयोग करने के लिए पथ को 0 से बदलें
कैप = cv2.वीडियो कैप्चर('inputvid.mp4')

अस्थिर वीडियो के गुण प्राप्त करें:

num_frames = int (cap.get (cv2.CAP_PROP_FRAME_COUNT))
चौड़ाई = int (cap.get (cv2.CAP_PROP_FRAME_WIDTH))
ऊँचाई = int (cap.get (cv2.CAP_PROP_FRAME_HEIGHT))
एफपीएस = कैप.गेट (cv2.CAP_PROP_FPS)

आउटपुट स्वरूप सेट करें. यह वह प्रारूप है जिसमें प्रोग्राम स्थिर वीडियो को सहेजेगा। आप कोई भी उपयोग कर सकते हैं सामान्य वीडियो प्रारूप आप चाहते हैं।

चारcc = cv2.VideoWriter_fourcc(*'mp4v')

अंत में, वीडियो लेखक को प्रारंभ करें:

आउट = cv2.वीडियो राइटर('वीडियो_आउट.mp4', फोरसीसी, एफपीएस, (2 * चौड़ाई ऊंचाई))

आपके द्वारा वीडियो लेखक को दिए गए फ़ाइल नाम का एक्सटेंशन वही होना चाहिए जो आपने आउटपुट स्वरूप में सेट किया था।

फ़्रेम पढ़ना और प्रसंस्करण करना

अस्थिर वीडियो को संसाधित करने का पहला चरण यहां से शुरू होता है। इसमें इनपुट वीडियो से फ़्रेम पढ़ना, परिवर्तनों की गणना करना और ट्रांसफ़ॉर्म सरणी को पॉप्युलेट करना शामिल है।

पहला फ्रेम पढ़कर शुरुआत करें।

_, पिछला_फ़्रेम = कैप.रीड()
prev_gray = cv2.cvtColor (prev_frame, cv2.COLOR_BGR2GRAY)

फिर ट्रांसफॉर्मेशन ऐरे को इनिशियलाइज़ करें। यह प्रत्येक फ़्रेम के लिए जानकारी संग्रहीत करेगा.

रूपांतर = np.zeros((num_frames - 1, 3), एनपी.फ्लोट32)

अंत में, आपको लगातार फ़्रेमों के बीच ऑप्टिकल प्रवाह की गणना करने की आवश्यकता है। फिर, बिंदुओं के बीच एफ़िन परिवर्तन का अनुमान लगाएं।

के लिए मैं में रेंज (num_frames - 2):
# लगातार फ़्रेमों के बीच ऑप्टिकल प्रवाह की गणना करें
 prev_points = cv2.goodFeaturesToTrack(
 पिछला_ग्रे,
 अधिकतमकोने=200,
 गुणवत्तास्तर=0.01,
 न्यूनतम दूरी =30,
 ब्लॉक आकार=3
 )
 सफलता, curr_frame = कैप.रीड()
अगरनहीं सफलता:
तोड़ना
 curr_gray = cv2.cvtColor (curr_frame, cv2.COLOR_BGR2GRAY)
 curr_points, स्थिति, err = cv2.calcOpticalFlowPyrLK(
 पिछला_ग्रे,
 curr_धूसर,
 पिछला_बिंदु,
कोई नहीं
 )
ज़ोर prev_points.shape == curr_points.shape
 आईडीएक्स = एनपी.जहां (स्थिति == 1)[0]
 prev_points = prev_points[idx]
 curr_points = curr_points[idx]
# बिंदुओं के बीच एफ़िन परिवर्तन का अनुमान लगाएं
 मैट्रिक्स, _ = cv2.estimateAffine2D(prev_points, curr_points)
 अनुवाद_x = मैट्रिक्स[0, 2]
 अनुवाद_वाई = मैट्रिक्स[1, 2]
 रोटेशन_एंगल = np.arctan2(मैट्रिक्स[1, 0], आव्यूह[0, 0])
 रूपान्तरण[i] = [अनुवाद_x, अनुवाद_y, घूर्णन_कोण]
 prev_gray = curr_gray

परिवर्तनों की गणना करने के लिए लूप प्रत्येक फ्रेम (अंतिम फ्रेम को छोड़कर) पर पुनरावृत्त होता है। यह लुकास-कनाडे विधि का उपयोग करके लगातार फ़्रेमों के बीच ऑप्टिकल प्रवाह की गणना करता है। cv2.goodFeaturesToTrack पिछले फ़्रेम में फ़ीचर बिंदुओं का पता लगाता है पिछला_ग्रे. तब, cv2.calcOpticalFlowPyrLK इन बिंदुओं को वर्तमान फ़्रेम में ट्रैक करता है curr_धूसर.

केवल 1 की स्थिति वाले बिंदु (सफल ट्रैकिंग का संकेत) एक एफ़िन ट्रांसफ़ॉर्मेशन मैट्रिक्स का अनुमान लगाने में मदद करते हैं। कोड अद्यतन करता है पिछला_ग्रे अगले पुनरावृत्ति के लिए वर्तमान ग्रेस्केल फ्रेम के साथ परिवर्तनीय।

प्रक्षेपवक्र को सुचारू करना

स्थिर परिणाम प्राप्त करने के लिए आपको परिवर्तनों से प्राप्त प्रक्षेप पथ को सुचारू करने की आवश्यकता है।

# परिवर्तनों को संचयी रूप से जोड़कर प्रक्षेपवक्र की गणना करें
प्रक्षेपवक्र = np.cumsum (रूपांतरित, अक्ष=0)
# चलती औसत का उपयोग करके प्रक्षेपवक्र को चिकना करें
स्मूथ_ट्रैजेक्टरी = स्मूथ_ट्रैजेक्टरी (प्रक्षेपवक्र)
# सुचारू और मूल प्रक्षेपवक्र के बीच अंतर की गणना करें
अंतर = सुचारू_प्रक्षेपवक्र - प्रक्षेपवक्र
# सहजता प्राप्त करने के लिए अंतर को मूल परिवर्तनों में वापस जोड़ें
#परिवर्तन
रूपांतर_चिकना = रूपांतर + अंतर

उपरोक्त कोड कैमरे की गति के प्रक्षेप पथ की गणना करता है और इसे सुचारू बनाता है।

फ्रेम्स को स्थिर करना और लिखना

अंतिम चरण फ़्रेम को स्थिर करना और स्थिर वीडियो को आउटपुट फ़ाइल में लिखना है।

वीडियो कैप्चर को रीसेट करके प्रारंभ करें। यह सुनिश्चित करता है कि भविष्य के ऑपरेशन वीडियो की शुरुआत से पढ़े जाएंगे।

कैप.सेट (cv2.CAP_PROP_POS_FRAMES, 0)

फिर प्रत्येक फ़्रेम को संसाधित करके वीडियो को स्थिर करें।

# प्रत्येक फ़्रेम को संसाधित करें और वीडियो को स्थिर करें
के लिए मैं में रेंज (num_frames - 2):
 सफलता, फ़्रेम = कैप.रीड()
अगरनहीं सफलता:
तोड़ना
 अनुवाद_x = परिवर्तन_सुचारू[i, 0]
 अनुवाद_y = परिवर्तन_सुचारू[i, 1]
 घूर्णन_कोण = परिवर्तन_चिकना[i, 2]
# स्थिरीकरण के लिए परिवर्तन मैट्रिक्स बनाएं
 परिवर्तन_मैट्रिक्स = np.zeros((2, 3), एनपी.फ्लोट32)
 परिवर्तन_मैट्रिक्स[0, 0] = np.cos (रोटेशन_एंगल)
 परिवर्तन_मैट्रिक्स[0, 1] = -np.sin (रोटेशन_एंगल)
 परिवर्तन_मैट्रिक्स[1, 0] = np.sin (rotation_कोण)
 परिवर्तन_मैट्रिक्स[1, 1] = np.cos (रोटेशन_एंगल)
 परिवर्तन_मैट्रिक्स[0, 2] = अनुवाद_x
 परिवर्तन_मैट्रिक्स[1, 2] = अनुवाद_y
# फ़्रेम को स्थिर करने के लिए परिवर्तन लागू करें
 फ़्रेम_स्थिरीकृत = cv2.warpAffine(
 चौखटा,
 परिवर्तन_मैट्रिक्स,
 (चौड़ाई ऊंचाई)
 )
# स्थिर फ़्रेम की सीमा को ठीक करें
 फ़्रेम_स्थिरीकृत = फ़िक्स_बॉर्डर (फ़्रेम_स्थिरीकृत)
# मूल और स्थिर फ़्रेमों को एक साथ जोड़ें
 फ़्रेम_आउट = cv2.hconcat([फ़्रेम, फ़्रेम_स्थिर])
# यदि फ़्रेम की चौड़ाई 1920 पिक्सेल से अधिक है तो उसका आकार बदलें
अगर फ़्रेम_आउट.आकार[1] > 1920:
 फ़्रेम_आउट = cv2.resize(
 फ़्रेम_आउट,
 (frame_out.shape[1] // 2, फ़्रेम_आउट.आकार[0] // 2)
 )
# पहले और बाद के फ़्रेम प्रदर्शित करें
 cv2.imshow("पहले और बाद में", फ़्रेम_आउट)
 cv2.waitKey(10)
# आउटपुट वीडियो फ़ाइल में फ़्रेम लिखें
 बाहर.लिखें (frame_out)

उपरोक्त कोड अनुवाद और रोटेशन समायोजन सहित गणना किए गए परिवर्तनों का उपयोग करके प्रत्येक फ्रेम को स्थिर करता है। फिर यह तुलना प्रदान करने के लिए स्थिर फ़्रेमों को मूल फ़्रेमों के साथ जोड़ता है।

वीडियो कैप्चर और राइटर जारी करना

वीडियो कैप्चर और राइटर ऑब्जेक्ट जारी करके कार्यक्रम को अंतिम रूप दें।

# वीडियो कैप्चर और राइटर को रिलीज़ करें, और किसी भी खुली हुई विंडो को बंद करें
कैप.रिलीज़()
बाहर.रिलीज़()
cv2.destroyAllWindows()

यह कोड किसी भी खुली हुई विंडो को भी बंद कर देता है।

अंतिम कार्यक्रम आउटपुट

प्रोग्राम का आउटपुट कुछ इस तरह दिखेगा:

और यहाँ स्थिर वीडियो का एक उदाहरण है:

आउटपुट अस्थिर वीडियो और स्थिर वीडियो के बीच तुलना दिखाता है।

ओपनसीवी क्षमताओं का अन्वेषण करें

आप OpenCV को कई क्षेत्रों में लागू कर सकते हैं जिनमें कंप्यूटर विज़न शामिल है। ऐसा इसलिए है क्योंकि यह कार्यक्षमताओं की एक विस्तृत श्रृंखला प्रदान करता है। आपको कंप्यूटर विज़न से जुड़ी अधिक परियोजनाओं पर काम करके इसकी क्षमताओं का पता लगाना चाहिए। यह आपको नई अवधारणाओं से परिचित कराएगा और शोध के लिए नए क्षेत्र देगा।