{"id":30583032,"url":"https://github.com/personalrobotics/batching_pomp","last_synced_at":"2026-06-15T20:31:31.914Z","repository":{"id":70899198,"uuid":"88790105","full_name":"personalrobotics/batching_pomp","owner":"personalrobotics","description":"Research code repository that implements anytime geometric motion planning on large dense roadmaps with densification strategies and searching via the POMP algorithm.","archived":false,"fork":false,"pushed_at":"2019-09-22T06:43:32.000Z","size":156,"stargazers_count":4,"open_issues_count":2,"forks_count":0,"subscribers_count":7,"default_branch":"master","last_synced_at":"2025-08-29T10:21:41.848Z","etag":null,"topics":["motion-planning","ompl","robotics"],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"bsd-2-clause","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/personalrobotics.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2017-04-19T20:56:07.000Z","updated_at":"2024-04-02T03:11:42.000Z","dependencies_parsed_at":null,"dependency_job_id":"8baf2b55-5771-4e66-8bcb-e4bd321d7d50","html_url":"https://github.com/personalrobotics/batching_pomp","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/personalrobotics/batching_pomp","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/personalrobotics%2Fbatching_pomp","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/personalrobotics%2Fbatching_pomp/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/personalrobotics%2Fbatching_pomp/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/personalrobotics%2Fbatching_pomp/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/personalrobotics","download_url":"https://codeload.github.com/personalrobotics/batching_pomp/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/personalrobotics%2Fbatching_pomp/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34379915,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-15T02:00:07.085Z","response_time":63,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["motion-planning","ompl","robotics"],"created_at":"2025-08-29T08:09:51.825Z","updated_at":"2026-06-15T20:31:31.910Z","avatar_url":"https://github.com/personalrobotics.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# batching_pomp\n\nA motion planning algorithm implemented in [OMPL](http://ompl.kavrakilab.org/), also using [Boost Graph Library](http://www.boost.org/doc/libs/1_64_0/libs/graph/doc/index.html). It is released under the [BSD License](https://opensource.org/licenses/BSD-2-Clause). \nDoxygen-generated documentation is available [here](http://web.stanford.edu/~shushman/documentation/batching_pomp/index.html).\nThe algorithm is based on my MS thesis work, summarized in the [ArXiv paper](https://arxiv.org/abs/1711.04040) \"Anytime Motion Planning on Large Dense Roadmaps with Expensive Edge Evaluations\".\nPlease cite the following conference papers if you are interested in using this code:\n\n[1] *Choudhury, S., Salzman, O., Choudhury, S., \u0026 Srinivasa, S. S. (2017, May). Densification strategies for anytime motion planning over large dense roadmaps. In Robotics and Automation (ICRA), 2017 IEEE International Conference on (pp. 3770-3777). IEEE.*\n\n[2] *Choudhury, S., Dellin, C. M., \u0026 Srinivasa, S. S. (2016, October). Pareto-optimal search over configuration space beliefs for anytime motion planning. In Intelligent Robots and Systems (IROS), 2016 IEEE/RSJ International Conference on (pp. 3742-3749). IEEE.*\n\nThis is an implementation of an algorithmic framework for anytime motion planning on large dense roadmaps. There are two key components:\n\n- A sequence of subgraphs of the entire roadmap is generated, using some densification strategy.\n- After each subgraph is added, the current roadmap is searched using an anytime roadmap planning algorithm called POMP (Pareto-Optimal Motion Planner).\n\n### Disclaimer\nCurrently the densification strategies use radius of connectivity (where appropriate) to induce subgraphs (check the densification paper for details). The results are obtained from analysis done for unit hypercubes. For other state spaces, please ensure that the distance function is appropriately defined so that the r-disk roadmaps have the appropriate expected average degree. Instead, a k-NN version of our framework could be used (and was started to be implemented in the `kNN_bpomp` branch but was not completed). Contact the author for more details if the r-disk version cannot be used reliably.\n\n# Dependencies\n\n## For the library\n- Ubuntu 14.04 or later (Has also been built on OSX)\n- [C++11](https://isocpp.org/wiki/faq/cpp11) or higher\n- [cmake](https://cmake.org/download/)\n- [Eigen](http://eigen.tuxfamily.org/index.php?title=Main_Page)\n- [FLANN](http://www.cs.ubc.ca/research/flann/)\n- [OMPL](http://ompl.kavrakilab.org/) built with FLANN\n- [Boost Graph Library](http://www.boost.org/doc/libs/1_64_0/libs/graph/doc/index.html)\n## For the example\n- [Networkx](https://networkx.github.io/)\n- [OpenCV](http://opencv.org/)\n\n# Build\nThe `CMakeLists.txt` file supports [catkin tools](https://catkin-tools.readthedocs.io/en/latest/). Once you have created and [initialized your workspace](https://catkin-tools.readthedocs.io/en/latest/quick_start.html#initializing-a-new-workspace), you should be able to clone `batching_pomp` into your workspace and do `catkin build batching_pomp`.\n\n*Please note that the build process has not been extensively tested for various different systems and the authors cannot commit to provide support for the same. Feel free to raise a Github issue though.*\n\n# Usage\n`batching_pomp` is implemented as an [OMPL Geometric Multi-Query Planner](http://ompl.kavrakilab.org/planners.html#geometric_planners) and can be invoked on a [`RealVectorStateSpace`](http://ompl.kavrakilab.org/classompl_1_1base_1_1RealVectorStateSpace.html) problem.\nIt returns a sequence of successively shorter feasible paths on the provided roadmap, for the given motion planning problem. \n\nThe following are the OMPL parameters that the planner supports:\n\n- `increment`(required): The step-wise increment for the value of the `alpha` tradeoff parameter in POMP. `alpha` varies from 0 (only considers edge collision measure) to 1 (only considers edge length)\n- `batching_type`(required): The kind of batching method to be used by the `BatchingManager`. Options are vertex, edge, hybrid and single. The first three are defined in paper [1] and the last refers to an explicit roadmap with vertices and edges, that is added in a single batch.\n- `roadmap_filename`(required): The path to the `.graphml` file that will be read in by the `BatchingManager`. If the corresponding `batching_type` is single batching, then the vertices should have underlying states and the edges along with their end-point vertices should be present. For any other kind of batching, only the vertices with their states should be present.\n- `graph_type`: The kind of sample sequence used to generate the vertex states. Either `halton` or `rgg`. If edge or hybrid batching is chosen, then graph type *must* be provided.\n- `prune_threshold`(default=1.05): The threshold of the ratio of previous best solution cost to new best solution cost, above which pruning of existing vertices should be done. This prunes more conservatively.\n- `start_goal_radius`(required only for Single Batching): The radius of connectivity to use for connecting the start and goal to the `singlebatching` roadmap\n- `selector_type`(optional): Arranges the order of edges to evaluate on a candidate path. If not included, the full candidate path will be evaluated each time, rather than just the first unevaluated edge.\n\n# Example\nA `Python` script for generating a complete roadmap has been provided with some options, along with a `C++` example of using the planner. To use them, checkout the `example` branch of the repository. Now we will run `batching_pomp` on a 2D point planning example on a B/W map. All code is assumed to be run from the `batching_pomp` level of the repository. Check the imports in the `scripts/save_sequence_to_graph.py` file to see what `Python` libraries you need. You will also need `OpenCV` to run the example.\n\nThe first step is to generate a complete roadmap for the unit 2D grid (the locations in the unit grid will be scaled to the square image, where (0,0) is the upper left and (1,1) is the lower right of the image). To do this, run\n```shell\n$ python scripts/save_sequence_to_graph.py --num_nodes 1000 --dimensions 2 --bounds unit --sequence halton --outfile data/halton_2d_1000.graphml\n```\nOpen up the `.graphml` file if you have never seen one before and take a look at how the states are associated with the vertex IDs. Note that there are no edges defined between vertex IDs as these are assumed to be complete roadmaps, with the edges based on radii of connectivity, handled by the batching manager.\n\nNow you can run the example in `scripts/example_2d_image.cc` on the map in `data/example_map.png`, once you have built the package and example. The example assumes you have a catkin workspace in which `batching_pomp` resides but you can also just use the typical `cmake` procedure \n```shell\n$ catkin build batching_pomp # Assuming you have a catkin workspace\n$ ../../devel/lib/batching_pomp/example_2d -f data/halton_2d_5000.graphml -m data/example_map.png -v halton -s 0.1 0.1 -g 0.9 0.9 -b hybrid # There's probably an easier way to call the executable\n```\nYou should see an OpenCV window with a solution path pop up. Keep pressing the 'Enter' key over the window to get shorter and shorter paths.\n\nThe above example assumes you have a `catkin` workspace but if you do not, you should still be able to do it through the `cmake` and `make` route after editing the `CMakeLists.txt` file appropriately. Contact the author for help with that if needed.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpersonalrobotics%2Fbatching_pomp","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fpersonalrobotics%2Fbatching_pomp","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpersonalrobotics%2Fbatching_pomp/lists"}