Android NDK के लिए, ऑगमेंटेड रिएलिटी (एआर) इमेज

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

ज़रूरी बातें

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

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

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

  • खाली डेटाबेस बनाना
ArAugmentedImageDatabase* ar_augmented_image_database = NULL;
ArAugmentedImageDatabase_create(ar_session, &ar_augmented_image_database);
  • किसी इमेज डेटाबेस फ़ाइल से पढ़ें. util::LoadFileFromAssetManager के लिए, [ऑगमेंटेड इमेज 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