Guide du développeur Augmented Images pour 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

Chaque base de données d'images peut stocker des informations pour un maximum de 1 000 images.

Il existe deux façons de créer un AugmentedImageDatabase:

  • Chargez une base de données d'images enregistrée. Si vous le souhaitez, vous pouvez ajouter d'autres images de référence.
  • Créez une base de données vide. Ajoutez ensuite des images de référence une par une.

Charger une base de données d'images enregistrée

Utilisez AugmentedImageDatabase.deserialize() pour charger une base de données d'images existante:

Java

AugmentedImageDatabase imageDatabase;
try (InputStream inputStream = this.getAssets().open("example.imgdb")) {
  imageDatabase = AugmentedImageDatabase.deserialize(session, inputStream);
} catch (IOException e) {
  // The Augmented Image database could not be deserialized; handle this error appropriately.
}

Kotlin

val imageDatabase = this.assets.open("example.imgdb").use {
  AugmentedImageDatabase.deserialize(session, it)
}

Vous pouvez créer des bases de données d'images à l'aide de l'outil de ligne de commande arcoreimg pendant le développement ou en appelant AugmentedImageDatabase.serialize() sur une base de données qui contient et est chargée en mémoire.

Créer une base de données vide

Pour créer une base de données d'images vide au moment de l'exécution, utilisez le constructeur AugmentedImageDatabase:

Java

AugmentedImageDatabase imageDatabase = new AugmentedImageDatabase(session);

Kotlin

val imageDatabase = AugmentedImageDatabase(session)

Ajouter des images à une base de données existante

Ajoutez des images à votre base de données d'images en appelant AugmentedImageDatabase.addImage() pour chaque image, en spécifiant un widthInMeters facultatif.

Java

Bitmap bitmap;
try (InputStream bitmapString = getAssets().open("dog.jpg")) {
  bitmap = BitmapFactory.decodeStream(bitmapString);
} catch (IOException e) {
  // The bitmap could not be found in assets; handle this error appropriately.
  throw new AssertionError("The bitmap could not be found in assets.", e);
}

// If the physical size of the image is not known, use addImage(String, Bitmap) instead, at the
// expense of an increased image detection time.
float imageWidthInMeters = 0.10f; // 10 cm
int dogIndex = imageDatabase.addImage("dog", bitmap, imageWidthInMeters);

Kotlin

val bitmap = assets.open("dog.jpg").use { BitmapFactory.decodeStream(it) }
// If the physical size of the image is not known, use addImage(String, Bitmap) instead, at the
// expense of an increased image detection time.
val imageWidthInMeters = 0.10f // 10 cm
val dogIndex = imageDatabase.addImage("dog", bitmap, imageWidthInMeters)

Les index renvoyés peuvent être utilisés ultérieurement pour identifier l'image de référence qui a été détectée.

Activer le suivi des images

Configurez votre session ARCore pour commencer à suivre les images. Pour ce faire, définissez la configuration sur une configuration avec la base de données d'images souhaitée:

Java

Config config = new Config(session);
config.setAugmentedImageDatabase(imageDatabase);
session.configure(config);

Kotlin

val config = Config(session)
config.augmentedImageDatabase = imageDatabase
session.configure(config)

Au cours de la session, ARCore recherche des images en faisant correspondre les points de caractéristiques de l'image de l'appareil photo à ceux de la base de données d'images.

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

Java

Collection<AugmentedImage> updatedAugmentedImages =
    frame.getUpdatedTrackables(AugmentedImage.class);
for (AugmentedImage img : updatedAugmentedImages) {
  if (img.getTrackingState() == TrackingState.TRACKING) {
    // Use getTrackingMethod() to determine whether the image is currently
    // being tracked by the camera.
    switch (img.getTrackingMethod()) {
      case LAST_KNOWN_POSE:
        // The planar target is currently being tracked based on its last
        // known pose.
        break;
      case FULL_TRACKING:
        // The planar target is being tracked using the current camera image.
        break;
      case NOT_TRACKING:
        // The planar target isn't been tracked.
        break;
    }

    // You can also check which image this is based on img.getName().
    if (img.getIndex() == dogIndex) {
      // TODO: Render a 3D version of a dog in front of img.getCenterPose().
    } else if (img.getIndex() == catIndex) {
      // TODO: Render a 3D version of a cat in front of img.getCenterPose().
    }
  }
}

Kotlin

val updatedAugmentedImages = frame.getUpdatedTrackables(AugmentedImage::class.java)

for (img in updatedAugmentedImages) {
  if (img.trackingState == TrackingState.TRACKING) {
    // Use getTrackingMethod() to determine whether the image is currently
    // being tracked by the camera.
    when (img.trackingMethod) {
      AugmentedImage.TrackingMethod.LAST_KNOWN_POSE -> {
        // The planar target is currently being tracked based on its last known pose.
      }
      AugmentedImage.TrackingMethod.FULL_TRACKING -> {
        // The planar target is being tracked using the current camera image.
      }
      AugmentedImage.TrackingMethod.NOT_TRACKING -> {
        // The planar target isn't been tracked.
      }
    }

    // You can also check which image this is based on AugmentedImage.getName().
    when (img.index) {
      dogIndex -> TODO("Render a 3D version of a dog at img.getCenterPose()")
      catIndex -> TODO("Render a 3D version of a cat at img.getCenterPose()")
    }
  }
}

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 TrackingState sur TRACKING et TrackingMethod sur FULL_TRACKING. Lorsque l'image suivie sort de la vue de la caméra, ARCore remplace TrackingMethod par LAST_KNOWN_POSE tout en continuant à fournir l'orientation et la position de l'image.

Votre application doit utiliser ces énumérations 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 TrackingState pour déterminer si l'image a été détectée et si son emplacement est connu. Vous pouvez ignorer TrackingMethod.

  • Images en mouvement : Si votre application doit suivre une image en mouvement, utilisez à la fois TrackingState et TrackingMethod 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 		TrackingState == TRACKING TrackingState == TRACKING
et
TrackingMethod == FULL_TRACKING

Voir aussi