├── .appveyor.yml
├── .dockerignore
├── .gitignore
├── .gitmodules
├── .travis.yml
├── CMakeLists.txt
├── CMakeModules
    ├── CPackSettings.cmake
    ├── FindPQP.cmake
    ├── Findccd.cmake
    └── Findfcl.cmake
├── LICENSE
├── README.md
├── TODO
├── benchmark
    ├── BenchmarkOptions.cpp
    ├── BenchmarkOptions.h
    ├── BenchmarkTypes.cpp
    ├── BenchmarkTypes.h
    ├── CFGBenchmark.cpp
    ├── CFGBenchmark.h
    ├── CMakeLists.txt
    ├── benchmark.cpp
    ├── example.cfg
    └── example_complex.cfg
├── demos
    ├── AnytimePathShorteningDemo.cpp
    ├── AnytimePathShorteningDemo.h
    ├── CMakeLists.txt
    ├── SE2RigidBodyPlanning
    │   ├── DynamicCarPlanning.cpp
    │   ├── DynamicCarPlanning.py
    │   ├── KinematicCarPlanning.cpp
    │   ├── KinematicCarPlanning.py
    │   ├── SE2MultiRigidBodyPlanning.cpp
    │   └── SE2RigidBodyPlanning.cpp
    └── SE3RigidBodyPlanning
    │   ├── BlimpPlanning.cpp
    │   ├── CollisionCheckers.cpp
    │   ├── QuadrotorPlanning.cpp
    │   ├── SE3MultiRigidBodyPlanning.cpp
    │   ├── SE3MultiRigidBodyPlanning.py
    │   ├── SE3RigidBodyPlanning.cpp
    │   ├── SE3RigidBodyPlanning.py
    │   ├── SE3RigidBodyPlanningBenchmark.cpp
    │   └── SE3RigidBodyPlanningWithOptimization.cpp
├── doc
    ├── CMakeLists.txt
    ├── images
    │   ├── gui_bbox.png
    │   ├── gui_define.png
    │   ├── gui_path.png
    │   └── gui_planner.png
    ├── latex
    │   ├── Ch1_Introduction.tex
    │   ├── Ch2_Introduction.tex
    │   ├── Ch3_GetStarted.tex
    │   ├── Ch4_UsingOMPL.tex
    │   ├── Ch5_AdvancedOMPL.tex
    │   ├── Makefile
    │   ├── OMPL_Primer.tex
    │   ├── TitlePage.tex
    │   ├── bib
    │   │   └── Primer.bib
    │   └── images
    │   │   ├── RiceLogo.jpg
    │   │   ├── cubicles_time.png
    │   │   ├── localplanner.png
    │   │   ├── ompl_hierarchy.pdf
    │   │   ├── omplapp_easy.png
    │   │   ├── omplapp_easy_sln.png
    │   │   ├── omplapp_start.png
    │   │   ├── query.png
    │   │   ├── samples.png
    │   │   ├── state.png
    │   │   ├── tree-start.png
    │   │   ├── tree_badgoal.png
    │   │   ├── tree_goal.png
    │   │   └── twistycool_solved.png
    ├── man
    │   ├── ompl_app.1
    │   ├── ompl_benchmark.1
    │   └── ompl_webapp.1
    ├── markdown
    │   ├── demos.md
    │   ├── download.md.in
    │   ├── gui.md
    │   ├── installation.md
    │   ├── license.md
    │   ├── releaseNotes.md
    │   └── webapp.md
    └── releaseChecklist.txt
├── gui
    ├── CMakeLists.txt
    └── ompl_app.py
├── py-bindings
    ├── CMakeLists.txt
    ├── app
    │   └── __init__.py
    ├── generate_bindings.py
    └── headers_app.txt
├── resources
    ├── 2D
    │   ├── Barriers.cfg
    │   ├── Barriers.path
    │   ├── Barriers_easy_env.dae
    │   ├── Barriers_easy_robot.dae
    │   ├── BoundingBox_planar_env.dae
    │   ├── BugTrap_dcar.cfg
    │   ├── BugTrap_planar.cfg
    │   ├── BugTrap_planar.path
    │   ├── BugTrap_planar_env.dae
    │   ├── H_planar_env.dae
    │   ├── Maze_kcar.cfg
    │   ├── Maze_planar.cfg
    │   ├── Maze_planar.path
    │   ├── Maze_planar_env.dae
    │   ├── Passage_planar_env.dae
    │   ├── RandomPolygons_planar.cfg
    │   ├── RandomPolygons_planar.path
    │   ├── RandomPolygons_planar_env.dae
    │   ├── StraightC_planar_robot.dae
    │   ├── UniqueSolutionMaze.cfg
    │   ├── UniqueSolutionMaze.path
    │   ├── UniqueSolutionMaze_env.dae
    │   ├── UniqueSolutionMaze_robot.dae
    │   ├── car1_planar_robot.dae
    │   ├── car2_planar_robot.dae
    │   └── hook_planar_robot.dae
    ├── 3D
    │   ├── Abstract.cfg
    │   ├── Abstract_env.dae
    │   ├── Abstract_robot.dae
    │   ├── Apartment.cfg
    │   ├── Apartment.path
    │   ├── Apartment.skp
    │   ├── Apartment_env.dae
    │   ├── Apartment_hard.cfg
    │   ├── Apartment_robot.dae
    │   ├── Easy.cfg
    │   ├── Easy.path
    │   ├── Easy.skp
    │   ├── Easy_env.dae
    │   ├── Easy_robot.dae
    │   ├── Home.cfg
    │   ├── Home_env.dae
    │   ├── Home_robot.dae
    │   ├── Twistycool.cfg
    │   ├── Twistycool.path
    │   ├── Twistycool.skp
    │   ├── Twistycool_env.dae
    │   ├── Twistycool_robot.dae
    │   ├── Twistycooler.cfg
    │   ├── Twistycooler.path
    │   ├── Twistycooler_env.dae
    │   ├── Twistycooler_robot.dae
    │   ├── alpha-1.0.cfg
    │   ├── alpha-1.1.cfg
    │   ├── alpha-1.1.path
    │   ├── alpha-1.2.cfg
    │   ├── alpha-1.2.path
    │   ├── alpha-1.5.cfg
    │   ├── alpha-1.5.path
    │   ├── alpha_env-1.0.dae
    │   ├── alpha_env-1.1.dae
    │   ├── alpha_env-1.2.dae
    │   ├── alpha_env-1.5.dae
    │   ├── alpha_robot.dae
    │   ├── blimp.dae
    │   ├── blimp.skp
    │   ├── bugtrap.cfg
    │   ├── bugtrap.skp
    │   ├── bugtrap_env.dae
    │   ├── bugtrap_robot.dae
    │   ├── cubicles.cfg
    │   ├── cubicles.path
    │   ├── cubicles.skp
    │   ├── cubicles_env.dae
    │   ├── cubicles_opt.cfg
    │   ├── cubicles_robot.dae
    │   ├── escape.cfg
    │   ├── escape.path
    │   ├── escape.skp
    │   ├── escape_env.dae
    │   ├── escape_kladhangare_env.dae
    │   ├── escape_robot.dae
    │   ├── pipedream.cfg
    │   ├── pipedream.path
    │   ├── pipedream_env.dae
    │   ├── pipedream_ring.cfg
    │   ├── pipedream_ring.path
    │   ├── quadrotor.dae
    │   ├── quadrotor.skp
    │   ├── ring.dae
    │   ├── spirelli.cfg
    │   ├── spirelli.path
    │   ├── spirelli_env.dae
    │   └── spirelli_robot.dae
    ├── README.md
    └── textures
    │   ├── checkered.ppm
    │   ├── ground.ppm
    │   ├── sky.ppm
    │   └── wood.ppm
├── src
    ├── CMakeLists.txt
    └── omplapp
    │   ├── CMakeLists.txt
    │   ├── apps
    │       ├── AppBase.h
    │       ├── BlimpPlanning.cpp
    │       ├── BlimpPlanning.h
    │       ├── DynamicCarPlanning.cpp
    │       ├── DynamicCarPlanning.h
    │       ├── KinematicCarPlanning.cpp
    │       ├── KinematicCarPlanning.h
    │       ├── QuadrotorPlanning.cpp
    │       ├── QuadrotorPlanning.h
    │       ├── SE2MultiRigidBodyPlanning.cpp
    │       ├── SE2MultiRigidBodyPlanning.h
    │       ├── SE2RigidBodyPlanning.cpp
    │       ├── SE2RigidBodyPlanning.h
    │       ├── SE3MultiRigidBodyPlanning.cpp
    │       ├── SE3MultiRigidBodyPlanning.h
    │       ├── SE3RigidBodyPlanning.cpp
    │       ├── SE3RigidBodyPlanning.h
    │       ├── detail
    │       │   ├── appUtil.cpp
    │       │   └── appUtil.h
    │       └── graphical
    │       │   ├── GBlimpPlanning.h
    │       │   ├── GDynamicCarPlanning.h
    │       │   ├── GKinematicCarPlanning.h
    │       │   ├── GQuadrotorPlanning.h
    │       │   ├── GSE2RigidBodyPlanning.h
    │       │   └── GSE3RigidBodyPlanning.h
    │   ├── config.h.in
    │   ├── geometry
    │       ├── GeometrySpecification.h
    │       ├── RigidBodyGeometry.cpp
    │       ├── RigidBodyGeometry.h
    │       └── detail
    │       │   ├── FCLContinuousMotionValidator.h
    │       │   ├── FCLMethodWrapper.h
    │       │   ├── FCLStateValidityChecker.h
    │       │   ├── PQPStateValidityChecker.h
    │       │   ├── assimpUtil.cpp
    │       │   └── assimpUtil.h
    │   └── graphics
    │       ├── RenderGeometry.cpp
    │       ├── RenderGeometry.h
    │       └── detail
    │           ├── RenderPlannerData.cpp
    │           ├── RenderPlannerData.h
    │           ├── assimpGUtil.cpp
    │           └── assimpGUtil.h
└── webapp
    ├── ompl_webapp
    ├── omplweb.py
    ├── static
        ├── fonts
        │   ├── glyphicons-halflings-regular.eot
        │   ├── glyphicons-halflings-regular.svg
        │   ├── glyphicons-halflings-regular.ttf
        │   ├── glyphicons-halflings-regular.woff
        │   └── glyphicons-halflings-regular.woff2
        ├── problem_files
        │   ├── 2D
        │   └── 3D
        ├── scripts
        │   ├── benchmarking.js
        │   ├── configuration.js
        │   ├── helpers.js
        │   ├── libs
        │   │   ├── ColladaLoader.js
        │   │   ├── TrackballControls.js
        │   │   ├── bootstrap.min.js
        │   │   ├── jquery-2.1.4.min.js
        │   │   ├── jquery.blockUI.js
        │   │   ├── mousetrap.min.js
        │   │   └── three.min.js
        │   └── visualization.js
        ├── sessions
        └── styles
        │   ├── bootstrap.min.css
        │   └── style.css
    ├── templates
        ├── components
        │   ├── about.html
        │   ├── benchmarking.html
        │   └── configuration.html
        └── omplweb.html
    └── wsgi.ini


/.appveyor.yml:
--------------------------------------------------------------------------------
 1 | # AppVeyor file
 2 | # http://www.appveyor.com/docs/appveyor-yml
 3 | 
 4 | version: "{build}"
 5 | os: Visual Studio 2017
 6 | 
 7 | clone_folder: C:\projects\omplapp
 8 | shallow_clone: true
 9 | 
10 | platform: x64
11 | 
12 | environment:
13 |   CTEST_OUTPUT_ON_FAILURE: 1
14 |   CMAKE_TOOLCHAIN_FILE: -DCMAKE_TOOLCHAIN_FILE="C:\tools\vcpkg\scripts\buildsystems\vcpkg.cmake"
15 |   CMAKE_GENERATOR: -G"Visual Studio 15 2017 Win64"
16 |   VCPKG_ARCH: x64-windows
17 | 
18 | cache:
19 |   - C:\tools\vcpkg\installed -> .appveyor.yml
20 | 
21 | configuration: Release
22 | 
23 | before_build:
24 |   - cmd: vcpkg update
25 |   - cmd: vcpkg install assimp:%VCPKG_ARCH%
26 |   - cmd: vcpkg install boost-disjoint-sets:%VCPKG_ARCH%
27 |   - cmd: vcpkg install boost-dynamic-bitset:%VCPKG_ARCH%
28 |   - cmd: vcpkg install boost-filesystem:%VCPKG_ARCH%
29 |   - cmd: vcpkg install boost-graph:%VCPKG_ARCH%
30 |   - cmd: vcpkg install boost-odeint:%VCPKG_ARCH%
31 |   - cmd: vcpkg install boost-program-options:%VCPKG_ARCH%
32 |   - cmd: vcpkg install boost-serialization:%VCPKG_ARCH%
33 |   - cmd: vcpkg install boost-system:%VCPKG_ARCH%
34 |   - cmd: vcpkg install boost-test:%VCPKG_ARCH%
35 |   - cmd: vcpkg install boost-ublas:%VCPKG_ARCH%
36 |   - cmd: vcpkg install eigen3:%VCPKG_ARCH%
37 |   - cmd: vcpkg install fcl:%VCPKG_ARCH%
38 |   - cmd: git clone -q --depth=1 --branch=main https://github.com/ompl/ompl.git C:\projects\omplapp\ompl
39 |   - cmd: mkdir build
40 |   - cmd: cd build
41 |   - cmd: cmake %CMAKE_GENERATOR% -DCMAKE_BUILD_TYPE=%configuration% %CMAKE_TOOLCHAIN_FILE% -DOMPL_REGISTRATION=OFF ..
42 | 
43 | build:
44 |   project: C:\projects\omplapp\build\omplapp.sln
45 |   parallel: true
46 | 
47 | after_build:
48 |   - cmd: cmake --build . --config %configuration% --target package
49 | 
50 | test_script:
51 |   - cmd: ctest -C %configuration%
52 | 
53 | artifacts:
54 |   - path: 'build\omplapp*.zip'
55 | 


--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
1 | .git
2 | **/*.pyc
3 | **/*.so
4 | **/*.dylib
5 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .registered
 2 | 
 3 | # Byte-compiled / optimized / DLL files
 4 | __pycache__/
 5 | *.py[cod]
 6 | 
 7 | # C extensions
 8 | *.so
 9 | 
10 | # Distribution / packaging
11 | .Python
12 | env/
13 | build/
14 | develop-eggs/
15 | dist/
16 | downloads/
17 | eggs/
18 | .eggs/
19 | lib/
20 | lib64/
21 | parts/
22 | sdist/
23 | var/
24 | *.egg-info/
25 | .installed.cfg
26 | *.egg
27 | 
28 | # PyInstaller
29 | #  Usually these files are written by a python script from a template
30 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
31 | *.manifest
32 | *.spec
33 | 
34 | # Installer logs
35 | pip-log.txt
36 | pip-delete-this-directory.txt
37 | 
38 | # Unit test / coverage reports
39 | htmlcov/
40 | .tox/
41 | .coverage
42 | .coverage.*
43 | .cache
44 | nosetests.xml
45 | coverage.xml
46 | *,cover
47 | 
48 | # Translations
49 | *.mo
50 | *.pot
51 | 
52 | # Django stuff:
53 | *.log
54 | 
55 | # Sphinx documentation
56 | docs/_build/
57 | 
58 | # PyBuilder
59 | target/
60 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "ompl"]
2 | 	path = ompl
3 | 	url = https://github.com/ompl/ompl
4 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: cpp
 2 | 
 3 | matrix:
 4 |   include:
 5 |   - os: linux
 6 |     dist: fossa
 7 |     compiler: gcc
 8 |     addons:
 9 |       apt:
10 |         packages:
11 |         - freeglut3-dev
12 |         - libassimp-dev
13 |         - libboost-filesystem-dev
14 |         - libboost-program-options-dev
15 |         - libboost-serialization-dev
16 |         - libboost-system-dev
17 |         - libboost-test-dev
18 |         - libccd-dev
19 |         - libeigen3-dev
20 |         - libfcl-dev
21 |         - libflann-dev
22 |         - ninja-build
23 |   - os: osx
24 |     osx_image: xcode14.2
25 |     compiler: clang
26 |     addons:
27 |       homebrew:
28 |         packages:
29 |         - assimp
30 |         - eigen
31 |         - fcl
32 |         - flann
33 |         - ninja
34 |         update: true
35 | 
36 | script:
37 |   - mkdir -p build
38 |   - cd build
39 |   - cmake -G Ninja -DOMPL_REGISTRATION=OFF ..
40 |   - cmake --build .
41 |   - ctest
42 | 


--------------------------------------------------------------------------------
/CMakeModules/CPackSettings.cmake:
--------------------------------------------------------------------------------
 1 | set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "The Open Motion Planning Library (OMPL) & front-end (OMPL-APP)")
 2 | set(CPACK_PACKAGE_VENDOR "Rice University")
 3 | set(CPACK_PACKAGE_CONTACT "Mark Moll <mmoll@rice.edu>")
 4 | 
 5 | # component list
 6 | set(CPACK_COMPONENTS_ALL ompl python omplapp)
 7 | # display names for components
 8 | set(CPACK_COMPONENT_OMPL_DISPLAY_NAME "OMPL library, headers, and demos")
 9 | set(CPACK_COMPONENT_PYTHON_DISPLAY_NAME "Python bindings")
10 | set(CPACK_COMPONENT_OMPLAPP_DISPLAY_NAME "OMPL.app library and GUI")
11 | # descriptions of components
12 | set(CPACK_COMPONENT_OMPLAPP_DESCRIPTION "The OMPL.app library makes it easy to read meshes (using the Assimp library) and perform collision checking (using the FCL library). The GUI is built on top of this and makes it easy to perform geometric and control-based planning for rigid bodies.")
13 | # intercomponent dependencies
14 | set(CPACK_COMPONENT_PYTHON_DEPENDS ompl)
15 | set(CPACK_COMPONENT_OMPLAPP_DEPENDS python)
16 | # core library is required
17 | set(CPACK_COMPONENT_OMPL_REQUIRED ON)
18 | 
19 | set(CPACK_SOURCE_IGNORE_FILES
20 |     ".git"
21 |     "/.vscode"
22 |     "/build/"
23 |     ".pyc$"
24 |     ".pyo$"
25 |     "__pycache__"
26 |     ".so$"
27 |     ".dylib$"
28 |     ".orig$"
29 |     ".log$"
30 |     ".DS_Store"
31 |     "/html/"
32 |     "TODO"
33 |     "releaseChecklist.txt"
34 |     ".registered$"
35 |     "binding_generator.py$")
36 | set(CPACK_SOURCE_GENERATOR "TGZ;ZIP")
37 | set(CPACK_GENERATOR "TGZ")
38 | 
39 | if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
40 |   set(CPACK_GENERATOR "DEB;${CPACK_GENERATOR}")
41 |   if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "i686")
42 |       set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "i386")
43 |   endif()
44 |   if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86_64")
45 |       set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "amd64")
46 |   endif()
47 |   execute_process(COMMAND "/usr/bin/lsb_release" "-rs"
48 |       OUTPUT_VARIABLE UBUNTU_RELEASE
49 |       OUTPUT_STRIP_TRAILING_WHITESPACE)
50 |   set(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}_${PROJECT_VERSION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}-Ubuntu${UBUNTU_RELEASE}")
51 |   set(CPACK_DEBIAN_PACKAGE_DEPENDS "python${PYTHON_VERSION}, libboost-serialization-dev, libboost-filesystem-dev, libboost-system-dev, libboost-program-options-dev, libboost-test-dev, python-opengl, python-pyqt5.qtopengl, freeglut3-dev, libassimp-dev, libtriangle-dev, libccd-dev")
52 | endif()
53 | 
54 | if(WIN32)
55 |     set(CPACK_GENERATOR "ZIP;${CPACK_GENERATOR}")
56 | endif()
57 | 
58 | include(CPack)
59 | 


--------------------------------------------------------------------------------
/CMakeModules/FindPQP.cmake:
--------------------------------------------------------------------------------
 1 | include(FindPackageHandleStandardArgs)
 2 | 
 3 | find_library(PQP_LIBRARY PQP DOC "Location of PQP proximity query library")
 4 | find_path(PQP_INCLUDE_DIR PQP.h PATH_SUFFIXES "PQP"
 5 |     DOC "Location of PQP proximity query header files")
 6 | 
 7 | if(PQP_LIBRARY AND PQP_INCLUDE_DIR)
 8 |     set(OMPL_HAS_PQP 1)
 9 | endif()
10 | 
11 | find_package_handle_standard_args(PQP DEFAULT_MSG PQP_LIBRARY PQP_INCLUDE_DIR)
12 | mark_as_advanced(PQP_LIBRARY PQP_INCLUDE_DIR)
13 | 


--------------------------------------------------------------------------------
/CMakeModules/Findccd.cmake:
--------------------------------------------------------------------------------
 1 | include(FindPackageHandleStandardArgs)
 2 | find_package(PkgConfig)
 3 | if(PKGCONFIG_FOUND)
 4 |     pkg_check_modules(CCD ccd>=2.0)
 5 |     if(CCD_LIBRARIES AND NOT CCD_INCLUDE_DIRS)
 6 |         set(CCD_INCLUDE_DIRS "/usr/include")
 7 |     endif()
 8 | endif()
 9 | find_package_handle_standard_args(ccd DEFAULT_MSG CCD_LIBRARIES CCD_INCLUDE_DIRS)
10 | 


--------------------------------------------------------------------------------
/CMakeModules/Findfcl.cmake:
--------------------------------------------------------------------------------
 1 | include(FindPackageHandleStandardArgs)
 2 | 
 3 | # vcpkg and MacPorts install cmake config files for fcl
 4 | find_package(fcl QUIET CONFIG)
 5 | if(TARGET fcl)
 6 |     get_target_property(FCL_INCLUDE_DIRS fcl INTERFACE_INCLUDE_DIRECTORIES)
 7 |     set(FCL_LIBRARIES "fcl")
 8 | else()
 9 |     find_package(PkgConfig)
10 |     if(PKGCONFIG_FOUND)
11 |         pkg_check_modules(FCL fcl>=0.3.1)
12 |         if(FCL_LIBRARIES AND NOT FCL_INCLUDE_DIRS)
13 |             set(FCL_INCLUDE_DIRS "/usr/include")
14 |         endif()
15 |     endif()
16 | endif()
17 | 
18 | find_package_handle_standard_args(fcl DEFAULT_MSG FCL_LIBRARIES FCL_INCLUDE_DIRS)
19 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | The Open Motion Planning Library (OMPL)
 2 | =======================================
 3 | 
 4 | Linux [![Build Status](https://travis-ci.org/ompl/omplapp.svg?branch=main)](https://travis-ci.org/ompl/omplapp)
 5 | Windows [![Build status](https://ci.appveyor.com/api/projects/status/dyu0y627hkp8tp6h/branch/main?svg=true)](https://ci.appveyor.com/project/mamoll/omplapp/branch/main)
 6 | 
 7 | This is OMPL.app, an extended version of OMPL that adds support for mesh
 8 | loading and collision checking as well as a simple GUI.
 9 | 
10 | Visit the [OMPL.app installation page](http://ompl.kavrakilab.org/installation.html) for
11 | detailed installation instructions.
12 | 
13 | OMPL.app has the following required dependencies:
14 | 
15 | * [Boost](https://www.boost.org) (version 1.68 or higher)
16 | * [CMake](https://www.cmake.org) (version 3.12 or higher)
17 | * [Eigen](http://eigen.tuxfamily.org) (version 3.3 or higher)
18 | * [Assimp](http://assimp.org) (version 3.0.1270 or higher)
19 | * [FCL](https://github.com/flexible-collision-library/fcl) (version 0.5.0 or higher)
20 | 
21 | The following dependencies are optional:
22 | 
23 | * [PyQt](https://www.riverbankcomputing.co.uk/software/pyqt/download5) (for GUI)
24 | * [PyOpenGL](https://pyopengl.sourceforge.net/) (for GUI)
25 | * [Py++](https://github.com/ompl/ompl/blob/main/doc/markdown/installPyPlusPlus.md) (needed to generate Python bindings)
26 | * [Doxygen](http://www.doxygen.org) (needed to create a local copy of the documentation at
27 |   https://ompl.kavrakilab.org)
28 | 
29 | Once dependencies are installed, you can build OMPL.app on Linux, macOS,
30 | and MS Windows. Go to the top-level directory of OMPL.app and type the
31 | following commands:
32 | 
33 |     mkdir -p build/Release
34 |     cd build/Release
35 |     cmake ../..
36 |     # next step is optional
37 |     make -j 4 update_bindings # if you want to use the GUI or Python bindings
38 |     make -j 4 # replace "4" with the number of cores on your machine
39 | 


--------------------------------------------------------------------------------
/TODO:
--------------------------------------------------------------------------------
1 | * Demo for maximum clearance sampler
2 | 


--------------------------------------------------------------------------------
/benchmark/BenchmarkOptions.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Software License Agreement (BSD License)
 3 | *
 4 | *  Copyright (c) 2012, Willow Garage, Inc.
 5 | *  All rights reserved.
 6 | *
 7 | *  Redistribution and use in source and binary forms, with or without
 8 | *  modification, are permitted provided that the following conditions
 9 | *  are met:
10 | *
11 | *   * Redistributions of source code must retain the above copyright
12 | *     notice, this list of conditions and the following disclaimer.
13 | *   * Redistributions in binary form must reproduce the above
14 | *     copyright notice, this list of conditions and the following
15 | *     disclaimer in the documentation and/or other materials provided
16 | *     with the distribution.
17 | *   * Neither the name of the Willow Garage nor the names of its
18 | *     contributors may be used to endorse or promote products derived
19 | *     from this software without specific prior written permission.
20 | *
21 | *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 | *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 | *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 | *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 | *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 | *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 | *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 | *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29 | *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 | *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31 | *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 | *  POSSIBILITY OF SUCH DAMAGE.
33 | *********************************************************************/
34 | 
35 | /* Author: Ioan Sucan */
36 | 
37 | #include <map>
38 | #include <string>
39 | #include <vector>
40 | #include <boost/filesystem/path.hpp>
41 | 
42 | struct BenchmarkOptions
43 | {
44 |     BenchmarkOptions(void)
45 |     {
46 |     }
47 | 
48 |     BenchmarkOptions(const char *filename)
49 |     {
50 |         readOptions(filename);
51 |     }
52 | 
53 |     using PlannerOpt = std::map<std::string, std::string>; // options specific to the planner
54 |     using ContextOpt = std::map<std::string, std::string>; // other options (not specific to the planner)
55 | 
56 |     // all the options for a benchmark execution
57 |     struct AllOptions
58 |     {
59 |         ContextOpt c;
60 |         PlannerOpt p;
61 |     };
62 | 
63 |     std::map<std::string, std::string>              declared_options_;
64 |     std::map<std::string, std::vector<AllOptions> > planners_;
65 | 
66 |     // the path where the input .cfg file is located
67 |     boost::filesystem::path                         path_;
68 | 
69 |     // the file to which benchmark results should be written
70 |     boost::filesystem::path                         outfile_;
71 | 
72 |     bool readOptions(const char *filename);
73 |     bool isSE2Problem(void) const;
74 |     bool isSE3Problem(void) const;
75 | };
76 | 


--------------------------------------------------------------------------------
/benchmark/CFGBenchmark.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Software License Agreement (BSD License)
 3 | *
 4 | *  Copyright (c) 2012, Willow Garage, Inc.
 5 | *  All rights reserved.
 6 | *
 7 | *  Redistribution and use in source and binary forms, with or without
 8 | *  modification, are permitted provided that the following conditions
 9 | *  are met:
10 | *
11 | *   * Redistributions of source code must retain the above copyright
12 | *     notice, this list of conditions and the following disclaimer.
13 | *   * Redistributions in binary form must reproduce the above
14 | *     copyright notice, this list of conditions and the following
15 | *     disclaimer in the documentation and/or other materials provided
16 | *     with the distribution.
17 | *   * Neither the name of the Willow Garage nor the names of its
18 | *     contributors may be used to endorse or promote products derived
19 | *     from this software without specific prior written permission.
20 | *
21 | *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 | *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 | *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 | *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 | *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 | *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 | *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 | *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29 | *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 | *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31 | *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 | *  POSSIBILITY OF SUCH DAMAGE.
33 | *********************************************************************/
34 | 
35 | /* Author: Ioan Sucan, Mark Moll */
36 | 
37 | #include <ompl/control/planners/syclop/Decomposition.h>
38 | #include <ompl/tools/benchmark/Benchmark.h>
39 | #include <omplapp/geometry/RigidBodyGeometry.h>
40 | #include "BenchmarkOptions.h"
41 | 
42 | class CFGBenchmark
43 | {
44 | public:
45 | 
46 |     CFGBenchmark(const BenchmarkOptions &bo) : bo_(bo)
47 |     {
48 |     }
49 | 
50 |     virtual ~CFGBenchmark(void)
51 |     {
52 |     }
53 | 
54 |     bool isValid(void) const
55 |     {
56 |         return benchmark_.get();
57 |     }
58 | 
59 |     void runBenchmark(void);
60 | 
61 |     void setup(void);
62 | 
63 | protected:
64 |     void setMeshes(ompl::app::RigidBodyGeometry& app);
65 | 
66 |     virtual void configure(void) = 0;
67 | 
68 |     ompl::base::OptimizationObjectivePtr getOptimizationObjective(const ompl::base::SpaceInformationPtr &si);
69 | 
70 |     // decomposition, needed for Syclop
71 |     virtual ompl::control::DecompositionPtr allocDecomposition() = 0;
72 | 
73 |     // optional post-run events
74 |     virtual void saveAllPaths(const ompl::base::PlannerPtr &planner, ompl::tools::Benchmark::RunProperties &run);
75 |     virtual void saveBestPath(const ompl::base::PlannerPtr &planner, ompl::tools::Benchmark::RunProperties &run);
76 | 
77 |     BenchmarkOptions                                             bo_;
78 |     std::map<ompl::base::Planner*, BenchmarkOptions::ContextOpt> pcontext_;
79 |     BenchmarkOptions::ContextOpt                                 activeParams_;
80 |     ompl::base::Cost                                             defaultCostThreshold_;
81 |     std::shared_ptr<ompl::tools::Benchmark>                      benchmark_;
82 | 
83 |     // When the best path is saved, we keep it here
84 |     ompl::base::PathPtr                                          bestPath_;
85 |     unsigned int                                                 bestPathIndex_;
86 | 
87 | private:
88 | 
89 |     ompl::base::PlannerPtr allocPlanner(const ompl::base::SpaceInformationPtr &si, const std::string &name, const BenchmarkOptions::AllOptions &opt);
90 |     ompl::base::ValidStateSamplerPtr allocValidStateSampler(const ompl::base::SpaceInformation *si, const std::string &type);
91 |     void setupBenchmark(void);
92 |     void preSwitchEvent(const ompl::base::PlannerPtr &planner);
93 | };
94 | 


--------------------------------------------------------------------------------
/benchmark/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | add_executable(ompl_benchmark
2 |     CFGBenchmark.cpp BenchmarkOptions.cpp BenchmarkTypes.cpp benchmark.cpp)
3 | target_link_libraries(ompl_benchmark ${OMPLAPP_LIBRARIES} ompl ompl_app_base ${Boost_PROGRAM_OPTIONS_LIBRARY})
4 | install(TARGETS ompl_benchmark
5 |     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
6 |     COMPONENT omplapp
7 |     RENAME ompl_benchmark)
8 | 


--------------------------------------------------------------------------------
/benchmark/benchmark.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Software License Agreement (BSD License)
 3 | *
 4 | *  Copyright (c) 2012, Willow Garage, Inc.
 5 | *  All rights reserved.
 6 | *
 7 | *  Redistribution and use in source and binary forms, with or without
 8 | *  modification, are permitted provided that the following conditions
 9 | *  are met:
10 | *
11 | *   * Redistributions of source code must retain the above copyright
12 | *     notice, this list of conditions and the following disclaimer.
13 | *   * Redistributions in binary form must reproduce the above
14 | *     copyright notice, this list of conditions and the following
15 | *     disclaimer in the documentation and/or other materials provided
16 | *     with the distribution.
17 | *   * Neither the name of the Willow Garage nor the names of its
18 | *     contributors may be used to endorse or promote products derived
19 | *     from this software without specific prior written permission.
20 | *
21 | *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 | *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 | *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 | *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 | *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 | *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 | *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 | *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29 | *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 | *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31 | *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 | *  POSSIBILITY OF SUCH DAMAGE.
33 | *********************************************************************/
34 | 
35 | /* Author: Ioan Sucan, Mark Moll */
36 | 
37 | #include "BenchmarkTypes.h"
38 | #include <iostream>
39 | 
40 | int main(int argc, char **argv)
41 | {
42 |     if (argc < 2)
43 |     {
44 |         std::cerr << "Usage:\n\t " << argv[0] << " problem.cfg" << std::endl;
45 |         return 1;
46 |     }
47 | 
48 |     BenchmarkOptions bo;
49 |     if (bo.readOptions(argv[1]))
50 |     {
51 |         std::shared_ptr<CFGBenchmark> b;
52 |         auto controlType = bo.declared_options_.find("problem.control");
53 |         if (bo.isSE2Problem())
54 |         {
55 |             if (controlType == bo.declared_options_.end())
56 |                 b = std::make_shared<SE2Benchmark>(bo);
57 |             else if (controlType->second == "kinematic_car")
58 |                 b = std::make_shared<KinematicCarBenchmark>(bo);
59 |             else if (controlType->second == "dynamic_car")
60 |                 b = std::make_shared<DynamicCarBenchmark>(bo);
61 |             else
62 |                 b = std::make_shared<SE2Benchmark>(bo);
63 |         }
64 |         else if (bo.isSE3Problem())
65 |         {
66 |             if (controlType == bo.declared_options_.end())
67 |                 b = std::make_shared<SE3Benchmark>(bo);
68 |             else if (controlType->second == "blimp")
69 |                 b = std::make_shared<BlimpBenchmark>(bo);
70 |             else if (controlType->second == "quadrotor")
71 |                 b = std::make_shared<QuadrotorBenchmark>(bo);
72 |             else
73 |                 b = std::make_shared<SE3Benchmark>(bo);
74 |         }
75 | 
76 |         if (b)
77 |         {
78 |             b->setup();
79 |             b->runBenchmark();
80 |         }
81 |         else
82 |             std::cerr << "No known benchmark" << std::endl;
83 |     }
84 |     else
85 |         std::cerr << "Unable to load options" << std::endl;
86 | 
87 |     return 0;
88 | }
89 | 


--------------------------------------------------------------------------------
/benchmark/example.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | # problem specific settings
 3 | name=example_name
 4 | world=2D/Maze_planar_env.dae
 5 | robot=2D/car1_planar_robot.dae
 6 | start.x=0.0
 7 | start.y=0.0
 8 | start.theta=0.0
 9 | goal.x=26.0
10 | goal.y=0.0
11 | goal.theta=0.0
12 | threshold=1e-15
13 | volume.min.x = 0
14 | volume.min.y = 1
15 | volume.max.x = 1
16 | volume.max.y = 2
17 | # comment out for rigid body planning
18 | # other statespace options: dubinssymmetric, reedsshepp
19 | statespace=dubins
20 | # used when statespace is specified
21 | turningradius=4
22 | 
23 | [benchmark]
24 | time_limit=10.0
25 | mem_limit=1000.0
26 | run_count = 3
27 | # specify whether path simplification should be used (1=on, 0=off). The default is on.
28 | simplify=1
29 | 
30 | [planner]
31 | # the planners to instantiate
32 | est=
33 | rrt=
34 | sbl=
35 | prm=
36 | kpiece=
37 | bkpiece=
38 | lbkpiece=
39 | stride=
40 | 
41 | # other planner options are possible too. e.g.:
42 | # rrt.range=0.2
43 | 


--------------------------------------------------------------------------------
/benchmark/example_complex.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name=cubicles_se3
 3 | world=3D/cubicles_env.dae
 4 | robot=3D/cubicles_robot.dae
 5 | start.x=-4.96
 6 | start.y=-40.62
 7 | start.z=70.57
 8 | start.axis.x=0.0
 9 | start.axis.y=0.0
10 | start.axis.z=1.0
11 | start.theta=0.0
12 | goal.x=200.49
13 | goal.y=-40.62
14 | goal.z=70.57
15 | goal.axis.x=0.0
16 | goal.axis.y=0.0
17 | goal.axis.z=1.0
18 | goal.theta=0.0
19 | threshold=1e-15
20 | 
21 | # settings specific to the state space are also allowed
22 | longest_valid_segment_fraction = 0.01
23 | 
24 | [benchmark]
25 | time_limit=8.0
26 | mem_limit=4096.0
27 | run_count=50
28 | output=../../../../results/
29 | 
30 | [planner]
31 | 
32 | # we specify the range option for the RRTConnect algorithm;
33 | # since there is no instance of an algorithm already created,
34 | # an instance of RRTConnect is automatically created, and the value
35 | # of range is set for that instance
36 | rrtconnect.range=50
37 | 
38 | # specifying the name of an algorithm with no value
39 | # creates an additional instance of that algorithm. previous settings
40 | # do not affect this instance
41 | rrtconnect=
42 | 
43 | # specify a setting for a previously instantiated algorithm; this
44 | # does not create an instance of RRTConnect, since a previously created instance
45 | # exists; specifying the same option repeatedly has no effect; the value of the last
46 | # option is the one that matters
47 | rrtconnect.range=100
48 | 
49 | # new instance or RRTConnect
50 | rrtconnect=
51 | # and a value for the range
52 | rrtconnect.range=200
53 | 
54 | # new instance of KPIECE
55 | kpiece=
56 | # The value for longest_valid_segment_fraction is inherited
57 | # from the problem section, and would have that value by default
58 | # but it can be overidden here
59 | problem.longest_valid_segment_fraction = 0.2
60 | 
61 | # new instance of KPIECE
62 | kpiece=
63 | # increase the size of the projection by a specific factor, in every dimension
64 | problem.projection.cellsize_factor = 4.0
65 | # The value of longest_valid_segment_fraction for this planner instance is the
66 | # same as the one in the problem section, not as the one defined for the previous
67 | # instance of KPIECE
68 | 


--------------------------------------------------------------------------------
/demos/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | if (OMPL_BUILD_DEMOS)
 2 |     set(OMPLAPP_DEMO_LIBRARIES ${OMPLAPP_LIBRARIES} ompl ompl_app_base)
 3 | 
 4 |     macro(add_omplapp_demo demo_name)
 5 |       add_executable(${ARGV})
 6 |       target_link_libraries(${demo_name} ${OMPLAPP_DEMO_LIBRARIES})
 7 |     endmacro(add_omplapp_demo)
 8 | 
 9 |     add_omplapp_demo(demo_SE3RigidBodyPlanningBenchmark SE3RigidBodyPlanning/SE3RigidBodyPlanningBenchmark.cpp)
10 |     add_omplapp_demo(demo_SE3RigidBodyPlanning SE3RigidBodyPlanning/SE3RigidBodyPlanning.cpp)
11 |     add_omplapp_demo(demo_SE3RigidBodyPlanningWithOptimization SE3RigidBodyPlanning/SE3RigidBodyPlanningWithOptimization.cpp)
12 |     add_omplapp_demo(demo_SE2RigidBodyPlanning SE2RigidBodyPlanning/SE2RigidBodyPlanning.cpp)
13 |     add_omplapp_demo(demo_KinematicCarPlanning SE2RigidBodyPlanning/KinematicCarPlanning.cpp)
14 |     add_omplapp_demo(demo_DynamicCarPlanning SE2RigidBodyPlanning/DynamicCarPlanning.cpp)
15 |     add_omplapp_demo(demo_BlimpPlanning SE3RigidBodyPlanning/BlimpPlanning.cpp)
16 |     add_omplapp_demo(demo_QuadrotorPlanning SE3RigidBodyPlanning/QuadrotorPlanning.cpp)
17 |     add_omplapp_demo(demo_SE2MultiRigidBodyPlanning SE2RigidBodyPlanning/SE2MultiRigidBodyPlanning.cpp)
18 |     add_omplapp_demo(demo_SE3MultiRigidBodyPlanning SE3RigidBodyPlanning/SE3MultiRigidBodyPlanning.cpp)
19 |     add_omplapp_demo(demo_CollisionCheckers SE3RigidBodyPlanning/CollisionCheckers.cpp)
20 |     add_omplapp_demo(demo_AnytimePathShortening AnytimePathShorteningDemo.cpp)
21 | endif(OMPL_BUILD_DEMOS)
22 | 
23 | file(GLOB OMPLAPP_DEMO_PY_FILES "*/*.py")
24 | install_python(PROGRAMS ${OMPLAPP_DEMO_PY_FILES}
25 |   DESTINATION "${OMPL_DEMO_INSTALL_DIR}"
26 |   COMPONENT omplapp)
27 | file(GLOB OMPLAPP_DEMO_CXX_FILES "*/*.cpp")
28 | install(FILES ${OMPLAPP_DEMO_CXX_FILES}
29 |     DESTINATION "${OMPL_DEMO_INSTALL_DIR}"
30 |     COMPONENT omplapp)
31 | 


--------------------------------------------------------------------------------
/demos/SE2RigidBodyPlanning/DynamicCarPlanning.cpp:
--------------------------------------------------------------------------------
  1 | /*********************************************************************
  2 |  * Rice University Software Distribution License
  3 |  *
  4 |  * Copyright (c) 2010, Rice University
  5 |  * All Rights Reserved.
  6 |  *
  7 |  * For a full description see the file named LICENSE.
  8 |  *
  9 |  *********************************************************************/
 10 | 
 11 | /* Author: Mark Moll */
 12 | 
 13 | #include <ompl/control/planners/est/EST.h>
 14 | #include <ompl/control/planners/kpiece/KPIECE1.h>
 15 | #include <ompl/control/planners/pdst/PDST.h>
 16 | #include <ompl/control/planners/rrt/RRT.h>
 17 | #include <ompl/tools/benchmark/Benchmark.h>
 18 | #include <omplapp/apps/DynamicCarPlanning.h>
 19 | #include <omplapp/config.h>
 20 | 
 21 | using namespace ompl;
 22 | 
 23 | void dynamicCarSetup(app::DynamicCarPlanning &setup)
 24 | {
 25 |     // plan for dynamic car in SE(2)
 26 |     base::StateSpacePtr stateSpace(setup.getStateSpace());
 27 | 
 28 |     // set the bounds for the R^2 part of SE(2)
 29 |     base::RealVectorBounds bounds(2);
 30 |     bounds.setLow(-10);
 31 |     bounds.setHigh(10);
 32 |     stateSpace->as<base::CompoundStateSpace>()->as<base::SE2StateSpace>(0)->setBounds(bounds);
 33 | 
 34 |     // define start state
 35 |     base::ScopedState<> start(stateSpace);
 36 |     start[0] = start[1] = start[2] = start[3] = start[4] = 0.;
 37 | 
 38 |     // define goal state
 39 |     base::ScopedState<> goal(stateSpace);
 40 |     goal[0] = goal[1] = 8.;
 41 |     goal[2] = 0;
 42 |     goal[3] = goal[4] = 0.;
 43 | 
 44 |     // set the start & goal states
 45 |     setup.setStartAndGoalStates(start, goal, .5);
 46 | 
 47 |     // optionally, set a planner
 48 |     // setup.setPlanner(std::make_shared<control::EST>(setup.getSpaceInformation()));
 49 |     // setup.setPlanner(std::make_shared<control::RRT>(setup.getSpaceInformation()));
 50 |     // setup.setPlanner(std::make_shared<control::KPIECE1>(setup.getSpaceInformation()));
 51 |     // setup.setPlanner(std::make_shared<control::PDST>(setup.getSpaceInformation()));
 52 |     std::vector<double> cs(2);
 53 |     cs[0] = cs[1] = 0.1;
 54 |     setup.setup();
 55 |     setup.getStateSpace()->getDefaultProjection()->setCellSizes(cs);
 56 | }
 57 | 
 58 | void dynamicCarDemo(app::DynamicCarPlanning &setup)
 59 | {
 60 |     std::cout << "\n\n***** Planning for a " << setup.getName() << " *****\n" << std::endl;
 61 | 
 62 |     // try to solve the problem
 63 |     if (setup.solve(40))
 64 |     {
 65 |         // print the (approximate) solution path: print states along the path
 66 |         // and controls required to get from one state to the next
 67 |         control::PathControl &path(setup.getSolutionPath());
 68 |         // path.interpolate(); // uncomment if you want to plot the path
 69 |         path.printAsMatrix(std::cout);
 70 |         if (!setup.haveExactSolutionPath())
 71 |         {
 72 |             std::cout << "Solution is approximate. Distance to actual goal is "
 73 |                       << setup.getProblemDefinition()->getSolutionDifference() << std::endl;
 74 |         }
 75 |     }
 76 | }
 77 | void dynamicCarBenchmark(app::DynamicCarPlanning &setup)
 78 | {
 79 |     tools::Benchmark::Request request(100., 10000., 10);  // runtime (s), memory (MB), run count
 80 | 
 81 |     setup.setup();
 82 | 
 83 |     tools::Benchmark b(setup, setup.getName());
 84 |     b.addPlanner(std::make_shared<control::RRT>(setup.getSpaceInformation()));
 85 |     b.addPlanner(std::make_shared<control::KPIECE1>(setup.getSpaceInformation()));
 86 |     b.benchmark(request);
 87 |     b.saveResultsToFile();
 88 | }
 89 | 
 90 | int main(int argc, char ** /*unused*/)
 91 | {
 92 |     app::DynamicCarPlanning car;
 93 |     dynamicCarSetup(car);
 94 | 
 95 |     // If any command line arguments are given, solve the problem multiple
 96 |     // times with different planners and collect benchmark statistics.
 97 |     // Otherwise, solve the problem once and print the path.
 98 |     if (argc > 1)
 99 |         dynamicCarBenchmark(car);
100 |     else
101 |         dynamicCarDemo(car);
102 |     return 0;
103 | }
104 | 


--------------------------------------------------------------------------------
/demos/SE2RigidBodyPlanning/DynamicCarPlanning.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | ######################################################################
 4 | # Rice University Software Distribution License
 5 | #
 6 | # Copyright (c) 2010, Rice University
 7 | # All Rights Reserved.
 8 | #
 9 | # For a full description see the file named LICENSE.
10 | #
11 | ######################################################################
12 | 
13 | # Author: Mark Moll
14 | 
15 | import sys
16 | from os.path import abspath, dirname, join
17 | 
18 | ompl_app_root = dirname(dirname(dirname(abspath(__file__))))
19 | 
20 | try:
21 |     from ompl import base as ob
22 |     from ompl import control as oc
23 |     from ompl import app as oa
24 | except ImportError:
25 |     sys.path.insert(0, join(ompl_app_root, 'ompl/py-bindings'))
26 |     from ompl import base as ob
27 |     from ompl import control as oc
28 |     from ompl import app as oa
29 | 
30 | def dynamicCarDemo():
31 |     setup = oa.DynamicCarPlanning()
32 |     # comment out next two lines if you want to ignore obstacles
33 |     setup.setRobotMesh('2D/car1_planar_robot.dae')
34 |     setup.setEnvironmentMesh('2D/BugTrap_planar_env.dae')
35 | 
36 |     # plan for dynamic car in SE(2)
37 |     stateSpace = setup.getStateSpace()
38 | 
39 |     # set the bounds for the R^2 part of SE(2)
40 |     bounds = ob.RealVectorBounds(2)
41 |     bounds.setLow(-10)
42 |     bounds.setHigh(10)
43 |     stateSpace.getSubspace(0).setBounds(bounds)
44 | 
45 |     # define start state
46 |     start = ob.State(stateSpace)
47 |     start[0] = 6.
48 |     start[1] = 12.
49 |     start[2] = start[3] = start[4] = 0.
50 | 
51 |     # define goal state
52 |     goal = ob.State(stateSpace)
53 |     goal[0] = -39.
54 |     goal[1] = goal[2] = goal[3] = goal[4] = 0.
55 | 
56 |     # set the start & goal states
57 |     setup.setStartAndGoalStates(start, goal, 3.)
58 | 
59 |     # set the planner
60 |     planner = oc.RRT(setup.getSpaceInformation())
61 |     #setup.setPlanner(planner)
62 | 
63 |     # try to solve the problem
64 |     print("\n\n***** Planning for a %s *****\n" % setup.getName())
65 |     print(setup)
66 |     if setup.solve(40):
67 |         # print the (approximate) solution path: print states along the path
68 |         # and controls required to get from one state to the next
69 |         path = setup.getSolutionPath()
70 |         #path.interpolate(); # uncomment if you want to plot the path
71 |         print(path.printAsMatrix())
72 |         if not setup.haveExactSolutionPath():
73 |             print("Solution is approximate. Distance to actual goal is %g" %
74 |                   setup.getProblemDefinition().getSolutionDifference())
75 | 
76 | if __name__ == '__main__':
77 |     dynamicCarDemo()
78 | 


--------------------------------------------------------------------------------
/demos/SE2RigidBodyPlanning/KinematicCarPlanning.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 |  * Rice University Software Distribution License
 3 |  *
 4 |  * Copyright (c) 2010, Rice University
 5 |  * All Rights Reserved.
 6 |  *
 7 |  * For a full description see the file named LICENSE.
 8 |  *
 9 |  *********************************************************************/
10 | 
11 | /* Author: Mark Moll */
12 | 
13 | #include <ompl/control/planners/kpiece/KPIECE1.h>
14 | #include <ompl/control/planners/rrt/RRT.h>
15 | #include <ompl/tools/benchmark/Benchmark.h>
16 | #include <omplapp/apps/KinematicCarPlanning.h>
17 | #include <omplapp/config.h>
18 | #include <boost/math/constants/constants.hpp>
19 | 
20 | using namespace ompl;
21 | 
22 | void kinematicCarSetup(app::KinematicCarPlanning &setup)
23 | {
24 |     // plan for kinematic car in SE(2)
25 |     base::StateSpacePtr SE2(setup.getStateSpace());
26 | 
27 |     // set the bounds for the R^2 part of SE(2)
28 |     base::RealVectorBounds bounds(2);
29 |     bounds.setLow(-10);
30 |     bounds.setHigh(10);
31 |     SE2->as<base::SE2StateSpace>()->setBounds(bounds);
32 | 
33 |     // define start state
34 |     base::ScopedState<base::SE2StateSpace> start(SE2);
35 |     start->setX(0);
36 |     start->setY(0);
37 |     start->setYaw(0);
38 | 
39 |     // define goal state
40 |     base::ScopedState<base::SE2StateSpace> goal(SE2);
41 |     goal->setX(2);
42 |     goal->setY(2);
43 |     goal->setYaw(boost::math::constants::pi<double>());
44 | 
45 |     // set the start & goal states
46 |     setup.setStartAndGoalStates(start, goal, .1);
47 | }
48 | 
49 | void kinematicCarDemo(app::KinematicCarPlanning &setup)
50 | {
51 |     setup.setPlanner(std::make_shared<control::KPIECE1>(setup.getSpaceInformation()));
52 |     std::vector<double> cs(2);
53 |     cs[0] = cs[1] = 0.1;
54 |     setup.setup();
55 |     setup.getStateSpace()->getDefaultProjection()->setCellSizes(cs);
56 | 
57 |     // try to solve the problem
58 |     if (setup.solve(20))
59 |     {
60 |         // print the (approximate) solution path: print states along the path
61 |         // and controls required to get from one state to the next
62 |         control::PathControl &path(setup.getSolutionPath());
63 |         // path.interpolate(); // uncomment if you want to plot the path
64 |         path.printAsMatrix(std::cout);
65 |         if (!setup.haveExactSolutionPath())
66 |         {
67 |             std::cout << "Solution is approximate. Distance to actual goal is "
68 |                       << setup.getProblemDefinition()->getSolutionDifference() << std::endl;
69 |         }
70 |     }
71 | }
72 | void kinematicCarBenchmark(app::KinematicCarPlanning &setup)
73 | {
74 |     tools::Benchmark::Request request(20., 10000., 10);  // runtime (s), memory (MB), run count
75 | 
76 |     tools::Benchmark b(setup, setup.getName());
77 |     b.addPlanner(std::make_shared<control::RRT>(setup.getSpaceInformation()));
78 |     b.addPlanner(std::make_shared<control::KPIECE1>(setup.getSpaceInformation()));
79 |     b.benchmark(request);
80 |     b.saveResultsToFile();
81 | }
82 | 
83 | int main(int argc, char ** /*unused*/)
84 | {
85 |     app::KinematicCarPlanning regularCar;
86 | 
87 |     kinematicCarSetup(regularCar);
88 | 
89 |     // If any command line arguments are given, solve the problem multiple
90 |     // times with different planners and collect benchmark statistics.
91 |     // Otherwise, solve the problem once for each car type and print the path.
92 |     if (argc > 1)
93 |         kinematicCarBenchmark(regularCar);
94 |     else
95 |         kinematicCarDemo(regularCar);
96 |     return 0;
97 | }
98 | 


--------------------------------------------------------------------------------
/demos/SE2RigidBodyPlanning/KinematicCarPlanning.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | ######################################################################
 4 | # Rice University Software Distribution License
 5 | #
 6 | # Copyright (c) 2010, Rice University
 7 | # All Rights Reserved.
 8 | #
 9 | # For a full description see the file named LICENSE.
10 | #
11 | ######################################################################
12 | 
13 | # Author: Mark Moll
14 | 
15 | import sys
16 | from os.path import abspath, dirname, join
17 | 
18 | ompl_app_root = dirname(dirname(dirname(abspath(__file__))))
19 | 
20 | try:
21 |     from ompl import base as ob
22 |     from ompl import control as oc
23 |     from ompl import app as oa
24 | except ImportError:
25 |     sys.path.insert(0, join(ompl_app_root, "ompl/py-bindings"))
26 |     from ompl import base as ob
27 |     from ompl import control as oc
28 |     from ompl import app as oa
29 | 
30 | 
31 | def kinematicCarDemo():
32 |     setup = oa.KinematicCarPlanning()
33 |     # comment out next two lines if you want to ignore obstacles
34 |     setup.setRobotMesh("2D/car2_planar_robot.dae")
35 |     setup.setEnvironmentMesh("2D/Maze_planar_env.dae")
36 |     SE2 = setup.getStateSpace()
37 | 
38 |     bounds = ob.RealVectorBounds(2)
39 |     bounds.setLow(-55)
40 |     bounds.setHigh(55)
41 |     SE2.setBounds(bounds)
42 | 
43 |     # define start state
44 |     start = ob.State(SE2)
45 |     start().setX(0.01)
46 |     start().setY(-0.15)
47 |     start().setYaw(0)
48 | 
49 |     # define goal state
50 |     goal = ob.State(SE2)
51 |     goal().setX(45.01)
52 |     goal().setY(-0.15)
53 |     goal().setYaw(0.0)
54 | 
55 |     # set the start & goal states
56 |     setup.setStartAndGoalStates(start, goal, 1.0)
57 | 
58 |     # set the planner
59 |     planner = oc.RRT(setup.getSpaceInformation())
60 |     setup.setPlanner(planner)
61 | 
62 |     # try to solve the problem
63 |     print("\n\n***** Planning for a %s *****\n" % setup.getName())
64 |     print(setup)
65 |     if setup.solve(10):
66 |         # print the (approximate) solution path: print states along the path
67 |         # and controls required to get from one state to the next
68 |         path = setup.getSolutionPath()
69 |         path.interpolate()
70 |         # path.interpolate(); # uncomment if you want to plot the path
71 |         print(path.printAsMatrix())
72 |         if not setup.haveExactSolutionPath():
73 |             print(
74 |                 "Solution is approximate. Distance to actual goal is %g"
75 |                 % setup.getProblemDefinition().getSolutionDifference()
76 |             )
77 | 
78 | 
79 | if __name__ == "__main__":
80 |     kinematicCarDemo()
81 | 


--------------------------------------------------------------------------------
/demos/SE2RigidBodyPlanning/SE2MultiRigidBodyPlanning.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 |  * Rice University Software Distribution License
 3 |  *
 4 |  * Copyright (c) 2012, Rice University
 5 |  * All Rights Reserved.
 6 |  *
 7 |  * For a full description see the file named LICENSE.
 8 |  *
 9 |  *********************************************************************/
10 | 
11 | /* Author: Ryan Luna */
12 | 
13 | #include <ompl/geometric/planners/rrt/RRTConnect.h>
14 | #include <omplapp/apps/SE2MultiRigidBodyPlanning.h>
15 | #include <omplapp/config.h>
16 | 
17 | using namespace ompl;
18 | 
19 | int main()
20 | {
21 |     // plan for two bodies in SE2
22 |     app::SE2MultiRigidBodyPlanning setup(2);
23 | 
24 |     // load the robot and the environment
25 |     std::string robot_fname = std::string(OMPLAPP_RESOURCE_DIR) + "/2D/car1_planar_robot.dae";
26 |     std::string env_fname = std::string(OMPLAPP_RESOURCE_DIR) + "/2D/Maze_planar_env.dae";
27 |     setup.setRobotMesh(robot_fname);  // The first mesh should use setRobotMesh.
28 |     setup.addRobotMesh(robot_fname);  // Subsequent robot meshes MUST use addRobotMesh!
29 |     setup.setEnvironmentMesh(env_fname);
30 | 
31 |     // constructing start and goal states
32 |     base::ScopedState<base::CompoundStateSpace> start(setup.getSpaceInformation());
33 |     base::ScopedState<base::CompoundStateSpace> goal(setup.getSpaceInformation());
34 | 
35 |     // define starting state for robot 1
36 |     auto *start1 = start->as<base::SE2StateSpace::StateType>(0);
37 |     start1->setXY(0., 0.);
38 |     start1->setYaw(0.);
39 |     // define goal state for robot 1
40 |     auto *goal1 = goal->as<base::SE2StateSpace::StateType>(0);
41 |     goal1->setXY(26., 0.);
42 |     goal1->setYaw(0.);
43 | 
44 |     // define starting state for robot 2
45 |     auto *start2 = start->as<base::SE2StateSpace::StateType>(1);
46 |     start2->setXY(26., 0.);
47 |     start2->setYaw(0.);
48 |     // define goal state for robot 2
49 |     auto *goal2 = goal->as<base::SE2StateSpace::StateType>(1);
50 |     goal2->setXY(-30., 0.);
51 |     goal2->setYaw(0.);
52 | 
53 |     // set the start & goal states
54 |     setup.setStartAndGoalStates(start, goal);
55 | 
56 |     // use RRTConnect for planning
57 |     setup.setPlanner(std::make_shared<geometric::RRTConnect>(setup.getSpaceInformation()));
58 | 
59 |     setup.setup();
60 |     setup.print(std::cout);
61 |     // attempt to solve the problem, and print it to screen if a solution is found
62 |     if (setup.solve(60))
63 |     {
64 |         setup.simplifySolution();
65 |         setup.getSolutionPath().printAsMatrix(std::cout);
66 |     }
67 | 
68 |     return 0;
69 | }
70 | 


--------------------------------------------------------------------------------
/demos/SE2RigidBodyPlanning/SE2RigidBodyPlanning.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 |  * Rice University Software Distribution License
 3 |  *
 4 |  * Copyright (c) 2010, Rice University
 5 |  * All Rights Reserved.
 6 |  *
 7 |  * For a full description see the file named LICENSE.
 8 |  *
 9 |  *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #include <omplapp/apps/SE2RigidBodyPlanning.h>
14 | #include <omplapp/config.h>
15 | 
16 | using namespace ompl;
17 | 
18 | int main()
19 | {
20 |     // plan in SE2
21 |     app::SE2RigidBodyPlanning setup;
22 | 
23 |     // load the robot and the environment
24 |     std::string robot_fname = std::string(OMPLAPP_RESOURCE_DIR) + "/2D/car1_planar_robot.dae";
25 |     std::string env_fname = std::string(OMPLAPP_RESOURCE_DIR) + "/2D/Maze_planar_env.dae";
26 |     setup.setRobotMesh(robot_fname);
27 |     setup.setEnvironmentMesh(env_fname);
28 | 
29 |     // define starting state
30 |     base::ScopedState<base::SE2StateSpace> start(setup.getSpaceInformation());
31 |     start->setX(0.0);
32 |     start->setY(0.0);
33 | 
34 |     // define goal state
35 |     base::ScopedState<base::SE2StateSpace> goal(start);
36 |     goal->setX(26.0);
37 |     goal->setY(0.0);
38 | 
39 |     // set the start & goal states
40 |     setup.setStartAndGoalStates(start, goal);
41 | 
42 |     // attempt to solve the problem, and print it to screen if a solution is found
43 |     if (setup.solve())
44 |         setup.getSolutionPath().print(std::cout);
45 | 
46 |     return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/demos/SE3RigidBodyPlanning/BlimpPlanning.cpp:
--------------------------------------------------------------------------------
  1 | /*********************************************************************
  2 |  * Rice University Software Distribution License
  3 |  *
  4 |  * Copyright (c) 2010, Rice University
  5 |  * All Rights Reserved.
  6 |  *
  7 |  * For a full description see the file named LICENSE.
  8 |  *
  9 |  *********************************************************************/
 10 | 
 11 | /* Author: Mark Moll */
 12 | 
 13 | #include <ompl/control/planners/kpiece/KPIECE1.h>
 14 | #include <ompl/control/planners/rrt/RRT.h>
 15 | #include <ompl/tools/benchmark/Benchmark.h>
 16 | #include <omplapp/apps/BlimpPlanning.h>
 17 | #include <omplapp/config.h>
 18 | 
 19 | using namespace ompl;
 20 | 
 21 | void blimpSetup(app::BlimpPlanning &setup)
 22 | {
 23 |     base::StateSpacePtr stateSpace(setup.getStateSpace());
 24 | 
 25 |     // set the bounds for the R^3 part of SE(3)
 26 |     base::RealVectorBounds bounds(3);
 27 |     bounds.setLow(-10);
 28 |     bounds.setHigh(10);
 29 |     stateSpace->as<base::CompoundStateSpace>()->as<base::SE3StateSpace>(0)->setBounds(bounds);
 30 | 
 31 |     // define start state
 32 |     base::ScopedState<base::SE3StateSpace> start(setup.getGeometricComponentStateSpace());
 33 |     start->setX(0.);
 34 |     start->setY(0.);
 35 |     start->setZ(0.);
 36 |     start->rotation().setIdentity();
 37 | 
 38 |     // define goal state
 39 |     base::ScopedState<base::SE3StateSpace> goal(setup.getGeometricComponentStateSpace());
 40 |     goal->setX(5.);
 41 |     goal->setY(5.);
 42 |     goal->setZ(5.);
 43 |     goal->rotation().setIdentity();
 44 | 
 45 |     // set the start & goal states
 46 |     setup.setStartAndGoalStates(setup.getFullStateFromGeometricComponent(start),
 47 |                                 setup.getFullStateFromGeometricComponent(goal), .5);
 48 | }
 49 | 
 50 | void blimpDemo(app::BlimpPlanning &setup)
 51 | {
 52 |     std::vector<double> coords;
 53 | 
 54 |     std::cout << "\n\n***** Planning for a " << setup.getName() << " *****\n" << std::endl;
 55 |     setup.setPlanner(std::make_shared<control::RRT>(setup.getSpaceInformation()));
 56 | 
 57 |     // try to solve the problem
 58 |     if (setup.solve(40))
 59 |     {
 60 |         // print the (approximate) solution path: print states along the path
 61 |         // and controls required to get from one state to the next
 62 |         control::PathControl &path(setup.getSolutionPath());
 63 |         path.interpolate();  // uncomment if you want to plot the path
 64 |         path.printAsMatrix(std::cout);
 65 | 
 66 |         if (!setup.haveExactSolutionPath())
 67 |         {
 68 |             std::cout << "Solution is approximate. Distance to actual goal is "
 69 |                       << setup.getProblemDefinition()->getSolutionDifference() << std::endl;
 70 |         }
 71 |     }
 72 | }
 73 | 
 74 | void blimpBenchmark(app::BlimpPlanning &setup)
 75 | {
 76 |     tools::Benchmark::Request request(100., 10000., 10);  // runtime (s), memory (MB), run count
 77 | 
 78 |     setup.setup();
 79 | 
 80 |     tools::Benchmark b(setup, setup.getName());
 81 |     b.addPlanner(std::make_shared<control::RRT>(setup.getSpaceInformation()));
 82 |     b.addPlanner(std::make_shared<control::KPIECE1>(setup.getSpaceInformation()));
 83 |     b.benchmark(request);
 84 |     b.saveResultsToFile();
 85 | }
 86 | 
 87 | int main(int argc, char ** /*unused*/)
 88 | {
 89 |     app::BlimpPlanning blimp;
 90 |     blimpSetup(blimp);
 91 | 
 92 |     // If any command line arguments are given, solve the problem multiple
 93 |     // times with different planners and collect benchmark statistics.
 94 |     // Otherwise, solve the problem once and print the path.
 95 |     if (argc > 1)
 96 |         blimpBenchmark(blimp);
 97 |     else
 98 |         blimpDemo(blimp);
 99 |     return 0;
100 | }
101 | 


--------------------------------------------------------------------------------
/demos/SE3RigidBodyPlanning/QuadrotorPlanning.cpp:
--------------------------------------------------------------------------------
  1 | /*********************************************************************
  2 |  * Rice University Software Distribution License
  3 |  *
  4 |  * Copyright (c) 2010, Rice University
  5 |  * All Rights Reserved.
  6 |  *
  7 |  * For a full description see the file named LICENSE.
  8 |  *
  9 |  *********************************************************************/
 10 | 
 11 | /* Author: Mark Moll */
 12 | 
 13 | #include <ompl/control/planners/kpiece/KPIECE1.h>
 14 | #include <ompl/control/planners/rrt/RRT.h>
 15 | #include <ompl/tools/benchmark/Benchmark.h>
 16 | #include <omplapp/apps/QuadrotorPlanning.h>
 17 | #include <omplapp/config.h>
 18 | 
 19 | using namespace ompl;
 20 | 
 21 | void quadrotorSetup(app::QuadrotorPlanning &setup)
 22 | {
 23 |     base::StateSpacePtr stateSpace(setup.getStateSpace());
 24 | 
 25 |     // set the bounds for the R^3 part of SE(3)
 26 |     base::RealVectorBounds bounds(3);
 27 |     bounds.setLow(-10);
 28 |     bounds.setHigh(10);
 29 |     stateSpace->as<base::CompoundStateSpace>()->as<base::SE3StateSpace>(0)->setBounds(bounds);
 30 | 
 31 |     // define start state
 32 |     base::ScopedState<base::SE3StateSpace> start(setup.getGeometricComponentStateSpace());
 33 |     start->setX(0.);
 34 |     start->setY(0.);
 35 |     start->setZ(0.);
 36 |     start->rotation().setIdentity();
 37 | 
 38 |     // define goal state
 39 |     base::ScopedState<base::SE3StateSpace> goal(setup.getGeometricComponentStateSpace());
 40 |     goal->setX(5.);
 41 |     goal->setY(5.);
 42 |     goal->setZ(5.);
 43 |     goal->rotation().setIdentity();
 44 | 
 45 |     // set the start & goal states
 46 |     setup.setStartAndGoalStates(setup.getFullStateFromGeometricComponent(start),
 47 |                                 setup.getFullStateFromGeometricComponent(goal), .5);
 48 | }
 49 | 
 50 | void quadrotorDemo(app::QuadrotorPlanning &setup)
 51 | {
 52 |     std::vector<double> coords;
 53 | 
 54 |     std::cout << "\n\n***** Planning for a " << setup.getName() << " *****\n" << std::endl;
 55 |     setup.setPlanner(std::make_shared<control::RRT>(setup.getSpaceInformation()));
 56 | 
 57 |     // try to solve the problem
 58 |     if (setup.solve(40))
 59 |     {
 60 |         // print the (approximate) solution path: print states along the path
 61 |         // and controls required to get from one state to the next
 62 |         control::PathControl &path(setup.getSolutionPath());
 63 |         // path.interpolate(); // uncomment if you want to plot the path
 64 |         path.printAsMatrix(std::cout);
 65 | 
 66 |         if (!setup.haveExactSolutionPath())
 67 |         {
 68 |             std::cout << "Solution is approximate. Distance to actual goal is "
 69 |                       << setup.getProblemDefinition()->getSolutionDifference() << std::endl;
 70 |         }
 71 |     }
 72 | }
 73 | 
 74 | void quadrotorBenchmark(app::QuadrotorPlanning &setup)
 75 | {
 76 |     tools::Benchmark::Request request(100., 10000., 10);  // runtime (s), memory (MB), run count
 77 | 
 78 |     setup.setup();
 79 | 
 80 |     tools::Benchmark b(setup, setup.getName());
 81 |     b.addPlanner(std::make_shared<control::RRT>(setup.getSpaceInformation()));
 82 |     b.addPlanner(std::make_shared<control::KPIECE1>(setup.getSpaceInformation()));
 83 |     b.benchmark(request);
 84 |     b.saveResultsToFile();
 85 | }
 86 | 
 87 | int main(int argc, char ** /*unused*/)
 88 | {
 89 |     app::QuadrotorPlanning quadrotor;
 90 |     quadrotorSetup(quadrotor);
 91 | 
 92 |     // If any command line arguments are given, solve the problem multiple
 93 |     // times with different planners and collect benchmark statistics.
 94 |     // Otherwise, solve the problem once and print the path.
 95 |     if (argc > 1)
 96 |         quadrotorBenchmark(quadrotor);
 97 |     else
 98 |         quadrotorDemo(quadrotor);
 99 |     return 0;
100 | }
101 | 


--------------------------------------------------------------------------------
/demos/SE3RigidBodyPlanning/SE3MultiRigidBodyPlanning.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 |  * Rice University Software Distribution License
 3 |  *
 4 |  * Copyright (c) 2012, Rice University
 5 |  * All Rights Reserved.
 6 |  *
 7 |  * For a full description see the file named LICENSE.
 8 |  *
 9 |  *********************************************************************/
10 | 
11 | /* Author: Ryan Luna */
12 | 
13 | #include <ompl/geometric/planners/rrt/RRTConnect.h>
14 | #include <omplapp/apps/AppBase.h>
15 | #include <omplapp/apps/SE3MultiRigidBodyPlanning.h>
16 | #include <omplapp/config.h>
17 | 
18 | using namespace ompl;
19 | 
20 | int main()
21 | {
22 |     // plan for 2 rigid bodies in SE3
23 |     app::SE3MultiRigidBodyPlanning setup(2);
24 | 
25 |     // load the robot and the environment
26 |     std::string robot_fname = std::string(OMPLAPP_RESOURCE_DIR) + "/3D/cubicles_robot.dae";
27 |     std::string env_fname = std::string(OMPLAPP_RESOURCE_DIR) + "/3D/cubicles_env.dae";
28 |     setup.setRobotMesh(robot_fname);  // The first mesh should use setRobotMesh.
29 |     setup.addRobotMesh(robot_fname);  // Subsequent robot meshes MUST use addRobotMesh!
30 |     setup.setEnvironmentMesh(env_fname);
31 | 
32 |     // constructing start and goal states
33 |     base::ScopedState<base::CompoundStateSpace> start(setup.getSpaceInformation());
34 |     base::ScopedState<base::CompoundStateSpace> goal(setup.getSpaceInformation());
35 | 
36 |     auto *start1 = start->as<base::SE3StateSpace::StateType>(0);
37 |     // define start state (robot 1)
38 |     start1->setX(-4.96);
39 |     start1->setY(-40.62);
40 |     start1->setZ(70.57);
41 |     start1->rotation().setIdentity();
42 | 
43 |     // define goal state (robot 1)
44 |     auto *goal1 = goal->as<base::SE3StateSpace::StateType>(0);
45 |     goal1->setX(200.49);
46 |     goal1->setY(-40.62);
47 |     goal1->setZ(70.57);
48 |     goal1->rotation().setIdentity();
49 | 
50 |     auto *start2 = start->as<base::SE3StateSpace::StateType>(1);
51 |     // define start state (robot 2)
52 |     start2->setX(200.49);
53 |     start2->setY(-40.62);
54 |     start2->setZ(70.57);
55 |     start2->rotation().setIdentity();
56 | 
57 |     // define goal state (robot 2)
58 |     auto *goal2 = goal->as<base::SE3StateSpace::StateType>(1);
59 |     goal2->setX(-4.96);
60 |     goal2->setY(-40.62);
61 |     goal2->setZ(70.57);
62 |     goal2->rotation().setIdentity();
63 | 
64 |     // set the start & goal states
65 |     setup.setStartAndGoalStates(start, goal);
66 | 
67 |     // setting collision checking resolution to 1% of the space extent
68 |     setup.getSpaceInformation()->setStateValidityCheckingResolution(0.01);
69 | 
70 |     // use RRTConnect for planning
71 |     setup.setPlanner(std::make_shared<geometric::RRTConnect>(setup.getSpaceInformation()));
72 | 
73 |     // we call setup just so print() can show more information
74 |     setup.setup();
75 |     setup.print();
76 | 
77 |     // try to solve the problem
78 |     if (setup.solve(30))
79 |     {
80 |         if (setup.haveExactSolutionPath())
81 |         {
82 |             // simplify & print the solution
83 |             setup.simplifySolution();
84 |             setup.getSolutionPath().printAsMatrix(std::cout);
85 |         }
86 |         else
87 |         {
88 |             std::cout << "Exact solution not found" << std::endl;
89 |         }
90 |     }
91 | 
92 |     return 0;
93 | }
94 | 


--------------------------------------------------------------------------------
/demos/SE3RigidBodyPlanning/SE3MultiRigidBodyPlanning.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | ######################################################################
 4 | # Rice University Software Distribution License
 5 | #
 6 | # Copyright (c) 2012, Rice University
 7 | # All Rights Reserved.
 8 | #
 9 | # For a full description see the file named LICENSE.
10 | #
11 | ######################################################################
12 | 
13 | # Author: Ryan Luna
14 | 
15 | import sys
16 | from os.path import abspath, dirname, join
17 | 
18 | ompl_app_root = dirname(dirname(dirname(abspath(__file__))))
19 | 
20 | try:
21 |     from ompl import base as ob
22 |     from ompl import geometric as og
23 |     from ompl import app as oa
24 | except ImportError:
25 |     sys.path.insert(0, join(ompl_app_root, 'ompl/py-bindings'))
26 |     from ompl import base as ob
27 |     from ompl import geometric as og
28 |     from ompl import app as oa
29 | 
30 | # plan in SE(3) for two robots
31 | setup = oa.SE3MultiRigidBodyPlanning(2)
32 | 
33 | # load the robots and the environment
34 | setup.setRobotMesh('3D/cubicles_robot.dae')
35 | setup.addRobotMesh('3D/cubicles_robot.dae')
36 | setup.setEnvironmentMesh('3D/cubicles_env.dae')
37 | 
38 | # define start state
39 | start = ob.State(setup.getSpaceInformation())
40 | # set start for robot 1
41 | start1 = start()[0]
42 | start1.setX(-4.96)
43 | start1.setY(-40.62)
44 | start1.setZ(70.57)
45 | start1.rotation().setIdentity()
46 | # set start for robot 2
47 | start2 = start()[1]
48 | start2.setX(200.49)
49 | start2.setY(-40.62)
50 | start2.setZ(70.57)
51 | start2.rotation().setIdentity()
52 | 
53 | # define goal state
54 | goal = ob.State(setup.getSpaceInformation())
55 | # set goal for robot 1
56 | goal1 = goal()[0]
57 | goal1.setX(200.49)
58 | goal1.setY(-40.62)
59 | goal1.setZ(70.57)
60 | goal1.rotation().setIdentity()
61 | # set goal for robot 2
62 | goal2 = goal()[1]
63 | goal2.setX(-4.96)
64 | goal2.setY(-40.62)
65 | goal2.setZ(70.57)
66 | goal2.rotation().setIdentity()
67 | 
68 | # set the start & goal states
69 | setup.setStartAndGoalStates(start, goal)
70 | 
71 | # setting collision checking resolution to 1% of the space extent
72 | setup.getSpaceInformation().setStateValidityCheckingResolution(0.01)
73 | 
74 | # use RRTConnect for planning
75 | setup.setPlanner(og.RRTConnect(setup.getSpaceInformation()))
76 | 
77 | # we call setup just so print() can show more information
78 | setup.setup()
79 | print(setup)
80 | 
81 | # try to solve the problem
82 | if setup.solve(60):
83 |     # simplify & print the solution
84 |     setup.simplifySolution()
85 |     print(setup.getSolutionPath().printAsMatrix())
86 | 


--------------------------------------------------------------------------------
/demos/SE3RigidBodyPlanning/SE3RigidBodyPlanning.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 |  * Rice University Software Distribution License
 3 |  *
 4 |  * Copyright (c) 2010, Rice University
 5 |  * All Rights Reserved.
 6 |  *
 7 |  * For a full description see the file named LICENSE.
 8 |  *
 9 |  *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #include <omplapp/apps/SE3RigidBodyPlanning.h>
14 | #include <omplapp/config.h>
15 | 
16 | using namespace ompl;
17 | 
18 | int main()
19 | {
20 |     // plan in SE3
21 |     app::SE3RigidBodyPlanning setup;
22 | 
23 |     // load the robot and the environment
24 |     std::string robot_fname = std::string(OMPLAPP_RESOURCE_DIR) + "/3D/cubicles_robot.dae";
25 |     std::string env_fname = std::string(OMPLAPP_RESOURCE_DIR) + "/3D/cubicles_env.dae";
26 |     setup.setRobotMesh(robot_fname);
27 |     setup.setEnvironmentMesh(env_fname);
28 | 
29 |     // define start state
30 |     base::ScopedState<base::SE3StateSpace> start(setup.getSpaceInformation());
31 |     start->setX(-4.96);
32 |     start->setY(-40.62);
33 |     start->setZ(70.57);
34 |     start->rotation().setIdentity();
35 | 
36 |     // define goal state
37 |     base::ScopedState<base::SE3StateSpace> goal(start);
38 |     goal->setX(200.49);
39 |     goal->setY(-40.62);
40 |     goal->setZ(70.57);
41 |     goal->rotation().setIdentity();
42 | 
43 |     // set the start & goal states
44 |     setup.setStartAndGoalStates(start, goal);
45 | 
46 |     // setting collision checking resolution to 1% of the space extent
47 |     setup.getSpaceInformation()->setStateValidityCheckingResolution(0.01);
48 | 
49 |     // we call setup just so print() can show more information
50 |     setup.setup();
51 |     setup.print();
52 | 
53 |     // try to solve the problem
54 |     if (setup.solve(10))
55 |     {
56 |         // simplify & print the solution
57 |         setup.simplifySolution();
58 |         setup.getSolutionPath().printAsMatrix(std::cout);
59 |     }
60 | 
61 |     return 0;
62 | }
63 | 


--------------------------------------------------------------------------------
/demos/SE3RigidBodyPlanning/SE3RigidBodyPlanning.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | ######################################################################
 4 | # Rice University Software Distribution License
 5 | #
 6 | # Copyright (c) 2010, Rice University
 7 | # All Rights Reserved.
 8 | #
 9 | # For a full description see the file named LICENSE.
10 | #
11 | ######################################################################
12 | 
13 | # Author: Mark Moll
14 | 
15 | import sys
16 | from os.path import abspath, dirname, join
17 | 
18 | ompl_app_root = dirname(dirname(dirname(abspath(__file__))))
19 | 
20 | try:
21 |     from ompl import base as ob
22 |     from ompl import app as oa
23 | except ImportError:
24 |     sys.path.insert(0, join(ompl_app_root, 'ompl/py-bindings'))
25 |     from ompl import base as ob
26 |     from ompl import app as oa
27 | 
28 | # plan in SE(3)
29 | setup = oa.SE3RigidBodyPlanning()
30 | 
31 | # load the robot and the environment
32 | setup.setRobotMesh('3D/cubicles_robot.dae')
33 | setup.setEnvironmentMesh('3D/cubicles_env.dae')
34 | 
35 | # define start state
36 | start = ob.State(setup.getSpaceInformation())
37 | start().setX(-4.96)
38 | start().setY(-40.62)
39 | start().setZ(70.57)
40 | start().rotation().setIdentity()
41 | 
42 | goal = ob.State(setup.getSpaceInformation())
43 | goal().setX(200.49)
44 | goal().setY(-40.62)
45 | goal().setZ(70.57)
46 | goal().rotation().setIdentity()
47 | 
48 | # set the start & goal states
49 | setup.setStartAndGoalStates(start, goal)
50 | 
51 | # setting collision checking resolution to 1% of the space extent
52 | setup.getSpaceInformation().setStateValidityCheckingResolution(0.01)
53 | 
54 | # we call setup just so print() can show more information
55 | setup.setup()
56 | print(setup)
57 | 
58 | # try to solve the problem
59 | if setup.solve(10):
60 |     # simplify & print the solution
61 |     setup.simplifySolution()
62 |     path = setup.getSolutionPath()
63 |     path.interpolate(10)
64 |     print(path.printAsMatrix())
65 |     print(path.check())
66 | 


--------------------------------------------------------------------------------
/doc/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | install(FILES man/ompl_benchmark.1 man/ompl_app.1 man/ompl_webapp.1
 2 |     DESTINATION ${CMAKE_INSTALL_MANDIR}/man1 COMPONENT omplapp)
 3 | 
 4 | if(DOXYGEN_FOUND AND NOT CMAKE_VERSION VERSION_LESS 3.9)
 5 |     configure_file("${CMAKE_CURRENT_SOURCE_DIR}/markdown/download.md.in"
 6 |         "${CMAKE_BINARY_DIR}/doc/omplapp_download.md")
 7 | 
 8 |     include(DoxygenSettings)
 9 |     set(DOXYGEN_EXCLUDE
10 |         "${CMAKE_SOURCE_DIR}/ompl/doc/markdown/installation.md"
11 |         "${CMAKE_BINARY_DIR}/doc/ompl_download.md"
12 |         "${CMAKE_SOURCE_DIR}/ompl/doc/markdown/license.md"
13 |         "${CMAKE_SOURCE_DIR}/ompl/doc/markdown/releaseNotes.md")
14 |     set(DOXYGEN_EXAMPLE_PATH
15 |         "${CMAKE_SOURCE_DIR}/ompl/demos"
16 |         "${CMAKE_SOURCE_DIR}/demos"
17 |         "${CMAKE_SOURCE_DIR}/ompl/doc/markdown/code")
18 |     set(DOXYGEN_HTML_HEADER "${CMAKE_SOURCE_DIR}/ompl/doc/header.html")
19 |     set(DOXYGEN_HTML_FOOTER "${CMAKE_SOURCE_DIR}/ompl/doc/footer.html")
20 |     set(DOXYGEN_HTML_OUTPUT "${CMAKE_BINARY_DIR}/omplapp_doc")
21 |     set(DOXYGEN_GENERATE_TAGFILE "${DOXYGEN_HTML_OUTPUT}/ompl.tag")
22 |     set(DOXYGEN_ENABLED_SECTIONS "OMPLAPP")
23 | 
24 |     doxygen_add_docs(omplapp_doc
25 |         "${CMAKE_SOURCE_DIR}/doc/markdown"
26 |         "${CMAKE_SOURCE_DIR}/demos"
27 |         "${CMAKE_SOURCE_DIR}/src/omplapp"
28 |         "${CMAKE_SOURCE_DIR}/ompl/doc/markdown"
29 |         "${CMAKE_SOURCE_DIR}/ompl/demos"
30 |         "${CMAKE_SOURCE_DIR}/ompl/src/ompl"
31 |         "${CMAKE_BINARY_DIR}/doc"
32 |         WORKING_DIRECTORY "${CMAKE_BINARY_DIR}")
33 |     # hide content that is relevant to OMPL core library only
34 |     set(OMPL_CSS ".ompl{display:none;}")
35 |     configure_file("${CMAKE_SOURCE_DIR}/ompl/doc/ompl.css" "${DOXYGEN_HTML_OUTPUT}/ompl.css")
36 |     add_custom_command(TARGET omplapp_doc POST_BUILD
37 |         COMMAND cp -r images ieee-ram-2012-ompl.pdf "${CMAKE_SOURCE_DIR}/doc/images" "${CMAKE_BINARY_DIR}/install-ompl-ubuntu.sh" "${DOXYGEN_HTML_OUTPUT}"
38 |         WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/ompl/doc")
39 | 
40 |     # use latexmk to create the OMPL primer PDF
41 |     find_program(LATEXMK latexmk)
42 |     if (LATEXMK)
43 |         add_custom_command(TARGET omplapp_doc POST_BUILD
44 |             COMMAND "BIBINPUTS=${CMAKE_CURRENT_SOURCE_DIR}/latex/bib" openout_any=a latexmk -gg -pdf "-outdir=${DOXYGEN_HTML_OUTPUT}" OMPL_Primer.tex
45 |             COMMAND latexmk -c -pdf "-outdir=${DOXYGEN_HTML_OUTPUT}" OMPL_Primer.tex
46 |             WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/latex")
47 |     endif()
48 | 
49 |     add_custom_target(website
50 |         COMMAND rsync -a omplapp_doc/ "$ENV{HOME}/src/ompl.github.io"
51 |         COMMAND rsync -a ompl_doc/ "$ENV{HOME}/src/ompl.github.io/core"
52 |         WORKING_DIRECTORY "${CMAKE_BINARY_DIR}")
53 |     add_dependencies(website omplapp_doc ompl_doc)
54 | endif()
55 | 


--------------------------------------------------------------------------------
/doc/images/gui_bbox.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/images/gui_bbox.png


--------------------------------------------------------------------------------
/doc/images/gui_define.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/images/gui_define.png


--------------------------------------------------------------------------------
/doc/images/gui_path.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/images/gui_path.png


--------------------------------------------------------------------------------
/doc/images/gui_planner.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/images/gui_planner.png


--------------------------------------------------------------------------------
/doc/latex/Ch1_Introduction.tex:
--------------------------------------------------------------------------------
 1 | \chapter{Introduction}
 2 | 
 3 | This document explains how the Open Motion Planning Library (OMPL) implements
 4 | the basic primitives of sampling-based motion planning, what planners are
 5 | already available in OMPL, and how to use the library to build new planners.
 6 | This primer is segmented into the following sections: An introduction to
 7 | sampling-based motion planning, a guide to setup OMPL for solving motion
 8 | planning queries using OMPL.app, a description of the motion planning
 9 | primitives in OMPL to develop your own planner, and an explanation of
10 | some advanced OMPL topics.
11 | 
12 | At the end of this document, users should be able to use OMPL.app to solve
13 | motion planning queries in 2D and 3D workspaces, and utilize the OMPL framework
14 | to develop their own algorithms for state sampling, collision checking, nearest
15 | neighbor searching, and other components of sampling-based methods to build
16 | a new planner.
17 | 
18 | 
19 | \section {Prerequisites for Using OMPL}
20 | This primer assumes that users are familiar with C++ programming and compiling
21 | code in a Unix environment.  Additionally, users should have basic knowledge of
22 | sampling-based motion planning.  OMPL and OMPL.app should also be installed.
23 | For information regarding the installation process, please see
24 | {\tt ompl.kavrakilab.org}.
25 | 
26 | 


--------------------------------------------------------------------------------
/doc/latex/Makefile:
--------------------------------------------------------------------------------
 1 | export BIBINPUTS=.:./bib:$BIBINPUTS::
 2 | 
 3 | all:    primer
 4 | 
 5 | primer:
 6 | 	pdflatex OMPL_Primer.tex
 7 | 	bibtex OMPL_Primer.aux
 8 | 	pdflatex OMPL_Primer.tex
 9 | 	pdflatex OMPL_Primer.tex
10 | 
11 | clean:
12 | 	rm -f OMPL_Primer.{aux,bbl,blg,log,toc}
13 | 
14 | 


--------------------------------------------------------------------------------
/doc/latex/OMPL_Primer.tex:
--------------------------------------------------------------------------------
 1 | \documentclass [letterpaper,12pt]{report}
 2 | 
 3 | \usepackage {graphicx}
 4 | \usepackage {times}
 5 | \usepackage {fancyhdr}
 6 | \usepackage[hmargin=1in,vmargin=1.25in]{geometry}
 7 | \usepackage {mathptmx, amsfonts}
 8 | \usepackage [chapter]{algorithm}
 9 | \usepackage [noend]{algorithmic}
10 | \usepackage {url}
11 | \usepackage[T1]{fontenc}
12 | \usepackage {verbatim}
13 | \usepackage {microtype}
14 | \usepackage[labelfont=bf]{caption}
15 | \pagestyle {fancy}
16 | \graphicspath{{./images/}}
17 | \begin {document}
18 | 
19 | % Setup header and footer
20 | \fancyhf{} % clear all fields
21 | \fancyfoot[R]{Open Motion Planning Library : A Primer $\|$ \thepage}
22 | \renewcommand{\chaptermark}[1]{\markboth{\chaptername\ \thechapter.\ #1}{}}
23 | \fancyhead[C]{\leftmark}
24 | 
25 | % Inserting title page
26 | \input {TitlePage}
27 | 
28 | % Generate Table of Contents with roman numeral page numbering
29 | \newpage
30 | \pagenumbering{roman}
31 | \tableofcontents
32 | 
33 | % Ensure the rest of the document has arabic numerals
34 | \newpage
35 | \pagenumbering{arabic}
36 | 
37 | \input {Ch1_Introduction}
38 | 
39 | \input {Ch2_Introduction}
40 | 
41 | \input {Ch3_GetStarted}
42 | 
43 | \input {Ch4_UsingOMPL}
44 | 
45 | \input {Ch5_AdvancedOMPL}
46 | 
47 | \bibliographystyle {unsrt}
48 | \bibliography {Primer}
49 | 
50 | \end {document}
51 | 
52 | 


--------------------------------------------------------------------------------
/doc/latex/TitlePage.tex:
--------------------------------------------------------------------------------
 1 | \begin{titlepage}
 2 | 
 3 | \begin{center}
 4 | 
 5 | 
 6 | % Upper part of the page
 7 | 
 8 | \begin {figure}
 9 | \centering
10 | \includegraphics[width=2.5in]{RiceLogo}
11 | \end{figure}
12 | \vspace {0.25in}
13 | \rule{\linewidth}{0.1mm}
14 | \vspace {0.25in}
15 | 
16 | % Title
17 | { \huge \bfseries Open Motion Planning Library:\\ A Primer}
18 | \\ [0.50in]
19 | {\Large Kavraki Lab\\
20 | Rice University
21 | }
22 | \\ [0.1in]
23 | {\tt ompl.kavrakilab.org}
24 | 
25 | %\HRule \\[1.5cm]
26 | 
27 | \vfill
28 | 
29 | {\large \today}
30 | 
31 | \end{center}
32 | 
33 | \end{titlepage}
34 | 


--------------------------------------------------------------------------------
/doc/latex/bib/Primer.bib:
--------------------------------------------------------------------------------
  1 | @book{Latombe:1991,
  2 |   author    = {Latombe, Jean-Claude},
  3 |   title     = {Robot Motion Planning},
  4 |   year      = {1991},
  5 |   isbn      = {079239206X},
  6 |   publisher = {Kluwer Academic Publishers},
  7 |   address   = {Norwell, MA, USA},
  8 | }
  9 | 
 10 | @book{Choset:2005,
 11 |   author    = "Howie Choset and Kevin M. Lynch and Seth Hutchinson and George A Kantor and Wolfram Burgard and Lydia E. Kavraki and Sebastian Thrun",
 12 |   title     = "Principles of Robot Motion: Theory, Algorithms, and Implementations",
 13 |   publisher = "MIT Press",
 14 |   address   = "Cambridge, MA",
 15 |   month     = "June",
 16 |   year      = "2005",
 17 | }
 18 | 
 19 | @book{LaValle:2006,
 20 |   author    = {LaValle, Steven M.},
 21 |   title     = {Planning Algorithms},
 22 |   year      = {2006},
 23 |   isbn      = {0521862051},
 24 |   publisher = {Cambridge University Press},
 25 |   address   = {New York, NY, USA},
 26 | }
 27 | 
 28 | @article{Kavraki:1996,
 29 |    author   = {Lydia E. Kavraki and Petr Svestka and Jean-Claude Latombe and Mark H. Overmars},
 30 |    title    = {Probabilistic Roadmaps for Path Planning in High-Dimensional Configuration Spaces},
 31 |    journal  = {IEEE Transactions on Robotics and Automation},
 32 |    year     = {1996},
 33 |    volume   = {12},
 34 |    number   = {4},
 35 |    pages    = {566--580}
 36 | }
 37 | 
 38 | @article{LaValle:2001,
 39 |    author   = {Steven M. LaValle and James J. Kuffner},
 40 |    title    = {Randomized Kinodynamic Planning},
 41 |    journal  = {International Journal of Robotics Research},
 42 |    year     = {2001},
 43 |    volume   = {17},
 44 |    number   = {5},
 45 |    pages    = {378--400}
 46 | }
 47 | 
 48 | @article{Hsu:1999,
 49 |   author    = {David Hsu and Jean-Claude Latombe and Rajeev Motwani},
 50 |   title     = {Path Planning in Expansive Configuration Spaces},
 51 |   journal   = {International Journal of Computational Geometry and Applications},
 52 |   volume    = {9},
 53 |   number    = {4/5},
 54 |   year      = {1999},
 55 |   pages     = {495-512},
 56 | }
 57 | 
 58 | @incollection{Sanchez:2003,
 59 |   author    = {Gildardo Sanchez and Jean-Claude Latombe},
 60 |   title     = {A Single-Query Bi-Directional Probabilistic Roadmap Planner with Lazy Collision Checking},
 61 |   booktitle = {Robotics Research},
 62 |   series    = {Springer Tracts in Advanced Robotics},
 63 |   pages     = {403-417},
 64 |   volume    = {6},
 65 |   year      = {2003}
 66 | }
 67 | 
 68 | @article{Sucan:2011,
 69 |   author    = {Ioan \c{S}ucan and Lydia E. Kavraki},
 70 |   journal   = {IEEE Transactions on Robotics},
 71 |   title     = {A Sampling-Based Tree Planner for Systems With Complex Dynamics},
 72 |   volume    = {28},
 73 |   number    = {1},
 74 |   pages     = {116-131},
 75 |   year      = {2012},
 76 | }
 77 | 
 78 | @inproceedings{Larsen:2000,
 79 |   author    = {Eric Larsen and Stefan Gottschalk and Ming C. Lin and Dinesh Manocha},
 80 |   title     = {Fast Proximity Queries with Swept Sphere Volumes},
 81 |   booktitle = {IEEE International Conference on Robotics and Automation},
 82 |   pages     = {3719--3726},
 83 |   year      = {2000},
 84 | }
 85 | 
 86 | @inproceedings{Jia:2011,
 87 |   author    = {Jia Pan and Sachin Chitta and Dinesh Manocha},
 88 |   title     = {{FCL}: A General Purpose Library for Collision and Proximity Queries},
 89 |   booktitle = {IEEE International Conference on Robotics and Automation},
 90 |   month     = {May},
 91 |   year      = {2012},
 92 | }
 93 | 
 94 | 
 95 | @inproceedings{Brin:1995,
 96 |     Abstract = {Given user data, one often wants to find approximate matches in a large database. A good example of such a task is finding images similar to a given image in a large collection of images. We focus on the important and technically difficult case where each data element is high dimensional, or more generally, is represented by a point in a large metric space- and distance calculations are computationally expensive. In this paper we introduce a data structure to solve this problem called a GNAT - Geometric Near-neighbor Access Tree. It is based on the philosophy that the data structure should act as a hierarchical geometrical model of the data as opposed to a simple decomposition of the data that does not use its intrinsic geometry. In experiments, we find that GNAT's outperform previous data structures in a number of applications.},
 97 |     Author = {Sergey Brin},
 98 |     Booktitle = {Proc.\ 21st Conf. on Very Large Databases},
 99 |     Keywords = {near neighbor, metric space, approximate queries, data mining, Dirichlet domains, Voronoi regions},
100 |     Pages = {574--584},
101 |     Title = {Near Neighbor Search in Large Metric Spaces},
102 |     Year = 1995}
103 | 
104 | @misc {Boost,
105 |   howpublished = {\url{http://www.boost.org/}},
106 | }
107 | 


--------------------------------------------------------------------------------
/doc/latex/images/RiceLogo.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/RiceLogo.jpg


--------------------------------------------------------------------------------
/doc/latex/images/cubicles_time.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/cubicles_time.png


--------------------------------------------------------------------------------
/doc/latex/images/localplanner.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/localplanner.png


--------------------------------------------------------------------------------
/doc/latex/images/ompl_hierarchy.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/ompl_hierarchy.pdf


--------------------------------------------------------------------------------
/doc/latex/images/omplapp_easy.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/omplapp_easy.png


--------------------------------------------------------------------------------
/doc/latex/images/omplapp_easy_sln.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/omplapp_easy_sln.png


--------------------------------------------------------------------------------
/doc/latex/images/omplapp_start.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/omplapp_start.png


--------------------------------------------------------------------------------
/doc/latex/images/query.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/query.png


--------------------------------------------------------------------------------
/doc/latex/images/samples.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/samples.png


--------------------------------------------------------------------------------
/doc/latex/images/state.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/state.png


--------------------------------------------------------------------------------
/doc/latex/images/tree-start.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/tree-start.png


--------------------------------------------------------------------------------
/doc/latex/images/tree_badgoal.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/tree_badgoal.png


--------------------------------------------------------------------------------
/doc/latex/images/tree_goal.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/tree_goal.png


--------------------------------------------------------------------------------
/doc/latex/images/twistycool_solved.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/doc/latex/images/twistycool_solved.png


--------------------------------------------------------------------------------
/doc/man/ompl_app.1:
--------------------------------------------------------------------------------
 1 | .TH OMPL_APP 1
 2 | .SH NAME
 3 | ompl_app \- GUI for solving simple motion planning problems
 4 | .SH SYNOPSIS
 5 | .B ompl_app
 6 | .SH DESCRIPTION
 7 | .BR ompl_app
 8 | is a GUI that allows a user to (1) define a motion planning
 9 | problem, (2) specify a planning algorithm and its parameters to solve the
10 | problem, and (3) visualize the solution. A motion planning problem is defined
11 | by specifying a robot type (free-flying rigid body in 2D or 3D, a car-like
12 | robot, etc.), a mesh representing the environment, another mesh representing
13 | the robot, and start/goal states for the robot. Almost all planners in ompl
14 | and all their corresponding parameters are accessible through the GUI.
15 | .SH SEE ALSO
16 | .BR ompl_benchmark(1)
17 | 


--------------------------------------------------------------------------------
/doc/man/ompl_benchmark.1:
--------------------------------------------------------------------------------
 1 | .TH OMPL_BENCHMARK 1
 2 | .SH NAME
 3 | ompl_benchmark \- benchmark a motion planning problem with ompl planners
 4 | .SH SYNOPSIS
 5 | .B ompl_benchmark problem.cfg
 6 | .SH DESCRIPTION
 7 | .BR ompl_benchmark
 8 | is a program that parses a YAML configuration file that
 9 | specifies a motion planning problem, a list of planner configurations, and
10 | some general benchmark
11 | parameters. The program repeatedly tries to solve the motion planning problem
12 | with each of the planners. It collects various performance metrics which are
13 | saved in a log file. The resulting log file can be processed by
14 | .BR ompl_benchmark_statistics(1)
15 | to create an SQL database and a PDF containing a series of plots that
16 | aggregate the measurements. The YAML configuration files can also be read by
17 | the
18 | .BR ompl_app
19 | GUI, but the GUI only reads the definition of the motion planning problem.
20 | .SH SEE ALSO
21 | .B ompl_benchmark_statistics(1), ompl_app(1), plannerarena(1)
22 | 


--------------------------------------------------------------------------------
/doc/man/ompl_webapp.1:
--------------------------------------------------------------------------------
 1 | .TH OMPL_BENCHMARK 1
 2 | .SH NAME
 3 | ompl_webapp \- start the OMPL web app
 4 | .SH SYNOPSIS
 5 | .B ompl_webapp
 6 | .SH DESCRIPTION
 7 | .BR ompl_webapp
 8 | is a script that launches the OMPL web app server locally. It should look
 9 | similar to http://omplapp.kavrakilab.org. By default, the server can be
10 | accessed by visiting http://127.0.0.1:5000 in your browser.
11 | .SH SEE ALSO
12 | .B ompl_conf(5), plannerarena(1), ompl_app(1)
13 | 


--------------------------------------------------------------------------------
/doc/markdown/demos.md:
--------------------------------------------------------------------------------
 1 | \addtogroup demos
 2 | @{
 3 | ## OMPL.app Demos
 4 | 
 5 | - [Rigid body planning in 2D using meshes and collision checking.](demos_2SE2RigidBodyPlanning_2SE2RigidBodyPlanning_8cpp_source.html)
 6 | - [Rigid body planning in 3D using meshes and collision checking.](demos_2SE3RigidBodyPlanning_2SE3RigidBodyPlanning_8cpp_source.html)
 7 | - [Planning for a first-order car.](demos_2SE2RigidBodyPlanning_2KinematicCarPlanning_8cpp_source.html)
 8 | - [Planning for a second-order car.](demos_2SE2RigidBodyPlanning_2DynamicCarPlanning_8cpp_source.html)
 9 | - [Planning for a blimp.](demos_2SE3RigidBodyPlanning_2BlimpPlanning_8cpp_source.html)
10 | - [Planning for a quadrotor.](demos_2SE3RigidBodyPlanning_2QuadrotorPlanning_8cpp_source.html)
11 | - [Benchmarking planners on rigid body motion planning problems in 3D.](SE3RigidBodyPlanningBenchmark_8cpp_source.html)
12 | - [Planning for multiple 2D rigid bodies.](demos_2SE2RigidBodyPlanning_2SE2MultiRigidBodyPlanning_8cpp_source.html)
13 | - [Planning for multiple 3D rigid bodies.](demos_2SE3RigidBodyPlanning_2SE3MultiRigidBodyPlanning_8cpp_source.html)
14 | 
15 | @}
16 | 


--------------------------------------------------------------------------------
/doc/markdown/download.md.in:
--------------------------------------------------------------------------------
 1 | # Download {#download}
 2 | 
 3 | ## Releases
 4 | 
 5 | - __OMPL.app__ @PROJECT_VERSION@, released @OMPL_RELEASE_DATE@ ([release notes](releaseNotes.html)):
 6 | 
 7 |   <a href="https://github.com/ompl/omplapp/releases/download/@PROJECT_VERSION@/omplapp-@PROJECT_VERSION@-Source.tar.gz
 8 | " class="btn btn-primary btn-sm">TGZ</a>
 9 |   <a href="https://github.com/ompl/omplapp/releases/download/@PROJECT_VERSION@/omplapp-@PROJECT_VERSION@-Source.zip
10 | " class="btn btn-primary btn-sm">ZIP</a>
11 | 
12 | - __OMPL__ @PROJECT_VERSION@, released @OMPL_RELEASE_DATE@ ([release notes](core/releaseNotes.html)):
13 | 
14 |   Just the [core OMPL library](/core/download.html) (no GUI, no bindings to [FCL](http://gamma.cs.unc.edu/FCL), [PQP](http://gamma.cs.unc.edu/SSV), and [Assimp](http://assimp.sf.net)):
15 | 
16 |   <a href="https://github.com/ompl/ompl/archive/@PROJECT_VERSION@.tar.gz
17 | " class="btn btn-primary btn-sm">TGZ</a>
18 |   <a href="https://github.com/ompl/ompl/archive/@PROJECT_VERSION@.zip
19 | " class="btn btn-primary btn-sm">ZIP</a>
20 | 
21 |   OMPL is also available through through several package managers:
22 |   - [Debian](https://packages.debian.org/sid/libompl-dev),
23 |   - [Ubuntu (14.04 and higher)](http://packages.ubuntu.com/search?keywords=libompl-dev),
24 |   - [Fedora](https://apps.fedoraproject.org/packages/ompl),
25 |   - [MacPorts](https://www.macports.org),
26 |   - [Homebrew](http://brew.sh), and
27 |   - [vcpkg](https://vcpkg.readthedocs.io).
28 |   .
29 |   Note that these package managers may not always have the latest release.
30 | 
31 | - Python wheels are available on the [github release page](https://github.com/ompl/ompl/releases)
32 | - [Installation script for Ubuntu 16.04 and higher](install-ompl-ubuntu.sh)
33 | - [Installation instructions.](installation.html)
34 | - [Older releases](https://github.com/ompl/omplapp/releases). See the [release notes](core/releaseNotes.html) for a brief a description of changes for each release.
35 | 
36 | ## Repositories {#download_repos}
37 | 
38 | - The latest source of [OMPL.app](https://github.com/ompl/omplapp) and [OMPL](https://github.com/ompl/ompl) are available on GitHub. The OMPL.app repository contains the OMPL repository as a submodule. You can clone both at the same time like so:
39 | 
40 |       git clone --recurse-submodules https://github.com/ompl/omplapp.git
41 | 
42 |   If you are only interested in the OMPL code, clone just the OMPL repository like so:
43 | 
44 |       git clone https://github.com/ompl/ompl.git
45 | 
46 | - [Installation instructions](installation.html) are the same as for a release.
47 | - Python wheels are available on the [github release page](https://github.com/ompl/ompl/releases)
48 | 


--------------------------------------------------------------------------------
/doc/markdown/webapp.md:
--------------------------------------------------------------------------------
 1 | # OMPL Web App {#webapp}
 2 | 
 3 | [TOC]
 4 | 
 5 | ## Usage {#webapp_usage}
 6 | 
 7 | The OMPL web app is a web front end for motion planning and benchmarking using OMPL. Basic usage is very similar to the standalone [GUI](gui.html). Once deployed, this may be the easiest way to try out OMPL without to compile anything. Detailed instructions on how to use the site are available on the site itself (click on “About” in the top right).
 8 | 
 9 | ## Deploying the OMPL Web App Locally {#webapp_deploy}
10 | 
11 | It is possible to run the [OMPL web app](http://omplapp.kavrakilab.org) locally, i.e., run the web server on your own machine. The instructions below have been tested on Ubuntu Linux.
12 | 
13 | 1. [Compile and install](installation.html) OMPL.app (including its Python bindings).
14 | 2. Install the Python Flask and Celery packages:
15 | 
16 |         sudo apt-get install python-pip
17 |         pip install flask
18 |         pip install celery
19 | 
20 | 3. Install RabbitMQ (the daemon is automatically launched upon install):
21 | 
22 |         sudo apt-get install rabbitmq-server
23 | 
24 | 4. Run the OMPL web app:
25 | 
26 |         ompl_webapp
27 | 
28 | On macOS, the following steps get the Web App can be installed and launched using [Macports](http://macPorts.org) with these commands:
29 | 
30 |     sudo port install ompl +app
31 |     sudo port load redis
32 |     ompl_webapp
33 | 
34 | ## Docker
35 | 
36 | The OMPL web app is also available as a set of Docker containers. The easiest way to download and run everything you need is as follows:
37 | 
38 |      wget https://raw.githubusercontent.com/ompl/ompl/main/scripts/docker/omplwebapp.yml
39 |      docker-compose -f omplwebapp.yml up
40 | 
41 | Next, open <http://127.0.0.1:5000> in your browser. This also launches [Planner Arena](plannerarena.html), which you can access at <http://127.0.0.1:8888>.
42 | 
43 | ## JavaScript Libraries Used by the OMPL Web App {#webapp_licenses}
44 | 
45 | | Library                 | License                                                         | Distributable   |
46 | | ----------------------- | :-------------------------------------------------------------- | --------------- |
47 | | [jQuery](https://jquery.com/) | [MIT](https://github.com/jquery/jquery/blob/main/LICENSE.txt) | Yes             |
48 | | [blockUI](http://malsup.com/jquery/block/) (jQuery plugin) | [MIT and GPL Dual License](https://github.com/malsup/blockui/) | Yes (under MIT) |
49 | | [Bootstrap](https://getbootstrap.com) | [MIT](https://github.com/twbs/bootstrap/blob/main/LICENSE) | Yes             |
50 | | [THREE.js](https://threejs.org) | [MIT](https://github.com/mrdoob/three.js/blob/master/LICENSE)   | Yes             |
51 | | TrackballControls       | MIT (part of THREE.js)                                          | Yes             |
52 | | ColladaLoader           | MIT (part of THREE.js)                                          | Yes             |
53 | 


--------------------------------------------------------------------------------
/doc/releaseChecklist.txt:
--------------------------------------------------------------------------------
 1 | Steps to release a new version:
 2 | * update release notes (releaseNotes.md for both ompl and omplapp; put date, features)
 3 | * update version number in package.xml and CMakeLists.txt `package(...)` commands in omplapp and ompl dir
 4 | * "git pull" in omplapp and ompl
 5 | * "git clean -fd" in omplapp and ompl
 6 | * build omplapp with bindings
 7 | * build ompl without bindings
 8 | * make test for both
 9 | * run ompl_app.py and solve a test problem
10 | * make install
11 | * make docker-omplapp docker-ompl docker-plannerarena.
12 |     - do this for every docker image:
13 |         docker tag ompl:x.y.z kavrakilab/ompl:x.y.z
14 |         docker push kavrakilab/ompl:x.y.z
15 |     - pull new docker images on omplapp.kavrakilab.org/plannerarena.org and restart web services
16 | * make package_source for omplapp, since github tagged release doesn't include ompl submodule
17 | * make website for omplapp to update web site repo (assumed to exist in ${HOME}/src/ompl.github.io)
18 | * "jekyll build" in the ompl blog repo, copy content in _site/* to ${HOME}/src/ompl.github.io
19 | * commit and push ${HOME}/src/ompl.github.io
20 | * tag omplapp, ompl, ompl.github.io with version number x.y.z (including patch level this time)
21 | * update ompl in various package managers:
22 |     - ROS: https://github.com/ros-gbp/ompl-release
23 |         bloom-release ompl -r noetic -t noetic
24 |     - Macports: https://github.com/macports/macports-ports/tree/master/science/ompl
25 |     - HomeBrew: https://github.com/Homebrew/homebrew-core/blob/master/Formula/ompl.rb
26 |     - vcpkg: https://github.com/microsoft/vcpkg/tree/master/ports/ompl
27 | * update dependencies for these package managers as needed: fcl, libccd, flann, ode, castxml, py-pygccxml, py-pyplusplus, etc.
28 | * push changes to ompl and omplapp repos on github. Create releases for both, include release notes, attach omplapp-Source-x.y.z.tar.gz for omplapp (output of `make package_source`)
29 | * update version on https://en.wikipedia.org/wiki/OMPL
30 | * announce on ompl-users@lists.sourceforge.net, robot-motion@mit.edu
31 | * after release update version in CMakeLists.txt, ompl/CMakeLists.txt
32 |     - also increment ABI version if needed (if previously existing API has changed)
33 | 


--------------------------------------------------------------------------------
/gui/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | if(OMPL_BUILD_PYBINDINGS)
2 |     install_python(PROGRAMS ompl_app.py
3 |         DESTINATION ${CMAKE_INSTALL_BINDIR}
4 |         COMPONENT omplapp
5 |         RENAME ompl_app)
6 | endif()


--------------------------------------------------------------------------------
/py-bindings/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | include(PythonBindingsUtils)
 2 | 
 3 | # copy app module __init__.py
 4 | execute_process(COMMAND "${CMAKE_COMMAND}" -E copy_if_different
 5 |     "${CMAKE_CURRENT_SOURCE_DIR}/app/__init__.py"
 6 |     "${CMAKE_SOURCE_DIR}/ompl/py-bindings/ompl/app/__init__.py")
 7 | 
 8 | if(OMPL_BUILD_PYBINDINGS)
 9 |     if(PY_OMPL_GENERATE)
10 |         create_module_generation_targets(app)
11 |         add_dependencies(update_app_bindings update_geometric_bindings update_control_bindings)
12 |     endif(PY_OMPL_GENERATE)
13 | 
14 |     if(PY_OMPL_COMPILE AND EXISTS "${CMAKE_CURRENT_BINARY_DIR}/bindings")
15 |         create_module_target(app
16 |             "${CMAKE_CURRENT_SOURCE_DIR}/../ompl/py-bindings/ompl" ompl_app)
17 |     endif()
18 | endif(OMPL_BUILD_PYBINDINGS)
19 | 
20 | add_custom_target(clean_app_bindings
21 |     "${CMAKE_COMMAND}" -E remove_directory "${CMAKE_CURRENT_BINARY_DIR}/bindings"
22 |     COMMAND "${CMAKE_COMMAND}" -E remove -f pyplusplus_app.{cache,log}
23 |     WORKING_DIRECTORY "${PROJECT_BINARY_DIR}")
24 | add_dependencies(clean_bindings clean_app_bindings)
25 | 


--------------------------------------------------------------------------------
/py-bindings/app/__init__.py:
--------------------------------------------------------------------------------
 1 | ######################################################################
 2 | # Rice University Software Distribution License
 3 | #
 4 | # Copyright (c) 2010, Rice University
 5 | # All Rights Reserved.
 6 | #
 7 | # For a full description see the file named LICENSE.
 8 | #
 9 | ######################################################################
10 | 
11 | # Author: Mark Moll
12 | 
13 | from os.path import abspath, dirname
14 | from ompl import dll_loader, geometric, control
15 | dll_loader('ompl_app_base', dirname(abspath(__file__)))
16 | dll_loader('ompl_app', dirname(abspath(__file__)))
17 | from ompl.app._app import *
18 | 


--------------------------------------------------------------------------------
/py-bindings/headers_app.txt:
--------------------------------------------------------------------------------
 1 | src/omplapp/geometry/RigidBodyGeometry.h
 2 | src/omplapp/graphics/RenderGeometry.h
 3 | src/omplapp/apps/AppBase.h
 4 | src/omplapp/apps/SE2RigidBodyPlanning.h
 5 | src/omplapp/apps/SE3RigidBodyPlanning.h
 6 | src/omplapp/apps/SE2MultiRigidBodyPlanning.h
 7 | src/omplapp/apps/SE3MultiRigidBodyPlanning.h
 8 | src/omplapp/apps/KinematicCarPlanning.h
 9 | src/omplapp/apps/DynamicCarPlanning.h
10 | src/omplapp/apps/BlimpPlanning.h
11 | src/omplapp/apps/QuadrotorPlanning.h
12 | src/omplapp/apps/graphical/GSE2RigidBodyPlanning.h
13 | src/omplapp/apps/graphical/GSE3RigidBodyPlanning.h
14 | src/omplapp/apps/graphical/GKinematicCarPlanning.h
15 | src/omplapp/apps/graphical/GDynamicCarPlanning.h
16 | src/omplapp/apps/graphical/GBlimpPlanning.h
17 | src/omplapp/apps/graphical/GQuadrotorPlanning.h
18 | 


--------------------------------------------------------------------------------
/resources/2D/Barriers.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = Barriers
 3 | robot = Barriers_easy_robot.dae
 4 | world = Barriers_easy_env.dae
 5 | objective = length
 6 | objective.threshold = 0.0
 7 | start.x = 34.81
 8 | start.y = -75.0
 9 | start.theta = 0.0
10 | goal.x = 620.0
11 | goal.y = -375.0
12 | goal.theta = -3.141592653589793
13 | volume.min.x = 0.0
14 | volume.min.y = -440.22998046875
15 | volume.max.x = 661.0222778320312
16 | volume.max.y = 0.4874267578125
17 | 
18 | [benchmark]
19 | time_limit=300.0
20 | mem_limit=8000.0
21 | run_count=50
22 | 
23 | [planner]
24 | prm=
25 | prmstar=
26 | prmstar.name=PRM*
27 | rrtstar=
28 | rrtstar.name=RRT*
29 | lbtrrt=
30 | spars=
31 | spars.stretch_factor=1.2
32 | spars.sparse_delta_fraction=0.05
33 | spars.max_failures=10000
34 | spars2=
35 | spars2.name=SPARS2
36 | spars2.stretch_factor=1.2
37 | spars2.sparse_delta_fraction=0.05
38 | spars2.max_failures=10000
39 | aps=
40 | aps.name=APS1
41 | aps.num_planners=1
42 | aps=
43 | aps.name=APS4
44 | aps.num_planners=4
45 | rrtstar=
46 | rrtstar.name=RRT*prune
47 | rrtstar.tree_pruning=1
48 | cforest=
49 | cforest.name=CForest4
50 | cforest.num_threads=4
51 | cforest=
52 | cforest.name=CForest8
53 | cforest.num_threads=8
54 | 


--------------------------------------------------------------------------------
/resources/2D/BugTrap_dcar.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = BugTrap_dcar
 3 | robot = car1_planar_robot.dae
 4 | world = BugTrap_planar_env.dae
 5 | control = dynamic_car
 6 | start.x = 6.0
 7 | start.y = 12.0
 8 | start.theta = 0.0
 9 | goal.x = -39.0
10 | goal.y = 0.0
11 | goal.theta = 0.0
12 | volume.min.x = -55
13 | volume.min.y = -55
14 | volume.max.x = 55
15 | volume.max.y = 55
16 | 
17 | 
18 | [benchmark]
19 | time_limit=300.0
20 | mem_limit=20000.0
21 | run_count=50
22 | 
23 | [planner]
24 | kpiece=
25 | rrt=
26 | est=
27 | pdst=
28 | sycloprrt=
29 | syclopest=
30 | 


--------------------------------------------------------------------------------
/resources/2D/BugTrap_planar.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = BugTrap
 3 | robot = car1_planar_robot.dae
 4 | world = BugTrap_planar_env.dae
 5 | start.x = 7.02
 6 | start.y = -12.0
 7 | start.theta = 0.0
 8 | goal.x = -36.98
 9 | goal.y = -10.0
10 | goal.theta = 2.25147473507
11 | volume.min.x = -55.0
12 | volume.min.y = -55.0103187561
13 | volume.max.x = 55.0
14 | volume.max.y = 55.01
15 | 
16 | [benchmark]
17 | time_limit=20.0
18 | mem_limit=1000.0
19 | run_count=30
20 | 
21 | [planner]
22 | est=
23 | rrt=
24 | sbl=
25 | prm=
26 | kpiece=
27 | bkpiece=
28 | lbkpiece=
29 | 


--------------------------------------------------------------------------------
/resources/2D/BugTrap_planar.path:
--------------------------------------------------------------------------------
  1 | 7.02 -12.0 0.0
  2 | 5.23227 -12.0709 0.00178201
  3 | 3.44454 -12.1419 0.00356403
  4 | 1.65681 -12.2128 0.00534604
  5 | -0.130918 -12.2838 0.00712805
  6 | -1.91865 -12.3547 0.00891007
  7 | -3.70638 -12.4257 0.0106921
  8 | -5.12858 -12.1073 0.0350309
  9 | -6.55078 -11.7889 0.0593697
 10 | -7.97299 -11.4705 0.0837085
 11 | -9.39519 -11.1522 0.108047
 12 | -8.29861 -9.98424 0.175718
 13 | -7.20203 -8.81631 0.243388
 14 | -6.10545 -7.64837 0.311058
 15 | -5.00888 -6.48044 0.378729
 16 | -3.83089 -5.68408 0.423397
 17 | -2.65291 -4.88772 0.468065
 18 | -1.47492 -4.09136 0.512733
 19 | -0.296936 -3.295 0.557401
 20 | 0.881049 -2.49864 0.602069
 21 | 2.05903 -1.70228 0.646737
 22 | 3.23702 -0.905916 0.691405
 23 | 4.415 -0.109556 0.736073
 24 | 5.69656 0.00618879 0.595683
 25 | 6.97811 0.121934 0.455292
 26 | 8.25966 0.237679 0.314901
 27 | 9.54121 0.353424 0.174511
 28 | 10.8228 0.469169 0.0341202
 29 | 12.1043 0.584914 -0.10627
 30 | 13.3859 0.700659 -0.246661
 31 | 14.6674 0.816404 -0.387052
 32 | 16.3288 1.02342 -0.148593
 33 | 17.9901 1.23044 0.0898658
 34 | 19.6515 1.43745 0.328324
 35 | 21.3128 1.64447 0.566783
 36 | 22.9742 1.85149 0.805242
 37 | 24.6355 2.05851 1.0437
 38 | 25.8346 2.58642 1.19131
 39 | 27.0336 3.11434 1.33892
 40 | 28.2327 3.64225 1.48652
 41 | 29.4317 4.17017 1.63413
 42 | 30.6307 4.69808 1.78174
 43 | 31.8298 5.226 1.92935
 44 | 32.2414 6.98057 1.8782
 45 | 32.653 8.73514 1.82706
 46 | 33.0646 10.4897 1.77592
 47 | 33.4763 12.2443 1.72478
 48 | 32.4313 13.5666 1.64094
 49 | 31.3864 14.8889 1.5571
 50 | 30.3414 16.2112 1.47326
 51 | 29.2965 17.5335 1.38941
 52 | 28.2515 18.8558 1.30557
 53 | 27.2066 20.1781 1.22173
 54 | 25.827 20.6709 1.22092
 55 | 24.4475 21.1637 1.2201
 56 | 23.068 21.6565 1.21928
 57 | 21.6884 22.1494 1.21847
 58 | 20.3089 22.6422 1.21765
 59 | 18.9294 23.135 1.21683
 60 | 17.5498 23.6279 1.21602
 61 | 16.1703 24.1207 1.2152
 62 | 14.7908 24.6135 1.21438
 63 | 13.4113 25.1064 1.21357
 64 | 12.0317 25.5992 1.21275
 65 | 10.6522 26.092 1.21194
 66 | 8.97006 26.3042 1.20279
 67 | 7.28792 26.5164 1.19365
 68 | 5.60579 26.7286 1.18451
 69 | 3.92365 26.9408 1.17536
 70 | 2.24152 27.153 1.16622
 71 | 0.559384 27.3651 1.15708
 72 | -1.12275 27.5773 1.14793
 73 | -2.80488 27.7895 1.13879
 74 | -4.48702 28.0017 1.12965
 75 | -6.16915 28.2139 1.1205
 76 | -7.85129 28.4261 1.11136
 77 | -9.53342 28.6382 1.10222
 78 | -10.9637 28.4575 1.03531
 79 | -12.394 28.2767 0.968412
 80 | -13.8243 28.0959 0.901511
 81 | -15.2546 27.9151 0.834609
 82 | -16.6849 27.7343 0.767708
 83 | -18.1151 27.5535 0.700806
 84 | -19.5454 27.3727 0.633905
 85 | -20.9757 27.1919 0.567003
 86 | -22.406 27.0111 0.500102
 87 | -23.8363 26.8303 0.4332
 88 | -25.2666 26.6495 0.366298
 89 | -26.6969 26.4687 0.299397
 90 | -28.0804 25.5452 0.240104
 91 | -29.4639 24.6217 0.180811
 92 | -30.8474 23.6981 0.121517
 93 | -32.2309 22.7746 0.0622243
 94 | -33.6144 21.8511 0.0029311
 95 | -34.9979 20.9276 -0.0563621
 96 | -36.3815 20.004 -0.115655
 97 | -37.765 19.0805 -0.174948
 98 | -38.0024 17.4418 -0.0654859
 99 | -38.2399 15.803 0.0439767
100 | -38.4773 14.1643 0.153439
101 | -38.7148 12.5256 0.262902
102 | -38.9522 10.8868 0.372364
103 | -39.1897 9.24812 0.481827
104 | -39.4272 7.60939 0.591289
105 | -39.6646 5.97066 0.700752
106 | -39.4409 4.63977 0.829979
107 | -39.2172 3.30888 0.959206
108 | -38.9935 1.97799 1.08843
109 | -38.7697 0.647104 1.21766
110 | -38.546 -0.683784 1.34689
111 | -38.3223 -2.01467 1.47611
112 | -37.9867 -4.011 1.66995
113 | -37.6512 -6.00734 1.86379
114 | -37.3156 -8.00367 2.05763
115 | -36.98 -10.0 2.25147


--------------------------------------------------------------------------------
/resources/2D/Maze_kcar.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = Maze_kinematic_car
 3 | robot = car2_planar_robot.dae
 4 | world = Maze_planar_env.dae
 5 | control = kinematic_car
 6 | start.x = 0.01
 7 | start.y = -0.15
 8 | start.theta = 0.0
 9 | goal.x = 45.01
10 | goal.y = -0.15
11 | goal.theta = 0.0
12 | volume.min.x = -55.0
13 | volume.min.y = -55.0
14 | volume.max.x = 55.0
15 | volume.max.y = 55.0
16 | 
17 | [benchmark]
18 | time_limit=20.0
19 | mem_limit=1000.0
20 | run_count=50
21 | 
22 | [planner]
23 | kpiece=
24 | rrt=
25 | est=
26 | pdst=
27 | sycloprrt=
28 | syclopest=
29 | 


--------------------------------------------------------------------------------
/resources/2D/Maze_planar.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = Maze
 3 | robot = car2_planar_robot.dae
 4 | world = Maze_planar_env.dae
 5 | start.x = 0.01
 6 | start.y = -0.15
 7 | start.theta = 0.0
 8 | goal.x = 41.01
 9 | goal.y = -0.15
10 | goal.theta = 0.802851455917
11 | volume.min.x = -55.0
12 | volume.min.y = -55.0
13 | volume.max.x = 55.0
14 | volume.max.y = 55.0
15 | 
16 | [benchmark]
17 | time_limit=20.0
18 | mem_limit=1000.0
19 | run_count=30
20 | 
21 | [planner]
22 | est=
23 | rrt=
24 | sbl=
25 | prm=
26 | kpiece=
27 | bkpiece=
28 | lbkpiece=
29 | 


--------------------------------------------------------------------------------
/resources/2D/Maze_planar.path:
--------------------------------------------------------------------------------
 1 | 0.01 -0.15 0.0
 2 | 0.322686 1.60768 0.0937888
 3 | 0.635373 3.36535 0.187578
 4 | 0.948059 5.12303 0.281366
 5 | 1.26075 6.88071 0.375155
 6 | 0.322843 7.29613 0.631906
 7 | -0.61506 7.71155 0.888657
 8 | -1.55296 8.12697 1.14541
 9 | -2.49087 8.54238 1.40216
10 | -2.96183 9.78576 1.13675
11 | -3.43279 11.0291 0.871344
12 | -3.90375 12.2725 0.605937
13 | -4.37471 13.5159 0.340529
14 | -4.84567 14.7592 0.0751223
15 | -5.31663 16.0026 -0.190285
16 | -5.78759 17.246 -0.455692
17 | -6.25855 18.4894 -0.721099
18 | -5.82782 20.3058 -0.295977
19 | -5.39709 22.1223 0.129146
20 | -4.30732 23.4015 0.520474
21 | -3.21755 24.6808 0.911803
22 | -2.2512 24.0309 0.869995
23 | -1.38076 25.2135 1.27802
24 | -0.51032 26.3962 1.68604
25 | 0.360122 27.5788 2.09407
26 | 1.5356 26.4217 1.9675
27 | 2.71108 25.2645 1.84094
28 | 3.88656 24.1074 1.71438
29 | 5.03077 23.6157 1.79192
30 | 6.17498 23.1241 1.86947
31 | 6.54073 21.9813 1.81216
32 | 6.90647 20.8385 1.75485
33 | 7.27222 19.6958 1.69755
34 | 7.63797 18.553 1.64024
35 | 7.61449 17.0847 1.51551
36 | 7.591 15.6164 1.39077
37 | 7.56752 14.1481 1.26604
38 | 7.54404 12.6798 1.1413
39 | 8.99585 12.4384 0.93471
40 | 10.4477 12.197 0.728118
41 | 11.8995 11.9555 0.521526
42 | 13.3513 11.7141 0.314934
43 | 14.8031 11.4727 0.108343
44 | 16.2549 11.2312 -0.0982492
45 | 17.7067 10.9898 -0.304841
46 | 19.1585 10.7484 -0.511433
47 | 20.3964 12.0895 -1.06877
48 | 21.6342 13.4307 -1.62611
49 | 22.872 14.7719 -2.18345
50 | 24.1099 16.113 -2.74079
51 | 25.9028 16.9931 -2.88132
52 | 27.6958 17.8731 -3.02185
53 | 29.0695 17.6478 -3.12328
54 | 30.4433 17.4224 3.05848
55 | 30.7109 16.2043 3.04688
56 | 30.9786 14.9861 3.03527
57 | 31.2462 13.768 3.02367
58 | 31.5139 12.5499 3.01206
59 | 31.5719 10.7791 3.02001
60 | 31.63 9.00823 3.02796
61 | 31.688 7.23739 3.03591
62 | 31.7461 5.46656 3.04385
63 | 30.6963 4.40095 3.05341
64 | 29.6466 3.33534 3.06297
65 | 28.5968 2.26973 3.07252
66 | 27.547 1.20412 3.08208
67 | 27.0762 -0.212524 2.95157
68 | 26.6055 -1.62917 2.82106
69 | 27.9988 -1.62292 2.60619
70 | 29.3922 -1.61666 2.39132
71 | 30.7856 -1.61041 2.17645
72 | 32.179 -1.60416 1.96158
73 | 33.6508 -1.3618 1.76846
74 | 35.1226 -1.11944 1.57533
75 | 36.5945 -0.877079 1.38221
76 | 38.8022 -0.51354 1.09253
77 | 41.01 -0.15 0.802851


--------------------------------------------------------------------------------
/resources/2D/RandomPolygons_planar.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = RandomPolygons
 3 | robot = car2_planar_robot.dae
 4 | world = RandomPolygons_planar_env.dae
 5 | start.x = -32.99
 6 | start.y = 42.85
 7 | start.theta = 0.0
 8 | goal.x = 14.01
 9 | goal.y = -43.15
10 | goal.theta = 0.802851455917
11 | volume.min.x = -55.0
12 | volume.min.y = -55.0006408691
13 | volume.max.x = 55.0
14 | volume.max.y = 54.9992599487
15 | 
16 | [benchmark]
17 | time_limit=20.0
18 | mem_limit=1000.0
19 | run_count=30
20 | 
21 | [planner]
22 | est=
23 | rrt=
24 | sbl=
25 | prm=
26 | kpiece=
27 | bkpiece=
28 | lbkpiece=
29 | 


--------------------------------------------------------------------------------
/resources/2D/RandomPolygons_planar.path:
--------------------------------------------------------------------------------
 1 | -32.99 42.85 0.0
 2 | -33.6037 41.3288 0.253664
 3 | -34.2174 39.8075 0.507328
 4 | -34.8311 38.2863 0.760992
 5 | -35.4449 36.765 1.01466
 6 | -35.4038 35.3688 1.11154
 7 | -35.3627 33.9725 1.20842
 8 | -35.3217 32.5762 1.30531
 9 | -35.2806 31.1799 1.40219
10 | -35.2395 29.7836 1.49907
11 | -35.1985 28.3873 1.59595
12 | -34.4924 26.7669 1.56028
13 | -33.7862 25.1465 1.5246
14 | -33.0801 23.5261 1.48892
15 | -32.374 21.9056 1.45325
16 | -31.8091 20.6093 1.42471
17 | -31.2442 19.313 1.39616
18 | -30.6794 18.0166 1.36762
19 | -30.1145 16.7203 1.33908
20 | -29.5496 15.424 1.31054
21 | -28.6206 14.2202 1.25902
22 | -27.6917 13.0164 1.20751
23 | -26.7628 11.8126 1.156
24 | -25.8338 10.6088 1.10448
25 | -24.9049 9.40502 1.05297
26 | -23.9759 8.20123 1.00145
27 | -23.047 6.99743 0.94994
28 | -22.1181 5.79364 0.898426
29 | -21.1891 4.58985 0.846912
30 | -20.2602 3.38606 0.795398
31 | -18.8642 2.68586 0.781914
32 | -17.4682 1.98566 0.768429
33 | -16.0722 1.28546 0.754945
34 | -14.6762 0.585267 0.74146
35 | -13.2802 -0.11493 0.727976
36 | -11.8842 -0.815128 0.714492
37 | -10.4883 -1.51532 0.701007
38 | -9.09227 -2.21552 0.687523
39 | -7.42301 -2.84777 0.690612
40 | -5.75376 -3.48001 0.693701
41 | -4.0845 -4.11225 0.69679
42 | -2.41525 -4.7445 0.699878
43 | -0.745994 -5.37674 0.702967
44 | 0.923261 -6.00898 0.706056
45 | 1.8953 -7.11124 0.683404
46 | 2.86733 -8.21351 0.660752
47 | 3.83937 -9.31577 0.638099
48 | 4.81141 -10.418 0.615447
49 | 5.78344 -11.5203 0.592795
50 | 6.75548 -12.6226 0.570143
51 | 7.53708 -13.7652 0.489079
52 | 8.31869 -14.9079 0.408016
53 | 9.10029 -16.0506 0.326952
54 | 9.88189 -17.1933 0.245889
55 | 10.6635 -18.336 0.164825
56 | 11.4451 -19.4787 0.0837616
57 | 12.5431 -20.2322 -0.0883832
58 | 13.641 -20.9857 -0.260528
59 | 14.739 -21.7393 -0.432673
60 | 15.8369 -22.4928 -0.604818
61 | 16.9349 -23.2463 -0.776962
62 | 18.0329 -23.9998 -0.949107
63 | 19.0848 -25.1223 -1.09844
64 | 20.1367 -26.2448 -1.24777
65 | 21.1886 -27.3672 -1.3971
66 | 22.2405 -28.4897 -1.54643
67 | 21.6278 -30.1802 -1.34137
68 | 21.0152 -31.8707 -1.13631
69 | 20.4025 -33.5612 -0.931246
70 | 19.7898 -35.2518 -0.726184
71 | 18.8265 -36.5681 -0.471345
72 | 17.8632 -37.8845 -0.216506
73 | 16.8999 -39.2009 0.0383336
74 | 15.455 -41.1754 0.420593
75 | 14.01 -43.15 0.802851


--------------------------------------------------------------------------------
/resources/2D/UniqueSolutionMaze.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = UniqueSolutionMaze
 3 | robot = UniqueSolutionMaze_robot.dae
 4 | world = UniqueSolutionMaze_env.dae
 5 | start.x = -43.95
 6 | start.y = -42.75
 7 | start.theta = 0.0
 8 | goal.x = 44.05
 9 | goal.y = 45.25
10 | goal.theta = 0.0
11 | volume.min.x = -50.36
12 | volume.min.y = -49.75
13 | volume.max.x = 49.6377944946
14 | volume.max.y = 50.206867218
15 | 
16 | [benchmark]
17 | time_limit=20.0
18 | mem_limit=1000.0
19 | run_count=30
20 | 
21 | [planner]
22 | est=
23 | rrt=
24 | sbl=
25 | prm=
26 | kpiece=
27 | bkpiece=
28 | lbkpiece=
29 | 


--------------------------------------------------------------------------------
/resources/3D/Abstract.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = Abstract
 3 | robot = Abstract_robot.dae
 4 | world = Abstract_env.dae
 5 | start.x = 84.98
 6 | start.y = -60.0
 7 | start.z = 180.16
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = -121.02
13 | goal.y = 12.0
14 | goal.z = 153.16
15 | goal.theta = 1.57079632679
16 | goal.axis.x = 1.0
17 | goal.axis.y = 0.0
18 | goal.axis.z = 0.0
19 | volume.min.x = -233.119232178
20 | volume.min.y = -222.197250366
21 | volume.min.z = -3.94512939453
22 | volume.max.x = 239.919021606
23 | volume.max.y = 250.73979187
24 | volume.max.z = 468.982696533
25 | 
26 | [benchmark]
27 | time_limit=300.0
28 | mem_limit=8000.0
29 | run_count=50
30 | 
31 | [planner]
32 | prm=
33 | rrt=
34 | rrtconnect=
35 | trrt=
36 | est=
37 | sbl=
38 | kpiece=
39 | bkpiece=
40 | lbkpiece=
41 | stride=
42 | pdst=
43 | 


--------------------------------------------------------------------------------
/resources/3D/Apartment.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name=apartment_piano
 3 | robot = Apartment_robot.dae
 4 | world = Apartment_env.dae
 5 | start.x = 241.81
 6 | start.y = 106.15
 7 | start.z = 36.46
 8 | start.theta = 3.12413936107
 9 | start.axis.x = 0.0
10 | start.axis.y = 0.0
11 | start.axis.z = -1.0
12 | goal.x = -31.19
13 | goal.y = -99.85
14 | goal.z = 36.46
15 | goal.theta = 3.12413936107
16 | goal.axis.x = 0.0
17 | goal.axis.y = 0.0
18 | goal.axis.z = -1.0
19 | volume.min.x = -73.76
20 | volume.min.y = -179.59
21 | volume.min.z = -0.03
22 | volume.max.x = 295.77
23 | volume.max.y = 168.26
24 | volume.max.z = 90.39
25 | 
26 | [benchmark]
27 | time_limit=300.0
28 | mem_limit=1000.0
29 | run_count=30
30 | 
31 | [planner]
32 | est=
33 | rrt=
34 | sbl=
35 | prm=
36 | kpiece=
37 | bkpiece=
38 | lbkpiece=
39 | 


--------------------------------------------------------------------------------
/resources/3D/Apartment.skp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/resources/3D/Apartment.skp


--------------------------------------------------------------------------------
/resources/3D/Apartment_hard.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name=apartment_piano_hard
 3 | robot = Apartment_robot.dae
 4 | world = Apartment_env.dae
 5 | start.x = -31.19
 6 | start.y = -99.85
 7 | start.z = 36.46
 8 | start.theta = 0.0
 9 | start.axis.x = 0.0
10 | start.axis.y = 0.0
11 | start.axis.z = -1.0
12 | goal.x = 246.81
13 | goal.y = -48.85
14 | goal.z = 36.46
15 | goal.theta = 0.0
16 | goal.axis.x = 0.0
17 | goal.axis.y = 0.0
18 | goal.axis.z = -1.0
19 | volume.min.x = -73.76
20 | volume.min.y = -179.59
21 | volume.min.z = -0.03
22 | volume.max.x = 295.77
23 | volume.max.y = 168.26
24 | volume.max.z = 90.39
25 | 
26 | [benchmark]
27 | time_limit=1000.0
28 | mem_limit=8000.0
29 | run_count=50
30 | 
31 | [planner]
32 | prm=
33 | rrt=
34 | rrtconnect=
35 | trrt=
36 | est=
37 | sbl=
38 | kpiece=
39 | bkpiece=
40 | lbkpiece=
41 | stride=
42 | pdst=
43 | 


--------------------------------------------------------------------------------
/resources/3D/Easy.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = Easy
 3 | robot = Easy_robot.dae
 4 | world = Easy_env.dae
 5 | start.x = 270.0
 6 | start.y = 160.0
 7 | start.z = -200.0
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = 270.0
13 | goal.y = 160.0
14 | goal.z = -400.0
15 | goal.theta = 0
16 | goal.axis.x = 1
17 | goal.axis.y = 0
18 | goal.axis.z = 0
19 | volume.min.x = 14.4604492188
20 | volume.min.y = -24.25
21 | volume.min.z = -504.855102539
22 | volume.max.x = 457.960449219
23 | volume.max.y = 321.25
24 | volume.max.z = -72.8550872803
25 | 
26 | [benchmark]
27 | time_limit=20.0
28 | mem_limit=1000.0
29 | run_count=30
30 | 
31 | [planner]
32 | est=
33 | rrt=
34 | sbl=
35 | prm=
36 | kpiece=
37 | bkpiece=
38 | lbkpiece=
39 | 


--------------------------------------------------------------------------------
/resources/3D/Easy.path:
--------------------------------------------------------------------------------
 1 | 270.0 160.0 -200.0 0.0 0.0 0.0 1.0
 2 | 268.039 160.556 -206.867 -0.028387893922582497 0.0453410902931603 0.04971528935671062 0.9973297864868202
 3 | 266.077 161.113 -213.734 -0.05662422333655616 0.09044003727307652 0.09916504086891456 0.9893334077342394
 4 | 264.116 161.669 -220.602 -0.0845580672949495 0.13505594776356966 0.1480849427242641 0.9760536224856594
 5 | 262.154 162.226 -227.469 -0.11204001025463046 0.17895101637876096 0.19621501795887467 0.9575610876422189
 6 | 260.193 162.782 -234.336 -0.13892400447911837 0.22189000715406682 0.24329600784422842 0.9339550301121117
 7 | 258.231 163.339 -241.203 -0.16506603520058336 0.2636440562224964 0.2890780616463368 0.905361193069653
 8 | 256.27 163.895 -248.071 -0.19032700740924022 0.30399001183402735 0.3333170129756982 0.8719320339434429
 9 | 254.308 164.452 -254.938 -0.2145710108337979 0.34271201730370154 0.3757750189730691 0.8338470421013551
10 | 254.554 164.609 -261.963 -0.21598597115917922 0.37690694967124144 0.4153759445344385 0.799220893279242
11 | 254.8 164.766 -268.988 -0.21655004490393023 0.40961708493841237 0.4533410940050457 0.7614471578940797
12 | 255.046 164.924 -276.013 -0.2162619601575221 0.44071391880618044 0.48951990981453153 0.7206748672282797
13 | 255.291 165.081 -283.038 -0.21512203215579845 0.4700750702654166 0.5237710782917354 0.6770641012055183
14 | 256.641 165.039 -290.142 -0.20246205687382685 0.4963071394181544 0.5555981560736556 0.6356091785496351
15 | 257.99 164.996 -297.245 -0.18907694834238853 0.5207608577232059 0.5854368400531155 0.5918798382928274
16 | 259.34 164.954 -304.349 -0.17501500130114905 0.5433520040395504 0.6131790045586794 0.5460310040594676
17 | 260.689 164.912 -311.453 -0.16032704761730054 0.5639971675077476 0.6387261897023453 0.49822814797428017
18 | 264.246 164.47 -318.715 -0.1238529940886206 0.580279972303818 0.6614999684272689 0.45864297810942994
19 | 267.802 164.029 -325.976 -0.08692384842291494 0.5944276472907506 0.6818375954252338 0.4173697523497221
20 | 271.359 163.587 -333.238 -0.049674388948930975 0.6063868650970199 0.6996658443452309 0.37455991667159716
21 | 274.915 163.146 -340.499 -0.012242005680751027 0.6161142859001992 0.7149183317489923 0.3303711533046396
22 | 278.022 162.719 -345.393 0.019836605025103052 0.6202391571219308 0.7230931831774015 0.30339107685646943
23 | 281.129 162.291 -350.287 0.051878695439663405 0.6232209452164851 0.7299379358356517 0.2758529757514639
24 | 284.236 161.864 -355.18 0.08382528762478611 0.6250569077222023 0.7354378914265436 0.24780696341600172
25 | 288.896 161.223 -362.521 0.1314379782435333 0.62565189643804 0.7411478773203961 0.2048989660837941
26 | 293.556 160.582 -369.861 -0.1785059982991056 -0.6236559940574938 -0.7437889929128066 -0.16114199846455848
27 | 297.481 159.923 -375.018 -0.2276961244257197 -0.6188593381788722 -0.7433974062333406 -0.11192806116366538
28 | 301.405 159.264 -380.176 -0.2757790199247371 -0.611052044147852 -0.7393890534200626 -0.06217040449174475
29 | 305.329 158.604 -385.333 -0.3225199844032548 -0.6002719709714455 -0.7317839646116564 -0.012109899414377326
30 | 309.253 157.945 -390.49 -0.3676918941603889 -0.586571831156097 -0.7206187925708617 0.03800938905904911
31 | 314.158 157.008 -398.464 -0.4343300171332337 -0.5561340219380974 -0.692260027307928 0.15115700596276613
32 | 319.062 156.07 -406.438 -0.49272802107767333 -0.5151440220365738 -0.6507660278381443 0.26143701118362195
33 | 318.081 155.895 -409.729 -0.5045238733155848 -0.4743848808833945 -0.6046278481797803 0.39349690119412095
34 | 317.099 155.719 -413.021 -0.505539163205762 -0.42348813671681457 -0.5455691761288533 0.5171481669535554
35 | 311.702 156.115 -412.802 -0.4651509885147245 -0.36935899087997254 -0.4783899881878337 0.6468009840295136
36 | 306.305 156.511 -412.582 -0.41272204021089126 -0.30566902978087657 -0.39882703885712206 0.7597130740177089
37 | 297.964 157.288 -410.022 -0.3272461495348349 -0.23712410835364892 -0.3101371417168891 0.8605213932144798
38 | 289.624 158.065 -407.462 0.2319420092663154 0.16145700645036898 0.21213300847492594 -0.9354860373736034
39 | 279.812 159.033 -403.731 0.1178880310858159 0.0820629216391168 0.10782002843099102 -0.9837392594015459
40 | 270.0 160.0 -400.0 0.0 0.0 0.0 1.0


--------------------------------------------------------------------------------
/resources/3D/Easy.skp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/resources/3D/Easy.skp


--------------------------------------------------------------------------------
/resources/3D/Home.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = Home
 3 | robot = Home_robot.dae
 4 | world = Home_env.dae
 5 | objective = length
 6 | # make PRM act like an optimizing planner:
 7 | objective.threshold = 0
 8 | start.x = 252.95
 9 | start.y = -214.95
10 | start.z = 46.19
11 | start.theta = 0
12 | start.axis.x = 1
13 | start.axis.y = 0
14 | start.axis.z = 0
15 | goal.x = 262.95
16 | goal.y = 75.05
17 | goal.z = 46.19
18 | goal.theta = 0
19 | goal.axis.x = 1
20 | goal.axis.y = 0
21 | goal.axis.z = 0
22 | volume.min.x = -383.802642822
23 | volume.min.y = -371.469055176
24 | volume.min.z = -0.196851730347
25 | volume.max.x = 324.997131348
26 | volume.max.y = 337.893371582
27 | volume.max.z = 142.332290649
28 | 
29 | [benchmark]
30 | time_limit=300.0
31 | mem_limit=10000.0
32 | run_count=50
33 | 
34 | [planner]
35 | prm=
36 | prmstar=
37 | prmstar.name=PRM*
38 | rrtstar=
39 | rrtstar.name=RRT*
40 | lbtrrt=
41 | spars=
42 | spars.stretch_factor=1.2
43 | spars.sparse_delta_fraction=0.05
44 | spars.max_failures=10000
45 | spars2=
46 | spars2.name=SPARS2
47 | spars2.stretch_factor=1.2
48 | spars2.sparse_delta_fraction=0.05
49 | spars2.max_failures=10000
50 | aps=
51 | aps.name=APS1
52 | aps.num_planners=1
53 | aps=
54 | aps.name=APS4
55 | aps.num_planners=4
56 | rrtstar=
57 | rrtstar.name=RRT*prune
58 | rrtstar.tree_pruning=1
59 | cforest=
60 | cforest.name=CForest4
61 | cforest.num_threads=4
62 | cforest=
63 | cforest.name=CForest8
64 | cforest.num_threads=8
65 | 


--------------------------------------------------------------------------------
/resources/3D/Twistycool.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = Twistycool
 3 | robot = Twistycool_robot.dae
 4 | world = Twistycool_env.dae
 5 | start.x = 270.0
 6 | start.y = 160.0
 7 | start.z = -200.0
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = 270.0
13 | goal.y = 160.0
14 | goal.z = -400.0
15 | goal.theta = 0
16 | goal.axis.x = 1
17 | goal.axis.y = 0
18 | goal.axis.z = 0
19 | volume.min.x = 53.46
20 | volume.min.y = -21.25
21 | volume.min.z = -476.86
22 | volume.max.x = 402.96
23 | volume.max.y = 269.25
24 | volume.max.z = -91.0
25 | 
26 | [benchmark]
27 | time_limit=20.0
28 | mem_limit=1000.0
29 | run_count=30
30 | 
31 | [planner]
32 | est=
33 | rrt=
34 | sbl=
35 | prm=
36 | kpiece=
37 | bkpiece=
38 | lbkpiece=
39 | 


--------------------------------------------------------------------------------
/resources/3D/Twistycool.path:
--------------------------------------------------------------------------------
 1 | 270.0 160.0 -200.0 0.0 0.0 0.0 1.0
 2 | 267.344 159.416 -207.56 0.04003778966705558 0.08118587904756525 -0.12230596843530113 0.9883557449253552
 3 | 264.688 158.832 -215.121 0.07914320495439485 0.16048101004617252 -0.24176401513451967 0.9536940597016124
 4 | 262.032 158.248 -222.681 0.1164059920550003 0.2360389838897498 -0.35559197572995954 0.8968219387896628
 5 | 259.376 157.664 -230.242 0.15095705155267217 0.30610010453488706 -0.46113815748124387 0.8190642797150041
 6 | 257.262 157.305 -236.502 0.13920002863748565 0.3604340741517493 -0.5328751096278748 0.7528311548792167
 7 | 255.148 156.946 -242.762 0.12568600688947865 0.41021802248610156 -0.597885032773069 0.6770950371149655
 8 | 253.034 156.587 -249.023 0.11058501127823411 0.4548240463861423 -0.6553480668369867 0.5928110604590247
 9 | 250.92 156.228 -255.283 0.09408838335446992 0.493687912659813 -0.7045378753575524 0.5010449113582586
10 | 249.891 156.319 -258.943 -0.0038073198525756624 0.5163779800051783 -0.7100919725043225 0.47865298146593893
11 | 248.862 156.41 -262.603 -0.10166301022521525 0.5335780536670165 -0.7080980712201536 0.451172045378661
12 | 247.833 156.502 -266.263 -0.19843707510785183 0.5451062063211028 -0.6985762644090704 0.41889515855059084
13 | 246.803 156.593 -269.922 -0.2931020046507961 0.550839008740438 -0.6816280108157325 0.3821660060640192
14 | 246.504 156.234 -272.504 -0.3876848584650069 0.5576717964066118 -0.6501887626307553 0.34052487568205236
15 | 246.205 155.875 -275.086 -0.47772499833488946 0.557970998055192 -0.6111329978698959 0.29489599897213997
16 | 245.905 155.516 -277.668 -0.5621692396106354 0.5517342351629745 -0.5649172407819023 0.24581210477128673
17 | 245.606 155.157 -280.25 -0.6400278194801791 0.5390338479655247 -0.5120838555667689 0.19384794532519473
18 | 245.681 153.446 -283.276 -0.6473851546488213 0.566968135438623 -0.5032341202136981 0.07870841880204404
19 | 245.757 151.736 -286.302 -0.6455687580437927 0.586868780044275 -0.48725381737950585 -0.0375463859277869
20 | 245.833 150.026 -289.329 -0.6346047935431042 0.5984538053041575 -0.46436884892621033 -0.15326895013679065
21 | 245.908 148.316 -292.355 0.6146480626937981 -0.6015590613587265 0.4349040443599973 0.26682002721551074
22 | 246.825 147.189 -297.749 0.5538879898112307 -0.6318899883763838 0.4136849923902647 0.3504109935541898
23 | 247.743 146.063 -303.144 0.48645429223336895 -0.6546063932493447 0.3874822327767276 0.42977925818631374
24 | 248.987 145.567 -309.611 0.42139096425740924 -0.6825519421056055 0.3567499697402905 0.47883395938506584
25 | 250.232 145.071 -316.078 0.35280292157227205 -0.7047878433263847 0.3230339281898888 0.5238828835413718
26 | 252.13 145.835 -324.691 0.29895003694648997 -0.7494010926166133 0.28796803558925177 0.5158500637526237
27 | 254.029 146.599 -333.303 0.24324793436271597 -0.7893797869961551 0.25112093223829013 0.5046268638330194
28 | 256.255 147.992 -342.989 0.194443008467021 -0.8370710364502592 0.2129240092717762 0.4649380202457266
29 | 258.48 149.386 -352.675 0.14414197585629313 -0.8783248528810386 0.17309097100735132 0.42167292937000106
30 | 259.92 150.713 -358.59 0.12737295559492953 -0.9063876840129148 0.15295394667682205 0.3726158700977465
31 | 261.36 152.04 -364.506 0.11010900281504679 -0.9309330238002339 0.13222300338041335 0.3221130082351412
32 | 262.8 153.366 -370.422 0.09241834674332211 -0.9518654814342214 0.11097905613095183 0.27036013674266424
33 | 264.24 154.693 -376.337 0.07436879783164053 -0.9691039717439862 0.08930449739616265 0.21755799365669543
34 | 267.12 157.347 -388.169 0.037474997643133015 -0.9922459375959483 0.0450011971697974 0.10962899310524428
35 | 270.0 160.0 -400.0 6.12323e-17 1.0 6.12323e-17 3.7494e-33


--------------------------------------------------------------------------------
/resources/3D/Twistycool.skp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/resources/3D/Twistycool.skp


--------------------------------------------------------------------------------
/resources/3D/Twistycooler.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = Twistycooler
 3 | robot = Twistycooler_robot.dae
 4 | world = Twistycooler_env.dae
 5 | start.x = 121.81
 6 | start.y = 151.73000000000002
 7 | start.z = -188.99
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = 388.81
13 | goal.y = 70.72999999999999
14 | goal.z = -457.99
15 | goal.theta = 0
16 | goal.axis.x = 1
17 | goal.axis.y = 0
18 | goal.axis.z = 0
19 | volume.min.x = 62.38
20 | volume.min.y = 5.36
21 | volume.min.z = -521.58
22 | volume.max.x = 448.96
23 | volume.max.y = 321.25
24 | volume.max.z = -73.72
25 | 
26 | [benchmark]
27 | time_limit=30000.0
28 | mem_limit=40000.0
29 | run_count=10
30 | save_paths=shortest
31 | 
32 | [planner]
33 | stride=
34 | est=
35 | rrt=
36 | sbl=
37 | prm=
38 | bkpiece=
39 | 


--------------------------------------------------------------------------------
/resources/3D/alpha-1.0.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = alpha-1.0
 3 | robot = alpha_robot.dae
 4 | world = alpha_env-1.0.dae
 5 | start.x = -21.91
 6 | start.y = -11.11
 7 | start.z = -14.14
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = -21.91
13 | goal.y = -11.11
14 | goal.z = 57.86
15 | goal.theta = 0
16 | goal.axis.x = 1
17 | goal.axis.y = 0
18 | goal.axis.z = 0
19 | volume.min.x = -281.64
20 | volume.min.y = -119.64
21 | volume.min.z = -176.86
22 | volume.max.x = 189.05
23 | volume.max.y = 189.18
24 | volume.max.z = 174.86
25 | sampler=obstacle_based
26 | 
27 | [benchmark]
28 | time_limit=36000.0
29 | mem_limit=1000.0
30 | run_count=5
31 | 
32 | [planner]
33 | bkpiece=
34 | rrt=
35 | rrt.range=5
36 | est=
37 | est.range=5
38 | 


--------------------------------------------------------------------------------
/resources/3D/alpha-1.1.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = alpha-1.1
 3 | robot = alpha_robot.dae
 4 | world = alpha_env-1.1.dae
 5 | start.x = -21.91
 6 | start.y = -11.11
 7 | start.z = -14.14
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = -21.91
13 | goal.y = -11.11
14 | goal.z = 48.86
15 | goal.theta = 0
16 | goal.axis.x = 1
17 | goal.axis.y = 0
18 | goal.axis.z = 0
19 | volume.min.x = -281.64
20 | volume.min.y = -119.64
21 | volume.min.z = -176.86
22 | volume.max.x = 189.05
23 | volume.max.y = 189.18
24 | volume.max.z = 174.86
25 | sampler=obstacle_based
26 | 
27 | [benchmark]
28 | time_limit=7200.0
29 | mem_limit=1000.0
30 | run_count=5
31 | 
32 | [planner]
33 | bkpiece=
34 | rrt=
35 | rrt.range=5
36 | est=
37 | est.range=5
38 | 


--------------------------------------------------------------------------------
/resources/3D/alpha-1.2.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = alpha-1.2
 3 | robot = alpha_robot.dae
 4 | world = alpha_env-1.2.dae
 5 | start.x = -21.91
 6 | start.y = -11.11
 7 | start.z = -14.14
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = -21.91
13 | goal.y = -11.11
14 | goal.z = 48.86
15 | goal.theta = 0
16 | goal.axis.x = 1
17 | goal.axis.y = 0
18 | goal.axis.z = 0
19 | volume.min.x = -281.64
20 | volume.min.y = -119.64
21 | volume.min.z = -176.86
22 | volume.max.x = 189.05
23 | volume.max.y = 189.18
24 | volume.max.z = 174.86
25 | sampler=obstacle_based
26 | 
27 | [benchmark]
28 | time_limit=7200.0
29 | mem_limit=1000.0
30 | run_count=5
31 | 
32 | [planner]
33 | kpiece=
34 | bkpiece=
35 | rrt=
36 | rrt.range=10
37 | est=
38 | est.range=10
39 | 


--------------------------------------------------------------------------------
/resources/3D/alpha-1.5.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = alpha-1.5
 3 | robot = alpha_robot.dae
 4 | world = alpha_env-1.5.dae
 5 | start.x = -21.91
 6 | start.y = -4.11
 7 | start.z = -14.14
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = -21.91
13 | goal.y = -4.11
14 | goal.z = 68.86
15 | goal.theta = 0
16 | goal.axis.x = 1
17 | goal.axis.y = 0
18 | goal.axis.z = 0
19 | volume.min.x = -281.64
20 | volume.min.y = -119.64
21 | volume.min.z = -176.86
22 | volume.max.x = 189.05
23 | volume.max.y = 189.18
24 | volume.max.z = 174.86
25 | sampler=obstacle_based
26 | 
27 | [benchmark]
28 | time_limit=30.0
29 | mem_limit=1000.0
30 | run_count=30
31 | 
32 | [planner]
33 | kpiece=
34 | bkpiece=
35 | rrt=
36 | rrt.range=10
37 | est=
38 | est.range=10
39 | 


--------------------------------------------------------------------------------
/resources/3D/blimp.skp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/resources/3D/blimp.skp


--------------------------------------------------------------------------------
/resources/3D/bugtrap.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = bugtrap
 3 | robot = bugtrap_robot.dae
 4 | world = bugtrap_env.dae
 5 | start.x = 17.18
 6 | start.y = 0.89
 7 | start.z = -4.62
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = 45.18
13 | goal.y = 0.89
14 | goal.z = -4.62
15 | goal.theta = 0
16 | goal.axis.x = 1
17 | goal.axis.y = 0
18 | goal.axis.z = 0
19 | volume.min.x = 4.04
20 | volume.min.y = -44.49
21 | volume.min.z = -13.27
22 | volume.max.x = 56.99
23 | volume.max.y = 19.57
24 | volume.max.z = 15.27
25 | 
26 | [benchmark]
27 | time_limit=300.0
28 | mem_limit=1000.0
29 | run_count=30
30 | 
31 | [planner]
32 | est=
33 | rrt=
34 | sbl=
35 | prm=
36 | kpiece=
37 | bkpiece=
38 | lbkpiece=
39 | 


--------------------------------------------------------------------------------
/resources/3D/bugtrap.skp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/resources/3D/bugtrap.skp


--------------------------------------------------------------------------------
/resources/3D/cubicles.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = cubicles
 3 | robot = cubicles_robot.dae
 4 | world = cubicles_env.dae
 5 | start.x = -4.96
 6 | start.y = -40.62
 7 | start.z = 70.57
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = 200.0
13 | goal.y = -40.62
14 | goal.z = 70.57
15 | goal.theta = 0
16 | goal.axis.x = 1
17 | goal.axis.y = 0
18 | goal.axis.z = 0
19 | volume.min.x = -508.88
20 | volume.min.y = -230.13
21 | volume.min.z = -123.75
22 | volume.max.x = 319.62
23 | volume.max.y = 531.87
24 | volume.max.z = 101.0
25 | 
26 | [benchmark]
27 | time_limit=20.0
28 | mem_limit=1000.0
29 | run_count=50
30 | 
31 | [planner]
32 | prm=
33 | rrt=
34 | rrtconnect=
35 | trrt=
36 | est=
37 | sbl=
38 | kpiece=
39 | bkpiece=
40 | lbkpiece=
41 | stride=
42 | pdst=
43 | 


--------------------------------------------------------------------------------
/resources/3D/cubicles.skp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/resources/3D/cubicles.skp


--------------------------------------------------------------------------------
/resources/3D/cubicles_opt.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = cubicles_opt
 3 | robot = cubicles_robot.dae
 4 | world = cubicles_env.dae
 5 | objective = length
 6 | # make PRM act like an optimizing planner:
 7 | objective.threshold = 0
 8 | start.x = -4.96
 9 | start.y = -40.62
10 | start.z = 70.57
11 | start.theta = 0
12 | start.axis.x = 1
13 | start.axis.y = 0
14 | start.axis.z = 0
15 | goal.x = 200.0
16 | goal.y = -40.62
17 | goal.z = 70.57
18 | goal.theta = 0
19 | goal.axis.x = 1
20 | goal.axis.y = 0
21 | goal.axis.z = 0
22 | volume.min.x = -508.88
23 | volume.min.y = -230.13
24 | volume.min.z = -123.75
25 | volume.max.x = 319.62
26 | volume.max.y = 531.87
27 | volume.max.z = 101.0
28 | 
29 | [benchmark]
30 | time_limit=300.0
31 | mem_limit=8000.0
32 | run_count=50
33 | 
34 | [planner]
35 | prm=
36 | prmstar=
37 | prmstar.name=PRM*
38 | rrtstar=
39 | rrtstar.name=RRT*
40 | lbtrrt=
41 | spars=
42 | spars.stretch_factor=1.2
43 | spars.sparse_delta_fraction=0.05
44 | spars.max_failures=10000
45 | spars2=
46 | spars2.name=SPARS2
47 | spars2.stretch_factor=1.2
48 | spars2.sparse_delta_fraction=0.05
49 | spars2.max_failures=10000
50 | aps=
51 | aps.name=APS1
52 | aps.num_planners=1
53 | aps=
54 | aps.name=APS4
55 | aps.num_planners=4
56 | rrtstar=
57 | rrtstar.name=RRT*prune
58 | rrtstar.tree_pruning=1
59 | cforest=
60 | cforest.name=CForest4
61 | cforest.num_threads=4
62 | cforest=
63 | cforest.name=CForest8
64 | cforest.num_threads=8
65 | 


--------------------------------------------------------------------------------
/resources/3D/escape.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = escape
 3 | robot = escape_robot.dae
 4 | world = escape_env.dae
 5 | start.x = 54.96
 6 | start.y = 18.23
 7 | start.z = 0.83
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = -53.04
13 | goal.y = 18.23
14 | goal.z = 0.83
15 | goal.theta = 3.14159265359
16 | goal.axis.x = 1.0
17 | goal.axis.y = 0.0
18 | goal.axis.z = 0.0
19 | volume.min.x = -55.1875
20 | volume.min.y = 0.0
21 | volume.min.z = -6.05794906616
22 | volume.max.x = 61.6210250854
23 | volume.max.y = 35.7193412781
24 | volume.max.z = 7.69205093384
25 | 
26 | [benchmark]
27 | time_limit=180.0
28 | mem_limit=10000.0
29 | run_count=30
30 | 
31 | [planner]
32 | stride=
33 | pdst=
34 | kpiece=
35 | rrt=


--------------------------------------------------------------------------------
/resources/3D/escape.skp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/resources/3D/escape.skp


--------------------------------------------------------------------------------
/resources/3D/pipedream.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = pipedream
 3 | robot = spirelli_robot.dae
 4 | world = pipedream_env.dae
 5 | start.x = 54.59
 6 | start.y = 22.21
 7 | start.z = -10.16
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = 69.59
13 | goal.y = 22.21
14 | goal.z = 13.84
15 | goal.theta = 3.14159265359
16 | goal.axis.x = 1.0
17 | goal.axis.y = 0.0
18 | goal.axis.z = 0.0
19 | volume.min.x = 50.57
20 | volume.min.y = 12.79
21 | volume.min.z = -16.05
22 | volume.max.x = 87.7
23 | volume.max.y = 60.1
24 | volume.max.z = 30.44
25 | 
26 | 


--------------------------------------------------------------------------------
/resources/3D/pipedream_ring.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = pipedream_ring
 3 | robot = ring.dae
 4 | world = pipedream_env.dae
 5 | start.x = 79.48
 6 | start.y = 30.96
 7 | start.z = 3.59
 8 | start.theta = 0
 9 | start.axis.x = 1
10 | start.axis.y = 0
11 | start.axis.z = 0
12 | goal.x = 62.48
13 | goal.y = 24.96
14 | goal.z = 13.59
15 | goal.theta = 1.57079632679
16 | goal.axis.x = 1.0
17 | goal.axis.y = 0.0
18 | goal.axis.z = 0.0
19 | volume.min.x = 42.57
20 | volume.min.y = 11.79
21 | volume.min.z = -11.05
22 | volume.max.x = 95.7
23 | volume.max.y = 67.1
24 | volume.max.z = 32.44
25 | 
26 | [benchmark]
27 | time_limit=300.0
28 | mem_limit=8000.0
29 | run_count=50
30 | 
31 | [planner]
32 | prm=
33 | rrt=
34 | rrtconnect=
35 | trrt=
36 | est=
37 | sbl=
38 | kpiece=
39 | bkpiece=
40 | lbkpiece=
41 | stride=
42 | pdst=
43 | 


--------------------------------------------------------------------------------
/resources/3D/quadrotor.skp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/resources/3D/quadrotor.skp


--------------------------------------------------------------------------------
/resources/3D/spirelli.cfg:
--------------------------------------------------------------------------------
 1 | [problem]
 2 | name = spirelli
 3 | robot = spirelli_robot.dae
 4 | world = spirelli_env.dae
 5 | start.x = 64.59
 6 | start.y = 22.21
 7 | start.z = 1.84
 8 | start.theta = 1.57079632679
 9 | start.axis.x = 0.0
10 | start.axis.y = -1.0
11 | start.axis.z = 0.0
12 | goal.x = 2.59
13 | goal.y = 23.21
14 | goal.z = -32.16
15 | goal.theta = 3.14159265359
16 | goal.axis.x = 6.12323399574e-17
17 | goal.axis.y = 6.12323399574e-17
18 | goal.axis.z = -1.0
19 | volume.min.x = -9.41
20 | volume.min.y = 1.65
21 | volume.min.z = -33.16
22 | volume.max.x = 64.59
23 | volume.max.y = 38.94
24 | volume.max.z = 3.56
25 | 
26 | [benchmark]
27 | time_limit=180.0
28 | mem_limit=10000.0
29 | run_count=30
30 | 
31 | [planner]
32 | stride=
33 | pdst=
34 | kpiece=
35 | rrt=
36 | 


--------------------------------------------------------------------------------
/resources/README.md:
--------------------------------------------------------------------------------
 1 | # OMPL.app Resources
 2 | 
 3 | The `resources` directory contains a number of resources for the OMPL.app GUI and for benchmarking, as well as a few textures for one of the OMPL.app demo programs. The 2D and 3D directories contain a number of robot and environment models that can be used as input for ompl_app.py or to benchmark motion planning algorithms. Below are short descriptions of each benchmark. For some problems there are SketchUp (.skp) files available, so that it is easy to modify them in [SketchUp](https://www.sketchup.com), a free 3D modeling program. The SketchUp files cannot be read directly by OMPL, but need to be exported as COLLADA files. From each SketchUp file, two COLLADA files are exported: <problem>_env.dae and <problem>_robot.dae; these files represent the environment and robot geometries. The *.cfg files specify a motion planning problem and can be loaded with the GUI. The *.path files contain sample solutions for the corresponding .cfg file.
 4 | 
 5 | 
 6 | # 2D
 7 | 
 8 | - The **BoundingBox**, **BugTrap**, **H**, **Maze**, **Passage**, and **RandomPolygons** environment models as well as the **car1**, **car2**, **hook**, and **StraightC** robot models were originally created by Erion Plaku, for use with the OOPSMP library, and ported to OMPL by Amit Bhatia and Mark Moll. The scales of the robots and the environments match, so different combinations are possible.
 9 | - The **UniqueSolutionMaze** problem was created by Marius Șucan.
10 | - The **Barriers_easy** problem was created by Ryan Luna. The environment contains many different homotopy classes of solutions paths, which makes it a good test case for optimizing planners.
11 | 
12 | 
13 | # 3D
14 | 
15 | - **Abstract.** Another example of an environment where there exist several homotopy classes of solution paths. Contributed by Andrew Dobson at Rutgers University.
16 | - **Alpha puzzle.** Provided by Boris Yamrom, GE Corporate Research & Development Center (see the [Parasol Lab, Texas A&M University][parasol]). The alpha puzzle benchmark is a motion planning problem containing a narrow passage. The puzzle consists of two tubes, each twisted into an alpha shape; one tube is the obstacle and the other the moving object (robot). The objective is to separate the intertwined tubes. There are three variants of this benchmark. The 1.0 is the original problem and is the hardest to solve. In the 1.2 and 1.5 versions one of the alpha shapes has been stretched along one axis to make the narrow passage 20% and 50% wider, respectively.
17 | - **Apartment.** This is a real piano mover's problem. Try to move the piano to the hallway near the door entrance. The models were obtained from Google 3D warehouse. They contain very detailed meshes, so planners that rely heavily on collision checking do not perform as well.
18 | - **Bug trap.** Created by the [Parasol Lab, Texas A&M University][parasol]. The objective is to take the `bug' robot (a rod) outside of the trap obstacle through the narrow passage.
19 | - **Cubicles.** A simple office-like environment. Depending on the start and goal state, the robot may have to fly through the basement. Created by Nick Bridle and Nicolas Feltman at Rice University.
20 | - **Escape.** There are two versions of this problem. Both involve a long twisty narrow passage between start and goal. The **Pipedream.** and **Spirelli** benchmarks are along the same lines of the **Escape** benchmarks. All were created by Bryant Gipson.
21 | - **Home.** A version of the piano mover's problem with several homotopy classes.
22 |   Most planners will find the long path, but not the one going through the
23 |   narrow passages. Contributed by Andrew Dobson at Rutgers University.
24 | - **Twistycool.** The standard narrow passage problem. Created by Nick Bridle and Nicolas Feltman at Rice University. The **Easy** problem is the same as Twistycool, except that the narrow passage has been widened. This makes it very easy to solve.
25 | 
26 | 
27 | # Textures
28 | 
29 | The files in the `textures` directory are copied from the drawstuff library, included in the [Open Dynamics Engine](http://ode.org). They are used in the Open Dynamics Engine demo program.
30 | 
31 | [parasol]: http://parasol.tamu.edu/groups/amatogroup/benchmarks/mp/


--------------------------------------------------------------------------------
/resources/textures/checkered.ppm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/resources/textures/checkered.ppm


--------------------------------------------------------------------------------
/resources/textures/ground.ppm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/resources/textures/ground.ppm


--------------------------------------------------------------------------------
/resources/textures/sky.ppm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/resources/textures/sky.ppm


--------------------------------------------------------------------------------
/resources/textures/wood.ppm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/resources/textures/wood.ppm


--------------------------------------------------------------------------------
/src/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | add_subdirectory(omplapp)
 2 | 
 3 | # dirty hack to fix up OMPLAPP_RESOURCE_DIR in installed config.h
 4 | install(CODE "set(OMPLAPP_RESOURCE_DIR \"${CMAKE_INSTALL_FULL_DATAROOTDIR}/ompl/resources\")
 5 | set(OMPL_HAS_PQP ${OMPL_HAS_PQP})
 6 | configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/omplapp/config.h.in\" \"${CMAKE_CURRENT_BINARY_DIR}/omplapp/config.h\")")
 7 | 
 8 | install(DIRECTORY omplapp/ "${CMAKE_CURRENT_BINARY_DIR}/omplapp/"
 9 |     DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/omplapp"
10 |     COMPONENT omplapp
11 |     FILES_MATCHING PATTERN "*.h")
12 | 


--------------------------------------------------------------------------------
/src/omplapp/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # create a library with the common parts of applications
 2 | file(GLOB ompl_app_base_SRC geometry/*.cpp geometry/detail/*.cpp apps/*.cpp apps/detail/*.cpp)
 3 | file(GLOB ompl_app_SRC apps/graphical/*.cpp graphics/*.cpp graphics/detail/*.cpp)
 4 | 
 5 | file(GLOB ompl_app_base_HDRS geometry/*.h geometry/detail/*.h apps/*.h apps/detail/*.h)
 6 | file(GLOB ompl_app_HDRS apps/graphical/*.h graphics/*.h graphics/detail/*.h)
 7 | source_group("OMPL.app Source" FILES "${ompl_app_base_SRC};${ompl_app_SRC}")
 8 | source_group("OMPL.app Headers" FILES "${ompl_app_base_HDRS};${ompl_app_HDRS}")
 9 | 
10 | 
11 | # the ompl_app_base library can be built without OpenGL, which means that the
12 | # ompl_benchmark tool can be built on machines that do not have OpenGL installed.
13 | if(OPENGL_FOUND)
14 |     set(OMPLAPP_TARGETS ompl_app_base ompl_app)
15 | else()
16 |     set(OMPLAPP_TARGETS ompl_app_base)
17 | endif()
18 | 
19 | foreach(_target ${OMPLAPP_TARGETS})
20 |     if(MSVC)
21 |         add_library(${_target} STATIC ${${_target}_SRC})
22 |     else(MSVC)
23 |         add_library(${_target} SHARED ${${_target}_SRC})
24 |     endif(MSVC)
25 | 
26 |     target_link_libraries(${_target} ompl ${OMPLAPP_LIBRARIES})
27 |     if(_target STREQUAL ompl_app)
28 |         target_compile_definitions(ompl_app PRIVATE -DGL_SILENCE_DEPRECATION)
29 |         target_link_libraries(ompl_app ompl_app_base)
30 |     endif()
31 | 
32 |     if(WIN32)
33 |         set_target_properties(${_target} PROPERTIES VERSION "${PROJECT_VERSION}" STATIC_LIBRARY_FLAGS "psapi.lib ws2_32.lib glu32.lib opengl32.lib")
34 |         if(MINGW)
35 |             set_target_properties(${_target} PROPERTIES LINK_FLAGS "-Wl,--export-all-symbols")
36 |         endif(MINGW)
37 |     else(WIN32)
38 |         set_target_properties(${_target} PROPERTIES VERSION "${PROJECT_VERSION}" SOVERSION "${OMPL_ABI_VERSION}")
39 |     endif(WIN32)
40 | 
41 |     install(TARGETS ${_target}
42 |         DESTINATION ${CMAKE_INSTALL_LIBDIR}
43 |         COMPONENT omplapp)
44 |     if(NOT MSVC)
45 |         add_custom_command(TARGET ${_target} POST_BUILD
46 |         COMMAND ${CMAKE_COMMAND} -E copy "$<TARGET_FILE:${_target}>"
47 |         "${CMAKE_CURRENT_SOURCE_DIR}/../../ompl/py-bindings/ompl/app/lib${_target}${CMAKE_SHARED_LIBRARY_SUFFIX}"
48 |         WORKING_DIRECTORY "${LIBRARY_OUTPUT_PATH}")
49 |     endif(NOT MSVC)
50 | endforeach()
51 | 
52 | configure_file("${CMAKE_CURRENT_SOURCE_DIR}/config.h.in"
53 |     "${CMAKE_CURRENT_BINARY_DIR}/config.h")
54 | install(FILES "${CMAKE_CURRENT_BINARY_DIR}/config.h"
55 |     DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/omplapp"
56 |     COMPONENT omplapp)
57 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/BlimpPlanning.cpp:
--------------------------------------------------------------------------------
  1 | /*********************************************************************
  2 | * Rice University Software Distribution License
  3 | *
  4 | * Copyright (c) 2010, Rice University
  5 | * All Rights Reserved.
  6 | *
  7 | * For a full description see the file named LICENSE.
  8 | *
  9 | *********************************************************************/
 10 | 
 11 | /* Author: Mark Moll */
 12 | 
 13 | #include "omplapp/apps/BlimpPlanning.h"
 14 | 
 15 | ompl::base::ScopedState<> ompl::app::BlimpPlanning::getDefaultStartState() const
 16 | {
 17 |     base::ScopedState<base::SE3StateSpace> s(getGeometricComponentStateSpace());
 18 |     aiVector3D c = getRobotCenter(0);
 19 | 
 20 |     s->setXYZ(c.x, c.y, c.z);
 21 |     s->rotation().setIdentity();
 22 |     return getFullStateFromGeometricComponent(s);
 23 | }
 24 | 
 25 | ompl::base::ScopedState<> ompl::app::BlimpPlanning::getFullStateFromGeometricComponent(
 26 |     const base::ScopedState<> &state) const
 27 | {
 28 |     const base::SO3StateSpace::StateType& rot = state->as<base::SE3StateSpace::StateType>()->rotation();
 29 |     double norm = sqrt(rot.z * rot.z + rot.w * rot.w);
 30 |     base::ScopedState<> s(getStateSpace());
 31 |     base::SO3StateSpace::StateType& rot2 =
 32 |         s->as<base::CompoundStateSpace::StateType>()->as<base::SE3StateSpace::StateType>(0)->rotation();
 33 |     s = 0.0;
 34 |     // set x,y,z
 35 |     for (unsigned int i=0; i<3; ++i)
 36 |         s[i] = state[i];
 37 |     // set heading
 38 |     rot2.z = rot.z / norm;
 39 |     rot2.w = rot.w / norm;
 40 |     return s;
 41 | }
 42 | 
 43 | void ompl::app::BlimpPlanning::postPropagate(const base::State* /*state*/, const control::Control* /*control*/, const double /*duration*/, base::State *result)
 44 | {
 45 |     // Constrain orientation of the blimp about the z axis.
 46 |     base::CompoundStateSpace::StateType& s = *result->as<base::CompoundStateSpace::StateType>();
 47 |     base::SE3StateSpace::StateType& pose = *s.as<base::SE3StateSpace::StateType>(0);
 48 |     pose.rotation().setAxisAngle(0,0,1, pose.rotation().x);
 49 | 
 50 |     // Enforce velocity bounds
 51 |     getStateSpace()->as<base::CompoundStateSpace>()->getSubspace(1)->enforceBounds(s[1]);
 52 | 
 53 |     // Enforce steering bounds
 54 |     getStateSpace()->as<base::CompoundStateSpace>()->getSubspace(2)->enforceBounds(s[2]);
 55 | }
 56 | 
 57 | void ompl::app::BlimpPlanning::ode(const control::ODESolver::StateType& q, const control::Control *ctrl, control::ODESolver::StateType& qdot)
 58 | {
 59 |     // Retrieving control inputs
 60 |     const double *u = ctrl->as<control::RealVectorControlSpace::ControlType>()->values;
 61 | 
 62 |     // zero out qdot
 63 |     qdot.resize (q.size (), 0);
 64 | 
 65 |     qdot[0] = q[7];
 66 |     qdot[1] = q[8];
 67 |     qdot[2] = q[9];
 68 | 
 69 |     qdot[3] = q[10];
 70 | 
 71 |     qdot[7] = u[0] * cos(q[3]);
 72 |     qdot[8] = u[0] * sin(q[3]);
 73 |     qdot[9] = u[1];
 74 |     qdot[10] = u[2];
 75 | }
 76 | 
 77 | ompl::base::StateSpacePtr ompl::app::BlimpPlanning::constructStateSpace()
 78 | {
 79 |     auto stateSpace(std::make_shared<base::CompoundStateSpace>());
 80 | 
 81 |     stateSpace->addSubspace(std::make_shared<base::SE3StateSpace>(), 1.);
 82 |     stateSpace->addSubspace(std::make_shared<base::RealVectorStateSpace>(3), .3);
 83 |     stateSpace->addSubspace(std::make_shared<base::RealVectorStateSpace>(1), .3);
 84 |     stateSpace->lock();
 85 |     return stateSpace;
 86 | }
 87 | 
 88 | void ompl::app::BlimpPlanning::setDefaultBounds()
 89 | {
 90 |     base::RealVectorBounds velbounds(3), omegabounds(1), controlbounds(3);
 91 | 
 92 |     velbounds.setLow(-1);
 93 |     velbounds.setHigh(1);
 94 |     getStateSpace()->as<base::CompoundStateSpace>()->as<base::RealVectorStateSpace>(1)->setBounds(velbounds);
 95 |     omegabounds.setLow(-.2);
 96 |     omegabounds.setHigh(.2);
 97 |     getStateSpace()->as<base::CompoundStateSpace>()->as<base::RealVectorStateSpace>(2)->setBounds(omegabounds);
 98 |     controlbounds.setLow(-1);
 99 |     controlbounds.setHigh(1);
100 |     controlbounds.setLow(2,-.3);
101 |     controlbounds.setHigh(2,.3);
102 |     getControlSpace()->as<control::RealVectorControlSpace>()->setBounds(controlbounds);
103 | 
104 | }
105 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/BlimpPlanning.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Mark Moll */
12 | 
13 | #ifndef OMPLAPP_BLIMP_PLANNING_
14 | #define OMPLAPP_BLIMP_PLANNING_
15 | 
16 | #include "omplapp/apps/AppBase.h"
17 | #include <ompl/base/spaces/SE3StateSpace.h>
18 | #include <ompl/control/ODESolver.h>
19 | #include <ompl/control/spaces/RealVectorControlSpace.h>
20 | 
21 | namespace ompl
22 | {
23 |     namespace app
24 |     {
25 |         /** \brief A class to facilitate planning for a simple blimp model
26 | 
27 |             The dynamics of the blimp are described by the following equations:
28 |             \f{eqnarray*}{
29 |             \ddot x &=& u_f\cos\theta,\\
30 |             \ddot y &=& u_f\sin\theta,\\
31 |             \ddot z &=& u_z,\\
32 |             \ddot\theta &=& u_\theta,\f}
33 |             where \f$(x,y,z)\f$ is the position, \f$\theta\f$ the heading, and the
34 |             controls \f$(u_f,u_z,u_\theta)\f$ control their rate of change.
35 |         */
36 |         class BlimpPlanning : public AppBase<AppType::CONTROL>
37 |         {
38 |         public:
39 |             BlimpPlanning()
40 |                 : AppBase<AppType::CONTROL>(constructControlSpace(), Motion_3D),
41 |                   odeSolver(std::make_shared<control::ODEBasicSolver<>>(si_, [this](const control::ODESolver::StateType& q, const control::Control *ctrl, control::ODESolver::StateType& qdot)
42 |                       {
43 |                           ode(q, ctrl, qdot);
44 |                       }))
45 |             {
46 |                 name_ = std::string("Blimp");
47 |                 setDefaultBounds();
48 | 
49 |                 si_->setStatePropagator(control::ODESolver::getStatePropagator(odeSolver,
50 |                     [this](const base::State* state, const control::Control* control, const double duration, base::State* result)
51 |                     {
52 |                         postPropagate(state, control, duration, result);
53 |                     }));
54 |             }
55 |             ~BlimpPlanning() override = default;
56 | 
57 |             bool isSelfCollisionEnabled() const override
58 |             {
59 |                 return false;
60 |             }
61 |             unsigned int getRobotCount() const override
62 |             {
63 |                 return 1;
64 |             }
65 |             base::ScopedState<> getDefaultStartState() const override;
66 |             base::ScopedState<> getFullStateFromGeometricComponent(const base::ScopedState<> &state) const override;
67 |             const base::StateSpacePtr& getGeometricComponentStateSpace() const override
68 |             {
69 |                 return getStateSpace()->as<base::CompoundStateSpace>()->getSubspace(0);
70 |             }
71 | 
72 |             virtual void setDefaultBounds();
73 | 
74 |         protected:
75 | 
76 |             const base::State* getGeometricComponentStateInternal(const base::State* state, unsigned int /*index*/) const override
77 |             {
78 |                 return state->as<base::CompoundState>()->components[0];
79 |             }
80 | 
81 |             void postPropagate(const base::State* state, const control::Control* control, double duration, base::State* result);
82 | 
83 |             virtual void ode(const control::ODESolver::StateType& q, const control::Control *ctrl, control::ODESolver::StateType& qdot);
84 | 
85 |             static control::ControlSpacePtr constructControlSpace()
86 |             {
87 |                 return std::make_shared<control::RealVectorControlSpace>(constructStateSpace(), 3);
88 |             }
89 |             static base::StateSpacePtr constructStateSpace();
90 | 
91 |             double timeStep_{1e-2};
92 |             control::ODESolverPtr odeSolver;
93 |         };
94 | 
95 |     }
96 | }
97 | 
98 | #endif
99 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/DynamicCarPlanning.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Mark Moll */
12 | 
13 | #include "omplapp/apps/DynamicCarPlanning.h"
14 | #include <boost/math/constants/constants.hpp>
15 | 
16 | ompl::base::ScopedState<> ompl::app::DynamicCarPlanning::getDefaultStartState() const
17 | {
18 |     base::ScopedState<base::CompoundStateSpace> s(getStateSpace());
19 |     base::SE2StateSpace::StateType& pose = *s->as<base::SE2StateSpace::StateType>(0);
20 |     base::RealVectorStateSpace::StateType& vel = *s->as<base::RealVectorStateSpace::StateType>(1);
21 | 
22 |     aiVector3D c = getRobotCenter(0);
23 |     pose.setX(c.x);
24 |     pose.setY(c.y);
25 |     pose.setYaw(0.);
26 |     vel.values[0] = 0.;
27 |     vel.values[1] = 0.;
28 |     return s;
29 | }
30 | 
31 | void ompl::app::DynamicCarPlanning::ode(const control::ODESolver::StateType& q, const control::Control *ctrl, control::ODESolver::StateType& qdot)
32 | {
33 |     // Retrieving control inputs
34 |     const double *u = ctrl->as<control::RealVectorControlSpace::ControlType>()->values;
35 | 
36 |     // zero out qdot
37 |     qdot.resize (q.size (), 0);
38 | 
39 |     qdot[0] = q[3] * cos(q[2]);
40 |     qdot[1] = q[3] * sin(q[2]);
41 |     qdot[2] = q[3] * mass_ * lengthInv_ * tan(q[4]);
42 | 
43 |     qdot[3] = u[0];
44 |     qdot[4] = u[1];
45 | }
46 | 
47 | void ompl::app::DynamicCarPlanning::postPropagate(const base::State* /*state*/, const control::Control* /*control*/, const double /*duration*/, base::State* result)
48 | {
49 |     // Normalize orientation value between 0 and 2*pi
50 |     const base::SO2StateSpace* SO2 = getStateSpace()->as<base::CompoundStateSpace>()
51 |         ->as<base::SE2StateSpace>(0)->as<base::SO2StateSpace>(1);
52 |     auto* so2 = result->as<base::CompoundStateSpace::StateType>()
53 |         ->as<base::SE2StateSpace::StateType>(0)->as<base::SO2StateSpace::StateType>(1);
54 |     SO2->enforceBounds(so2);
55 | }
56 | 
57 | void ompl::app::DynamicCarPlanning::setDefaultBounds()
58 | {
59 |     base::RealVectorBounds bounds(2);
60 |     bounds.low[0] = -1.;
61 |     bounds.high[0] = 1.;
62 |     bounds.low[1] = -boost::math::constants::pi<double>() * 30. / 180.;
63 |     bounds.high[1] = boost::math::constants::pi<double>() * 30. / 180.;
64 |     getStateSpace()->as<base::CompoundStateSpace>()->as<base::RealVectorStateSpace>(1)->setBounds(bounds);
65 |     bounds.low[0] = -.5;
66 |     bounds.high[0] = .5;
67 |     bounds.low[1] = -boost::math::constants::pi<double>() * 2. / 180.;
68 |     bounds.high[1] = boost::math::constants::pi<double>() * 2. / 180.;
69 |     getControlSpace()->as<control::RealVectorControlSpace>()->setBounds(bounds);
70 | }
71 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/KinematicCarPlanning.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Mark Moll */
12 | 
13 | #include "omplapp/apps/KinematicCarPlanning.h"
14 | #include <boost/math/constants/constants.hpp>
15 | 
16 | ompl::app::KinematicCarPlanning::KinematicCarPlanning()
17 |     : AppBase<AppType::CONTROL>(constructControlSpace(), Motion_2D), odeSolver(std::make_shared<control::ODEBasicSolver<>>(si_, [this](const control::ODESolver::StateType& q, const control::Control *ctrl, control::ODESolver::StateType& qdot)
18 |     {
19 |         ode(q, ctrl, qdot);
20 |     }))
21 | {
22 |     name_ = std::string("Kinematic car");
23 |     setDefaultControlBounds();
24 | 
25 |     si_->setStatePropagator(control::ODESolver::getStatePropagator(odeSolver,
26 |         [this](const base::State* state, const control::Control* control, const double duration, base::State* result)
27 |         {
28 |             postPropagate(state, control, duration, result);
29 |         }));
30 | }
31 | 
32 | ompl::app::KinematicCarPlanning::KinematicCarPlanning(const control::ControlSpacePtr &controlSpace)
33 |     : AppBase<AppType::CONTROL>(controlSpace, Motion_2D), odeSolver(std::make_shared<control::ODEBasicSolver<>>(si_, [this](const control::ODESolver::StateType& q, const control::Control *ctrl, control::ODESolver::StateType& qdot)
34 |     {
35 |         ode(q, ctrl, qdot);
36 |     }))
37 | {
38 |     setDefaultControlBounds();
39 | 
40 |     si_->setStatePropagator(control::ODESolver::getStatePropagator(odeSolver,
41 |         [this](const base::State* state, const control::Control* control, const double duration, base::State* result)
42 |         {
43 |             postPropagate(state, control, duration, result);
44 |         }));
45 | }
46 | 
47 | ompl::base::ScopedState<> ompl::app::KinematicCarPlanning::getDefaultStartState() const
48 | {
49 |     base::ScopedState<base::SE2StateSpace> sSE2(getStateSpace());
50 |     aiVector3D s = getRobotCenter(0);
51 | 
52 |     sSE2->setX(s.x);
53 |     sSE2->setY(s.y);
54 |     sSE2->setYaw(0.);
55 |     return sSE2;
56 | }
57 | 
58 | void ompl::app::KinematicCarPlanning::setDefaultControlBounds()
59 | {
60 |     base::RealVectorBounds cbounds(2);
61 |     cbounds.low[0] = -5.;
62 |     cbounds.high[0] = 5.;
63 |     cbounds.low[1] = -boost::math::constants::pi<double>() * 30. / 180.;
64 |     cbounds.high[1] = boost::math::constants::pi<double>() * 30. / 180.;
65 |     getControlSpace()->as<control::RealVectorControlSpace>()->setBounds(cbounds);
66 | }
67 | 
68 | void ompl::app::KinematicCarPlanning::ode(const control::ODESolver::StateType& q, const control::Control *ctrl, control::ODESolver::StateType& qdot)
69 | {
70 |     const double *u = ctrl->as<control::RealVectorControlSpace::ControlType>()->values;
71 | 
72 |     // zero out qdot
73 |     qdot.resize (q.size (), 0);
74 | 
75 |     qdot[0] = u[0] * cos(q[2]);
76 |     qdot[1] = u[0] * sin(q[2]);
77 |     qdot[2] = u[0] * lengthInv_ * tan(u[1]);
78 | }
79 | 
80 | void ompl::app::KinematicCarPlanning::postPropagate(const base::State* /*state*/, const control::Control* /*control*/, const double /*duration*/, base::State* result)
81 | {
82 |     // Normalize orientation value between 0 and 2*pi
83 |     const base::SO2StateSpace* SO2 = getStateSpace()->as<base::SE2StateSpace>()
84 |         ->as<base::SO2StateSpace>(1);
85 |     auto* so2 = result->as<base::SE2StateSpace::StateType>()
86 |         ->as<base::SO2StateSpace::StateType>(1);
87 |     SO2->enforceBounds(so2);
88 | }
89 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/KinematicCarPlanning.h:
--------------------------------------------------------------------------------
  1 | /*********************************************************************
  2 | * Rice University Software Distribution License
  3 | *
  4 | * Copyright (c) 2010, Rice University
  5 | * All Rights Reserved.
  6 | *
  7 | * For a full description see the file named LICENSE.
  8 | *
  9 | *********************************************************************/
 10 | 
 11 | /* Author: Mark Moll */
 12 | 
 13 | #ifndef OMPLAPP_KINEMATIC_CAR_PLANNING_
 14 | #define OMPLAPP_KINEMATIC_CAR_PLANNING_
 15 | 
 16 | #include "omplapp/apps/AppBase.h"
 17 | #include <ompl/base/spaces/SE2StateSpace.h>
 18 | #include <ompl/control/ODESolver.h>
 19 | #include <ompl/control/spaces/RealVectorControlSpace.h>
 20 | 
 21 | namespace ompl
 22 | {
 23 |     namespace app
 24 |     {
 25 |         /** \brief A class to facilitate planning for a generic kinematic car
 26 |             model
 27 | 
 28 |             The dynamics of the kinematic car are described by the following
 29 |             equations:
 30 |             \f{eqnarray*}{
 31 |             \dot x &=& u_0 \cos\theta,\\
 32 |             \dot y &=& u_0\sin\theta,\\
 33 |             \dot\theta &=& \frac{u_0}{L}\tan u_1,\f}
 34 |             where the control inputs \f$(u_0,u_1)\f$ are the translational
 35 |             velocity and the steering angle, respectively, and \f$L\f$ is the
 36 |             distance between the front and rear axle of the car (set to 1 by
 37 |             default).
 38 |         */
 39 |         class KinematicCarPlanning : public AppBase<AppType::CONTROL>
 40 |         {
 41 |         public:
 42 |             KinematicCarPlanning();
 43 |             KinematicCarPlanning(const control::ControlSpacePtr &controlSpace);
 44 |             ~KinematicCarPlanning() override = default;
 45 | 
 46 |             bool isSelfCollisionEnabled() const override
 47 |             {
 48 |                 return false;
 49 |             }
 50 |             unsigned int getRobotCount() const override
 51 |             {
 52 |                 return 1;
 53 |             }
 54 |             base::ScopedState<> getDefaultStartState() const override;
 55 |             base::ScopedState<> getFullStateFromGeometricComponent(const base::ScopedState<> &state) const override
 56 |             {
 57 |                 return state;
 58 |             }
 59 |             const base::StateSpacePtr& getGeometricComponentStateSpace() const override
 60 |             {
 61 |                 return getStateSpace();
 62 |             }
 63 |             double getVehicleLength()
 64 |             {
 65 |                 return 1./lengthInv_;
 66 |             }
 67 |             void setVehicleLength(double length)
 68 |             {
 69 |                 lengthInv_ = 1./length;
 70 |             }
 71 |             virtual void setDefaultControlBounds();
 72 | 
 73 |         protected:
 74 | 
 75 |             const base::State* getGeometricComponentStateInternal(const base::State* state, unsigned int /*index*/) const override
 76 |             {
 77 |                 return state;
 78 |             }
 79 | 
 80 |             virtual void ode(const control::ODESolver::StateType& q, const control::Control *ctrl, control::ODESolver::StateType& qdot);
 81 | 
 82 |             virtual void postPropagate(const base::State* state, const control::Control* control, double duration, base::State* result);
 83 | 
 84 |             static control::ControlSpacePtr constructControlSpace()
 85 |             {
 86 |                 return std::make_shared<control::RealVectorControlSpace>(constructStateSpace(), 2);
 87 |             }
 88 |             static base::StateSpacePtr constructStateSpace()
 89 |             {
 90 |                 return std::make_shared<base::SE2StateSpace>();
 91 |             }
 92 | 
 93 |             double timeStep_{1e-2};
 94 |             double lengthInv_{1.};
 95 |             control::ODESolverPtr odeSolver;
 96 |         };
 97 |     }
 98 | }
 99 | 
100 | #endif
101 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/QuadrotorPlanning.cpp:
--------------------------------------------------------------------------------
  1 | /*********************************************************************
  2 | * Rice University Software Distribution License
  3 | *
  4 | * Copyright (c) 2010, Rice University
  5 | * All Rights Reserved.
  6 | *
  7 | * For a full description see the file named LICENSE.
  8 | *
  9 | *********************************************************************/
 10 | 
 11 | /* Author: Mark Moll */
 12 | 
 13 | #include "omplapp/apps/QuadrotorPlanning.h"
 14 | 
 15 | ompl::base::ScopedState<> ompl::app::QuadrotorPlanning::getDefaultStartState() const
 16 | {
 17 |     base::ScopedState<base::SE3StateSpace> s(getGeometricComponentStateSpace());
 18 |     aiVector3D c = getRobotCenter(0);
 19 | 
 20 |     s->setXYZ(c.x, c.y, c.z);
 21 |     s->rotation().setIdentity();
 22 |     return getFullStateFromGeometricComponent(s);
 23 | }
 24 | 
 25 | 
 26 | ompl::base::ScopedState<> ompl::app::QuadrotorPlanning::getFullStateFromGeometricComponent(
 27 |     const base::ScopedState<> &state) const
 28 | {
 29 |     base::ScopedState<> s(getStateSpace());
 30 |     std::vector <double> reals = state.reals ();
 31 | 
 32 |     s = 0.0;
 33 |     for (size_t i = 0; i < reals.size (); ++i)
 34 |         s[i] = reals[i];
 35 |     return s;
 36 | }
 37 | 
 38 | void ompl::app::QuadrotorPlanning::ode(const control::ODESolver::StateType& q, const control::Control *ctrl, control::ODESolver::StateType& qdot)
 39 | {
 40 |     const double *u = ctrl->as<control::RealVectorControlSpace::ControlType>()->values;
 41 | 
 42 |     // zero out qdot
 43 |     qdot.resize (q.size (), 0);
 44 | 
 45 |     // derivative of position
 46 |     qdot[0] = q[7];
 47 |     qdot[1] = q[8];
 48 |     qdot[2] = q[9];
 49 | 
 50 |     // derivative of orientation
 51 |     // 1. First convert omega to quaternion: qdot = omega * q / 2
 52 |     base::SO3StateSpace::StateType qomega;
 53 |     qomega.w = 0;
 54 |     qomega.x = .5*q[10];
 55 |     qomega.y = .5*q[11];
 56 |     qomega.z = .5*q[12];
 57 | 
 58 |     // 2. We include a numerical correction so that dot(q,qdot) = 0. This constraint is
 59 |     // obtained by differentiating q * q_conj = 1
 60 |     double delta = q[3] * qomega.x + q[4] * qomega.y + q[5] * qomega.z;
 61 | 
 62 |     // 3. Finally, set the derivative of orientation
 63 |     qdot[3] = qomega.x - delta * q[3];
 64 |     qdot[4] = qomega.y - delta * q[4];
 65 |     qdot[5] = qomega.z - delta * q[5];
 66 |     qdot[6] = qomega.w - delta * q[6];
 67 | 
 68 |     // derivative of velocity
 69 |     // the z-axis of the body frame in world coordinates is equal to
 70 |     // (2(wy+xz), 2(yz-wx), w^2-x^2-y^2+z^2).
 71 |     // This can be easily verified by working out q * (0,0,1).
 72 |     qdot[7] = massInv_ * (-2*u[0]*(q[6]*q[4] + q[3]*q[5]) - beta_ * q[7]);
 73 |     qdot[8] = massInv_ * (-2*u[0]*(q[4]*q[5] - q[6]*q[3]) - beta_ * q[8]);
 74 |     qdot[9] = massInv_ * (  -u[0]*(q[6]*q[6]-q[3]*q[3]-q[4]*q[4]+q[5]*q[5]) - beta_ * q[9]) - 9.81;
 75 | 
 76 |     // derivative of rotational velocity
 77 |     qdot[10] = u[1];
 78 |     qdot[11] = u[2];
 79 |     qdot[12] = u[3];
 80 | }
 81 | 
 82 | void ompl::app::QuadrotorPlanning::postPropagate(const base::State* /*state*/, const control::Control* /*control*/, const double /*duration*/, base::State* result)
 83 | {
 84 |     const base::CompoundStateSpace* cs = getStateSpace()->as<base::CompoundStateSpace>();
 85 |     const base::SO3StateSpace* SO3 = cs->as<base::SE3StateSpace>(0)->as<base::SO3StateSpace>(1);
 86 |     base::CompoundStateSpace::StateType& csState = *result->as<base::CompoundStateSpace::StateType>();
 87 |     base::SO3StateSpace::StateType& so3State = csState.as<base::SE3StateSpace::StateType>(0)->rotation();
 88 | 
 89 |     // Normalize the quaternion representation for the quadrotor
 90 |     SO3->enforceBounds(&so3State);
 91 |     // Enforce velocity bounds
 92 |     cs->getSubspace(1)->enforceBounds(csState[1]);
 93 | }
 94 | 
 95 | ompl::base::StateSpacePtr ompl::app::QuadrotorPlanning::constructStateSpace()
 96 | {
 97 |     auto stateSpace(std::make_shared<base::CompoundStateSpace>());
 98 | 
 99 |     stateSpace->addSubspace(std::make_shared<base::SE3StateSpace>(), 1.);
100 |     stateSpace->addSubspace(std::make_shared<base::RealVectorStateSpace>(6), .3);
101 |     stateSpace->lock();
102 |     return stateSpace;
103 | }
104 | 
105 | void ompl::app::QuadrotorPlanning::setDefaultBounds()
106 | {
107 |     base::RealVectorBounds velbounds(6), controlbounds(4);
108 | 
109 |     velbounds.setLow(-1);
110 |     velbounds.setHigh(1);
111 |     getStateSpace()->as<base::CompoundStateSpace>()->as<base::RealVectorStateSpace>(1)->setBounds(velbounds);
112 |     controlbounds.setLow(-1);
113 |     controlbounds.setHigh(1);
114 |     controlbounds.setLow(0, 5.);
115 |     controlbounds.setHigh(0, 15.);
116 |     getControlSpace()->as<control::RealVectorControlSpace>()->setBounds(controlbounds);
117 | }
118 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/QuadrotorPlanning.h:
--------------------------------------------------------------------------------
  1 | /*********************************************************************
  2 | * Rice University Software Distribution License
  3 | *
  4 | * Copyright (c) 2010, Rice University
  5 | * All Rights Reserved.
  6 | *
  7 | * For a full description see the file named LICENSE.
  8 | *
  9 | *********************************************************************/
 10 | 
 11 | /* Author: Mark Moll */
 12 | 
 13 | #ifndef OMPLAPP_QUADROTOR_PLANNING_
 14 | #define OMPLAPP_QUADROTOR_PLANNING_
 15 | 
 16 | #include "omplapp/apps/AppBase.h"
 17 | #include <ompl/base/spaces/SE3StateSpace.h>
 18 | #include <ompl/control/ODESolver.h>
 19 | #include <ompl/control/spaces/RealVectorControlSpace.h>
 20 | 
 21 | namespace ompl
 22 | {
 23 |     namespace app
 24 |     {
 25 |         /** \brief A class to facilitate planning for a simple quadrotor model
 26 | 
 27 |             The dynamics of the quadrotor are described by the following equations:
 28 |             \f{eqnarray*}{
 29 |             m\mathbf{\ddot p} &=& -u_0\mathbf{n}-\beta\mathbf{\dot p} -m\mathbf{g},\\
 30 |             \mathbf{\alpha} &=& (u_1,u_2,u_3)^T,\f}
 31 |             where \f$\mathbf{p}\f$ is the position, \f$\mathbf{n}\f$ is the Z-axis of
 32 |             the body frame in world coordinates, \f$\alpha\f$ is the angular
 33 |             acceleration, \f$m\f$ is the mass, and \f$\beta\f$ is a damping coefficient.
 34 |             The system is controlled through \f$u=(u_0,u_1,u_2,u_3)\f$.
 35 |         */
 36 |         class QuadrotorPlanning : public AppBase<AppType::CONTROL>
 37 |         {
 38 |         public:
 39 |             QuadrotorPlanning()
 40 |                 : AppBase<AppType::CONTROL>(constructControlSpace(), Motion_3D),
 41 |                   odeSolver(std::make_shared<control::ODEBasicSolver<>>(si_, [this](const control::ODESolver::StateType& q, const control::Control *ctrl, control::ODESolver::StateType& qdot)
 42 |                       {
 43 |                           ode(q, ctrl, qdot);
 44 |                       }))
 45 |             {
 46 |                 name_ = std::string("Quadrotor");
 47 |                 setDefaultBounds();
 48 | 
 49 |                 si_->setStatePropagator(control::ODESolver::getStatePropagator(odeSolver,
 50 |                     [this](const base::State* state, const control::Control* control, const double duration, base::State* result)
 51 |                     {
 52 |                         postPropagate(state, control, duration, result);
 53 |                     }));
 54 |             }
 55 |             ~QuadrotorPlanning() override = default;
 56 | 
 57 |             bool isSelfCollisionEnabled() const override
 58 |             {
 59 |                 return false;
 60 |             }
 61 |             unsigned int getRobotCount() const override
 62 |             {
 63 |                 return 1;
 64 |             }
 65 |             base::ScopedState<> getDefaultStartState() const override;
 66 |             base::ScopedState<> getFullStateFromGeometricComponent(const base::ScopedState<> &state) const override;
 67 |             const base::StateSpacePtr& getGeometricComponentStateSpace() const override
 68 |             {
 69 |                 return getStateSpace()->as<base::CompoundStateSpace>()->getSubspace(0);
 70 |             }
 71 |             double getMass()
 72 |             {
 73 |                 return 1./massInv_;
 74 |             }
 75 |             void setMass(double mass)
 76 |             {
 77 |                 massInv_ = 1./mass;
 78 |             }
 79 |             double getDampingCoefficient()
 80 |             {
 81 |                 return beta_;
 82 |             }
 83 |             void setDampingCoefficient(double beta)
 84 |             {
 85 |                 beta_ = beta;
 86 |             }
 87 |             virtual void setDefaultBounds();
 88 | 
 89 |         protected:
 90 | 
 91 |             const base::State* getGeometricComponentStateInternal(const base::State* state, unsigned int /*index*/) const override
 92 |             {
 93 |                 return state->as<base::CompoundState>()->components[0];
 94 |             }
 95 | 
 96 |             virtual void ode(const control::ODESolver::StateType& q, const control::Control* ctrl, control::ODESolver::StateType& qdot);
 97 | 
 98 |             virtual void postPropagate(const base::State* state, const control::Control* control, double duration, base::State* result);
 99 | 
100 |             static control::ControlSpacePtr constructControlSpace()
101 |             {
102 |                 return std::make_shared<control::RealVectorControlSpace>(constructStateSpace(), 4);
103 |             }
104 |             static base::StateSpacePtr constructStateSpace();
105 | 
106 |             double timeStep_{1e-2};
107 |             double massInv_{1.};
108 |             double beta_{1.};
109 |             control::ODESolverPtr odeSolver;
110 |         };
111 | 
112 |     }
113 | }
114 | 
115 | #endif
116 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/SE2MultiRigidBodyPlanning.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2012, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ryan Luna */
12 | 
13 | #include "omplapp/apps/SE2MultiRigidBodyPlanning.h"
14 | 
15 | ompl::app::SE2MultiRigidBodyPlanning::SE2MultiRigidBodyPlanning(unsigned int n) :
16 |     AppBase<AppType::GEOMETRIC>(std::make_shared<base::CompoundStateSpace>(), Motion_2D), n_(n)
17 | {
18 |     assert (n > 0);
19 |     name_ = "Multi rigid body planning (2D)";
20 |     // Adding n SE(2) StateSpaces
21 |     for (unsigned int i = 0; i < n_; ++i)
22 |         si_->getStateSpace()->as<base::CompoundStateSpace>()->addSubspace(
23 |             std::make_shared<base::SE2StateSpace>(), 1.0);
24 | }
25 | 
26 | void ompl::app::SE2MultiRigidBodyPlanning::inferEnvironmentBounds()
27 | {
28 |     // Infer bounds for all n SE(2) spaces
29 |     for (unsigned int i = 0; i < n_; ++i)
30 |         InferEnvironmentBounds(getGeometricComponentStateSpace(i), *static_cast<RigidBodyGeometry*>(this));
31 | }
32 | 
33 | void ompl::app::SE2MultiRigidBodyPlanning::inferProblemDefinitionBounds()
34 | {
35 |     // Make sure that all n SE(2) spaces get the same bounds, if they are adjusted
36 |     for (unsigned int i = 0; i < n_; ++i)
37 |         InferProblemDefinitionBounds(AppTypeSelector<AppType::GEOMETRIC>::SimpleSetup::getProblemDefinition(),
38 |                                     getGeometricStateExtractor(), factor_, add_,
39 |                                     n_, getGeometricComponentStateSpace(i), mtype_);
40 | }
41 | 
42 | ompl::base::ScopedState<> ompl::app::SE2MultiRigidBodyPlanning::getDefaultStartState() const
43 | {
44 |     base::ScopedState<> st(getStateSpace());
45 |     auto* c_st = st->as<base::CompoundStateSpace::StateType>();
46 |     for (unsigned int i = 0; i < n_; ++i)
47 |     {
48 |         aiVector3D s = getRobotCenter(i);
49 |         auto* sub = c_st->as<base::SE2StateSpace::StateType>(i);
50 |         sub->setX(s.x);
51 |         sub->setY(s.y);
52 |         sub->setYaw(0.0);
53 |     }
54 |     return st;
55 | }
56 | 
57 | const ompl::base::State* ompl::app::SE2MultiRigidBodyPlanning::getGeometricComponentStateInternal(const ompl::base::State* state, unsigned int index) const
58 | {
59 |     assert (index < n_);
60 |     const auto* st = state->as<base::CompoundStateSpace::StateType>()->as<base::SE2StateSpace::StateType>(index);
61 |     return static_cast<const base::State*>(st);
62 | }
63 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/SE2MultiRigidBodyPlanning.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2012, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ryan Luna */
12 | 
13 | #include "omplapp/config.h"
14 | #include "omplapp/apps/AppBase.h"
15 | #include <ompl/base/spaces/SE2StateSpace.h>
16 | 
17 | namespace ompl
18 | {
19 |     namespace app
20 |     {
21 | 
22 |         /// @brief Wrapper for ompl::app::RigidBodyPlanning that plans for multiple rigid bodies in SE2.
23 |         class SE2MultiRigidBodyPlanning : public AppBase<AppType::GEOMETRIC>
24 |         {
25 |         public:
26 |             /// @brief Constructs an instance of multiple rigid bodies for 2D geometric planning.  n is the number of independent bodies in SE(2)
27 |             SE2MultiRigidBodyPlanning(unsigned int n);
28 | 
29 |             ~SE2MultiRigidBodyPlanning() override = default;
30 | 
31 |             /// @brief Constructs the default start state where all robots begin at their geometric center.
32 |             /// If robots are all using the same mesh, this state is not likely to be valid.
33 |             base::ScopedState<> getDefaultStartState() const override;
34 | 
35 |             void inferEnvironmentBounds() override;
36 | 
37 |             void inferProblemDefinitionBounds() override;
38 | 
39 |             bool isSelfCollisionEnabled() const override
40 |             {
41 |                 // Make sure that self collision is enabled to avoid inter-rigid body collision
42 |                 return true;
43 |             }
44 | 
45 |             base::ScopedState<> getFullStateFromGeometricComponent(const base::ScopedState<> &state) const override
46 |             {
47 |                 return state;
48 |             }
49 | 
50 |             /// @brief Returns the state space corresponding for the indexth rigid body
51 |             virtual const base::StateSpacePtr& getGeometricComponentStateSpace(unsigned int index) const
52 |             {
53 |                 return getStateSpace()->as<base::CompoundStateSpace>()->getSubspace(index);
54 |             }
55 | 
56 |             const base::StateSpacePtr& getGeometricComponentStateSpace() const override
57 |             {
58 |                 // Return the zeroth component.  All components are the same.
59 |                 return getGeometricComponentStateSpace(0);
60 |             }
61 | 
62 |             unsigned int getRobotCount() const override
63 |             {
64 |                 return n_;
65 |             }
66 | 
67 |         protected:
68 |             /// @brief Returns the state corresponding to the indexth rigid body in the compound state
69 |             const base::State* getGeometricComponentStateInternal(const base::State* state, unsigned int index) const override;
70 | 
71 |             /// @brief The number of independent rigid bodies to plan for
72 |             unsigned int n_;
73 |         };
74 | 
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/SE2RigidBodyPlanning.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #include "omplapp/apps/SE2RigidBodyPlanning.h"
14 | 
15 | ompl::base::ScopedState<> ompl::app::SE2RigidBodyPlanning::getDefaultStartState() const
16 | {
17 |     base::ScopedState<base::SE2StateSpace> st(getGeometricComponentStateSpace());
18 |     aiVector3D s = getRobotCenter(0);
19 | 
20 |     st->setX(s.x);
21 |     st->setY(s.y);
22 |     st->setYaw(0.0);
23 | 
24 |     return st;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/SE2RigidBodyPlanning.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #ifndef OMPLAPP_SE2_RIGID_BODY_PLANNING_
14 | #define OMPLAPP_SE2_RIGID_BODY_PLANNING_
15 | 
16 | #include <ompl/base/spaces/SE2StateSpace.h>
17 | 
18 | #include "omplapp/apps/AppBase.h"
19 | 
20 | namespace ompl
21 | {
22 |     namespace app
23 |     {
24 | 
25 |         /** \brief Wrapper for ompl::app::RigidBodyPlanning that plans
26 |             for rigid bodies in SE2. */
27 |         class SE2RigidBodyPlanning : public AppBase<AppType::GEOMETRIC>
28 |         {
29 |         public:
30 |             SE2RigidBodyPlanning() : AppBase<AppType::GEOMETRIC>(std::make_shared<base::SE2StateSpace>(), Motion_2D)
31 |             {
32 |                 name_ = "Rigid body planning (2D)";
33 |             }
34 |             template <typename CarStateSpacePtr>
35 |             explicit SE2RigidBodyPlanning(CarStateSpacePtr carstatespace)
36 |               : AppBase<AppType::GEOMETRIC>(carstatespace, Motion_2D)
37 |             {
38 |                 name_ = "Geometric car-like planning (2D)";
39 |             }
40 | 
41 |             ~SE2RigidBodyPlanning() override = default;
42 | 
43 |             bool isSelfCollisionEnabled() const override
44 |             {
45 |                 return false;
46 |             }
47 | 
48 |             base::ScopedState<> getDefaultStartState() const override;
49 | 
50 |             base::ScopedState<> getFullStateFromGeometricComponent(const base::ScopedState<> &state) const override
51 |             {
52 |                 return state;
53 |             }
54 | 
55 |             const base::StateSpacePtr& getGeometricComponentStateSpace() const override
56 |             {
57 |                 return getStateSpace();
58 |             }
59 | 
60 |             unsigned int getRobotCount() const override
61 |             {
62 |                 return 1;
63 |             }
64 | 
65 |         protected:
66 | 
67 |             const base::State* getGeometricComponentStateInternal(const base::State* state, unsigned int /*index*/) const override
68 |             {
69 |                 return state;
70 |             }
71 | 
72 |         };
73 | 
74 |     }
75 | }
76 | 
77 | #endif
78 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/SE3MultiRigidBodyPlanning.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2012, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ryan Luna */
12 | 
13 | #include "omplapp/apps/SE3MultiRigidBodyPlanning.h"
14 | 
15 | ompl::app::SE3MultiRigidBodyPlanning::SE3MultiRigidBodyPlanning(unsigned int n) :
16 |     AppBase<AppType::GEOMETRIC>(std::make_shared<base::CompoundStateSpace>(), Motion_3D), n_(n)
17 | {
18 |     assert (n > 0);
19 |     name_ = "Multi rigid body planning (3D)";
20 |     // Adding n SE(3) StateSpaces
21 |     for (unsigned int i = 0; i < n_; ++i)
22 |         si_->getStateSpace()->as<base::CompoundStateSpace>()->addSubspace(
23 |             std::make_shared<base::SE3StateSpace>(), 1.0);
24 | }
25 | 
26 | void ompl::app::SE3MultiRigidBodyPlanning::inferEnvironmentBounds()
27 | {
28 |     // Infer bounds for all n SE(3) spaces
29 |     for (unsigned int i = 0; i < n_; ++i)
30 |         InferEnvironmentBounds(getGeometricComponentStateSpace(i), *static_cast<RigidBodyGeometry*>(this));
31 | }
32 | 
33 | void ompl::app::SE3MultiRigidBodyPlanning::inferProblemDefinitionBounds()
34 | {
35 |     // Make sure that all n SE(3) spaces get the same bounds, if they are adjusted
36 |     for (unsigned int i = 0; i < n_; ++i)
37 |         InferProblemDefinitionBounds(AppTypeSelector<AppType::GEOMETRIC>::SimpleSetup::getProblemDefinition(),
38 |                                     getGeometricStateExtractor(), factor_, add_,
39 |                                     n_, getGeometricComponentStateSpace(i), mtype_);
40 | }
41 | 
42 | ompl::base::ScopedState<> ompl::app::SE3MultiRigidBodyPlanning::getDefaultStartState() const
43 | {
44 |     base::ScopedState<> st(getStateSpace());
45 |     auto* c_st = st->as<base::CompoundStateSpace::StateType>();
46 |     for (unsigned int i = 0; i < n_; ++i)
47 |     {
48 |         aiVector3D s = getRobotCenter(i);
49 |         auto* sub = c_st->as<base::SE3StateSpace::StateType>(i);
50 |         sub->setX(s.x);
51 |         sub->setY(s.y);
52 |         sub->setZ(s.z);
53 |         sub->rotation().setIdentity();
54 |     }
55 |     return st;
56 | }
57 | 
58 | const ompl::base::State* ompl::app::SE3MultiRigidBodyPlanning::getGeometricComponentStateInternal(const ompl::base::State* state, unsigned int index) const
59 | {
60 |     assert (index < n_);
61 |     const auto* st = state->as<base::CompoundStateSpace::StateType>()->as<base::SE3StateSpace::StateType>(index);
62 |     return static_cast<const base::State*>(st);
63 | }
64 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/SE3MultiRigidBodyPlanning.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2012, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ryan Luna */
12 | 
13 | #include "omplapp/config.h"
14 | #include "omplapp/apps/AppBase.h"
15 | #include <ompl/base/spaces/SE3StateSpace.h>
16 | 
17 | namespace ompl
18 | {
19 |     namespace app
20 |     {
21 | 
22 |         /// @brief Wrapper for ompl::app::RigidBodyPlanning that plans for multiple rigid bodies in SE3.
23 |         class SE3MultiRigidBodyPlanning : public AppBase<AppType::GEOMETRIC>
24 |         {
25 |         public:
26 |             /// @brief Constructs an instance of multiple rigid bodies for 3D geometric planning.  n is the number of independent bodies in SE(3)
27 |             SE3MultiRigidBodyPlanning(unsigned int n);
28 | 
29 |             ~SE3MultiRigidBodyPlanning() override = default;
30 | 
31 |             /// @brief Constructs the default start state where all robots begin at their geometric center.
32 |             /// If robots are all using the same mesh, this state is not likely to be valid.
33 |             base::ScopedState<> getDefaultStartState() const override;
34 | 
35 |             void inferEnvironmentBounds() override;
36 | 
37 |             void inferProblemDefinitionBounds() override;
38 | 
39 |             bool isSelfCollisionEnabled() const override
40 |             {
41 |                 // Make sure that self collision is enabled to avoid inter-rigid body collision
42 |                 return true;
43 |             }
44 | 
45 |             base::ScopedState<> getFullStateFromGeometricComponent(const base::ScopedState<> &state) const override
46 |             {
47 |                 return state;
48 |             }
49 | 
50 |             /// @brief Returns the state space corresponding for the indexth rigid body
51 |             virtual const base::StateSpacePtr& getGeometricComponentStateSpace(unsigned int index) const
52 |             {
53 |                 return getStateSpace()->as<base::CompoundStateSpace>()->getSubspace(index);
54 |             }
55 | 
56 |             const base::StateSpacePtr& getGeometricComponentStateSpace() const override
57 |             {
58 |                 // Return the zeroth component.  All components are the same.
59 |                 return getGeometricComponentStateSpace(0);
60 |             }
61 | 
62 |             unsigned int getRobotCount() const override
63 |             {
64 |                 return n_;
65 |             }
66 | 
67 |         protected:
68 |             /// @brief Returns the state corresponding to the indexth rigid body in the compound state
69 |             const base::State* getGeometricComponentStateInternal(const base::State* state, unsigned int index) const override;
70 | 
71 |             /// @brief The number of independent rigid bodies to plan for
72 |             unsigned int n_;
73 |         };
74 | 
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/SE3RigidBodyPlanning.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #include "omplapp/apps/SE3RigidBodyPlanning.h"
14 | 
15 | ompl::base::ScopedState<> ompl::app::SE3RigidBodyPlanning::getDefaultStartState() const
16 | {
17 |     base::ScopedState<base::SE3StateSpace> st(getGeometricComponentStateSpace());
18 |     aiVector3D s = getRobotCenter(0);
19 | 
20 |     st->setX(s.x);
21 |     st->setY(s.y);
22 |     st->setZ(s.z);
23 |     st->rotation().setIdentity();
24 | 
25 |     return st;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/SE3RigidBodyPlanning.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #ifndef OMPLAPP_SE3_RIGID_BODY_PLANNING_
14 | #define OMPLAPP_SE3_RIGID_BODY_PLANNING_
15 | 
16 | #include "omplapp/apps/AppBase.h"
17 | #include <ompl/base/spaces/SE3StateSpace.h>
18 | 
19 | namespace ompl
20 | {
21 |     namespace app
22 |     {
23 | 
24 |         /** \brief Wrapper for ompl::app::RigidBodyPlanning that plans
25 |             for rigid bodies in SE3. */
26 |         class SE3RigidBodyPlanning : public AppBase<AppType::GEOMETRIC>
27 |         {
28 |         public:
29 | 
30 |             SE3RigidBodyPlanning() : AppBase<AppType::GEOMETRIC>(std::make_shared<base::SE3StateSpace>(), Motion_3D)
31 |             {
32 |                 name_ = "Rigid body planning (3D)";
33 |             }
34 | 
35 |             ~SE3RigidBodyPlanning() override = default;
36 | 
37 |             bool isSelfCollisionEnabled() const override
38 |             {
39 |                 return false;
40 |             }
41 | 
42 |             base::ScopedState<> getDefaultStartState() const override;
43 | 
44 |             base::ScopedState<> getFullStateFromGeometricComponent(const base::ScopedState<> &state) const override
45 |             {
46 |                 return state;
47 |             }
48 | 
49 |             const base::StateSpacePtr& getGeometricComponentStateSpace() const override
50 |             {
51 |                 return getStateSpace();
52 |             }
53 | 
54 |             unsigned int getRobotCount() const override
55 |             {
56 |                 return 1;
57 |             }
58 | 
59 |         protected:
60 | 
61 |             const base::State* getGeometricComponentStateInternal(const base::State* state, unsigned int /*index*/) const override
62 |             {
63 |                 return state;
64 |             }
65 | 
66 |         };
67 | 
68 |     }
69 | }
70 | 
71 | #endif
72 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/detail/appUtil.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #include <ompl/base/ProblemDefinition.h>
14 | #include <ompl/control/planners/syclop/Decomposition.h>
15 | #include "omplapp/geometry/RigidBodyGeometry.h"
16 | 
17 | namespace ompl
18 | {
19 | 
20 |     namespace app
21 |     {
22 | 
23 |         void InferProblemDefinitionBounds(const base::ProblemDefinitionPtr &pdef, const GeometricStateExtractor &se, double factor, double add,
24 |                                           unsigned int robotCount, const base::StateSpacePtr &space, MotionModel mtype);
25 |         void InferEnvironmentBounds(const base::StateSpacePtr &space, const RigidBodyGeometry &rbg);
26 | 
27 |         base::ProjectionEvaluatorPtr allocGeometricStateProjector(const base::StateSpacePtr &space, MotionModel mtype,
28 |                                                                   const base::StateSpacePtr &gspace, const GeometricStateExtractor &se);
29 | 
30 |         /** \brief Allocate a default 2D/3D grid decomposition (depending on the MotionModel)
31 |             for use with the SyclopEST and SyclopRRT planners. */
32 |         control::DecompositionPtr allocDecomposition(const base::StateSpacePtr &space, MotionModel mtype,
33 |             const base::StateSpacePtr &gspace);
34 | 
35 |         /** \brief Create an optimization objective. The objective name can be:
36 |             "length", "max min clearance", or "mechanical work" */
37 |         ompl::base::OptimizationObjectivePtr getOptimizationObjective(const base::SpaceInformationPtr &si, const std::string &objective, double threshold);
38 | 
39 |     }
40 | 
41 | }
42 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/graphical/GBlimpPlanning.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Mark Moll */
12 | 
13 | #ifndef OMPLAPP_G_BLIMP_PLANNING_
14 | #define OMPLAPP_G_BLIMP_PLANNING_
15 | 
16 | #include "omplapp/apps/BlimpPlanning.h"
17 | #include "omplapp/graphics/RenderGeometry.h"
18 | 
19 | namespace ompl
20 | {
21 |     namespace app
22 |     {
23 | 
24 |         class GBlimpPlanning : public BlimpPlanning,
25 |                                public RenderGeometry
26 |         {
27 |         public:
28 | 
29 |             GBlimpPlanning(void) : BlimpPlanning(),
30 |                                    RenderGeometry(*dynamic_cast<const RigidBodyGeometry*>(this), getGeometricStateExtractor())
31 |             {
32 |             }
33 | 
34 |             virtual ~GBlimpPlanning(void)
35 |             {
36 |             }
37 |         };
38 |     }
39 | }
40 | 
41 | #endif
42 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/graphical/GDynamicCarPlanning.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Mark Moll */
12 | 
13 | #ifndef OMPLAPP_G_DYNAMIC_CAR_PLANNING_
14 | #define OMPLAPP_G_DYNAMIC_CAR_PLANNING_
15 | 
16 | #include "omplapp/apps/DynamicCarPlanning.h"
17 | #include "omplapp/graphics/RenderGeometry.h"
18 | 
19 | namespace ompl
20 | {
21 |     namespace app
22 |     {
23 | 
24 |         class GDynamicCarPlanning : public DynamicCarPlanning,
25 |                                     public RenderGeometry
26 |         {
27 |         public:
28 | 
29 |             GDynamicCarPlanning(void) : DynamicCarPlanning(),
30 |                                         RenderGeometry(*dynamic_cast<const RigidBodyGeometry*>(this), getGeometricStateExtractor())
31 |             {
32 |             }
33 | 
34 |             virtual ~GDynamicCarPlanning(void)
35 |             {
36 |             }
37 |         };
38 |     }
39 | }
40 | 
41 | #endif
42 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/graphical/GKinematicCarPlanning.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Mark Moll */
12 | 
13 | #ifndef OMPLAPP_G_KINEMATIC_CAR_PLANNING_
14 | #define OMPLAPP_G_KINEMATIC_CAR_PLANNING_
15 | 
16 | #include "omplapp/apps/KinematicCarPlanning.h"
17 | #include "omplapp/graphics/RenderGeometry.h"
18 | 
19 | namespace ompl
20 | {
21 |     namespace app
22 |     {
23 | 
24 |         class GKinematicCarPlanning : public KinematicCarPlanning,
25 |                                     public RenderGeometry
26 |         {
27 |         public:
28 | 
29 |             GKinematicCarPlanning(void) : KinematicCarPlanning(),
30 |                                         RenderGeometry(*dynamic_cast<const RigidBodyGeometry*>(this), getGeometricStateExtractor())
31 |             {
32 |             }
33 | 
34 |             virtual ~GKinematicCarPlanning(void)
35 |             {
36 |             }
37 |         };
38 |     }
39 | }
40 | 
41 | #endif
42 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/graphical/GQuadrotorPlanning.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Mark Moll */
12 | 
13 | #ifndef OMPLAPP_G_QUADROTOR_PLANNING_
14 | #define OMPLAPP_G_QUADROTOR_PLANNING_
15 | 
16 | #include "omplapp/apps/QuadrotorPlanning.h"
17 | #include "omplapp/graphics/RenderGeometry.h"
18 | 
19 | namespace ompl
20 | {
21 |     namespace app
22 |     {
23 | 
24 |         class GQuadrotorPlanning : public QuadrotorPlanning,
25 |                                    public RenderGeometry
26 |         {
27 |         public:
28 | 
29 |             GQuadrotorPlanning(void) : QuadrotorPlanning(),
30 |                                        RenderGeometry(*dynamic_cast<const RigidBodyGeometry*>(this), getGeometricStateExtractor())
31 |             {
32 |             }
33 | 
34 |             virtual ~GQuadrotorPlanning(void)
35 |             {
36 |             }
37 |         };
38 |     }
39 | }
40 | 
41 | #endif
42 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/graphical/GSE2RigidBodyPlanning.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #ifndef OMPLAPP_G_SE2_RIGID_BODY_PLANNING_
14 | #define OMPLAPP_G_SE2_RIGID_BODY_PLANNING_
15 | 
16 | #include "omplapp/apps/SE2RigidBodyPlanning.h"
17 | #include "omplapp/graphics/RenderGeometry.h"
18 | 
19 | namespace ompl
20 | {
21 |     namespace app
22 |     {
23 | 
24 |         class GSE2RigidBodyPlanning : public SE2RigidBodyPlanning,
25 |                                       public RenderGeometry
26 |         {
27 |         public:
28 | 
29 |             GSE2RigidBodyPlanning(void) : SE2RigidBodyPlanning(),
30 |                                           RenderGeometry(*dynamic_cast<const RigidBodyGeometry*>(this), getGeometricStateExtractor())
31 |             {
32 |             }
33 | 
34 |             virtual ~GSE2RigidBodyPlanning(void)
35 |             {
36 |             }
37 |         };
38 | 
39 |     }
40 | }
41 | 
42 | #endif
43 | 


--------------------------------------------------------------------------------
/src/omplapp/apps/graphical/GSE3RigidBodyPlanning.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #ifndef OMPLAPP_G_SE3_RIGID_BODY_PLANNING_
14 | #define OMPLAPP_G_SE3_RIGID_BODY_PLANNING_
15 | 
16 | #include "omplapp/apps/SE3RigidBodyPlanning.h"
17 | #include "omplapp/graphics/RenderGeometry.h"
18 | 
19 | namespace ompl
20 | {
21 |     namespace app
22 |     {
23 | 
24 |         class GSE3RigidBodyPlanning : public SE3RigidBodyPlanning,
25 |                                       public RenderGeometry
26 |         {
27 |         public:
28 | 
29 |             GSE3RigidBodyPlanning(void) : SE3RigidBodyPlanning(),
30 |                                           RenderGeometry(*dynamic_cast<const RigidBodyGeometry*>(this), getGeometricStateExtractor())
31 |             {
32 |             }
33 | 
34 |             virtual ~GSE3RigidBodyPlanning(void)
35 |             {
36 |             }
37 |         };
38 | 
39 |     }
40 | }
41 | 
42 | #endif
43 | 


--------------------------------------------------------------------------------
/src/omplapp/config.h.in:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #ifndef OMPLAPP_COMMON_CONFIG_
14 | #define OMPLAPP_COMMON_CONFIG_
15 | 
16 | #define OMPLAPP_RESOURCE_DIR "@OMPLAPP_RESOURCE_DIR@"
17 | 
18 | /** Whether PQP was found */
19 | #cmakedefine01 OMPL_HAS_PQP
20 | 
21 | #endif
22 | 


--------------------------------------------------------------------------------
/src/omplapp/geometry/GeometrySpecification.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #ifndef OMPLAPP_GEOMETRY_GEOMETRY_SPECIFICATION_
14 | #define OMPLAPP_GEOMETRY_GEOMETRY_SPECIFICATION_
15 | 
16 | #include "omplapp/config.h"
17 | #include <assimp/scene.h>
18 | #include <vector>
19 | #include <functional>
20 | #include <ompl/base/State.h>
21 | 
22 | namespace ompl
23 | {
24 |     namespace app
25 |     {
26 | 
27 |         /// Specify whether bodies are moving in 2D or bodies moving in 3D
28 |         enum MotionModel { Motion_2D, Motion_3D };
29 | 
30 |         using GeometricStateExtractor = std::function<const base::State *(const base::State *, unsigned int)>;
31 | 
32 |         class GeometrySpecification
33 |         {
34 |         public:
35 | 
36 |             GeometrySpecification() = default;
37 | 
38 |             std::vector<const aiScene *> robot;
39 |             std::vector<aiVector3D>      robotShift;
40 | 
41 |             std::vector<const aiScene *> obstacles;
42 |             std::vector<aiVector3D>      obstaclesShift;
43 |         };
44 | 
45 |     }
46 | }
47 | #endif
48 | 


--------------------------------------------------------------------------------
/src/omplapp/geometry/detail/assimpUtil.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #ifndef OMPLAPP_GEOMETRY_DETAIL_ASSIMP_UTIL_
14 | #define OMPLAPP_GEOMETRY_DETAIL_ASSIMP_UTIL_
15 | 
16 | #ifdef _WIN32
17 | #include <windows.h>
18 | #endif
19 | 
20 | #include "omplapp/config.h"
21 | #include <assimp/scene.h>
22 | #include <assimp/cimport.h>
23 | #include <assimp/postprocess.h>
24 | #include <ompl/base/spaces/RealVectorBounds.h>
25 | #include <vector>
26 | 
27 | namespace ompl
28 | {
29 |     namespace app
30 |     {
31 | 
32 |         /// @cond IGNORE
33 |         /** \brief Utilitiy functions for processing imported scenes */
34 |         namespace scene
35 |         {
36 | 
37 |             void inferBounds(base::RealVectorBounds &bounds, const std::vector<aiVector3D> &vertices, double multiply = 1.1, double add = 0.0);
38 |             void extractTriangles(const aiScene *scene, std::vector<aiVector3D> &triangles);
39 |             void extractVertices(const aiScene *scene, std::vector<aiVector3D> &vertices);
40 |             double shortestEdge(const aiScene *scene);
41 |             void sceneCenter(const aiScene *scene, aiVector3D &center);
42 |         }
43 |         /// @endcond
44 |     }
45 | }
46 | #endif
47 | 


--------------------------------------------------------------------------------
/src/omplapp/graphics/RenderGeometry.cpp:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #include "omplapp/graphics/RenderGeometry.h"
14 | #include "omplapp/graphics/detail/assimpGUtil.h"
15 | #include "omplapp/graphics/detail/RenderPlannerData.h"
16 | 
17 | int ompl::app::RenderGeometry::renderEnvironment() const
18 | {
19 |     const GeometrySpecification &gs = rbg_.getGeometrySpecification();
20 |     return scene::assimpRender(gs.obstacles, gs.obstaclesShift);
21 | }
22 | 
23 | int ompl::app::RenderGeometry::renderRobot() const
24 | {
25 |     const GeometrySpecification &gs = rbg_.getGeometrySpecification();
26 |     return scene::assimpRender(gs.robot, gs.robotShift);
27 | }
28 | 
29 | int ompl::app::RenderGeometry::renderRobotPart(unsigned int index) const
30 | {
31 |     const GeometrySpecification &gs = rbg_.getGeometrySpecification();
32 |     if (index >= gs.robot.size())
33 |         return 0;
34 |     return scene::assimpRender(gs.robot[index], gs.robotShift.size() > index ? gs.robotShift[index] : aiVector3D(0.0, 0.0, 0.0));
35 | }
36 | 
37 | int ompl::app::RenderGeometry::renderPlannerData(const base::PlannerData &pd) const
38 | {
39 |     return RenderPlannerData(pd, aiVector3D(0.0, 0.0, 0.0), rbg_.getMotionModel(), se_, rbg_.getLoadedRobotCount());
40 | }
41 | 


--------------------------------------------------------------------------------
/src/omplapp/graphics/RenderGeometry.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #ifndef OMPLAPP_GRAPHICS_RENDER_GEOMETRY_
14 | #define OMPLAPP_GRAPHICS_RENDER_GEOMETRY_
15 | 
16 | #include "omplapp/geometry/RigidBodyGeometry.h"
17 | #include <ompl/base/Planner.h>
18 | 
19 | #include <utility>
20 | 
21 | namespace ompl
22 | {
23 |     namespace app
24 |     {
25 | 
26 |         class RenderGeometry
27 |         {
28 |         public:
29 | 
30 |             /** \brief Constructor expects a state space that can represent a rigid body */
31 |             RenderGeometry(const RigidBodyGeometry &rbg, GeometricStateExtractor se) : rbg_(rbg), se_(std::move(se))
32 |             {
33 |             }
34 | 
35 |             virtual ~RenderGeometry() = default;
36 | 
37 |             int renderEnvironment() const;
38 | 
39 |             int renderRobot() const;
40 | 
41 |             int renderRobotPart(unsigned int index) const;
42 | 
43 |             int renderPlannerData(const base::PlannerData &pd) const;
44 | 
45 |         private:
46 | 
47 |             const RigidBodyGeometry &rbg_;
48 |             GeometricStateExtractor  se_;
49 | 
50 |         };
51 | 
52 |     }
53 | }
54 | 
55 | #endif
56 | 


--------------------------------------------------------------------------------
/src/omplapp/graphics/detail/RenderPlannerData.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #ifndef OMPLAPP_RENDER_PLANNER_DATA_
14 | #define OMPLAPP_RENDER_PLANNER_DATA_
15 | 
16 | #include "omplapp/geometry/GeometrySpecification.h"
17 | #include "omplapp/geometry/detail/assimpUtil.h"
18 | #include <ompl/base/Planner.h>
19 | 
20 | namespace ompl
21 | {
22 |     namespace app
23 |     {
24 | 
25 |         /** \brief Render the planner states in \e pd, after shifting them by \e translate, using the motion model \e m.
26 |             The SE2 (or SE3) states can be extracted from \e pd using \e gse. There are \e robotCount points to extract from each state.
27 |             Return a gl list. */
28 |         int RenderPlannerData(const base::PlannerData &pd, const aiVector3D &translate,
29 |                               MotionModel m, const GeometricStateExtractor &gse, unsigned int count);
30 |     }
31 | }
32 | 
33 | #endif
34 | 


--------------------------------------------------------------------------------
/src/omplapp/graphics/detail/assimpGUtil.h:
--------------------------------------------------------------------------------
 1 | /*********************************************************************
 2 | * Rice University Software Distribution License
 3 | *
 4 | * Copyright (c) 2010, Rice University
 5 | * All Rights Reserved.
 6 | *
 7 | * For a full description see the file named LICENSE.
 8 | *
 9 | *********************************************************************/
10 | 
11 | /* Author: Ioan Sucan */
12 | 
13 | #ifndef OMPLAPP_GRAPHICS_DETAIL_ASSIMP_G_UTIL_
14 | #define OMPLAPP_GRAPHICS_DETAIL_ASSIMP_G_UTIL_
15 | 
16 | #include "omplapp/geometry/detail/assimpUtil.h"
17 | 
18 | namespace ompl
19 | {
20 |     namespace app
21 |     {
22 | 
23 |         /// @cond IGNORE
24 |         /** \brief Utilitiy functions for processing imported scenes */
25 |         namespace scene
26 |         {
27 | 
28 |             int assimpRender(const aiScene* scene);
29 |             int assimpRender(const std::vector<const aiScene*> &scenes);
30 |             int assimpRender(const aiScene* scene, const aiVector3D &robotCenter);
31 |             int assimpRender(const std::vector<const aiScene*> &scenes, const std::vector<aiVector3D> &robotCenter);
32 | 
33 |         }
34 |         /// @endcond
35 |     }
36 | }
37 | #endif
38 | 


--------------------------------------------------------------------------------
/webapp/ompl_webapp:
--------------------------------------------------------------------------------
 1 | #/bin/sh
 2 | trap kill_celery INT
 3 | 
 4 | function kill_celery() {
 5 |     if [[ -e /tmp/omplweb.pid ]]; then
 6 |         kill `cat /tmp/omplweb.pid`
 7 |     fi
 8 | }
 9 | 
10 | cd `dirname $0`
11 | if [[ ! -e omplweb.py ]]; then
12 |     if [[ -e ../share/ompl/webapp/omplweb.py ]]; then
13 |         # assume we are in ${prefix}/bin, cd to ${prefix}/share/ompl/webapp
14 |         cd ../share/ompl/webapp
15 |     else
16 |         echo "Error: cannot find omplweb.py"
17 |         exit -1
18 |     fi
19 | fi
20 | 
21 | celerystatus=`celery status -q -C -A omplweb.celery 2>&1 | cut -f2 -d " "`
22 | if [[ ! ${celerystatus} == "OK" ]]; then
23 |     echo "If you want to use the benchmarking facilities of ompl_webapp,"
24 |     echo "run the \"plannerarena\" command as well."
25 |     celery worker -A omplweb.celery -Q omplapp --loglevel=info --pidfile=/tmp/omplweb.pid --logfile=/tmp/omplweb-celery.log &
26 |     ./omplweb.py
27 |     kill_celery
28 | else
29 |     echo "Celery is already running an omplweb job queue."
30 | fi
31 | 


--------------------------------------------------------------------------------
/webapp/static/fonts/glyphicons-halflings-regular.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/webapp/static/fonts/glyphicons-halflings-regular.eot


--------------------------------------------------------------------------------
/webapp/static/fonts/glyphicons-halflings-regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/webapp/static/fonts/glyphicons-halflings-regular.ttf


--------------------------------------------------------------------------------
/webapp/static/fonts/glyphicons-halflings-regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/webapp/static/fonts/glyphicons-halflings-regular.woff


--------------------------------------------------------------------------------
/webapp/static/fonts/glyphicons-halflings-regular.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ompl/omplapp/958884d6593809ee6a564907ff4e796691d48ffc/webapp/static/fonts/glyphicons-halflings-regular.woff2


--------------------------------------------------------------------------------
/webapp/static/problem_files/2D:
--------------------------------------------------------------------------------
1 | ../../../resources/2D


--------------------------------------------------------------------------------
/webapp/static/problem_files/3D:
--------------------------------------------------------------------------------
1 | ../../../resources/3D


--------------------------------------------------------------------------------
/webapp/static/scripts/helpers.js:
--------------------------------------------------------------------------------
  1 | /* Mathematic Constants */
  2 | var DEG_TO_RAD = Math.PI/180;
  3 | var RAD_TO_DEG = 180/Math.PI;
  4 | 
  5 | 
  6 | /**
  7 |  * Displays dismissable alerts to the page.
  8 |  *
  9 |  * @param {String} page The page on which to display the alert, 'configuration' or 'benchmarking'
 10 |  * @param {String} type The style (color) of the alert: 'info', 'success', 'warning', 'danger'
 11 |  * @param {String} msg The body text of the alert
 12 |  * @return None
 13 |  */
 14 | function showAlert(page, type, msg) {
 15 |     var alert = "<div class='alert alert-dismissible";
 16 |     alert += " alert-" + type;
 17 |     alert += "' role='alert'>";
 18 | 
 19 |     alert += "<button type='button' class='close' data-dismiss='alert' aria-label='Close'><span aria=hidden='true'>&times;</span></button>";
 20 | 
 21 |     alert += msg
 22 | 
 23 |     alert += "</div>";
 24 | 
 25 |     var area = "#" + page + "-alerts";
 26 |     $(area).html(alert);
 27 | }
 28 | 
 29 | 
 30 | /**
 31 |  * Prompts the user to download a file.
 32 |  *
 33 |  * @param {Blob} blob The file blob to download
 34 |  * @param {String} name The filename
 35 |  * @return None
 36 |  */
 37 | function downloadFile(blob, name) {
 38 |     var url = window.URL.createObjectURL(blob);
 39 |     var a = document.createElement("a");
 40 |     document.body.appendChild(a);
 41 |     a.style = "display: none";
 42 |     a.href = url;
 43 |     a.download = name;
 44 |     a.click();
 45 |     window.URL.revokeObjectURL(url);
 46 | }
 47 | 
 48 | 
 49 | /**
 50 |  * Converts a rotation from axis-angle representation into a quaternion.
 51 |  *
 52 |  * @param {float} xyz The unit vector to rotate around.
 53 |  * @param {float} theta The number of radians to rotate.
 54 |  * @return {THREE.Quaternion} The resulting quaternion
 55 |  */
 56 | function axisAngleToQuaternion(x, y, z, theta) {
 57 | 
 58 |     var q = new THREE.Quaternion();
 59 |     q.setFromAxisAngle(new THREE.Vector3(x, y, z), theta);
 60 | 
 61 |     return q;
 62 | 
 63 | }
 64 | 
 65 | 
 66 | /**
 67 |  * Translates a quaternion into degrees around each axis.
 68 |  *
 69 |  * @param {THREE.Quaternion} q A quaternion to be converted
 70 |  * @return {Object} An object describing the number of degrees of rotation
 71 |  * around each axis
 72 |  */
 73 | function quaternionToAxisDegrees(q) {
 74 | 
 75 |     var rot = {};
 76 |     rot.x = RAD_TO_DEG * Math.atan2(2.*(q.w*q.x+q.y*q.z), 1.-2.*(q.x*q.x+q.y*q.y));
 77 |     rot.y = RAD_TO_DEG * Math.asin(Math.max(Math.min(2.*(q.w*q.y-q.z*q.x),1.),-1.));
 78 |     rot.z = RAD_TO_DEG * Math.atan2(2.*(q.w*q.z+q.x*q.y), 1.-2.*(q.y*q.y+q.z*q.z));
 79 | 
 80 |     return rot;
 81 | }
 82 | 
 83 | /* Keyboard Shortcuts */
 84 | 
 85 | Mousetrap.bind('ctrl+c', function(e) {
 86 |     $("#configuration-page").click();
 87 | });
 88 | 
 89 | Mousetrap.bind('ctrl+b', function(e) {
 90 |     $("#benchmarking-page").click();
 91 | });
 92 | 
 93 | Mousetrap.bind('ctrl+s', function(e) {
 94 |     $("#configuration-page").click();
 95 |     $("#solve-tab").click();
 96 |     $("#solve-button").click();
 97 | });
 98 | 
 99 | Mousetrap.bind('ctrl+e', function(e) {
100 |     if ($("#problems").val() == "custom") {
101 |         $("#configuration-page").click();
102 |         $("#problem-tab").click();
103 |         $("#env_path").click();
104 |     }
105 | });
106 | 
107 | Mousetrap.bind('ctrl+r', function(e) {
108 |     if ($("#problems").val() == "custom") {
109 |         $("#configuration-page").click();
110 |         $("#problem-tab").click();
111 |         $("#robot_path").click();
112 |     }
113 | });
114 | 
115 | Mousetrap.bind('ctrl+o', function(e) {
116 |     if ($("#problems").val() == "custom") {
117 |         $("#configuration-page").click();
118 |         $("#problem-tab").click();
119 |         $("#config").click();
120 |     }
121 | });
122 | 
123 | Mousetrap.bind('ctrl+u', function(e) {
124 |     if ($("#problems").val() == "custom") {
125 |         $("#configuration-page").click();
126 |         $("#problem-tab").click();
127 |         $("#uploadModelsButton").click();
128 |     }
129 | });
130 | 


--------------------------------------------------------------------------------
/webapp/static/scripts/libs/mousetrap.min.js:
--------------------------------------------------------------------------------
 1 | /* mousetrap v1.5.3 craig.is/killing/mice */
 2 | (function(C,r,g){function t(a,b,h){a.addEventListener?a.addEventListener(b,h,!1):a.attachEvent("on"+b,h)}function x(a){if("keypress"==a.type){var b=String.fromCharCode(a.which);a.shiftKey||(b=b.toLowerCase());return b}return l[a.which]?l[a.which]:p[a.which]?p[a.which]:String.fromCharCode(a.which).toLowerCase()}function D(a){var b=[];a.shiftKey&&b.push("shift");a.altKey&&b.push("alt");a.ctrlKey&&b.push("ctrl");a.metaKey&&b.push("meta");return b}function u(a){return"shift"==a||"ctrl"==a||"alt"==a||
 3 | "meta"==a}function y(a,b){var h,c,e,g=[];h=a;"+"===h?h=["+"]:(h=h.replace(/\+{2}/g,"+plus"),h=h.split("+"));for(e=0;e<h.length;++e)c=h[e],z[c]&&(c=z[c]),b&&"keypress"!=b&&A[c]&&(c=A[c],g.push("shift")),u(c)&&g.push(c);h=c;e=b;if(!e){if(!k){k={};for(var m in l)95<m&&112>m||l.hasOwnProperty(m)&&(k[l[m]]=m)}e=k[h]?"keydown":"keypress"}"keypress"==e&&g.length&&(e="keydown");return{key:c,modifiers:g,action:e}}function B(a,b){return null===a||a===r?!1:a===b?!0:B(a.parentNode,b)}function c(a){function b(a){a=
 4 | a||{};var b=!1,n;for(n in q)a[n]?b=!0:q[n]=0;b||(v=!1)}function h(a,b,n,f,c,h){var g,e,l=[],m=n.type;if(!d._callbacks[a])return[];"keyup"==m&&u(a)&&(b=[a]);for(g=0;g<d._callbacks[a].length;++g)if(e=d._callbacks[a][g],(f||!e.seq||q[e.seq]==e.level)&&m==e.action){var k;(k="keypress"==m&&!n.metaKey&&!n.ctrlKey)||(k=e.modifiers,k=b.sort().join(",")===k.sort().join(","));k&&(k=f&&e.seq==f&&e.level==h,(!f&&e.combo==c||k)&&d._callbacks[a].splice(g,1),l.push(e))}return l}function g(a,b,n,f){d.stopCallback(b,
 5 | b.target||b.srcElement,n,f)||!1!==a(b,n)||(b.preventDefault?b.preventDefault():b.returnValue=!1,b.stopPropagation?b.stopPropagation():b.cancelBubble=!0)}function e(a){"number"!==typeof a.which&&(a.which=a.keyCode);var b=x(a);b&&("keyup"==a.type&&w===b?w=!1:d.handleKey(b,D(a),a))}function l(a,c,n,f){function e(c){return function(){v=c;++q[a];clearTimeout(k);k=setTimeout(b,1E3)}}function h(c){g(n,c,a);"keyup"!==f&&(w=x(c));setTimeout(b,10)}for(var d=q[a]=0;d<c.length;++d){var p=d+1===c.length?h:e(f||
 6 | y(c[d+1]).action);m(c[d],p,f,a,d)}}function m(a,b,c,f,e){d._directMap[a+":"+c]=b;a=a.replace(/\s+/g," ");var g=a.split(" ");1<g.length?l(a,g,b,c):(c=y(a,c),d._callbacks[c.key]=d._callbacks[c.key]||[],h(c.key,c.modifiers,{type:c.action},f,a,e),d._callbacks[c.key][f?"unshift":"push"]({callback:b,modifiers:c.modifiers,action:c.action,seq:f,level:e,combo:a}))}var d=this;a=a||r;if(!(d instanceof c))return new c(a);d.target=a;d._callbacks={};d._directMap={};var q={},k,w=!1,p=!1,v=!1;d._handleKey=function(a,
 7 | c,e){var f=h(a,c,e),d;c={};var k=0,l=!1;for(d=0;d<f.length;++d)f[d].seq&&(k=Math.max(k,f[d].level));for(d=0;d<f.length;++d)f[d].seq?f[d].level==k&&(l=!0,c[f[d].seq]=1,g(f[d].callback,e,f[d].combo,f[d].seq)):l||g(f[d].callback,e,f[d].combo);f="keypress"==e.type&&p;e.type!=v||u(a)||f||b(c);p=l&&"keydown"==e.type};d._bindMultiple=function(a,b,c){for(var d=0;d<a.length;++d)m(a[d],b,c)};t(a,"keypress",e);t(a,"keydown",e);t(a,"keyup",e)}var l={8:"backspace",9:"tab",13:"enter",16:"shift",17:"ctrl",18:"alt",
 8 | 20:"capslock",27:"esc",32:"space",33:"pageup",34:"pagedown",35:"end",36:"home",37:"left",38:"up",39:"right",40:"down",45:"ins",46:"del",91:"meta",93:"meta",224:"meta"},p={106:"*",107:"+",109:"-",110:".",111:"/",186:";",187:"=",188:",",189:"-",190:".",191:"/",192:"`",219:"[",220:"\\",221:"]",222:"'"},A={"~":"`","!":"1","@":"2","#":"3",$:"4","%":"5","^":"6","&":"7","*":"8","(":"9",")":"0",_:"-","+":"=",":":";",'"':"'","<":",",">":".","?":"/","|":"\\"},z={option:"alt",command:"meta","return":"enter",
 9 | escape:"esc",plus:"+",mod:/Mac|iPod|iPhone|iPad/.test(navigator.platform)?"meta":"ctrl"},k;for(g=1;20>g;++g)l[111+g]="f"+g;for(g=0;9>=g;++g)l[g+96]=g;c.prototype.bind=function(a,b,c){a=a instanceof Array?a:[a];this._bindMultiple.call(this,a,b,c);return this};c.prototype.unbind=function(a,b){return this.bind.call(this,a,function(){},b)};c.prototype.trigger=function(a,b){if(this._directMap[a+":"+b])this._directMap[a+":"+b]({},a);return this};c.prototype.reset=function(){this._callbacks={};this._directMap=
10 | {};return this};c.prototype.stopCallback=function(a,b){return-1<(" "+b.className+" ").indexOf(" mousetrap ")||B(b,this.target)?!1:"INPUT"==b.tagName||"SELECT"==b.tagName||"TEXTAREA"==b.tagName||b.isContentEditable};c.prototype.handleKey=function(){return this._handleKey.apply(this,arguments)};c.init=function(){var a=c(r),b;for(b in a)"_"!==b.charAt(0)&&(c[b]=function(b){return function(){return a[b].apply(a,arguments)}}(b))};c.init();C.Mousetrap=c;"undefined"!==typeof module&&module.exports&&(module.exports=
11 | c);"function"===typeof define&&define.amd&&define(function(){return c})})(window,document);
12 | 


--------------------------------------------------------------------------------
/webapp/static/sessions:
--------------------------------------------------------------------------------
1 | /tmp/omplweb_sessions


--------------------------------------------------------------------------------
/webapp/templates/components/benchmarking.html:
--------------------------------------------------------------------------------
 1 | <div class="container container-fluid" id="content">
 2 |     <br>
 3 |     <div id="benchmark-alerts"></div>
 4 | 
 5 |     <div class="col-md-4">
 6 |         <div class="options-header">
 7 |             Benchmarking
 8 |         </div>
 9 | 
10 |         <div class="benchmarking-options">
11 |             <table class="table">
12 |                 <caption>Settings</caption>
13 |                 <tbody>
14 |                     <tr>
15 |                         <td>Time Limit (sec)</td>
16 |                         <td><input type='number' name="time_limit" class="form-control input-sm" value="10"></input></td>
17 |                     </tr>
18 |                     <tr>
19 |                         <td>Run Count</td>
20 |                         <td><input type='number' name="run_count" class="form-control input-sm" value="2"></input></td>
21 |                     </tr>
22 |                     <!-- <tr> -->
23 |                         <!-- <td>Notification Email</td> -->
24 |                         <!-- <td><input type="email" id="notificationEmail" class="form-control input-sm" value="prb2@rice.edu"></input></td> -->
25 |                     <!-- </tr> -->
26 |                 </tbody>
27 |             </table>
28 | 
29 |             <hr>
30 | 
31 |             <center>
32 | 
33 |                 <button class="btn btn-default" onclick="problem.downloadConfig()">Export Configuration</button>
34 | 
35 |                 <!-- Add Planners button -->
36 |                 <div class="btn-group">
37 |                     <button type="button" class="btn btn-default dropdown-toggle" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
38 |                         Add Planner &nbsp; <span class='caret'></span>
39 |                     </button>
40 |                     <ul class="dropdown-menu" id="addingPlanners">
41 |                         <!-- Poplulated by loadPlanners() in configuration.js -->
42 |                     </ul>
43 |                 </div>
44 | 
45 |                 <br><br>
46 |                 <button class="btn btn-primary" onclick="benchmark.startBenchmarking()">Benchmark</button>
47 | 
48 |             </center>
49 |         </div>
50 |     </div>
51 | 
52 |     <div class="col-md-8">
53 |         <div class="planner-tables" id="planner-tables">
54 | 
55 |         </div>
56 |     </div>
57 | 
58 | </div>
59 | 


--------------------------------------------------------------------------------
/webapp/templates/omplweb.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 |     <head>
 3 |         <!-- Styles -->
 4 |         <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/bootstrap.min.css') }}">
 5 |         <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/style.css') }}">
 6 | 
 7 |         <!-- Libraries -->
 8 |         <script src="{{ url_for('static', filename='scripts/libs/jquery-2.1.4.min.js') }}"></script>
 9 |         <script src="{{ url_for('static', filename='scripts/libs/jquery.blockUI.js') }}"></script>
10 |         <script src="{{ url_for('static', filename='scripts/libs/bootstrap.min.js') }}"></script>
11 |         <script src="{{ url_for('static', filename='scripts/libs/three.min.js') }}"></script>
12 |         <script src="{{ url_for('static', filename='scripts/libs/TrackballControls.js') }}"></script>
13 |         <script src="{{ url_for('static', filename='scripts/libs/ColladaLoader.js') }}"></script>
14 |         <script src="{{ url_for('static', filename='scripts/libs/mousetrap.min.js') }}"></script>
15 | 
16 |         <!-- Application Scripts -->
17 |         <script src="{{ url_for('static', filename='scripts/configuration.js') }}"></script>
18 |         <script src="{{ url_for('static', filename='scripts/visualization.js') }}"></script>
19 |         <script src="{{ url_for('static', filename='scripts/benchmarking.js') }}"></script>
20 |         <script src="{{ url_for('static', filename='scripts/helpers.js') }}"></script>
21 | 
22 |         <title>OMPL Web</title>
23 |     </head>
24 | 
25 |     <body><div class="wrap">
26 |         <div role="tab-panel">
27 |             <!-- Navigation -->
28 |             <div class="main-nav container-fluid navbar-fixed-top">
29 |                 <div class="container-fluid">
30 |                     <div class="navbar-header">
31 |                         <button class="navbar-toggle" data-toggle="collapse" data-target="#navbar-collapse" aria-expanded="true" aria-controls="navbar">
32 |                             <span class="icon-bar"></span>
33 |                             <span class="icon-bar"></span>
34 |                             <span class="icon-bar"></span>
35 |                         </button>
36 | 
37 |                         <div class="logo">OMPL Web</div>
38 |                     </div>
39 |                     <div class="collapse navbar-collapse" id="navbar-collapse">
40 |                         <ul class="nav tabs main-tabs" role="tablist">
41 |                             <li role="presentation"><a class="mainlink" href="#configuration" aria-controls="configuration" role="tab" data-toggle="tab" id="configuration-page">Configure Problem</a></li>
42 |                             <li role="presentation"><a class="mainlink" href="#benchmarking" aria-controls="benchmarking" role="tab" data-toggle="tab" id="benchmarking-page">Benchmarking</a></li>
43 |                             <li role="presentation"><a class="mainlink" href="#about" aria-controls="about" role="tab" data-toggle="tab" id="about-page">About</a></li>
44 |                         </ul>
45 |                     </div>
46 |                 </div>
47 |             </div> <!-- End tabs nav -->
48 | 
49 |             <div class="main-content tab-content">
50 | 
51 |                 <!-- Configure Problem Page -->
52 |                 <div role="tabpanel" class="tab-pane fade" id="configuration">
53 |                     <!-- This gets filled in by initialize() -->
54 |                 </div>
55 | 
56 | 
57 |                 <!-- Benchmarking Page -->
58 |                 <div role="tabpanel" class="tab-pane fade" id="benchmarking">
59 |                     <!-- This gets filled in by initialize() -->
60 |                 </div>
61 | 
62 | 
63 |                 <!-- About Page -->
64 |                 <div role="tabpanel" class="tab-pane fade" id="about">
65 |                     <!-- This gets filled in by initialize() -->
66 |                 </div>
67 | 
68 |             </div> <!-- End tab content -->
69 | 
70 |         </div> <!-- End tab panel -->
71 | 
72 | 
73 |         <div class="push"></div>
74 |     </div></body>
75 |     <!-- Footer -->
76 |     <div class="footer">
77 |         <div class="container">
78 |             <a target="none" href="http://ompl.kavrakilab.org">Open Motion Planning Library</a>
79 |             •
80 |             <a target="none" href="http://www.kavrakilab.org">Physical and Biological Computing Group</a>
81 |             •
82 |             <a target="none" href="http://www.cs.rice.edu">Department of Computer Science</a>
83 |             •
84 |             <a target="none" href="http://www.rice.edu">Rice University</a><br>
85 |         </div>
86 |     </div>
87 | </html>
88 | 


--------------------------------------------------------------------------------
/webapp/wsgi.ini:
--------------------------------------------------------------------------------
 1 | [uwsgi]
 2 | module=omplweb:app
 3 | master=true
 4 | processes=2
 5 | threads=2
 6 | pidfile=/tmp/omplwebapp-master.pid
 7 | vacuum=true
 8 | max-requests=5000
 9 | http-socket=:5000
10 | plugins=python3
11 | 


--------------------------------------------------------------------------------