Scopri come utilizzare le immagini aumentate nelle tue app.
Prerequisiti
Assicurati di aver compreso i concetti fondamentali di AR e di configurare una sessione ARCore prima di procedere.
Crea un database di immagini
Crea una ArAugmentedImageDatabase
per archiviare le immagini di riferimento. Puoi farlo in due modi:
- Crea un database vuoto
ArAugmentedImageDatabase* ar_augmented_image_database = NULL; ArAugmentedImageDatabase_create(ar_session, &ar_augmented_image_database);
- Legge da un file di database di immagini. Fai riferimento all'[AugmentedImage C] per
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);
I file di database possono essere creati con lo Strumento di immagine o chiamando ArAugmentedImageDatabase_serialize()
.
Aggiungi immagini al database
Questo passaggio è facoltativo se le immagini di riferimento desiderate sono già state caricate dal file di database. Per aggiungere un'immagine in fase di runtime, chiama ArAugmentedImageDatabase_addImage()
come mostrato di seguito. Fai riferimento all'app di esempio augmented_image_c per informazioni sulle funzioni nello spazio dei nomi util
.
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;
I valori index
e name
vengono utilizzati in un secondo momento per identificare l'immagine di riferimento rilevata.
Attiva il monitoraggio delle immagini
Configura la tua sessione ARCore per tenere traccia delle immagini registrando il database delle immagini:
ArConfig_setAugmentedImageDatabase(ar_session_, ar_config, ar_augmented_image_database); const ArStatus status = ArSession_configure(ar_session_, ar_config);
Durante la sessione, ARCore utilizza i feature point dell'immagine della videocamera per confrontarli con quelli nel database di immagini.
Trovare immagini aumentate in una sessione AR
Per ottenere le immagini corrispondenti, esegui il sondaggio per verificare la presenza di ArAugmentedImage
aggiornate nel loop di aggiornamento del frame.
// 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). } }
Supportare diversi casi d'uso
Quando ARCore rileva un'immagine aumentata, crea un elemento Trackable
per
questa immagine e imposta ArTrackingState
su TRACKING
e ArAugmentedImageTrackingMethod
su FULL_TRACKING
. Quando l'immagine monitorata esce dalla visualizzazione della fotocamera, ARCore continua a impostare ArTrackingState
su TRACKING
, ma cambia ArAugmentedImageTrackingMethod
su LAST_KNOWN_POSE
continuando a fornire l'orientamento e la posizione dell'immagine.
La tua app deve utilizzare lo stato e il metodo di monitoraggio in modo diverso a seconda del caso d'uso previsto.
Immagini fisse. Nella maggior parte dei casi d'uso relativi a immagini fisse in posizione (ovvero che non sono previste per essere spostate) possono semplicemente utilizzare
ArTrackingState
per determinare se l'immagine è stata rilevata e se la sua posizione è nota.ArAugmentedImageTrackingMethod
può essere ignorato.Immagini in movimento. Se la tua app deve monitorare un'immagine in movimento, usa sia
ArTrackingState
siaArAugmentedImageTrackingMethod
per determinare se l'immagine è stata rilevata e se la sua posizione è nota.
Caso d'uso | Immagine corretta | Spostamento immagine in corso... |
---|---|---|
Esempio | Un poster appeso a una parete | Un annuncio sulla fiancata di un autobus |
La posa può essere considerata valida quando |
ArTrackingState == TRACKING |
ArTrackingState == TRACKING
e ArAugmentedImageTrackingMethod == FULL_TRACKING
|