TODO_list.txt

///----------------PATH PLANNING-------------

///----------------ALGORITHMS----------------


implement interpolated topology (similar to SVP/SAP reach-topology)   -----------X


implement the dynamic topologies and planners   
  implement a point-to-point trajectory   ---------------------------------------X
  add iterators to the interpolated_trajectory   --------------------------------X
    test interpolated_trajectory   ----------------------------------------------X
  add iterators to the constant_trajectory   ------------------------------------X
  create protected-virtual functions in the waypoint-cont-base   ----------------X
  add iterators to the belief_predicted_trajectory   ----------------------------X
    test belief_predicted_trajectory   ------------------------------------------X
  create a topo-map from belief to max-likelihood   -----------------------------X
  implement the intercept_query   -----------------------------------------------X
    implement the search alg. to find intercept-point   -------------------------X
  add the capability to load target trajectories to app   -----------------------X
  add the capability to run dyn intercept queries to app   ----------------------X
  create a simulation program to generate target trajectories   -----------------X
    add real-time feeding of noisy data   ---------------------------------------X
  add the capability to load a belief predictor   -------------------------------X
    plug the belief predictor into the intercept queries   ----------------------X
  add mechanisms, somewhere (?), to delay motion-plan start   -------------------X


finish reachability sorting algorithm
  test it on 1D+T space

implement sequential EKF on target trajectory
  define trajectory concept    --------------------------------------------------X
    define way-point based trajectory concept    --------------------------------|
      implement point-to-point (reachable) trajectories   -----------------------X
  define motion-prediction concept   --------------------------------------------X
    define state-space system concept    ----------------------------------------X
      define linear state-space system concept    -------------------------------X
        define LTI state-sapce system concept    --------------------------------X
          implement LTI systems (A,B,C,D)   -------------------------------------X
      define non-linear state-space system concept    ---------------------------X
        implement non-linear multi-body dynamics systems based on a KTE chain   -X
      define linearized state-space system concept    ---------------------------X
        implement linearized multi-body dynamics systems based on a KTE chain   -O  : I don't think this is possible
    define discrete-time state-space system concept   ---------------------------X
      define linear discrete-time state-space system concept   ------------------X
        implement Discrete-time LTI system   ------------------------------------X
        implement integration of LTI system into a discrete-time system   -------X
      define non-linear discrete-time state-space system concept   --------------X
      define linearized discrete-time state-space system concept   --------------X
      implement numerically-integrated discrete-time state-space systems   ------X
    define covariance concept   -------------------------------------------------X
      implement covariance matrix   ---------------------------------------------X
      implement covariance info matrix   ----------------------------------------X
      implement decomposed covariance matrix   ----------------------------------X
    define belief-state concept   -----------------------------------------------X
      implement Gaussian belief-state   -----------------------------------------X
      implement point-based belief-state   
    implement transitioner templates (free functions)   -------------------------X
      implement Bayes updates on gaussian belief states   -----------------------X
        Kalman Filter   ---------------------------------------------------------X
        Extended Kalman Filter   ------------------------------------------------X
        Kalman-Bucy Filter   ----------------------------------------------------X
        Hybrid Kalman Filter   --------------------------------------------------X
        Invariant Extended Kalman-Bucy Filter   ---------------------------------X
        Invariant Extended Kalman Filter   --------------------------------------X
        Unscented Kalman Filter   -----------------------------------------------X
        Aggregate Kalman Filter   -----------------------------------------------X
        Invariant Aggregate Kalman Filter   -------------------------------------O
        Symplectic Kalman Filter   ----------------------------------------------X
        Invariant Symplectic Kalman Filter   ------------------------------------X
      implement belief-state overloads of transitioner templates   --------------O
  implement belief-state point-to-point (reachable) trajectories   --------------X

implement Elastic Roadmap
  define transition function concept
    add gradient computation
    add "pushing" a vertex
  implement vertex motion control loop
  test it on AD*-like world (2D-particle robot with growing obstables)


implement "adjacency-list on dvp-tree" overlay data structure   -----------------X
  reimplement the DVP-tree to handle more generic storage types   ---------------X
  reimplement the DVP-tree to de-recursify it   ---------------------------------X
  implement an adjacency-list that indirects a tree (ALT)   ---------------------X
    define strict concepts for property-graphs and trees (BGL extensions)   -----X
    implement additional property-maps   ----------------------------------------X
      implement a data-member property-map   ------------------------------------X
      implement a composite property-map   --------------------------------------X
      implement a raw-property property-map   -----------------------------------X
      implement a raw-to-bundled property-map   ---------------------------------X
    define a concept for callbacks to added/removed nodes   ---------------------X
      implement the DVP-tree callbacks (visitor)   ------------------------------X
    implement the graph-view on the ALT   ---------------------------------------X
    implement the tree-view on the ALT   ----------------------------------------X
  test suite   ------------------------------------------------------------------X
    test all graphs for BGL concept compliance   --------------------------------X (passed)
    test all trees for BGL(extended) concept compliance   -----------------------X (passed)
    test trees and graphs for property-graph concepts   -------------------------X (passed)
    test the ALT on path planners (RRT, RRT*, PRM, RRG)   -----------------------X (passed, with significant improvements)
      test on 2D world    -------------------------------------------------------X (passed, with no improvement)
      test on 6D world    -------------------------------------------------------X (passed, with some improvement)
      test on 12D world    ------------------------------------------------------X (passed, with significant improvement)
      test on SE(3) 2nd order world    ------------------------------------------X (passed, with significant improvement)


update the DVP-tree implementation to include asymmetric metrics   --------------X
  define concepts related to asymmetric metrics   -------------------------------X
  implement the tree construction for asym. metrics   ---------------------------X
  implement the KNN query for asym. metrics   -----------------------------------X
  test on directed motion graph planners (RRT, RRT*, and PRM)   -----------------X


implement a "Sampling-based A*" (generalization of A* to sampled graphs)   
  implement the basic sampling-based A* algorithm   -----------------------------X
    test on 2d point-robot world   ----------------------------------------------X
    test on CRS robot (static)   ------------------------------------------------X
    test on CRS robot (dynamic)   -----------------------------------------------X
  implement the "pruned" sampling-based A* algorithm   --------------------------X
    test on 2d point-robot world   ----------------------------------------------X
    test on CRS robot (static)   ------------------------------------------------X
    test on CRS robot (dynamic)   -----------------------------------------------X
  implement the lazy sampling-based A* algorithm   ------------------------------X
    test on 2d point-robot world   ----------------------------------------------X
    test on CRS robot (static)   ------------------------------------------------X
    test on CRS robot (dynamic)   -----------------------------------------------X
  implement the branch-and-bound sampling-based A* algorithm   ------------------X
    test on 2d point-robot world   ----------------------------------------------X
    test on CRS robot (static)   ------------------------------------------------X
    test on CRS robot (dynamic)   -----------------------------------------------X
  implement the simulated-annealing sampling-based A* algorithm   ---------------X
    test on 2d point-robot world   ----------------------------------------------X
    test on CRS robot (static)   ------------------------------------------------X
    test on CRS robot (dynamic)   -----------------------------------------------X
  implement the inconst-set traversal   -----------------------------------------X
    in SBA*   -------------------------------------------------------------------X
    in Pruned-SBA*   ------------------------------------------------------------X
    in Lazy-SBA*   --------------------------------------------------------------X
  implement the bi-directional variants   ---------------------------------------X
    in SBA*   -------------------------------------------------------------------X
    in SA-SBA*   ----------------------------------------------------------------X
    in RRT*   -------------------------------------------------------------------X
  implement a density threshold 
    in SBA*   
    in Pruned-SBA*   
    in Lazy-SBA*   
    test on 2d point-robot world   
    test on CRS robot (static)   
    test on CRS robot (dynamic)   
  incorporate collision probability into constriction calculation   
    in SBA*   
    in Pruned-SBA*   
    in Lazy-SBA*   
    test on 2d point-robot world   
    test on CRS robot (static)   
    test on CRS robot (dynamic)   
    

create a motion-graph mutation-sentinel framework   
  anticipated pitfalls:
    infinite recursions like add-edge -> add-vertex -> connect -> add-edge
      could use operation queues   
      could disable connection (make it optional)   
      could split add and connect   
    concurrency problems (in "replanning" scenarios)
      could make the sentinel mutex'd
    invalidate descriptors currently used in caller's context when callee adds things
      I think graphs must already be non-invalidating (list or pool containers)


implement a trajectory wrapper for "best in motion-graph"
  add support in motion-graph sentinel for registering current robot location
    consider start-vertex as next one to be reached
  add support in motion-graph sentinel or algs for pruning of unreachable points
    watch out for start-vertex invalidation
  


implement "promising trajectory sampling"
  define a Frenet frame concept for trajectories
    implement Frenet frame on linear interp
    implement Frenet frame on cubic interp
    implement Frenet frame on quintic interp
    implement Frenet frame on SVP interp
    implement Frenet frame on SAP interp
  implement Gaussian sampling in normal hyper-Frenet-plane
    test on linear interp
    test on cubic interp
    test on quintic interp
    test on SVP interp
    test on SAP interp
  implement a mixed pool of promising trajectories
    test on a few interpolators
  implement a Bayesian update scheme for the promising trajectories
    test on random (e.g., Perlin Noise) obstacle world
  implement a multi-nomial distribution on trajectory (tangential)
    implement Bayesian update on a per-sample basis
  integration tests
    test with basic interpolator + Gaussian sampling + mixed pool
    test interp. + GS + MP + Bayesian update on blobby obstacle world
    test interp. + GS + MP + per-sample Bayesian update on blob-world
    test SVP/SAP interp. + GS + MP + PSBU + Manipulator / Collision world
    test SVP/SAP interp. + GS + MP + PSBU + Manip. / Col. world + Moving Target



///----------------GEOMETRY LIBRARY----------

implement a set of basic geometries   -------------------------------------------X
  define base-classes for geometries (2D & 3D) (anchored, renderable)   ---------X
  define base-classes for shapes (2D & 3D) (collideable)   ----------------------X
  in 2D, implement:
    Coordinate arrows   ---------------------------------------------------------X
    Grid   ----------------------------------------------------------------------X
    Line Segment   --------------------------------------------------------------X
    Composite Shape   -----------------------------------------------------------X
    Rectangle   -----------------------------------------------------------------X
    Circle   --------------------------------------------------------------------X
    Capped Rectangle   ----------------------------------------------------------X
  in 3D, implement:
    Coordinate arrows   ---------------------------------------------------------X
    Grid   ----------------------------------------------------------------------X
    Line Segment   --------------------------------------------------------------X
    Plane   ---------------------------------------------------------------------X
    Composite Shape   -----------------------------------------------------------X
    Box   -----------------------------------------------------------------------X
    Sphere   --------------------------------------------------------------------X
    Cylinder   ------------------------------------------------------------------X
    Capped Cylinder   -----------------------------------------------------------X

implement export-import facilities for geometries   
  use some external lib for VRML / X3D import-export   --------------------------X
  interface to whatever FreeCAD is using   

implement rendering facilities for geometries
  interface to OpenInventor (Coin3D)   ------------------------------------------X
  create a FreeCAD module
  use some VRML / X3D renderer   ------------------------------------------------O

implement proximity-query methods   ---------------------------------------------X
  implement closed-form solution when possible:   -------------------------------X
    rectangle - rectangle   -----------------------------------------------------X
    circle - circle   -----------------------------------------------------------X
    rectange - circle   ---------------------------------------------------------X
    capped rectangle - rectangle   ----------------------------------------------X
    capped rectangle - circle   -------------------------------------------------X
    capped rectangle - capped rectangle   ---------------------------------------X
    capped cylinder - capped cylinder   -----------------------------------------X
    box - capped cylinder   -----------------------------------------------------X
    sphere - sphere   -----------------------------------------------------------X
    sphere - box   --------------------------------------------------------------X
    sphere - cylinder   ---------------------------------------------------------X
    sphere - capped cylinder   --------------------------------------------------X
    plane - plane   -------------------------------------------------------------X
    plane - sphere   ------------------------------------------------------------X
    plane - box   ---------------------------------------------------------------X
    plane - cylinder   ----------------------------------------------------------X
    plane - capped cylinder   ---------------------------------------------------X
  implement a support-function for all geometries   -----------------------------X
  implement a proximity-query based on support-function (GJK)   -----------------X
  implement the penetration depth EPA algorithm   ---------------
    cylinder - cylinder   -------------------------------------------------------X
    capped cylinder - cylinder   ------------------------------------------------X
    box - box   -----------------------------------------------------------------X
    box - cylinder   ------------------------------------------------------------X
    
  implement a composite-shape proximity-query dispatcher   ----------------------X

  implement an approximator of collision probability   
    assume Gaussian probability on pose of bodies   


///----------------TEST SCENARIOS------------

Kalman filtering tests
  implement airship2D test models   ---------------------------------------------X
    implement airship2D model   -------------------------------------------------X
    implement airship2D simulator   ---------------------------------------------X
      with input-disturbance   --------------------------------------------------X
  implement data extractor (inverse of data-recorders)   ------------------------X
  implement airship2D estimator systems   ---------------------------------------X
    implement airship2D linearized continuous-time model   ----------------------X
    implement invariant airship2D continuous-time model   -----------------------X
    implement airship2D linearized discrete-time model   ------------------------X
    implement invariant airship2D discrete-time model   -------------------------X
  implement airship3D test models   ---------------------------------------------X
    implement airship3D model   -------------------------------------------------X
    implement airship3D simulator   ---------------------------------------------X
      with input disturbance   --------------------------------------------------X
  implement airship3D estimator systems   ---------------------------------------X
    implement airship3D linearized continuous-time model   ----------------------X
    implement invariant airship3D continuous-time model   -----------------------X
    implement airship3D linearized discrete-time model   ------------------------X
    implement invariant airship3D discrete-time model   -------------------------X
    implement invariant momentum-conserving airship3D discrete-time model   -----X
  integrate airship models with Kalman filters   --------------------------------X
    test all Kalman filters on airship2D   --------------------------------------X
    test all Kalman filters on airship3D   --------------------------------------X

///----------------CORE(2)----------------------

///----------------RTTI-----------------------


///----------------SERIALIZATION--------------

provide a non-intrusive means to make types serializable (by value-ref)   -------X (sfinae to the rescue, again!)
  (mainly to avoid instantiation of save/load functions in a class template)   --X (sfinae to the rescue, again!)

implement protobuf-based archiver   ---------------------------------------------X
  implement protobuf scheme creator   -------------------------------------------X

implement RPC-based archiver (both XML-RPC and Protobuf-RPC)


///----------------RPC (Remote Procedure Call)--------------

create and implement a discovery protocol

create and implement a rpc protocol

create and implement a publish-subscribe protocol


///----------------MATH----------------------

define generic matrix concepts   ------------------------------------------------X
  refactor matrix library using generic concepts   ------------------------------X
  support for nil, identity and scalar matrices   -------------------------------X
  extend support for ortho, lo-tri, hi-tri and tridiag  
  implement vector-to-matrix adaptor   ------------------------------------------X
  implement matrix views   ------------------------------------------------------X
  implement matrix composition   ------------------------------------------------X
  implement matrix slicing (matrix-to-vector adaptor)   -------------------------X
  refactor matrix numerical methods to generic matrices  ------------------------X
    gaussian_elim  --------------------------------------------------------------X
    cholesky  -------------------------------------------------------------------X
    qr_decomp  ------------------------------------------------------------------X
    jacobi_method  --------------------------------------------------------------X
    svd_method  -----------------------------------------------------------------X
  implement matrix exponential method   -----------------------------------------X
  implement Redheffer star product (hamiltonian matrices)   ---------------------X
idem for vectors  ---------------------------------------------------------------X
idem for rotation  --------------------------------------------------------------X
idem for kinetostatics  ---------------------------------------------------------X

write a tensor library (3-4 order)
  define tensor concepts  -------------------------------------------------------X
  define tensor traits  ---------------------------------------------------------X
  write adaptor for vectors to act as tensors  ----------------------------------X
    allow all vector views / matrix slices to act as tensors
  write adaptor for matrices to act as tensors  ---------------------------------X
    allow all matrix views to act as tensors
  write third-order tensor classes  ---------------------------------------------X
    write third-order rectangular tensor  ---------------------------------------X
    write third-order square tensor  --------------------------------------------X
    write third-order nil tensor  -----------------------------------------------X
  write fourth-order tensor classes  --------------------------------------------X
    write fourth-order rectangular tensor  --------------------------------------X
    write fourth-order square tensor  -------------------------------------------X
    write fourth-order nil tensor  ----------------------------------------------X
  write order-augmentation views  
    vector to tensor-3  
    vector to tensor-4  
    matrix to tensor-3  
    matrix to tensor-4  
    tensor-3 to tensor-4  
  create ESN indices  
  define ESN expression concepts  
  define ESN expression traits  
  write terminal ESN expressions  
    for vectors
    for matrices
    for tensors-3  
    for tensors-4  
  write constant ESN expression wrappers  
  write arithmetic ESN operations  
    range-summation (basis for mult and div)  
    multiplication  
    division  
    addition  
    subtraction  
  write elem-wise ESN functions (exp, log, sin, ...)  
  write ESN expression evaluator  




///----------------OPTIMIZATION--------------

Linear Programming
  primal-dual simplex method   --------------------------------------------------X
    test with simple LP problems   -----------------------------------------FAILED
  mehrotra's interior-point method   --------------------------------------------X
    test with simple LP problems   -----------------------------------------FAILED
Quadratic Programming
  Equality-constrained
    null-space direct method   --------------------------------------------------X
      test with simple ECQP problems   ------------------------------------------X
    projected conjugate gradient method   ---------------------------------------X
      test with simple ECQP problems   ------------------------------------------X
    mehrotra's QP method   ------------------------------------------------------X
      test with simple ECQP problems   ------------------------------------------X
  Inequality-constrained
    mehrotra's QP method   ------------------------------------------------------X
      test with simple ICQP problems   
Non-Linear Least-square   
  Unconstrained (aside from limiters)
    Gauss-Newton method   -------------------------------------------------------X
      test with various non-linear functions   ----------------------------------X (reasonable)
    Jacobian-transpose method   -------------------------------------------------X
      test with various non-linear functions   ----------------------------------X (shit)
    Levenberg-Marquardt method (DLS with trust-region)   ------------------------X
      test with various non-linear functions   ----------------------------------X (best)
Non-Linear Optimization problems
  Unconstrained (aside from limiters)
    Nelder-Mead method   --------------------------------------------------------X
      test with various non-linear functions   --------------------------------BAD (expected)
    Quasi-Newton line-search methods   ------------------------------------------X
      test with various non-linear functions   ----------------------------------X (best: bfgs)
    Quasi-Newton trust-region methods   -----------------------------------------X
      test with various non-linear functions   ----------------------------------X (best: sr1)
    Conjugate-Gradient method   -------------------------------------------------X
      test with various non-linear functions   ----------------------------------X (so so..)
    Newton line-search methods   ------------------------------------------------X
      test with various non-linear functions (idea: use nllsq)   
    Newton trust-region methods   -----------------------------------------------X
      test with various non-linear functions (idea: use nllsq)   ----------------X
  Equality-constrained
    Bound-constrained Newton methods (Augmented Lagrangian methods)   -----------X
      test with various non-linear functions   ----------------------------------X (bad, expected)
    Bound-constrained Quasi-Newton methods (Augmented Lagrangian methods)   
      test with various non-linear functions   
    Byrd-Omojokun SQP method   --------------------------------------------------X
      test with various non-linear functions   ----------------------------------X
    Line-search Interior-point method   -----------------------------------------X (sucks)
      test with various non-linear functions   -------------------------------FAIL
    Trust-region Interior-point method   ----------------------------------------X
      test with various non-linear functions   ----------------------------------X
  Inequality-constrained
    Bound-constrained Newton methods (Augmented Lagrangian methods)   -----------X
      test with various non-linear functions   ----------------------------------X (bad, expected)
    Bound-constrained Quasi-Newton methods (Augmented Lagrangian methods)   
      test with various non-linear functions   
    Byrd-Omojokun SQP method (with non-negative limiters)   ---------------------X
      test with various non-linear functions   ----------------------------------X
    Line-search Interior-point method   -----------------------------------------X (sucks)
      test with various non-linear functions   -------------------------------FAIL
    Trust-region Interior-point method   ----------------------------------------X
      test with various non-linear functions   ----------------------------------X
    


///----------------INTEGRATORS---------------

port integrators to generic continuous SSS concepts -- made an adaptor instead --X


///----------------SIGNALS AND SYSTEMS-------

reimplement as non-blocking using Boost.Atomic   ---? (never?)





///----------------KTE-----------------------

///----------------GENERAL--------------------


encapsulate manipulator simulation loops:
  simulated step;
  ext_force_estimator;
  adaptive step;
  virtual model ctrl;



///-----------------ADAPTATION----------------------

adaptation for all kte model:
  inertia
  spring
  damper
  dry_friction
  vmc_dry_friction or vmc_joints

adaptation loop;

associate adaptive model and vmc model somehow;