Changes since 0.14.2
--------------------

- Added many new planners:
	- Linear Temporal Logical Planner (LTLPlanner): a planner that finds
	  solutions for kinodynamic motion planning problems where the goal is specified
	  by a Linear Temporal Logic (LTL) specification.
	- Fast Marching Tree algorithm (FMT∗): a new asymptotically optimal
	  algorithm contributed by Marco Pavone's Autonomous Systems Laboratory at
	  Stanford.
	- Coupled Forest of Random Engrafting Search Trees (CForest): a
	  meta-planner that runs several instances of asymptotically optimal planners in
	  different threads. When one thread finds a better solution path, the states
	  along the path are passed on to the other threads.
	- Anytime Path Shortening: a generic wrapper around one or more
	  geometric motion planners that repeatedly applies shortcutting and
	  hybridization to a set of solution paths. Any number and combination of
	  planners can be specified, each is run in a separate thread.
        - LazyPRM / LazyPRMstar: not entirely new, but completely re-implemented.

- RRT* has a new option to periodically prune parts of the tree that are
  guaranteed not to contain the optimal solution. This idea was introduced in
  CForest, but it useful independently of the CForest parallelization. Although
  pruning is almost always useful, it is disabled by default to preserve the
  original behavior.

- Created consistent behavior across all planners that can optimize paths.
  Calls to the solve method of RRT*, PRM*, SPARS, SPARStwo, and LBTRRT will
  terminate when (1) the planner termination condition is true or (2) the
  optimization objective is satisfied. To make these planners terminate when any
  solution is found, you can set the cost threshold for the optimization
  objective to, e.g., OptimizationObjective::infiniteCost(). For most of these
  planners, asymptotic (approximate) optimality is only guaranteed when using the
  PathLengthOptimizationObjective class.

- Most control-based planners can now use steering functions. The user simply
  needs to override ompl::control::StatePropagator::steer() and
  ompl::control::StatePropagator::canSteer() in a derived class.

- Several improvements to benchmarking functionality:
	- Planner Arena has been relaunched and can be used to interactively
	  visualize benchmark results.
	- ompl_benchmark_statistics.py can now also parse MoveIt! benchmark log
	  files using the flag --moveit.

- Added ompl::tools::PlannerMonitor class, which periodically prints planner
  progress properties in a separate thread. Useful for developing / debugging new
  planners.

- Updated Py++ toolchain. If you previously installed Py++ and have trouble
  generating the OMPL Python bindings, you may need to run "make
  installpyplusplus" again.

- Minimum Boost version is now 1.48 and minimum CMake version is now 2.8.7.
- Bug fixes.

Changes since 0.12.2:
---------------------

OMPL.app 0.14.1 (January 23, 2014)

Update PlannerData to use new cost infrastructure.
Bug fixes.

OMPL 0.14.0 (December 20, 2013)

    - Added new cost infrastructure to plan optimal paths with respect to
    arbitrary cost functions. Several common cost objective functions have been
    defined (such as path length and mechanical work) and new ones can easily be
    defined.
    - RRT*, PRM*, TRRT, and PRM have been updated to use this cost
    infrastructure.
    - BallTreeRRT* has been removed since it assumed that the path cost is equal
    to the path length.
    - Added two new planners:
	- Lower Bound Tree RRT (LBTRRT), a near asymptotically-optimal
	incremental sampling-based motion planning algorithm.
	- Search Tree with Resolution Independent Density Estimation (STRIDE), an
	EST-like planner that uses an extension of the GNAT nearest neighbor data
	structure that supports sampling states inversely proportional to the density
	of previously sampled states.
    - Added support for MORSE. Through a plugin you can use OMPL with Blender
                        ^^^^^
    and MORSE to plan kinodynamic paths. See the gallery for some examples.
    -  Added functionality to the Benchmark class to keep track of
    user-specified properties at regular intervals. This is especially useful for
    asymptotically/approximately optimal or anytime planners.
    - Added more demo programs.
    - Updated gccxml snapshot. If you use gcc 4.8 and the OMPL Python bindings,
    you need to run "make installpyplusplus" again.
    - Bug fixes.

OMPL 0.13.0 (August 5, 2013)

    - Added several new planners:
	- SPARS and SPARS2 are roadmap-based planners that operate similarly to
	Visibility-based PRM, but provide asymptotic near-optimality guarantees.
	- Path-Directed Subdivision Tree (PDST). There are actually two
	versions: one for geometric planning and one for control-based planning.
	- Lazy PRM, a variant that lazily evaluates the validity of nodes and
	edges in a roadmap.
    - Various improvements and bug fixes in the RRTstar and BallTreeRRTstar planners.
    - Various optimizations in the Syclop planner.
    - The Syclop planner can now operate over triangular decompositions. This
    is enabled if the triangle package is installed.
    - Significantly reworked and extended unit tests for planning algorithms.
    - Added method to extract a ompl::base::StateStorage object from ompl::base::PlannerData.
    - State spaces can indicate whether they are metric.
    - Certain path shortcutting techniques are disabled for non-metric state
    spaces during path simplification.
    - Extended ProblemDefinition API to support path optimizing planners.
    - Added printAsMatrix method to ompl::geometric::PathGeometric and
    ompl::control::PathControl to facilitate plotting of paths. Added a tutorial on
    path visualization.
    - Added more demo programs.
    - Use the officially released version of OdeInt that comes with Boost 1.53
    for numerical integration. The bundled version of OdeInt is not used or
    installed if the user has Boost >= 1.53 installed.
    - Updated Py++ toolchain (gccxml, pygccxml, pyplusplus). If you use gcc
    4.7/4.8 or Boost 1.54, you need to run "make installpyplusplus" again.
    - Bug fixes.

OMPL, the Open Motion Planning Library, consists of many
state-of-the-art sampling-based motion planning algorithms.