Python के लिए, जेस्चर की पहचान करने वाली गाइड

MediaPipe जेस्चर रेकग्निज़र टास्क की मदद से, रीयल टाइम में हाथ के जेस्चर की पहचान की जा सकती है. साथ ही, इससे हाथ के जेस्चर की पहचान के नतीजे और हाथ के पहचाने गए हिस्सों की जानकारी मिलती है. इन निर्देशों में, Python ऐप्लिकेशन के साथ जेस्चर रेकग्निज़र का इस्तेमाल करने का तरीका बताया गया है.

वेब डिमो देखकर, इस टास्क को काम करते हुए देखा जा सकता है. इस टास्क की सुविधाओं, मॉडल, और कॉन्फ़िगरेशन के विकल्पों के बारे में ज़्यादा जानने के लिए, खास जानकारी देखें.

कोड का उदाहरण

जेस्चर रेकग्निज़र के लिए दिए गए कोड के उदाहरण में, Python में इस टास्क को पूरी तरह से लागू करने का तरीका बताया गया है. इस कोड की मदद से, इस टास्क को टेस्ट किया जा सकता है और हाथ के जेस्चर की पहचान करने वाला अपना मॉडल बनाया जा सकता है. सिर्फ़ वेब ब्राउज़र का इस्तेमाल करके, जेस्चर रेकग्निज़र के उदाहरण के तौर पर दिए गए कोड को देखा, चलाया, और उसमें बदलाव किया जा सकता है.

अगर Raspberry Pi के लिए जेस्चर रिकॉगनाइज़र लागू किया जा रहा है, तो Raspberry Pi के लिए उदाहरण ऐप्लिकेशन देखें.

सेटअप

इस सेक्शन में, खास तौर पर जेस्चर रेकग्निज़र का इस्तेमाल करने के लिए, डेवलपमेंट एनवायरमेंट और कोड प्रोजेक्ट सेट अप करने के मुख्य चरणों के बारे में बताया गया है. MediaPipe Tasks का इस्तेमाल करने के लिए, डेवलपमेंट एनवायरमेंट सेट अप करने के बारे में सामान्य जानकारी पाने के लिए, Python के लिए सेटअप गाइड देखें. इसमें प्लैटफ़ॉर्म के वर्शन से जुड़ी ज़रूरी शर्तें भी शामिल हैं.

पैकेज

MediaPipe जेस्चर पहचानने वाले टास्क के लिए, mediapipe PyPI पैकेज की ज़रूरत होती है. इन डिपेंडेंसी को इनके साथ इंस्टॉल और इंपोर्ट किया जा सकता है:

$ python -m pip install mediapipe

आयात

जेस्चर पहचानने वाले टास्क के फ़ंक्शन ऐक्सेस करने के लिए, ये क्लास इंपोर्ट करें:

import mediapipe as mp
from mediapipe.tasks import python
from mediapipe.tasks.python import vision

मॉडल

MediaPipe जेस्चर पहचानने वाले टास्क के लिए, ट्रेन किए गए मॉडल का बंडल ज़रूरी है, जो इस टास्क के साथ काम करता हो. जेस्चर पहचानने वाले टूल के लिए, पहले से ट्रेन किए गए मॉडल के बारे में ज़्यादा जानने के लिए, टास्क की खास जानकारी वाला मॉडल सेक्शन देखें.

मॉडल चुनें और डाउनलोड करें. इसके बाद, उसे किसी लोकल डायरेक्ट्री में सेव करें:

model_path = '/absolute/path/to/gesture_recognizer.task'

मॉडल के नाम वाले पैरामीटर में, मॉडल का पाथ बताएं, जैसा कि यहां दिखाया गया है:

base_options = BaseOptions(model_asset_path=model_path)

टास्क बनाना

MediaPipe जेस्चर रेकग्निज़र टास्क, टास्क सेट अप करने के लिए create_from_options फ़ंक्शन का इस्तेमाल करता है. create_from_options फ़ंक्शन, कॉन्फ़िगरेशन के विकल्पों को मैनेज करने के लिए वैल्यू स्वीकार करता है. कॉन्फ़िगरेशन के विकल्पों के बारे में ज़्यादा जानने के लिए, कॉन्फ़िगरेशन के विकल्प लेख पढ़ें.

नीचे दिए गए कोड में, इस टास्क को बनाने और कॉन्फ़िगर करने का तरीका बताया गया है.

इन सैंपल में, इमेज, वीडियो फ़ाइलों, और लाइव वीडियो स्ट्रीम के लिए, टास्क बनाने के अलग-अलग तरीके भी दिखाए गए हैं.

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
GestureRecognizer = mp.tasks.vision.GestureRecognizer
GestureRecognizerOptions = mp.tasks.vision.GestureRecognizerOptions
VisionRunningMode = mp.tasks.vision.RunningMode

# Create a gesture recognizer instance with the image mode:
options = GestureRecognizerOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.task'),
    running_mode=VisionRunningMode.IMAGE)
with GestureRecognizer.create_from_options(options) as recognizer:
  # The detector is initialized. Use it here.
  # ...
    

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
GestureRecognizer = mp.tasks.vision.GestureRecognizer
GestureRecognizerOptions = mp.tasks.vision.GestureRecognizerOptions
VisionRunningMode = mp.tasks.vision.RunningMode

# Create a gesture recognizer instance with the video mode:
options = GestureRecognizerOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.task'),
    running_mode=VisionRunningMode.VIDEO)
with GestureRecognizer.create_from_options(options) as recognizer:
  # The detector is initialized. Use it here.
  # ...
    

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
GestureRecognizer = mp.tasks.vision.GestureRecognizer
GestureRecognizerOptions = mp.tasks.vision.GestureRecognizerOptions
GestureRecognizerResult = mp.tasks.vision.GestureRecognizerResult
VisionRunningMode = mp.tasks.vision.RunningMode

# Create a gesture recognizer instance with the live stream mode:
def print_result(result: GestureRecognizerResult, output_image: mp.Image, timestamp_ms: int):
    print('gesture recognition result: {}'.format(result))

options = GestureRecognizerOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.task'),
    running_mode=VisionRunningMode.LIVE_STREAM,
    result_callback=print_result)
with GestureRecognizer.create_from_options(options) as recognizer:
  # The detector is initialized. Use it here.
  # ...
    

कॉन्फ़िगरेशन विकल्प

इस टास्क में, Python ऐप्लिकेशन के लिए ये कॉन्फ़िगरेशन विकल्प हैं:

डेटा तैयार करना

अपने इनपुट को इमेज फ़ाइल या numpy अरे के तौर पर तैयार करें. इसके बाद, उसे mediapipe.Image ऑब्जेक्ट में बदलें. अगर आपका इनपुट, वेबकैम से ली गई वीडियो फ़ाइल या लाइव स्ट्रीम है, तो अपने इनपुट फ़्रेम को numpy ऐरे के तौर पर लोड करने के लिए, OpenCV जैसी किसी बाहरी लाइब्रेरी का इस्तेमाल किया जा सकता है.

import mediapipe as mp

# Load the input image from an image file.
mp_image = mp.Image.create_from_file('/path/to/image')

# Load the input image from a numpy array.
mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=numpy_image)
    

import mediapipe as mp

# Use OpenCV’s VideoCapture to load the input video.

# Load the frame rate of the video using OpenCV’s CV_CAP_PROP_FPS
# You’ll need it to calculate the timestamp for each frame.

# Loop through each frame in the video using VideoCapture#read()

# Convert the frame received from OpenCV to a MediaPipe’s Image object.
mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=numpy_frame_from_opencv)
    

import mediapipe as mp

# Use OpenCV’s VideoCapture to start capturing from the webcam.

# Create a loop to read the latest frame from the camera using VideoCapture#read()

# Convert the frame received from OpenCV to a MediaPipe’s Image object.
mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=numpy_frame_from_opencv)
    

टास्क चलाना

अनुमान लगाने के लिए, जेस्चर पहचानने वाला टूल, recognize, recognize_for_video, और recognize_async फ़ंक्शन का इस्तेमाल करता है. जेस्चर की पहचान करने के लिए, इनपुट डेटा को पहले से प्रोसेस करना, इमेज में हाथों का पता लगाना, हाथ के लैंडमार्क का पता लगाना, और लैंडमार्क से हाथ के जेस्चर की पहचान करना शामिल है.

नीचे दिए गए कोड में, टास्क मॉडल की मदद से प्रोसेसिंग को लागू करने का तरीका बताया गया है.

# Perform gesture recognition on the provided single image.
# The gesture recognizer must be created with the image mode.
gesture_recognition_result = recognizer.recognize(mp_image)
    

# Perform gesture recognition on the provided single image.
# The gesture recognizer must be created with the video mode.
gesture_recognition_result = recognizer.recognize_for_video(mp_image, frame_timestamp_ms)
    

# Send live image data to perform gesture recognition.
# The results are accessible via the `result_callback` provided in
# the `GestureRecognizerOptions` object.
# The gesture recognizer must be created with the live stream mode.
recognizer.recognize_async(mp_image, frame_timestamp_ms)
    

निम्न पर ध्यान दें:

• वीडियो मोड या लाइव स्ट्रीम मोड में चलाने के दौरान, आपको जेस्चर पहचानने वाले टास्क के लिए इनपुट फ़्रेम का टाइमस्टैंप भी देना होगा.
• इमेज या वीडियो मॉडल में चलने पर, जेस्चर पहचानने वाला टास्क, मौजूदा थ्रेड को तब तक ब्लॉक कर देगा, जब तक वह इनपुट इमेज या फ़्रेम को प्रोसेस करना पूरा नहीं कर लेता.
• लाइव स्ट्रीम मोड में चलने पर, जेस्चर (हाव-भाव) की पहचान करने वाला टास्क, मौजूदा थ्रेड को ब्लॉक नहीं करता, बल्कि तुरंत वापस आ जाता है. यह हर बार किसी इनपुट फ़्रेम को प्रोसेस करने के बाद, पहचान के नतीजे के साथ अपने नतीजे सुनने वाले को कॉल करेगा. अगर जेस्चर पहचानने वाले टास्क के किसी फ़्रेम को प्रोसेस करने के दौरान, पहचान करने वाले फ़ंक्शन को कॉल किया जाता है, तो टास्क नए इनपुट फ़्रेम को अनदेखा कर देगा.

किसी इमेज पर जेस्चर रेकग्निज़र को चलाने का पूरा उदाहरण देखने के लिए, ज़्यादा जानकारी के लिए कोड का उदाहरण देखें.

नतीजों को मैनेज और दिखाना

जेस्चर की पहचान करने वाला टूल, पहचान करने के हर चरण के लिए जेस्चर डिटेक्शन का नतीजा ऑब्जेक्ट जनरेट करता है. नतीजे के ऑब्जेक्ट में, इमेज के कोऑर्डिनेट में हाथ के लैंडमार्क, दुनिया के कोऑर्डिनेट में हाथ के लैंडमार्क, हाथ का इस्तेमाल करने वाला व्यक्ति(बायां/दायां हाथ), और हाथ के जेस्चर की कैटगरी शामिल होती है.

यहां इस टास्क के आउटपुट डेटा का उदाहरण दिया गया है:

नतीजे के तौर पर मिले GestureRecognizerResult में चार कॉम्पोनेंट होते हैं. हर कॉम्पोनेंट एक कलेक्शन होता है. इसमें हर एलिमेंट में, हाथ के एक हिस्से का पता लगाने से जुड़ा नतीजा होता है.

• किसी खास हाथ का इस्तेमाल

  इस एट्रिब्यूट से पता चलता है कि पहचाने गए हाथ बाएं हैं या दाएं.

• हाथ के जेस्चर

  हाथों के जेस्चर की पहचान की गई कैटगरी.

• लैंडमार्क

  हाथ के 21 लैंडमार्क हैं. हर लैंडमार्क में x, y, और z कोऑर्डिनेट होते हैं. x और y निर्देशांक को इमेज की चौड़ाई और ऊंचाई के हिसाब से, [0.0, 1.0] पर नॉर्मलाइज़ किया जाता है. z निर्देशांक, लैंडमार्क की गहराई दिखाता है. इसमें कलाई की गहराई को ऑरिजिन माना जाता है. वैल्यू जितनी कम होगी, लैंडमार्क कैमरे के उतना ही करीब होगा. z के मैग्नीट्यूड के लिए, x के स्केल का इस्तेमाल किया जाता है.

• विश्व भू-स्थल

  हाथ के 21 लैंडमार्क, वर्ल्ड कोऑर्डिनेट में भी दिखाए जाते हैं. हर लैंडमार्क, x, y, और z से बना होता है. यह मीटर में, असल दुनिया के 3D कोऑर्डिनेट दिखाता है. इसमें हाथ के ज्यामितीय केंद्र को ऑरिजिन माना जाता है.

GestureRecognizerResult:
  Handedness:
    Categories #0:
      index        : 0
      score        : 0.98396
      categoryName : Left
  Gestures:
    Categories #0:
      score        : 0.76893
      categoryName : Thumb_Up
  Landmarks:
    Landmark #0:
      x            : 0.638852
      y            : 0.671197
      z            : -3.41E-7
    Landmark #1:
      x            : 0.634599
      y            : 0.536441
      z            : -0.06984
    ... (21 landmarks for a hand)
  WorldLandmarks:
    Landmark #0:
      x            : 0.067485
      y            : 0.031084
      z            : 0.055223
    Landmark #1:
      x            : 0.063209
      y            : -0.00382
      z            : 0.020920
    ... (21 world landmarks for a hand)

नीचे दी गई इमेज में, टास्क के आउटपुट को विज़ुअलाइज़ किया गया है:

जेस्चर पहचानने वाले टूल के उदाहरण वाले कोड में, टास्क से मिले पहचाने गए नतीजों को दिखाने का तरीका बताया गया है. ज़्यादा जानकारी के लिए, कोड का उदाहरण देखें.