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

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

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

कोड का उदाहरण

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

इस ऐप्लिकेशन को, अपने iOS ऐप्लिकेशन के लिए शुरुआती पॉइंट के तौर पर इस्तेमाल किया जा सकता है या किसी मौजूदा ऐप्लिकेशन में बदलाव करते समय इसे देखा जा सकता है. जेस्चर आइडेंटिफ़ायर का उदाहरण कोड GitHub पर होस्ट किया जाता है.

कोड डाउनलोड करें

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

उदाहरण कोड डाउनलोड करने के लिए:

1. नीचे दिए गए कमांड का इस्तेमाल करके, गिट रिपॉज़िटरी का क्लोन बनाएं:

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. इसके अलावा, स्पार्स चेकआउट का इस्तेमाल करने के लिए अपना git इंस्टेंस कॉन्फ़िगर करें. ऐसा करने से आपके पास सिर्फ़ हाथ के जेस्चर पहचानने वाले टूल के उदाहरण वाले ऐप्लिकेशन की फ़ाइलें होंगी:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/gesture_recognizer/ios/
   

उदाहरण कोड का स्थानीय वर्शन बनाने के बाद, आप MediaPipe टास्क लाइब्रेरी इंस्टॉल कर सकते हैं, Xcode का इस्तेमाल करके प्रोजेक्ट खोलें और ऐप्लिकेशन चलाएं. निर्देशों के लिए, iOS के लिए सेटअप गाइड देखें.

मुख्य कॉम्पोनेंट

इन फ़ाइलों में 'जेस्चर आइडेंटिफ़ायर' के उदाहरण वाले ऐप्लिकेशन का ज़रूरी कोड मौजूद है:

• GestureRecognizerService.swift: जेस्चर आइडेंटिफ़ायर शुरू करता है, चुने गए मॉडल को हैंडल करता है, और इनपुट डेटा पर अनुमान चलाता है.
• CameraViewController.swift: लाइव कैमरा फ़ीड इनपुट मोड के लिए यूज़र इंटरफ़ेस (यूआई) लागू करता है और नतीजों को विज़ुअलाइज़ करता है.
• MediaLibraryViewController.swift: स्टिल इमेज और वीडियो फ़ाइल के इनपुट मोड के लिए यूज़र इंटरफ़ेस (यूआई) लागू करता है और नतीजों को विज़ुअलाइज़ करता है.

सेटअप

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

डिपेंडेंसी

जेस्चर आइडेंटिफ़ायर MediaPipeTasksVision लाइब्रेरी का इस्तेमाल करता है, जिसे CocoaPods का इस्तेमाल करके इंस्टॉल किया जाना चाहिए. यह लाइब्रेरी, Swift और Objective-C ऐप्लिकेशन, दोनों के साथ काम करती है और इसके लिए अलग से किसी भाषा के सेटअप की ज़रूरत नहीं होती.

macOS पर CocoaPods इंस्टॉल करने के निर्देशों के लिए, CocoaPods को इंस्टॉल करने से जुड़ी गाइड देखें. अपने ऐप्लिकेशन के लिए ज़रूरी पॉड के साथ Podfile बनाने का तरीका जानने के लिए, CocoaPods का इस्तेमाल करना देखें.

नीचे दिए गए कोड का इस्तेमाल करके, Podfile में MediaPipeTasksVision पॉड जोड़ें:

target 'MyGestureRecognizerApp' do
  use_frameworks!
  pod 'MediaPipeTasksVision'
end

अगर आपके ऐप्लिकेशन में यूनिट टेस्ट टारगेट शामिल हैं, तो अपने Podfile को सेट अप करने के बारे में ज़्यादा जानकारी के लिए iOS के लिए सेट अप करने से जुड़ी गाइड देखें.

मॉडल

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

कोई मॉडल चुनें और डाउनलोड करें और Xcode का इस्तेमाल करके उसे अपनी प्रोजेक्ट डायरेक्ट्री में जोड़ें. अपने Xcode प्रोजेक्ट में फ़ाइलें जोड़ने के तरीके से जुड़े निर्देशों के लिए, अपने Xcode प्रोजेक्ट में फ़ाइलें और फ़ोल्डर मैनेज करना देखें.

अपने ऐप्लिकेशन बंडल में मॉडल का पाथ बताने के लिए, BaseOptions.modelAssetPath प्रॉपर्टी का इस्तेमाल करें. कोड के उदाहरण के लिए, अगला सेक्शन देखें.

टास्क बनाएं

जेस्चर आइडेंटिफ़ायर टास्क बनाने के लिए, इसके किसी शुरू करने वाले टूल को कॉल किया जा सकता है. GestureRecognizer(options:) शुरू करने वाला टूल, कॉन्फ़िगरेशन के विकल्पों के लिए वैल्यू स्वीकार करता है.

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

जेस्चर आइडेंटिफ़ायर टास्क में तीन तरह के इनपुट डेटा काम करते हैं: स्टिल इमेज, वीडियो फ़ाइलें, और लाइव वीडियो स्ट्रीम. डिफ़ॉल्ट रूप से, GestureRecognizer(modelPath:) स्टिल इमेज के लिए टास्क शुरू करता है. अगर आपको वीडियो फ़ाइलों या लाइव वीडियो स्ट्रीम को प्रोसेस करने के लिए, टास्क शुरू करना है, तो वीडियो या लाइव स्ट्रीम के रनिंग मोड के बारे में बताने के लिए GestureRecognizer(options:) का इस्तेमाल करें. लाइव स्ट्रीम मोड के लिए, gestureRecognizerLiveStreamDelegate को कॉन्फ़िगर करने के एक और विकल्प की भी ज़रूरत होती है. इससे जेस्चर की पहचान करने वाला टूल, जेस्चर की पहचान करने वाले टूल को प्रतिनिधि को एसिंक्रोनस तरीके से जेस्चर की पहचान करने के नतीजे दे पाता है.

टास्क बनाने और अनुमान लगाने का तरीक़ा जानने के लिए, अपने रनिंग मोड से जुड़ा टैब चुनें.

Swift

import MediaPipeTasksVision

let modelPath = Bundle.main.path(forResource: "gesture_recognizer",
                                      ofType: "task")

let options = GestureRecognizerOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .image
options.minHandDetectionConfidence = minHandDetectionConfidence
options.minHandPresenceConfidence = minHandPresenceConfidence
options.minTrackingConfidence = minHandTrackingConfidence
options.numHands = numHands

let gestureRecognizer = try GestureRecognizer(options: options)
    

import MediaPipeTasksVision

let modelPath = Bundle.main.path(forResource: "gesture_recognizer",
                                      ofType: "task")

let options = GestureRecognizerOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .video
options.minHandDetectionConfidence = minHandDetectionConfidence
options.minHandPresenceConfidence = minHandPresenceConfidence
options.minTrackingConfidence = minHandTrackingConfidence
options.numHands = numHands

let gestureRecognizer = try GestureRecognizer(options: options)
    

import MediaPipeTasksVision

// Class that conforms to the `GestureRecognizerLiveStreamDelegate` protocol and
// implements the method that the gesture recognizer calls once it finishes
// performing recognizing hand gestures in each input frame.
class GestureRecognizerResultProcessor: NSObject, GestureRecognizerLiveStreamDelegate {

  func gestureRecognizer(
    _ gestureRecognizer: GestureRecognizer,
    didFinishRecognition result: GestureRecognizerResult?,
    timestampInMilliseconds: Int,
    error: Error?) {

    // Process the gesture recognizer result or errors here.

  }
}

let modelPath = Bundle.main.path(
  forResource: "gesture_recognizer",
  ofType: "task")

let options = GestureRecognizerOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .liveStream
options.minHandDetectionConfidence = minHandDetectionConfidence
options.minHandPresenceConfidence = minHandPresenceConfidence
options.minTrackingConfidence = minHandTrackingConfidence
options.numHands = numHands

// Assign an object of the class to the `gestureRecognizerLiveStreamDelegate`
// property.
let processor = GestureRecognizerResultProcessor()
options.gestureRecognizerLiveStreamDelegate = processor

let gestureRecognizer = try GestureRecognizer(options: options)
    

Objective-C

@import MediaPipeTasksVision;

NSString *modelPath =
  [[NSBundle mainBundle] pathForResource:@"gesture_recognizer"
                                  ofType:@"task"];

MPPGestureRecognizerOptions *options =
  [[MPPGestureRecognizerOptions alloc] init];
options.baseOptions.modelAssetPath = modelPath;
options.runningMode = MPPRunningModeImage;
options.minHandDetectionConfidence = minHandDetectionConfidence
options.minHandPresenceConfidence = minHandPresenceConfidence
options.minTrackingConfidence = minHandTrackingConfidence
options.numHands = numHands

MPPGestureRecognizer *gestureRecognizer =
      [[MPPGestureRecognizer alloc] initWithOptions:options error:nil];
    

@import MediaPipeTasksVision;

NSString *modelPath =
  [[NSBundle mainBundle] pathForResource:@"gesture_recognizer"
                                  ofType:@"task"];

MPPGestureRecognizerOptions *options =
  [[MPPGestureRecognizerOptions alloc] init];
options.baseOptions.modelAssetPath = modelPath;
options.runningMode = MPPRunningModeVideo;
options.minHandDetectionConfidence = minHandDetectionConfidence
options.minHandPresenceConfidence = minHandPresenceConfidence
options.minTrackingConfidence = minHandTrackingConfidence
options.numHands = numHands

MPPGestureRecognizer *gestureRecognizer =
      [[MPPGestureRecognizer alloc] initWithOptions:options error:nil];
    

@import MediaPipeTasksVision;

// Class that conforms to the `MPPGestureRecognizerLiveStreamDelegate` protocol
// and implements the method that the gesture recognizer calls once it finishes
// performing gesture recognition on each input frame.

@interface APPGestureRecognizerResultProcessor : NSObject 

@end

@implementation APPGestureRecognizerResultProcessor

-   (void)gestureRecognizer:(MPPGestureRecognizer *)gestureRecognizer
    didFinishRecognitionWithResult:(MPPGestureRecognizerResult *)gestureRecognizerResult
           timestampInMilliseconds:(NSInteger)timestampInMilliseconds
                             error:(NSError *)error {

    // Process the gesture recognizer result or errors here.

}

@end

NSString *modelPath =
  [[NSBundle mainBundle] pathForResource:@"gesture_recognizer"
                                  ofType:@"task"];

MPPGestureRecognizerOptions *options =
  [[MPPGestureRecognizerOptions alloc] init];
options.baseOptions.modelAssetPath = modelPath;
options.runningMode = MPPRunningModeLiveStream;
options.minHandDetectionConfidence = minHandDetectionConfidence
options.minHandPresenceConfidence = minHandPresenceConfidence
options.minTrackingConfidence = minHandTrackingConfidence
options.numHands = numHands

// Assign an object of the class to the `gestureRecognizerLiveStreamDelegate`
// property.
APPGestureRecognizerResultProcessor *processor =
  [APPGestureRecognizerResultProcessor new];
options.gestureRecognizerLiveStreamDelegate = processor;

MPPGestureRecognizer *gestureRecognizer =
      [[MPPGestureRecognizer alloc] initWithOptions:options error:nil];
    

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

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

जब रनिंग मोड को लाइव स्ट्रीम पर सेट किया जाता है, तब जेस्चर आइडेंटिफ़ायर को अतिरिक्त gestureRecognizerLiveStreamDelegate कॉन्फ़िगरेशन की ज़रूरत होती है. इससे जेस्चर आइडेंटिफ़ायर, जेस्चर की पहचान करने वाले टूल को एसिंक्रोनस तरीके से, जेस्चर की पहचान करने वाले नतीजे दे पाता है. डेलिगेट को वह gestureRecognizer(_:didFinishRecognition:timestampInMilliseconds:error:) तरीका लागू करना होगा जिसे 'जेस्चर आइडेंटिफ़ायर'र, हर फ़्रेम पर जेस्चर की पहचान करने के नतीजों को प्रोसेस करने के बाद कॉल करता है.

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

जेस्चर आइडेंटिफ़ायर में पास करने से पहले आपको इनपुट इमेज या फ़्रेम को किसी MPImage ऑब्जेक्ट में बदलना होगा. MPImage अलग-अलग तरह के iOS इमेज फ़ॉर्मैट का इस्तेमाल करता है. साथ ही, अनुमान के लिए इन्हें किसी भी रनिंग मोड में इस्तेमाल किया जा सकता है. MPImage के बारे में ज़्यादा जानकारी के लिए, MPImage API देखें

अपने इस्तेमाल के उदाहरण और ऐप्लिकेशन के रनिंग मोड के हिसाब से iOS इमेज फ़ॉर्मैट चुनें.MPImage UIImage, CVPixelBuffer, और CMSampleBuffer iOS इमेज फ़ॉर्मैट स्वीकार करता है.

UIImage

UIImage फ़ॉर्मैट इन रनिंग मोड के लिए बहुत काम का है:

• इमेज: किसी ऐप्लिकेशन बंडल, उपयोगकर्ता गैलरी या फ़ाइल सिस्टम में मौजूद इमेज को UIImage इमेज के तौर पर फ़ॉर्मैट करके, MPImage ऑब्जेक्ट में बदला जा सकता है.

• वीडियो: AVAssetImageGenerator का इस्तेमाल करके वीडियो फ़्रेम को CGImage फ़ॉर्मैट में एक्सट्रैक्ट करें. इसके बाद, उन्हें UIImage इमेज में बदलें.

// Load an image on the user's device as an iOS `UIImage` object.

// Convert the `UIImage` object to a MediaPipe's Image object having the default
// orientation `UIImage.Orientation.up`.
let image = try MPImage(uiImage: image)
    

// Load an image on the user's device as an iOS `UIImage` object.

// Convert the `UIImage` object to a MediaPipe's Image object having the default
// orientation `UIImageOrientationUp`.
MPImage *image = [[MPPImage alloc] initWithUIImage:image error:nil];
    

इस उदाहरण में, MPImage को डिफ़ॉल्ट UIImage.Orientation.Up ओरिएंटेशन के साथ शुरू किया जाता है. MPImage को इस्तेमाल की जा सकने वाली किसी भी UIImage.Orientation वैल्यू के साथ शुरू किया जा सकता है. जेस्चर आइडेंटिफ़ायर, .upMirrored, .downMirrored, .leftMirrored, .rightMirrored जैसे मिरर किए गए ओरिएंटेशन पर काम नहीं करता.

UIImage के बारे में ज़्यादा जानकारी के लिए, UIImage Apple डेवलपर दस्तावेज़ देखें.

CVPixelBuffer

CVPixelBuffer फ़ॉर्मैट, उन ऐप्लिकेशन के लिए बेहद कारगर है जो फ़्रेम जनरेट करते हैं. साथ ही, प्रोसेस करने के लिए iOS CoreImage फ़्रेमवर्क का इस्तेमाल करते हैं.

CVPixelBuffer फ़ॉर्मैट इन रनिंग मोड के लिए बहुत काम का है:

• इमेज: iOS के CoreImage फ़्रेमवर्क का इस्तेमाल करके कुछ प्रोसेसिंग के बाद CVPixelBuffer इमेज जनरेट करने वाले ऐप्लिकेशन, इमेज रनिंग मोड में जेस्चर आइडेंटिफ़ायर को भेजे जा सकते हैं.

• वीडियो: वीडियो फ़्रेम को प्रोसेस करने के लिए, उन्हें CVPixelBuffer फ़ॉर्मैट में बदला जा सकता है. इसके बाद, उन्हें वीडियो मोड में जेस्चर आइडेंटिफ़ायर को भेजा जा सकता है.

• लाइव स्ट्रीम: फ़्रेम जनरेट करने के लिए iOS कैमरे का इस्तेमाल करने वाले ऐप्लिकेशन को लाइव स्ट्रीम मोड में जेस्चर आइडेंटिफ़ायर को भेजे जाने से पहले, प्रोसेस होने के लिए CVPixelBuffer फ़ॉर्मैट में बदला जा सकता है.

// Obtain a CVPixelBuffer.

// Convert the `CVPixelBuffer` object to a MediaPipe's Image object having the default
// orientation `UIImage.Orientation.up`.
let image = try MPImage(pixelBuffer: pixelBuffer)
    

// Obtain a CVPixelBuffer.

// Convert the `CVPixelBuffer` object to a MediaPipe's Image object having the
// default orientation `UIImageOrientationUp`.
MPImage *image = [[MPPImage alloc] initWithUIImage:image error:nil];
    

CVPixelBuffer के बारे में ज़्यादा जानकारी के लिए, CVPixelBuffer Apple डेवलपर दस्तावेज़ देखें.

CMSampleBuffer

CMSampleBuffer फ़ॉर्मैट, एक ही तरह के मीडिया के सैंपल स्टोर करता है. इसका इस्तेमाल लाइव स्ट्रीम के रनिंग मोड में किया जा सकता है. iOS कैमरों के लाइव फ़्रेम, iOS AVCaptureVideoDataOutput पर, CMSampleBuffer फ़ॉर्मैट में एसिंक्रोनस तरीके से डिलीवर किए जाते हैं.

// Obtain a CMSampleBuffer.

// Convert the `CMSampleBuffer` object to a MediaPipe's Image object having the default
// orientation `UIImage.Orientation.up`.
let image = try MPImage(sampleBuffer: sampleBuffer)
    

// Obtain a `CMSampleBuffer`.

// Convert the `CMSampleBuffer` object to a MediaPipe's Image object having the
// default orientation `UIImageOrientationUp`.
MPImage *image = [[MPPImage alloc] initWithSampleBuffer:sampleBuffer error:nil];
    

CMSampleBuffer के बारे में ज़्यादा जानकारी के लिए, CMSampleBuffer Apple डेवलपर दस्तावेज़ देखें.

टास्क चलाएं

जेस्चर आइडेंटिफ़ायर को चलाने के लिए, असाइन किए गए रनिंग मोड के लिए खास recognize() तरीके का इस्तेमाल करें:

• इमेज: recognize(image:)
• वीडियो: recognize(videoFrame:timestampInMilliseconds:)
• लाइवस्ट्रीम: recognizeAsync(image:timestampInMilliseconds:)

नीचे दिए गए कोड सैंपल, इन अलग-अलग रनिंग मोड में जेस्चर आइडेंटिफ़ायर को चलाने के बुनियादी उदाहरण दिखाते हैं:

Swift

let result = try gestureRecognizer.recognize(image: image)
    

let result = try gestureRecognizer.recognize(
  videoFrame: image,
  timestampInMilliseconds: timestamp)
    

try gestureRecognizer.recognizeAsync(
  image: image,
  timestampInMilliseconds: timestamp)
    

Objective-C

  MPPGestureRecognizerResult *result =
    [gestureRecognizer recognizeImage:mppImage
                                error:nil];
    

MPPGestureRecognizerResult *result =
  [gestureRecognizer recognizeVideoFrame:image
                 timestampInMilliseconds:timestamp
                                   error:nil];
    

BOOL success =
  [gestureRecognizer recognizeAsyncImage:image
                 timestampInMilliseconds:timestamp
                                   error:nil];
    

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

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

• वीडियो मोड या लाइव स्ट्रीम मोड में विज्ञापन चलाते समय, आपको जेस्चर आइडेंटिफ़ायर टास्क को इनपुट फ़्रेम का टाइमस्टैंप भी देना होगा.

• इमेज या वीडियो मोड में चलाते समय, जेस्चर आइडेंटिफ़ायर टास्क मौजूदा थ्रेड को तब तक ब्लॉक करता है, जब तक कि वह इनपुट इमेज या फ़्रेम की प्रोसेसिंग पूरी नहीं कर लेता. मौजूदा थ्रेड को ब्लॉक करने से बचने के लिए, iOS Dispatch या NSOperation फ़्रेमवर्क का इस्तेमाल करके, बैकग्राउंड में प्रोसेस करें.

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

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

अनुमान लगाने पर, जेस्चर आइडेंटिफ़ायर टास्क एक GestureRecognizerResult दिखाता है, जिसमें इमेज के निर्देशांक में हैंड लैंडमार्क, दुनिया के निर्देशांकों में हाथ से बने लैंडमार्क, किसी हाथ का जेस्चर(बायां/दायां हाथ), और पता लगाए गए हाथों की जेस्चर की कैटगरी शामिल होती हैं.

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

नतीजे के तौर पर मिले 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)

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