Entwicklerleitfaden für erweiterte Bilder für Android NDK

Hier erfahren Sie, wie Sie erweiterte Bilder in Ihren eigenen Apps verwenden.

Voraussetzungen

Machen Sie sich mit den grundlegenden AR-Konzepten und zur Konfiguration einer ARCore-Sitzung vertraut, bevor Sie fortfahren.

Bilddatenbank erstellen

Erstellen Sie ein ArAugmentedImageDatabase zum Speichern von Referenzbildern. Dafür gibt es zwei Möglichkeiten:

  • Leere Datenbank erstellen
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);

Datenbankdateien können entweder mit dem Image-Tool oder durch Aufrufen von ArAugmentedImageDatabase_serialize() erstellt werden.

Bilder zur Datenbank hinzufügen

Dieser Schritt ist optional, wenn die gewünschten Referenzbilder bereits aus der Datenbankdatei geladen wurden. Wenn Sie ein Bild zur Laufzeit hinzufügen möchten, rufen Sie wie unten gezeigt ArAugmentedImageDatabase_addImage() auf. In der Beispiel-App augmented_image_c finden Sie Funktionen im util-Namespace.

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;

Die Werte index und name werden später verwendet, um festzustellen, welches Referenzbild erkannt wurde.

Bild-Tracking aktivieren

Konfigurieren Sie Ihre ARCore-Sitzung für das Tracking von Bildern, indem Sie die Bilddatenbank registrieren:

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

Während der Sitzung nutzt ARCore Featurepunkte aus dem Kamerabild, um es mit denen in der Bilddatenbank abzugleichen.

Erweiterte Bilder in einer AR-Sitzung finden

Um übereinstimmende Bilder zu erhalten, fragen Sie in der Frame-Update-Schleife nach aktualisierten ArAugmentedImage-Elementen ab.

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

Unterstützung verschiedener Anwendungsfälle

Wenn ARCore ein erweitertes Bild erkennt, wird ein Trackable dafür erstellt und ArTrackingState auf TRACKING und ArAugmentedImageTrackingMethod auf FULL_TRACKING gesetzt. Wenn sich das erfasste Bild aus dem Sichtfeld der Kamera hinausbewegt, setzt ARCore ArTrackingState weiterhin auf TRACKING, ändert jedoch ArAugmentedImageTrackingMethod zu LAST_KNOWN_POSE und stellt weiterhin die Ausrichtung und Position des Bilds bereit.

Je nach beabsichtigtem Anwendungsfall sollten Tracking-Status und Tracking-Methode in Ihrer App unterschiedlich verwendet werden.

  • Behobene Bilder: In den meisten Anwendungsfällen, in denen Bilder an Ort und Stelle fixiert sind (also nicht verschoben werden sollen), kann einfach mit ArTrackingState ermittelt werden, ob das Bild erkannt wurde und ob sein Standort bekannt ist. ArAugmentedImageTrackingMethod kann ignoriert werden.

  • Bilder verschieben: Wenn Ihre Anwendung ein sich bewegendes Bild verfolgen muss, verwenden Sie sowohl ArTrackingState als auch ArAugmentedImageTrackingMethod, um festzustellen, ob das Bild erkannt wurde und ob seine Position bekannt ist.

Anwendungsfall Fixiertes Bild Bild wird verschoben
Beispiel Ein an einer Wand hängendes Plakat Anzeige an der Seite eines Busses
Die Pose kann
als gültig angesehen werden, wenn 		ArTrackingState == TRACKING ArTrackingState == TRACKING
und
ArAugmentedImageTrackingMethod == FULL_TRACKING