norangebit/open-ar
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

bugs fix

Browse Source 
- mv introduzione to chapter3.0
- edit chapter3.1 and chapter3.2
This commit is contained in:
Raffaele Mignone 2019-01-05 16:34:51 +01:00
parent 81ebc85722
commit a9db63e055
Signed by: norangebit
GPG Key ID: 4B9DF72AB9508845
3 changed files with 73 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/chapter3.0.md Normal file
View File

@ -0,0 +1,31 @@
# Progetti d'esempio
Per poter realizzare delle applicazioni mediante ARCore e Sceneform sono necessarie una serie di configurazioni iniziali.
Requisito necessario al funzionamento di ARCore è una versione di Android uguale o superiore ad Android 7.0 Nougat(API level 24).
Inoltre se si sta lavorando su un progetto con API level minore di 26 è necessario esplicitare il supporto a Java 8 andando a modificare file `app/build.gradle`.
```gradle
android {
...
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
...
}
```
Sempre nel file per il build del progetto è necessario aggiungere la dipendenza di Sceneform.
```gradle
implementation "com.google.ar.sceneform.ux:sceneform-ux:1.6.0"
```
Inoltre nell'Android Manifest[^manifest] va dichiarato l'utilizzo del permesso della fotocamera[^camera] e l'utilizzo di ARCore[^arcore].
[^manifest]: File in cui vengono dichiarate tutte caratteristiche di un'applicazione Android, tra cui anche i permessi.
[^camera]: Lo sviluppatore deve solo dichiarare l'utilizzo del permesso, la richiesta di concessione è gestita in automatico da Sceneform.
[^arcore]: L'utilizzo di ARCore deve essere dichiarata in quanto non tutti i dispositivi lo supportano.

64
src/chapter3.1.md
View File

@ -1,44 +1,23 @@
# Progetti di esempio
Prima di procedere allo sviluppo di applicazioni mediante ARCore e Sceneform sono necessarie alcune configurazioni iniziali.
Per funzionare ARCore necessita di Android 7.0(API level 24) o superiore.
Inoltre se si sta lavorando con un progetto con API level minore di 26 è necessario esplicitare il supporto a Java 8 andando a modificare file `app/build.gradle`.
```gradle
android {
...
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
...
}
```
Un'altra modifica da fare al file è l'aggiunta della dipendenza di Sceneform.
```gradle
implementation "com.google.ar.sceneform.ux:sceneform-ux:1.6.0"
```
Inoltre nell'AndroidManifest è necessario dichiarare l'utilizzo del permesso della fotocamera[^camera] e l'utilizzo di ARCore[^arcore].
## Augmented images ## Augmented images
Il primo progetto è un classico esempio di AR marker based e ha lo scopo di riconosce un immagine data e sovrapporre ad essa un oggetto virtuale. Nel primo progetto d'esempio si è affrontato un classico problema di AR marker based, ovvero il riconoscimento di un'immagine preimpostata e il conseguente sovrapponimento di un oggetto virtuale.
Nel caso specifico si vuole riconoscere una foto del pianeta terra e sostituirvi un modello tridimensionale di essa. Nel caso specifico si vuole riconoscere una foto del pianeta terra e sostituirvi un modello tridimensionale di essa.
### Aggiunta del modello ### Aggiunta del modello
Prima di tutto dobbiamo la cartella *"sampledata"*, il cui contenuto sarà usato solo in fase di progettazione, e aggiungere ad essa il modello tridimensionale[^format] che vogliamo usare. Il modello tridimensionale della terra è stato recuperato dal sito `poly.google.com`, che funge da repository per modelli 3D.
Per facilitare l'importazione del modello 3D usiamo il plug-in *Google Sceneform Tools*. La scelta del modello è stata dettata sia del formato[^format] in cui era disponibile, sia dalla licenza con cui veniva distribuito.
Una volta ottenuto il modello è stato salvato nella cartella *"sampledata"*, il cui contenuto sarà usato solo in fase di progettazione.
L'importazione del modello all'interno del progetto di Android Studio è stato effettuato mediante l'utilizzo del plug-in *Google Sceneform Tools*, che si occupa sia di convertire il modello nel formato di Sceneform, sia di aggiornare il file `build.gradle` affinché sia incluso nell'APK[^apk] finale.
### Creazione del database ### Creazione del database
La prima cosa da fare è la creazione di un database con tutte le immagini che si desidera far riconosce all'applicazione. Questa operazione può essere svolta sia quando si sta sviluppando l'applicazione, sia runtime. Per questo progetto si è scelta la seconda opzione. Il database contenete tutte le immagini che si desidera far riconosce all'applicazione, può essere creato sia a priori, sia a tempo di esecuzione.
Per la prima soluzione Google mette a disposizione *The arcoreimag tool*, un software a linea di comando, che oltre a creare il database si occupa anche di valutare l'immagine.
L'aggiunta dell'immagine al database avviene mediante la funzione `setupAugmentedImageDb`. Dato che nel caso specifico si vuole far riconoscere un'unica immagine si è optato per la generazione del database a runtime.
In particolare quest'operazione avviene mediante la funzione `setupAugmentedImageDb`.
```kotlin ```kotlin
private fun setupAugmentedImageDb (config: Config): Boolean { private fun setupAugmentedImageDb (config: Config): Boolean {
@ -53,8 +32,10 @@ private fun setupAugmentedImageDb (config: Config): Boolean {
### Riconoscimento dell'immagine ### Riconoscimento dell'immagine
Sfortunatamente ARCore non permette di gestire il riconoscimento dell'immagine mediante un listener, per cui sarà compito dello sviluppatore controllare quando si è verificato un match. Il riconoscimento dell'immagine non può avvenire mediate l'utilizzo di una callback in quanto ARCore non permette di registrare un listener all'evento.
Per fare ciò si usa il metodo `addOnUpdateListener()` dell'oggetto `Scene`, che permette di eseguire del codice ogni qual volta che la scena viene aggiornata. Risulta dunque evidente che la verifica dell'avvenuto match sarà delegata allo sviluppatore.
Per fare ciò si è usato il metodo `addOnUpdateListener` dell'oggetto `Scene`, che permette di eseguire del codice ogni qual volta la scena viene aggiornata.
```kotlin ```kotlin
override fun onCreate(savedInstanceState: Bundle?) { override fun onCreate(savedInstanceState: Bundle?) {
@ -66,7 +47,7 @@ override fun onCreate(savedInstanceState: Bundle?) {
} }
``` ```
Dove la funzione `detectAndPlaceAugmentedImage()` si occupa di verificare la presenza di un match e nel caso aggiungere l'oggetto virtuale alla scena. Dove la funzione `detectAndPlaceAugmentedImage` si occupa di verificare la presenza di un match e nel caso di un riscontro positivo, dell'aggiunta dell'oggetto virtuale alla scena.
```kotlin ```kotlin
private fun detectAndPlaceAugmentedImage(frameTime: FrameTime) { private fun detectAndPlaceAugmentedImage(frameTime: FrameTime) {
@ -93,11 +74,13 @@ private fun detectAndPlaceAugmentedImage(frameTime: FrameTime) {
} }
``` ```
Il settaggio del flag `isModelAdded` al valore booleano di vero, si rende necessario al fine di evitare l'aggiunta incontrollata di nuovi modelli alla medesima immagine.
### Rendering del modello ### Rendering del modello
Il rendering del modello avviene attraverso la funzione `buildRenderable()`. Il rendering del modello avviene attraverso la funzione `buildRenderable` che a sua volta chiama la funzione di libreria `ModelRenderable.builder()`.
Poiché quest'ultima è un operazione onerosa viene restituito un `Future`[^future] che racchiude il `Renderable` vero e proprio. Poiché quest'ultima è un operazione onerosa viene restituito un `Future`[^future] che racchiude il `Renderable` vero e proprio.
L'interazione con quest'oggetto avviene attraverso una callback che è possibile specificare attraverso il metodo `thenAccept()`. L'interazione con l'oggetto concreto avviene mediante una callback che è possibile specificare attraverso il metodo `thenAccept`.
```kotlin ```kotlin
fun buildRenderable( fun buildRenderable(
@ -119,7 +102,9 @@ fun buildRenderable(
### Aggiunta dell'oggetto virtuale nella scena ### Aggiunta dell'oggetto virtuale nella scena
L'ultima operazione da compiere è l'aggiunta del modello renderizzato alla scena. L'ultima operazione da compiere è l'aggiunta del modello renderizzato alla scena.
Questa operazione avviene attraverso la funzione `addTrasformableNodeToScene()`. Questa operazione avviene attraverso la funzione `addTrasformableNodeToScene()` che si occupa di creare un ancora in corrispondenza del punto reale d'interesse.
A partire da quest'ancora viene creato un nodo che racchiude l'oggetto renderizzato.
Inoltre nel caso specifico si è usato un `TransformabelNode`, in modo da concedere all'utente la possibilità di ridimensionare o ruotare il modello.
```kotlin ```kotlin
fun addTransformableNodeToScene( fun addTransformableNodeToScene(
@ -137,6 +122,7 @@ fun addTransformableNodeToScene(
``` ```
[^format]: Attualmente sono supportati solo modelli OBJ, FBX e gLTF. [^format]: Attualmente sono supportati solo modelli OBJ, FBX e gLTF.
[^camera]: Lo sviluppatore deve solo dichiarare l'utilizzo del permesso, la richiesta di concessione è gestita in automatico da Sceneform.
[^arcore]: L'utilizzo di ARCore deve essere dichiarata in quanto non tutti i dispositivi supportano ARCore. [^apk]: Formato delle applicazioni Android.
[^future]: In informatica con il termine *future*, o *promise*, *delay* e *deferred*, si indica un tecnica che permette di sincronizzare l'esecuzione di un programma concorrente. [^future]: In informatica con il termine *future*, o *promise*, *delay* e *deferred*, si indica un tecnica che permette di sincronizzare l'esecuzione di un programma concorrente.

21
src/chapter3.2.md
View File

@ -1,10 +1,12 @@
## Runtime fetching models ## Runtime fetching models
Lo scopo di questa seconda applicazione è mostrare come sia possibile recuperare i modelli da renderizzare durante l'esecuzione dell'applicazione. Nella seconda applicazione d'esempio viene mostrato come sia possibile recuperare i modelli da renderizzare anche durante l'esecuzione dell'applicazione.
Questa funzione risulta particolarmente utile quando si deve rilasciare un'applicazione che sfrutta un numero elevato di modelli e non si vuole appesantire il volume del file *apk*[^apk]. Questa funzione risulta particolarmente utile quando si deve rilasciare un'applicazione che sfrutta numerosi modelli e non si vuole appesantire eccessivamente il volume del file *APK*.
Inoltre è possibile aggiungere nuovi modelli, o aggiornare quelli vecchi, senza dover aggiornare l'applicazione, ma lavorando esclusivamente lato server. Inoltre concede maggiore libertà allo sviluppatore in quanto è possibile aggiungere nuovi modelli, o aggiornare quelli vecchi, senza dover operare sull'applicazione, ma lavorando esclusivamente lato server.
Per quest'applicazione oltre alle configurazioni già viste in precedenza dobbiamo aggiungere una nuova dipendenza che include le funzioni necessarie per il fetching del modello. In questo caso specifico l'applicazione dovrà riconosce uno o più piani e in seguito ad un tocco dell'utente su di essi, mostrare un modello di *Andy*, la mascotte di Android.
Per quest'applicazione oltre alle configurazioni già viste in precedenza è necessario aggiungere una nuova dipendenza che include le funzioni necessarie per il fetching del modello.
```gradle ```gradle
implementation 'com.google.ar.sceneform:assets:1.6.0' implementation 'com.google.ar.sceneform:assets:1.6.0'
@ -14,8 +16,8 @@ Inoltre nell'AndroidManifest bisogna aggiungere il permesso per accedere alla re
### Interazione con l'utente ### Interazione con l'utente
L'interazione con l'utente avviene mediante un tocco sul display. L'interazione con l'utente avviene mediante un tocco sul display in corrispondenza di un piano.
Sceneform ci permette di personalizzare il comportamento al verificarsi di questo evento tramite un listener. Sceneform ci permette di personalizzare il comportamento al verificarsi di questo evento tramite il metodo `setOnTapArPlaneListener`.
```kotlin ```kotlin
override fun onCreate(savedInstanceState: Bundle?) { override fun onCreate(savedInstanceState: Bundle?) {
@ -47,7 +49,7 @@ private fun fetchAndPlaceModel(
### Fetching del model ### Fetching del model
Il recupero del modello avviene attraverso la funzione `fetchModel`. Il recupero del modello avviene attraverso la funzione `fetchModel`, che a sua volta chiama la funzione di libreria `RenderableSource.builder()`.
```kotlin ```kotlin
fun fetchModel( fun fetchModel(
@ -65,7 +67,7 @@ Attualmente[^sceneform-1.6] Sceneform supporta unicamente il fetching di modelli
### Rendering e aggiunta del modello ### Rendering e aggiunta del modello
Il rendering del modello avviene tramite la funzione `buildRenderable`, che è molto simile a quella utilizzata nel progetto precedente, con la differenza che in questo caso deve essere passato anche il modello che si è recuperato in precedenza. Il rendering del modello avviene tramite la funzione `buildRenderable`, che riprende in buona parte quella vista precedentemente, con la differenza che in questo caso deve essere passato anche il modello recuperato.
```kotlin ```kotlin
fun buildRenderable( fun buildRenderable(
@ -86,7 +88,6 @@ fun buildRenderable(
} }
``` ```
L'aggiunta del modello renderizzato alla scena avviene mediante la medesima funzione `addTransformableNodeToScene` vista in precedenza. Infine l'aggiunta del modello renderizzato alla scena avviene mediante la medesima funzione `addTransformableNodeToScene` vista in precedenza.
[^sceneform-1.6]: Sceneform 1.6.0. [^sceneform-1.6]: Sceneform 1.6.0.
[^apk]: Formato delle applicazioni android.