Guide du développeur Augmented Images pour Android

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

Prérequis

Assurez-vous de bien maîtriser les concepts fondamentaux de la RA. et comment 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 les informations d'un maximum de 1 000 images.

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

• Chargez une base de données d'images enregistrée. Ajoutez ensuite d'autres images de référence si vous le souhaitez.
• Créez une base de données vide. Ajoutez ensuite les images de référence une par une.

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

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

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

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 arcoreimg pendant le développement, ou en appelant AugmentedImageDatabase.serialize() sur une base de données qui contient qui 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:

AugmentedImageDatabase imageDatabase = new AugmentedImageDatabase(session);

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.

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);

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 ensuite être utilisés pour identifier l'image de référence qui a été détecté.

Activer le suivi des images

Configurez votre session ARCore pour commencer à suivre les images en définissant la session par une autre configurée avec la base de données d'images souhaitée:

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

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

Pendant la session, ARCore recherche des images en faisant correspondre les points de caractéristiques de l'image de l'appareil photo par rapport à celles de la base de données.

Pour obtenir les images correspondantes, recherchez des AugmentedImage mis à jour dans votre boucle de mise à jour de frames.

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

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()")
    }
  }
}

Compatibilité avec différents cas d'utilisation

Lorsqu'ARCore détecte une image augmentée, il crée un Trackable pour cette image. Image augmentée et ensembles TrackingState vers TRACKING et TrackingMethod et le FULL_TRACKING. Lorsque l'image suivie sort de la vue de l'appareil photo, ARCore modifie TrackingMethod à LAST_KNOWN_POSE tout en continuant à fournir l'orientation et la position l'image.

Votre application doit utiliser ces énumérations différemment selon l'utilisation prévue .

• Images fixes : La plupart des cas d'utilisation impliquant des images fixes (c'est-à-dire qu'elle ne doit pas être déplacée) peut 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 animées Si votre application doit suivre une image en mouvement, utilisez les deux TrackingState et TrackingMethod pour déterminer si l'image a été détectée et si sa position est connue.

Voir aussi

• Exemples de projets Augmented Images dans le SDK ARCore.

• L'atelier de programmation ARCore Augmented Images