TDSP Tentative Project Plan

This is a tentative project plan for Implementation of Time Dependent Shortest Path algorithm (TDSP) for pgRouting as per the initial project proposal for Google Summer of Code 2011.

Note - This plan is subject to minor changes as the project proceeds.

26th April - 24th May:

* Study the Boost Graph Library in detail and get accustomed to the data-structures that will 
  be needed for the implementation of the algorithm.
* Study the Boost Priority Queues Library. Implement the functionality hands on.
* Get fluent with use of git-hub, CMAKE ad other tools required for the development of the project.
* Carry on discussions regarding the design and implementation of the algorithm on the mailing list.
* Come up with different options, use-cases and prototypes for the design of time_dependent_cost 
  function.

25th May - 5th June:

* Finalize the overall architecture of the project.
* Finalize the database-design\ other storage format which will be used for dynamically 
  storing\updating the data for time-dependent edge weights.
* Finalize the class-diagram which will be used for the implementation.
* Finalize the prototypes for the SQL-queries and the SQL-shared library functions that must be 
  implemented.
* Decide the test cases and data that will be needed for rigorous testing of the modules.
* Start coding small trivial modules/functions that will be needed for the project.

6th June - 15th June:

* Implement the basic time-dependent dijkstra algorithm using Boost Graph Library and Boost Priority 
  Queues Library assuming the time_dependent_cost
* function as black box.
* Test the basic function with dummy data.

16th June - 25th June:

* Implement the shared-library modules needed for retrieving the time-dependent_costs from the database 
  / dynamic storage as decided in the design.

26th June - 7th July:

* Implement the SQL queries needed for data retrieval from the database source.
* Implement the SQL queries needed for finding the time dependent edge costs.
* Integrate the basic algorithm and all components using CMAKE scripts.
* Test the basic functionality using dummy data.

7th July - 13th July:

* Prepare and Submit the mid-term evaluation report.
* Work on the code in background.

14th July - 25th July:

* Implement the shared library wrapper functions around the basic function with and without bounding 
  box limitations.
* Implement any other functions / variants to original functions that may have come up during the brain-
  storming period.
* Implement the corresponding SQL queries and write the CMAKE scripts.

26th July - 5th August:

* Test the implementation with test cases and data as planned.
* Fix any bugs / exceptions that come up.

6th August - 16th August:

* Fix any bugs and finish testing.
* Complete the detailed documentation, examples, tutorials regarding the application of the algorithm 
  in real-world projects.
* Wrap-up any remaining tasks.
* Start working on the final report for the project.

17th August - 22nd August:

* Complete and Submit the final report for the project.