XR_EXT_spatial_marker_tracking

Name String

XR_EXT_spatial_marker_tracking

एक्सटेंशन का टाइप

इंस्टेंस एक्सटेंशन

रजिस्टर किया गया एक्सटेंशन नंबर

744

बदलाव

1

पुष्टि की स्थिति

मंज़ूरी दी गई

एक्सटेंशन और वर्शन डिपेंडेंसी

XR_EXT_spatial_entity

योगदान देने वाले

रॉन बेसेम्स, Meta
निहाव जैन, Google
नताली फ़्ल्यूरी, Meta
यूइची तागुची, Meta
यिन ली, Microsoft
जिमी आलमपरमबिल, ByteDance
ज़ीपेंग लियू, ByteDance
जून यान, ByteDance

खास जानकारी

यह एक्सटेंशन XR_EXT_spatial_entity पर आधारित है. इसकी मदद से, ऐप्लिकेशन अपने आस-पास के मार्कर का पता लगा सकते हैं और उन्हें ट्रैक कर सकते हैं. मार्कर, 2D कोड होते हैं. इनमें क्यूआर कोड, माइक्रो क्यूआर कोड, ArUco मार्कर या AprilTags शामिल हो सकते हैं.

ट्रैक किए गए मार्कर को एक स्पेशल एंटिटी के तौर पर दिखाया जाता है. इसमें ये कॉम्पोनेंट होते हैं:

  • XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT
  • XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT

रनटाइम से जुड़ी सहायता

रनटाइम को xrEnumerateSpatialCapabilitiesEXT का इस्तेमाल करके, मार्कर ट्रैकिंग की अलग-अलग सुविधाओं के लिए अपने सपोर्ट का विज्ञापन ज़रूर करना चाहिए. इसके लिए, इनमें से किसी भी सुविधा को लिस्ट करना होगा:

  • XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT
  • XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT
  • XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT
  • XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT

कॉन्फ़िगरेशन

किसी मार्कर टाइप का पता लगाने की सुविधा चालू करने के लिए, ऐप्लिकेशन को xrCreateSpatialContextAsyncEXT को उससे जुड़ा कॉन्फ़िगरेशन स्ट्रक्चर पास करना होगा .

मार्कर टाइप कॉन्फ़िगरेशन

क्यूआर कोड

XrSpatialCapabilityConfigurationQrCodeEXT स्ट्रक्चर को इस तरह से तय किया गया है:

typedef struct XrSpatialCapabilityConfigurationQrCodeEXT {
    XrStructureType                     type;
    const void*                         next;
    XrSpatialCapabilityEXT              capability;
    uint32_t                            enabledComponentCount;
    const XrSpatialComponentTypeEXT*    enabledComponents;
} XrSpatialCapabilityConfigurationQrCodeEXT;

सदस्यों की जानकारी

  • type, इस स्ट्रक्चर का XrStructureType है.
  • next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
  • capability की वैल्यू XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT होनी चाहिए.
  • enabledComponentCount एक uint32_t है, जिसमें enabledComponents एलिमेंट हैं.
  • enabledComponents, कॉम्पोनेंट की कैटगरी का एक पॉइंटर है. इसका इस्तेमाल, इस सुविधा को चालू करने के लिए किया जाता है.

अगर क्यूआर कोड इस्तेमाल किए जा सकते हैं, तो xrCreateSpatialContextAsyncEXT को कॉल करते समय, XrSpatialContextCreateInfoEXT :: capabilityConfigs में XrSpatialCapabilityConfigurationQrCodeEXT स्ट्रक्चर पास होने पर, रनटाइम को क्यूआर कोड ट्रैकिंग की सुविधा ज़रूर चालू करनी चाहिए.

अगर xrEnumerateSpatialCapabilitiesEXT ने XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT को एन्यूमेरेटर नहीं किया है, तो रनटाइम को XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT दिखाना चाहिए.

सही इस्तेमाल (इंप्लिसिट)

माइक्रो क्यूआर कोड

XrSpatialCapabilityConfigurationMicroQrCodeEXT स्ट्रक्चर को इस तरह से तय किया गया है:

typedef struct XrSpatialCapabilityConfigurationMicroQrCodeEXT {
    XrStructureType                     type;
    const void*                         next;
    XrSpatialCapabilityEXT              capability;
    uint32_t                            enabledComponentCount;
    const XrSpatialComponentTypeEXT*    enabledComponents;
} XrSpatialCapabilityConfigurationMicroQrCodeEXT;

सदस्यों की जानकारी

  • type, इस स्ट्रक्चर का XrStructureType है.
  • next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
  • capability की वैल्यू XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT होनी चाहिए.
  • enabledComponentCount एक uint32_t है, जिसमें enabledComponents एलिमेंट हैं.
  • enabledComponents, कॉम्पोनेंट की कैटगरी का एक पॉइंटर है. इसका इस्तेमाल, इस सुविधा को चालू करने के लिए किया जाता है.

अगर माइक्रो क्यूआर कोड इस्तेमाल किए जा सकते हैं, तो xrCreateSpatialContextAsyncEXT को कॉल करते समय, XrSpatialContextCreateInfoEXT :: capabilityConfigs में XrSpatialCapabilityConfigurationMicroQrCodeEXT स्ट्रक्चर पास होने पर, रनटाइम को माइक्रो क्यूआर कोड ट्रैकिंग की सुविधा ज़रूर चालू करनी चाहिए.

अगर xrEnumerateSpatialCapabilitiesEXT ने XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT को एन्यूमेरेटर नहीं किया है, तो रनटाइम को XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT दिखाना चाहिए.

सही इस्तेमाल (इंप्लिसिट)

ArUco मार्कर

XrSpatialCapabilityConfigurationArucoMarkerEXT स्ट्रक्चर को इस तरह से तय किया गया है:

typedef struct XrSpatialCapabilityConfigurationArucoMarkerEXT {
    XrStructureType                     type;
    const void*                         next;
    XrSpatialCapabilityEXT              capability;
    uint32_t                            enabledComponentCount;
    const XrSpatialComponentTypeEXT*    enabledComponents;
    XrSpatialMarkerArucoDictEXT         arUcoDict;
} XrSpatialCapabilityConfigurationArucoMarkerEXT;

सदस्यों की जानकारी

  • type, इस स्ट्रक्चर का XrStructureType है.
  • next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
  • capability की वैल्यू XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT होनी चाहिए.
  • enabledComponentCount एक uint32_t है, जिसमें enabledComponents एलिमेंट हैं.
  • enabledComponents, कॉम्पोनेंट की कैटगरी का एक पॉइंटर है. इसका इस्तेमाल, इस सुविधा को चालू करने के लिए किया जाता है.
  • arUcoDict, मार्कर डिक्शनरी है, जिसका पता लगाना है.

अगर ArUco मार्कर काम करते हैं, तो xrCreateSpatialContextAsyncEXT को कॉल करते समय, XrSpatialContextCreateInfoEXT :: capabilityConfigs में XrSpatialCapabilityConfigurationArucoMarkerEXT स्ट्रक्चर पास होने पर, रनटाइम को ArUco मार्कर ट्रैकिंग चालू करनी चाहिए.

अगर XrSpatialCapabilityConfigurationArucoMarkerEXT स्ट्रक्चर, XrSpatialContextCreateInfoEXT :: capabilityConfigs में है, लेकिन XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT को xrEnumerateSpatialCapabilitiesEXT से नहीं गिना गया है, तो रनटाइम को xrCreateSpatialContextAsyncEXT से XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT को ज़रूर दिखाना चाहिए.

सही इस्तेमाल (इंप्लिसिट)

XrSpatialMarkerArucoDictEXT एन्यूमरेशन को इस तरह से तय किया गया है:

typedef enum XrSpatialMarkerArucoDictEXT {
    XR_SPATIAL_MARKER_ARUCO_DICT_4X4_50_EXT = 1,
    XR_SPATIAL_MARKER_ARUCO_DICT_4X4_100_EXT = 2,
    XR_SPATIAL_MARKER_ARUCO_DICT_4X4_250_EXT = 3,
    XR_SPATIAL_MARKER_ARUCO_DICT_4X4_1000_EXT = 4,
    XR_SPATIAL_MARKER_ARUCO_DICT_5X5_50_EXT = 5,
    XR_SPATIAL_MARKER_ARUCO_DICT_5X5_100_EXT = 6,
    XR_SPATIAL_MARKER_ARUCO_DICT_5X5_250_EXT = 7,
    XR_SPATIAL_MARKER_ARUCO_DICT_5X5_1000_EXT = 8,
    XR_SPATIAL_MARKER_ARUCO_DICT_6X6_50_EXT = 9,
    XR_SPATIAL_MARKER_ARUCO_DICT_6X6_100_EXT = 10,
    XR_SPATIAL_MARKER_ARUCO_DICT_6X6_250_EXT = 11,
    XR_SPATIAL_MARKER_ARUCO_DICT_6X6_1000_EXT = 12,
    XR_SPATIAL_MARKER_ARUCO_DICT_7X7_50_EXT = 13,
    XR_SPATIAL_MARKER_ARUCO_DICT_7X7_100_EXT = 14,
    XR_SPATIAL_MARKER_ARUCO_DICT_7X7_250_EXT = 15,
    XR_SPATIAL_MARKER_ARUCO_DICT_7X7_1000_EXT = 16,
    XR_SPATIAL_MARKER_ARUCO_DICT_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialMarkerArucoDictEXT;

पहले से तय की गई ArUco डिक्शनरी, जो काम करती है:

Enumerant Descriptions

  • XR_SPATIAL_MARKER_ARUCO_DICT_4X4_50_EXT — 4 बाई 4 पिक्सल का अरूको मार्कर डिक्शनरी, जिसमें 50 आईडी हैं.
  • XR_SPATIAL_MARKER_ARUCO_DICT_4X4_100_EXT — 100 आईडी वाली 4 x 4 पिक्सल की Aruco मार्कर डिक्शनरी.
  • XR_SPATIAL_MARKER_ARUCO_DICT_4X4_250_EXT — 4 x 4 पिक्सल का Aruco मार्कर डिक्शनरी, जिसमें 250 आईडी हैं.
  • XR_SPATIAL_MARKER_ARUCO_DICT_4X4_1000_EXT — 1,000 आईडी वाली 4x4 पिक्सल की Aruco मार्कर डिक्शनरी.
  • XR_SPATIAL_MARKER_ARUCO_DICT_5X5_50_EXT — 50 आईडी वाली 5 x 5 पिक्सल की Aruco मार्कर डिक्शनरी.
  • XR_SPATIAL_MARKER_ARUCO_DICT_5X5_100_EXT — 100 आईडी वाली 5 x 5 पिक्सल की Aruco मार्कर डिक्शनरी.
  • XR_SPATIAL_MARKER_ARUCO_DICT_5X5_250_EXT — 5 x 5 पिक्सल की Aruco मार्कर डिक्शनरी, जिसमें 250 आईडी हैं.
  • XR_SPATIAL_MARKER_ARUCO_DICT_5X5_1000_EXT — 1,000 आईडी वाली 5 x 5 पिक्सल की Aruco मार्कर डिक्शनरी.
  • XR_SPATIAL_MARKER_ARUCO_DICT_6X6_50_EXT — 50 आईडी वाली 6 x 6 पिक्सल की Aruco मार्कर डिक्शनरी.
  • XR_SPATIAL_MARKER_ARUCO_DICT_6X6_100_EXT — 6 x 6 पिक्सल का Aruco मार्कर डिक्शनरी, जिसमें 100 आईडी हैं.
  • XR_SPATIAL_MARKER_ARUCO_DICT_6X6_250_EXT — 6 x 6 पिक्सल की Aruco मार्कर डिक्शनरी, जिसमें 250 आईडी हैं.
  • XR_SPATIAL_MARKER_ARUCO_DICT_6X6_1000_EXT — 6 x 6 पिक्सल अरूको मार्कर डिक्शनरी, जिसमें 1,000 आईडी हैं.
  • XR_SPATIAL_MARKER_ARUCO_DICT_7X7_50_EXT — 7 x 7 पिक्सल का Aruco मार्कर डिक्शनरी, जिसमें 50 आईडी हैं.
  • XR_SPATIAL_MARKER_ARUCO_DICT_7X7_100_EXT — 7 x 7 पिक्सल का अरूको मार्कर डिक्शनरी, जिसमें 100 आईडी हैं.
  • XR_SPATIAL_MARKER_ARUCO_DICT_7X7_250_EXT — 7 गुणा 7 पिक्सल का अरूको मार्कर डिक्शनरी, जिसमें 250 आईडी हैं.
  • XR_SPATIAL_MARKER_ARUCO_DICT_7X7_1000_EXT — 7 गुणा 7 पिक्सल का अरूको मार्कर डिक्शनरी, जिसमें 1,000 आईडी हैं.
AprilTags

XrSpatialCapabilityConfigurationAprilTagEXT स्ट्रक्चर को इस तरह से तय किया गया है:

typedef struct XrSpatialCapabilityConfigurationAprilTagEXT {
    XrStructureType                     type;
    const void*                         next;
    XrSpatialCapabilityEXT              capability;
    uint32_t                            enabledComponentCount;
    const XrSpatialComponentTypeEXT*    enabledComponents;
    XrSpatialMarkerAprilTagDictEXT      aprilDict;
} XrSpatialCapabilityConfigurationAprilTagEXT;

सदस्यों की जानकारी

  • type, इस स्ट्रक्चर का XrStructureType है.
  • next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
  • capability की वैल्यू XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT होनी चाहिए.
  • enabledComponentCount एक uint32_t है, जिसमें enabledComponents एलिमेंट हैं.
  • enabledComponents, कॉम्पोनेंट की कैटगरी का एक पॉइंटर है. इसका इस्तेमाल, इस सुविधा को चालू करने के लिए किया जाता है.
  • aprilDict, मार्कर डिक्शनरी है, जिसका पता लगाना है.

अगर AprilTags काम करते हैं, तो xrCreateSpatialContextAsyncEXT को कॉल करते समय, XrSpatialContextCreateInfoEXT :: capabilityConfigs में XrSpatialCapabilityConfigurationAprilTagEXT स्ट्रक्चर पास होने पर, रनटाइम को AprilTag ट्रैकिंग चालू करनी चाहिए.

अगर XrSpatialCapabilityConfigurationAprilTagEXT स्ट्रक्चर, XrSpatialContextCreateInfoEXT :: capabilityConfigs में मौजूद है, लेकिन XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT को xrEnumerateSpatialCapabilitiesEXT से नहीं गिना गया है, तो रनटाइम को xrCreateSpatialContextAsyncEXT से XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT दिखाना चाहिए.

सही इस्तेमाल (इंप्लिसिट)

XrSpatialMarkerAprilTagDictEXT एन्यूमरेशन को इस तरह से तय किया गया है:

typedef enum XrSpatialMarkerAprilTagDictEXT {
    XR_SPATIAL_MARKER_APRIL_TAG_DICT_16H5_EXT = 1,
    XR_SPATIAL_MARKER_APRIL_TAG_DICT_25H9_EXT = 2,
    XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H10_EXT = 3,
    XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H11_EXT = 4,
    XR_SPATIAL_MARKER_APRIL_TAG_DICT_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialMarkerAprilTagDictEXT;

पहले से तय की गई AprilTag डिक्शनरी, जो काम करती है:

Enumerant Descriptions

  • XR_SPATIAL_MARKER_APRIL_TAG_DICT_16H5_EXT — 4 x 4 बिट, किन्हीं दो कोड के बीच कम से कम हैमिंग डिस्टेंस = 5, 30 कोड.
  • XR_SPATIAL_MARKER_APRIL_TAG_DICT_25H9_EXT — 5 x 5 बिट, किन्हीं दो कोड के बीच कम से कम हैमिंग डिस्टेंस = 9, 35 कोड.
  • XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H10_EXT — 6 x 6 बिट, किन्हीं दो कोड के बीच कम से कम हैमिंग डिस्टेंस = 10, 2320 कोड.
  • XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H11_EXT — 6 बाई 6 बिट, किन्हीं दो कोड के बीच कम से कम हैमिंग डिस्टेंस = 11, 587 कोड.

मार्कर के लिए वैकल्पिक कॉन्फ़िगरेशन

ऐप्लिकेशन को xrEnumerateSpatialCapabilityFeaturesEXT को कॉल करना चाहिए, ताकि वे इस्तेमाल की जा सकने वाली वैकल्पिक सुविधाओं की सूची पा सकें.

किसी भी एक्सटेंशन के साथ काम करने वाली सभी स्पेशल कैपेबिलिटी सुविधाओं की पूरी सूची देखने के लिए, XrSpatialCapabilityFeatureEXT देखें.

मार्कर का साइज़

XrSpatialMarkerSizeEXT स्ट्रक्चर को इस तरह से तय किया गया है:

typedef struct XrSpatialMarkerSizeEXT {
    XrStructureType    type;
    const void*        next;
    float              markerSideLength;
} XrSpatialMarkerSizeEXT;

सदस्यों की जानकारी

  • type, इस स्ट्रक्चर का XrStructureType है.
  • next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
  • markerSideLength, सभी मार्कर का साइज़ मीटर में है.

अगर किसी क्षमता के लिए, xrEnumerateSpatialCapabilityFeaturesEXT, XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_FIXED_SIZE_MARKERS_EXT को सूची में शामिल करता है और ऐप्लिकेशन, XrSpatialMarkerSizeEXT को उस क्षमता के कॉन्फ़िगरेशन स्ट्रक्चर से जोड़ता है, तो रनटाइम को यह ज़रूर मानना चाहिए कि पहचाने गए सभी मार्कर की चौड़ाई और ऊंचाई markerSideLength है. रनटाइम को यह जानकारी देने से, रनटाइम को ज़्यादा सटीक पोज़ और साइज़ दिखाने में मदद मिलती है. इस स्ट्रक्चर को XrSpatialCapabilityConfigurationQrCodeEXT , XrSpatialCapabilityConfigurationMicroQrCodeEXT , XrSpatialCapabilityConfigurationArucoMarkerEXT या XrSpatialCapabilityConfigurationAprilTagEXT की next चेन से लिंक करना ज़रूरी है .

सही इस्तेमाल (इंप्लिसिट)

स्टैटिक मार्कर ऑप्टिमाइज़ेशन

XrSpatialMarkerStaticOptimizationEXT स्ट्रक्चर को इस तरह से तय किया गया है:

typedef struct XrSpatialMarkerStaticOptimizationEXT {
    XrStructureType    type;
    const void*        next;
    XrBool32           optimizeForStaticMarker;
} XrSpatialMarkerStaticOptimizationEXT;

सदस्यों की जानकारी

  • type, इस स्ट्रक्चर का XrStructureType है.
  • next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
  • optimizeForStaticMarker से पता चलता है कि स्पेस में मौजूद सभी मार्कर के मूव न होने की उम्मीद है या नहीं.

अगर किसी क्षमता के लिए, xrEnumerateSpatialCapabilityFeaturesEXT, XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_STATIC_MARKERS_EXT को शामिल करता है और ऐप्लिकेशन, उस क्षमता के कॉन्फ़िगरेशन स्ट्रक्चर में XrSpatialMarkerStaticOptimizationEXT को जोड़ता है, तो रनटाइम को यह मानना होगा कि पहचाने गए सभी मार्कर स्टैटिक हैं. ऐसा तब होगा, जब optimizeForStaticMarker को XR_TRUE पर सेट किया गया हो. इससे रनटाइम को ज़्यादा सटीक पोज़ और साइज़ जनरेट करने में मदद मिलती है. इस स्ट्रक्चर को XrSpatialCapabilityConfigurationQrCodeEXT , XrSpatialCapabilityConfigurationMicroQrCodeEXT , XrSpatialCapabilityConfigurationArucoMarkerEXT या XrSpatialCapabilityConfigurationAprilTagEXT की next चेन से लिंक करना ज़रूरी है .

सही इस्तेमाल (इंप्लिसिट)

गारंटी वाले कॉम्पोनेंट

XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT , XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT , XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT या XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT के साथ काम करने वाले रनटाइम को, इन क्षमताओं से खोजी गई सभी इकाइयों के गारंटी वाले कॉम्पोनेंट के तौर पर, ये स्पेशल कॉम्पोनेंट उपलब्ध कराने होंगे. साथ ही, उन्हें xrEnumerateSpatialCapabilityComponentTypesEXT में शामिल करना होगा :

  • XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT
  • XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT

मार्कर कॉम्पोनेंट

कॉम्पोनेंट का डेटा

XrSpatialMarkerDataEXT स्ट्रक्चर को इस तरह से तय किया गया है:

typedef struct XrSpatialMarkerDataEXT {
    XrSpatialCapabilityEXT    capability;
    uint32_t                  markerId;
    XrSpatialBufferEXT        data;
} XrSpatialMarkerDataEXT;

सदस्यों की जानकारी

  • capability, XrSpatialCapabilityEXT है, जिसने मार्कर का पता लगाया.
  • markerId, मार्कर से एन्कोड किया गया आइडेंटिफ़ायर है. ArUco मार्कर और AprilTag के लिए, यह फ़ील्ड मान्य होना चाहिए. साथ ही, इसमें एन्कोड किया गया आईडी भरा होना चाहिए. क्यूआर कोड के लिए, इस फ़ील्ड की वैल्यू शून्य होनी चाहिए.
  • data, बफ़र आईडी और मार्कर में मौजूद अतिरिक्त जानकारी का टाइप है.

XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT और XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT में अतिरिक्त डेटा ट्रांसफ़र किया जा सकता है. अगर capability इनमें से कोई एक है -

  • अगर रनटाइम ने मार्कर के लिए डेटा को डिकोड कर लिया है, तो उसे मार्कर में मौजूद डेटा के आधार पर, data बफ़र टाइप को XR_SPATIAL_BUFFER_TYPE_UINT8_EXT या XR_SPATIAL_BUFFER_TYPE_STRING_EXT पर सेट करना चाहिए. रनटाइम को data में एक मान्य बफ़र आईडी भी सेट करना चाहिए. ऐप्लिकेशन, डेटा पाने के लिए सही xrGetSpatialBuffer* फ़ंक्शन के साथ इसका इस्तेमाल कर सकता है.
  • अगर रनटाइम ने अब तक मार्कर के डेटा को डिकोड नहीं किया है, तो उसे data बफ़र आईडी को XR_NULL_SPATIAL_BUFFER_ID_EXT पर और बफ़र टाइप को XR_SPATIAL_BUFFER_TYPE_UNKNOWN_EXT पर सेट करना चाहिए.

XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT और XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT में अतिरिक्त डेटा इस्तेमाल नहीं किया जा सकता. साथ ही, रनटाइम के दौरान data के बफ़र आईडी को XR_NULL_SPATIAL_BUFFER_ID_EXT पर सेट करना ज़रूरी है.

सही इस्तेमाल (इंप्लिसिट)

  • XrSpatialMarkerDataEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_marker_tracking एक्सटेंशन को चालू करना ज़रूरी है
  • capability की वैल्यू, XrSpatialCapabilityEXT की मान्य वैल्यू होनी चाहिए
  • data एक मान्य XrSpatialBufferEXT स्ट्रक्चर होना चाहिए
डेटा के बारे में क्वेरी करने के लिए कॉम्पोनेंट की सूची का स्ट्रक्चर

XrSpatialComponentMarkerListEXT स्ट्रक्चर को इस तरह से तय किया गया है:

typedef struct XrSpatialComponentMarkerListEXT {
    XrStructureType            type;
    void*                      next;
    uint32_t                   markerCount;
    XrSpatialMarkerDataEXT*    markers;
} XrSpatialComponentMarkerListEXT;

सदस्यों की जानकारी

  • type, इस स्ट्रक्चर का XrStructureType है.
  • next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. OpenXR के मुख्य वर्शन या इस एक्सटेंशन में, इस तरह के स्ट्रक्चर के बारे में नहीं बताया गया है.
  • markerCount, markers मेंबर में मौजूद एलिमेंट की संख्या है.
  • markers, XrSpatialMarkerDataEXT का कलेक्शन है.

ऐप्लिकेशन, XrSpatialSnapshotEXT में मौजूद स्पेशल इकाइयों के मार्कर कॉम्पोनेंट के बारे में क्वेरी कर सकता है. इसके लिए, उसे XrSpatialComponentDataQueryConditionEXT :: componentTypes में XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT जोड़ना होगा. साथ ही, XrSpatialComponentDataQueryResultEXT की अगली पॉइंटर चेन में XrSpatialComponentMarkerListEXT जोड़ना होगा.

अगर XrSpatialComponentMarkerListEXT, XrSpatialComponentDataQueryResultEXT :: next की अगली चेन में है, तो रनटाइम को xrQuerySpatialComponentDataEXT से XR_ERROR_VALIDATION_FAILURE को रिटर्न करना चाहिए. हालांकि, XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT को XrSpatialComponentDataQueryConditionEXT :: componentTypes में शामिल नहीं किया गया है.

अगर markerCount, XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput से कम है, तो रनटाइम को xrQuerySpatialComponentDataEXT से XR_ERROR_SIZE_INSUFFICIENT को ज़रूर दिखाना चाहिए.

सही इस्तेमाल (इंप्लिसिट)

  • XrSpatialComponentMarkerListEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_marker_tracking एक्सटेंशन चालू करना ज़रूरी है
  • type की वैल्यू XR_TYPE_SPATIAL_COMPONENT_MARKER_LIST_EXT होनी चाहिए
  • next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
  • markers, markerCount XrSpatialMarkerDataEXT स्ट्रक्चर के कलेक्शन का पॉइंटर होना चाहिए
  • markerCount पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए
कॉन्फ़िगरेशन

अगर किसी क्षमता के लिए, XrSpatialCapabilityComponentTypesEXT :: componentTypes में XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT को शामिल किया गया है, तो कोई ऐप्लिकेशन उसे चालू कर सकता है. इसके लिए, उसे XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents सूची में शामिल करना होगा. यह सूची, इस कॉम्पोनेंट के साथ काम करने वाली क्षमता के XrSpatialCapabilityConfigurationBaseHeaderEXT से बनाए गए स्ट्रक्चर की होती है.

इस कॉम्पोनेंट को XrSpatialCapabilityConfigurationBaseHeaderEXT :: next चेन में शामिल करने के लिए, किसी खास कॉन्फ़िगरेशन की ज़रूरत नहीं होती.

Bounded 2D Component

बाउंडेड 2D कॉम्पोनेंट, मार्कर का सेंटर और एक्सटेंट दिखाता है. यह मार्कर, उस इकाई से दिखाया जाता है जिस पर वह मौजूद होता है. बाउंडेड 2D कॉम्पोनेंट के बारे में ज़्यादा जानने के लिए, बाउंडेड 2D देखें.

XrSpatialBounded2DDataEXT :: center को मार्कर के बीच में पॉइंट करना ज़रूरी है. मार्कर के सामने के हिस्से को देखते समय, X-ऐक्सिस को दाईं ओर और Y-ऐक्सिस को मार्कर के सबसे ऊपर की ओर पॉइंट करना चाहिए. रनटाइम को राइट-हैंडेड कोऑर्डिनेट सिस्टम कन्वेंशन का पालन करना चाहिए. इससे Z-ऐक्सिस, मार्कर के सामने वाले हिस्से से बाहर निकलता है. इसका मतलब है कि {0, 0, 0} पोज़िशन, {0, 0, 0, 1} रोटेशन (कोई रोटेशन नहीं), और {1, 1} एक्सटेंट वाले मार्कर का मतलब है कि 1 मीटर x 1 मीटर का मार्कर, {0, 0, 0} पर मौजूद है. इसका सामने वाला नॉर्मल वेक्टर, कॉम्पोनेंट के स्पेस में +Z दिशा की ओर इशारा करता है.

मार्कर के ओरिएंटेशन को नीचे दिखाया गया है.

एक्सआर एमएल मार्कर अंडरस्टैंडिंग ऐक्सिस

इमेज 25. ऐक्सिस के साथ क्यूआर कोड मार्कर

टेस्ट कोड

इन कोड का X-Y प्लेन, दस्तावेज़ के अंदर होना चाहिए. साथ ही, Z-ऐक्सिस, व्यूअर की तरफ़ होना चाहिए. ऐक्सिस ऑरिजिन, हर मार्कर के बीच में दिखना चाहिए. X-ऐक्सिस दाईं ओर होना चाहिए और Y-ऐक्सिस दस्तावेज़ के सबसे ऊपर होना चाहिए.

ext marker tracking qr

इमेज 26. 'OpenXR' टेक्स्ट वाला क्यूआर कोड

ext marker tracking apriltag

इमेज 27. आईडी 42 वाला AprilTag XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H11_EXT

ext marker tracking aruco

इमेज 28. आईडी 43 वाला ArUco मार्कर XR_SPATIAL_MARKER_ARUCO_DICT_5X5_50_EXT

कोड का उदाहरण

क्यूआर कोड को ट्रैक करने की सुविधा कॉन्फ़िगर करना

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

// Check if marker tracking capability is supported
uint32_t capabilityCount;
CHK_XR(xrEnumerateSpatialCapabilitiesEXT(instance, systemId, 0, &capabilityCount, nullptr));
std::vector<XrSpatialCapabilityEXT> capabilities(capabilityCount);
CHK_XR(xrEnumerateSpatialCapabilitiesEXT(instance, systemId, capabilityCount, &capabilityCount, capabilities.data()));

if (std::find(capabilities.begin(), capabilities.end(), XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT) == capabilities.end()) {
  return;
}

uint32_t featureCount = 0;
CHK_XR(xrEnumerateSpatialCapabilityFeaturesEXT(instance, systemId, XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT, 0, &featureCount, nullptr));
std::vector<XrSpatialCapabilityFeatureEXT> capabilityFeatures(featureCount);
CHK_XR(xrEnumerateSpatialCapabilityFeaturesEXT(instance, systemId, XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT, featureCount, &featureCount, capabilityFeatures.data()));

bool supportsFixedMarkerSize = std::find(capabilityFeatures.begin(), capabilityFeatures.end(), XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_FIXED_SIZE_MARKERS_EXT) != capabilityFeatures.end();

// Create a spatial context
XrSpatialContextEXT spatialContext{};

// Enable the 2 guaranteed components of the qr code tracking capability
std::vector<XrSpatialComponentTypeEXT> enabledComponents = {
  XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT,
  XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT,
};
XrSpatialCapabilityConfigurationQrCodeEXT markerConfiguration{XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_QR_CODE_EXT};
markerConfiguration.capability = XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT;
markerConfiguration.enabledComponentCount = static_cast<uint32_t>(enabledComponents.size());
markerConfiguration.enabledComponents = enabledComponents.data();

// only chained if features.markerSideLength is true.
XrSpatialMarkerSizeEXT markerSize{XR_TYPE_SPATIAL_MARKER_SIZE_EXT};
markerSize.markerSideLength = 0.10f;
if (supportsFixedMarkerSize) {
  markerConfiguration.next = &markerSize;
}


std::array<XrSpatialCapabilityConfigurationBaseHeaderEXT*, 1> capabilityConfigs = {
  reinterpret_cast<XrSpatialCapabilityConfigurationBaseHeaderEXT*>(&markerConfiguration),
};

XrSpatialContextCreateInfoEXT spatialContextCreateInfo{XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT};
spatialContextCreateInfo.capabilityConfigCount = capabilityConfigs.size();
spatialContextCreateInfo.capabilityConfigs = capabilityConfigs.data();
XrFutureEXT createContextFuture;
CHK_XR(xrCreateSpatialContextAsyncEXT(session, &spatialContextCreateInfo, &createContextFuture));

waitUntilReady(createContextFuture);

XrCreateSpatialContextCompletionEXT completion{XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT};
CHK_XR(xrCreateSpatialContextCompleteEXT(session, createContextFuture, &completion));
if (completion.futureResult != XR_SUCCESS) {
  return;
}

spatialContext = completion.spatialContext;

// ...
// Discovery entities with the spatial context
// ...

CHK_XR(xrDestroySpatialContextEXT(spatialContext));

स्पेशल एंटिटी और क्वेरी कॉम्पोनेंट डेटा को एक्सप्लोर करना

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

XrFutureEXT future = XR_NULL_FUTURE_EXT;

// We want to look for entities that have the following components.
std::vector<XrSpatialComponentTypeEXT> snapshotComponents = {
  XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT,
  XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT,
};

auto discoverSpatialEntities = [&](XrSpatialContextEXT spatialContext, XrTime time) {
  XrSpatialDiscoverySnapshotCreateInfoEXT snapshotCreateInfo{XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT};
  snapshotCreateInfo.componentTypeCount = snapshotComponents.size();
  snapshotCreateInfo.componentTypes = snapshotComponents.data();
  CHK_XR(xrCreateSpatialDiscoverySnapshotAsyncEXT(spatialContext, &snapshotCreateInfo, &future));

  waitUntilReady(future);

  XrCreateSpatialDiscoverySnapshotCompletionInfoEXT completionInfo{XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT};
  completionInfo.baseSpace = localSpace;
  completionInfo.time = time;
  completionInfo.future = future;

  XrCreateSpatialDiscoverySnapshotCompletionEXT completion{XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT};
  CHK_XR(xrCreateSpatialDiscoverySnapshotCompleteEXT(spatialContext, &completionInfo, &completion));
  if (completion.futureResult == XR_SUCCESS) {

    // Query for the bounded2D and marker component data
    XrSpatialComponentDataQueryConditionEXT queryCond{XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT};
    queryCond.componentTypeCount = snapshotComponents.size();
    queryCond.componentTypes = snapshotComponents.data();

    XrSpatialComponentDataQueryResultEXT queryResult{XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT};
    CHK_XR(xrQuerySpatialComponentDataEXT(completion.snapshot, &queryCond, &queryResult));

    std::vector<XrSpatialEntityIdEXT> entityIds(queryResult.entityIdCountOutput);
    std::vector<XrSpatialEntityTrackingStateEXT> entityStates(queryResult.entityIdCountOutput);
    queryResult.entityIdCapacityInput = entityIds.size();
    queryResult.entityIds = entityIds.data();
    queryResult.entityStateCapacityInput = entityStates.size();
    queryResult.entityStates = entityStates.data();

    std::vector<XrSpatialBounded2DDataEXT> bounded2D(queryResult.entityIdCountOutput);
    XrSpatialComponentBounded2DListEXT bounded2DList{XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT};
    bounded2DList.boundCount = bounded2D.size();
    bounded2DList.bounds = bounded2D.data();
    queryResult.next = &bounded2DList;

    std::vector<XrSpatialMarkerDataEXT> markers;
    XrSpatialComponentMarkerListEXT markerList{XR_TYPE_SPATIAL_COMPONENT_MARKER_LIST_EXT};
    markers.resize(queryResult.entityIdCountOutput);
    markerList.markerCount = markers.size();
    markerList.markers = markers.data();
    bounded2DList.next = &markerList;

    CHK_XR(xrQuerySpatialComponentDataEXT(completion.snapshot, &queryCond, &queryResult));

    for (int32_t i = 0; i < queryResult.entityIdCountOutput; ++i) {
      if (entityStates[i] != XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT) {
        continue;
      }

      // 2D bounds for entity entityIds[i] is bounded2D[i].extents centered on bounded2D[i].center.

      if (markers[i].capability == XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT) {
        // Check if marker data has been decoded.
        if (markers[i].data.bufferId != XR_NULL_SPATIAL_BUFFER_ID_EXT) {
          if (markers[i].data.bufferType == XR_SPATIAL_BUFFER_TYPE_STRING_EXT) {
            // Qr Code data can be queried using
            // XrSpatialBufferGetInfoEXT getInfo{XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT};
            // info.bufferId = markers[i].data.bufferId;
            // xrGetSpatialBufferStringEXT(completion.snapshot, &getInfo, ...)
          } else if (markers[i].data.bufferType == XR_SPATIAL_BUFFER_TYPE_UINT8_EXT) {
            // Qr Code data can be queried using
            // XrSpatialBufferGetInfoEXT getInfo{XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT};
            // info.bufferId = markers[i].data.bufferId;
            // xrGetSpatialBufferUint8(completion.snapshot, &getInfo, ...)
          }
        }
      }
    }

    CHK_XR(xrDestroySpatialSnapshotEXT(completion.snapshot));
  }
};

while (1) {
  // ...
  // For every frame in frame loop
  // ...

  XrFrameState frameState;  // previously returned from xrWaitFrame
  const XrTime time = frameState.predictedDisplayTime;

  // Poll for the XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT event
  XrEventDataBuffer event = {XR_TYPE_EVENT_DATA_BUFFER};
  XrResult result = xrPollEvent(instance, &event);
  if (result == XR_SUCCESS) {
      switch (event.type) {
          case XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT: {
              const XrEventDataSpatialDiscoveryRecommendedEXT& eventdata =
                  *reinterpret_cast<XrEventDataSpatialDiscoveryRecommendedEXT*>(&event);
              // Discover spatial entities for the context that we received the "discovery
              // recommended" event for.
              discoverSpatialEntities(eventdata.spatialContext, time);
              break;
          }
      }
  }

  // ...
  // Finish frame loop
  // ...
}

नए स्ट्रक्चर

नए Enum

नए Enum कॉन्सटेंट

  • XR_EXT_SPATIAL_MARKER_TRACKING_EXTENSION_NAME
  • XR_EXT_spatial_marker_tracking_SPEC_VERSION

  • XrSpatialCapabilityEXT को एक्सटेंड करना :

    • XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT
    • XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT
    • XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT
    • XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT

  • XrSpatialCapabilityFeatureEXT को एक्सटेंड करना :

    • XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_FIXED_SIZE_MARKERS_EXT
    • XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_STATIC_MARKERS_EXT

  • XrSpatialComponentTypeEXT को एक्सटेंड करना :

    • XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT

  • XrStructureType को एक्सटेंड करना :

    • XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_APRIL_TAG_EXT
    • XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ARUCO_MARKER_EXT
    • XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_MICRO_QR_CODE_EXT
    • XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_QR_CODE_EXT
    • XR_TYPE_SPATIAL_COMPONENT_MARKER_LIST_EXT
    • XR_TYPE_SPATIAL_MARKER_SIZE_EXT
    • XR_TYPE_SPATIAL_MARKER_STATIC_OPTIMIZATION_EXT

वर्शन हिस्ट्री

  • संशोधन 1, 29-07-2024 (रॉन बेसेम्स, Meta)

    • एक्सटेंशन का शुरुआती ब्यौरा