Entwicklerleitfaden für erweiterte Bilder für Android NDK

Informationen zur Verwendung von Augmented Reality-Bildern in Ihren eigenen Apps

Vorbereitung

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

Bilddatenbank erstellen

Erstellen Sie eine ArAugmentedImageDatabase, um Referenzbilder zu speichern. 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 ArAugmentedImageDatabase_addImage() auf, wie unten dargestellt. Funktionen im Namespace util finden Sie in der Beispiel-App augmented_image_c.

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;

Anhand der Werte index und name wird später ermittelt, welches Referenzbild erkannt wurde.

Bild-Tracking aktivieren

Konfigurieren Sie Ihre ARCore-Sitzung so, dass Bilder erfasst werden, 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 verwendet ARCore Merkmals-/Referenzpunkte aus dem Kamerabild, um sie mit denen in der Bilddatenbank abzugleichen.

Augmented Reality-Bilder in einer AR-Sitzung finden

Um die übereinstimmenden Bilder abzurufen, frage in der Frame-Update-Schleife nach aktualisierten ArAugmentedImages.

// 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 Augmented Image erkennt, wird ein Trackable für dieses Augmented Image erstellt und ArTrackingState auf TRACKING und ArAugmentedImageTrackingMethod auf FULL_TRACKING festgelegt. Wenn sich das getrackte Bild aus dem Kamerabild bewegt, setzt ARCore weiterhin ArTrackingState auf TRACKING, ändert aber ArAugmentedImageTrackingMethod in LAST_KNOWN_POSE und liefert weiterhin die Ausrichtung und Position des Bildes.

In Ihrer App sollten der Tracking-Status und die Tracking-Methode je nach beabsichtigtem Anwendungsfall unterschiedlich verwendet werden.

  • Statische Bilder Bei den meisten Anwendungsfällen mit Bildern, die an Ort und Stelle bleiben (d. h. sich nicht bewegen sollen), kann mit ArTrackingState einfach ermittelt werden, ob das Bild erkannt wurde und ob sein Standort bekannt ist. ArAugmentedImageTrackingMethod kann ignoriert werden.

  • Bewegte Bilder Wenn Ihre App 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 Bewegtes Bild
Beispiel Ein an einer Wand hängendes Poster Eine Anzeige auf der Seite eines Busses
Die Pose kann als
gültig betrachtet werden, wenn 		ArTrackingState == TRACKING ArTrackingState == TRACKING
und
ArAugmentedImageTrackingMethod == FULL_TRACKING