Entwicklerleitfaden für erweiterte Bilder für Android NDK

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

Vorbereitung

Machen Sie sich mit den grundlegenden AR-Konzepten vertraut. und Konfigurieren einer ARCore-Sitzung beschrieben, bevor du fortfährst.

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

Aus einer Bilddatenbankdatei lesen. Weitere Informationen finden Sie in der [AugmentedImage C-Beispiel-App] für util::LoadFileFromAssetManager.

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 Bildtool 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. Um ein Bild zur Laufzeit hinzuzufügen, rufen Sie ArAugmentedImageDatabase_addImage() auf, wie unten gezeigt. 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;

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

Bild-Tracking aktivieren

Konfigurieren Sie Ihre ARCore-Sitzung so, dass Bilder erfasst werden. Registrieren Sie dazu die Bilddatenbank:

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 Featurepunkte aus dem Kamerabild, um sie mit denen in der Bilddatenbank abzugleichen.

Erweiterte Bilder in AR-Sitzungen suchen

Um übereinstimmende Bilder zu erhalten, 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).
  }
}

Verschiedene Anwendungsfälle unterstützen

Wenn ARCore ein erweitertes Bild erkennt, wird dafür ein Trackable erstellt. Erweitertes Bild und Gruppen ArTrackingState an TRACKING und ArAugmentedImageTrackingMethod auf FULL_TRACKING. Wann das Bild „Tracking“ sich aus der Kamerasicht bewegt, setzt ARCore ArTrackingState bis TRACKING, ändert jedoch die ArAugmentedImageTrackingMethod nach LAST_KNOWN_POSE und stellt weiterhin die Ausrichtung und Position des auf das Bild.

Der Tracking-Status und die Tracking-Methode sollten in Ihrer App je nach Verwendungszweck unterschiedlich verwendet werden Fall.

Feste Bilder: Die meisten Anwendungsfälle umfassen Bilder, die an Ort und Stelle fixiert sind. (d. h., es wird nicht voraussichtlich verschoben) können einfach mit ArTrackingState bestimmen, ob das Bild erkannt wurde und ob sein Standort bekannt ist. ArAugmentedImageTrackingMethod kann ignoriert werden.
Verschieben von Bildern: Wenn deine App ein bewegtes Bild erfassen muss, verwende beide ArTrackingState und ArAugmentedImageTrackingMethod, um festzustellen, ob das Bild erkannt wird und ob seine Position bekannt ist.

Anwendungsfall	Fixiertes Bild	Bild wird verschoben
Beispiel	Ein Poster an einer Wand	Werbung an der Seite eines Busses
Die Position kann als gültig angesehen, wenn	`ArTrackingState == TRACKING`	`ArTrackingState == TRACKING` und `ArAugmentedImageTrackingMethod == FULL_TRACKING`