Obrazy rozszerzone – przewodnik dla programistów – pakiet NDK na Androida

Dowiedz się, jak używać obrazów rozszerzonych w swoich aplikacjach.

Wymagania wstępne

Zanim przejdziesz dalej, upewnij się, że rozumiesz podstawowe zagadnienia związane z rozszerzoną rzeczywistością oraz że wiesz, jak skonfigurować sesję ARCore.

Tworzenie bazy danych obrazów

Utwórz ArAugmentedImageDatabase, aby przechowywać obrazy referencyjne. Możesz to zrobić na 2 sposoby:

Tworzenie pustej bazy danych

ArAugmentedImageDatabase* ar_augmented_image_database = NULL;
ArAugmentedImageDatabase_create(ar_session, &ar_augmented_image_database);

odczyt z pliku bazy danych obrazów; Aby uzyskać więcej informacji, zapoznaj się z [AugmentedImage] (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);

Pliki bazy danych można tworzyć za pomocą Narzędzia do tworzenia obrazów lub wywołując funkcję ArAugmentedImageDatabase_serialize().

Dodawanie obrazów do bazy danych

Ten krok jest opcjonalny, jeśli żądane obrazy referencyjne zostały już załadowane z pliku bazy danych. Aby dodać obraz w czasie wykonywania kodu, wywołaj funkcję ArAugmentedImageDatabase_addImage(), jak pokazano poniżej. Funkcje w przestrzeni nazw util znajdziesz w przykładowej aplikacji 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;

Wartości index i name są później używane do identyfikowania, który obraz referencyjny został wykryty.

Włączanie śledzenia obrazów

Skonfiguruj sesję ARCore, aby śledzić obrazy, rejestrując bazę danych obrazów:

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

Podczas sesji ARCore używa punktów funkcji z obrazu z kamery, aby dopasować je do punktów w bazie danych obrazów.

Znajdowanie rozszerzonych obrazów w sesji AR

Aby uzyskać dopasowane obrazy, sprawdź, czy w pętli aktualizacji klatek są dostępne nowe ArAugmentedImage.

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

Obsługa różnych przypadków użycia

Gdy ARCore wykryje obraz rozszerzony, utworzy Trackable dla tego obrazu rozszerzonego i ustawi ArTrackingState na TRACKING, a ArAugmentedImageTrackingMethod na FULL_TRACKING. Gdy śledzony obraz zniknie z pola widzenia kamery, ARCore nadal będzie ustawiać wartość ArTrackingState na TRACKING, ale zmieni wartość ArAugmentedImageTrackingMethod na LAST_KNOWN_POSE, zachowując przy tym orientację i położenie obrazu.

Aplikacja powinna stosować stan śledzenia i metodę śledzenia w różny sposób w zależności od przewidywanego zastosowania.

Obrazy zostały naprawione. W większości przypadków obrazy, które są nieruchome (czyli nie powinny się przemieszczać), można po prostu wykrywać za pomocą funkcji ArTrackingState. ArAugmentedImageTrackingMethod można zignorować.
Przesuwanie obrazów. Jeśli Twoja aplikacja musi śledzić ruchomy obraz, użyj zarówno ArTrackingState, jak i ArAugmentedImageTrackingMethod, aby określić, czy obraz został wykryty i czy jego pozycja jest znana.

Przypadek użycia	Obraz statyczny	Obraz w ruchu
Przykład	Plakat powieszony na ścianie	Reklama na boku autobusu
Poza może być uznawana za prawidłową, gdy	`ArTrackingState == TRACKING`	`ArTrackingState == TRACKING` i `ArAugmentedImageTrackingMethod == FULL_TRACKING`