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

Dowiedz się, jak korzystać z obrazów rozszerzonych we własnych aplikacjach.

Wymagania wstępne

Upewnij się, że znasz podstawowe pojęcia związane z AR. i dowiedz się, jak skonfigurować sesję ARCore, zanim przejdziesz dalej.

Tworzenie bazy danych obrazów

Utwórz ArAugmentedImageDatabase do przechowywania obrazów referencyjnych. Możesz to zrobić na 2 sposoby:

Utwórz pustą bazę danych

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

Odczyt z pliku bazy danych zdjęć. Zapoznaj się z [AugmentedImage C przykład app] for 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 graficznego lub za pomocą wywołania ArAugmentedImageDatabase_serialize().

Dodaj obrazy 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 działania, wywołaj 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 zostaną później użyte do określenia, który obraz referencyjny został wykryty.

Włącz śledzenie obrazów

Skonfiguruj sesję ARCore tak, aby śledziła 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 wykorzystuje punkty cech ze zdjęcia z aparatu, aby porównać je z tymi w bazie danych zdjęć.

Znajdowanie obrazów rozszerzonych w sesji AR

Aby uzyskać dopasowane obrazy, przeprowadź ankietę w sprawie zaktualizowanych elementów ArAugmentedImage w pętli aktualizacji ramki.

// 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, tworzy dla niego Trackable Rozszerzony obraz i zestawy ArTrackingState do TRACKING i ArAugmentedImageTrackingMethod do FULL_TRACKING. Kiedy śledzony obraz zniknie z widoku kamery, ARCore nadal będzie ArTrackingState do TRACKING, ale zmienia ArAugmentedImageTrackingMethod do LAST_KNOWN_POSE, przy czym nadal podaj orientację i położenie zdjęcia.

Aplikacja powinna używać stanu śledzenia i metody śledzenia w różny sposób zależnie od przeznaczenia tych kwestii.

Poprawione obrazy. Większość przypadków użycia obejmujących obrazy, które mają stałą wysokość (czyli nie zostanie przeniesiony) może za pomocą funkcji ArTrackingState określić czy obraz został wykryty i czy jego lokalizacja jest znana. ArAugmentedImageTrackingMethod można zignorować.
Ruchome obrazy. Jeśli aplikacja ma śledzić ruchomy obraz, użyj obu funkcji ArTrackingState i ArAugmentedImageTrackingMethod, aby określić, czy obraz został i czy jest znana jej pozycja.

Przypadek użycia	Stały obraz	Przenoszę obraz
Przykład	Plakat na ścianie	Reklama na boku autobusu
Pozycja może być: uważane za prawidłowe, gdy	`ArTrackingState == TRACKING`	`ArTrackingState == TRACKING` i `ArAugmentedImageTrackingMethod == FULL_TRACKING`