Guide du développeur Augmented Images pour le NDK Android

Découvrez comment utiliser Augmented Images dans vos propres applications.

Conditions préalables

Assurez-vous de bien comprendre les concepts fondamentaux de la RA et de configurer une session ARCore avant de continuer.

Créer une base de données d'images

Créez un ArAugmentedImageDatabase pour stocker des images de référence. Il existe deux façons:

  • Créer une base de données vide
ArAugmentedImageDatabase* ar_augmented_image_database = NULL;
ArAugmentedImageDatabase_create(ar_session, &ar_augmented_image_database);
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);

Les fichiers de base de données peuvent être créés avec l'outil Image ou en appelant ArAugmentedImageDatabase_serialize().

Ajouter des images à la base de données

Cette étape est facultative si les images de référence souhaitées ont déjà été chargées à partir du fichier de base de données. Pour ajouter une image au moment de l'exécution, appelez ArAugmentedImageDatabase_addImage() comme indiqué ci-dessous. Consultez l'application exemple augmented_image_c pour connaître les fonctions dans l'espace de noms util.

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;

Les valeurs index et name serviront ultérieurement à identifier l'image de référence détectée.

Activer le suivi des images

Configurez votre session ARCore pour suivre les images en enregistrant la base de données d'images:

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

Pendant la session, ARCore utilise les points de caractéristiques de l'image de la caméra pour les comparer à ceux de la base de données d'images.

Trouver des images augmentées dans une session de RA

Pour obtenir les images correspondantes, recherchez les ArAugmentedImage mises à jour dans votre boucle d'actualisation des frames.

// 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).
  }
}

Assurer la compatibilité avec différents cas d'utilisation

Lorsqu'ARCore détecte une image augmentée, il crée une Trackable pour cette image augmentée, et définit ArTrackingState sur TRACKING et ArAugmentedImageTrackingMethod sur FULL_TRACKING. Lorsque l'image suivie quitte la vue de la caméra, ARCore continue de définir ArTrackingState sur TRACKING, mais remplace ArAugmentedImageTrackingMethod par LAST_KNOWN_POSE tout en continuant à fournir l'orientation et la position de l'image.

Votre application doit utiliser l'état et la méthode de suivi différemment en fonction du cas d'utilisation prévu.

  • Images fixes : La plupart des cas d'utilisation impliquant des images fixes (c'est-à-dire qui ne sont pas censées se déplacer) peuvent simplement utiliser ArTrackingState pour déterminer si l'image a été détectée et si son emplacement est connu. Vous pouvez ignorer ArAugmentedImageTrackingMethod.

  • Images en mouvement : Si votre application doit suivre une image en mouvement, utilisez à la fois ArTrackingState et ArAugmentedImageTrackingMethod pour déterminer si l'image a été détectée et si sa position est connue.

Cas d'utilisation Image corrigée Déplacement de l'image...
Exemple Affiche accrochée à un mur Publicité sur le côté d'un bus
La position peut être
considérée comme valide lorsque 		ArTrackingState == TRACKING ArTrackingState == TRACKING
et
ArAugmentedImageTrackingMethod == FULL_TRACKING