यह ट्यूटोरियल आपको दिखाएगा कि OpenCV, Python और ImageMagick का उपयोग करके एनिमेटेड GIF कैसे बनाएं। फिर OpenCV के साथ एक मेम जनरेटर बनाने के लिए इन विधियों को संयोजित करें!

हम सभी को समय-समय पर हंसने की जरूरत है। और शायद लुलजा को खोजने का सबसे अच्छा तरीका मेमों के साथ है। मेरे कुछ पसंदीदा:

Krogit मेंढक: "लेकिन यह मेरा व्यवसाय नहीं है"
क्रोधी बिल्ली
महाकाव्य की विफलता
अच्छा आदमी जीजी

लेकिन मेरे लिए व्यक्तिगत रूप से, इनमें से कोई भी मेम "डील विथ इट" मेम ("इसके साथ डील" या "इसे खुद समझें") के साथ तुलना कर सकता है, जिसका एक उदाहरण लेख की शुरुआत में दिया गया है।

यह आमतौर पर निम्नलिखित मामलों में उपयोग किया जाता है:

किसी ऐसे व्यक्ति के लिए जवाब या आपत्ति के रूप में, जो आपके द्वारा किए गए किसी काम को मंजूरी नहीं देता / कहा जाता है ("इसके साथ सौदा")
अपने चश्मे पर रखना मानो आप उस व्यक्ति को समस्या के साथ अकेला छोड़ कर जा रहे हैं ("इसे स्वयं समझें")

कुछ साल पहले मैंने लेखक के ब्लॉग पर एक मजेदार लेख पढ़ा था, जिसे याद नहीं कर सकता कि कंप्यूटर विज़न का उपयोग करके इस तरह के मीम्स कैसे बनाए जा सकते हैं। पिछले हफ्ते मुझे यह गाइड कहीं नहीं मिला, इसलिए एक ब्लॉगर, कंप्यूटर विज़न विशेषज्ञ और मेम पर विशेषज्ञ के रूप में, मैंने खुद एक ट्यूटोरियल लिखने का फैसला किया! (वैसे, अगर आप गलती से मूल स्रोत को जानते हैं, तो कृपया मुझे बताएं ताकि मैं लेखक को धन्यवाद दे सकूं । UPD: बस किर्क कैसर के ब्लॉग MakeArtWithPython से मूल लेख मिला)।

OpenCV पर मेमे जनरेटर विकसित करना हमें कई मूल्यवान व्यावहारिक कौशल सिखाएगा, जिसमें शामिल हैं:

डीप लर्निंग तकनीक का उपयोग करते हुए फेस डिटेक्शन
चेहरे की जगहें का पता लगाने और आंखों के क्षेत्रों को निकालने के लिए dlib लाइब्रेरी का उपयोग करना
प्राप्त जानकारी के आधार पर आंखों के बीच रोटेशन के कोण की गणना कैसे करें
और अंत में, OpenCV का उपयोग करके एनिमेटेड GIF कैसे उत्पन्न करें (ImageMagick से थोड़ी मदद के साथ)

यह मार्गदर्शिका मज़ेदार और मनोरंजक होनी चाहिए - और साथ ही आपको मूल्यवान कंप्यूटर विज़न प्रोग्रामिंग कौशल सिखाएँ जो वास्तविक दुनिया में काम आते हैं।

OpenCV के साथ GIF बनाना

गाइड के पहले भाग में, हम इस परियोजना के लिए आवश्यक परिस्थितियों और निर्भरता पर चर्चा करेंगे, जिसमें विकास पर्यावरण का उचित विन्यास भी शामिल है।

फिर हमारे OpenCV GIF जनरेटर के लिए प्रोजेक्ट / कैटलॉग संरचना पर विचार करें।

जैसे ही हम परियोजना संरचना को समझते हैं, हम विचार करेंगे: 1) हमारी कॉन्फ़िगरेशन फ़ाइल; 2) OpenCV के साथ GIF बनाने के लिए जिम्मेदार पायथन स्क्रिप्ट।

अंत में, हम लोकप्रिय मेम "डील विद इट" पर कार्यक्रम के परिणामों का मूल्यांकन करेंगे।

पूर्वापेक्षाएँ और निर्भरताएँ

अंजीर। 1. हम GIF बनाने के लिए OpenCV, dlib और ImageMagick का उपयोग करेंगे

Opencv और dlib

OpenCV को फ्रेम और बेसिक इमेज प्रोसेसिंग में चेहरे को निर्धारित करने के लिए आवश्यक है। यदि सिस्टम पर OpenCV स्थापित नहीं है, तो मेरे किसी OpenCV इंस्टॉलेशन गाइड का पालन करें।

हम चेहरे की स्थलों का पता लगाने के लिए डेलिब का उपयोग करते हैं, जो हमें चेहरे पर दो आँखें खोजने और धूप का चश्मा लगाने की अनुमति देता है। आप इस निर्देश का उपयोग करके dlib स्थापित कर सकते हैं।

ImageMagick

यदि आप ImageMagick से परिचित नहीं हैं, तो व्यर्थ में। यह एक क्रॉस-प्लेटफ़ॉर्म कमांड लाइन टूल है जिसमें कई इमेज प्रोसेसिंग फीचर्स हैं।

क्या आप PNG / JPG को एक कमांड से PDF में बदलना चाहते हैं? कोई बात नहीं।

कई छवियां हैं जिनसे आपको एक बहु-पृष्ठ पीडीएफ बनाने की आवश्यकता है? आसानी से।

बहुभुज, रेखाओं और अन्य आकृतियों को खींचने की आवश्यकता है? और यह संभव है।

कैसे के बारे में बैच रंग ग्रेडिंग या एक आदेश के साथ सभी चित्रों का आकार बदलने? ऐसा करने के लिए, आपको OpenCV के लिए पायथन में कुछ पंक्तियाँ लिखने की आवश्यकता नहीं है।

ImageMagick किसी भी इमेज से GIF भी बनाता है।

Ubuntu (या रास्पियन) पर ImageMagick स्थापित करने के लिए बस apt का उपयोग करें:

OpenCVShell के साथ GIF बनाना

$ sudo apt-get install imagemagick

MacOS पर, आप HomeBrew का उपयोग कर सकते हैं:

 $ brew install imagemagick

imutils

अधिकांश लेखों, पाठ्यक्रमों और पुस्तकों में, मैं अपने सुविधाजनक imutils छवि प्रसंस्करण पैकेज का उपयोग करता हूं। यह पाइप का उपयोग कर एक सिस्टम या वर्चुअल वातावरण में स्थापित किया गया है:

 $ pip install imutils

परियोजना की संरचना

अंजीर। 2. प्रोजेक्ट संरचना में दो निर्देशिकाएं, एक कॉन्फ़िगरेशन फ़ाइल और एक पायथन स्क्रिप्ट शामिल हैं

हमारी परियोजना में दो कैटलॉग हैं:

images/ : इनपुट छवियों के उदाहरण जिनके लिए हम एक एनिमेटेड GIF बनाना चाहते हैं। मुझे अपने साथ कुछ छवियां मिलीं, लेकिन अपने आप को जोड़ने के लिए स्वतंत्र महसूस करें।
assets/ : इस फ़ोल्डर में हमारा फेस डिटेक्टर, फेस लैंडमार्क डिटेक्टर और सभी चित्र + संबंधित मास्क शामिल हैं। इन परिसंपत्तियों के साथ, हम पहले फ़ोल्डर से मूल चित्रों पर अंक और पाठ डालेंगे।

बड़ी संख्या में विन्यास योग्य मापदंडों के कारण, मैंने JSON कॉन्फ़िगरेशन फ़ाइल बनाने का निर्णय लिया, जो: 1) मापदंडों के संपादन की सुविधा प्रदान करेगा; 2) कम कमांड लाइन तर्क की आवश्यकता होगी। इस परियोजना के लिए आवश्यक सभी विन्यास पैरामीटर config.json में सम्‍मिलित हैं।

config.json और create_gif.py की सामग्री पर विचार करें।

लगभग। प्रति: प्रोजेक्ट कोड और कंप्यूटर विज़न, मशीन लर्निंग और OpenCV पर 17-पेज मैनुअल पंजीकरण के बाद जारी किए जाते हैं (दर्पण: स्रोत कोड , मैनुअल )।

OpenCV के साथ GIF जनरेशन

तो, चलिए जारी रखते हैं और अपना OpenCV GIF जनरेटर बनाना शुरू करते हैं!

JSON कॉन्फ़िगरेशन फ़ाइल सामग्री

आइए JSON कॉन्फ़िगरेशन फ़ाइल से शुरू करें, और फिर पायथन स्क्रिप्ट पर जाएं।

एक नया config.json फ़ाइल खोलें और निम्नलिखित कुंजी / मान जोड़े डालें:

OpenCVPththon के साथ GIF बनाना

 { "face_detector_prototxt": "assets/deploy.prototxt", "face_detector_weights": "assets/res10_300x300_ssd_iter_140000.caffemodel", "landmark_predictor": "assets/shape_predictor_68_face_landmarks.dat",

ये OpenCV फेस डिटेक्टर मॉडल फाइल्स डीप लर्निंग में हैं ।

अंतिम पंक्ति dlib फेस प्रेडिक्टर का मार्ग है।

और अब हमारे पास इमेज फाइल के कुछ रास्ते हैं:

 "sunglasses": "assets/sunglasses.png", "sunglasses_mask": "assets/sunglasses_mask.png", "deal_with_it": "assets/deal_with_it.png", "deal_with_it_mask": "assets/deal_with_it_mask.png",

ये हमारे धूप के चश्मे, पाठ और उनके लिए मेल खाने वाले रास्ते हैं, जो नीचे दिखाए गए हैं।

सबसे पहले, फैंसी धूप का चश्मा और एक मुखौटा:

अंजीर। 3. आपको पिक्सल वाले चश्मे पसंद नहीं हैं? बस इसके साथ रखो

अंजीर। 4. आपको समझ में नहीं आता कि आपको धूप के चश्मे के लिए मास्क की आवश्यकता क्यों है? बस इसके साथ रखो - या उत्तर के लिए बाकी लेख पढ़ें।

और अब हमारा पाठ "आईटी के साथ सौदा" और मुखौटा है:

अंजीर। 5. क्या आप Helvetica Neue Condensed से नफरत करते हैं? इससे निपटो

अंजीर। 6: यह मुखौटा आपको पाठ के चारों ओर एक सीमा खींचने की अनुमति देता है। ओह, शायद आप नहीं चाहते, क्या आप एक सीमा चाहते हैं? ठीक है, इसके साथ रखो

फोटो पर संबंधित छवि को ओवरले करने के लिए मास्क की आवश्यकता होती है: हम बाद में इससे निपटेंगे।

अब मेम जनरेटर के लिए कुछ पैरामीटर सेट करें:

  "min_confidence": 0.5, "steps": 20, "delay": 5, "final_delay": 250, "loop": 0, "temp_dir": "temp" }

यहाँ प्रत्येक पैरामीटर के लिए परिभाषाएँ दी गई हैं:

min_confidence : न्यूनतम आवश्यक चेहरा पहचान संभावना।
steps : अंतिम एनीमेशन में फ़्रेम की संख्या। प्रत्येक "स्टेप" धूप के चश्मे को ऊपरी सीमा से नीचे लक्ष्य (यानी आंखों के लिए) तक ले जाता है।
delay : सेकंड के सौवें हिस्से में फ्रेम के बीच देरी।
final_delay : एक सेकंड के सौवें हिस्से में अंतिम फ्रेम में देरी (इस संदर्भ में उपयोगी, क्योंकि हम चाहते हैं कि पाठ बाकी फ़्रेमों की तुलना में अधिक समय तक प्रदर्शित हो)।
loop : एक शून्य मान इंगित करता है कि जीआईएफ हमेशा के लिए दोहराता है, अन्यथा एनीमेशन के दोहराव की संख्या के लिए एक सकारात्मक पूर्णांक निर्दिष्ट करें।
temp_dir : अंतिम जीआईएफ बनाने से पहले अस्थायी निर्देशिका जिसमें प्रत्येक फ़्रेम संग्रहीत किया जाएगा।

मेम, GIF और OpenCV

हमने JSON कॉन्फ़िगरेशन फ़ाइल बनाई, अब हम वास्तविक कोड पर चलते हैं।

एक नई फ़ाइल खोलें, इसे create_gif.py नाम दें और निम्नलिखित कोड पेस्ट करें:

 #    from imutils import face_utils from imutils import paths import numpy as np import argparse import imutils import shutil import json import dlib import cv2 import sys import os

यहां हम आवश्यक पैकेज आयात करते हैं। विशेष रूप से, हम imutils, dlib और OpenCV का उपयोग करेंगे। इन निर्भरताओं को स्थापित करने के लिए, ऊपर दिए गए पूर्वापेक्षाएँ और निर्भरता अनुभाग देखें।

अब स्क्रिप्ट में आवश्यक पैकेज हैं, तो overlay_image फ़ंक्शन को परिभाषित करते हैं:

 def overlay_image(bg, fg, fgMask, coords): #     (, )  #    (sH, sW) = fg.shape[:2] (x, y) = coords #          #  ,   , **  # ,    overlay = np.zeros(bg.shape, dtype="uint8") overlay[y:y + sH, x:x + sW] = fg # - , **  ** # ,    ,    # ,       alpha = np.zeros(bg.shape[:2], dtype="uint8") alpha[y:y + sH, x:x + sW] = fgMask alpha = np.dstack([alpha] * 3) #  -   , #   - output = alpha_blend(overlay, bg, alpha) #   return output

overlay_image फंक्शन, बैकग्राउंड इमेज ( bg ) के ऊपर fgMask ( निर्देशांक (x, y) ) पर एक अग्रभूमि ( fg ) लगाता है, जो fgMask फोरग्राउंड मास्क पर अल्फा पारदर्शिता का एहसास fgMask है।

ओपनसीवी की मूल बातें से खुद को परिचित करने के लिए, जैसे मास्क के साथ काम करना, इस गाइड को पढ़ना सुनिश्चित करें।

सम्मिश्रण प्रक्रिया को पूरा करने के लिए, अल्फा सम्मिश्रण करें:

 def alpha_blend(fg, bg, alpha): #  ,    - #        [0, 1] fg = fg.astype("float") bg = bg.astype("float") alpha = alpha.astype("float") / 255 #  - fg = cv2.multiply(alpha, fg) bg = cv2.multiply(1 - alpha, bg) #     ,    output = cv2.add(fg, bg) #   return output.astype("uint8")

यह अल्फा ब्लेंडिंग कार्यान्वयन LearnOpenCV ब्लॉग पर भी उपलब्ध है।

संक्षेप में, हम अग्रभूमि, पृष्ठभूमि और अल्फा चैनल को अस्थायी बिंदुओं की सीमा में बदल देंगे [0, 1] । फिर हम अल्फा सम्मिश्रण करते हैं, परिणाम प्राप्त करने के लिए अग्रभूमि और पृष्ठभूमि जोड़ते हैं जो हम कॉलिंग फ़ंक्शन पर लौटते हैं।

हम एक सहायक फ़ंक्शन भी बनाएंगे जो ImageMagick और convert कमांड का उपयोग करके छवि पथों के सेट से GIF बनाने की अनुमति देता है:

 def create_gif(inputPath, outputPath, delay, finalDelay, loop): #        imagePaths = sorted(list(paths.list_images(inputPath))) #      lastPath = imagePaths[-1] imagePaths = imagePaths[:-1] #   imagemagick 'convert'  #  GIF      #   ( ) cmd = "convert -delay {} {} -delay {} {} -loop {} {}".format( delay, " ".join(imagePaths), finalDelay, lastPath, loop, outputPath) os.system(cmd)

create_gif फ़ंक्शन छवियों का एक सेट लेता है और उन्हें फ़्रेम और छोरों के बीच निर्दिष्ट देरी के साथ GIF एनिमेशन में इकट्ठा करता है। ImageMagick यह सब प्रक्रिया करता है - हम केवल एक फ़ंक्शन में convert कमांड को गतिशील रूप से विभिन्न मापदंडों को संसाधित करते हैं।

उपलब्ध convert तर्क देखने के लिए, दस्तावेज़ देखें । वहाँ आप देखेंगे कि इस टीम के कितने कार्य हैं!

इस समारोह में विशेष रूप से, हम:

imagePaths लें।
अंतिम छवि का पथ चुनें, जिसमें एक अलग विलंब होगा।
अंतिम पथ को बाहर करने के लिए imagePaths पुन: असाइन करें।
हम कमांड लाइन तर्कों के साथ एक कमांड को इकट्ठा करते हैं, और फिर ऑपरेटिंग सिस्टम को GIF एनिमेशन बनाने के लिए convert करने का निर्देश देते हैं।

स्क्रिप्ट को अपनी कमांड लाइन तर्क असाइन करें:

 #      ap = argparse.ArgumentParser() ap.add_argument("-c", "--config", required=True, help="path to configuration file") ap.add_argument("-i", "--image", required=True, help="path to input image") ap.add_argument("-o", "--output", required=True, help="path to output GIF") args = vars(ap.parse_args())

हमारे पास तीन कमांड लाइन तर्क हैं जिन्हें रनटाइम पर संसाधित किया जाता है:

--config : JSON कॉन्फ़िगरेशन फ़ाइल का पथ। हमने पिछले अनुभाग में कॉन्फ़िगरेशन फ़ाइल की समीक्षा की।
--image : इनपुट छवि के लिए पथ, जिसके खिलाफ एनीमेशन बनाया गया है (यानी चेहरे का पता लगाना, धूप का चश्मा जोड़ना, और फिर पाठ)।
--output : परिणामस्वरूप GIF के लिए पथ।

कमांड लाइन / टर्मिनल पर स्क्रिप्ट चलाते समय इनमें से प्रत्येक तर्क की आवश्यकता होती है।

कॉन्फ़िगरेशन फ़ाइल, साथ ही चश्मा और संबंधित मास्क डाउनलोड करें:

 #    JSON, #     config = json.loads(open(args["config"]).read()) sg = cv2.imread(config["sunglasses"]) sgMask = cv2.imread(config["sunglasses_mask"]) #    (  ),   #  ,  ,     #   GIF- shutil.rmtree(config["temp_dir"], ignore_errors=True) os.makedirs(config["temp_dir"])

यहां हम कॉन्फ़िगरेशन फ़ाइल लोड करते हैं (जो भविष्य में पायथन डिक्शनरी के रूप में उपलब्ध हो सकती है)। फिर धूप का चश्मा और मुखौटा लोड करें।

यदि पिछली स्क्रिप्ट से कुछ रहता है, तो अस्थायी निर्देशिका हटाएं, और फिर खाली अस्थायी निर्देशिका को फिर से बनाएँ। अस्थायी फ़ोल्डर में जीआईएफ एनीमेशन से प्रत्येक व्यक्तिगत फ्रेम होगा।

अब OpenCV डीप लर्निंग फेस डिटेक्टर को मेमोरी में लोड करें:

 # load our OpenCV face detector and dlib facial landmark predictor print("[INFO] loading models...") detector = cv2.dnn.readNetFromCaffe(config["face_detector_prototxt"], config["face_detector_weights"]) predictor = dlib.shape_predictor(config["landmark_predictor"])

ऐसा करने के लिए, cv2.dnn.readNetFromCaffe कॉल करें। dnn मॉड्यूल केवल OpenCV 3.3 या बाद के संस्करण में उपलब्ध है। एक चेहरा डिटेक्टर छवि में चेहरे की उपस्थिति का पता लगाएगा:

अंजीर। 7. OpenCV DNN का उपयोग करके फेस डिटेक्टर ऑपरेशन

फिर dlib फेस लैंडमार्क प्रेडिक्टर लोड करें। यह आपको व्यक्तिगत संरचनाओं को स्थानीय बनाने की अनुमति देगा: आँखें, भौं, नाक, मुंह और ठोड़ी रेखा:

अंजीर। 8. dlib द्वारा खोजे गए स्थल मेरे चेहरे पर अंकित हैं

बाद में इस स्क्रिप्ट में हम केवल आंख क्षेत्र को निकालते हैं।

चल रहा है, चलो चेहरा मिल:

 #       image = cv2.imread(args["image"]) (H, W) = image.shape[:2] blob = cv2.dnn.blobFromImage(cv2.resize(image, (300, 300)), 1.0, (300, 300), (104.0, 177.0, 123.0)) #        print("[INFO] computing object detections...") detector.setInput(blob) detections = detector.forward() #       ,  #  ,      i = np.argmax(detections[0, 0, :, 2]) confidence = detections[0, 0, i, 2] #    if confidence < config["min_confidence"]: print("[INFO] no reliable faces found") sys.exit(0)

इस ब्लॉक में हम निम्नलिखित कार्य करते हैं:

मूल image डाउनलोड करें।
हम एक तंत्रिका नेटवर्क के फेस डिटेक्टर को भेजने के लिए एक blob का निर्माण करते हैं। यह आलेख बताता है कि OpenCV से blobFromImage कैसे काम करता है।
चेहरा पहचानने की प्रक्रिया करें।
हम उच्चतम संभावना वाले व्यक्ति को पाते हैं और इसकी तुलना न्यूनतम स्वीकार्य संभावना सीमा से करते हैं। यदि मानदंड पूरा नहीं हुआ है, तो स्क्रिप्ट से बाहर निकलें। अन्यथा, जारी रखें।

अब हम चेहरे को निकालेंगे और स्थलों की गणना करेंगे:

 #   (x, y)  #    box = detections[0, 0, i, 3:7] * np.array([W, H, W, H]) (startX, startY, endX, endY) = box.astype("int") #    dlib    #       rect = dlib.rectangle(int(startX), int(startY), int(endX), int(endY)) shape = predictor(image, rect) shape = face_utils.shape_to_np(shape) #        ,  #     (lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"] (rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"] leftEyePts = shape[lStart:lEnd] rightEyePts = shape[rStart:rEnd]

चेहरे को निकालने और चेहरे के स्थान खोजने के लिए, हम निम्नलिखित कार्य करते हैं:

हम चेहरे के चारों ओर बाउंडिंग बॉक्स के निर्देशांक निकालते हैं।
Dlib में एक rectangle वस्तु बनाएँ और चेहरे का स्थानीयकरण लागू करें।
हम क्रमशः leftEyePts और rightEyePts leftEyePts की leftEyePts x (y, निर्देशांक ) को पुनः प्राप्त करते हैं।

आंखों के निर्देशांक को देखते हुए, आप गणना कर सकते हैं कि धूप का चश्मा कहां और कैसे लगाएं:

 #       leftEyeCenter = leftEyePts.mean(axis=0).astype("int") rightEyeCenter = rightEyePts.mean(axis=0).astype("int") #      dY = rightEyeCenter[1] - leftEyeCenter[1] dX = rightEyeCenter[0] - leftEyeCenter[0] angle = np.degrees(np.arctan2(dY, dX)) - 180 #      ,  #      sg = imutils.rotate_bound(sg, angle) #     **  ,    #   —       # 90%       sgW = int((endX - startX) * 0.9) sg = imutils.resize(sg, width=sgW) #      ( ,   #  ),      #     - —   #       , #     sgMask = cv2.cvtColor(sgMask, cv2.COLOR_BGR2GRAY) sgMask = cv2.threshold(sgMask, 0, 255, cv2.THRESH_BINARY)[1] sgMask = imutils.rotate_bound(sgMask, angle) sgMask = imutils.resize(sgMask, width=sgW, inter=cv2.INTER_NEAREST)

सबसे पहले, हम प्रत्येक आंख के केंद्र की गणना करते हैं, फिर सेंट्रोइड्स के बीच का कोण। फ़्रेम में चेहरे के क्षैतिज संरेखण के साथ एक ही ऑपरेशन किया जाता है।

अब आप चश्मे को घुमा और आकार बदल सकते हैं। ध्यान दें कि हम रोटेट_बाउंड फ़ंक्शन का उपयोग करते हैं , न कि केवल rotate , ताकि ओपनसीवी उन भागों को ट्रिम न करें जो कि एफाइन रूपांतरण के बाद दिखाई नहीं देते हैं।

वही ऑपरेशन जो चश्मे पर लगाए गए थे, मास्क पर लागू होते हैं। लेकिन पहले आपको इसे ग्रे और बिनाराइज़ के रंगों में बदलने की आवश्यकता है, क्योंकि मास्क हमेशा द्विआधारी होते हैं। फिर हम उसी तरह से मुखौटे को घुमाते और आकार देते हैं जैसे हमने चश्मे से किया था।

नोट: ध्यान दें कि मास्क का आकार बदलते समय, हम निकटतम पड़ोसी बिंदुओं के लिए प्रक्षेप का उपयोग करते हैं, क्योंकि मास्क में केवल दो मान (0 और 255) होने चाहिए। अन्य प्रक्षेप विधियां अधिक सौंदर्यवादी हैं, लेकिन मास्क के लिए उपयुक्त नहीं हैं। यहां आप निकटतम पड़ोसी बिंदुओं पर प्रक्षेप के बारे में अतिरिक्त जानकारी प्राप्त कर सकते हैं।

कोड के शेष तीन ब्लॉक GIF एनीमेशन के लिए फ्रेम बनाते हैं:

 #    ,   #  N       #    steps = np.linspace(0, rightEyeCenter[1], config["steps"], dtype="int") # start looping over the steps for (i, y) in enumerate(steps): #      #  ,    **    #  ,       #   shiftX = int(sg.shape[1] * 0.25) shiftY = int(sg.shape[0] * 0.35) y = max(0, y - shiftY) # add the sunglasses to the image output = overlay_image(image, sg, sgMask, (rightEyeCenter[0] - shiftX, y))

छवि के ऊपर से चश्मा गिरता है। प्रत्येक फ्रेम पर, उन्हें चेहरे के करीब प्रदर्शित किया जाता है जब तक कि वे अपनी आंखों को कवर नहीं करते। JSON कॉन्फ़िगरेशन फ़ाइल में "steps" चर का उपयोग करते हुए, हम प्रत्येक फ्रेम के लिए y-निर्देशांक उत्पन्न करते हैं। ऐसा करने के लिए, बहुत प्रयास के बिना, हम NumPy से लिंचस्पेस फ़ंक्शन का उपयोग करते हैं।

बाईं और ऊपर की ओर थोड़ी सी बदलाव वाली रेखाएं थोड़ी अजीब लग सकती हैं, लेकिन उन्हें यह सुनिश्चित करने की आवश्यकता है कि चश्मा आंखों को पूरी तरह से कवर करें, और न केवल उस बिंदु पर जाएं जहां आंख का केंद्र है। मैंने प्रत्येक अक्ष के साथ ऑफसेट की गणना करने के लिए अनुभवजन्य रूप से प्रतिशत निर्धारित किया है। अगली पंक्ति कोई नकारात्मक मान सुनिश्चित नहीं करती है।

overlay_image फ़ंक्शन का उपयोग करके, overlay_image अंतिम output फ़्रेम उत्पन्न करते हैं।

अब एक अन्य मुखौटा का उपयोग करके "आईटी के साथ सौदा" पाठ लागू करें:

  #    ,    #  "DEAL WITH IT"   if i == len(steps) - 1: #   "DEAL WITH IT"  , #   dwi = cv2.imread(config["deal_with_it"]) dwiMask = cv2.imread(config["deal_with_it_mask"]) dwiMask = cv2.cvtColor(dwiMask, cv2.COLOR_BGR2GRAY) dwiMask = cv2.threshold(dwiMask, 0, 255, cv2.THRESH_BINARY)[1] #       80%   #  oW = int(W * 0.8) dwi = imutils.resize(dwi, width=oW) dwiMask = imutils.resize(dwiMask, width=oW, inter=cv2.INTER_NEAREST) #  ,   ,  #   oX = int(W * 0.1) oY = int(H * 0.8) output = overlay_image(output, dwi, dwiMask, (oX, oY))

अंतिम चरण में हम पाठ को लागू करते हैं, जो वास्तव में एक और छवि है।

मैंने एक छवि का उपयोग करने का निर्णय लिया क्योंकि OpenCV फोंट की प्रतिपादन क्षमताएं काफी सीमित हैं। इसके अलावा, मैं पाठ के चारों ओर एक छाया और एक सीमा जोड़ना चाहता था, जो फिर से OpenCV नहीं जानता कि कैसे।

इस कोड के बाकी हिस्सों में, हम छवि और मुखौटा दोनों को लोड करते हैं, और फिर अंतिम परिणाम उत्पन्न करने के लिए अल्फा सम्मिश्रण करते हैं।

यह जीआईएफ-एनीमेशन के बाद के निर्माण के साथ प्रत्येक फ्रेम को डिस्क में सहेजने के लिए ही रहता है:

  #      p = os.path.sep.join([config["temp_dir"], "{}.jpg".format( str(i).zfill(8))]) cv2.imwrite(p, output) #      ,     #   GIF- print("[INFO] creating GIF...") create_gif(config["temp_dir"], args["output"], config["delay"], config["final_delay"], config["loop"]) #  --    print("[INFO] cleaning up...") shutil.rmtree(config["temp_dir"], ignore_errors=True)

हम डिस्क पर परिणाम लिखते हैं। सभी फ़्रेमों को बनाने के बाद, हम GIF एनीमेशन फ़ाइल बनाने के लिए create_gif फ़ंक्शन को कॉल करते हैं। याद रखें कि यह एक शेल है जो इमेजमैजिक convert कमांड-लाइन टूल के मापदंडों को पार करता है।

अंत में, अस्थायी आउटपुट निर्देशिका और व्यक्तिगत छवि फ़ाइलों को हटा दें।

परिणाम

अब मज़ेदार हिस्सा: आइए देखें कि हमारे मेम जनरेटर ने क्या बनाया है!

स्रोत कोड, नमूना चित्र और गहन शिक्षण मॉडल डाउनलोड करना सुनिश्चित करें। फिर एक टर्मिनल खोलें और निम्न कमांड चलाएँ:

 $ python create_gif.py --config config.json --image images/adrian.jpg \ --output adrian_out.gif [INFO] loading models... [INFO] computing object detections... [INFO] creating GIF... [INFO] cleaning up...

चित्र 9. इस पायथन स्क्रिप्ट के साथ OpenCV और ImageMagick के साथ उत्पन्न GIF एनीमेशन

यहां आप OpenCV और ImageMagick का उपयोग करके बनाए गए जीआईएफ देख सकते हैं। इस पर निम्न क्रियाएं की जाती हैं:

मेरे चेहरे की सही पहचान।
आंखों का स्थानीयकरण और उनके केंद्रों की गणना।
चेहरे पर सही ढंग से चश्मा पड़ जाता है।

मेरे ब्लॉग के पाठकों को पता है कि मैं जुरासिक पार्क में एक बड़ा बेवकूफ हूं और अक्सर इसका उल्लेख मेरी पुस्तकों, पाठ्यक्रमों और अध्ययन गाइडों में किया जाता है।

जुरासिक पार्क पसंद नहीं है?

ठीक है, यहाँ मेरा जवाब है:

 $ python create_gif.py --config config.json --image images/adrian_jp.jpg \ --output adrian_jp_out.gif [INFO] loading models... [INFO] computing object detections... [INFO] creating GIF... [INFO] cleaning up...

अंजीर। 10. OpenCV GIF एनीमेशन, जुरासिक वर्ल्ड 2 की हालिया स्क्रीनिंग की तस्वीर पर आधारित है

यहां मैं एक विषयगत टी-शर्ट में "जुरासिक वर्ल्ड: 2" शो में एक गिलास प्रकाश और एक संग्रह पुस्तक के साथ हूं।

मजेदार कहानी:

पांच या छह साल पहले, मेरी पत्नी और मैंने डिज्नी वर्ल्ड, फ्लोरिडा में एपकोट सेंटर थीम पार्क का दौरा किया।

हम कनेक्टिकट में कठोर सर्दियों से दूर जाने के लिए एक यात्रा लेने का फैसला किया, और सख्त धूप की जरूरत थी।

दुर्भाग्य से, फ्लोरिडा में हर समय बारिश हुई, और तापमान मुश्किल से 10 डिग्री सेल्सियस से अधिक हो गया।

कैनेडियन गार्डन के पास, तृषा ने मेरी एक तस्वीर ली: वह कहती है कि मैं एक चमड़ी की तरह दिखती हूँ जिसमें पीछे की ओर हरे-भरे बगीचे, काले कपड़े और एक हुड, हरे-भरे बगीचों की पृष्ठभूमि के खिलाफ है:

 $ python create_gif.py --config config.json --image images/vampire.jpg \ --output vampire_out.gif [INFO] loading models... [INFO] computing object detections... [INFO] creating GIF... [INFO] cleaning up...

अंजीर। 11. OpenCV और पायथन का उपयोग करके, आप इस मेम या एक और एनिमेटेड GIF बना सकते हैं

उसी शाम, त्रिशा ने सोशल नेटवर्क पर एक तस्वीर प्रकाशित की - मुझे इसके साथ काम करना था।

आप में से जिन्होंने PyImageConf 2018 में भाग लिया ( समीक्षा पढ़ें ) जानते हैं कि मैं हमेशा चुटकुलों के लिए खुला हूं। यहाँ एक उदाहरण है:

प्रश्न: मुर्गा सड़क पार क्यों करता है?

 $ python create_gif.py --config config.json --image images/rooster.jpg \ --output rooster_out.gif [INFO] loading models... [INFO] computing object detections... [INFO] creating GIF... [INFO] cleaning up...

अंजीर। 12. चेहरा कम विपरीत के साथ भी पहचाना जाता है, और OpenCV फोटो को सही ढंग से संसाधित करता है और धूप का चश्मा कम करता है

उत्तर: मैं इस जवाब को नहीं कहूंगा - इसके साथ रखो।

अंत में, हम एक अच्छे मेम के साथ आज के गाइड का निष्कर्ष निकालते हैं।

लगभग छह साल पहले, मेरे पिता और मैंने एक छोटे से बीगल, जेम्मा को अपनाया।

यहाँ आप मेरे कंधे पर गेमा देख सकते हैं:

 $ python create_gif.py --config config.json --image images/pupper.jpg \ --output pupper_out.gif [INFO] loading models... [INFO] computing object detections... [INFO] creating GIF... [INFO] cleaning up...

अंजीर। 13. गेमा स्वादिष्ट है। क्या आपको ऐसा नहीं लगता? फिर "इसके साथ शर्तों पर आएं!"

सहमत नहीं है कि वह प्यारा है? इससे निपटो।

एक गुण त्रुटि है?

चिंता मत करो!

यदि आपने यह त्रुटि देखी है:

 $ python create_gif.py --config config.json --image images/adrian.jpg \ --output adrian_out.gif ... Traceback (most recent call last): File "create_gif.py", line 142, in <module> (lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"] AttributeError: module 'imutils.face_utils' has no attribute 'FACIAL_LANDMARKS_IDXS'

... तो आपको बस imutils पैकेज को अपडेट करना होगा:

 $ pip install --upgrade imutils Collecting imutils ... Successfully installed imutils-0.5.1

क्यों?

डिफ़ॉल्ट रूप से, यह imutils.face_utilsdlib (इस आलेख में) के रूप में निर्मित 68-बिंदु लैंडमार्क डिटेक्टर का उपयोग करता है। नहीं है एक त्वरित 5 अंकों डिटेक्टर , जो अब भी imutils के साथ काम कर रहा है। मैंने हाल ही में दोनों डिटेक्टरों का समर्थन करने के लिए imutils अपडेट किया है (ताकि आपको एक त्रुटि दिखाई दे)।

सारांश

आज के ट्यूटोरियल में, आपने OpenCV का उपयोग करके GIF बनाना सीखा।

पाठ को मजेदार बनाने के लिए, हमने एक लोकप्रिय मेम (और मेरा पसंदीदा) GIF एनीमेशन "डील विथ इट" उत्पन्न करने के लिए OpenCV का उपयोग किया, जो लगभग हर सोशल नेटवर्किंग साइट पर एक या किसी अन्य रूप में पाया जाता है।

इस प्रक्रिया में, हमने कई व्यावहारिक समस्याओं को हल करने के लिए कंप्यूटर विज़न और गहरी शिक्षा का उपयोग किया:

व्यक्तियों की पहचान
चेहरे पर पूर्वानुमान पूर्वानुमान
चेहरे के क्षेत्रों की पहचान (इस मामले में, आंख)
चेहरे को संरेखित करने के लिए आंखों के बीच के कोण की गणना
अल्फा सम्मिश्रण के साथ पारदर्शी मिश्रण बनाएं

अंत में, हमने उत्पन्न छवियों का एक सेट लिया और OpenCV और ImageMagick का उपयोग करके एक एनिमेटेड GIF बनाया।

मुझे आशा है कि आपको आज का ट्यूटोरियल अच्छा लगा होगा!

अगर आपको यह पसंद आया, तो कृपया एक टिप्पणी छोड़ें और मुझे बताएं।

ठीक है, अगर आप इसे पसंद नहीं करते हैं, तो यह कोई बात नहीं है, बस इसके साथ रखो। ;)

OpenCV के साथ GIF बनाएँ