Android एनडीके के लिए ऑगमेंटेड इमेज डेवलपर गाइड

अपने ऐप्लिकेशन में ऑगमेंटेड इमेज इस्तेमाल करने का तरीका जानें.

ज़रूरी शर्तें

आगे बढ़ने से पहले, पक्का करें कि आपने एआर के बुनियादी कॉन्सेप्ट और ARCore सेशन को कॉन्फ़िगर करने का तरीका समझ लिया हो.

इमेज डेटाबेस बनाना

रेफ़रंस इमेज सेव करने के लिए, ArAugmentedImageDatabase बनाएं. इसके दो तरीके हैं:

• खाली डेटाबेस बनाना

ArAugmentedImageDatabase* ar_augmented_image_database = NULL;
ArAugmentedImageDatabase_create(ar_session, &ar_augmented_image_database);

• इमेज डेटाबेस फ़ाइल से पढ़ना. util::LoadFileFromAssetManager के लिए, [AugmentedImage C सैंपल ऐप्लिकेशन] देखें.

std::string database_buffer;
util::LoadFileFromAssetManager(asset_manager_, "sample_database.imgdb",
                               &database_buffer);
uint8_t* raw_buffer = reinterpret_cast<uint8_t*>(&database_buffer.front());

ArAugmentedImageDatabase* ar_augmented_image_database = NULL;
const ArStatus status = ArAugmentedImageDatabase_deserialize(
    ar_session, raw_buffer, database_buffer.size(),
    &ar_augmented_image_database);

डेटाबेस फ़ाइलें, इमेज टूल या ArAugmentedImageDatabase_serialize() को कॉल करके बनाई जा सकती हैं.

डेटाबेस में इमेज जोड़ना

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

int32_t width, height, stride, index;
uint8_t* image_pixel_buffer = nullptr;
constexpr const char kSampleImageName[] = "default.jpg";
bool load_image_result = util::LoadImageFromAssetManager(
    kSampleImageName, &width, &height, &stride, &image_pixel_buffer);

uint8_t* grayscale_buffer = nullptr;
util::ConvertRgbaToGrayscale(image_pixel_buffer, width, height, stride,
                             &grayscale_buffer);

int32_t grayscale_stride = stride / 4;
const ArStatus status = ArAugmentedImageDatabase_addImage(
    ar_session_, ar_augmented_image_database, kSampleImageName,
    grayscale_buffer, width, height, grayscale_stride, &index);

// If the physical size of the image is known, you can instead use
//     ArStatus ArAugmentedImageDatabase_addImageWithPhysicalSize
// This will improve the initial detection speed. ARCore will still actively
// estimate the physical size of the image as it is viewed from multiple
// viewpoints.

delete[] image_pixel_buffer;
delete[] grayscale_buffer;

index और name वैल्यू का इस्तेमाल बाद में, यह पता लगाने के लिए किया जाता है कि कौनसी रेफ़रंस इमेज का पता चला है.

इमेज ट्रैकिंग की सुविधा चालू करना

इमेज डेटाबेस को रजिस्टर करके, इमेज ट्रैक करने के लिए अपने ARCore सेशन को कॉन्फ़िगर करें:

ArConfig_setAugmentedImageDatabase(ar_session_, ar_config,
                                   ar_augmented_image_database);
const ArStatus status = ArSession_configure(ar_session_, ar_config);

सेशन के दौरान, ARCore कैमरे की इमेज के फ़ीचर पॉइंट का इस्तेमाल करके, इमेज डेटाबेस में मौजूद पॉइंट से मैच करता है.

एआर सेशन में ऑगमेंटेड इमेज ढूंढना

मैच होने वाली इमेज पाने के लिए, अपने फ़्रेम अपडेट लूप में अपडेट किए गए ArAugmentedImage के लिए पोल करें.

// Update loop, in onDrawFrame
ArTrackableList* updated_image_list = nullptr;
ArTrackableList_create(ar_session_, &updated_image_list);
ArFrame_getUpdatedTrackables(
    ar_session_, ar_frame_, AR_TRACKABLE_AUGMENTED_IMAGE, updated_image_list);

int32_t image_list_size;
ArTrackableList_getSize(ar_session_, updated_image_list, &image_list_size);

for (int i = 0; i < image_list_size; ++i) {
  ArTrackable* ar_trackable = nullptr;
  ArTrackableList_acquireItem(ar_session_, updated_image_list, i,
                              &ar_trackable);
  ArAugmentedImage* image = ArAsAugmentedImage(ar_trackable);

  ArTrackingState tracking_state;
  ArTrackable_getTrackingState(ar_session_, ar_trackable, &tracking_state);

  int image_index;
  ArAugmentedImage_getIndex(ar_session_, image, &image_index);

  if (tracking_state == AR_TRACKING_STATE_TRACKING) {
    util::ScopedArPose scopedArPose(ar_session_);
    ArAugmentedImage_getCenterPose(ar_session_, image,
                                   scopedArPose.GetArPose());

    ArAnchor* image_anchor = nullptr;
    const ArStatus status = ArTrackable_acquireNewAnchor(
        ar_session_, ar_trackable, scopedArPose.GetArPose(), &image_anchor);

    // For example, you can now render content at the image anchor, choosing
    // content based on the image index (or name).
  }
}

अलग-अलग तरह के कामों में इस्तेमाल किया जा सकता है

जब ARCore को किसी ऑगमेंटेड इमेज का पता चलता है, तो वह उस ऑगमेंटेड इमेज के लिए Trackable बनाता है. साथ ही, ArTrackingState को TRACKING और ArAugmentedImageTrackingMethod को FULL_TRACKING पर सेट करता है. जब ट्रैक की गई इमेज, कैमरे के व्यू से बाहर निकल जाती है, तो ARCore ArTrackingState को TRACKING पर सेट करना जारी रखता है. हालांकि, इमेज का ओरिएंटेशन और पोज़िशन उपलब्ध कराते हुए, ArAugmentedImageTrackingMethod को LAST_KNOWN_POSE पर बदल देता है.

आपके ऐप्लिकेशन को ट्रैकिंग की स्थिति और ट्रैकिंग के तरीके का इस्तेमाल अलग-अलग तरीके से करना चाहिए. यह इस बात पर निर्भर करता है कि ऐप्लिकेशन का इस्तेमाल किस काम के लिए किया जा रहा है.

• फ़िक्स की गई इमेज. ज़्यादातर इस्तेमाल के उदाहरणों में, ऐसी इमेज शामिल होती हैं जो एक ही जगह पर होती हैं. इसका मतलब है कि इमेज की जगह में बदलाव नहीं होता. ऐसे में, ArTrackingState का इस्तेमाल करके यह पता लगाया जा सकता है कि इमेज का पता चला है या नहीं और उसकी जगह की जानकारी है या नहीं. ArAugmentedImageTrackingMethod को अनदेखा किया जा सकता है.

• हिलने-डुलने वाली इमेज. अगर आपके ऐप्लिकेशन को किसी चलती-फिरती इमेज को ट्रैक करना है, तो ArTrackingState और ArAugmentedImageTrackingMethod, दोनों का इस्तेमाल करें. इससे यह पता चलेगा कि इमेज का पता चला है या नहीं और उसकी पोज़िशन क्या है.

इस्तेमाल का उदाहरण	फ़िक्स की गई इमेज	मूविंग इमेज
उदाहरण	दीवार पर लटका हुआ पोस्टर	बस की साइड पर मौजूद विज्ञापन
पोज़ को मान्य तब माना जा सकता है, जब	ArTrackingState == TRACKING	ArTrackingState == TRACKING और ArAugmentedImageTrackingMethod == FULL_TRACKING

ध्यान दें: अगर कैमरे के व्यू में मौजूद कोई इमेज, बहुत तेज़ी से दूसरी इमेज में बदल जाती है, जिसका साइज़ और पोज़िशन काफ़ी हद तक एक जैसी होती है, तो हो सकता है कि ARCore दोनों इमेज के लिए, ArAugmentedImageTrackingMethod को FULL_TRACKING पर सेट कर दे. साथ ही, पहली ऐगमेंटेड इमेज के ऐंकर को नई इमेज की पोज़िशन पर अपडेट कर दे. उदाहरण के लिए, ऐसा तब हो सकता है, जब आपने वेब ब्राउज़र में किसी इमेज पर कैमरा फ़ोकस किया हो और फिर किसी दूसरे ब्राउज़र टैब पर स्विच किया हो. इस टैब में, ऐसी ही साइज़ और पोज़िशन वाली दूसरी इमेज हो सकती है.