From 4f510da0d011b4bb292c0b2f84798dd10925cc8d Mon Sep 17 00:00:00 2001 From: Piero Toffanin Date: Wed, 15 Jul 2026 14:26:00 -0400 Subject: [PATCH 1/2] Add AGENTS.md, enable localization --- AGENTS.md | 39 +++++++++++++++++++++++++++++++++++++++ astro.config.mjs | 14 ++++++++++++++ 2 files changed, 53 insertions(+) create mode 100644 AGENTS.md diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..279fe19 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,39 @@ +This is the documentation repository of LibreTranslate, a free and open source translation API. + +# Where to find contents + +- `src/docs`: directory with documentation pages in mdx and markdown format + +# Rules + +- The tone of translation should be technical. The context of translation is that of drone mapping software and photogrammetry. +- When updating translations, always look at the current git diff to see which sections were changed. If there are no active changes in the current branch, compare against the latest commit (git diff HEAD~1 HEAD) +- Never edit or commit any file in `src/content/docs/api`, `src/content/docs/reference`, `src/content/docs/tutorials`, `src/content/index.mdx` or `src/content/*.md`. These are the original English pages +- Always preserve images in the proper places. +- Each translation for other languages, like Italian or Spanish, needs to be added as subfolder in `src/content/docs/[langcode]`, where `langcode` is the 2 letter ISO 639 language code. For example, Italian docs go in `src/content/docs/it/`. +- Each translation must have an `index.mdx` and copies of each subfolder (`api`, `reference`, `tutorials`) and a copy of each markdown file in each subfolder. Always verify that the number of pages match. +- Always create/update ALL the markdown files when asked to add or update a translation. +- Always translate from English, never from another language. +- Always verify all translations for accuracy and completeness in all markdown files, then fix all inaccuracies and fill any missing section, if any. +- When translating internal links, we always reference them with the appropriate URL that maps to a markdown file of the translation. +- Never modify any other file other than those in `src/content` or `astro.config.mjs` without explicit permission. +- When translating, always check that all the sidebar items in `astro.config.mjs` have a proper translation item in the `translations` key. + +# How to build / check that the website builds + +```bash +nvm use 22 +npm run build +``` + +The outputs will be in `dist/`. + +# Glossaries / Nuances + +These words / sentences should be treated carefully: + +## Machine + +Should be interpreted as "computer" or "system" (not a literal machine). + +E.g. in Spanish use "equipo" or "computadora", not "máquina". \ No newline at end of file diff --git a/astro.config.mjs b/astro.config.mjs index 751e7ee..86c62ff 100644 --- a/astro.config.mjs +++ b/astro.config.mjs @@ -27,6 +27,17 @@ export default defineConfig({ components: { EditLink: './src/components/EditLink.astro', }, + defaultLocale: 'root', + locales: { + // English docs in `src/content/docs/en/` + root: { + label: 'English', + lang: 'en' + }, + it: { + label: 'Italiano', + } + }, plugins: [ // Generate the OpenAPI documentation pages. starlightOpenAPI([ @@ -56,6 +67,9 @@ export default defineConfig({ sidebar: [ { label: 'Installation', + translations: { + it: "Installazione" + }, slug: 'installation' }, { From a244b5460f9200165e0600a550a6a339534580c2 Mon Sep 17 00:00:00 2001 From: Piero Toffanin Date: Wed, 15 Jul 2026 15:12:44 -0400 Subject: [PATCH 2/2] Add it translation --- AGENTS.md | 1 + astro.config.mjs | 149 +++- src/content/docs/it/api/authentication.md | 57 ++ src/content/docs/it/api/handlingerrors.md | 19 + src/content/docs/it/api/permissions.md | 24 + src/content/docs/it/api/quickstart.md | 106 +++ src/content/docs/it/api/task.md | 250 +++++++ src/content/docs/it/architecture.md | 20 + src/content/docs/it/contributing.md | 75 ++ src/content/docs/it/faq.md | 63 ++ .../docs/it/feedback-feature-requests.md | 31 + .../docs/it/flowchart-options-flags.md | 353 ++++++++++ src/content/docs/it/flying-tips.md | 37 + src/content/docs/it/ground-control-points.md | 222 ++++++ src/content/docs/it/index.mdx | 71 ++ src/content/docs/it/installation.md | 323 +++++++++ src/content/docs/it/mission-planning.md | 18 + src/content/docs/it/multispectral.md | 63 ++ src/content/docs/it/options-flags.md | 655 ++++++++++++++++++ .../docs/it/plugin-development-guide.md | 360 ++++++++++ src/content/docs/it/roadmap.md | 12 + src/content/docs/it/support-the-project.md | 62 ++ .../it/tutorials/calibrating-the-camera.md | 29 + .../creating-digital-elevation-models.md | 34 + .../creating-high-quality-orthophotos.md | 12 + .../docs/it/tutorials/large-datasets.md | 189 +++++ .../tutorials/measuring-stockpile-volume.md | 82 +++ .../it/tutorials/options-selection-guide.md | 351 ++++++++++ .../docs/it/tutorials/potree-3d-viewer.md | 146 ++++ src/content/docs/it/tutorials/using-docker.md | 83 +++ .../docs/it/tutorials/using-image-masks.md | 20 + src/content/docs/it/tutorials/using-podman.md | 75 ++ .../docs/it/tutorials/using-singularity.md | 104 +++ 33 files changed, 4069 insertions(+), 27 deletions(-) create mode 100644 src/content/docs/it/api/authentication.md create mode 100644 src/content/docs/it/api/handlingerrors.md create mode 100644 src/content/docs/it/api/permissions.md create mode 100644 src/content/docs/it/api/quickstart.md create mode 100644 src/content/docs/it/api/task.md create mode 100644 src/content/docs/it/architecture.md create mode 100644 src/content/docs/it/contributing.md create mode 100644 src/content/docs/it/faq.md create mode 100644 src/content/docs/it/feedback-feature-requests.md create mode 100644 src/content/docs/it/flowchart-options-flags.md create mode 100644 src/content/docs/it/flying-tips.md create mode 100644 src/content/docs/it/ground-control-points.md create mode 100644 src/content/docs/it/index.mdx create mode 100644 src/content/docs/it/installation.md create mode 100644 src/content/docs/it/mission-planning.md create mode 100644 src/content/docs/it/multispectral.md create mode 100644 src/content/docs/it/options-flags.md create mode 100644 src/content/docs/it/plugin-development-guide.md create mode 100644 src/content/docs/it/roadmap.md create mode 100644 src/content/docs/it/support-the-project.md create mode 100644 src/content/docs/it/tutorials/calibrating-the-camera.md create mode 100644 src/content/docs/it/tutorials/creating-digital-elevation-models.md create mode 100644 src/content/docs/it/tutorials/creating-high-quality-orthophotos.md create mode 100644 src/content/docs/it/tutorials/large-datasets.md create mode 100644 src/content/docs/it/tutorials/measuring-stockpile-volume.md create mode 100644 src/content/docs/it/tutorials/options-selection-guide.md create mode 100644 src/content/docs/it/tutorials/potree-3d-viewer.md create mode 100644 src/content/docs/it/tutorials/using-docker.md create mode 100644 src/content/docs/it/tutorials/using-image-masks.md create mode 100644 src/content/docs/it/tutorials/using-podman.md create mode 100644 src/content/docs/it/tutorials/using-singularity.md diff --git a/AGENTS.md b/AGENTS.md index 279fe19..176368a 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -18,6 +18,7 @@ This is the documentation repository of LibreTranslate, a free and open source t - When translating internal links, we always reference them with the appropriate URL that maps to a markdown file of the translation. - Never modify any other file other than those in `src/content` or `astro.config.mjs` without explicit permission. - When translating, always check that all the sidebar items in `astro.config.mjs` have a proper translation item in the `translations` key. +- At the top of markdown documents, make sure to always fill in the template preamble `---` with `title: ` and `template: doc` # How to build / check that the website builds diff --git a/astro.config.mjs b/astro.config.mjs index 86c62ff..5a2a8eb 100644 --- a/astro.config.mjs +++ b/astro.config.mjs @@ -29,13 +29,15 @@ export default defineConfig({ }, defaultLocale: 'root', locales: { - // English docs in `src/content/docs/en/` + // English docs at the root of `src/content/docs/` root: { label: 'English', lang: 'en' }, + // Italian docs in `src/content/docs/it/` it: { label: 'Italiano', + lang: 'it' } }, plugins: [ @@ -74,128 +76,221 @@ export default defineConfig({ }, { label: 'Ground Control Points', + translations: { + it: "Punti di Controllo a Terra" + }, slug: 'ground-control-points' }, { label: 'Multispectral and Thermal', + translations: { + it: "Multispettrale e Termico" + }, slug: 'multispectral' }, { label: 'Tutorials', + translations: { + it: "Tutorial" + }, items: [ { label: 'Creating Quality Orthophotos', - slug: 'tutorials/creating-high-quality-orthophotos' + slug: 'tutorials/creating-high-quality-orthophotos', + translations: { + it: "Creazione di Ortofoto di Qualità" + } }, { label: 'Digital Elevation Models', - slug: 'tutorials/creating-digital-elevation-models' + slug: 'tutorials/creating-digital-elevation-models', + translations: { + it: "Modelli Digitali di Elevazione" + } }, { label: '3D Viewer', - slug: 'tutorials/potree-3d-viewer' + slug: 'tutorials/potree-3d-viewer', + translations: { + it: "Visualizzatore 3D" + } }, { label: 'Measuring Stockpiles', - slug: 'tutorials/measuring-stockpile-volume' + slug: 'tutorials/measuring-stockpile-volume', + translations: { + it: "Misurazione di Cumuli" + } }, { label: 'Large Datasets', - slug: 'tutorials/large-datasets' + slug: 'tutorials/large-datasets', + translations: { + it: "Grandi Set di Dati" + } }, { label: 'Using Docker', - slug: 'tutorials/using-docker' + slug: 'tutorials/using-docker', + translations: { + it: "Uso di Docker" + } }, { label: 'Using Podman', - slug: 'tutorials/using-podman' + slug: 'tutorials/using-podman', + translations: { + it: "Uso di Podman" + } }, { label: 'Calibrating the Camera', - slug: 'tutorials/calibrating-the-camera' + slug: 'tutorials/calibrating-the-camera', + translations: { + it: "Calibrazione della Fotocamera" + } }, { label: 'Using Image Masks', - slug: 'tutorials/using-image-masks' + slug: 'tutorials/using-image-masks', + translations: { + it: "Uso di Maschere di Immagine" + } }, { label: 'Using Singularity', - slug: 'tutorials/using-singularity' + slug: 'tutorials/using-singularity', + translations: { + it: "Uso di Singularity" + } }, { label: 'Options Selection Guide', - slug: 'tutorials/options-selection-guide' + slug: 'tutorials/options-selection-guide', + translations: { + it: "Guida alla Selezione delle Opzioni" + } }, ] }, { label: 'Flying Tips', - slug: 'flying-tips' + slug: 'flying-tips', + translations: { + it: "Consigli di Volo" + } }, { label: 'Options & Flags', - slug: 'options-flags' + slug: 'options-flags', + translations: { + it: "Opzioni e Flag" + } }, { label: 'Mission Planning', - slug: 'mission-planning' + slug: 'mission-planning', + translations: { + it: "Pianificazione della Missione" + } }, { label: 'Frequently Asked Questions', - slug: 'faq' + slug: 'faq', + translations: { + it: "Domande Frequenti" + } }, { label: 'Support the Project', - slug: 'support-the-project' + slug: 'support-the-project', + translations: { + it: "Sostieni il Progetto" + } }, { label: 'Feedback & Feature Requests', - slug: 'feedback-feature-requests' + slug: 'feedback-feature-requests', + translations: { + it: "Feedback e Richieste di Funzionalità" + } }, { label: 'Developers', + translations: { + it: "Sviluppatori" + }, items: [ { label: 'Contributing', - slug: 'contributing' + slug: 'contributing', + translations: { + it: "Contribuire" + } }, { label: 'Architecture', - slug: 'architecture' + slug: 'architecture', + translations: { + it: "Architettura" + } }, { label: 'Roadmap', - slug: 'roadmap' + slug: 'roadmap', + translations: { + it: "Roadmap" + } }, { label: 'Plugin Development Guide', - slug: 'plugin-development-guide' + slug: 'plugin-development-guide', + translations: { + it: "Guida allo Sviluppo di Plugin" + } }, ] }, { label: 'API', + translations: { + it: "API" + }, items: [ { label: 'Quickstart', - slug: 'api/quickstart' + slug: 'api/quickstart', + translations: { + it: "Avvio Rapido" + } }, { label: 'Authentication', - slug: 'api/authentication' + slug: 'api/authentication', + translations: { + it: "Autenticazione" + } }, { label: 'Task', - slug: 'api/task' + slug: 'api/task', + translations: { + it: "Task" + } }, { label: 'Permissions', - slug: 'api/permissions' + slug: 'api/permissions', + translations: { + it: "Permessi" + } }, { label: 'Handling Errors', - slug: 'api/handlingerrors' + slug: 'api/handlingerrors', + translations: { + it: "Gestione degli Errori" + } }, ...openAPISidebarGroups ] diff --git a/src/content/docs/it/api/authentication.md b/src/content/docs/it/api/authentication.md new file mode 100644 index 0000000..fa0017f --- /dev/null +++ b/src/content/docs/it/api/authentication.md @@ -0,0 +1,57 @@ +--- +title: Autenticazione +template: doc +--- + +### Nozioni di Base sull'Autenticazione + +> Ottenere il token di autenticazione: + +```bash +curl -X POST -d "username=testuser&password=testpass" http://localhost:8000/api/token-auth/ + +{"token":"eyJ0eXAiO..."} +``` + +> Utilizzare il token di autenticazione: + +```bash +curl -H "Authorization: JWT " http://localhost:8000/api/projects/ + +{"count":13, ...} +``` + +> Utilizzare il token di autenticazione tramite querystring (meno sicuro): + +```bash +curl http://localhost:8000/api/projects/?jwt= + +{"count":13, ...} +``` + + +`POST /api/token-auth/` + +Campo | Tipo | Descrizione +----- | ---- | ----------- +username | string | Nome utente +password | string | Password + +Per accedere all'API è necessario fornire un nome utente e una password validi. Puoi creare gli utenti dalla pagina di Amministrazione di WebODM. + +Se l'autenticazione ha esito positivo, ti verrà rilasciato un token. Tutte le chiamate API devono includere il seguente header: + +Header | +------ | +Authorization: JWT `your_token` | + +Il token scade dopo un determinato periodo di tempo. Consulta [Scadenza del Token](#scadenza-del-token) per maggiori informazioni. + +Poiché a volte le applicazioni non consentono di modificare gli header, è anche possibile autenticarsi aggiungendo il parametro querystring `jwt` a un URL protetto. Questo metodo è meno sicuro, quindi se possibile passa il token tramite header. + + +### Scadenza del Token + +Per impostazione predefinita il token scade dopo sei ore. Il tempo di scadenza è definito nel modulo settings di Django in WebODM. Se compili WebODM dai sorgenti o lo esegui in modo nativo, il tempo di scadenza può essere modificato tramite la variabile `JWT_AUTH['JWT_EXPIRATION_DELTA']`. In caso contrario, ad esempio se utilizzi le immagini docker, dovrai richiedere un nuovo token quando un token scade. + +Puoi capire che un token è scaduto se una qualsiasi chiamata API restituisce un codice di stato `403` con il corpo JSON `{'detail': 'Signature has expired.'}`. diff --git a/src/content/docs/it/api/handlingerrors.md b/src/content/docs/it/api/handlingerrors.md new file mode 100644 index 0000000..e3a3b45 --- /dev/null +++ b/src/content/docs/it/api/handlingerrors.md @@ -0,0 +1,19 @@ +--- +title: Gestione degli Errori +template: doc +--- + +Tutte le chiamate API utilizzano i codici di stato descritti nella [Guida ai Codici di Stato del Django REST Framework](http://www.django-rest-framework.org/api-guide/status-codes/), ma in generale è sufficiente verificare i codici di stato di successo (`200` o `204`), gestire il caso speciale della [Scadenza del Token](/it/api/authentication/#scadenza-del-token) (`403`) e segnalare un errore in tutti gli altri casi. + +### Codici di Stato di Errore + +Questo non è un elenco esaustivo, ma i codici di errore più comuni sono riportati di seguito. + +Codice di Stato | Descrizione +----------- | ----------- +401 | Non autenticato +403 | Accesso negato (token scaduto?) +400 | Richiesta malformata +404 | Non trovato + +Per motivi di sicurezza, a volte un'operazione che dovrebbe restituire `403` restituisce `404`, per evitare di rivelare ID e altre informazioni a potenziali malintenzionati. diff --git a/src/content/docs/it/api/permissions.md b/src/content/docs/it/api/permissions.md new file mode 100644 index 0000000..ddf8aeb --- /dev/null +++ b/src/content/docs/it/api/permissions.md @@ -0,0 +1,24 @@ +--- +title: Permessi +template: doc +--- + +WebODM include un sistema standard di permessi a `livello di modello` (model level). Puoi +verificare se gli utenti hanno effettuato l'accesso e dispongono dei privilegi per agire sugli oggetti +a livello di modello (un utente può aggiungere un progetto? un utente può visualizzare i progetti?). + +Oltre a questo, WebODM offre un potente sistema di permessi a `livello di riga` (row level). Puoi specificare esattamente a quali elementi un utente ha o non ha accesso, cosa può eliminare, modificare, ecc. + +Le modifiche ai permessi degli oggetti possono essere gestite tramite la pagina di `Amministrazione` di WebODM. + +Stiamo pianificando di rendere più semplice la gestione dei permessi tramite API per utenti e sviluppatori. Si tratta di un lavoro in corso. + + +### Valori dei Permessi + +Permesso | Descrizione +----- | ----------- +delete | L'oggetto può essere eliminato +change | L'oggetto può essere modificato +add | Un oggetto correlato può essere aggiunto all'oggetto (un task può essere aggiunto al progetto) +view | L'oggetto può essere visualizzato (sola lettura) diff --git a/src/content/docs/it/api/quickstart.md b/src/content/docs/it/api/quickstart.md new file mode 100644 index 0000000..0e8ee1c --- /dev/null +++ b/src/content/docs/it/api/quickstart.md @@ -0,0 +1,106 @@ +--- +title: Avvio Rapido +template: doc +--- + +## Come Elaborare le Immagini + +In questo tutorial esploreremo come elaborare un'ortofoto a partire da un insieme di immagini aeree utilizzando Python. Per farlo dovremo: + + - Autenticarci + - Creare un [Progetto](/api/reference/operations/projects_create/). I progetti sono un modo per raggruppare insieme [Task](/it/api/task/) correlati + - Caricare alcune immagini per creare un [Task](/it/api/task/) + - Controllare lo stato di avanzamento del [Task](/it/api/task/). La fotogrammetria può richiedere molto tempo, quindi l'elaborazione dei risultati potrebbe impiegare da alcuni minuti ad alcune ore. + - Scaricare l'ortofoto risultante. + + + + + +```python +import requests +res = requests.post('http://localhost:8000/api/token-auth/', + data={'username': 'admin', + 'password': 'admin'}).json() +token = res['token'] +``` + +Per prima cosa ci autentichiamo con WebODM. Quando l'autenticazione ha esito positivo viene restituito un `token`. +
+ +```python +res = requests.post('http://localhost:8000/api/projects/', + headers={'Authorization': 'JWT {}'.format(token)}, + data={'name': 'Hello WebODM!'}).json() +project_id = res['id'] +``` + +Dobbiamo poi creare un [Progetto](/api/reference/operations/projects_create/). Passiamo il nostro `token` tramite l'header `Authorization`. Se dimentichiamo di passare questo header, il sistema non ci autenticherà e rifiuterà di elaborare la richiesta. Assegniamo inoltre un `name` al nostro progetto. +
+ +```python +images = [ + ('images', ('image1.jpg', open('image1.jpg', 'rb'), 'image/jpg')), + ('images', ('image2.jpg', open('image2.jpg', 'rb'), 'image/jpg')), + # ... +] +options = json.dumps([ + {'name': "orthophoto-resolution", 'value': 24} +]) + +res = requests.post('http://localhost:8000/api/projects/{}/tasks/'.format(project_id), + headers={'Authorization': 'JWT {}'.format(token)}, + files=images, + data={ + 'options': options + }).json() + +task_id = res['id'] +``` + +Possiamo quindi creare un [Task](/it/api/task/). L'unico parametro obbligatorio è un elenco di più `images` codificate in multipart. L'elaborazione inizierà automaticamente +non appena un [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) sarà disponibile. È possibile specificare opzioni aggiuntive passando un valore `options`, ovvero un elenco codificato in JSON di coppie nome/valore. Sono disponibili diverse altre opzioni. Consulta il riferimento [Opzioni e Flag](/it/options-flags/) per maggiori informazioni. +
+ +```python +while True: + res = requests.get('http://localhost:8000/api/projects/{}/tasks/{}/'.format(project_id, task_id), + headers={'Authorization': 'JWT {}'.format(token)}).json() + + if res['status'] == status_codes.COMPLETED: + print("Task has completed!") + break + elif res['status'] == status_codes.FAILED: + print("Task failed: {}".format(res)) + sys.exit(1) + else: + print("Processing, hold on...") + time.sleep(3) +``` + +Controlliamo periodicamente lo stato del [Task](/it/api/task/) utilizzando un ciclo. +
+ +```python +res = requests.get("http://localhost:8000/api/projects/{}/tasks/{}/download/orthophoto.tif".format(project_id, task_id), + headers={'Authorization': 'JWT {}'.format(token)}, + stream=True) +with open("orthophoto.tif", 'wb') as f: + for chunk in res.iter_content(chunk_size=1024): + if chunk: + f.write(chunk) +print("Saved ./orthophoto.tif") +``` + +La nostra ortofoto è pronta per essere scaricata. Sono [disponibili anche](/it/api/task/#scaricare-gli-asset) numerosi altri asset, tra cui una nuvola di punti 3D densa e un modello con texture. + +Congratulazioni! Hai appena elaborato alcune immagini. + +![Successo](https://i.imgflip.com/2/ipzhf.jpg) diff --git a/src/content/docs/it/api/task.md b/src/content/docs/it/api/task.md new file mode 100644 index 0000000..f605944 --- /dev/null +++ b/src/content/docs/it/api/task.md @@ -0,0 +1,250 @@ +--- +title: Task +template: doc +--- + +> Esempio di task: + +```json +{ + "id": 134, + "project": 27, + "processing_node": 10, + "processing_node_name": "localhost:3000", + "images_count": 48, + "can_rerun_from": [], + "available_assets": [ + "all.zip", + "orthophoto.tif", + "orthophoto.png", + "georeferenced_model.las", + "georeferenced_model.ply", + "georeferenced_model.csv", + "textured_model.zip" + ], + "uuid": "4338d684-91b4-49a2-b907-8ba171894393", + "name": "Task Name", + "processing_time": 2197417, + "auto_processing_node": false, + "status": 40, + "last_error": null, + "options": [ + { + "name": "use-opensfm-pointcloud", + "value": true + } + ], + "created_at": "2017-02-18T18:01:55.402551Z", + "pending_action": null, + "upload_progress": 1.0, + "resize_progress": 0.0, + "running_progress": 1.0 +} +``` + +Un [Task](/it/api/task/) è l'unità di elaborazione di base di WebODM. Per calcolare un'ortofoto, una nuvola di punti e un modello con texture a partire da un insieme di immagini, è necessario creare un [Task](/it/api/task/). + +Campo | Tipo | Descrizione +----- | ---- | ----------- +id | int | Identificatore univoco +project | int | ID del [Progetto](/api/reference/operations/projects_create/) a cui appartiene il task +processing_node | int | L'ID del [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) a cui questo task è stato assegnato, oppure `null` se nessun [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) è stato assegnato. +processing_node_name | string | Il nome del nodo di elaborazione di cui sopra, oppure `null` se nessun [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) è stato assegnato. +images_count | int | Numero di immagini +can_rerun_from | string[] | Elenco delle possibili opzioni "rerun-from" da cui questo task potrebbe ripartire, dato il nodo di elaborazione attualmente assegnato. Se questo è un elenco vuoto, il task può essere riavviato solo dall'inizio della pipeline. +available_assets | string[] | Elenco degli [asset](/it/api/task/#scaricare-gli-asset) disponibili per il download +uuid | string | Identificatore univoco assegnato da un [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) una volta iniziata l'elaborazione. +name | string | Nome del task definito dall'utente +processing_time | int | Millisecondi trascorsi dall'inizio dell'elaborazione, oppure `-1` se non sono disponibili informazioni. Utile per mostrare all'utente un resoconto del tempo trascorso. +auto_processing_node | boolean | Indica se WebODM deve assegnare automaticamente il prossimo [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) disponibile per elaborare questo [Task](/it/api/task/). Un utente può impostarlo a `false` per scegliere manualmente un [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/). +status | int | Uno dei [Codici di Stato](#codici-di-stato), oppure `null` se nessuno stato è disponibile. +last_error | string | L'ultimo messaggio di errore riportato da un [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) in caso di errore di elaborazione. +options | JSON[] | Elenco codificato in JSON di coppie nome/valore, dove ogni coppia rappresenta un'opzione da riga di comando da passare a un [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/). +created_at | string | Data e ora di creazione. +pending_action | int | Una delle [Azioni in Sospeso](#azioni-in-sospeso), oppure `null` se nessuna azione in sospeso è impostata. +upload_progress | float | Valore compreso tra 0 e 1 che indica l'avanzamento del caricamento dei file di questo task verso il nodo di elaborazione. +resize_progress | float | Valore compreso tra 0 e 1 che indica l'avanzamento del ridimensionamento delle immagini di questo task. +running_progress | float | Valore compreso tra 0 e 1 che indica l'avanzamento (stimato) dell'esecuzione di questo task. + + + + +### Creare un task + +`POST /api/projects/{project_id}/tasks/` + +Parametro | Obbligatorio | Predefinito | Descrizione +--------- | ------------ | ----------- | ----------- +images[] | * | "" | Elenco di immagini codificate in multipart (minimo 2) +processing_node | | null | L'ID del [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) a cui questo [Task](/it/api/task/) deve essere assegnato. Se non specificato, e auto_processing_node è `true`, un [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) verrà assegnato automaticamente. +name | | "" | Nome del task definito dall'utente +auto_processing_node | | true | Indica se WebODM deve assegnare automaticamente il prossimo [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) disponibile per elaborare questo [Task](/it/api/task/). +options | | "[]" | Elenco codificato in JSON di coppie nome/valore, dove ogni coppia rappresenta un'opzione da riga di comando da passare a un [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/). + +Puoi assegnare un [Task](/it/api/task/) a un [Progetto](/api/reference/operations/projects_create/) passando il corretto `project_id` nel percorso dell'URL. + + +### Aggiornare un task + +`PATCH /api/projects/{project_id}/tasks/{task_id}/` + +I parametri sono gli stessi indicati sopra. + +### Importare un Task + +`POST /api/projects/{project_id}/tasks/import` + +Importa task che sono stati elaborati da un'altra istanza di WebODM (oppure tramite [webodm.net](https://webodm.net) o NodeODX) + +Parametro | Obbligatorio | Predefinito | Descrizione +--------- | ------------ | ------- | ---------- +name | | Imported Task | Nome del task definito dall'utente. +filename | */ | "" | File contenente gli asset. Deve essere uno zip. +url | /* | "" | URL degli asset compressi in zip. + +Per importare gli asset creati devi fornire il parametro `filename` oppure `url` (ma non entrambi). + +Ricorda di impostare il Content-type corretto per la richiesta a seconda di come vengono caricati gli asset: + +Parametro | Content-Type +--------- | --- +filename | application/zip +url | application/x-www-form-urlencoded + +### Ottenere l'elenco dei task + +> Elenco dei task: + +```json +[ + { + "id": 6, + "project": 2, + "processing_node": 2, + "processing_node_name": "localhost:3000", + "images_count": 89, + "uuid": "2e8b687d-c269-4e2f-91b3-5a2cd51b5321", + "name": "Test name", + "processing_time": 8402184, + "auto_processing_node": true, + "status": 40, + "last_error": null, + "options": [], + "created_at": "2016-12-08T13:32:28.139474Z", + "pending_action": null, + "upload_progress": 1.0, + "resize_progress": 0.0, + "running_progress": 1.0 + } +] +``` + +`GET /api/projects/{project_id}/tasks/` + +Recupera tutti i [Task](/it/api/task/) associati a `project_id`. + +### Scaricare gli asset + +`GET /api/projects/{project_id}/tasks/{task_id}/download/{asset}` + +Dopo che un task è stato elaborato con successo, l'utente può scaricare diversi asset da questo URL. Non tutti gli asset sono sempre disponibili. Ad esempio, se le informazioni GPS sono assenti dalle immagini di input, l'asset `orthophoto.tif` non sarà presente. Puoi controllare la proprietà `available_assets` di un [Task](/it/api/task/) per vedere quali asset sono disponibili per il download. + +Asset | Descrizione +----- | ----------- +all.zip | Archivio (.zip) contenente tutti gli asset, tra cui un'ortofoto, le tile TMS, un modello 3D con texture e la nuvola di punti in vari formati. +orthophoto.tif | Ortofoto GeoTIFF. +orthophoto.png | Ortofoto PNG. +orthophoto.mbtiles | Archivio MBTiles dell'ortofoto. +textured_model.zip | Archivio contenente il modello 3D con texture +georeferenced_model.las | Nuvola di punti in formato .LAS. +georeferenced_model.ply | Nuvola di punti in formato .PLY. +georeferenced_model.csv | Nuvola di punti in formato .CSV. + +### Scaricare gli asset (percorso diretto) + +`GET /api/projects/{project_id}/tasks/{task_id}/assets/{path}` + +Dopo che un task è stato elaborato con successo, i suoi asset vengono archiviati in una directory sul file system. Questa chiamata API consente l'accesso diretto ai file di quella directory (per impostazione predefinita: `WebODM/app/media/project/{project_id}/task/{task_id}/assets`). Questo può essere utile per le applicazioni che vogliono trasmettere in streaming un dataset `Potree`, o renderizzare al volo un modello 3D con texture. + + + +### Recuperare l'output della console + +> Esempio di output della console: + +```bash +curl -H "Authorization: JWT " http://localhost:8000/api/projects/2/tasks/1/output/?line=5 + +[DEBUG] /var/www/data/e453747f-5fd4-4654-9622-b02727b29fc5/images\n[DEBUG] Loaded DJI_0219.JPG | camera: dji fc300s ... +``` + + +`GET /api/projects/{project_id}/tasks/{task_id}/output/` + +Mentre un [Task](/it/api/task/) è in fase di elaborazione, i nodi di elaborazione restituiscono una stringa di output che può essere utilizzata a scopo di debug e informativo. L'output è disponibile solo dopo l'inizio dell'elaborazione. + +Parametro | Obbligatorio | Predefinito | Descrizione +--------- | ------------ | ----------- | ----------- +line | | 0 | Mostra solo l'output a partire da un certo numero di riga. Questo può essere utile per mostrare l'output in tempo reale all'utente, tenendo traccia del numero di righe già mostrate finora ed evitando così di scaricare tutto l'output a ogni richiesta. + +### Annullare un task + +`POST /api/projects/{project_id}/tasks/{task_id}/cancel/` + +Interrompe l'elaborazione di un [Task](/it/api/task/). I task annullati possono essere riavviati. + +### Rimuovere un task + +`POST /api/projects/{project_id}/tasks/{task_id}/remove/` + +Anche tutti gli asset associati verranno eliminati. Se il [Task](/it/api/task/) è attualmente in fase di elaborazione, l'elaborazione verrà interrotta. + +### Riavviare un task + +`POST /api/projects/{project_id}/tasks/{task_id}/restart/` + +Se un [Task](/it/api/task/) è stato annullato o la sua elaborazione non è riuscita, oppure è stato completato ma l'utente ha deciso di cambiare le opzioni di elaborazione, può essere riavviato. Se il [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) assegnato al [Task](/it/api/task/) non è cambiato, l'elaborazione avverrà più rapidamente rispetto alla creazione di un nuovo [Task](/it/api/task/), poiché il [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) ricorda lo `uuid` del [Task](/it/api/task/) e tenterà di riutilizzare i risultati precedenti della pipeline di calcolo. + +### Layer TMS dell'ortofoto + +`GET /api/projects/{project_id}/tasks/{task_id}/orthophoto/tiles.json` + +`GET /api/projects/{project_id}/tasks/{task_id}/orthophoto/tiles/{Z}/{X}/{Y}.png` + +Dopo che un task è stato elaborato con successo, viene reso disponibile un layer TMS per l'inclusione in programmi come [Leaflet](http://leafletjs.com/) o [Cesium](http://cesiumjs.org). + + + +### Layer TMS del Modello di Superficie + +`GET /api/projects/{project_id}/tasks/{task_id}/dsm/tiles.json` + +`GET /api/projects/{project_id}/tasks/{task_id}/dsm/tiles/{Z}/{X}/{Y}.png` + +### Layer TMS del Modello del Terreno + +`GET /api/projects/{project_id}/tasks/{task_id}/dtm/tiles.json` + +`GET /api/projects/{project_id}/tasks/{task_id}/dtm/tiles/{Z}/{X}/{Y}.png` + +### Azioni in Sospeso + +In alcune circostanze, un [Task](/it/api/task/) può avere un'azione in sospeso che richiede una certa quantità di tempo per essere eseguita. + +Azione in Sospeso | Codice | Descrizione +----- | ---- | ----------- +CANCEL | 1 | Il [Task](/it/api/task/) è in fase di annullamento +REMOVE | 2 | Il [Task](/it/api/task/) è in fase di rimozione +RESTART | 3 | Il [Task](/it/api/task/) è in fase di riavvio + +### Codici di Stato + +Stato | Codice | Descrizione +----- | ---- | ----------- +QUEUED | 10 | I file del [Task](/it/api/task/) sono stati caricati su un [Nodo di Elaborazione](/api/reference/operations/processingnodes_list/) e sono in attesa di essere elaborati. +RUNNING | 20 | Il [Task](/it/api/task/) è attualmente in fase di elaborazione. +FAILED | 30 | Il [Task](/it/api/task/) non è riuscito per qualche motivo (immagini insufficienti, memoria esaurita, Piero ha dimenticato di chiudere una parentesi, ecc.) +COMPLETED | 40 | Il [Task](/it/api/task/) è stato completato. Gli asset sono pronti per essere scaricati. +CANCELED | 50 | Il [Task](/it/api/task/) è stato annullato manualmente dall'utente. diff --git a/src/content/docs/it/architecture.md b/src/content/docs/it/architecture.md new file mode 100644 index 0000000..a537db0 --- /dev/null +++ b/src/content/docs/it/architecture.md @@ -0,0 +1,20 @@ +--- +title: Architettura +template: doc +--- + +[WebODM](https://github.com/WebODM/WebODM) è composto da diversi componenti. + +- [ODX](https://github.com/WebODM/ODX) è un toolkit a riga di comando che elabora immagini aeree. Gli utenti a proprio agio con la riga di comando probabilmente possono usare questo componente da solo. +- [NodeODX](https://github.com/WebODM/NodeODX) è un'interfaccia leggera e un'API (Application Program Interface) costruita direttamente sopra [ODX](https://github.com/WebODM/ODX). Gli utenti non a proprio agio con la riga di comando possono usare questa interfaccia per elaborare immagini aeree, e gli sviluppatori possono usare l'API per realizzare applicazioni. Funzionalità come l'autenticazione degli utenti, la visualizzazione delle mappe, ecc. non sono fornite. +- [WebODM](https://github.com/WebODM/WebODM) aggiunge ulteriori funzionalità come l'autenticazione degli utenti, la visualizzazione delle mappe, la visualizzazione 3D, un'API di livello più alto e la capacità di orchestrare più nodi di elaborazione (eseguire job in parallelo). I nodi di elaborazione sono semplicemente server che eseguono [NodeODX](https://github.com/WebODM/NodeODX). + +![webodm](https://cloud.githubusercontent.com/assets/1951843/25567386/5aeec7aa-2dba-11e7-9169-aca97b70db79.png) + +WebODM è costruito pensando alla scalabilità e alle prestazioni. Mentre la configurazione predefinita colloca tutti i database e le applicazioni sullo stesso sistema, gli utenti possono separarne i componenti per aumentare le prestazioni (es. collocare un worker Celery su un computer separato per eseguire task in background). + +![Architettura](https://user-images.githubusercontent.com/1951843/36916884-3a269a7a-1e23-11e8-997a-a57cd6ca7950.png) + +Alcune cose da notare: + * Usiamo worker Celery per eseguire task in background, come il ridimensionamento delle immagini e l'elaborazione dei risultati dei task, ma usiamo un meccanismo di scheduling ad-hoc per comunicare con NodeODX (che elabora le ortofoto, i modelli 3D, ecc.). La scelta di usare due sistemi separati per lo scheduling dei task è dovuta alla flessibilità che un meccanismo ad-hoc ci offre per determinate operazioni (cattura dell'output dei task, persistenza dei dati e possibilità di riavviare i task a metà, comunicazione tramite chiamate REST, ecc.). + * Se distribuiti su più computer, i worker Celery dovrebbero condividere tutti la loro directory `app/media` con l'applicazione Django (tramite condivisioni di rete). Puoi gestire i worker tramite `./worker.sh` diff --git a/src/content/docs/it/contributing.md b/src/content/docs/it/contributing.md new file mode 100644 index 0000000..52b2c67 --- /dev/null +++ b/src/content/docs/it/contributing.md @@ -0,0 +1,75 @@ +--- +title: Contribuire +template: doc +--- + +Fare un contributo di codice può sembrare intimidatorio, ma non è troppo difficile: + +1. Crea un fork del [repository WebODM](https://github.com/WebODM/WebODM/) +2. Clona il tuo repository in una directory +3. Crea un nuovo branch: `git checkout -b branchname`. +4. [Configura un ambiente di sviluppo](#configurare-un-ambiente-di-sviluppo) con docker. +5. Esegui il commit delle modifiche: `git commit -a -m "describe your changes"` +6. Esegui il push delle modifiche sul tuo repository: `git push origin branchname` +7. Crea una [pull request](https://github.com/WebODM/WebODM/compare) + +Non abbiamo molte regole. Segui le linee guida indicate nel documento [Contributing](https://github.com/WebODM/WebODM/blob/master/CONTRIBUTING.md), sii gentile con gli altri e andrà alla grande! :) + +## Configurare un Ambiente di Sviluppo + +Segui le [istruzioni di installazione docker di WebODM](https://github.com/WebODM/WebODM/#manual-installation-docker), quindi esegui: + +`./webodm.sh start --dev` + +È tutto! Puoi modificare qualsiasi file, inclusi i file SASS e React.js. Le modifiche verranno riflesse automaticamente nell'istanza WebODM in esecuzione. + +## Eseguire gli Unit Test + +Riteniamo che i test siano una parte necessaria per fornire software robusto. Cerchiamo di raggiungere una copertura di test completa per il codice backend e, come minimo, robusti smoke test per il codice frontend. + +Per eseguire gli unit test, digita semplicemente: + +`./webodm.sh test` + +## Applicare le Modifiche in Produzione + +Una volta terminate le modifiche, se avvii WebODM in modalità produzione (senza il flag `--dev`), noterai che le tue modifiche non sono presenti. Questo perché `webodm.sh` usa l'immagine docker `webodm/webodm_webapp` per avviare WebODM, che non contiene le tue modifiche. Per applicare le modifiche, devi ricostruire l'immagine docker localmente: + +`docker build -t webodm/webodm_webapp .` + +Puoi anche modificare il file `docker-compose.yml` per puntare a un'immagine diversa. + +## Panoramica del Progetto + +### Backend + +Il backend si basa principalmente su [Django](https://www.djangoproject.com/) e [Django REST Framework](http://www.django-rest-framework.org/). + +Non usiamo molto il sistema di template di Django, tranne che per le sezioni `Administration` e `Processing Nodes`. Usiamo invece Django per esporre una [API](/it/api/task/), che colleghiamo poi a un'app [React.js](https://facebook.github.io/react/). + +Le directory di interesse sono elencate di seguito: + +Directory | Descrizione +--------- | ----------- +`/app` | Applicazione principale; include i componenti dell'interfaccia utente, l'API, i test e la logica di backend. +`/nodeodx`| Applicazione che fa da ponte per la comunicazione tra WebODM e [NodeODX](https://github.com/WebODM/NodeODX). Include i propri unit test e modelli. +`/webodm` | Directory principale del progetto Django. I file di impostazione si trovano qui. + +### Frontend + +Usiamo un'app [React.js](https://facebook.github.io/react/) (sintassi [ES6](https://leanpub.com/understandinges6/read/)) e [SCSS](http://sass-lang.com/) per vari componenti dell'interfaccia utente, come la dashboard. Usiamo [webpack](https://webpack.github.io/) per compilare i componenti intermedi in un bundle statico. + +Le directory di interesse sono elencate di seguito: + +Directory | Descrizione +--------- | ----------- +`/app/templates/app` | Posizione dei template Django. Anche se non li usiamo molto, li utilizziamo per alcune pagine e come collante per inizializzare il codice React. +`/app/static/app/js` | Posizione dei file Javascript per tutti i componenti dell'interfaccia utente. +`/app/static/app/js/components` | Cerchiamo di separare i componenti in vari componenti React per favorirne la riusabilità. Ogni componente è memorizzato qui. +`/app/static/app/js/css` | Ogni componente dovrebbe avere il proprio file SCSS. Quei file sono memorizzati qui. + +`/app/static/app/js/main.jsx` è il punto di ingresso dell'interfaccia utente. Se ti chiedi come colleghiamo Django e React.js, questo è il file da cui iniziare la tua ricerca. + +### Documentazione + +Usiamo [Astro](https://astro.build) per generare la nostra documentazione. Consulta la [documentazione](https://docs.astro.build/en/getting-started/) del loro progetto per informazioni su come apportare modifiche alla documentazione. diff --git a/src/content/docs/it/faq.md b/src/content/docs/it/faq.md new file mode 100644 index 0000000..f351239 --- /dev/null +++ b/src/content/docs/it/faq.md @@ -0,0 +1,63 @@ +--- +title: Domande Frequenti +template: doc +--- + +## Qual è la relazione tra WebODM e OpenDroneMap? + +WebODM faceva parte del progetto OpenDroneMap. Dal 2026, WebODM non è più affiliato né collegato a OpenDroneMap. Sono due progetti separati. + +## Il software non usa sempre tutti i core della CPU / la memoria / la GPU. È normale? + +Sì. Il software cerca di utilizzare tutte le risorse disponibili, quando possibile, ma non sempre. È normale osservare un utilizzo della CPU del 10-15% in diversi momenti dell'elaborazione e un utilizzo della GPU dello 0% per lunghi periodi. + +## Come posso ottenere mappe alla massima risoluzione? + +Imposta [orthophoto-resolution](/it/options-flags/#orthophoto-resolution) e [dem-resolution](/it/options-flags/#dem-resolution) a un valore basso come `0.01`. + +## Dove Sono Memorizzati i Miei File? + +Quando si usa Docker, tutti i risultati dell'elaborazione sono memorizzati in un volume docker e non sono disponibili sul filesystem dell'host. Ci sono due volumi docker di particolare interesse: +1. Media (chiamato webodm_appmedia): è qui che vengono memorizzati tutti i file relativi a un progetto e a un task. +2. Postgres DB (chiamato webodm_dbdata): è ciò che il database Postgres utilizza per memorizzare i propri dati. + +Per maggiori informazioni su come questi due volumi vengono utilizzati e in quali container, consulta il file [docker-compose.yml](https://github.com/WebODM/WebODM/blob/master/docker-compose.yml). + +Per vari motivi, come la facilità di backup/ripristino, se vuoi memorizzare i tuoi file sul filesystem dell'host invece che in un volume docker, devi passare un percorso tramite le opzioni `--media-dir` e/o `--db-dir`: + +```bash +./webodm.sh restart --media-dir /home/user/webodm_data --db-dir /home/user/webodm_db +``` + +Nota che i risultati dei task esistenti non saranno disponibili dopo la modifica. Consulta la sezione [Migrate Data Volumes](https://docs.docker.com/engine/tutorials/dockervolumes/#backup-restore-or-migrate-data-volumes) della documentazione di Docker per informazioni sulla migrazione dei risultati dei task esistenti. + +## Posso elaborare due o più GeoTIFF di ortofoto per unirli insieme? + +No. WebODM è un software fotogrammetrico e le ortofoto non contengono le informazioni necessarie sulla fotocamera, poiché le immagini sono già state ortorettificate. Per farlo puoi usare questo [plugin QGIS](https://github.com/uav4geo/QRasterMerge). + +## Se uso la versione nativa del software, come posso allocare più risorse per l'elaborazione? + +Non è necessario; la versione nativa (non docker) del software utilizza già tutte le risorse disponibili. + +## Voglio realizzare un'applicazione commerciale che include WebODM. Ho bisogno di una licenza commerciale? + +WebODM è software libero e open source, rilasciato sotto licenza [AGPLv3](https://github.com/WebODM/WebODM/blob/master/LICENSE.md). Sei libero di realizzare e vendere applicazioni con esso, purché tu rispetti i requisiti della licenza, in particolare l'obbligo di divulgazione del codice sorgente, e segua le nostre [linee guida sul marchio](https://github.com/WebODM/WebODM/blob/master/TRADEMARK.md). + +## Esistono altre opzioni di licenza oltre alla AGPLv3? + +No, spiacenti! + +## Il tuo computer sta esaurendo la memoria. Cosa puoi fare? + +1. Innanzitutto puoi acquistare più RAM: questa è la soluzione definitiva. +2. In alternativa puoi ridimensionare le immagini durante il caricamento e/o regolare le impostazioni di qualità. +3. Configurare un file di swap. Sia in Windows che in Linux avrai bisogno preferibilmente di un SSD veloce o di un'unità NVME, e il processo di calcolo sarà comunque MOLTO più lento. + + - Se usi Windows con [Docker+WSL2](https://docs.docker.com/desktop/windows/wsl/) puoi aggiungere due righe nel tuo file .wslconfig in modo che Docker utilizzi un file di swap. Consulta anche la documentazione completa di Microsoft su [Advanced settings configuration in WSL](https://docs.microsoft.com/en-us/windows/wsl/wsl-config). + + ``` + swap=128GB + swapfile=C:\temp\wsl-swap.vhdx + ``` + + - In Linux puoi aggiungere un file di swap o una partizione dedicata allo swap. Per maggiori informazioni, consulta il tuo motore di ricerca preferito, poiché esistono molte distribuzioni e metodi diversi per aggiungere lo swap. diff --git a/src/content/docs/it/feedback-feature-requests.md b/src/content/docs/it/feedback-feature-requests.md new file mode 100644 index 0000000..734ec4b --- /dev/null +++ b/src/content/docs/it/feedback-feature-requests.md @@ -0,0 +1,31 @@ +--- +title: Feedback e Richieste di Funzionalità +template: doc +--- + +Tutto il software trae grande beneficio dal feedback degli utenti e dalle richieste di funzionalità. Incoraggiamo le persone a fornire feedback tramite i canali della [comunità](https://webodm.org/community). + +**Per favore, non** aprire richieste di funzionalità su GitHub senza prima discuterne con la comunità. 🙏 + +## Come Fornire Feedback + +Apri una discussione per descrivere qual è il problema, quale potrebbe essere un possibile miglioramento e **in che modo sei disposto ad aiutare**. Per esempio: + + * "Sono disposto ad aiutare con i test" + * "Sono disposto a pagare per risolvere questo problema" + * "Sono disposto a fornire dati di test" + * "Anche se non posso offrire alcun aiuto, spero che questo venga preso in considerazione" + +WebODM è libero e open source. **Pretendere** che qualcosa venga corretto o migliorato non convincerà le persone a farlo. **Suggerire** che qualcosa venga migliorato è un modo molto migliore per iniziare una discussione di feedback. + +:::tip +Un problema riguarda molte persone? È molto più convincente intervenire su un problema se riguarda molte persone, piuttosto che una singola persona o entità. +::: + +## Come Fare Richieste di Funzionalità + +Oltre alle linee guida sul feedback riportate sopra, dichiara se sei un hobbista o se usi WebODM professionalmente. Le richieste di funzionalità non sono la stessa cosa delle "richieste di tempo gratuito degli sviluppatori". Se guadagni con WebODM e hai bisogno di una funzionalità, per favore offriti di finanziare, almeno in parte, la funzionalità che stai richiedendo. + +Comprendiamo che può essere complicato o difficile ottenere finanziamenti per il software open source e prenderemo in considerazione tutte le richieste di funzionalità, indipendentemente dalla disponibilità di fondi. Ti chiediamo solo di dichiarare in anticipo la natura della tua richiesta (lavoro vs. hobby). + +Accogliamo con piacere anche contributi di codice per implementare le funzionalità, se il finanziamento non è un'opzione. Consulta [Contribuire](/it/contributing/). diff --git a/src/content/docs/it/flowchart-options-flags.md b/src/content/docs/it/flowchart-options-flags.md new file mode 100644 index 0000000..0c96a60 --- /dev/null +++ b/src/content/docs/it/flowchart-options-flags.md @@ -0,0 +1,353 @@ +--- +title: Diagramma di Flusso di Opzioni e Flag +template: doc +--- +```mermaid + +flowchart TB + +Images@{ shape: docs, label: "Immagini"} + +subgraph DatasetGroup[" "] + direction RL + Dataset["Dataset"] + ds_bg["bg-removal"] + ds_camera_lens["camera-lens"] + ds_cameras["cameras"] + ds_gcp["gcp"] + ds_geo["geo"] + ds_gps_accuracy["gps-accuracy"] + ds_primary_band["primary-band"] + ds_sky_removal["sky-removal"] + ds_use_exif["use-exif"] + ds_video_limit["video-limit"] + ds_video_resolution["video-resolution"] + + ds_bg ~~~ ds_camera_lens + ds_cameras ~~~ ds_gcp + ds_geo ~~~ ds_gps_accuracy + ds_primary_band ~~~ ds_sky_removal + ds_use_exif ~~~ ds_video_limit + ds_video_resolution + + click ds_bg "../options-flags/#bg-removal" + click ds_camera_lens "../options-flags/#camera-lens" + click ds_cameras "../options-flags/#cameras" + click ds_gcp "../options-flags/#gcp" + click ds_geo "../options-flags/#geo" + click ds_gps_accuracy "../options-flags/#gps-accuracy" + click ds_primary_band "../options-flags/#primary-band" + click ds_sky_removal "../options-flags/#sky-removal" + click ds_use_exif "../options-flags/#use-exif" + click ds_video_limit "../options-flags/#video-limit" + click ds_video_resolution "../options-flags/#video-resolution" +end + + +subgraph SplitGroup[" "] + direction RL + Split["Split"] + split_sm_cluster["sm-cluster"] + split_sm_no_align["sm-no-align"] + split_split["split"] + split_image_groups["split-image-groups"] + split_overlap["split-overlap"] + Split + split_sm_cluster ~~~ split_sm_no_align + split_split ~~~ split_image_groups + split_overlap + + click split_sm_cluster "../options-flags/#sm-cluster" + click split_sm_no_align "../options-flags/#sm-no-align" + click split_split "../options-flags/#split" + click split_image_groups "../options-flags/#split-image-groups" + click split_overlap "../options-flags/#split-overlap" +end + + Spliting["`**Suddivisione**`"] + + +subgraph OpenSFMGroup[" "] + direction RL + OpenSFM["OpenSFM"] + sfm_feature_quality["feature-quality"] + sfm_feature_type["feature-type"] + sfm_force_gps["force-gps"] + sfm_ignore_gsd["ignore-gsd"] + sfm_matcher_neighbors["matcher-neighbors"] + sfm_matcher_order["matcher-order"] + sfm_matcher_type["matcher-type"] + sfm_min_num_features["min-num-features"] + sfm_pc_quality["pc-quality"] + sfm_radiometric_calibration["radiometric-calibration"] + sfm_rolling_shutter["rolling-shutter"] + sfm_rolling_shutter_readout["rolling-shutter-readout"] + sfm_algorithm["sfm-algorithm"] + sfm_no_partial["sfm-no-partial"] + sfm_skip_band_alignment["skip-band-alignment"] + sfm_use_fixed_camera_params["use-fixed-camera-params"] + sfm_use_hybrid_bundle_adjustment["use-hybrid-bundle-adjustment"] + + OpenSFM + sfm_feature_quality ~~~ sfm_feature_type + sfm_force_gps ~~~ sfm_ignore_gsd + sfm_matcher_neighbors ~~~ sfm_matcher_order + sfm_matcher_type ~~~ sfm_min_num_features + sfm_pc_quality ~~~ sfm_radiometric_calibration + sfm_rolling_shutter ~~~ sfm_rolling_shutter_readout + sfm_algorithm ~~~ sfm_no_partial + sfm_skip_band_alignment ~~~ sfm_use_fixed_camera_params + sfm_use_hybrid_bundle_adjustment + + click sfm_feature_quality "../options-flags/#feature-quality" + click sfm_feature_type "../options-flags/#feature-type" + click sfm_force_gps "../options-flags/#force-gps" + click sfm_ignore_gsd "../options-flags/#ignore-gsd" + click sfm_matcher_neighbors "../options-flags/#matcher-neighbors" + click sfm_matcher_order "../options-flags/#matcher-order" + click sfm_matcher_type "../options-flags/#matcher-type" + click sfm_min_num_features "../options-flags/#min-num-features" + click sfm_pc_quality "../options-flags/#pc-quality" + click sfm_radiometric_calibration "../options-flags/#radiometric-calibration" + click sfm_rolling_shutter "../options-flags/#rolling-shutter" + click sfm_rolling_shutter_readout "../options-flags/#rolling-shutter-readout" + click sfm_algorithm "../options-flags/#sfm-algorithm" + click sfm_no_partial "../options-flags/#sfm-no-partial" + click sfm_skip_band_alignment "../options-flags/#skip-band-alignment" + click sfm_use_fixed_camera_params "../options-flags/#use-fixed-camera-params" + click sfm_use_hybrid_bundle_adjustment "../options-flags/#use-hybrid-bundle-adjustment" +end + +subgraph OpenMVSGroup[" "] + direction RL + OpenMVS["OpenMVS"] + openmvs_pc_filter["pc-filter"] + openmvs_pc_skip_geometric["pc-skip-geometric"] + + OpenMVS + openmvs_pc_filter ~~~ openmvs_pc_skip_geometric + + click openmvs_pc_filter "../options-flags/#pc-filter" + click openmvs_pc_skip_geometric "../options-flags/#pc-skip-geometric" +end + +subgraph FilterpointsGroup[" "] + direction RL + Filterpoints["Filterpoints"] + filter_auto_boundary["auto-boundary"] + filter_auto_boundary_distance["auto-boundary-distance"] + filter_boundary["boundary"] + filter_fast_orthophoto["fast-orthophoto"] + filter_pc_sample["pc-sample"] + + Filterpoints + filter_auto_boundary ~~~ filter_auto_boundary_distance + filter_boundary ~~~ filter_fast_orthophoto + filter_pc_sample + + click filter_auto_boundary "../options-flags/#auto-boundary" + click filter_auto_boundary_distance "../options-flags/#auto-boundary-distance" + click filter_boundary "../options-flags/#boundary" + click filter_fast_orthophoto "../options-flags/#fast-orthophoto" + click filter_pc_sample "../options-flags/#pc-sample" +end + +subgraph MeshingGroup[" "] + direction RL + Meshing["Meshing"] + mesh_octree_depth["mesh-octree-depth"] + mesh_size["mesh-size"] + mesh_skip_3dmodel["skip-3dmodel"] + Meshing + mesh_octree_depth ~~~ mesh_size ~~~ mesh_skip_3dmodel + + click mesh_octree_depth "../options-flags/#mesh-octree-depth" + click mesh_size "../options-flags/#mesh-size" + click mesh_skip_3dmodel "../options-flags/#skip-3dmodel" +end + +subgraph MvsTexturingGroup[" "] + direction RL + + MvsTexturing["MvsTexturing"] + texturing_keep_unseen_faces["texturing-keep-unseen-faces"] + texturing_single_material["texturing-single-material"] + texturing_skip_global_seam_leveling["texturing-skip-global-seam-leveling"] + texturing_use_3dmesh["use-3dmesh"] + MvsTexturing + + texturing_keep_unseen_faces + texturing_single_material ~~~ texturing_skip_global_seam_leveling + texturing_use_3dmesh + + click texturing_keep_unseen_faces "../options-flags/#texturing-keep-unseen-faces" + click texturing_single_material "../options-flags/#texturing-single-material" + click texturing_skip_global_seam_leveling "../options-flags/#texturing-skip-global-seam-leveling" + click texturing_use_3dmesh "../options-flags/#use-3dmesh" +end + +subgraph GeoreferencingGroup[" "] + direction RL + Georeferencing["Georeferenziazione"] + georef_align["align"] + georef_crop["crop"] + georef_pc_classify["pc-classify"] + georef_pc_copc["pc-copc"] + georef_pc_csv["pc-csv"] + georef_pc_ept["pc-ept"] + georef_pc_las["pc-las"] + Georeferencing + georef_align ~~~ georef_crop + georef_pc_classify ~~~ georef_pc_copc + georef_pc_csv ~~~ georef_pc_ept + georef_pc_las + + click georef_align "../options-flags/#align" + click georef_crop "../options-flags/#crop" + click georef_pc_classify "../options-flags/#pc-classify" + click georef_pc_copc "../options-flags/#pc-copc" + click georef_pc_csv "../options-flags/#pc-csv" + click georef_pc_ept "../options-flags/#pc-ept" + click georef_pc_las "../options-flags/#pc-las" +end + +subgraph DEMGroup[" "] + direction RL + DEM["DEM"] + dem_cog["cog"] + dem_decimation["dem-decimation"] + dem_euclidean_map["dem-euclidean-map"] + dem_gapfill_steps["dem-gapfill-steps"] + dem_resolution["dem-resolution"] + dem_dsm["dsm"] + dem_dtm["dtm"] + dem_smrf_scalar["smrf-scalar"] + dem_smrf_slope["smrf-slope"] + dem_smrf_threshold["smrf-threshold"] + dem_smrf_window["smrf-window"] + dem_tiles["tiles"] + DEM + + dem_cog ~~~ dem_decimation + dem_euclidean_map ~~~ dem_gapfill_steps + dem_resolution ~~~ dem_dsm + dem_dtm ~~~ dem_smrf_scalar + dem_smrf_slope ~~~ dem_smrf_threshold + dem_smrf_window ~~~ dem_tiles + + click dem_cog "../options-flags/#cog" + click dem_decimation "../options-flags/#dem-decimation" + click dem_euclidean_map "../options-flags/#dem-euclidean-map" + click dem_gapfill_steps "../options-flags/#dem-gapfill-steps" + click dem_resolution "../options-flags/#dem-resolution" + click dem_dsm "../options-flags/#dsm" + click dem_dtm "../options-flags/#dtm" + click dem_smrf_scalar "../options-flags/#smrf-scalar" + click dem_smrf_slope "../options-flags/#smrf-slope" + click dem_smrf_threshold "../options-flags/#smrf-threshold" + click dem_smrf_window "../options-flags/#smrf-window" + click dem_tiles "../options-flags/#tiles" +end + +subgraph OrthophotoGroup[" "] + direction RL + Orthophoto["Ortofoto"] + ortho_build_overviews["build-overviews"] + ortho_compression["orthophoto-compression"] + ortho_cutline["orthophoto-cutline"] + ortho_kmz["orthophoto-kmz"] + ortho_no_tiled["orthophoto-no-tiled"] + ortho_png["orthophoto-png"] + ortho_resolution["orthophoto-resolution"] + ortho_skip["skip-orthophoto"] + Orthophoto + ortho_build_overviews ~~~ ortho_compression + ortho_cutline ~~~ ortho_kmz + ortho_no_tiled ~~~ ortho_png + ortho_resolution ~~~ ortho_skip + + click ortho_build_overviews "../options-flags/#build-overviews" + click ortho_compression "../options-flags/#orthophoto-compression" + click ortho_cutline "../options-flags/#orthophoto-cutline" + click ortho_kmz "../options-flags/#orthophoto-kmz" + click ortho_no_tiled "../options-flags/#orthophoto-no-tiled" + click ortho_png "../options-flags/#orthophoto-png" + click ortho_resolution "../options-flags/#orthophoto-resolution" + click ortho_skip "../options-flags/#skip-orthophoto" +end + +subgraph ReportGroup[" "] + direction TB + Report["Report"] + report_skip["skip-report"] + Report ~~~ report_skip + report_skip + + click report_skip "../options-flags/#skip-report" +end + +subgraph PostprocessGroup[" "] + direction RL + Postprocess["Post-elaborazione"] + post_3d_tiles["3d-tiles"] + post_copy_to["copy-to"] + post_gltf["gltf"] + Postprocess + post_3d_tiles ~~~ post_copy_to ~~~ post_gltf + + click post_3d_tiles "../options-flags/#3d-tiles" + click post_copy_to "../options-flags/#copy-to" + click post_gltf "../options-flags/#gltf" +end + +Images e01@==> DatasetGroup +DatasetGroup e02@--> SplitGroup + +SplitGroup == Sì ==> Spliting ==> OpenSFMGroup +SplitGroup == No ==> OpenSFMGroup + +OpenSFMGroup e02@--> OpenMVSGroup +OpenMVSGroup e03@--> FilterpointsGroup +FilterpointsGroup e04@--> MeshingGroup +MeshingGroup e05@--> MvsTexturingGroup +MvsTexturingGroup e06@--> GeoreferencingGroup +GeoreferencingGroup e07@--> DEMGroup +DEMGroup e08@--> OrthophotoGroup +OrthophotoGroup e09@--> ReportGroup +ReportGroup e10@--> PostprocessGroup + + + +classDef subgraphTitle fill:#1f2937,stroke:#94a3b8,stroke-width:1.5px,color:#fff,font-weight:bold; +classDef greenNode fill:#90EE90,stroke:#2d5016,stroke-width:1px,color:#000; +classDef blueNode fill:#87CEEB,stroke:#1e3a5f,stroke-width:1px,color:#000; +classDef pinkNode fill:#FFB6C1,stroke:#8b3a3a,stroke-width:1px,color:#000; +classDef purpleNode fill:#DDA0DD,stroke:#5d3a5d,stroke-width:1px,color:#000; +classDef yellowNode fill:#F0E68C,stroke:#8b8b00,stroke-width:1px,color:#000; +classDef orangeNode fill:#FFA07A,stroke:#8b4513,stroke-width:1px,color:#000; +classDef mintNode fill:#98FB98,stroke:#3a5f3a,stroke-width:1px,color:#000; +classDef goldNode fill:#FFD700,stroke:#8b7500,stroke-width:1px,color:#000; +classDef skyNode fill:#87CEFA,stroke:#1e3a8a,stroke-width:1px,color:#000; +classDef sandNode fill:#DEB887,stroke:#5d4e37,stroke-width:1px,color:#000; +classDef redNode fill:#F08080,stroke:#8b3a3a,stroke-width:1px,color:#000; +classDef tealNode fill:#20B2AA,stroke:#0d5d5d,stroke-width:1px,color:#000; +classDef animatedEdge stroke-dasharray: 9,5,stroke-dashoffset: 900,animation: dash 25s linear infinite; + +class e01,e02,e03,e04,e05,e06,e07,e08,e09,e10 animatedEdge; + + +class Dataset,Split,OpenSFM,OpenMVS,Filterpoints,Meshing,MvsTexturing,Georeferencing,DEM,Orthophoto,Report,Postprocess subgraphTitle; +class ds_bg,ds_camera_lens,ds_cameras,ds_gcp,ds_geo,ds_gps_accuracy,ds_primary_band,ds_sky_removal,ds_use_exif,ds_video_limit,ds_video_resolution greenNode; +class Images,split_sm_cluster,split_sm_no_align,split_split,split_image_groups,split_overlap blueNode; +class sfm_feature_quality,sfm_feature_type,sfm_force_gps,sfm_ignore_gsd,sfm_matcher_neighbors,sfm_matcher_order,sfm_matcher_type,sfm_min_num_features,sfm_pc_quality,sfm_radiometric_calibration,sfm_rolling_shutter,sfm_rolling_shutter_readout,sfm_algorithm,sfm_no_partial,sfm_skip_band_alignment,sfm_use_fixed_camera_params,sfm_use_hybrid_bundle_adjustment pinkNode; +class openmvs_pc_filter,openmvs_pc_skip_geometric purpleNode; +class filter_auto_boundary,filter_auto_boundary_distance,filter_boundary,filter_fast_orthophoto,filter_pc_sample yellowNode; +class mesh_octree_depth,mesh_size,mesh_skip_3dmodel orangeNode; +class texturing_keep_unseen_faces,texturing_single_material,texturing_skip_global_seam_leveling,texturing_use_3dmesh mintNode; +class georef_align,georef_crop,georef_pc_classify,georef_pc_copc,georef_pc_csv,georef_pc_ept,georef_pc_las goldNode; +class dem_cog,dem_decimation,dem_euclidean_map,dem_gapfill_steps,dem_resolution,dem_dsm,dem_dtm,dem_smrf_scalar,dem_smrf_slope,dem_smrf_threshold,dem_smrf_window,dem_tiles skyNode; +class Spliting,ortho_build_overviews,ortho_compression,ortho_cutline,ortho_kmz,ortho_no_tiled,ortho_png,ortho_resolution,ortho_skip sandNode; +class report_skip redNode; +class post_3d_tiles,post_copy_to,post_gltf tealNode; + +``` diff --git a/src/content/docs/it/flying-tips.md b/src/content/docs/it/flying-tips.md new file mode 100644 index 0000000..f222e59 --- /dev/null +++ b/src/content/docs/it/flying-tips.md @@ -0,0 +1,37 @@ +--- +title: Consigli di Volo +template: doc +--- + +## Acquisizione dei Dati, 3D Completo + +Per risultati di prima classe con ricostruzione 3D completa, raccomandiamo quanto segue: + +- volo nadirale con sovrapposizione del 60% +- griglia incrociata con angolo del gimbal a 45 gradi e sovrapposizione del 70-80% + +Il volo a griglia incrociata a 45 gradi fornisce la base per un modello completamente legato, mentre i voli nadirali forniscono la texture necessaria per la texturizzazione dell'ortofoto. La sovrapposizione più bassa soddisfa il requisito minimo per i prodotti ortofoto, grazie al matching delle feature reso possibile dalla griglia incrociata con sovrapposizione molto più alta. + +## Acquisizione dei Dati, Prodotti 2D e 2.5D + +Per risultati di prima classe con prodotti 2D e 2.5D, raccomandiamo quanto segue: + +- sovrapposizione del 70-80% leggermente fuori nadir (5-10 gradi fuori nadir) + +Per edifici e vegetazione più complessi, punta a una sovrapposizione più vicina all'80-83%. Se edifici, vegetazione e variazioni del terreno non sono complessi, è del tutto fattibile usare una sovrapposizione più vicina al 70%. + +*(credito: derivato da conversazioni in corso con Ivan Gayton, Humanitarian OpenStreetMap Team)* + +## Altre Risorse sul Volo + +Il team [Humanitarian OpenStreetMap](https://www.hotosm.org/) ha delle linee guida sul [volo per la mappatura con UAV](https://uav-guidelines.openaerialmap.org/): + +- [Scegliere l'UAV giusto](https://uav-guidelines.openaerialmap.org/pages/05-choosing-the-right-uav/) +- [Scegliere il sensore giusto](https://uav-guidelines.openaerialmap.org/pages/06-choosing-the-sensor/) +- [Preparazione della missione](https://uav-guidelines.openaerialmap.org/pages/07-preparing-for-the-uav-mission/) + +Le linee guida sono pensate per progetti di mappatura con droni sulle isole, ma sono di utilità generale per tutti coloro che fanno mappatura con droni. + +Consulta anche la guida di WebODM Lightning su [come realizzare mappe di successo](https://docs.webodm.net/references/create-successful-maps). + +Infine, la distorsione dell'obiettivo è una sfida nei progetti che richiedono dati 3D accurati. Consulta la nostra sezione sulla [Calibrazione della Fotocamera](/it/tutorials/calibrating-the-camera/). diff --git a/src/content/docs/it/ground-control-points.md b/src/content/docs/it/ground-control-points.md new file mode 100644 index 0000000..cbb948b --- /dev/null +++ b/src/content/docs/it/ground-control-points.md @@ -0,0 +1,222 @@ +--- +title: Punti di Controllo a Terra +template: doc +--- + +I punti di controllo a terra sono utili per correggere le distorsioni nei dati e per riferire i dati a sistemi di coordinate noti. + +Un Punto di Controllo a Terra (GCP) è una misurazione di posizione effettuata sul terreno, tipicamente utilizzando un GPS ad alta precisione. + +I punti di controllo a terra possono essere posizionati su strutture esistenti come angoli di pavimentazione, linee di un parcheggio o piastrelle di colore contrastante, altrimenti possono essere realizzati usando target posizionati sul terreno. + +I target possono essere acquistati o costruiti con un'ampia varietà di materiali, dai coperchi di secchi alle piastrelle. + +### Pratiche Raccomandate per il Posizionamento dei GCP + +Mantieni i punti di controllo a terra visibili da tutte le posizioni della fotocamera. Considera la distanza di campionamento al suolo (GSD) prevista, l'illuminazione, la vegetazione, gli edifici e tutti gli ostacoli esistenti. + +Procura una distribuzione orizzontale uniforme dei GCP all'interno del progetto, coprendo le quote più alte e più basse. Un minimo di 5 GCP funziona per la maggior parte dei lavori, e per progetti più grandi 8–10 sono sufficienti. Posiziona alcuni punti vicino agli angoli e altri al centro, considerando che la spaziatura tra i GCP dovrebbe essere maggiore dell'impronta a terra dell'immagine, in modo da non poter vedere più di un GCP in una singola immagine. + +Per garantire che i GCP siano visibili in almeno 5 immagini, distanzia i punti da 10 a 30 metri dal perimetro del progetto. Questa distanza dipende dalla sovrapposizione, quindi aumentare la sovrapposizione dovrebbe ridurre la distanza richiesta dal perimetro. + +### Formato del File GCP + +Il formato del file GCP è semplice. + +- La prima riga deve contenere il nome della proiezione utilizzata per le coordinate geografiche. Questa può essere specificata come stringa PROJ (ad esempio `+proj=utm +zone=10 +ellps=WGS84 +datum=WGS84 +units=m +no_defs`), codice EPSG (ad esempio `EPSG:4326`) oppure come valore `WGS84 UTM [N|S]` (ad esempio `WGS84 UTM 16N`) +- Le righe successive sono le coordinate X, Y e Z, i pixel associati, il nome del file dell'immagine e campi extra opzionali, separati da tabulazioni o spazi +- Evita di impostare i valori di elevazione a "NaN" per indicare l'assenza di valore. Questo può causare errori di elaborazione. Usa invece 0.0 +- Analogamente, ridurre il numero di cifre dopo la virgola per `geo_x` e `geo_y` può anch'esso ridurre gli errori di elaborazione +- La settima colonna (opzionale) contiene tipicamente l'etichetta del GCP + +``` + +geo_x geo_y geo_z im_x im_y filename [label] [extra1] [extra2] +... +``` + +Esempio: + +``` ++proj=utm +zone=10 +ellps=WGS84 +datum=WGS84 +units=m +no_defs +544256.7 5320919.9 5 3044 2622 IMG_0525.jpg +544157.7 5320899.2 5 4193 1552 IMG_0585.jpg +544033.4 5320876.0 5 1606 2763 IMG_0690.jpg +``` + +:::note + * Il nome del file distingue tra maiuscole e minuscole. IMG_0001.jpg non è lo stesso di IMG_0001.JPG. + * Il nome del file non può contenere spazi. Gli spazi possono essere codificati usando la sequenza di escape %20. Ad esempio, My Image.JPG deve essere riferito come My%20Image.JPG. +::: + +Se fornisci un file GCP chiamato `gcp_list.txt`, WebODM lo rileverà automaticamente. Se hai un file gcp e vuoi invece effettuare la georeferenziazione con exif, puoi specificare `--use-exif`. Se hai misurazioni GPS ad alta precisione nelle tue immagini (RTK) e vuoi usare quelle informazioni insieme a un file gcp, puoi specificare `--force-gps`. + +È importante che tu trovi oggetti ad alto contrasto presenti in **almeno** 3 foto e che tu trovi un minimo di 5 oggetti. + +Gli angoli netti sono buone scelte per i GCP. Dovresti inoltre posizionare/individuare i GCP in modo uniforme all'interno dell'area di rilievo. + +Il file `gcp_list.txt` deve essere creato nella cartella base del tuo progetto. + +Per ottenere buoni risultati il tuo file dovrebbe avere un minimo di 15 righe dopo l'intestazione (5 punti con 3 immagini per ciascun punto). + +### Contrassegnare i Checkpoint + +I checkpoint vengono utilizzati per verificare l'accuratezza della ricostruzione. Vengono esclusi dal processo di ricostruzione e sono invece utilizzati per misurare l'accuratezza dei risultati alla fine. + +Puoi contrassegnare un checkpoint etichettandolo con il prefisso `CHK-`. Ad esempio: + +``` ++proj=utm +zone=10 +ellps=WGS84 +datum=WGS84 +units=m +no_defs +544256.7 5320919.9 5 3044 2622 IMG_0525.jpg CHK-A +``` + + +### Interfacce Utente + +Puoi usare una di due interfacce utente per creare file GCP: + +- [POSM GCPi](https://github.com/posm/posm-gcpi) +- [GCP Editor Pro](https://github.com/uav4geo/GCPEditorPro) + +#### POSM GCPi + +POSM GCPi è caricato per impostazione predefinita in WebODM. Per usarlo con valori XYZ di controllo a terra noti, si procede come segue: + +Crea una lista di GCP che includa solo nome del gcp, x, y e z, con un'intestazione contenente una stringa proj4 dei tuoi GCP (assicurati che siano in un sistema di coordinate planare, come UTM). Dovrebbe apparire più o meno così: + +``` ++proj=utm +zone=37 +south +ellps=WGS84 +datum=WGS84 +units=m +no_defs +gcp01 529356.250827686 9251137.5643209 8.465 +gcp02 530203.125367657 9250140.80991621 15.781 +gcp03 530292.136003818 9250745.02372435 11.977 +gcp04 530203.125367657 9250140.80991621 15.781 +gcp05 530292.136003818 9250745.02372435 11.977 +``` + +Poi è possibile caricare questa lista di GCP nell'interfaccia, caricare le immagini e posizionare ciascuno dei GCP nell'immagine. + +#### GCP Editor Pro + +:::tip[Lo Sapevi?] + +[GCP Editor Pro](https://gcp.uav4geo.com) è realizzato dagli sviluppatori di WebODM. Acquistarlo supporta direttamente lo sviluppo di WebODM. ❤ + +::: + +[GCP Editor Pro](https://gcp.uav4geo.com) deve essere acquistato, ma offre un flusso di lavoro più fluido rispetto a POSM GCPi. + +Per usarlo, crea un file CSV che includa i nomi dei GCP, la coordinata nord (northing), la coordinata est (easting) e l'elevazione. + +``` +GCP Label,Northing,Easting,Elevation +gcp01,529356.250827686,9251137.5643209,8.465 +gcp02,530203.125367657,9250140.80991621,15.781 +... +``` + +Poi importa il CSV dalla schermata principale e digita `+proj=utm +zone=37 +south +ellps=WGS84 +datum=WGS84 +units=m +no_defs` nella casella `EPSG/PROJ`. Puoi trovare un database di codici EPSG su https://epsg.io + +La schermata successiva mostrerà una mappa da cui selezionare i GCP da contrassegnare e importare le rispettive immagini. + +## Accuratezza della Mappa + +L'accuratezza può essere definita come il grado o la vicinanza con cui le informazioni su una mappa corrispondono ai valori nel mondo reale. Pertanto, quando parliamo di accuratezza, parliamo di qualità dei dati e del numero di errori contenuti in un determinato dataset (Pascual 2011). + +**Accuratezza Relativa o Locale** + +L'accuratezza locale o relativa può essere definita come il grado con cui le distanze tra due punti su una mappa corrispondono alle distanze reali tra quei punti nel mondo reale. + +L'accuratezza relativa è indipendente dalla posizione della mappa nel mondo, quindi una mappa può avere un'alta accuratezza relativa (in dimensione e forma) ma la sua posizione nel mondo può essere traslata. + +![Modello che mostra un'alta accuratezza relativa](/images/rel_accuracy.webp) + +*Figura 1. Modello che mostra un'alta accuratezza relativa ma posizionato in modo errato rispetto alla sua posizione nel mondo reale* + +**Accuratezza Assoluta o Globale** + +L'accuratezza assoluta è l'accuratezza della ricostruzione in relazione alla sua vera posizione sul pianeta (Pix4D 2019). La Figura 2 mostra un modello accurato in senso relativo e assoluto, poiché i punti sono posizionati correttamente rispetto alla loro posizione nel mondo reale. + +![Modello che mostra un'alta accuratezza assoluta](/images/abs_accuracy.webp) + +*Figura 2. Modello che mostra un'alta accuratezza relativa e assoluta. Posizionato correttamente rispetto alla sua posizione nel mondo reale* + +**Un Livello di Accuratezza per Ogni Progetto** + +Ogni progetto ha esigenze specifiche di accuratezza da soddisfare. Ad esempio, valutare l'avanzamento di un cantiere o misurare un'area colpita da un incendio non richiede l'uso di GCP, poiché l'accuratezza assoluta non influirà sul processo decisionale. D'altra parte, ci sono lavori in cui l'accuratezza è critica, ad esempio le valutazioni di conformità dei progetti e i rilievi catastali, che richiedono un'accuratezza relativa e assoluta più elevata. + +### Cosa Aspettarsi + +In termini generali, ci si può aspettare che l'accuratezza relativa sia nell'ordine di 1-3 volte il GSD medio del dataset. Per quanto riguarda l'accuratezza assoluta, bisogna considerare che dipende dall'unità GPS montata sull'UAV, ma l'accuratezza orizzontale di un GPS standard è solitamente compresa tra 2 e 6 metri e l'accuratezza verticale tra 3 e 4 volte l'accuratezza orizzontale. + +Utilizzando i GCP, l'accuratezza assoluta può essere migliorata fino a 2,5 volte il GSD per l'accuratezza orizzontale e 4 volte il GSD per l'accuratezza verticale (Madawalagama 2016). + +Con un GSD di 1 cm, l'accuratezza è pari a quella del GNSS RTK e rientra nelle scale 1:200 secondo gli standard di accuratezza cartografica NSDI e FGDC in condizioni non ottimali (Barry 2013). + +### Aspetti che Influenzano l'Accuratezza della Mappa + +**Meteo** — Le condizioni meteorologiche hanno un impatto diretto sui risultati della fotogrammetria, quindi è importante considerare la copertura nuvolosa, la velocità del vento, l'umidità, l'altezza del sole e altri fattori che influenzano la stabilità dell'UAV e l'illuminazione del terreno. + +**Fotocamere** — Sensori più grandi e migliori producono meno rumore e immagini messe a fuoco più nitidamente. Considera inoltre che le fotocamere con otturatore rolling shutter producono immagini distorte quando l'UAV è in movimento, quindi per i lavori di mappatura sono consigliate fotocamere con otturatore globale o meccanico. + +**Altitudine di volo** — Maggiore è l'altitudine di volo, maggiore è l'impronta a terra dell'immagine e il GSD. Con un GSD più grande l'accuratezza sarà ridotta poiché ci sarà meno dettaglio negli elementi riconoscibili. Quando è richiesto un GSD più piccolo, è raccomandata un'altitudine di 3-4 volte l'altezza del punto più alto. + +**Velocità di volo** — La velocità di volo ha un effetto particolare sulle fotocamere dotate di rolling shutter, mentre quelle dotate di otturatore globale o meccanico tendono a ridurre questo effetto. Anche gli UAV dotati di sistemi di posizionamento RTK sono influenzati dalla velocità, ma se si rimane in hovering a ogni scatto, si può ottenere un'ottima accuratezza. Se invece ci si muove durante ogni scatto, l'accuratezza sarà limitata da due fattori: la velocità di movimento moltiplicata per gli incrementi di 1 secondo dell'RTK (Mather 2020). + +## Migliorare l'Accuratezza Relativa + +La georeferenziazione per impostazione predefinita viene effettuata utilizzando GPS (GNSS) o GCP (se forniti). + +WebODM può anche allineare due task. Quando ciò accade, la ricostruzione verrà inizialmente eseguita utilizzando GPS/GCP e verrà successivamente allineata al modello di riferimento tramite un'operazione lineare di scala/rotazione/traslazione. + +### Dataset Multi-temporali + +Quando siti precedentemente mappati devono essere rivisitati, WebODM può allineare più versioni di un dataset nel tempo utilizzando una nuvola di punti o un modello di elevazione digitale precedenti. + +**Flusso di lavoro per dataset multi-temporali:** + +1. Elabora i tuoi dati originali. Questo passaggio non richiede un file di punti di controllo a terra, ma usane uno se l'accuratezza assoluta è un requisito del progetto +2. Carica un altro dataset che si allinei con il precedente e cerca l'opzione **Align**, quindi seleziona il task originale. + +### Allineare Dataset di Grandi Dimensioni + +Quando si tenta di elaborare dataset molto grandi, può essere necessario dividere un ampio set di immagini in blocchi più piccoli e gestibili per facilitarne l'elaborazione. Questo processo, tuttavia, può introdurre una certa incertezza rispetto all'allineamento di tutti gli output elaborati. Per assicurarci che tutte le nuvole di punti e i modelli del terreno/della superficie siano perfettamente allineati in preparazione della fusione, seguiamo le semplici tecniche descritte di seguito. + +## File di Geolocalizzazione delle Immagini + +Per impostazione predefinita WebODM utilizzerà le informazioni GPS incorporate nelle immagini, se disponibili. A volte le immagini non contengono informazioni GPS, oppure un utente desidera sovrascrivere le informazioni con dati più accurati (come RTK). + +Puoi anche utilizzare un file di geolocalizzazione per specificare i centroidi GPS delle immagini. + +Il formato del file di geolocalizzazione delle immagini è semplice. + +- La prima riga deve contenere il nome della proiezione utilizzata per le coordinate geografiche. Questa può essere specificata come stringa PROJ (ad esempio `+proj=utm +zone=10 +ellps=WGS84 +datum=WGS84 +units=m +no_defs`), codice EPSG (ad esempio `EPSG:4326`) oppure come valore `WGS84 UTM [N|S]` (ad esempio `WGS84 UTM 16N`) +- Le righe successive sono il nome del file dell'immagine, le coordinate X, Y e Z (opzionale), gli angoli della fotocamera (opzionali, attualmente usati solo per la calibrazione radiometrica) e l'accuratezza orizzontale/verticale (opzionale) +- Gli angoli della fotocamera possono essere impostati a `0` se non sono disponibili +- La decima colonna (opzionale) può contenere campi extra, come un'etichetta + +``` + +filename geo_x geo_y [geo_z] [yaw (degrees)] [pitch (degrees)] [roll (degrees)] [horz accuracy (meters)] [vert accuracy (meters)] [extras...] +... +``` + +Esempio: + +``` +EPSG:4326 +DJI_0028.JPG -91.9942096111111 46.84252125 198.609 +DJI_0032.JPG -91.9938293055556 46.8424584444444 198.609 +``` + +Se fornisci un file chiamato `geo.txt`, WebODM lo rileverà automaticamente. Se ha un altro nome, puoi specificarlo usando `--geo `. + +Il file `geo.txt` deve essere creato nella cartella base del tuo progetto oppure, quando si usa WebODM, caricato insieme ai file di input raw jpg o tif. + +## Riferimenti + +- Barry, P., & Coakley, R. ["Accuracy of UAV photogrammetry compared with Network RTK GPS."](http://uav.ie/PDF/Accuracy_UAV_compare_RTK_GPS.pdf) Baseline Surveys. 2013. +- Drone Deploy. [How Do I Use Ground Control Points?: A guide to using ground control points with drone mapping software.](https://www.dronedeploy.com/blog/what-are-ground-control-points-gcps/) 2017. +- Madawalagama, S.L., Munasinghe, N., Dampegama, S.D.P.J. and Samarakoon, L. "Low-cost aerial mapping with consumer grade." 37th Asian Conference on Remote Sensing. Colombo, Sri Lanka, 2016. +- Mather, Stephen. [OpenDroneMap.](https://community.opendronemap.org/t/the-accuracy-of-webodm-using-rtk-uavs/3937) 2020. +- Pascual, Manuel S. [GIS Lounge: GIS Data: A Look at Accuracy, Precision, and Types of Errors.](https://www.gislounge.com/gis-data-a-look-at-accuracy-precision-and-types-of-errors/) 2011. +- Pix4D. ["What is accuracy in an aerial mapping project?"](https://www.pix4d.com/blog/accuracy-aerial-mapping) 2019. diff --git a/src/content/docs/it/index.mdx b/src/content/docs/it/index.mdx new file mode 100644 index 0000000..d14b440 --- /dev/null +++ b/src/content/docs/it/index.mdx @@ -0,0 +1,71 @@ +--- +title: Documentazione +description: La documentazione di WebODM +template: doc +--- + +import { LinkCard , Card, CardGrid } from '@astrojs/starlight/components'; + +:::tip[Novità] + +WebODM si è ufficialmente separato da OpenDroneMap! [Leggi l'annuncio](https://webodm.org/blog/announcement/) + +::: + +[WebODM](https://github.com/WebODM/WebODM) è un software intuitivo, di livello commerciale, per l'elaborazione di immagini da drone. Genera mappe georeferenziate, nuvole di punti, modelli di elevazione e modelli 3D texturizzati a partire da immagini aeree. Supporta diversi motori di elaborazione, attualmente [ODX](https://github.com/WebODM/ODX), [MicMac](https://github.com/OpenDroneMap/NodeMICMAC/) e [LGT](https://webodm.net/lgt). + +![image](https://github.com/user-attachments/assets/aa1c4340-728d-46c3-a8e1-53bcb4851adc) + +![image](https://user-images.githubusercontent.com/1951843/174504753-6869e56e-7b65-4775-bb23-6c1dc256575c.png) + + +## Per Iniziare + + + + + + + + +## Ottenere Aiuto + +Abbiamo diversi canali di comunicazione dove porre domande e partecipare alla comunità: + + - [Gruppi della Comunità](https://webodm.org/community) + - [Segnala Problemi](https://github.com/WebODM/WebODM/issues) + +## Licenza + +WebODM è rilasciato secondo i termini della [GNU Affero General Public License v3.0](https://github.com/WebODM/WebODM/blob/master/LICENSE.md). + +## Marchio + +Consulta le [Linee Guida sul Marchio](https://github.com/WebODM/WebODM/blob/master/TRADEMARK.md) + +## Citazione + +``` +@software{WebODM, + author = {Toffanin, Piero and {WebODM Contributors}}, + doi = {10.5281/zenodo.3965771}, + title = {{WebODM: User-friendly, commercial-grade software for processing aerial imagery.}}, + url = {https://github.com/WebODM/WebODM} +} +``` + +``` +Toffanin, P., & WebODM Contributors. WebODM: User-friendly, commercial-grade software for processing aerial imagery. [Computer software]. https://doi.org/10.5281/zenodo.3965771 +``` + +## Risorse Aggiuntive + + * [WebODM: The Missing Guide](https://webodmbook.com) diff --git a/src/content/docs/it/installation.md b/src/content/docs/it/installation.md new file mode 100644 index 0000000..aa2ee36 --- /dev/null +++ b/src/content/docs/it/installation.md @@ -0,0 +1,323 @@ +--- +title: Installazione +template: doc +--- + +:::tip[Lo Sapevi?] + +Puoi saltare l'installazione ed eseguire WebODM da [webodm.net](https://webodm.net), che supporta lo sviluppo del software ❤ Provalo [gratuitamente](https://webodm.net). + +::: + +## Installazione sul tuo computer + +Se utilizzi Windows o macOS, il modo più semplice è [scaricare](https://webodm.org/download) l'installer per la tua piattaforma da [webodm.org](https://webodm.org). + +Se utilizzi Linux, devi usare docker (vedi sotto). + +:::note + +OpenDroneMap, con cui [non siamo più affiliati](https://webodm.org/blog/announcement/), vende installer per un fork di WebODM. Sappi che gli installer ufficiali di WebODM sono gratuiti da scaricare e utilizzare e che l'acquisto da OpenDroneMap non supporta WebODM. + +::: + +### Docker + +Per installare WebODM sul tuo computer con docker, installa prima: + + - [Git](https://git-scm.com/downloads) + - [Docker](https://www.docker.com/) + +Gli utenti Windows e macOS dovrebbero installare Docker Desktop. Poi: + +1. Assegna a Docker un numero sufficiente di CPU (predefinito 2) e di RAM (>4Gb, 16Gb è meglio ma lasciane un po' per il sistema operativo) andando su `Settings -- Resources` +2. Seleziona dove sul tuo disco rigido vuoi che risiedano i dischi rigidi virtuali (`Settings -- Resources -- Advanced`). + +Poi: + +* Apri Git Bash (Windows), oppure dalla riga di comando (Mac / Linux / WSL), digita: + +```bash +git clone https://github.com/WebODM/WebODM --config core.autocrlf=input --depth 1 +cd WebODM +./webodm.sh start +``` + +* Se riscontri problemi nell'ultimo passaggio su Linux, assicurati che il tuo utente faccia parte del gruppo docker: + +```bash +sudo usermod -aG docker $USER +exit +(riavvia la shell disconnettendoti e riconnettendoti) +./webodm.sh start +``` + +🎉 **Congratulazioni!** Dovrebbe essere tutto operativo. Apri un browser all'indirizzo http://localhost:8000 + +Per fermare WebODM premi CTRL+C oppure esegui: + +``` +./webodm.sh stop +``` + +Per aggiornare WebODM all'ultima versione usa: + +``` +./webodm.sh update +``` + +:::note[Archiviazione su Disco] + +Per impostazione predefinita i dati vengono archiviati in volumi docker con nome. Vedi [Dove Sono Memorizzati i Miei File?](/it/faq/#dove-sono-memorizzati-i-miei-file) + +Per cambiare questa impostazione, vedi sotto. + +::: + + +Se prevedi di elaborare grandi quantità di dati o stai esaurendo lo spazio su disco, configura `--media-dir` e/o `--node-dir`: + +``` +./webodm.sh restart --media-dir /storage/media --node-dir /storage/node +``` + +| Argomento | Descrizione | +| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `--node-dir` | Percorso in cui verranno archiviati i file temporanei durante l'elaborazione quando si utilizza il nodo predefinito. Può essere cambiato senza rischi. | +| `--media-dir` | Dove vengono archiviati in modo permanente tutti i file relativi a un progetto e a un task. Cerca di non cambiare questa cartella dopo il primo avvio, se non nell'ambito di una [migrazione](#backup-e-ripristino). | + +## Installazione su altri sistemi + +### Google Compute, Amazon AWS + +Questi passaggi sono per Google Cloud, ma possono essere utilizzati anche per Amazon AWS e altre piattaforme cloud con piccole modifiche: + +1. Avvia un'istanza Google Cloud di Ubuntu LTS. +2. Apri il terminale SSH - Google offre SSH tramite il sito web. +3. Esegui `sudo apt-get update` +4. Esegui `sudo apt-get upgrade` +5. Installa [docker-compose](https://docs.docker.com/compose/install/). Non installarlo tramite apt dalla versione 24.04 in poi. +6. Esegui `sudo apt-get install python-pip` +7. Esegui `git clone https://github.com/WebODM/WebODM --config core.autocrlf=input --depth 1` +8. cd WebODM (Linux distingue tra maiuscole e minuscole) +9. `sudo ./webodm.sh start` +10. Ora puoi accedere a WebODM tramite l'indirizzo IP pubblico della tua istanza Google. Ricorda la porta predefinita 8000. +11. Verifica che il firewall della tua istanza consenta connessioni TCP in ingresso sulla porta 8000! Se dimentichi questo passaggio non potrai connetterti a WebODM. +12. Apri http://publicip:8000 + +Per configurare il firewall su Google Cloud, apri l'istanza, al centro della pagina delle impostazioni dell'istanza trova NIC0. Aprila, quindi aggiungi la porta TCP 8000 per l'ingresso (ingress) e l'uscita (egress) sul firewall. + + +### NAS (Qnap) + +Se utilizzi [Lightning](https://webodm.net) o un altro nodo di elaborazione, i requisiti di WebODM sono abbastanza bassi da permetterne l'esecuzione su un dispositivo a bassa potenza come un NAS. I test sono stati effettuati su un Qnap-TS264 con 32Gb di RAM (processore Celeron N5095). +Per installare WebODM su un NAS Qnap: + +1. Abilita l'accesso ssh al NAS nel pannello di controllo +2. Installa git. Questo può essere fatto facilmente usando il [qgit qkpg](https://www.myqnap.org/product/qgit/) +3. Segui le istruzioni "Installazione con Docker" riportate sopra. +4. Una nuova applicazione "webodm" dovrebbe apparire in Container Station insieme a quattro container individuali per l'app. +5. WebODM dovrebbe essere disponibile sulla porta 8000 del NAS. +6. Configura un account Lightning online e impostalo in "nodi di elaborazione". È anche possibile configurare un computer più potente per eseguire i task di elaborazione al posto di Lightning. + + +## Configurazioni Avanzate + +### Gestione dei Nodi di Elaborazione + +WebODM può essere collegato a uno o più nodi di elaborazione che utilizzano la [NodeODX API](https://github.com/WebODM/NodeODX/blob/master/docs/index.adoc), come [NodeODX](https://github.com/WebODM/NodeODX), [NodeMICMAC](https://github.com/OpenDroneMap/NodeMICMAC/), [ClusterODX](https://github.com/WebODM/ClusterODX) e [Lightning](https://webodm.net). La configurazione predefinita include un nodo di elaborazione "node-odx-1" che viene eseguito sullo stesso sistema di WebODM, giusto per aiutarti a iniziare. Man mano che acquisisci familiarità con WebODM, potresti voler installare nodi di elaborazione su sistemi separati. + +Aggiungere più nodi di elaborazione ti permetterà di eseguire più lavori in parallelo. + +Puoi anche configurare un nodo [ClusterODX](https://github.com/WebODM/ClusterODX) per eseguire un singolo task su più sistemi con lo [split-merge distribuito](https://docs.opendronemap.org/large/?highlight=distributed#getting-started-with-distributed-split-merge) ed elaborare decine di migliaia di immagini più rapidamente, con meno memoria. + +Se non hai bisogno del nodo predefinito "node-odx-1", passa semplicemente il flag `--default-nodes 0` all'avvio di WebODM: + +`./webodm.sh restart --default-nodes 0`. + +Poi dall'interfaccia web rimuovi semplicemente in modo manuale il nodo "node-odx-1". + + +### Abilitare SSL + +WebODM ha la capacità di richiedere e installare automaticamente un certificato SSL tramite [Let’s Encrypt](https://letsencrypt.org/), oppure puoi specificare manualmente la tua coppia chiave/certificato. + + - Configura il tuo record DNS (webodm.myorg.com --> IP del server). + - Assicurati che le porte 80 e 443 siano aperte. + - Esegui quanto segue: + +```bash +./webodm.sh restart --ssl --hostname webodm.myorg.com +``` + +Ecco fatto! Il certificato si rinnoverà automaticamente quando necessario. + +Se vuoi specificare la tua coppia chiave/certificato, passa semplicemente le opzioni `--ssl-key` e `--ssl-cert` a `./webodm.sh`. Vedi `./webodm.sh --help` per maggiori informazioni. + +Nota! Non puoi passare un indirizzo IP al parametro hostname! È necessario un record DNS configurato. + +### Abilitare l'Autenticazione OIDC + +WebODM supporta l'autenticazione [OIDC](https://openid.net/) (OpenID Connect), il che significa che puoi fornire un'esperienza di Single Sign On (SSO) utilizzando un provider di autenticazione come Google. Per abilitare uno o più provider, crea un file `local_settings.py` con il seguente contenuto: + +```python +OIDC_AUTH_PROVIDERS = [ + { + 'name': 'Google', + 'icon': 'fab fa-google', # icona Font-Awesome valida, o lascia vuoto + 'client_id': '', + 'client_secret': '', + 'auth_endpoint': 'https://accounts.google.com/o/oauth2/v2/auth', + 'token_endpoint': 'https://oauth2.googleapis.com/token', + 'userinfo_endpoint': 'https://openidconnect.googleapis.com/v1/userinfo' + }, + # Aggiungi altri provider qui sotto +] + +# Opzionale, imposta restrizioni su chi può accedere +# se non impostato, chiunque abbia un'email Google può accedere +OIDC_AUTH_EMAILS = ["@myorg.com", "user@gmail.com"] +``` + +I valori `client_id` e `client_secret` sono forniti dal provider di autenticazione. Dovrai registrare un'applicazione. Con Google, puoi farlo dalla [Google Cloud Console](https://console.cloud.google.com). + +Quando registri l'applicazione, imposta gli **Authorized redirect URIs** con: + + * `https://webodm.myorg.com/oidc/callback/` + +Gli URL degli endpoint sono spesso pubblicati a un URL `.well-known/openid-configuration`. Ad esempio, Google pubblica i propri su https://accounts.google.com/.well-known/openid-configuration. + +Poi riavvia WebODM con: + +``` +./webodm.sh restart --settings /path/to/local_settings.py +``` + +### Abilitare IPv6 + +La tua installazione deve prima avere un indirizzo IPv6 pubblico. +Per abilitare IPv6 sulla tua installazione, devi attivare IPv6 in Docker aggiungendo quanto segue a un file situato in /etc/docker/daemon.json: + +```bash +{ + "ipv6": true, + "fixed-cidr-v6": "fdb4:4d19:7eb5::/64" +} +``` +Riavvia Docker: +`systemctl restart docker` + +Per aggiungere IPv6, esegui semplicemente: + +`./webodm.sh restart --ipv6` + +Nota: quando si utilizza la modalità `--ssl`, non puoi passare un indirizzo IP al parametro hostname; devi configurare un record DNS AAAA. Senza la modalità `--ssl` abilitata, accedi al sito all'indirizzo (ad esempio, http://[2001:0db8:3c4d:0015::1]:8000). Le parentesi quadre attorno all'indirizzo IPv6 sono essenziali! +Puoi aggiungere un nuovo nodo NodeODX in WebODM specificando un indirizzo IPv6. Non dimenticare di includere le parentesi quadre attorno all'indirizzo! ad esempio, [2001:0db8:fd8a:ae80::1] + +### Abilitare MicMac + +WebODM può utilizzare [MicMac](https://github.com/OpenDroneMap/micmac) come motore di elaborazione tramite [NodeMICMAC](https://github.com/OpenDroneMap/NodeMICMAC/). Per aggiungere MicMac, esegui semplicemente: + +`./webodm.sh restart --with-micmac` + +Questo creerà un nodo di elaborazione "node-micmac-1" sullo stesso sistema che esegue WebODM. Tieni presente che NodeMICMAC è in sviluppo attivo ed è attualmente sperimentale. Se riscontri problemi, [segnalali](https://github.com/OpenDroneMap/NodeMICMAC/issues) sul repository di NodeMICMAC. + +## Risoluzione dei Problemi Comuni + +| Sintomi | Possibili Soluzioni | +| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| Esaurimento della memoria | Assicurati che il tuo ambiente Docker abbia abbastanza RAM allocata: [Istruzioni per MacOS](http://stackoverflow.com/a/39720010), [Istruzioni per Windows](https://docs.docker.com/desktop/settings/windows/#advanced) | +| Su Windows, docker-compose fallisce con `Failed to execute the script docker-compose` | Assicurati di aver abilitato la virtualizzazione VT-x nel BIOS | +| Impossibile accedere a WebODM usando Microsoft Edge su Windows 10 | Prova a modificare le proprietà internet secondo [queste istruzioni](http://www.hanselman.com/blog/FixedMicrosoftEdgeCantSeeOrOpenVirtualBoxhostedLocalWebSites.aspx) | +| Ricevi un errore `No space left on device`, ma il disco rigido ha ancora spazio sufficiente | Docker su Windows per impostazione predefinita alloca solo 20GB di spazio alla docker-machine predefinita. Devi aumentare quella quantità. Vedi [questo link](http://support.divio.com/local-development/docker/managing-disk-space-in-your-docker-vm) e [questo link](https://www.howtogeek.com/124622/how-to-enlarge-a-virtual-machines-disk-in-virtualbox-or-vmware/) | +| Impossibile avviare WebODM tramite `./webodm.sh start`, i messaggi di errore sono diversi a ogni tentativo | Potresti stare esaurendo la memoria. Assicurati di avere abbastanza RAM disponibile. 2GB dovrebbero essere il minimo raccomandato, a meno che tu non sappia cosa stai facendo | +| Su Windows, lo spazio di archiviazione mostrato nella pagina di diagnostica di WebODM non corrisponde a quanto effettivamente impostato nelle impostazioni di Docker. | Da Hyper-V Manager, fai clic con il tasto destro su "DockerDesktopVM", vai su Edit Disk, quindi scegli di espandere il disco e fai corrispondere la dimensione massima alle impostazioni specificate nelle impostazioni di docker. Dopo aver apportato le modifiche, riavvia docker. | +| Su Linux o WSL, avviso: `GPU use was requested, but no GPU has been found` | Esegui `nvidia-smi` (nativamente) o `docker run --rm --gpus all nvidia/cuda:11.2.2-devel-ubuntu20.04 nvidia-smi` (docker) per verificare con il [driver NVIDIA](https://www.nvidia.com/drivers/unix/) e il [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html). | +| Ricevi un errore `Connection error: HTTPSConnectionPool(host='spark1.webodm.net', port=443): Max retries exceeded [Errno 11002] Lookup timed out` quando invii immagini a Lightning | Per qualche motivo il sistema DNS sul tuo computer è configurato in modo errato o viene filtrato da software AV/VPN/di rete installato sul sistema. Puoi provare a modificare il tuo file `hosts` per mappare manualmente l'indirizzo IP di `spark1.webodm.net`. Vedi [come modificare il file hosts su Windows](https://www.howtogeek.com/784196/how-to-edit-the-hosts-file-on-windows-10-or-11/) e [usa questo indirizzo IP](https://mxtoolbox.com/SuperTool.aspx?action=a%3aspark1.webodm.net&run=toolpage) | + + +## Attività di Amministrazione Comuni + +Gestire un'installazione di WebODM è abbastanza semplice. Ecco un elenco delle operazioni comuni che potresti dover eseguire: + +### Reimpostare la Password di Amministratore + +Se hai dimenticato la password che hai scelto la prima volta che hai effettuato l'accesso a WebODM, per reimpostarla digita semplicemente: + +```bash +./webodm.sh start && ./webodm.sh resetadminpassword newpass +``` + +La password verrà reimpostata a `newpass`. Il comando ti dirà anche quale nome utente hai scelto. + +### Backup e Ripristino + +Se vuoi spostare WebODM su un altro sistema, devi solo trasferire i volumi docker (a meno che tu non stia archiviando i file sul file system). + +Sul vecchio sistema: + +```bash +mkdir -v backup +docker run --rm --volume webodm_dbdata:/temp --volume `pwd`/backup:/backup ubuntu tar cvf /backup/dbdata.tar /temp +docker run --rm --volume webodm_appmedia:/temp --volume `pwd`/backup:/backup ubuntu tar cvf /backup/appmedia.tar /temp +``` + +I tuoi file di backup verranno archiviati nella directory `backup` appena creata. Trasferisci la directory `backup` sul nuovo sistema, quindi sul nuovo sistema: + +```bash +ls backup # --> appmedia.tar dbdata.tar +./webodm.sh down # Assicurati che WebODM sia fermo +docker run --rm --volume webodm_dbdata:/temp --volume `pwd`/backup:/backup ubuntu bash -c "rm -fr /temp/* && tar xvf /backup/dbdata.tar" +docker run --rm --volume webodm_appmedia:/temp --volume `pwd`/backup:/backup ubuntu bash -c "rm -fr /temp/* && tar xvf /backup/appmedia.tar" +./webodm.sh start +``` + +### Aggiornamento + +Se usi docker, l'aggiornamento è semplice come eseguire: + +```bash +./webodm.sh update +``` + +### Personalizzazione ed Estensione + +Piccole personalizzazioni come la modifica dei colori dell'applicazione, del nome, del logo o l'aggiunta di CSS/HTML/Javascript personalizzati possono essere effettuate direttamente dai pannelli Customize -- Brand/Theme all'interno di WebODM. Non è necessario creare un fork o modificare il codice. + +Personalizzazioni più avanzate possono essere realizzate [scrivendo plugin](/it/plugin-development-guide/). Questo è il modo preferito per aggiungere nuove funzionalità a WebODM poiché richiede meno sforzo rispetto alla manutenzione di un fork separato. Il sistema di plugin offre segnali lato server che possono essere usati per essere notificati di vari eventi, un sistema di build ES6/React, una API dinamica lato client per aggiungere elementi all'interfaccia utente, un data store integrato, un esecutore di task asincroni, hook per aggiungere voci di menu e funzioni per iniettare rapidamente CSS, Javascript e viste Django. + +Per saperne di più, inizia dalla [guida allo sviluppo di plugin](https://docs.webodm.org/plugin-development-guide/). È anche utile studiare il codice sorgente dei [plugin esistenti](https://github.com/WebODM/WebODM/tree/master/coreplugins). + +Se un particolare hook / segnale per il tuo plugin non esiste ancora, [richiedilo](https://github.com/WebODM/WebODM/issues). Stiamo aggiungendo hook e segnali man mano che procediamo. + + +## Requisiti Hardware + +Per eseguire un'installazione standalone di WebODM (l'interfaccia utente), incluso il componente di elaborazione ([NodeODX](https://github.com/WebODM/NodeODX)), raccomandiamo come minimo: + +* 100 GB di spazio libero su disco +* 16 GB di RAM + +Non aspettarti di elaborare più di qualche centinaio di immagini con queste specifiche. Per elaborare dataset più grandi, aggiungi RAM in modo lineare rispetto al numero di immagini che vuoi elaborare: + +| Numero di Immagini | RAM o RAM + Swap (GB) | +| ---------------- | ---------------------- | +| 40 | 4 | +| 250 | 16 | +| 500 | 32 | +| 1500 | 64 | +| 2500 | 128 | +| 3500 | 192 | +| 5000 | 256 | + +:::note + +Queste sono stime conservative. Molti fattori influenzano l'utilizzo della memoria, come le dimensioni delle immagini, l'altitudine di volo e le impostazioni di elaborazione. Quindi potresti riuscire a elaborare più immagini con meno memoria rispetto a quanto riportato sopra. + +::: + +Una CPU con più core velocizzerà l'elaborazione, ma può aumentare l'utilizzo della memoria. L'accelerazione GPU è supportata anche su Linux e WSL. Per sfruttare la tua scheda grafica compatibile CUDA, assicurati di passare `--gpu` all'avvio di WebODM. In questo caso è necessario avere nvidia-docker installato, vedi https://github.com/NVIDIA/nvidia-docker e https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#docker per informazioni sulla configurazione docker/NVIDIA. + +WebODM funziona al meglio su Linux, ma funziona bene anche su Windows e Mac. + +WebODM di per sé è solo un'interfaccia utente e non richiede molte risorse. WebODM può essere caricato su un sistema con solo 1 o 2 GB di RAM e funzionare bene senza [NodeODX](https://github.com/WebODM/NodeODX). Puoi usare un servizio di elaborazione come [webodm.net](https://webodm.net) oppure eseguire NodeODX su un computer separato e più potente. diff --git a/src/content/docs/it/mission-planning.md b/src/content/docs/it/mission-planning.md new file mode 100644 index 0000000..dbbb135 --- /dev/null +++ b/src/content/docs/it/mission-planning.md @@ -0,0 +1,18 @@ +--- +title: Pianificazione della Missione +template: doc +--- + +I software di pianificazione della missione consentono ai piloti di programmare voli automatizzati, che permettono voli precisi e ripetibili, ideali per la mappatura. Ti raccomandiamo di usare un software di pianificazione della missione quando acquisisci dati da usare con WebODM. + +WebODM non ha (ancora) un pianificatore di missione ufficiale, ma di seguito trovi un elenco di software di terze parti. + +## Elenco Software + +| Nome | Costo | Piattaforma | Link | Note | +| -------------- | -------- | ----------- | --------------------------------------------------------- | ---------------------------------------------------------------- | +| QGroundControl | Gratuito | Mavlink | [qgroundcontrol.com](https://qgroundcontrol.com) | Software Open Source | +| YMapper | Gratuito | DJI, Litchi | [ymapper.yarosfpv.com](https://ymapper.yarosfpv.com/) | Software Open Source | +| MavenPilot | Ibrido | DJI | [mavenpilot.com](https://mavenpilot.com/planner/) | Pilot è a pagamento, ma Planner è gratuito | +| DroneLink | A pagamento | DJI, Autel | [dronelink.com](https://dronelink.com) | Sconto disponibile tramite [Lightning](https://webodm.net/dronelink) | +| Litchi | A pagamento | DJI | [flylitchi.com](https://flylitchi.com/) | La [beta di Litchi Pilot](https://forum.flylitchi.com/t/open-beta-litchi-pilot/10621) è gratuita | diff --git a/src/content/docs/it/multispectral.md b/src/content/docs/it/multispectral.md new file mode 100644 index 0000000..2609993 --- /dev/null +++ b/src/content/docs/it/multispectral.md @@ -0,0 +1,63 @@ +--- +title: Multispettrale e Termico +template: doc +--- + +## Supporto Multispettrale + +WebODM supporta la normalizzazione radiometrica, che consente di generare ortofoto di riflettanza da fotocamere multispettrali. Le fotocamere multispettrali acquisiscono più scatti della scena utilizzando sensori con bande diverse. + +### Sensori Supportati + +Sebbene il nostro obiettivo sia supportare quante più fotocamere possibile, il supporto multispettrale è stato sviluppato utilizzando le seguenti fotocamere, che quindi funzioneranno meglio: + +- [MicaSense RedEdge-MX e Altum](https://www.micasense.com/) +- [Sentera 6X](https://sentera.com/products/fieldcapture/sensors/6x/) +- [DJI Phantom 4 Multispectral](https://www.dji.com/p4-multispectral) +- [DJI Mavic 3 Multispectral](https://ag.dji.com/mavic-3-m) + +Anche altre fotocamere potrebbero funzionare. Puoi aiutarci ad ampliare questo elenco [condividendo](https://webodm.org/community) dataset acquisiti con altre fotocamere. + +### Creazione di Ortofoto da Dati Multispettrali + +Per i sensori supportati elencati sopra (e probabilmente per altri sensori), gli utenti possono elaborare i dati multispettrali allo stesso modo delle immagini a luce visibile. Le immagini di tutte le bande dei sensori devono essere elaborate insieme (non separare le bande in più cartelle). Gli utenti hanno la possibilità di passare il parametro `--radiometric-calibration` con le opzioni `camera` o `camera+sun` per abilitare la normalizzazione radiometrica. Se le immagini fanno parte di una configurazione multi-camera, l'ortofoto risultante avrà N bande, una per ogni fotocamera (+ alpha). + +L'NDVI e altri indici di vegetazione possono essere calcolati da queste ortofoto mosaicate utilizzando software come [QGIS](https://www.qgis.org/). + + +## Supporto Termico + +WebODM supporta la calibrazione radiometrica dei dati termici, che consente di generare ortofoto di temperatura da fotocamere a infrarossi a onda lunga (LWIR). Le immagini LWIR possono essere elaborate da sole o come parte di un dataset multispettrale. + +![Immagini termiche in WebODM](/images/thermal.webp) + +### Hardware + +Sebbene il nostro obiettivo sia supportare quante più fotocamere possibile, il supporto termico è stato sviluppato utilizzando le seguenti fotocamere, che quindi funzioneranno meglio: + +- [MicaSense Altum](https://www.micasense.com/) +- [DJI Zenmuse XT](https://www.dji.com/zenmuse-xt) +- [DJI Zenmuse H20 Series](https://enterprise.dji.com/zenmuse-h20-series) + +Anche questi droni sono supportati, ma richiedono una pre-elaborazione con +[Thermal Tools](https://webodm.net/thermaltools): + + * DJI Zenmuse H20N + * DJI Matrice 30 Series + * DJI Zenmuse XT S + * DJI Zenmuse H30 Series + * DJI Mavic 2 Enterprise Advanced + * DJI Mavic 3 Enterprise + * DJI Matrice 4 Series + +Anche altre fotocamere potrebbero funzionare. Puoi aiutarci ad ampliare questo elenco [condividendo](https://webodm.org/datasets) dataset acquisiti con altre fotocamere. + +### Utilizzo + +:::note[Solo per droni DJI] + +Per ottenere i valori di temperatura, pre-elabora le immagini con [Thermal Tools](https://webodm.net/thermaltools) prima di elaborarle con WebODM e usa le impostazioni standard (non usare `--radiometric-calibration`). + +::: + +Elabora le immagini utilizzando il parametro `--radiometric-calibration camera` per abilitare la calibrazione radiometrica. diff --git a/src/content/docs/it/options-flags.md b/src/content/docs/it/options-flags.md new file mode 100644 index 0000000..8e1da4c --- /dev/null +++ b/src/content/docs/it/options-flags.md @@ -0,0 +1,655 @@ +--- +title: Opzioni e Flag +template: doc +--- + +Questo è l'elenco completo delle opzioni disponibili in [ODX](https://github.com/WebODM/ODX). + + +:::note +Alcune di queste non saranno visibili in [WebODM](https://github.com/WebODM/WebODM) perché non sono applicabili oppure sono integrate nel flusso di lavoro dell'esperienza utente (ad es. i GCP vengono selezionati automaticamente, quindi non è necessario specificare un'opzione `--gcp`). +::: + +## 3d-tiles + +Genera output OGC 3D Tiles. + +**Predefinito:** `False` + +## align + +Percorso a un DEM GeoTIFF o a una nuvola di punti LAS/LAZ a cui gli output della ricostruzione devono essere allineati automaticamente. Sperimentale. + +**Opzioni:** `` + +**Predefinito:** `None` + +## auto-boundary + +Imposta automaticamente un confine utilizzando le posizioni degli scatti della fotocamera per limitare l'area della ricostruzione. Questo può aiutare a rimuovere artefatti di sfondo lontani (cielo, paesaggi sullo sfondo, ecc.). Vedi anche --boundary. + +**Predefinito:** `False` + +## auto-boundary-distance + +Specifica la distanza tra le posizioni degli scatti della fotocamera e il bordo esterno del confine quando questo viene calcolato con --auto-boundary. Imposta a 0 per scegliere automaticamente un valore. + +**Opzioni:** `` + +**Predefinito:** `0` + +## bg-removal + +Calcola automaticamente le maschere delle immagini utilizzando l'IA per rimuovere lo sfondo. Sperimentale. + +**Predefinito:** `False` + +## boundary + +Poligono GeoJSON che limita l'area della ricostruzione. Può essere specificato come percorso a un file GeoJSON oppure come stringa JSON che rappresenta il contenuto di un file GeoJSON. + +**Opzioni:** `` + +## build-overviews + +Genera le overview dell'ortofoto per una visualizzazione più rapida in programmi come QGIS. + +**Predefinito:** `False` + +## camera-lens + +Imposta un tipo di proiezione della fotocamera. Impostare manualmente un valore può aiutare a migliorare la correzione geometrica della distorsione. Per impostazione predefinita l'applicazione tenta di determinare il tipo di obiettivo dai metadati delle immagini. + +**Opzioni:** `auto | perspective | brown | fisheye | fisheye_opencv | spherical | equirectangular | dual` + +**Predefinito:** `auto` + +## cameras + +Utilizza i parametri della fotocamera calcolati da un altro dataset invece di calcolarli. Può essere specificato come percorso a un file cameras.json oppure come stringa JSON che rappresenta il contenuto di un file cameras.json. + +**Opzioni:** `` + +## cog + +Crea GeoTIFF Cloud-Optimized invece di GeoTIFF normali. + +**Predefinito:** `False` + +## copy-to + +Copia i risultati di output in questa cartella al termine dell'elaborazione. + +**Opzioni:** `` + +## crop + +Ritaglia automaticamente le immagini di output creando un buffer uniforme attorno ai confini del dataset, ridotto di N metri. Usa 0 per disabilitare il ritaglio. + +**Opzioni:** `` + +**Predefinito:** `3` + +## dem-decimation + +Decima i punti prima di generare il DEM. 1 significa nessuna decimazione (qualità piena). 100 decima circa il 99%% dei punti. Utile per velocizzare la generazione dei risultati DEM in dataset molto grandi. + +**Opzioni:** `` + +**Predefinito:** `1` + +## dem-euclidean-map + +Calcola una mappa raster euclidea per ogni DEM. La mappa riporta la distanza di ogni cella dal valore NODATA più vicino (prima che avvenga qualsiasi riempimento dei vuoti). Questo può essere utile per isolare le aree che sono state riempite. + +**Predefinito:** `False` + +## dem-gapfill-steps + +Numero di passaggi utilizzati per riempire le aree con vuoti. Imposta a 0 per disabilitare il riempimento dei vuoti. Partendo da un raggio pari alla risoluzione di output, vengono generati N DEM diversi con raggio progressivamente maggiore utilizzando l'algoritmo di ponderazione a distanza inversa (IDW) e poi uniti insieme. I vuoti rimanenti vengono quindi riempiti utilizzando l'interpolazione nearest neighbor. + +**Opzioni:** `` + +**Predefinito:** `3` + +## dem-resolution + +Risoluzione del DSM/DTM in cm / pixel. Nota che questo valore è limitato da una stima della distanza di campionamento al suolo (GSD). + +**Opzioni:** `` + +**Predefinito:** `5` + +## dsm + +Usa questo tag per generare un DSM (Digital Surface Model, terreno + oggetti) utilizzando un filtro morfologico progressivo. Consulta i parametri --dem* per una regolazione più fine. + +**Predefinito:** `False` + +## dtm + +Usa questo tag per generare un DTM (Digital Terrain Model, solo terreno) utilizzando un filtro morfologico semplice. Consulta i parametri --dem* e --smrf* per una regolazione più fine. + +**Predefinito:** `False` + +## end-with + +Termina l'elaborazione a questa fase. + +**Opzioni:** `dataset | split | merge | opensfm | openmvs | odm_filterpoints | odm_meshing | mvs_texturing | odm_georeferencing | odm_dem | odm_orthophoto | odm_report | odm_postprocess` + +**Predefinito:** `odm_postprocess` + +## fast-orthophoto + +Salta la ricostruzione densa e la generazione del modello 3D. Genera un'ortofoto direttamente dalla ricostruzione sparsa. Su terreni pianeggianti senza oggetti/strutture, attiva questa opzione per risparmiare tempo. + +**Predefinito:** `False` + +## feature-quality + +Imposta la qualità dell'estrazione delle feature. Una qualità più alta genera feature migliori, ma richiede più memoria e più tempo. + +**Opzioni:** `ultra | high | medium | low | lowest` + +**Predefinito:** `high` + +## feature-type + +Scegli l'algoritmo per l'estrazione dei keypoint e il calcolo dei descrittori. + +**Opzioni:** `akaze | dspsift | hahog | orb | sift` + +**Predefinito:** `dspsift` + +## force-gps + +Utilizza i dati GPS EXIF delle immagini per la ricostruzione, anche se sono presenti GCP. Questo flag è utile se disponi di misurazioni GPS ad alta precisione. Se non ci sono GCP, questo flag non ha alcun effetto. + +**Predefinito:** `False` + +## gcp + +Percorso al file contenente i Punti di Controllo a Terra (GCP) utilizzati per la georeferenziazione. Il file deve usare il seguente formato: + +EPSG:`` oppure `<+proj definition>` + +geo_x geo_y geo_z im_x im_y image_name [gcp_name] [extra1] [extra2] + +**Opzioni:** `` + +**Predefinito:** `None` + +## geo + +Percorso al file di geolocalizzazione delle immagini contenente le coordinate del centro della fotocamera utilizzate per la georeferenziazione. Se non disponi dei valori di yaw/pitch/roll puoi impostarli a 0. Il file deve usare il seguente formato: + +EPSG:`` oppure `<+proj definition>` + +image_name geo_x geo_y geo_z [yaw (gradi)] [pitch (gradi)] [roll (gradi)] [accuratezza orizzontale (metri)] [accuratezza verticale (metri)] + +**Opzioni:** `` + +**Predefinito:** `None` + +## gltf + +Genera modelli texturizzati Binary glTF (GLB) in file singolo. + +**Predefinito:** `False` + +## gps-accuracy + +Imposta un valore in metri per l'informazione GPS Dilution of Precision (DOP) per tutte le immagini. Se le tue immagini sono taggate con informazioni GPS ad alta precisione (RTK), questo valore verrà impostato automaticamente di conseguenza. Puoi usare questa opzione per impostarlo manualmente nel caso in cui la ricostruzione fallisca. Ridurre questa opzione può a volte aiutare a controllare gli effetti di incurvamento (bowling) su aree estese. + +**Opzioni:** `` + +**Predefinito:** `3` + +## gps-z-offset + +Imposta un offset GPS in metri per l'asse verticale (Z) aggiungendolo al valore di altitudine dei dati GPS EXIF. Questo non modifica il valore di alcun GCP. Può essere utile, ad esempio, per passare dall'altezza ellissoidica a quella ortometrica. + +**Opzioni:** `` + +**Predefinito:** `0` + +## help + +mostra questo messaggio di aiuto ed esce + +## ignore-gsd + +Ignora la distanza di campionamento al suolo (GSD). Se impostata a true, comporta un maggiore consumo di memoria e processore rispetto al comportamento predefinito. Normalmente, le stime della GSD vengono utilizzate per limitare la risoluzione massima delle immagini di output e per ridimensionare le immagini quando necessario, con conseguente elaborazione più rapida e minore utilizzo di memoria. Poiché la GSD è una stima, a volte ignorarla può produrre una qualità delle immagini di output leggermente migliore. Non impostare mai --ignore-gsd a true a meno che tu non sia certo di averne bisogno, e anche in quel caso: non usarla. + +**Predefinito:** `False` + +## matcher-neighbors + +Esegue il matching delle immagini con le immagini più vicine in base ai dati GPS EXIF. Imposta a 0 per effettuare il matching tramite triangolazione. + +**Opzioni:** `` + +**Predefinito:** `0` + +## matcher-order + +Esegue il matching delle immagini con le N immagini più vicine in base all'ordine dei nomi dei file. Può velocizzare l'elaborazione di immagini sequenziali, come quelle estratte da video. Viene applicato solo su dataset non georeferenziati. Imposta a 0 per disabilitare. + +**Opzioni:** `` + +**Predefinito:** `0` + +## matcher-type + +Algoritmo di matching, Fast Library for Approximate Nearest Neighbors o Bag of Words. FLANN è più lento, ma più stabile. BOW è più veloce, ma a volte può perdere corrispondenze valide. BRUTEFORCE è molto lento ma robusto. HAMMING è molto più veloce con dataset di grandi dimensioni ma richiede una GPU. + +**Opzioni:** `auto | bow | bruteforce | flann | hamming` + +**Predefinito:** `auto` + +## max-concurrency + +Il numero massimo di processi da utilizzare nelle varie elaborazioni. Il requisito di memoria di picco è di circa 1 GB per thread con immagini da 2 megapixel di risoluzione. + +**Opzioni:** `` + +**Predefinito:** `4` + +## merge + +Scegli cosa unire nella fase di merge in un dataset suddiviso. Per impostazione predefinita vengono uniti tutti gli output disponibili. Opzioni: ['all', 'pointcloud', 'orthophoto', 'dem']. + +**Opzioni:** `all | pointcloud | orthophoto | dem` + +**Predefinito:** `all` + +## mesh-octree-depth + +Profondità dell'octree utilizzata nella ricostruzione della mesh, aumentala per ottenere più vertici; i valori consigliati sono 8-12. + +**Opzioni:** `` + +**Predefinito:** `11` + +## mesh-size + +Il numero massimo di vertici della mesh di output. + +**Opzioni:** `` + +**Predefinito:** `200000` + +## min-num-features + +Numero minimo di feature da estrarre per immagine. Più feature possono essere utili per trovare più corrispondenze tra le immagini, consentendo potenzialmente la ricostruzione di aree con poca sovrapposizione o feature insufficienti. Un numero maggiore di feature rallenta però l'elaborazione. + +**Opzioni:** `` + +**Predefinito:** `10000` + +## name + +Nome del dataset (ovvero il nome della sottocartella all'interno della cartella del progetto). + +**Opzioni:** `` + +**Predefinito:** `code` + +## no-gpu + +Non utilizzare l'accelerazione GPU, anche se disponibile. + +**Predefinito:** `False` + +## optimize-disk-space + +Elimina i file intermedi pesanti per ottimizzare l'utilizzo dello spazio su disco. Questo influisce sulla possibilità di riavviare la pipeline da una fase intermedia, ma consente di elaborare i dataset su sistemi che non dispongono di spazio su disco sufficiente. + +**Predefinito:** `False` + +## orthophoto-compression + +Imposta la compressione da utilizzare per le ortofoto. + +**Opzioni:** `JPEG | LZW | PACKBITS | DEFLATE | LZMA | NONE` + +**Predefinito:** `DEFLATE` + +## orthophoto-cutline + +Genera un poligono attorno all'area di ritaglio che taglia l'ortofoto lungo i bordi degli elementi. Questo poligono può essere utile per assemblare mosaici senza giunzioni con più ortofoto sovrapposte. + +**Predefinito:** `False` + +## orthophoto-kmz + +Imposta questo parametro se vuoi generare un rendering Google Earth (KMZ) dell'ortofoto. + +**Predefinito:** `False` + +## orthophoto-no-tiled + +Imposta questo parametro se vuoi un GeoTIFF a strisce (striped). + +**Predefinito:** `False` + +## orthophoto-png + +Imposta questo parametro se vuoi generare un rendering PNG dell'ortofoto. + +**Predefinito:** `False` + +## orthophoto-resolution + +Risoluzione dell'ortofoto in cm / pixel. Nota che questo valore è limitato da una stima della distanza di campionamento al suolo (GSD). + +**Opzioni:** ` 0.0>` + +**Predefinito:** `5` + +## pc-classify + +Classifica gli output della nuvola di punti. Puoi controllare il comportamento di questa opzione regolando i parametri --dem-*. + +**Predefinito:** `False` + +## pc-copc + +Salva la nuvola di punti georeferenziata nel formato Cloud Optimized Point Cloud (COPC). + +**Predefinito:** `False` + +## pc-csv + +Esporta la nuvola di punti georeferenziata in formato CSV. + +**Predefinito:** `False` + +## pc-ept + +Esporta la nuvola di punti georeferenziata in formato Entwine Point Tile (EPT). + +**Predefinito:** `False` + +## pc-filter + +Filtra la nuvola di punti rimuovendo i punti che deviano più di N deviazioni standard dalla media locale. Imposta a 0 per disabilitare il filtraggio. + +**Opzioni:** `` + +**Predefinito:** `5` + +## pc-las + +Esporta la nuvola di punti georeferenziata in formato LAS. + +**Predefinito:** `False` + +## pc-quality + +Imposta la qualità della nuvola di punti. Una qualità più alta genera nuvole di punti migliori e più dense, ma richiede più memoria e più tempo. Ogni incremento di qualità aumenta il tempo di elaborazione di un fattore circa 4x. + +**Opzioni:** `ultra | high | medium | low | lowest` + +**Predefinito:** `medium` + +## pc-sample + +Filtra la nuvola di punti mantenendo un solo punto entro un raggio di N (in metri). Questo può essere utile per limitare la risoluzione di output della nuvola di punti e rimuovere punti duplicati. Imposta a 0 per disabilitare il campionamento. + +**Opzioni:** `` + +**Predefinito:** `0` + +## pc-skip-geometric + +Le stime geometriche migliorano l'accuratezza della nuvola di punti calcolando mappe di profondità geometricamente coerenti, ma potrebbero non essere utilizzabili in dataset più grandi. Questo flag disabilita le stime geometriche. + +**Predefinito:** `False` + +## primary-band + +Durante l'elaborazione di dataset multispettrali, puoi specificare il nome della banda primaria che verrà utilizzata per la ricostruzione. Si consiglia di scegliere una banda con dettagli nitidi e a fuoco. + +**Opzioni:** `` + +**Predefinito:** `auto` + +## project-path + +Percorso alla cartella del progetto. La cartella del progetto deve contenere sottocartelle per ciascun dataset. Ogni dataset deve avere una cartella "images". + +**Opzioni:** `` + +## radiometric-calibration + +Imposta la calibrazione radiometrica da eseguire sulle immagini. Durante l'elaborazione di immagini multispettrali e termiche dovresti impostare questa opzione per ottenere valori di riflettanza/temperatura (altrimenti otterrai valori digitali grezzi). [camera] applica il livello del nero, la vignettatura, la compensazione di guadagno/esposizione del gradiente di riga (se vengono trovati i tag EXIF appropriati) e calcola i valori di temperatura assoluta. [camera+sun] è sperimentale: applica tutte le correzioni di [camera] e in più compensa la radianza spettrale registrata tramite un sensore di luce incidente (DLS) tenendo in considerazione l'angolo del sole. + +**Opzioni:** `none | camera | camera+sun` + +**Predefinito:** `none` + +## report-units + +Imposta le unità di misura del report PDF. Per impostazione predefinita vengono utilizzate le unità verticali del sistema di riferimento delle coordinate. + +**Opzioni:** `m | ft | US survey foot` + +**Predefinito:** `m` + +## rerun + +Riesegue solo questa fase e si ferma. + +**Opzioni:** `dataset | split | merge | opensfm | openmvs | odm_filterpoints | odm_meshing | mvs_texturing | odm_georeferencing | odm_dem | odm_orthophoto | odm_report | odm_postprocess` + +## rerun-all + +Elimina definitivamente tutti i risultati precedenti e riesegue la pipeline di elaborazione. + +**Predefinito:** `False` + +## rerun-from + +Riesegue l'elaborazione a partire da questa fase. + +**Opzioni:** `dataset | split | merge | opensfm | openmvs | odm_filterpoints | odm_meshing | mvs_texturing | odm_georeferencing | odm_dem | odm_orthophoto | odm_report | odm_postprocess` + +## rolling-shutter + +Attiva la correzione del rolling shutter. Se la fotocamera ha un otturatore rolling shutter e le immagini sono state scattate in movimento, puoi attivare questa opzione per migliorare l'accuratezza dei risultati. Vedi anche --rolling-shutter-readout. + +**Predefinito:** `False` + +## rolling-shutter-readout + +Sovrascrive il tempo di lettura (readout) del rolling shutter per il sensore della tua fotocamera (in millisecondi), invece di utilizzare il database dei tempi di lettura del rolling shutter. Nota che non tutte le fotocamere sono presenti nel database. Imposta a 0 per utilizzare il valore del database. + +**Opzioni:** `` + +**Predefinito:** `0` + +## sfm-algorithm + +Scegli l'algoritmo di structure from motion. Per dataset aerei, se sono disponibili le posizioni GPS e gli angoli della fotocamera, la triangolazione può essere più veloce. Planar è deprecato e verrà rimosso in una versione futura. + +**Opzioni:** `incremental | triangulation | planar` + +**Predefinito:** `incremental` + +## sfm-no-partial + +Non tentare di unire le ricostruzioni parziali. Queste possono verificarsi quando le immagini non hanno una sovrapposizione sufficiente o sono isolate. + +**Predefinito:** `False` + +## skip-3dmodel + +Salta la generazione del modello 3D completo. Questo può far risparmiare tempo se ti servono solo risultati 2D come ortofoto e DEM. + +**Predefinito:** `False` + +## skip-band-alignment + +Durante l'elaborazione di dataset multispettrali, le immagini di ciascuna banda vengono allineate automaticamente. Se le immagini sono state post-elaborate e sono già allineate, usa questa opzione. + +**Predefinito:** `False` + +## skip-orthophoto + +Salta la generazione dell'ortofoto. Questo può far risparmiare tempo se ti servono solo risultati 3D o DEM. + +**Predefinito:** `False` + +## skip-report + +Salta la generazione del report PDF. Questo può far risparmiare tempo se non hai bisogno di un report. + +**Predefinito:** `False` + +## sky-removal + +Calcola automaticamente le maschere delle immagini utilizzando l'IA per rimuovere il cielo. Sperimentale. + +**Predefinito:** `False` + +## sm-cluster + +URL a un'istanza di ClusterODM per distribuire un flusso di lavoro split-merge su più nodi in parallelo. + +**Opzioni:** `` + +**Predefinito:** `None` + +## sm-no-align + +Salta l'allineamento dei sottomodelli nello split-merge. Utile se il GPS è sufficientemente buono su dataset molto grandi. + +**Predefinito:** `False` + +## smrf-scalar + +Parametro scalare di elevazione del Simple Morphological Filter. + +**Opzioni:** `` + +**Predefinito:** `1.25` + +## smrf-slope + +Parametro di pendenza del Simple Morphological Filter (rapporto tra dislivello e distanza). + +**Opzioni:** `` + +**Predefinito:** `0.15` + +## smrf-threshold + +Parametro di soglia di elevazione del Simple Morphological Filter (metri). + +**Opzioni:** `` + +**Predefinito:** `0.5` + +## smrf-window + +Parametro del raggio della finestra del Simple Morphological Filter (metri). + +**Opzioni:** `` + +**Predefinito:** `18.0` + +## split + +Numero medio di immagini per sottomodello. Quando si suddivide un dataset di grandi dimensioni in sottomodelli più piccoli, le immagini vengono raggruppate in cluster. Questo valore regola il numero medio di immagini che ciascun cluster dovrebbe avere. + +**Opzioni:** `` + +**Predefinito:** `999999` + +## split-image-groups + +Percorso al file dei gruppi di immagini che controlla come le immagini devono essere suddivise in gruppi. Il file deve usare il seguente formato: + +image_name group_name + +**Opzioni:** `` + +**Predefinito:** `None` + +## split-overlap + +Raggio della sovrapposizione tra i sottomodelli in metri. Dopo aver raggruppato le immagini in cluster, le immagini che si trovano a una distanza inferiore a questo raggio da un cluster vengono aggiunte al cluster. Questo viene fatto per garantire che i sottomodelli adiacenti si sovrappongano. Tutte le immagini necessitano di informazioni GPS. + +**Opzioni:** `` + +**Predefinito:** `150` + +## texturing-keep-unseen-faces + +Mantiene nella mesh le facce che non sono visibili in alcuna fotocamera. + +**Predefinito:** `False` + +## texturing-single-material + +Genera file OBJ con un singolo materiale e un singolo file di texture invece di più materiali e texture. + +**Predefinito:** `False` + +## texturing-skip-global-seam-leveling + +Salta la normalizzazione dei colori tra tutte le immagini. Utile durante l'elaborazione di dati radiometrici. + +**Predefinito:** `False` + +## tiles + +Genera tile statiche per ortofoto e DEM adatte a visualizzatori come Leaflet o OpenLayers. + +**Predefinito:** `False` + +## use-3dmesh + +Utilizza una mesh 3D completa per calcolare l'ortofoto invece di una mesh 2.5D. Questa opzione è un po' più veloce e fornisce risultati simili in aree pianeggianti. + +**Predefinito:** `False` + +## use-exif + +Usa questo tag se disponi di un file GCP ma vuoi utilizzare invece le informazioni EXIF per la georeferenziazione. + +**Predefinito:** `False` + +## use-fixed-camera-params + +Disattiva l'ottimizzazione dei parametri della fotocamera durante il bundle adjustment. Questo può a volte essere utile per migliorare risultati che presentano effetti di bombatura/incurvamento (doming/bowling) o quando le immagini sono state scattate con una fotocamera a rolling shutter. + +**Predefinito:** `False` + +## use-hybrid-bundle-adjustment + +Esegue un bundle adjustment locale per ogni immagine aggiunta alla ricostruzione e un adjustment globale ogni 100 immagini. Velocizza la ricostruzione per dataset molto grandi. + +**Predefinito:** `False` + +## version + +Mostra il numero di versione ed esce. + +## video-limit + +Numero massimo di fotogrammi da estrarre dai file video per l'elaborazione. Imposta a 0 per nessun limite. + +**Opzioni:** `` + +**Predefinito:** `500` + +## video-resolution + +La risoluzione massima di output dei fotogrammi video estratti, in pixel. + +**Opzioni:** `` + +**Predefinito:** `4000` diff --git a/src/content/docs/it/plugin-development-guide.md b/src/content/docs/it/plugin-development-guide.md new file mode 100644 index 0000000..50e499e --- /dev/null +++ b/src/content/docs/it/plugin-development-guide.md @@ -0,0 +1,360 @@ +--- +title: Guida allo Sviluppo di Plugin +template: doc +--- + +WebODM ti permette di scrivere plugin, che puoi distribuire come file .zip o condividere con il mondo aggiungendoli alla cartella `coreplugins` di WebODM (e aprendo una pull request). Questa è un'opzione flessibile per chi non vuole mantenere un fork separato, ma vuole comunque aggiungere nuove funzionalità a WebODM. + +Puoi attivare/disattivare i plugin dalla Dashboard tramite il menu **Administration** --> **Plugins**. + +I plugin ti permettono di definire sia logica lato server (Python) che lato client (Javascript). Vengono eseguiti in un ambiente condiviso. Ci sono hook / gestori di eventi / segnali a cui puoi iscriverti per essere notificato di vari eventi, ad esempio quando un task viene creato/eliminato, o quando la vista mappa sta per essere renderizzata. Il loro numero è limitato, ma tieni presente che se ne possono aggiungere altri. + +Vengono forniti alcuni helper di base, ad esempio per eseguire task asincroni di lunga durata, per l'archiviazione di base di dati chiave-valore, per installare dipendenze Python isolate (tramite pip) così come dipendenze Javascript (tramite npm). Un sistema di build lato client (tramite webpack) ti permette inoltre di usare React/SCSS nel codice del tuo plugin e di accedere a tutti i componenti lato client di WebODM (JSX). + +Puoi rendere disponibili degli asset (immagini, stili, template, ...) semplicemente posizionandoli in una cartella `public`. + +Il sistema di plugin non cerca di imporre standard rigidi. Ciò che costruisci dipende da te e tutto è possibile. + +## Avvio Rapido + + * Assicurati di aver avviato WebODM in modalità sviluppo (tramite `--dev`). Vedi [contribuire](/it/contributing/#configurare-un-ambiente-di-sviluppo) per le istruzioni. + * Vai su **Administration** --> **Plugins** e attiva il plugin **Hello World**. + * Nota che un menu "Hello World" è apparso nel menu laterale sinistro. + * Fai una copia della cartella `coreplugins/hello-world`. Chiamala `coreplugins/my-plugin`. + * Modifica `coreplugins/my-plugin/manifest.json`: + + ```json + { + "name": "My Plugin", + "webodmMinVersion": "2.9.4", + "description": "My First plugin", + "version": "1.0.0", + "author": "Your name", + "email": "your@email.here", + "repository": "https://github.com/WebODM/WebODM", + "tags": ["descriptive", "tags"], + "homepage": "https://github.com/WebODM/WebODM", + "experimental": false, + "deprecated": false +} +``` + + * Modifica `coreplugins/my-plugin/plugin.py`: + +```python +from app.plugins import PluginBase, Menu, MountPoint +from django.shortcuts import render +from django.contrib.auth.decorators import login_required +from django.utils.translation import gettext as _ + +class Plugin(PluginBase): + def main_menu(self): + return [Menu(_("My Plugin"), self.public_url(""), "fa fa-cog fa-fw")] + + def app_mount_points(self): + @login_required + def hello_view(request): + return render(request, self.template_path("hello.html"), {'message': "Hello!"}) + + return [ + MountPoint('$', hello_view), + # altri mount point qui ... + ] + + def include_js_files(self): + return ['main.js'] + + def build_jsx_components(self): + return ['app.jsx'] + + # vedi anche plugin_base.py per altri metodi + ``` + + * Salva le modifiche e apri `app/boot.py`, aggiungi una riga vuota, salva `boot.py`, poi rimuovi la riga vuota e salva di nuovo `boot.py`. Questo è un trucco per forzare WebODM a ricaricarsi senza riavviare il processo docker. Devi farlo solo una volta. + * Il tuo plugin dovrebbe ora essere visibile in **Administration** --> **Plugins**. + * Attivalo per vedere se funziona. + +Congratulazioni! 🎉 Ora sei uno sviluppatore di plugin. + +Il tuo plugin dovrebbe avere questa struttura di file di base: + +``` +├── disabled +├── __init__.py +├── manifest.json +├── plugin.py +├── public +│ ├── app.jsx +│ ├── app.scss +│ ├── main.js +│ └── webpack.config.js +└── templates + └── hello.html +``` + +Un file `disabled` vuoto nella radice indica che il plugin non deve essere abilitato per impostazione predefinita. + +## Template Django + +Puoi renderizzare [template Django](https://docs.djangoproject.com/en/2.2/topics/templates/) posizionando i file di template nella cartella `templates`. Poi renderizzi i template creando dei *mount point* (proprio come gli [URL Django](https://docs.djangoproject.com/en/2.2/topics/http/urls/)). + +## File Javascript + +Puoi eseguire codice javascript arbitrario. Quando il tuo plugin è abilitato, ogni file restituito da `include_js_files` verrà incluso in ogni pagina di WebODM (nell'header). Puoi usarlo come punto di ingresso per caricare codice Javascript più complesso (ad esempio una build React) o per registrare un hook. + +## File CSS + +Come per Javascript, puoi includere file CSS arbitrari tramite: + + +```python +def include_css_files(self): + return ['style.css'] +``` + +## Componenti React + +Se prevedi di usare React (opzionale) e vuoi utilizzare il sistema integrato per la build dei componenti (anch'esso opzionale), dovrai dichiarare quali file `.jsx` vuoi compilare tramite: + +```python +def build_jsx_components(self): + return ['app.jsx'] +``` + +I file compilati verranno posizionati in `coreplugins/my-plugin/public/build/*` e sono accessibili tramite `http://localhost:8000/plugins/my-plugin/build/*`. + +Se usi componenti JSX, ti conviene riavviare il tuo ambiente di sviluppo con: + +```bash +./webodm.sh restart --dev --dev-watch-plugins +``` + +Altrimenti dovrai eseguire manualmente `webpack --watch` dalla cartella `coreplugins/my-plugin/public` (all'interno del container WebODM). + +Sul lato client, puoi importare i tuoi componenti React, così come qualsiasi altro modulo Javascript, usando vari hook. Uno di questi hook è `PluginsAPI.App.Ready`, che viene attivato al caricamento della pagina: + +```javascript +PluginsAPI.App.ready([ + '/plugins/my-plugin/build/app.js', + '/plugins/my-plugin/build/app.css' + ], function(args, App){ + + ReactDOM.render(React.createElement(App, {greeting: "Hi"}), $("#hello-component").get(0)); +}); +``` + +## Hook Lato Client + +Puoi essere notificato di vari eventi lato client tramite gli hook. Alcuni di questi hook ti permettono di restituire un elemento DOM, che può essere utile per aggiungere pulsanti o altri componenti in momenti diversi del processo di rendering dell'interfaccia utente: + +```javascript +PluginsAPI.hook([ + // elenco opzionale di dipendenze da caricare +], function(args, optional dependencies]){ + // Il tuo codice qui + + // args contiene parametri specifici per ciascun hook. + + console.log(args); + + var domEl = /* ... */; + return domEl; +}); + +``` + +|
Hook
| Attivato | +| ----------------------------------- | ----------------------------------------------------------------------------------------- | +| `App.ready` | Al caricamento del DOM | +| `Dashboard.addTaskActionButton` | Quando sono stati aggiunti pulsanti a un task (accanto a View Map, View 3D Model, ..) | +| `Dashboard.addNewTaskPanelItem` | All'apertura del pannello dopo aver selezionato immagini e GCP | +| `Dashboard.addNewTaskButton` | Quando sono stati aggiunti pulsanti al pannello di un progetto (accanto a Select Images and GCP, Import) | +| `Map.willAddControls` | Quando i controlli Leaflet stanno per essere aggiunti | +| `Map.didAddControls` | Quando i controlli Leaflet sono stati aggiunti | +| `Map.addActionButton` | Quando i pulsanti azione (in basso a destra dello schermo) stanno per essere aggiunti | +| `ModelView.addActionButton` | Quando i pulsanti azione (in basso a destra dello schermo) stanno per essere aggiunti (nel Modello 3D) | +| `SharePopup.addLinkControl` | Al rendering della finestra di dialogo Share nella Vista Mappa | + +## Callback Lato Client + +Analogamente agli hook, le callback possono notificarti degli eventi che si verificano nell'applicazione, ma a differenza degli hook, non permettono il caricamento di dipendenze. Puoi registrare e annullare la registrazione delle callback: + +```javascript +var myFunction = function(){ + return someValue; +}; + +PluginsAPI.[ns].onCallback(myFunction); // per registrare +PluginsAPI.[ns].offCallback(myFunction); // per annullare la registrazione +``` + +Ad esempio: + +```javascript +PluginsAPI.Map.onHandleClick(function(){ + console.log("Map clicked!"); +}); +``` + +| Namespace |
Callback
| Attivata Quando | +| --------- | --------------------------------------- | ----------------------------------------------------------------------------- | +| `Map` | `handleClick` | La mappa Leaflet viene cliccata | +| `Map` | `addAnnotation` | Un'annotazione sta per essere aggiunta | +| `Map` | `updateAnnotation` | Un'annotazione sta per essere modificata | +| `Map` | `deleteAnnotation` | Un'annotazione sta per essere eliminata | +| `Map` | `toggleAnnotation` | Un'annotazione sta per essere attivata/disattivata | +| `Map` | `annotationDeleted` | Un'annotazione è stata eliminata | +| `Map` | `downloadAnnotations` | Viene avviata una richiesta di download delle annotazioni | +| `Map` | `mapTypeChanged` | Il tipo di mappa (da Ortofoto a Modello di Superficie, a Salute delle Piante, ecc.) è cambiato | +| `Map` | `sideBySideChanged` | L'utente ha sovrapposto due layer affiancati | + +## Segnali Lato Server + +Puoi registrarti a vari [segnali Django](https://docs.djangoproject.com/en/2.2/topics/signals/) per essere notificato degli eventi che si verificano nell'applicazione. + +```python +from django.dispatch import receiver +from app.plugins.signals import task_completed +from app.plugins.functions import get_current_plugin + +@receiver(task_completed) +def on_complete(sender, task_id, **kwargs): + # Non eseguire questo se il plugin non è attivo + if get_current_plugin(only_active=True) is None: + return + + print("Task %s has completed" % task_id) +``` + +|
Segnale
| Attivato Quando | +| ------------------------------------- | ---------------------------------- | +| `task_completed` | Un task è terminato con successo | +| `task_removing` | Un task sta per essere eliminato | +| `task_removed` | Un task è stato eliminato | +| `task_failed` | Un task è fallito | +| `task_resizing_images` | Un task sta ridimensionando le immagini | +| `task_duplicated` | Un task è stato duplicato | +| `processing_node_removed` | Un nodo di elaborazione è stato eliminato | + +## Dipendenze NPM + +Puoi utilizzare dipendenze esterne definendo un `package.json` nella cartella `public` del tuo plugin e riferire quelle dipendenze nei tuoi componenti JSX (o caricarle nel browser). Questo può essere creato tramite `npm init`. Le dipendenze vengono scaricate e installate automaticamente durante la build. + +## Dipendenze PIP + +Sul lato server, puoi installare pacchetti Python aggiuntivi definendo un file `requirements.txt` nella cartella radice del tuo plugin (ad esempio `coreplugins/my-plugin/requirements.txt`). + +Quando il plugin viene abilitato, il sistema verificherà prima se qualche dipendenza deve essere scaricata ed eseguirà `pip install` se necessario. + +Per evitare collisioni di versioni/namespace con WebODM, così come con altri plugin, per usare una dipendenza del plugin devi racchiudere l'import in un contesto `python_imports`: + +```python +from app.plugins.functions import get_current_plugin + +with get_current_plugin().python_imports(): + import numpy as np + # ... +``` + +## Task di Lunga Durata + +Il sistema di plugin offre funzioni per eseguire task lato server di lunga durata, così come funzioni lato client per tracciare lo stato di tali task. I task di lunga durata vengono eseguiti da processi worker anziché dall'applicazione del server web. + +Sul server: + +```python +from app.plugins.worker import run_function_async +from rest_framework import status +from rest_framework.response import Response + +# Dal mount point "greet" + +def long_greet(greeting, progress_callback=None): + import time # DEVI posizionare gli import all'interno della funzione asincrona e non all'inizio del file + time.sleep(30) + progress_callback("Almost done!", 50) # opzionale (testo di stato, [0-100]%) + time.sleep(10) + return {'output': greeting + " there!"} # qualsiasi output serializzabile in JSON + + # - oppure - puoi anche restituire file restituendo un + # myfile = 'path/to/file.txt' + # return {'file': myfile} + + # - oppure - un errore + # return {'error': 'oh no'} + +try: + celery_task_id = run_function_async(long_greet, greeting="Hi").task_id + return Response({'celery_task_id': celery_task_id}, status=status.HTTP_200_OK) +except Exception as e: + return Response({'error': str(e)}, status=status.HTTP_200_OK) +``` + +Sul client: + +```javascript +import Workers from 'webodm/classes/Workers'; + +$.ajax({ + type: 'GET', + url: `/api/plugins/my-plugin/greet/`, + contentType: "application/json" +}).done(res => { + Workers.waitForCompletion(res.celery_task_id, error => { + if (error){ + console.error("oh no!"); + }else{ + Workers.getOutput(result.celery_task_id, (error, greeting) => { + console.log(greeting); + }); + // - oppure - anche download di file + // Workers.downloadFile(res.celery_task_id, res.filename); + } + }, (status, progress) => { + console.log(status, progress) + }); +}); +``` + +:::caution +**Devi** dichiarare tutte le istruzioni di import all'interno delle tue funzioni asincrone (e non all'inizio del file). Inoltre puoi passare solo argomenti serializzabili in JSON alle funzioni asincrone. Ad esempio, non puoi passare oggetti Python complessi. +::: + +## Data Store Integrato + +L'archiviazione dei dati è un requisito frequente per ogni tipo di applicazione, quindi il sistema di plugin offre un semplice store chiave-valore per archiviare stringhe, interi, float, booleani e JSON, che può essere globale (condiviso tra tutti gli utenti) o basato sull'utente (specifico per un utente). + +```python +from app.plugins import GlobalDataStore, UserDataStore + +# da un mount point + +ds = GlobalDataStore('my-plugin') +uds = UserDataStore('my-plugin', request.user) + +ds.set_string("key1", "string") +ds.set_int("key2", 42) +ds.set_float("key3", 3.14) +ds.set_bool("key4", True) +ds.set_json("key5", {'piero_is': ['cool', 'silly', 'both']}) + +ds.get_string("key1") +ds.get_int("key2") + +# ... +``` + +I dati salvati in questo modo vengono archiviati **non cifrati** nella tabella *PluginDatum*. Puoi visualizzare/modificare questi dati visitando **Administration** --> **Application** --> **Plugin Datum**. + +## Pubblicare il Tuo Plugin + +Il modo più semplice per condividere il tuo lavoro è aprire una pull request nel repository di WebODM. A un certo punto in futuro potremmo creare una sorta di repository di plugin dove le persone possano sfogliare e scaricare i plugin, ma non ci siamo ancora arrivati. + +Puoi anche creare un file zip dell'intera cartella del plugin (ad esempio `my-plugin`) con la cartella come elemento di primo livello nell'archivio zip e distribuire il file zip manualmente. Gli utenti possono quindi installare il plugin premendo il pulsante **Load Plugin (.zip)** visitando **Administration** --> **Plugins**. + +## Consigli Finali + + * Impara dagli altri plugin! Questa documentazione fornisce le basi, ma è davvero utile studiare come funzionano gli altri plugin guardandone il codice sorgente. + * Se hai bisogno di un nuovo hook, callback o segnale, apri una pull request e aggiungiamolo al sistema. + * Col tempo, questa documentazione potrebbe diventare obsoleta. Se qualcosa non sembra corrispondere a ciò che vedi in questa pagina o non sembra funzionare, controlla il codice! Il sistema di plugin non è complicato e può essere letto dall'inizio alla fine in meno di qualche ora. Leggi `app/plugins` e `app/static/app/js/classes/plugins`. + * Divertiti :) diff --git a/src/content/docs/it/roadmap.md b/src/content/docs/it/roadmap.md new file mode 100644 index 0000000..1ee5dc3 --- /dev/null +++ b/src/content/docs/it/roadmap.md @@ -0,0 +1,12 @@ +--- +title: Roadmap +template: doc +--- + +Anche se non abbiamo una roadmap formale, seguiamo un approccio dal basso verso l'alto per decidere quali nuove funzionalità vengono aggiunte a WebODM. Il feedback degli utenti ci guida nel processo decisionale e raccogliamo tale feedback. + +Teniamo traccia delle funzionalità in fase di valutazione per l'inclusione tramite l'[issue tracker](https://github.com/WebODM/WebODM/issues) + +Non vedi una funzionalità che desideri? [Apri una issue](https://github.com/WebODM/WebODM/issues) o, ancora meglio, [una pull request](/it/contributing/). + +A volte diamo anche priorità al lavoro che ha ricevuto sostegno finanziario. Se la tua organizzazione è nella posizione di sostenere finanziariamente lo sviluppo di una particolare funzionalità, contattaci e la realizzeremo. diff --git a/src/content/docs/it/support-the-project.md b/src/content/docs/it/support-the-project.md new file mode 100644 index 0000000..cac002d --- /dev/null +++ b/src/content/docs/it/support-the-project.md @@ -0,0 +1,62 @@ +--- +title: Sostieni il Progetto +template: doc +--- + +Ci sono molti modi per contribuire al progetto: + + - Puoi acquistare un [piano WebODM Lightning](https://webodm.net) o [GCP Editor Pro](https://gcp.uav4geo.com), che aiutano a finanziare gli sforzi di sviluppo. + - Aiutaci a testare le funzionalità nuove ed esistenti e a [segnalare](https://www.github.com/WebODM/WebODM/issues) bug e feedback. + - Condividi i tuoi dataset aerei. + - Unisciti a una [comunità](https://webodm.org/community) + - Metti una ⭐️ su GitHub. + - Aiutaci a [tradurre](#traduzioni) WebODM nella tua lingua. + - Aiutaci a migliorare e ampliare la [documentazione](#documentazione) + - Fai conoscere WebODM sui social media. + - Diventa un contributore di codice 🤘 + +## Traduzioni + +Tradurre WebODM in un'altra lingua è facile! + + - Visita https://hosted.weblate.org/engage/webodm/ e registra un account (è gratuito) + - Scegli una lingua da tradurre, oppure [avvia una nuova traduzione](https://hosted.weblate.org/new-lang/webodm/webodm/) + - Inizia a tradurre! È davvero così semplice. + +Se vuoi vedere in anteprima il tuo lavoro di traduzione, avvia WebODM in modalità sviluppatore: + +``` +./webodm.sh restart --dev +``` + +Poi modifica il file [LOCALES](https://github.com/WebODM/WebODM/blob/master/LOCALES) per includere il codice locale della tua traduzione. Infine, visita il pannello `Developer Tools` dalla dashboard di WebODM e premi il pulsante `Download and Replace Translation Files`: + +![image](https://user-images.githubusercontent.com/1951843/102927263-a294a100-4464-11eb-956e-888b73dc5b94.png) + +I file di traduzione più recenti da weblate.org verranno scaricati e applicati all'installazione di WebODM. + +## Documentazione + +Aiutaci a migliorare la documentazione! Basta accedere a una qualsiasi pagina della documentazione e fare clic sul collegamento "edit this page" in fondo alla pagina. + + - Vai a una pagina qualsiasi + - Scorri fino in fondo e fai clic su "Edit this page" + - Verrai portato al file sorgente su GitHub. Dovrai creare un account se non ne hai uno + - Fai clic su "Fork this repository" + - Apporta le tue modifiche usando [markdown](https://www.markdownguide.org/basic-syntax/) + - Esegui il commit delle modifiche e fai clic su "Create pull request" + - Aggiungi eventuale contesto aggiuntivo nella descrizione della pull request e invia + +Il tuo contributo verrà revisionato e, una volta approvato, apparirà su questo sito. + +## Diventa un Contributore di Codice + +Il modo più semplice per iniziare è dare un'occhiata al nostro elenco di [issue aperte](https://github.com/WebODM/WebODM/issues) e sceglierne una. Puoi anche correggere/migliorare qualcosa di completamente nuovo basandoti sulla tua esperienza con WebODM. Tutte le idee vengono prese in considerazione e persone di ogni livello di competenza sono le benvenute a contribuire. + +Non è necessario essere uno sviluppatore per diventare un contributore. Il tuo aiuto ci è utile per scrivere una documentazione migliore e per migliorare i testi e la grafica dell'interfaccia utente. + +Se sai programmare, usiamo principalmente Python (Django), Javascript (React), HTML e SCSS. Consulta [Contribuire](/it/contributing) per maggiori informazioni. + +Per fare un contributo, dovrai aprire una pull request ([ecco come](https://github.com/Roshanjossey/first-contributions#fork-this-repository)). Per apportare modifiche a WebODM, crea un clone del repository ed esegui `./webodm.sh start --dev`. + +Se hai domande, vieni a trovarci sul [forum](http://community.opendronemap.org/c/webodm) e saremo felici di aiutarti con il tuo primo contributo. diff --git a/src/content/docs/it/tutorials/calibrating-the-camera.md b/src/content/docs/it/tutorials/calibrating-the-camera.md new file mode 100644 index 0000000..d0ec454 --- /dev/null +++ b/src/content/docs/it/tutorials/calibrating-the-camera.md @@ -0,0 +1,29 @@ +--- +title: Calibrazione della Fotocamera +template: doc +--- + +La calibrazione della fotocamera è una sfida particolare con le fotocamere di largo consumo. Variazioni di temperatura, vibrazioni, messa a fuoco e altri fattori possono influenzare i parametri derivati, con effetti sostanziali sui dati risultanti. La calibrazione automatica o autocalibrazione è possibile e desiderabile nei voli con drone, ma a seconda dello schema di volo, la calibrazione automatica potrebbe non rimuovere tutta la distorsione dai prodotti risultanti. James e Robson (2014), nel loro articolo [Mitigating systematic error in topographic models derived from UAV and ground‐based image networks](https://onlinelibrary.wiley.com/doi/full/10.1002/esp.3609), affrontano il tema di come minimizzare la distorsione derivante dall'autocalibrazione. + +![Effetto bowling sulla nuvola di punti](/images/msimbasi_bowling.webp) + +*Effetto bowling sulla nuvola di punti in un dataset di oltre 13.000 immagini raccolto dalla World Bank Tanzania sul bacino del Msimbasi, soggetto a inondazioni, a Dar es Salaam, Tanzania.* + +Per mitigare questo effetto esistono alcune opzioni, ma le più semplici sono le seguenti: volare seguendo due schemi separati di 20° e, invece di utilizzare una fotocamera al nadir (puntata verticalmente verso il basso), usarne una inclinata in avanti di 5°. + +![Pianificazione di volo ottimale](/images/flightplanning.webp) + +Poiché questo approccio richiede più tempo rispetto all'acquisizione tradizionale, i piloti e i team possono applicare questa tecnica a un'area più piccola e utilizzare i dati raccolti per ottimizzare i voli futuri. WebODM può generare un file di calibrazione chiamato cameras.json a partire da un piccolo volo campione. Il file di calibrazione può essere utilizzato per voli futuri, mitigando l'effetto bowling senza sacrificare l'efficienza. + +In alternativa, è possibile applicare il seguente metodo sperimentale: volare con una sovrapposizione molto più bassa, ma con due voli a *griglia incrociata* (crossgrid, talvolta detta crosshatch) separati di 20° con una fotocamera inclinata in avanti di 5°. + +- Le percentuali di sovrapposizione dei voli a griglia incrociata possono essere inferiori a quelle dei voli paralleli. Per ottenere buoni risultati 3D, saranno necessari il 68% di overlap e sidelap, equivalenti a un 83% di overlap e sidelap. +- Per ottenere buoni risultati 2D e 2.5D (modello digitale di elevazione), saranno necessari il 42% di overlap e sidelap, equivalenti a un 70% di overlap e sidelap. + +![Metodo sperimentale di rotazione](/images/rotation.webp) + +Anche linee di volo separate verticalmente migliorano l'accuratezza, ma in misura minore rispetto a una fotocamera inclinata in avanti di 5°. + +![Effetto delle linee di volo separate verticalmente](/images/forward_facing.webp) + +*Da James e Robson (2014), [CC BY 4.0](https://creativecommons.org/licenses/by/4.0)* diff --git a/src/content/docs/it/tutorials/creating-digital-elevation-models.md b/src/content/docs/it/tutorials/creating-digital-elevation-models.md new file mode 100644 index 0000000..3fecb51 --- /dev/null +++ b/src/content/docs/it/tutorials/creating-digital-elevation-models.md @@ -0,0 +1,34 @@ +--- +title: Modelli Digitali di Elevazione +template: doc +--- + +Per impostazione predefinita WebODM non crea modelli digitali di elevazione (DEM). Per creare un modello digitale del terreno, assicurarsi di passare il flag `--dtm`. Per creare un modello digitale di superficie, assicurarsi di passare il flag `--dsm`. + +![Modello digitale di superficie](/images/digitalsurfacemodel.webp) + +Per la generazione del DTM viene utilizzato un Simple Morphological Filter (smrf) per classificare i punti in punti a terra e non a terra, e vengono utilizzati solo i punti a terra. Il filtro `smrf` può essere controllato tramite diversi parametri: + +- `--smrf-scalar` valore di scala. Aumentare questo parametro per terreni con molte variazioni di quota. +- `--smrf-slope` parametro di pendenza, che è una misura della "tolleranza alla pendenza". Aumentare questo parametro per terreni con molte variazioni di quota. Dovrebbe essere impostato a un valore superiore a 0.1 e non superiore a 1.2. +- `--smrf-threshold` soglia di elevazione. Impostare questo parametro all'altezza minima (in metri) che ci si aspetta abbiano gli oggetti non a terra. +- `--smrf-window` parametro del raggio della finestra (in metri) che corrisponde alla dimensione dell'elemento più grande (edificio, alberi, ecc.) da rimuovere. Dovrebbe essere impostato a un valore superiore a 10. + +La modifica di queste opzioni può influenzare significativamente il risultato dei DTM. La migliore fonte da consultare per capire come i parametri influenzano il risultato è il documento originale [An improved simple morphological filter for the terrain classification of airborne LIDAR data](https://www.researchgate.net/publication/258333806_An_Improved_Simple_Morphological_Filter_for_the_Terrain_Classification_of_Airborne_LIDAR_Data). + +Nel complesso l'opzione `--smrf-threshold` ha il maggiore impatto sui risultati. + +SMRF è efficace nell'evitare errori di Tipo I (un piccolo numero di punti a terra erroneamente classificati come non a terra) ma solo "accettabile" nell'evitare errori di Tipo II (un grande numero di punti non a terra erroneamente classificati come a terra). Questo deve essere preso in considerazione quando si generano DTM destinati a un uso visivo, poiché gli oggetti scambiati per terreno appaiono come artefatti nel DTM finale. + +![Filtro SMRF](/images/smrf.webp) + +Altri due parametri importanti influenzano la generazione del DEM: + +- `--dem-resolution` che imposta la risoluzione in uscita del raster DEM (cm/pixel) +- `--dem-gapfill-steps` che determina il numero di layer DEM progressivi da utilizzare. Per scene urbane, aumentare questo valore a `4-5` può aiutare a produrre migliori risultati di interpolazione nelle aree lasciate vuote dal filtro SMRF. + +Esempio di come generare un DTM: + +```bash +docker run -ti --rm -v /my/project:/datasets/code --project-path /datasets --dtm --dem-resolution 2 --smrf-threshold 0.4 --smrf-window 24 +``` diff --git a/src/content/docs/it/tutorials/creating-high-quality-orthophotos.md b/src/content/docs/it/tutorials/creating-high-quality-orthophotos.md new file mode 100644 index 0000000..c392bca --- /dev/null +++ b/src/content/docs/it/tutorials/creating-high-quality-orthophotos.md @@ -0,0 +1,12 @@ +--- +title: Creazione di Ortofoto di Qualità +template: doc +--- + +![Ortofoto](/images/orthophoto.webp) + +Senza alcuna modifica dei parametri, WebODM sceglie un buon compromesso tra qualità, velocità e utilizzo della memoria. Se si desidera ottenere risultati di qualità superiore, è necessario regolare alcuni parametri: + +- `--orthophoto-resolution` è la risoluzione dell'ortofoto in cm/pixel. Diminuire questo valore per un risultato a risoluzione più elevata. + +- `--mesh-size` dovrebbe essere aumentato a `300000-600000` e `--mesh-octree-depth` dovrebbe essere aumentato a `10-11` nelle aree urbane per ricostruire meglio edifici e tetti. diff --git a/src/content/docs/it/tutorials/large-datasets.md b/src/content/docs/it/tutorials/large-datasets.md new file mode 100644 index 0000000..00b39bc --- /dev/null +++ b/src/content/docs/it/tutorials/large-datasets.md @@ -0,0 +1,189 @@ +--- +title: Grandi Set di Dati +template: doc +--- + +Puoi suddividere dataset molto grandi in porzioni gestibili (chiamate sottomodelli), eseguire il software su ciascuna porzione e quindi produrre DEM, ortofoto e nuvole di punti uniti. Il processo è chiamato "split-merge". + +Perché potresti usare la pipeline split-merge? Se hai un numero molto elevato di immagini nel tuo dataset, split-merge aiuterà a rendere l'elaborazione più gestibile su un sistema di grandi dimensioni (richiederà meno memoria). Se hai molti computer tutti connessi alla stessa rete, puoi anche elaborare i sottomodelli in parallelo, consentendo così la scalabilità orizzontale e l'elaborazione di migliaia di immagini più rapidamente. + +Split-merge funziona in WebODM senza configurazioni aggiuntive, purché i nodi di elaborazione supportino split-merge, abilitando l'opzione `--split` quando si crea un nuovo task. + +## Split-Merge Locale + +Suddividere un dataset in sottomodelli più gestibili ed elaborare in sequenza tutti i sottomodelli sullo stesso computer è facile! Basta usare `--split` e `--split-overlap` per decidere rispettivamente il numero medio di immagini per sottomodello e la sovrapposizione (in metri) tra i sottomodelli: + +```bash +docker run -ti --rm -v /my/project:/datasets/code webodm/odx --project-path /datasets --split 400 --split-overlap 100 +``` + +Se sai già come vuoi suddividere il dataset, puoi fornire quell'informazione e verrà usata al posto dell'algoritmo di clustering. + +Il raggruppamento può essere fornito aggiungendo un file chiamato `image_groups.txt` nella cartella principale del dataset. Il file deve avere una riga per immagine. Ogni riga deve contenere due parole: prima il nome dell'immagine e poi il nome del gruppo a cui appartiene. Per esempio: + +``` +01.jpg A +02.jpg A +03.jpg B +04.jpg B +05.jpg C +``` + +creerà 3 sottomodelli. Assicurati di passare `--split-overlap 0` se fornisci manualmente un file `image_groups.txt`. + +## Split-Merge Distribuito + +WebODM può anche distribuire automaticamente l'elaborazione di ogni sottomodello su più computer tramite nodi [NodeODX](https://github.com/WebODM/NodeODX), orchestrati tramite [ClusterODX](https://github.com/WebODM/ClusterODX). + +![ClusterODX](/images/ClusterODX.webp) + +### Primi Passi con lo Split-Merge Distribuito + +Il primo passo è avviare ClusterODX: + +```bash +docker run -ti -p 3001:3000 -p 8080:8080 webodm/clusterodx +``` + +Poi, su ogni computer che vuoi usare per l'elaborazione, avvia un'istanza di NodeODX tramite: + +```bash +docker run -ti -p 3000:3000 webodm/nodeodx +``` + +Connettiti via telnet a ClusterODX e aggiungi gli indirizzi IP/porta dei computer che eseguono NodeODX: + +```bash +$ telnet 8080 +Connected to . +Escape character is '^]'. +[...] +# node add 3000 +# node add 3000 +[...] +# node list +1) :3000 [online] [0/2] +2) :3000 [online] [0/2] +``` + +A questo punto, usa semplicemente l'opzione `--sm-cluster` per abilitare lo split-merge distribuito. + +### Comprendere il Cluster + +Quando si è connessi via telnet, è possibile interrogare ciò che sta accadendo sul cluster. Per esempio, possiamo usare il comando HELP per scoprire i comandi disponibili: + +``` +# HELP +NODE ADD [token] - Add new node +NODE DEL - Remove a node +NODE INFO - View node info +NODE LIST - List nodes +NODE LOCK - Stop forwarding tasks to this node +NODE UNLOCK - Resume forwarding tasks to this node +NODE UPDATE - Update all nodes info +NODE BEST - Show best node for the number of images +ROUTE INFO - Find route information for task +ROUTE LIST [node number] - List routes +TASK LIST [node number] - List tasks +TASK INFO - View task info +TASK OUTPUT [lines] - View task output +TASK CANCEL - Cancel task +TASK REMOVE - Remove task +ASR VIEWCMD - View command used to create a machine +!! - Repeat last command +``` + +Se l'istanza di NodeODX non era attiva quando ClusterODX è stato avviato, puoi eseguire un `NODE UPDATE`: + +``` +# NODE UPDATE +OK +# NODE LIST +1) localhost:3000 [online] [0/2] [L] +``` + +### Accedere ai Log + +Mentre un processo è in esecuzione, è anche possibile elencare i task e visualizzare l'output del task: + +``` +# TASK LIST +# TASK OUTPUT [lines] +``` + +### Autoscaling di ClusterODX + +ClusterODX include anche la possibilità di effettuare l'autoscaling su più piattaforme, tra cui Amazon e Digital Ocean. Questo consente agli utenti di ridurre i costi associati alle istanze sempre attive, oltre a poter scalare l'elaborazione in base alla domanda. + +Per configurare l'autoscaling devi: + +- Avere una versione funzionante di NodeJS installata e quindi installare ClusterODX: + +```bash +git clone https://github.com/WebODM/ClusterODX +cd ClusterODX +npm install +``` + +- Assicurarti che docker-machine sia installato. +- Configurare un bucket compatibile S3 per l'archiviazione dei risultati. +- Creare un file di configurazione per [DigitalOcean](https://github.com/WebODM/ClusterODX/blob/master/docs/digitalocean.md) o [Amazon Web Services](https://github.com/WebODM/ClusterODX/blob/master/docs/aws.md). + +Puoi quindi avviare ClusterODX con: + +```bash +node index.js --asr configuration.json +``` + +Dovresti vedere nella console qualcosa di simile ai seguenti messaggi: + +``` +info: ASR: DigitalOceanAsrProvider +info: Can write to S3 +info: Found docker-machine executable +``` + +Dovresti sempre avere almeno un nodo NodeODX statico collegato a ClusterODX, anche se prevedi di usare l'autoscaler per tutta l'elaborazione. Se configuri l'autoscaling, non puoi avere zero nodi e affidarti al 100% all'autoscaler. Devi collegare un nodo NodeODX che funga da "nodo di riferimento", altrimenti ClusterODX non saprà come gestire determinate richieste. A questo scopo, dovresti aggiungere un nodo NodeODX "fittizio" e bloccarlo: + +```bash +telnet localhost 8080 +> NODE ADD localhost 3001 +> NODE LOCK 1 +> NODE LIST +1) localhost:3001 [online] [0/2] [L] +``` + +In questo modo tutti i task verranno inoltrati automaticamente all'autoscaler. + +## Limitazioni + +Le mesh 3D texturizzate attualmente non vengono unite come parte del flusso di lavoro (vengono unite solo nuvole di punti, DEM e ortofoto). + +I GCP sono pienamente supportati; tuttavia, devono esserci almeno 3 punti GCP su ogni sottomodello affinché la georeferenziazione abbia luogo. Se un sottomodello ha meno di 3 GCP, verrà usata al loro posto una combinazione dei GCP rimanenti + dati EXIF (che risulterà meno accurata). Raccomandiamo di usare il file `image_groups.txt` per controllare con precisione la suddivisione dei sottomodelli quando si usano i GCP. + +## Stimare lo Sforzo di Raccolta Dati + +I dataset più grandi possono essere raccolti con UAV specializzati ad ala fissa, UAV a decollo e atterraggio verticale (VTOL), e raccolti in modo piuttosto efficiente in determinate condizioni. In molti casi, tuttavia, siamo vincolati a effettuare la raccolta dati con quadricotteri di uso comune. In questi casi, una domanda frequente riguarda il tempo di raccolta dati in condizioni ideali con attrezzatura di uso comune. + +### Sforzo di Raccolta Dati, 3D Completo + +Per risultati di prima classe con ricostruzione 3D completa e risoluzione di 5 cm, è fattibile raccogliere 1–2 km² per persona, al giorno. Questo richiede il seguente insieme di voli: + +- volo nadirale con sovrapposizione del 60% +- griglia incrociata con angolo del gimbal a 45 gradi e sovrapposizione del 70-80% + +Il volo a griglia incrociata a 45 gradi fornisce la base per un modello completamente collegato, mentre i voli nadirali forniscono la texture necessaria per la texturizzazione dell'ortofoto. La sovrapposizione più bassa soddisfa il requisito minimo per i prodotti ortofoto, agevolata dal feature matching reso possibile dalla griglia incrociata a sovrapposizione molto più elevata. + +### Sforzo di Raccolta Dati, Prodotti 2D e 2.5D + +Per risultati di prima classe per prodotti 2D e 2.5D e risoluzione di 5 cm, è fattibile raccogliere 2–4 km² per persona, al giorno. Questo richiede il seguente insieme di voli: + +- sovrapposizione del 70-80% leggermente fuori nadir (5-10 gradi fuori nadir) + +Per edifici e vegetazione più complessi, punta a una sovrapposizione più vicina all'80%. Se edifici, vegetazione e variazioni del terreno non sono complessi, è del tutto fattibile usare una sovrapposizione più vicina al 70%. + +*(credito: derivato da conversazioni in corso con Ivan Gayton, Humanitarian OpenStreetMap Team)* + +## Riconoscimenti + +Un enorme ringraziamento a Pau, Yann e al team di Mapillary per i loro straordinari contributi a OpenSfM, che è un componente chiave della pipeline split-merge. diff --git a/src/content/docs/it/tutorials/measuring-stockpile-volume.md b/src/content/docs/it/tutorials/measuring-stockpile-volume.md new file mode 100644 index 0000000..baab07f --- /dev/null +++ b/src/content/docs/it/tutorials/measuring-stockpile-volume.md @@ -0,0 +1,82 @@ +--- +title: Misurazione di Cumuli +template: doc +--- + +### Pianificazione del Lavoro sul Campo + +Le condizioni meteorologiche modificano l'illuminazione e quindi influenzano i risultati fotografici. I migliori risultati si ottengono con cielo uniformemente coperto o sereno. Cercare inoltre condizioni di vento debole che consentano alla fotocamera di rimanere stabile durante il processo di raccolta dei dati. + +Per evitare ombre che su un lato del cumulo possono ostacolare il rilevamento degli elementi e ridurre il numero di punti risultanti, preferire sempre i voli durante il mezzogiorno, quando il sole è al nadir, in modo che tutto sia illuminato in modo uniforme. + +Assicurarsi inoltre che la distanza di visibilità orizzontale a occhio nudo sia congruente con le distanze di volo pianificate per il progetto specifico, in modo che la qualità delle immagini non sia influenzata negativamente da polvere, nebbia, fumo, cenere vulcanica o inquinamento. + +### Schema di Volo + +La maggior parte dei lavori di misurazione dei cumuli non richiede uno schema a griglia incrociata (crosshatch) o un gimbal inclinato, poiché l'angolo di riposo dei materiali del cumulo consente alla fotocamera di catturare interamente i lati del cumulo. Solo alcuni casi particolari, in cui l'erosione o le operazioni dei macchinari causano angoli ripidi sulle facce del cumulo, trarrebbero beneficio dallo schema di volo a griglia incrociata e dal gimbal della fotocamera inclinato; ma bisogna considerare che questi elementi aggiuntivi riconosciuti hanno un costo (in lavoro sul campo e tempo di elaborazione) e i miglioramenti risultanti sono talvolta trascurabili. + +Nella maggior parte dei casi uno schema di volo "a tosaerba" (lawn mower) è in grado di produrre modelli di cumuli altamente accurati. + +![Schema di volo a tosaerba](/images/lawnmower_pattern.webp) + +La sovrapposizione longitudinale (overlap) consigliata è tra il 75% e l'80%, con una sovrapposizione laterale (sidelap) nell'ordine del 65%-70%. Si consiglia inoltre di aumentare leggermente overlap e sidelap all'aumentare dell'altezza di volo. + +### Altezza di Volo + +L'altezza di volo può essere influenzata dai diversi modelli di fotocamera, ma in linea generale, e al fine di garantire un equilibrio tra qualità delle immagini e ottimizzazione del volo, si raccomanda di eseguirlo ad altezze da 3 a 4 volte l'altezza del cumulo più alto. Quindi, per un cumulo di 10 metri, le immagini possono essere catturate a un'altezza di 40 metri. + +All'aumentare dell'altezza di volo, si raccomanda anche di aumentare la sovrapposizione: per un volo a 40 metri di altezza si può impostare un sidelap del 65% e un overlap del 75%, ma per un'altezza pianificata di 80 metri un sidelap del 70% e un overlap dell'80%, consentendo agli elementi di essere riconosciuti ed elaborati correttamente. + +### GCP + +Per raggiungere livelli di accuratezza migliori del 3%, si consiglia l'uso dei GCP. In genere 5 GCP distribuiti sono sufficienti a garantire risultati accurati. Quando si posizionano o si misurano i GCP, l'accuratezza della strumentazione dovrebbe essere superiore al GSD. I ricevitori GNSS di grado topografico e le stazioni totali sono pensati per fornire l'accuratezza millimetrica richiesta. + +Per ulteriori informazioni sull'uso dei GCP, fare riferimento alla [sezione Punti di Controllo a Terra (GCP)](/it/ground-control-points/). + +### Parametri di Elaborazione + +Un modello altamente accurato può essere ottenuto utilizzando le impostazioni predefinite ad alta risoluzione di WebODM. Successivamente è possibile regolare ulteriormente alcuni parametri secondo necessità. + +Questi valori di riferimento possono aiutare a configurare le impostazioni di elaborazione: + +- `--dsm`: true +- `--dem-resolution`: 2.0 +- `--orthophoto-resolution`: 1.0 +- `--feature-quality`: high +- `--pc-quality`: high + +### Misurazione + +Poiché quasi il 50% del materiale si trova nel primo 20% dell'altezza del cumulo, occorre prestare particolare attenzione a definire adeguatamente il piano di base. + +![Distribuzione dell'altezza del cumulo](/images/stockpile.webp) + +Nella Dashboard di WebODM, fare clic su "view map" per avviare una vista 2D del progetto. + +Una volta nella vista mappa 2D, fare clic sul pulsante "Measure volume, area and length" (Misura volume, area e lunghezza). + +![Pulsante di misurazione del volume](/images/measurement1.webp) + +Quindi fare clic su "Create a new measurement" (Crea una nuova misurazione). + +![Crea una nuova misurazione](/images/measurement2.webp) + +Iniziare a posizionare i punti per definire il piano di base del cumulo. + +![Definizione del piano di base del cumulo](/images/measurement3.webp) + +Fare clic su "Finish measurement" (Termina misurazione) per completare il processo. + +![Termina misurazione](/images/measurement4.webp) + +La finestra di dialogo mostrerà il messaggio "Computing ..." per alcuni secondi e, al termine del calcolo, verrà visualizzato il valore della misurazione del volume. + +![Risultato della misurazione del volume](/images/measurement7.webp) + +Se si utilizza la riga di comando, è possibile usare i file dsm per misurare i volumi dei cumuli con altri programmi. + +Si consideri inoltre che, una volta impostati i limiti del cumulo in software come [QGIS](https://www.qgis.org), si scoprirà che esistono diversi modi per determinare il piano di base. Per cumuli isolati i cui confini sono per lo più visibili, si può utilizzare un approccio lineare. Mentre per cumuli posti su pendii o in contenitori, il piano di base è meglio definito dal punto più basso. Per cumuli di grandi dimensioni si consiglia la creazione di una superficie 3D triangolata per definire il piano di base. Questo vale anche per cumuli posti su superfici irregolari. + +### Accuratezza Attesa + +Per progetti pianificati ed eseguiti con cura, e specialmente quando il GSD è inferiore a 1 cm, l'accuratezza attesa dovrebbe essere compresa tra l'1% e il 2%. L'accuratezza risultante è paragonabile a quella dei software di fotogrammetria disponibili in commercio e a quella ottenuta con strumentazione GNSS di grado topografico. diff --git a/src/content/docs/it/tutorials/options-selection-guide.md b/src/content/docs/it/tutorials/options-selection-guide.md new file mode 100644 index 0000000..bb1f8b2 --- /dev/null +++ b/src/content/docs/it/tutorials/options-selection-guide.md @@ -0,0 +1,351 @@ +--- +title: Guida alla Selezione delle Opzioni +template: doc +--- + +Questa guida ti aiuta a scegliere i parametri di elaborazione di WebODM più appropriati in base al tuo drone, alle caratteristiche del rilievo e ai risultati attesi. +Nota bene: questa guida non è perfetta; trovare i parametri giusti non è sempre un processo deterministico—il più delle volte è un'arte che trascende gli algoritmi. + +--- +# Passo 1 - Analisi dell'Hardware + +## Il tuo drone utilizza un Global Shutter o un Rolling Shutter? + +### Se stai utilizzando un drone consumer (DJI Mini, DJI Air, Mavic, ecc.) + +**Impostazione consigliata** +- `rolling-shutter: true` +**Perché?** +I sensori rolling shutter introducono distorsioni geometriche quando le immagini vengono acquisite mentre il drone è in movimento. +**Buona pratica** +Per i rilievi futuri, se possibile: +- riduci la velocità di volo; +- usa la modalità **Stop-and-Hover** durante l'acquisizione delle fotografie. + +--- + +# Passo 2 - Caratteristiche del Rilievo + +## Le immagini includono il cielo o l'orizzonte? +### Se sì +**Impostazione consigliata** +```text +sky-removal: true +``` +### Benefici +- Meno rumore nella ricostruzione +- Nuvola di punti più pulita +- Migliore qualità della mesh + +## Per la ricostruzione di oggetti a distanza ravvicinata +Usa: +```text +bg-removal +``` +--- +# Passo 3 - Scena Rilevata +## L'area contiene vegetazione o superfici a bassa texture? +Esempi: +- foreste +- praterie +- campi agricoli +- sabbia +- neve + +**Impostazione consigliata** +```text +min-num-features: 20000 +``` + +### Effetto +- aumenta il numero di punti caratteristici rilevabili; +- migliora la robustezza della ricostruzione; +- aumenta il tempo di elaborazione. + +--- + +## Il progetto include edifici o strutture verticali? +**Impostazioni consigliate** +```text +pc-quality: high +``` + +### Benefici +- Ortofoto più accurate +- Migliore ricostruzione delle pareti verticali +- Bordi degli edifici più nitidi + +--- + +# Passo 4 - Ground Sampling Distance (GSD) +## Hai bisogno di preservare la piena risoluzione nativa della fotocamera? +Quando si vola molto basso (GSD inferiore a circa 2 cm), WebODM potrebbe ridurre automaticamente la risoluzione di elaborazione. +Per disabilitare questa ottimizzazione: + +```text +ignore-gsd: true +``` + +### Attenzione +Questo aumenta in modo significativo: +- Utilizzo di RAM +- Spazio su disco +- Tempo di elaborazione + +--- + +# Passo 5 - Risultato Desiderato +## Priorità: Mesh 3D Dettagliata +Parametro principale: +```text +mesh-octree-depth +``` +Valori consigliati: +| Scenario | Valore | +|----------|------:| +| Terreno pianeggiante | 6–8 | +| Uso generale | 11 | +| Architettura complessa | 12 | + +Se aumenti questo valore, aumenta anche: +```text +mesh-size +``` +per evitare una semplificazione eccessiva della mesh. +--- + +## Priorità: Modello Digitale del Terreno (DTM) + +Abilita: +```text +dtm: true +``` +Regola questi parametri: +| Parametro | Raccomandazione | +|-----------|----------------| +| `smrf-slope` | 0.1 per terreno pianeggiante, fino a 1.2 per terreno montuoso | +| `smrf-threshold` | Altezza minima degli oggetti da rimuovere | + +--- + +## Priorità: Elaborazione Veloce +Abilita: +```text +fast-orthophoto: true +``` + +### Effetto + +Salta la ricostruzione densa MVS e genera l'ortofoto direttamente dalla nuvola di punti sparsa. + +--- + +## Priorità: Elaborazione Molto Veloce + +Quando l'obiettivo principale è ottenere un risultato il più rapidamente possibile (per esempio durante interventi di emergenza, valutazioni rapide, verifiche sul campo o analisi preliminari), applica le seguenti ottimizzazioni. + +### Raccomandazioni per la pianificazione del volo + +L'elaborazione più veloce inizia con una strategia di acquisizione ottimizzata: + +- Esegui un **volo nadirale planare** quando possibile. +- Mantieni un'altitudine costante rispetto al terreno. +- Usa una spaziatura regolare delle immagini e una sovrapposizione uniforme. +- Evita immagini oblique non necessarie se un'ortofoto 2D è l'obiettivo primario. +- Evita di acquisire ampie aree al di fuori dei confini del rilievo. +- Usa una traiettoria di volo più lenta e stabile quando utilizzi fotocamere con rolling shutter. + +--- + +### Impostazioni WebODM consigliate + +#### Usa la generazione rapida dell'ortofoto + +```text +fast-orthophoto: true +``` + +Genera l'ortofoto senza eseguire la fase completa di ricostruzione densa. + +--- + +#### Riduci la risoluzione delle immagini durante l'elaborazione + +```text +resize-to: 2048 +``` + +o un valore inferiore a seconda della qualità richiesta per il risultato. + +Benefici: + +- tempo di elaborazione significativamente ridotto; +- minore consumo di RAM; +- feature matching più veloce. + +--- + +#### Disabilita i prodotti non necessari + +Genera solo i prodotti necessari per il compito. + +Evita di produrre: +- nuvola di punti densa (il più importante!) +```text +fast-orthophoto: true +``` + +- mesh 3D texturizzata; +```text +skip-3dmodel: true +``` +- (se non necessari) prodotti DEM. +```text +dsm: false +dtm: false +``` + +- report +```text +skip-report:true +``` + + +Esempio: + +- Mappatura di emergenza → Solo ortofoto +- Ispezione preliminare → Ortofoto + DSM a bassa risoluzione +- Rilievo finale → Flusso di elaborazione completo + +--- + +#### Riduci la densità della nuvola di punti +(solo se hai bisogno della nuvola di punti) +Usa: + +```text +pc-quality: low +``` + +oppure + +```text +pc-quality: medium +``` + +quando non è richiesto un modello 3D dettagliato. + +Benefici: + +- ricostruzione più veloce; +- minore utilizzo del disco. + +--- + +#### Limita la generazione della mesh + +Se una mesh non è necessaria: + +```text +mesh: false +``` + +Evitare la generazione della mesh può far risparmiare una quantità significativa di tempo di elaborazione. + +--- + +### Ulteriori raccomandazioni operative + +Per la massima velocità: + +1. Carica solo le immagini necessarie. +2. Rimuovi le immagini sfocate o duplicate prima dell'elaborazione. +3. Evita immagini con grandi porzioni di cielo o sfondo irrilevante. +4. Usa un flusso di lavoro basato su aree invece di elaborare dataset molto grandi in una volta sola. +5. Suddividi i rilievi molto grandi in blocchi indipendenti più piccoli quando possibile. +6. Usa hardware di elaborazione locale con accelerazione GPU quando disponibile. + +--- +# Passo 6 - Software di Destinazione + +## QGIS + +Abilita: + +```text +build-overviews: true +``` + +### Nota + +Le versioni recenti di ODX generano già Cloud Optimized GeoTIFF (COG) se usi l'opzione `--cog`, che includono già gli overview interni. + +--- + +## Blender + +Abilita: + +```text +texturing-single-material: true +gltf: true +``` + +### Benefici + +- Importazione più semplice +- Materiale con texture singola +- Formato 3D compresso moderno + +--- + +## Cesium o Visualizzazione Web + +Abilita: + +```text +3d-tiles: true +``` + +Questo genera 3D Tiles ottimizzati adatti allo streaming web. + +--- + +# Passo 7 - Verifica dell'Accuratezza + +## Sono disponibili Punti di Controllo a Terra (GCP)? + +Per ottenere una valutazione indipendente dell'accuratezza: + +1. Seleziona alcuni punti di controllo come checkpoint. +2. Aggiungi ai loro nomi il prefisso: + +```text +CHK- +``` + +Le osservazioni dei checkpoint: + +- non influenzano il bundle adjustment; +- sono utilizzate esclusivamente per calcolare statistiche indipendenti di accuratezza nel **Quality Report**. + + + +--- + +# Riferimento Rapido + +| Situazione | Parametro Consigliato | +|------------|----------------------| +| Drone consumer | `rolling-shutter: true` | +| Drone RTK | `gps-accuracy` | +| RTK + GCP | `force-gps: true` | +| Le immagini includono il cielo | `sky-removal: true` | +| Vegetazione densa | `min-num-features: 20000` | +| Bordi degli edifici migliori | `pc-quality: high` | +| GSD molto basso | `ignore-gsd: true` | +| Generare il DTM | `dtm: true` | +| Ortofoto veloce | `fast-orthophoto: true` | +| Esportazione per Blender | `gltf: true` | +| Esportazione per Cesium | `3d-tiles: true` | +| Validazione dell'accuratezza | Checkpoint `CHK-` | diff --git a/src/content/docs/it/tutorials/potree-3d-viewer.md b/src/content/docs/it/tutorials/potree-3d-viewer.md new file mode 100644 index 0000000..7293e11 --- /dev/null +++ b/src/content/docs/it/tutorials/potree-3d-viewer.md @@ -0,0 +1,146 @@ +--- +title: Uso del Visualizzatore 3D +template: doc +--- + +### Fotocamere + +Attiva questa funzione per visualizzare le posizioni delle fotocamere. + +Puoi anche fare clic sull'icona della fotocamera per visualizzare le singole immagini in un riquadro nell'angolo in alto a destra. Un clic sul riquadro dell'immagine attiva la modalità a schermo intero. + +All'interno del riquadro dell'immagine ci sono collegamenti per scaricare l'immagine e il file GeoJSON delle fotocamere. + +![Posizioni delle fotocamere](/images/cameras.webp) + +### Modello Texturizzato + +Attiva questa funzione per caricare e mostrare il modello texturizzato. A seconda della dimensione del file e della velocità di connessione, il caricamento può richiedere diversi secondi. + +![Modello texturizzato](/images/texturedmodel.webp) + +### Aspetto + +#### Budget di Punti + +Sia per motivi di aspetto che di prestazioni, è possibile gestire il budget di punti della scena. Alcuni sistemi datati e meno potenti trarrebbero beneficio da un budget di 500.000 punti, mentre la maggior parte dei sistemi di fascia media è in grado di gestire un budget da 1 a 2 milioni di punti. + +Un budget da 5 a 7 milioni di punti produce un modello 3D della nuvola di punti uniforme, ma può risultare in un processo molto esigente in termini di risorse. + +Il valore predefinito del budget di punti è impostato a 1.000.000. + +#### Campo Visivo + +Per controllare gli elementi del modello da includere nella scena, è possibile regolare il campo visivo. Il valore predefinito è impostato a 60 gradi. + +![Regolazione del campo visivo](/images/FOV_animation.webp) + +#### Eye Dome-lighting + +Il modulo visualizzatore 3D di nuvole di punti Potree può implementare l'eye dome-lighting, un modello di illuminazione che accentua le forme degli oggetti. + +L'eye dome-lighting raggruppa gli oggetti, ne ombreggia i contorni e migliora la percezione della profondità nelle immagini di visualizzazione scientifica. È utile per il riconoscimento e la misurazione di strutture all'interno di un modello. Può essere modificato regolando Radius, Strength e Opacity. + +Per impostazione predefinita, l'Eye Dome-Lighting è abilitato nel visualizzatore 3D Potree, ma può essere disabilitato facendo clic sull'opzione di abilitazione. + +![Regolazione dell'eye dome lighting](/images/EDL_animation.webp) + +#### Sfondo + +Lo sfondo del visualizzatore 3D Potree può essere modificato. Le opzioni disponibili sono **Skybox** / **Gradient** / **Black** / **White** / **None** + +![Selezione dello sfondo](/images/Background_animation.webp) + +#### Altro + +**Splat Quality** — La qualità degli splat può essere regolata su standard o alta qualità, per migliorare l'aspetto del modello. + +**Min node size** — L'opzione della dimensione minima del nodo influisce sulla densità dei punti dei nodi rappresentati. + +**Box** — Visualizza i riquadri dei nodi. + +**Lock view** — Blocca la vista della nuvola di punti, impedendo il caricamento o lo scaricamento di punti dal modello. + +### Strumenti + +#### Misurazione + +Il modulo visualizzatore 3D Potree fornisce diversi strumenti di misurazione. Questo insieme di strumenti è composto da 12 elementi. Include anche controlli per mostrare o nascondere le etichette delle misurazioni risultanti. + +Le misurazioni vengono eseguite facendo clic con il tasto sinistro sui punti desiderati e, per alcuni strumenti, è necessario fare clic con il tasto destro per terminare il processo. + +![Strumenti di misurazione](/images/measurement.webp) + +**Angolo** — Questo strumento misura l'angolo tridimensionale formato dalle linee che collegano 3 punti. Per avviare una misurazione, fai clic sull'icona dell'angolo, poi fai clic con il tasto sinistro su 3 punti e il processo terminerà automaticamente. Ulteriori informazioni possono essere ottenute selezionando questo elemento nella sezione della scena. + +**Punto** — Questo strumento evidenzia un punto selezionato e ne visualizza le coordinate XYZ. Per avviare una misurazione, fai clic sull'icona del punto, poi fai clic sul punto desiderato e il processo terminerà automaticamente. Ulteriori informazioni possono essere ottenute selezionando questo elemento nella sezione della scena. + +**Distanza** — Questo strumento misura la distanza tridimensionale delle linee che collegano una serie di punti. Per avviare una misurazione, fai clic sull'icona della distanza e inizia a fare clic sui punti desiderati (due o più). Fai clic con il tasto destro per terminare la misurazione. Ulteriori informazioni, come la lunghezza totale, possono essere ottenute selezionando questo elemento nella sezione della scena. + +**Altezza** — Questo strumento misura l'altezza o la distanza verticale tra due punti. Per avviare una misurazione, fai clic sull'icona dell'altezza e poi fai clic sui due punti desiderati. Il processo terminerà automaticamente. Ulteriori informazioni possono essere ottenute selezionando questo elemento nella sezione della scena. + +![Misurazione dell'altezza](/images/height_animation.webp) + +**Cerchio** — Questo strumento misura il raggio di un cerchio formato da tre punti. Per avviare una misurazione, fai clic sull'icona del cerchio e poi fai clic sui due punti desiderati. Il processo terminerà automaticamente. Ulteriori informazioni, come la circonferenza, possono essere ottenute selezionando questo elemento nella sezione della scena. + +**Azimut** — Questo strumento misura l'angolo azimutale di una linea. Questa linea è formata da due punti selezionati dall'utente; l'angolo è misurato in gradi, in senso orario da 0 a 360 e partendo dal nord geografico. Per avviare una misurazione, fai clic sull'icona dell'azimut e poi fai clic sui due punti desiderati. Il processo terminerà automaticamente. Ulteriori informazioni possono essere ottenute selezionando questo elemento nella sezione della scena. + +**Area** — Questo strumento misura l'area orizzontale formata da un poligono. Per avviare una misurazione, fai clic sull'icona dell'area e inizia a fare clic sui punti che formano il poligono desiderato (tre o più). Fai clic con il tasto destro per terminare la misurazione. Ulteriori informazioni possono essere ottenute selezionando questo elemento nella sezione della scena. + +**Volume (cubo)** — Questo strumento misura il volume formato da un cubo. Per avviare una misurazione, fai clic sull'icona del volume (cubo) e fai clic sul modello per posizionare il cubo. È possibile riposizionare, ridimensionare e ruotare il cubo utilizzando le maniglie visualizzate. Fai clic con il tasto destro per terminare la misurazione. Ulteriori informazioni possono essere ottenute selezionando questo elemento nella sezione della scena. + +**Volume (sfera)** — Questo strumento misura il volume formato da una sfera. Per avviare una misurazione, fai clic sull'icona del volume (sfera) e fai clic sul modello per posizionare la sfera. È possibile riposizionare, ridimensionare e ruotare la sfera utilizzando le maniglie visualizzate. Fai clic con il tasto destro per terminare la misurazione. Ulteriori informazioni possono essere ottenute selezionando questo elemento nella sezione della scena. + +**Profilo altimetrico** — Questo strumento crea un profilo altimetrico formato da una linea sul modello. Per avviare una misurazione, fai clic sull'icona del profilo altimetrico e poi forma una linea sul modello facendo clic sui punti desiderati (due o più). Fai clic con il tasto destro per terminare la misurazione. Ulteriori informazioni e opzioni, come "Show 2d Profile", possono essere ottenute selezionando questo elemento nella sezione della scena. + +![Profilo altimetrico](/images/height_profile.webp) + +**Annotazione** — Questo strumento crea un'etichetta di annotazione su un punto evidenziato del modello. Per avviare una misurazione, fai clic sull'icona dell'annotazione e poi fai clic sul punto desiderato. Il processo terminerà automaticamente. Per modificare l'annotazione, seleziona questo elemento nella sezione della scena, poi modifica Titolo e Descrizione. + +**Rimuovi misurazioni** — Questo strumento rimuove tutte le misurazioni sul modello. Per rimuovere tutte le misurazioni, fai clic sull'icona "Remove measurements". + +#### Ritaglio + +![Strumenti di ritaglio](/images/clipping.webp) + +La nuvola di punti può essere ritagliata selezionando un'area. Le opzioni di ritaglio includono **None** / **Highlight** / **Inside** / **Outside** + +Per ritagliare una nuvola di punti, fai clic sull'icona del volume di ritaglio, posiziona il cubo sul modello e riposizionalo, ridimensionalo e ruotalo per contenere l'area desiderata. Highlight è impostato come metodo di ritaglio predefinito. Se vuoi visualizzare solo i punti contenuti all'interno del cubo, fai clic su "Inside", altrimenti fai clic su "Outside". + +Per rimuovere il volume di ritaglio o i poligoni, fai clic sull'icona "Remove all measurements". + +![Ritaglio](/images/clipping_animation.webp) + +#### Navigazione + +![Controlli di navigazione](/images/navigation.webp) + +Il visualizzatore 3D Potree ha 4 controlli di navigazione che ne definiscono il comportamento. + +**Earth Control** — Earth control naviga come ancorato al terreno. Il tasto sinistro del mouse sposta il modello orizzontalmente, la rotellina del mouse controlla lo zoom e il tasto destro orbita attorno al modello. + +**Fly control** — Fly control muove la fotocamera come in volo d'uccello utilizzando la tastiera. I tasti "W" e "S" muovono rispettivamente avanti e indietro nella direzione della fotocamera, mentre "A" e "D" muovono rispettivamente a sinistra e a destra. Inoltre, i tasti "R" e "F" muovono la fotocamera su e giù. Il tasto sinistro del mouse cambia la direzione della fotocamera, la rotellina del mouse controlla lo zoom e il tasto destro muove la fotocamera sugli assi XYZ. La velocità di questi movimenti può essere controllata utilizzando il cursore a scorrimento. + +**Helicopter control** — Helicopter control muove la fotocamera come in un aeromobile utilizzando la tastiera. I tasti "W" e "S" muovono rispettivamente avanti e indietro, vincolati a un piano orizzontale, mentre "A" e "D" muovono rispettivamente a sinistra e a destra. Inoltre, i tasti "R" e "F" muovono la fotocamera su e giù. Il tasto sinistro del mouse cambia la direzione della fotocamera, la rotellina del mouse controlla lo zoom e il tasto destro muove il modello sugli assi XY. La velocità di questi movimenti può essere controllata utilizzando il cursore a scorrimento. + +**Orbit Control** — Orbit Control è il comportamento di navigazione predefinito. Il tasto sinistro del mouse orbita attorno al modello, la rotellina controlla lo zoom e il tasto destro muove il modello sugli assi XYZ. + +**Full extent** — Il pulsante full extent ripristina la vista del modello. + +**Navigation cube** — Il navigation cube visualizza un cubo in wireframe che contiene il modello. + +**Compass** — Il pulsante della bussola visualizza una bussola nell'angolo in alto a destra. + +**Camera animation** — Il pulsante dell'animazione della fotocamera crea un percorso di animazione della fotocamera. La posizione della fotocamera è definita dai punti sulla linea verde, mentre i punti sulla linea blu sono le posizioni verso cui la fotocamera è destinata a rivolgersi. Per creare un'animazione, regola i punti per le posizioni della fotocamera e la direzione della fotocamera, poi seleziona l'elemento della fotocamera nella sezione Scena per creare altri punti, cambiare la velocità dell'animazione o riprodurre l'animazione. + +![Animazione della fotocamera](/images/camera_animation.webp) + +### Scena + +La sezione Scena visualizza un albero di file contenente tutti gli elementi della scena. Gli elementi sono organizzati in sei gruppi, che sono **Point clouds** / **Measurements** / **Annotations** / **Other** / **Vector** / **Images** + +Ogni elemento all'interno di questi gruppi può essere selezionato per ottenere ulteriori informazioni o per controllarne le proprietà. + +Per esempio, le proprietà delle nuvole di punti possono essere modificate per mostrare l'elevazione e anche la rampa di colori può essere personalizzata. + +![Elevazione della nuvola di punti](/images/pointcloud_elevation.webp) diff --git a/src/content/docs/it/tutorials/using-docker.md b/src/content/docs/it/tutorials/using-docker.md new file mode 100644 index 0000000..6b72736 --- /dev/null +++ b/src/content/docs/it/tutorials/using-docker.md @@ -0,0 +1,83 @@ +--- +title: Uso di Docker +template: doc +--- + +Poiché molti utenti utilizzano docker per installare WebODM, può essere utile comprendere alcuni comandi di base per interrogare le istanze docker quando qualcosa va storto, o quando siamo curiosi di sapere cosa sta succedendo. Docker è un ambiente containerizzato pensato, tra le altre cose, per semplificare l'installazione del software indipendentemente dall'ambiente locale. In questo senso, è simile alle macchine virtuali. + +### Elencare i Container Docker + +Possiamo iniziare elencando i container docker disponibili sul computer su cui stiamo lavorando, come segue: + +``` +> docker ps +CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES +2518817537ce webodm/odx "bash" 36 hours ago Up 36 hours zen_wright +1cdc7fadf688 webodm/nodeodx "/usr/bin/nodejs /va…" 37 hours ago Up 37 hours 0.0.0.0:3000->3000/tcp flamboyant_dhawan +``` + +Se vogliamo vedere i container che potrebbero non essere in esecuzione ma esistono ancora, possiamo aggiungere il flag `-a`: + +``` +> docker ps -a +CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES +2518817537ce webodm/odx "bash" 36 hours ago Up 36 hours zen_wright +1cdc7fadf688 webodm/nodeodx "/usr/bin/nodejs /va…" 37 hours ago Up 37 hours 0.0.0.0:3000->3000/tcp flamboyant_dhawan +cd7b9585b8f6 webodm/odx "bash" 3 days ago Exited (1) 37 hours ago nostalgic_lederberg +e31010c00b9a webodm/odx "python /code/run.py…" 3 days ago Exited (2) 3 days ago suspicious_kepler +c44e0d0b8448 webodm/nodeodx "/usr/bin/nodejs /va…" 3 days ago Exited (0) 37 hours ago wonderful_burnell +``` + +### Accedere ai Log dell'Istanza + +Utilizzando il `CONTAINER ID` oppure il nome, possiamo accedere a tutti i log disponibili sull'istanza come segue: + +```bash +docker logs 2518817537ce +``` + +È probabile che l'output sia scomodamente lungo, ma possiamo usare il carattere pipe `|` e altri strumenti per estrarre dai log solo ciò che ci serve. Ad esempio, possiamo scorrere il log lentamente usando il comando `more`: + +``` +> docker logs 2518817537ce | more +[INFO] DTM is turned on, automatically turning on point cloud classification +[INFO] Initializing ODX app - Mon Sep 23 01:30:33 2019 +[INFO] ============== +[INFO] build_overviews: False +[INFO] camera_lens: auto +[INFO] crop: 3 +[INFO] debug: False +[INFO] dem_decimation: 1 +[INFO] dem_euclidean_map: False +... +``` + +Premendo `Invio` o `Spazio`, i tasti freccia oppure i tasti `Pag Su` o `Pag Giù`, potremo navigare nei log. La lettera minuscola `Q` ci permetterà di tornare alla riga di comando. + +Possiamo anche estrarre solo la parte finale dei log usando il comando `tail` come segue: + +``` +> docker logs 2518817537ce | tail -5 +[INFO] Cropping /datasets/code/odm_orthophoto/odm_orthophoto.tif +[INFO] running gdalwarp -cutline /datasets/code/odm_georeferencing/odm_georeferenced_model.bounds.gpkg ... +Using band 4 of source image as alpha. +Creating output file that is 111567P x 137473L. +Processing input file /datasets/code/odm_orthophoto/odm_orthophoto.original.tif. +``` + +Il valore `-5` indica al comando tail di restituirci solo le ultime 5 righe dei log. + +### Accesso da Riga di Comando alle Istanze + +A volte è necessario approfondire ulteriormente l'esplorazione del processo di OpenDroneMap. A questo scopo possiamo ottenere accesso diretto da riga di comando alle istanze usando `docker exec`: + +```bash +> docker exec -ti 2518817537ce bash +root@2518817537ce:/code# +``` + +Ora abbiamo effettuato l'accesso alla nostra istanza docker e possiamo esplorare il sistema. + +### Pulizia Dopo l'Uso di Docker + +Docker fa un uso deplorevole dello spazio su disco e, per impostazione predefinita, non ripulisce i dati e le istanze in eccesso al termine dei processi. Questo può essere vantaggioso se abbiamo bisogno di accedere a un processo ormai terminato, ma comporta l'onere di utilizzare quantità crescenti di spazio di archiviazione nel tempo. Maciej Łebkowski offre un'[eccellente panoramica su come gestire l'utilizzo eccessivo del disco in docker](https://lebkowski.name/docker-volumes/). diff --git a/src/content/docs/it/tutorials/using-image-masks.md b/src/content/docs/it/tutorials/using-image-masks.md new file mode 100644 index 0000000..bc24b37 --- /dev/null +++ b/src/content/docs/it/tutorials/using-image-masks.md @@ -0,0 +1,20 @@ +--- +title: Uso di Maschere di Immagine +template: doc +--- + +È possibile fornire maschere di immagine per indicare al software di saltare la ricostruzione in determinate aree. Questo è utile nei casi in cui il cielo sia stato accidentalmente incluso nelle foto di input da scatti obliqui, o semplicemente per limitare la ricostruzione a un singolo soggetto. + +Per aggiungere una maschera, è sufficiente creare una nuova immagine in bianco e nero delle stesse dimensioni dell'immagine di destinazione che si desidera mascherare (è possibile utilizzare un programma come GIMP per farlo). Colorare in nero le aree da escludere dalla ricostruzione. + +![Immagine di destinazione](/images/target_image.webp) + +![Maschera di immagine](/images/target_image_mask.webp) + +![Risultato 3D con maschera applicata](/images/3D_result.webp) + +Nominare il file: + +`_mask.JPG` + +Ad esempio, `DJI_0018.JPG` può avere una maschera creando un file `DJI_0018_mask.JPG` e includendolo nell'elenco delle immagini. Per le maschere di immagine è possibile utilizzare i formati `.JPG`, `.PNG`, `.BMP` e `.TIF`. diff --git a/src/content/docs/it/tutorials/using-podman.md b/src/content/docs/it/tutorials/using-podman.md new file mode 100644 index 0000000..658b77a --- /dev/null +++ b/src/content/docs/it/tutorials/using-podman.md @@ -0,0 +1,75 @@ +--- +title: Uso di Podman +template: doc +--- + +In alternativa a Docker, è possibile scegliere di eseguire WebODM utilizzando [Podman](https://podman.io). Per farlo, è sufficiente installare il pacchetto podman della propria distribuzione, oltre al suo livello di compatibilità con docker. Ad esempio, su Alpine Linux: + +```bash +apk add podman podman-docker +``` + +La riga di comando di Podman è molto simile a quella di Docker, quindi fare riferimento alla sezione precedente e sostituire ogni invocazione del comando `docker` con `podman` è probabilmente sufficiente per apprenderne l'uso di base. + +### Migrazione da Docker a Podman + +Purtroppo, dato il numero di opzioni che `webodm.sh` offre per l'installazione, la migrazione tra le due piattaforme può richiedere del lavoro manuale prima del passaggio. Se le informazioni di WebODM erano memorizzate in directory tramite i flag `--media-dir` e `--db-dir`, allora i dati al loro interno devono essere di proprietà dell'utente che esegue i container Podman. Se si esegue in modalità rootless, assicurarsi di impostarlo sul proprio utente corrente. Se `media-dir` e `db-dir` si trovano all'interno del repository git, è possibile eseguire in sicurezza un chown ricorsivo dell'intero repository in questo modo: + +```bash +sudo chown -R $(whoami) WebODM +``` + +Se `webodm.sh` è stato usato senza flag, è necessario un intervento diverso per migrare i dati. + +```bash +docker volume export webodm-dbdata > webodm-dbdata.tar +docker volume export webodm-appmedia > webodm-appmedia.tar +``` + +Indipendentemente dalla posizione dei dati, sarà ora necessario disinstallare completamente Docker dal sistema secondo la documentazione del proprio sistema operativo. Si noti che, per impostazione predefinita, lo script `webodm.sh` potrebbe essersi preso la libertà di installare docker-compose. Per ripulirlo, eseguire quanto segue: + +```bash +rm ~/.docker/cni-plugins-docker-compose +``` + +Ora installare Podman secondo la documentazione del proprio sistema operativo. Se in precedenza è stato necessario esportare le directory media e db da Docker, è ora possibile utilizzare Podman per importare i volumi. + +```bash +podman volume import webodm-dbdata webodm-dbdata.tar +podman volume import webodm-appmedia webodm-appmedia.tar +``` + +A questo punto si consiglia di disconnettersi e riconnettersi al sistema per assicurarsi che tutte le variabili d'ambiente siano caricate correttamente. + +Eseguendo ora `webodm.sh`, i dati utente dovrebbero risultare persistenti attraverso il passaggio. + +### Per Versioni di podman-compose < 1.5.0 + +Le versioni di podman-compose precedenti alla 1.5.0 non supportano le variabili d'ambiente nei file docker-compose. Se la propria distribuzione non fornisce una versione aggiornata nei suoi repository, è possibile scegliere di fornire un proprio binario aggiornato oppure di utilizzare [Docker Compose](https://docs.docker.com/compose/install/linux/#install-the-plugin-manually) con podman stesso. In entrambi i casi, sarà necessario aggiornare la riga compose_providers del file `/etc/containers/containers.conf`. + +Se si sceglie di utilizzare Docker Compose al posto di podman-compose, potrebbe essere necessario configurare alcune variabili d'ambiente aggiuntive per indicare a WebODM dove inviare le proprie richieste API Docker. La seguente configurazione dell'ambiente ha permesso a WebODM di avviarsi correttamente su Alpine Linux 3.22, sebbene dovrebbe funzionare in modo abbastanza indipendente dalla distribuzione. + +```bash +export WEBODM_PODMAN_SOCKET=$(podman info --format '{{.Host.RemoteSocket.Path}}') +mkdir -p $(dirname WEBODM_PODMAN_SOCKET) +export DOCKER_HOST=unix://$WEBODM_PODMAN_SOCKET +``` + +Infine, avviare WebODM in questo modo: + +```bash +podman system service --time=0 unix://$WEBODM_PODMAN_SOCKET & ./webodm.sh start +``` + +### Configurare Podman per l'Esecuzione Rootless + +Uno dei principali vantaggi dell'uso di Podman rispetto a Docker risiede nella sua capacità di essere eseguito in modalità rootless. Il proprio sistema operativo potrebbe configurare o meno questa modalità automaticamente, ma istruzioni generiche su come farlo si trovano [nella documentazione ufficiale di Podman](https://docs.podman.io/en/latest/markdown/podman.1.html#rootless-mode). In sintesi, eseguire i seguenti comandi è probabilmente ciò che sarà necessario fare: + +```bash +sudo usermod --add-subuids 10000-75535 $(whoami) +sudo usermod --add-subgids 10000-75535 $(whoami) +``` + +### macOS + +In teoria, [installare](https://podman-desktop.io/docs/installation/macos-install) ed eseguire Podman Desktop dal sito ufficiale dovrebbe essere tutto ciò che serve per usare lo script `webodm.sh`. Installarlo e configurarlo sia per la [compatibilità con Docker](https://podman-desktop.io/docs/migrating-from-docker/customizing-docker-compatibility#enable-docker-compatibility) sia per la [funzionalità Compose](https://podman-desktop.io/docs/compose/setting-up-compose). diff --git a/src/content/docs/it/tutorials/using-singularity.md b/src/content/docs/it/tutorials/using-singularity.md new file mode 100644 index 0000000..4ed1139 --- /dev/null +++ b/src/content/docs/it/tutorials/using-singularity.md @@ -0,0 +1,104 @@ +--- +title: Uso di Singularity +template: doc +--- + +[Singularity](https://sylabs.io/) è un'altra piattaforma di container in grado di eseguire immagini Docker. Singularity può essere eseguito sia su computer locali sia in contesti in cui l'utente non dispone di accesso root. Tra i contesti in cui un utente potrebbe non avere privilegi di root vi sono i cluster HPC e le risorse di cluster in cloud. Un container è un singolo file, senza nient'altro da installare. + +### Creare un'Immagine Singularity da un'Immagine Docker + +Singularity può utilizzare un'immagine Docker per creare un'immagine SIF. + +Per l'immagine Docker ODX più recente (consigliato): + +```bash +singularity build --disable-cache -f odx_latest.sif docker://webodm/odx:latest +``` + +### Usare l'Immagine SIF di Singularity + +Una volta utilizzato uno dei comandi sopra riportati per scaricare e creare l'immagine `odx_latest.sif`, questa può essere eseguita con singularity. Posizionare le proprie immagini in una directory denominata "images" (ad esempio `/my/project/images`), quindi eseguire semplicemente: + +```bash +singularity run --bind /my/project:/datasets/code odx_latest.sif --project-path /datasets +``` + +Come con docker, è possibile aggiungere opzioni e flag aggiuntivi al comando: + +```bash +singularity run --bind /my/project:/datasets/code \ + --writable-tmpfs odx_latest.sif \ + --orthophoto-png --mesh-octree-depth 12 --dtm \ + --smrf-threshold 0.4 --smrf-window 24 --dsm --pc-csv --pc-las --orthophoto-kmz \ + --matcher-type flann --feature-quality ultra --max-concurrency 16 \ + --use-hybrid-bundle-adjustment --build-overviews --time --min-num-features 10000 \ + --project-path /datasets +``` + +### ClusterODX, NodeODX, SLURM, con Singularity su HPC + +Se si lavora su HPC, è possibile scrivere uno script SLURM per pianificare e configurare i nodi disponibili con NodeODX a cui collegare ClusterODX. L'uso di SLURM ridurrà il tempo e il numero di operazioni necessari per configurare ogni volta i nodi per ClusterODX. + +Per configurare l'HPC con SLURM, è necessario assicurarsi che SLURM sia installato. + +Lo script SLURM sarà diverso da cluster a cluster, a seconda dei nodi presenti nel cluster. Tuttavia, l'idea di fondo è eseguire NodeODX una volta su ciascun nodo e, per impostazione predefinita, ogni NodeODX sarà in esecuzione sulla porta 3000. Successivamente, eseguire ClusterODX sul nodo principale (head node) e collegare i NodeODX in esecuzione a ClusterODX. + +Ecco un esempio di script SLURM che assegna i nodi 48, 50 e 51 all'esecuzione di NodeODX: + +```bash +#!/usr/bin/bash +#SBATCH --partition=8core +#SBATCH --nodelist-node [48,50, 51] +#SBATCH --time 20:00:00 + +cd $HOME +cd ODX/NodeODX/ + +# Avvio sul nodo 48 +srun --nodes-1 apptainer run --writable node/ & + +# Avvio sul nodo 50 +srun --nodes-1 apptainer run --writable node/ & + +# Avvio sul nodo 51 +srun --nodes=1 apptainer run --writable node/ & +wait +``` + +È possibile verificare i nodi disponibili con `sinfo`, eseguire lo script con `sbatch sample.slurm` e controllare i job in esecuzione con `squeue -u $USER`. + +SLURM non gestisce l'assegnazione dei job al nodo principale, quindi eseguire ClusterODX localmente. Connettersi poi alla CLI e collegare i NodeODX a ClusterODX: + +```bash +telnet localhost 8080 +> NODE ADD node48 3000 +> NODE ADD node50 3000 +> NODE ADD node51 3000 +> NODE LIST +``` + +È anche possibile pre-popolare i nodi utilizzando JSON. Se si avvia ClusterODX da apptainer o docker, il file JSON pertinente è disponibile in `docker/data/nodes.json`: + +```json +[ + {"hostname":"node48","port":"3000","token":""}, + {"hostname":"node50","port":"3000","token":""}, + {"hostname":"node51","port":"3000","token":""} +] +``` + +Dopo aver avviato ClusterODX sul nodo principale e averlo collegato ai NodeODX, è possibile creare un tunnel per verificare che ClusterODX funzioni come previsto: + +```bash +ssh -L localhost:10000:localhost:10000 user@hostname +``` + +Aprire un browser e connettersi a `http://localhost:10000` (la porta 10000 è quella su cui è ospitata l'interfaccia web amministrativa di ClusterODX). + +Quindi creare un tunnel sulla porta 3000 per l'assegnazione dei task: + +```bash +ssh -L localhost:3000:localhost:3000 user@hostname +``` + +Connettersi a `http://localhost:3000` per assegnare i task e osservare i processi.