An open source command line toolkit for processing aerial drone imagery
 
 
 
 
 
 
Go to file
Lee Pepper 11237930b8 Docker packages.Dockerfile Updates
Moved to phusion/baseimage
Removed .git folder in docker image
Also removed .git from the COPY in Dockerfile
Dropped Test files and git info from Dockerfile


Former-commit-id: 7f8d206791
2017-03-30 14:58:51 -06:00
SuperBuild Use specific commit zip file for OpenGV 2017-03-02 08:44:03 -05:00
contrib Merge pull request #498 from dakotabenjamin/ndvi-contrib 2017-02-28 01:12:38 -05:00
docker Update README 2016-11-30 08:33:05 -05:00
hooks Add Mvs-Texturing 2016-03-24 13:35:29 -04:00
img Add orthophoto example to README 2016-06-29 20:35:18 +00:00
licenses Added reference to MVS paper. Added MVS license link. 2016-07-18 15:23:34 -07:00
modules Reduced memory fragmentation (#464) 2017-02-21 11:14:16 -05:00
opendm Clean up argument parsing 2017-03-27 15:41:51 -04:00
patched_files/src/graclus Revert "Revert "Upgrade Bundler + add support for Ceres solver"" 2015-08-21 14:13:42 -04:00
scripts Add more gdal creation options 2017-03-10 16:09:55 -05:00
tests Compress test data images 2016-06-29 20:39:48 +00:00
.dockerignore Docker packages.Dockerfile Updates 2017-03-30 14:58:51 -06:00
.gitignore Clean up argument parsing 2017-03-27 15:41:51 -04:00
.gitmodules Remove ceres-solver submodule 2015-09-05 01:09:30 +02:00
CMakeLists.txt Make SLAM build optional 2016-06-16 10:28:12 +02:00
CONTRIBUTING.md remove dev mention from contributing guide 2016-11-30 15:02:02 -05:00
Dockerfile Docker packages.Dockerfile Updates 2017-03-30 14:58:51 -06:00
LICENSE Rename LICENCE to LICENSE 2016-02-19 12:00:59 -05:00
README.md Merge pull request #510 from dakotabenjamin/global-config-file 2017-03-29 13:58:53 -04:00
VERSION Add --version parameter and version tracking 2017-03-10 14:49:36 -05:00
ccd_defs_check.py Add Mvs-Texturing 2016-03-24 13:35:29 -04:00
code_of_conduct.md update to 1.4 2016-07-18 14:58:40 -04:00
configure.sh Add appsettings installation 2017-03-29 13:57:35 -04:00
core2.Dockerfile Added VERSION file to docker build 2017-03-30 18:27:14 +00:00
docker.settings.yaml Clean up argument parsing 2017-03-27 15:41:51 -04:00
packages.Dockerfile Docker packages.Dockerfile Updates 2017-03-30 14:58:51 -06:00
run.py Clean up argument parsing 2017-03-27 15:41:51 -04:00
run.sh Use /bin/bash, remove test output 2016-06-29 20:36:36 +00:00
settings.yaml Clean up argument parsing 2017-03-27 15:41:51 -04:00
toledo_dataset_example_mesh.jpg JPEG compressed example 3D model image. 2016-07-19 17:28:37 -07:00

README.md

OpenDroneMap

What is it?

OpenDroneMap is an open source toolkit for processing aerial drone imagery. Typical drones use simple point-and-shoot cameras, so the images from drones, while from a different perspective, are similar to any pictures taken from point-and-shoot cameras, i.e. non-metric imagery. OpenDroneMap turns those simple images into three dimensional geographic data that can be used in combination with other geographic datasets.

In a word, OpenDroneMap is a toolchain for processing raw civilian UAS imagery to other useful products. What kind of products?

  1. Point Clouds
  2. Digital Surface Models
  3. Textured Digital Surface Models
  4. Orthorectified Imagery
  5. Classified Point Clouds
  6. Digital Elevation Models
  7. etc.

So far, it does Point Clouds, Digital Surface Models, Textured Digital Surface Models, and Orthorectified Imagery. Open Drone Map now includes state-of-the-art 3D reconstruction work by Michael Waechter, Nils Moehrle, and Michael Goesele. See their publication at http://www.gcc.tu-darmstadt.de/media/gcc/papers/Waechter-2014-LTB.pdf.

QUICKSTART

OpenDroneMap can run natively on Ubuntu 14.04 or later, see Build and Run Using Docker for running on Windows / MacOS. A Vagrant VM is also available: https://github.com/OpenDroneMap/odm_vagrant.

Support for Ubuntu 12.04 is currently BROKEN with the addition of OpenSfM and Ceres-Solver. It is likely to remain broken unless a champion is found to fix it.

Download the latest release here

Current version: 0.2 (this software is in beta)

  1. Extract and enter the OpenDroneMap directory
  2. Run bash configure.sh
  3. Copy the default settings file and edit it: cp default.settings.yaml settings.yaml. Set the project-path value to an empty directory (you will place sub-directories containing individual projects inside). You can add many options to this file, see here
  4. Download a sample dataset from here (about 550MB) and extract it as a subdirectory in your project directory.
  5. Run ./run.sh odm_data_aukerman
  6. Enter dataset directory to view results:
  • orthophoto: odm_orthophoto/odm_orthophoto.tif
  • textured mesh model: odm_texturing/odm_textured_model_geo.obj
  • point cloud (georeferenced): odm_georeferencing/odm_georeferenced_model.ply

See here for more detailed installation instructions.

Installation

Extract and enter the downloaded OpenDroneMap directory and compile all of the code by executing a single configuration script:

bash configure.sh

For Ubuntu 15.10 users, this will help you get running:

sudo apt-get install python-xmltodict
sudo ln -s /usr/lib/x86_64-linux-gnu/libproj.so.9 /usr/lib/libproj.so

Environment Variables

There are some environmental variables that need to be set. Open the ~/.bashrc file on your machine and add the following 3 lines at the end. The file can be opened with gedit ~/.bashrc if you are using an Ubuntu desktop environment. Be sure to replace the "/your/path/" with the correct path to the location where you extracted OpenDroneMap:

export PYTHONPATH=$PYTHONPATH:/your/path/OpenDroneMap/SuperBuild/install/lib/python2.7/dist-packages
export PYTHONPATH=$PYTHONPATH:/your/path/OpenDroneMap/SuperBuild/src/opensfm
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/your/path/OpenDroneMap/SuperBuild/install/lib

Note that using run.sh sets these temporarily in the shell.

Run OpenDroneMap

First you need a set of images, taken from a drone or otherwise. Example data can be obtained from https://github.com/OpenDroneMap/odm_data

Next, you need to copy over the settings file default.settings.yaml and edit it. The only setting you must edit is the project-path key. Set this to an empty directory within projects will be saved. There are many options for tuning your project. See the wiki or run python run.py -h

Then run:

python run.py -i /path/to/images project-name

The images will be copied over to the project path so you only need to specify the -i /path/ once. You can also override any variable from settings.yaml here using the command line arguments. If you want to rerun the whole thing, run

python run.py --rerun-all project-name

or

python run.py --rerun-from odm_meshing project-name

The options for rerunning are: 'resize', 'opensfm', 'slam', 'cmvs', 'pmvs', 'odm_meshing', 'mvs_texturing', 'odm_georeferencing', 'odm_orthophoto'

View Results

When the process finishes, the results will be organized as follows:

|-- images/
    |-- img-1234.jpg
    |-- ...
|-- images_resize/
    |-- img-1234.jpg
    |-- ...
|-- opensfm/
    |-- see mapillary/opensfm repository for more info
    |-- depthmaps/
        |-- merged.ply                  # Dense Point cloud (not georeferenced)
|-- odm_meshing/
    |-- odm_mesh.ply                    # A 3D mesh
    |-- odm_meshing_log.txt             # Output of the meshing task. May point out errors.
|-- odm_texturing/
    |-- odm_textured_model.obj          # Textured mesh
    |-- odm_textured_model_geo.obj      # Georeferenced textured mesh
    |-- texture_N.jpg                   # Associated textured images used by the model
|-- odm_georeferencing/
    |-- odm_georeferenced_model.ply     # A georeferenced dense point cloud
    |-- odm_georeferenced_model.ply.laz # LAZ format point cloud
    |-- odm_georeferenced_model.csv     # XYZ format point cloud
    |-- odm_georeferencing_log.txt      # Georeferencing log
    |-- odm_georeferencing_utm_log.txt  # Log for the extract_utm portion
|-- odm_orthophoto/
    |-- odm_orthophoto.png              # Orthophoto image (no coordinates)
    |-- odm_orthophoto.tif              # Orthophoto GeoTiff
    |-- odm_orthophoto_log.txt          # Log file
    |-- gdal_translate_log.txt          # Log for georeferencing the png file

Any file ending in .obj or .ply can be opened and viewed in MeshLab or similar software. That includes opensfm/depthmaps/merged.ply, odm_meshing/odm_mesh.ply, odm_texturing/odm_textured_model[_geo].obj, or odm_georeferencing/odm_georeferenced_model.ply. Below is an example textured mesh:

You can also view the orthophoto GeoTIFF in QGIS or other mapping software:

Build and Run Using Docker

(Instructions below apply to Ubuntu 14.04, but the Docker image workflow has equivalent procedures for Mac OS X and Windows. See docs.docker.com)

OpenDroneMap is Dockerized, meaning you can use containerization to build and run it without tampering with the configuration of libraries and packages already installed on your machine. Docker software is free to install and use in this context. If you don't have it installed, see the Docker Ubuntu installation tutorial and follow the instructions through "Create a Docker group". Once Docker is installed, the fastest way to use OpenDroneMap is to run a pre-built image by typing:

docker run -it --rm -v $(pwd)/images:/code/images -v $(pwd)/odm_orthophoto:/code/odm_orthophoto -v $(pwd)/odm_texturing:/code/odm_texturing opendronemap/opendronemap

If you want to build your own Docker image from sources, type:

docker build -t packages -f packages.Dockerfile .
docker build -t my_odm_image .
docker run -it --rm -v $(pwd)/images:/code/images -v $(pwd)/odm_orthophoto:/code/odm_orthophoto -v $(pwd)/odm_texturing:/code/odm_texturing my_odm_image

Using this method, the containerized ODM will process the images in the OpenDroneMap/images directory and output results to the OpenDroneMap/odm_orthophoto and OpenDroneMap/odm_texturing directories as described in the Viewing Results section. If you want to view other results outside the Docker image simply add which directories you're interested in to the run command in the same pattern established above. For example, if you're interested in the dense cloud results generated by PMVS and in the orthophoto, simply use the following docker run command after building the image:

docker run -it --rm -v $(pwd)/images:/code/images -v $(pwd)/odm_georeferencing:/code/odm_georeferencing -v $(pwd)/odm_orthophoto:/code/odm_orthophoto my_odm_image

If you want to get all intermediate outputs, run the following command:

docker run -it --rm -v $(pwd)/images:/code/images -v $(pwd)/odm_georeferencing:/code/odm_georeferencing -v $(pwd)/odm_meshing:/code/odm_meshing -v $(pwd)/odm_orthophoto:/code/odm_orthophoto -v $(pwd)/odm_texturing:/code/odm_texturing -v $(pwd)/opensfm:/code/opensfm -v $(pwd)/pmvs:/code/pmvs opendronemap/opendronemap

To pass in custom parameters to the run.py script, simply pass it as arguments to the docker run command. For example:

docker run -it --rm -v $(pwd)/images:/code/images v $(pwd)/odm_orthophoto:/code/odm_orthophoto -v $(pwd)/odm_texturing:/code/odm_texturing opendronemap/opendronemap --resize-to 1800 --force-ccd 6.16

If you want to pass in custom parameters using the settings.yaml file, you can pass it as a -v volume binding:

docker run -it --rm -v $(pwd)/images:/code/images v $(pwd)/odm_orthophoto:/code/odm_orthophoto -v $(pwd)/odm_texturing:/code/odm_texturing -v $(pwd)/settings.yaml:/code/settings.yaml opendronemap/opendronemap

User Interface

A web interface and API to OpenDroneMap is currently under active development in the WebODM repository.

Video Support

Currently we have an experimental feature that uses ORB_SLAM to render a textured mesh from video. It is only supported on Ubuntu 14.04 on machines with X11 support. See the wikifor details on installation and use.

Examples

Coming soon...

Documentation:

For documentation, please take a look at our wiki.Check here first if you are having problems. If you still need help, look through the issue queue or create one. There's also a general help chat here.

Developers

Help improve our software!

Join the chat at https://gitter.im/OpenDroneMap/OpenDroneMap

  1. Try to keep commits clean and simple
  2. Submit a pull request with detailed changes and test results