Guía para desarrolladores sobre imágenes aumentadas en Android

Aprende a usar imágenes aumentadas en tus propias apps.

Requisitos previos

Asegúrate de comprender los conceptos fundamentales de RA y cómo configurar una sesión de ARCore antes de continuar.

Crea una base de datos de imágenes

Cada base de datos de imágenes puede almacenar información para hasta 1,000 imágenes.

Existen dos maneras de crear un AugmentedImageDatabase

• Carga una base de datos de imágenes guardada. Luego, puedes agregar más imágenes de referencia de manera opcional.
• Crea una nueva base de datos vacía. Luego, agrega una imagen de referencia a la vez.

Carga una base de datos de imágenes guardada

Usa AugmentedImageDatabase.deserialize(). para cargar una base de datos de imágenes existente:

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

Las bases de datos de imágenes se pueden crear con arcoreimg. de línea de comandos durante el desarrollo, o llamando AugmentedImageDatabase.serialize() en una base de datos que contenga lo que se cargó en la memoria.

Crea una nueva base de datos vacía

Para crear una base de datos de imágenes vacía en el tiempo de ejecución, usa el constructor AugmentedImageDatabase:

AugmentedImageDatabase imageDatabase = new AugmentedImageDatabase(session);

val imageDatabase = AugmentedImageDatabase(session)

Agrega imágenes a una base de datos existente

Agrega imágenes a tu base de datos de imágenes llamando AugmentedImageDatabase.addImage() para cada imagen y especifica un widthInMeters opcional.

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)

Los índices devueltos se pueden usar posteriormente para identificar qué imagen de referencia se detectado.

Habilitar el seguimiento de imágenes

Configura tu sesión de ARCore para comenzar a hacer un seguimiento de las imágenes estableciendo la sesión config en uno que esté configurado con la base de datos de imágenes deseada:

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

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

Durante la sesión, ARCore busca imágenes haciendo coincidir los puntos del atributo de de la imagen de la cámara con los de la base de datos de imágenes.

Para obtener las imágenes coincidentes, sondea las AugmentedImage actualizadas en el bucle de actualización de marcos.

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

Compatibilidad con diferentes casos de uso

Cuando ARCore detecta una imagen aumentada, crea un Trackable para ella. Imagen aumentada y conjuntos TrackingState a TRACKING y TrackingMethod a FULL_TRACKING. Cuando la imagen rastreada se mueve fuera de la vista de cámara, ARCore cambia la TrackingMethod a LAST_KNOWN_POSE sin dejar de proporcionar la orientación y la posición de la imagen.

Tu app debe usar estas enumeraciones de manera diferente según el uso previsto para determinar si este es el caso.

• Imágenes fijas La mayoría de los casos de uso que implican imágenes fijas (es decir, no se espera que se mueva) puedes usar TrackingState para determinar si se detectó la imagen y si se conoce su ubicación. TrackingMethod se puede ignorar.

• Imágenes en movimiento. Si tu app necesita realizar el seguimiento de una imagen en movimiento, utiliza ambos. TrackingState y TrackingMethod para determinar si la imagen se detectada y si se conoce su posición.

Consulta también

• Los proyectos de muestra de las imágenes aumentadas en el SDK de ARCore.

• El codelab de imágenes aumentadas de ARCore