Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • gsaurel/hpp-manipulation
  • humanoid-path-planner/hpp-manipulation
2 results
Show changes
Commits on Source (943)
843 additional commits have been omitted to prevent performance issues.
Hide whitespace changes
Inline Side-by-side
Showing
with 632 additions and 246 deletions
.git-blame-ignore-revs 0 → 100644
View file @ 539aab52
# format (Guilhem Saurel, 2022-05-31)
fa649fc248b998a890e2730d8b56b238ca1e29df
# format (Guilhem Saurel, 2022-04-19)
2504d66d880b757858a5d90d2c7e4bf98e6e6139
# pre-commit run -a (Guilhem Saurel, 2022-10-05)
ccd75ad4f6e33d1690353b17383f4bca6dab2907
.github/workflows/nix.yml 0 → 100644
View file @ 539aab52
name: "CI - Nix"
on:
push:
jobs:
tests:
name: "Nix build on ${{ matrix.os }}"
runs-on: "${{ matrix.os }}-latest"
strategy:
matrix:
os: [ubuntu]
steps:
- uses: actions/checkout@v4
- uses: cachix/install-nix-action@v27
- uses: cachix/cachix-action@v15
with:
name: gepetto
authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
- run: nix build -L
.gitlab-ci.yml 0 → 100644
View file @ 539aab52
include: https://rainboard.laas.fr/project/hpp-manipulation/.gitlab-ci.yml
.gitmodules
View file @ 539aab52
[submodule "cmake"] [submodule "cmake"]
path = cmake path = cmake
url = git://github.com/jrl-umi3218/jrl-cmakemodules.git url = https://github.com/jrl-umi3218/jrl-cmakemodules.git
.mergify.yml 0 → 100644
View file @ 539aab52
pull_request_rules:
- name: merge automatically when CI passes and PR is approved
conditions:
- check-success = "gitlab-ci"
- check-success = "Nix build on ubuntu"
- check-success = "pre-commit.ci - pr"
- or:
- author = pre-commit-ci[bot]
- author = dependabot[bot]
actions:
merge:
.pre-commit-config.yaml 0 → 100644
View file @ 539aab52
ci:
autoupdate_branch: devel
repos:
- repo: https://github.com/astral-sh/ruff-pre-commit
rev: v0.8.1
hooks:
- id: ruff
args:
- --fix
- --exit-non-zero-on-fix
- id: ruff-format
- repo: https://github.com/cheshirekow/cmake-format-precommit
rev: v0.6.13
hooks:
- id: cmake-format
- repo: https://github.com/pappasam/toml-sort
rev: v0.24.2
hooks:
- id: toml-sort-fix
exclude: poetry.lock
- repo: https://github.com/pre-commit/mirrors-clang-format
rev: v19.1.4
hooks:
- id: clang-format
args:
- --style=Google
- repo: https://github.com/pre-commit/pre-commit-hooks
rev: v5.0.0
hooks:
- id: check-added-large-files
- id: check-ast
- id: check-executables-have-shebangs
- id: check-json
- id: check-merge-conflict
- id: check-symlinks
- id: check-toml
- id: check-yaml
- id: debug-statements
- id: destroyed-symlinks
- id: detect-private-key
- id: end-of-file-fixer
- id: fix-byte-order-marker
- id: mixed-line-ending
- id: trailing-whitespace
CMakeLists.txt
View file @ 539aab52
# #
# Copyright (c) 2014 CNRS # Copyright (c) 2014, 2020 CNRS Authors: Florent Lamiraux, Guilhem Saurel
# Authors: Florent Lamiraux
# #
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# #
# This file is part of hpp-manipulation # 1. Redistributions in binary form must reproduce the above copyright notice,
# hpp-manipulation is free software: you can redistribute it # this list of conditions and the following disclaimer in the documentation
# and/or modify it under the terms of the GNU Lesser General Public # and/or other materials provided with the distribution.
# License as published by the Free Software Foundation, either version
# 3 of the License, or (at your option) any later version.
# #
# hpp-manipulation is distributed in the hope that it will be # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# General Lesser Public License for more details. You should have # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# received a copy of the GNU Lesser General Public License along with # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# hpp-manipulation If not, see # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# <http://www.gnu.org/licenses/>. # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
CMAKE_MINIMUM_REQUIRED(VERSION 2.6) # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
SET(CXX_DISABLE_WERROR TRUE)
INCLUDE(cmake/base.cmake) cmake_minimum_required(VERSION 3.10)
INCLUDE(cmake/boost.cmake)
set(PROJECT_NAME hpp-manipulation)
SET(PROJECT_NAME hpp-manipulation) set(PROJECT_DESCRIPTION "Classes for manipulation planning.")
SET(PROJECT_URL "")
SET(PROJECT_DESCRIPTION "Classes for manipulation planning.") set(PROJECT_USE_CMAKE_EXPORT TRUE)
set(CXX_DISABLE_WERROR TRUE)
SETUP_PROJECT()
# Check if the submodule cmake have been initialized
# Activate hpp-util logging if requested set(JRL_CMAKE_MODULES "${CMAKE_CURRENT_LIST_DIR}/cmake")
SET (HPP_DEBUG FALSE CACHE BOOL "trigger hpp-util debug output") if(EXISTS "${JRL_CMAKE_MODULES}/base.cmake")
IF (HPP_DEBUG) message(STATUS "JRL cmakemodules found in 'cmake/' git submodule")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHPP_DEBUG") else()
ENDIF() find_package(jrl-cmakemodules QUIET CONFIG)
if(jrl-cmakemodules_FOUND)
# Activate test using UR5 if requested get_property(
SET (TEST_UR5 FALSE CACHE BOOL "Activate tests using ur5") JRL_CMAKE_MODULES
TARGET jrl-cmakemodules::jrl-cmakemodules
SEARCH_FOR_BOOST() PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
ADD_DOC_DEPENDENCY(hpp-model >= 3.0.0) message(STATUS "JRL cmakemodules found on system at ${JRL_CMAKE_MODULES}")
ADD_REQUIRED_DEPENDENCY(hpp-core >= 3.0.0) elseif(${CMAKE_VERSION} VERSION_LESS "3.14.0")
ADD_REQUIRED_DEPENDENCY(hpp-constraints >= 3.0.0) message(
ADD_REQUIRED_DEPENDENCY(hpp-statistics >= 0.1) FATAL_ERROR
IF (TEST_UR5) "\nCan't find jrl-cmakemodules. Please either:\n"
ADD_REQUIRED_DEPENDENCY(hpp-model-urdf >= 3.0.0) " - use git submodule: 'git submodule update --init'\n"
ENDIF () " - or install https://github.com/jrl-umi3218/jrl-cmakemodules\n"
" - or upgrade your CMake version to >= 3.14 to allow automatic fetching\n"
SET (${PROJECT_NAME}_HEADERS )
include/hpp/manipulation/fwd.hh else()
include/hpp/manipulation/axial-handle.hh message(STATUS "JRL cmakemodules not found. Let's fetch it.")
include/hpp/manipulation/handle.hh include(FetchContent)
include/hpp/manipulation/object.hh FetchContent_Declare(
include/hpp/manipulation/problem.hh "jrl-cmakemodules"
include/hpp/manipulation/problem-solver.hh GIT_REPOSITORY "https://github.com/jrl-umi3218/jrl-cmakemodules.git")
include/hpp/manipulation/robot.hh FetchContent_MakeAvailable("jrl-cmakemodules")
include/hpp/manipulation/roadmap.hh FetchContent_GetProperties("jrl-cmakemodules" SOURCE_DIR JRL_CMAKE_MODULES)
include/hpp/manipulation/manipulation-planner.hh endif()
include/hpp/manipulation/graph-path-validation.hh endif()
include/hpp/manipulation/graph-steering-method.hh
include/hpp/manipulation/graph/node.hh include("${JRL_CMAKE_MODULES}/hpp.cmake")
include/hpp/manipulation/graph/edge.hh include("${JRL_CMAKE_MODULES}/boost.cmake")
include/hpp/manipulation/graph/node-selector.hh include("${JRL_CMAKE_MODULES}/test.cmake")
include/hpp/manipulation/graph/graph.hh
include/hpp/manipulation/graph/statistics.hh compute_project_args(PROJECT_ARGS LANGUAGES CXX)
include/hpp/manipulation/graph/graph-component.hh project(${PROJECT_NAME} ${PROJECT_ARGS})
include/hpp/manipulation/graph/fwd.hh
include/hpp/manipulation/graph/dot.hh list(APPEND PKG_CONFIG_ADDITIONAL_VARIABLES cmake_plugin)
)
# Ask Doxygen to create a tree view in html documentation
# Add dependency toward hpp-model library in pkg-config file. set(DOXYGEN_TREEVIEW
PKG_CONFIG_APPEND_LIBS("hpp-manipulation") "NO"
CACHE STRING "Set to YES to generate a tree view in the html documentation")
ADD_SUBDIRECTORY(src)
ADD_SUBDIRECTORY(tests) add_project_dependency(Boost REQUIRED COMPONENTS regex)
SETUP_PROJECT_FINALIZE() add_project_dependency("hpp-core" REQUIRED)
if(BUILD_TESTING)
find_package(Boost REQUIRED COMPONENTS unit_test_framework)
add_project_dependency("example-robot-data" REQUIRED)
endif()
config_files(doc/main.hh include/hpp/manipulation/package-config.hh)
set(${PROJECT_NAME}_HEADERS
${CMAKE_BINARY_DIR}/include/hpp/manipulation/package-config.hh
include/hpp/manipulation/fwd.hh
include/hpp/manipulation/handle.hh
include/hpp/manipulation/problem.hh
include/hpp/manipulation/problem-solver.hh
include/hpp/manipulation/device.hh
include/hpp/manipulation/weighed-distance.hh
include/hpp/manipulation/constraint-set.hh
include/hpp/manipulation/roadmap.hh
include/hpp/manipulation/roadmap-node.hh
include/hpp/manipulation/connected-component.hh
include/hpp/manipulation/leaf-connected-comp.hh
include/hpp/manipulation/manipulation-planner.hh
include/hpp/manipulation/graph-path-validation.hh
include/hpp/manipulation/graph-optimizer.hh
include/hpp/manipulation/graph/state.hh
include/hpp/manipulation/graph/edge.hh
include/hpp/manipulation/graph/state-selector.hh
include/hpp/manipulation/graph/guided-state-selector.hh
include/hpp/manipulation/graph/graph.hh
include/hpp/manipulation/graph/statistics.hh
include/hpp/manipulation/graph/graph-component.hh
include/hpp/manipulation/graph/fwd.hh
include/hpp/manipulation/graph/dot.hh
include/hpp/manipulation/graph/helper.hh
include/hpp/manipulation/graph/validation.hh
include/hpp/manipulation/path-optimization/enforce-transition-semantic.hh
include/hpp/manipulation/path-optimization/random-shortcut.hh
include/hpp/manipulation/path-optimization/spline-gradient-based.hh
include/hpp/manipulation/path-planner/end-effector-trajectory.hh
include/hpp/manipulation/path-planner/states-path-finder.hh
include/hpp/manipulation/path-planner/transition-planner.hh
include/hpp/manipulation/problem-target/state.hh
include/hpp/manipulation/serialization.hh
include/hpp/manipulation/steering-method/cross-state-optimization.hh
include/hpp/manipulation/steering-method/fwd.hh
include/hpp/manipulation/steering-method/graph.hh
include/hpp/manipulation/steering-method/end-effector-trajectory.hh)
set(${PROJECT_NAME}_SOURCES
src/handle.cc
src/manipulation-planner.cc
src/problem-solver.cc
src/roadmap.cc
src/connected-component.cc
src/leaf-connected-comp.cc
src/constraint-set.cc
src/roadmap-node.cc
src/device.cc
src/weighed-distance.cc
src/problem.cc
src/graph-path-validation.cc
src/graph-optimizer.cc
src/graph/state.cc
src/graph/edge.cc
src/graph/graph.cc
src/graph/graph-component.cc
src/graph/state-selector.cc
src/graph/guided-state-selector.cc
src/graph/statistics.cc
src/graph/helper.cc
src/graph/dot.cc
src/graph/validation.cc
src/path-optimization/random-shortcut.cc
src/path-optimization/enforce-transition-semantic.cc
src/path-planner/end-effector-trajectory.cc
src/path-planner/states-path-finder.cc
src/path-planner/transition-planner.cc
src/problem-target/state.cc
src/serialization.cc
src/steering-method/end-effector-trajectory.cc
src/steering-method/cross-state-optimization.cc
src/steering-method/graph.cc)
add_library(${PROJECT_NAME} SHARED ${${PROJECT_NAME}_SOURCES}
${${PROJECT_NAME}_HEADERS})
target_include_directories(
${PROJECT_NAME} PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
target_link_libraries(${PROJECT_NAME} hpp-core::hpp-core Boost::regex)
install(
TARGETS ${PROJECT_NAME}
EXPORT ${TARGETS_EXPORT_NAME}
DESTINATION lib)
# GPL licenced part
set(${PROJECT_NAME}_SOURCES_GPL src/path-optimization/spline-gradient-based.cc)
add_library(${PROJECT_NAME}-gpl SHARED ${${PROJECT_NAME}_SOURCES_GPL})
target_link_libraries(${PROJECT_NAME}-gpl ${PROJECT_NAME}
hpp-core::hpp-core-gpl)
install(
TARGETS ${PROJECT_NAME}-gpl
EXPORT ${TARGETS_EXPORT_NAME}
DESTINATION lib)
add_subdirectory(plugins)
if(BUILD_TESTING)
add_subdirectory(tests)
endif()
pkg_config_append_libs(${PROJECT_NAME})
install(FILES package.xml DESTINATION share/${PROJECT_NAME})
LICENSE 0 → 100644
View file @ 539aab52
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
NEWS
View file @ 539aab52
2014/12/03 - Release 1.0.1 -*- outline -*-
* Fix bug in WaypointEdge * Dependency to hpp-wholebody-step has been removed.
New in 4.10.0
2014/11/18 - Release 1.0 * In graph::steeringMethod, if q1 == q2, the steering method calls the problem
* Manipulation planner based on RRT. inner steering method. This avoids a failure if no loop transition has been
* A graph of constraint. set on the state containing q1.
* graph::Edge has 3 implementations: Edge, WaypointEdge, LevelSetEdge * In class Edge,
* WaypointEdge supports several waypoints. - different security margins for different pairs of links can
* LevelSetEdge solves the zero-probability problem. be set for collision checking,
- rename some methods for homogeneity with python bindings
- applyConstraints -> generateTargetConfig
- configConstraint -> targetConstraint,
- from -> stateFrom, to -> stateTo,
* In class WaypointEdge,
- specialize initialization.
* In class LevelSetEdge,
- write documentation,
- rename method applyConstraintsWithOffset into generateTargetConfigOnLeaf,
- add read access to condition and parameterization constraints.
* In class GraphComponent,
- add cost
* Add end-effector-tracjectory plugin.
* In class ManipulationPlanner,
- call the problem PathValidation instead of the edge one.
* In class ProblemSolver
- register contact constraints and complement in constraint graph.
New in 4.8.0
* Rewrite steering method CrossStateOptimization.
* In graph component classes (State, Edge, Graph) locked joints are handled as other numerical constraints.
- decouple waypoint computations.
New in 4.6.0
* Add setter to relative motion matrix in edges.
* Add method Edge::neighborEdges.
* Enrich API of EndEffectorTrajectory steeringMethod.
* Fix API of Problem: make steeringMethod setter accessible.
* Always use edge validation and steering method in ManipulationPlanner.
* Make GraphPathValidation not mandatory.
* Remove SymbolicPlanner.
* Keep the default validation from hpp-core.
New in 4.1
* Reset data when inserting robot.
* Fix detection of hpp-wholebody-step.
* In GraphSteeringMethod; create a inner steering method at construction.
* Move lockedJointPtr_t to hpp-core in hpp::manipulation::ProblemSolver
* Remove unused static method Handle::createGrasp.
* Make class AxialHandle deprecated.
* Add a method createGraspAndComplement in Handle classes
* Add className static members in classes Handle and AxialHandle.
* Add a method createGraspAndComplement in Handle classes.
* Dectect pairs (constraint, complement) and replace by relative transformation.
* Make robot type hpp::manipulation::Device in ProblemSolver.
* Check input path of GraphPathValidation
* In class Roadmap call parent implementation in init method
* Rename class SymbolicComponent into LeafConnectedCompo.
* Rewrite implementation of class LeafConnectedComp.
* Add class problemTarget::State.
* Fix case where robot already exists in Device::didInsertRobot.
* Add parameter ManipulationPlanner/ExtendStep.
* Class Handle takes a mask as input.
* Update to changes about ConfigProjector::updateRightHandSize.
* Add LockedJoint before NumericalConstraint into ConfigProjector.
* GraphSteeringMethod is built with a const Problem& (not a ProblemPtr_t).
* Fix Roadmap::clear (remove symbolic components).
* Add possibility to provide placement constraint for automatic graph creation.
* Add SplineGradientBased for manipulation path
* Add possibility to set derivatives at state change to zero (SplineGradientBased).
* GraphOptimizer uses path validation of edge for optimization.
* Improve initialization of the graph and fix more const-correctness errors.
* ProblemSolver has a map of graph::GraphPtr_t.
* Prevent name collision in graph construction.
New in 1.1
* Add projector for paths.
* Add information in the tooltips of the DOT graph.
New in 1.0.2
* Fix bug when projection using WaypointEdge
New in 1.0.1
* Fix bug in WaypointEdge
New in 1.0
* Manipulation planner based on RRT.
* A graph of constraint.
* graph::Edge has 3 implementations: Edge, WaypointEdge, LevelSetEdge
* WaypointEdge supports several waypoints.
* LevelSetEdge solves the zero-probability problem.
README.md
View file @ 539aab52
# hpp-manipulation # hpp-manipulation
[![Building Status](https://travis-ci.org/humanoid-path-planner/hpp-manipulation.svg?branch=master)](https://travis-ci.org/humanoid-path-planner/hpp-manipulation)
[![Pipeline status](https://gitlab.laas.fr/humanoid-path-planner/hpp-manipulation/badges/master/pipeline.svg)](https://gitlab.laas.fr/humanoid-path-planner/hpp-manipulation/commits/master)
[![Coverage report](https://gitlab.laas.fr/humanoid-path-planner/hpp-manipulation/badges/master/coverage.svg?job=doc-coverage)](https://gepettoweb.laas.fr/doc/humanoid-path-planner/hpp-manipulation/master/coverage/)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/humanoid-path-planner/hpp-manipulation/master.svg)](https://results.pre-commit.ci/latest/github/humanoid-path-planner/hpp-manipulation)
This package is part of the [HPP] software and extends the functionalities of hpp-core. This package is part of the [HPP] software and extends the functionalities of hpp-core.
It implements a solver for manipulation planning problems. It implements a solver for manipulation planning problems.
### Version
1.0.1
### Dependencies ### Dependencies
[hpp-manipulation] needs the following package to be installed: [hpp-manipulation] needs the following package to be installed:
......
TODO.txt 0 → 100644
View file @ 539aab52
- InStatePath::solve
BiRRT* does not work properly at all:
- discontinuities due to an algorithmic mistake involving qProj_
- not using path projectors, while it should
DiffusingPlanner does not work properly sometimes
- Some collisions were detected on paths solves for romeo-placard
both with discrete and continuous (Progressive, 0.2) path validations
- InStatePath::mergeLeafRoadmapWith
this is inefficient because the roadmap recomputes the connected
component at every step. A better merge function should be added to roadmap.cc
- path optimizations after solving once :
They are done "locally" (for each of the leafs separately) in C++ with a
hard-coded optimizer (Graph-RandomShortcut) and then globally with the
command ps.addPathOptimizer("Graph-RandomShortcut"). Due to how this works,
this is like doing two times the same thing so the first should be removed.
However bugs have been observed when the global optimization is used (Core
dumped). For unknown reasons, in GraphOptimizer::optimize, the dynamic
cast of current->constraints() may fail on *some* 0-length paths. Ignoring
empty paths (the "if" I have added) seems to make the problem disappear
but the reason why some 0-length paths don't have the right Constraint type
is still to be found.
cmake @ 29c0eb4e
Subproject commit ab445160dbf90221334ec17bcf0366beb2dbea18 Subproject commit 29c0eb4e659304f44d55a0389e2749812d858659
doc/Doxyfile.extra.in
View file @ 539aab52
...@@ -2,13 +2,10 @@ INPUT = @CMAKE_SOURCE_DIR@/doc \ ...@@ -2,13 +2,10 @@ INPUT = @CMAKE_SOURCE_DIR@/doc \
@CMAKE_SOURCE_DIR@/include \ @CMAKE_SOURCE_DIR@/include \
@CMAKE_BINARY_DIR@/doc @CMAKE_BINARY_DIR@/doc
TAGFILES = @HPP_MODEL_DOXYGENDOCDIR@/hpp-model.doxytag=@HPP_MODEL_DOXYGENDOCDIR@ \
@HPP_CORE_DOXYGENDOCDIR@/hpp-core.doxytag=@HPP_CORE_DOXYGENDOCDIR@ \
@HPP_CONSTRAINTS_DOXYGENDOCDIR@/hpp-constraints.doxytag=@HPP_CONSTRAINTS_DOXYGENDOCDIR@
HTML_EXTRA_FILES = @CMAKE_SOURCE_DIR@/doc/ObjectManipulation_MasterThesis_JosephMirabel.pdf HTML_EXTRA_FILES = @CMAKE_SOURCE_DIR@/doc/ObjectManipulation_MasterThesis_JosephMirabel.pdf
ALIASES += Link{1}="\ref \1" ALIASES += Link{1}="\ref \1"
ALIASES += Link{2}="\ref \1 \"\2\"" ALIASES += Link{2}="\ref \1 \"\2\""
ALIASES += LHPP{2}="\Link{hpp::\1::\2, \2}" ALIASES += LHPP{2}="\Link{hpp::\1::\2,\2}"
ALIASES += LModel{1}="\LHPP{model, \1}" ALIASES += LPinocchio{1}="\LHPP{pinocchio,\1}"
USE_MATHJAX= YES
doc/constraint-graph.png 0 → 100644
View file @ 539aab52
doc/constraint-graph.png

367 KiB

doc/main.hh deleted 100644 → 0
View file @ dfb4329e
namespace hpp {
namespace manipulation {
namespace graph {
/**
\mainpage
\section sec_intro_hpp_manipulation Introduction
This package implements a solver for manipulation planning problems. A manipulation planning problem
is defined by:
\li Robot Build a \LModel{Device} from several \LModel{Device} and Object,
\li Object A \LModel{Device} with Handle,
\li Graph A graph of constraints defining the rules of a manipulation problem,
\li ManipulationPlanner Implements a RRT-based algorithm to solve manipulation planning problems.
\section sec_graph_hpp_manipulation Constraint graph
The graph of constraint, also referred to as constraint graph, represents the rules of a manipulation problem.
The component of the graph are:
\li Node represents a state of the Robot with constraints,
\li Edge represents a transition between two Node with parametric constraints.
Node contains a set of \LHPP{core,Constraint} that a configuration of the Robot should satisfy
to be in the represented state. To ensure that a configuration is in only one state, the Node are
ordered in a NodeSelector. The method NodeSelector::getNode(ConfigurationIn_t) const returns a
pointer to the first Node for which Node::contains(ConfigurationIn_t) const returns true.
For optimization only, another set of \LHPP{core,Constraint} is used for \LHPP{core,StraightPath} lying in this Node.
Edge has methods Edge::isInNodeFrom, to tell if a corresponding path lyes in Edge::from() or Edge::to(),
and Edge::node(), to retrive this Node.
Edge also contains two sets of \LHPP{core,Constraint}:
\li Edge::configConstraint() returns a \LHPP{core,ConstraintSet} used to generate a configuration lying in Edge::to()
and respecting the offset (previsously set using hpp::core::Constraint::offsetFromConfig),
\li Edge::pathConstraint() returns a \LHPP{core,ConstraintSet} to be inserted in \LHPP{core,Path} represented
by this Edge.
\note
For implementation details, see graph::Graph.
For more information about parametric and non-parametric constraints, see \LHPP{core,DifferentiableFunction}
and \LHPP{core,ConfigProjector}
\section sec_solver_hpp_manipulation Manipulation planner
ManipulationPlanner class implements an algorithm based on RRT. See
<a href="ObjectManipulation_MasterThesis_JosephMirabel.pdf">this master thesis</a> for details about the algorithm.
**/
}
}
}
doc/main.hh.in 0 → 100644
View file @ 539aab52
namespace hpp {
namespace manipulation {
/**
\mainpage hpp-manipulation documentation
\anchor hpp_manipulation_documentation
\par Introduction
This package implements a solver for manipulation planning problems. A
manipulation planning problem is defined by:
\li Device: a collection of several \LPinocchio{Device} with \ref Gripper
"grippers" and \ref Handle "handles",
\li Graph: A graph of constraints defining the rules of a manipulation
problem.
ManipulationPlanner implements a RRT-based algorithm to solve manipulation
planning problems.
\par Constraint graph
The graph of constraint, also referred to as constraint graph, represents the
rules of a manipulation problem. The component of the graph are:
\li graph::State represents a state of the Robot with constraints,
\li graph::Edge represents a transition between two graph::State with parametric constraints.
graph::State contains a set of \LHPP{core,Constraint} that a configuration of the
Robot should satisfy to be in the represented state. To ensure that a
configuration is in only one state, the graph::State are ordered in a graph::StateSelector.
The method graph::StateSelector::getState(ConfigurationIn_t) const returns a pointer to
the first graph::State for which graph::State::contains(ConfigurationIn_t) const returns true.
For optimization only, another set of \LHPP{core,Constraint} is used for
\LHPP{core,StraightPath} lying in this graph::State.
graph::Edge has methods graph::Edge::state() to tell in which graph::State a corresponding path lyes
graph::Edge also contains two sets of \LHPP{core,Constraint}:
\li graph::Edge::configConstraint() returns a \LHPP{core,ConstraintSet} used to
generate a configuration lying in graph::Edge::to() and respecting the
\LHPP{core,ConfigProjector::rightHandSide},
\li graph::Edge::pathConstraint() returns a \LHPP{core,ConstraintSet} to be inserted
in \LHPP{core,Path} represented by this graph::Edge.
\note
For implementation details, see graph::Graph.
For more information about parametric and non-parametric constraints, see
\LHPP{core,DifferentiableFunction} and \LHPP{core,ConfigProjector}
\par Manipulation planner
ManipulationPlanner class implements an algorithm based on RRT. See
<a href="ObjectManipulation_MasterThesis_JosephMirabel.pdf">this master
thesis</a> for details about the algorithm.
**/
} // namespace manipulation
} // namespace hpp
flake.lock 0 → 100644
View file @ 539aab52
{
"nodes": {
"flake-parts": {
"inputs": {
"nixpkgs-lib": [
"nixpkgs"
]
},
"locked": {
"lastModified": 1719877454,
"narHash": "sha256-g5N1yyOSsPNiOlFfkuI/wcUjmtah+nxdImJqrSATjOU=",
"owner": "hercules-ci",
"repo": "flake-parts",
"rev": "4e3583423212f9303aa1a6337f8dffb415920e4f",
"type": "github"
},
"original": {
"owner": "hercules-ci",
"repo": "flake-parts",
"type": "github"
}
},
"nixpkgs": {
"locked": {
"lastModified": 1727174734,
"narHash": "sha256-xa3TynMF5vaWonmTOg/Ejc1Fmo0GkQnCaVRVkBc3z2I=",
"owner": "gepetto",
"repo": "nixpkgs",
"rev": "0ad139a0e4372abc12320c8c92ee90e0e5e296e1",
"type": "github"
},
"original": {
"owner": "gepetto",
"repo": "nixpkgs",
"type": "github"
}
},
"root": {
"inputs": {
"flake-parts": "flake-parts",
"nixpkgs": "nixpkgs"
}
}
},
"root": "root",
"version": 7
}
flake.nix 0 → 100644
View file @ 539aab52
{
description = "Classes for manipulation planning";
inputs = {
nixpkgs.url = "github:gepetto/nixpkgs";
flake-parts = {
url = "github:hercules-ci/flake-parts";
inputs.nixpkgs-lib.follows = "nixpkgs";
};
};
outputs =
inputs:
inputs.flake-parts.lib.mkFlake { inherit inputs; } {
systems = [
"x86_64-linux"
"aarch64-linux"
"aarch64-darwin"
"x86_64-darwin"
];
perSystem =
{ pkgs, self', ... }:
{
devShells.default = pkgs.mkShell { inputsFrom = [ self'.packages.default ]; };
packages = {
default = self'.packages.hpp-manipulation;
hpp-manipulation = pkgs.hpp-manipulation.overrideAttrs (_: {
src = pkgs.lib.fileset.toSource {
root = ./.;
fileset = pkgs.lib.fileset.unions [
./CMakeLists.txt
./doc
./include
./package.xml
./plugins
./src
./tests
];
};
});
};
};
};
}
include/hpp/manipulation/axial-handle.hh deleted 100644 → 0
View file @ dfb4329e
///
/// Copyright (c) 2014 CNRS
/// Authors: Florent Lamiraux
///
///
// This file is part of hpp-manipulation.
// hpp-manipulation is free software: you can redistribute it
// and/or modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation, either version
// 3 of the License, or (at your option) any later version.
//
// hpp-manipulation is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Lesser Public License for more details. You should have
// received a copy of the GNU Lesser General Public License along with
// hpp-manipulation. If not, see
// <http://www.gnu.org/licenses/>.
#ifndef HPP_MANIPULATION_AXIAL_HANDLE_HH
# define HPP_MANIPULATION_AXIAL_HANDLE_HH
# include <hpp/manipulation/handle.hh>
namespace hpp {
namespace manipulation {
/// Handle symmetric around its x-axis.
class AxialHandle : public Handle
{
public:
/// Create constraint corresponding to a gripper grasping this object
/// \param robot the robot that grasps the handle,
/// \param grasp object containing the grasp information
/// \return the constraint of relative position between the handle and
/// the gripper. The rotation around x is not constrained.
static AxialHandlePtr_t create (const std::string& name,
const Transform3f& localPosition,
const JointPtr_t& joint)
{
AxialHandle* ptr = new AxialHandle (name, localPosition, joint);
AxialHandlePtr_t shPtr (ptr);
ptr->init (shPtr);
return shPtr;
}
/// Return a pointer to the copy of this
virtual HandlePtr_t clone () const;
/// Create constraint corresponding to a gripper grasping this object
/// \param grasp object containing the grasp information
/// \return the constraint of relative transformation between the handle and
/// the gripper. The rotation around x is not constrained.
virtual DifferentiableFunctionPtr_t createGrasp
(const GripperPtr_t& gripper) const;
/// Create constraint that acts on the non-constrained axis of the
/// constraint generated by Handle::createGrasp.
/// \param gripper object containing the gripper information
/// \return a relative orientation constraint between the handle and
/// the gripper. Only the rotation around the x-axis is constrained.
virtual DifferentiableFunctionPtr_t createGraspComplement
(const GripperPtr_t& gripper) const;
/// Create constraint corresponding to a pregrasping task.
/// \param gripper object containing the gripper information
/// \return the constraint of relative transformation between the handle and
/// the gripper.
/// \note The translation along x-axis and the rotation around z-axis are not constrained.
virtual DifferentiableFunctionPtr_t createPreGrasp
(const GripperPtr_t& gripper) const;
/// Create constraint that acts on the non-constrained axis of the
/// constraint generated by Handle::createPreGrasp.
/// \param gripper object containing the gripper information
/// \param shift the target value along the x-axis
/// \return the constraint of relative position between the handle and
/// the gripper.
/// \note The translation along x-axis and the rotation around z-axis are constrained.
virtual DifferentiableFunctionPtr_t createPreGraspComplement
(const GripperPtr_t& gripper, const value_type& shift) const;
virtual std::ostream& print (std::ostream& os) const;
protected:
/// Constructor
/// \param robot the robot that grasps the handle,
/// \param grasp object containing the grasp information
/// \return the constraint of relative position between the handle and
/// the gripper. The rotation around x is not constrained.
AxialHandle (const std::string& name, const Transform3f& localPosition,
const JointPtr_t& joint) : Handle (name, localPosition,
joint), weakPtr_ ()
{
}
void init (const AxialHandleWkPtr_t& weakPtr)
{
Handle::init (weakPtr);
weakPtr_ = weakPtr;
}
/// Weak pointer to itself
AxialHandleWkPtr_t weakPtr_;
}; // class AxialHandle
} // namespace manipulation
} // namespace hpp
#endif // HPP_MANIPULATION_AXIAL_HANDLE_HH
include/hpp/manipulation/connected-component.hh 0 → 100644
View file @ 539aab52
//
// Copyright (c) 2015 CNRS
// Authors: Anna Seppala (seppala@laas.fr)
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
#ifndef HPP_MANIPULATION_CONNECTED_COMPONENT_HH
#define HPP_MANIPULATION_CONNECTED_COMPONENT_HH
#include <hpp/core/connected-component.hh>
#include <hpp/manipulation/config.hh>
#include <hpp/manipulation/fwd.hh>
#include <hpp/manipulation/graph/fwd.hh>
namespace hpp {
namespace manipulation {
/// Extension of hpp::core::connected-component. Adds a list of roadmap nodes
/// for every contraint graph state within the connected component. Thus every
/// roadmap node is assigned to a grahp state, which minimises computation time.
class HPP_MANIPULATION_DLLAPI ConnectedComponent
: public core::ConnectedComponent {
public:
/// Map of graph states within the connected component
typedef std::map<graph::StatePtr_t, RoadmapNodes_t> GraphStates_t;
ConnectedComponent() {}
/// return a shared pointer to new instance of
/// manipulation::ConnectedComponent
static ConnectedComponentPtr_t create(const RoadmapWkPtr_t& roadmap);
/// Merge two connected components (extension of
/// core::ConnectedComponent::merge) \param other manipulation connected
/// component to merge into this one. \note other will be empty after calling
/// this method.
void merge(const core::ConnectedComponentPtr_t& otherCC);
/// Add roadmap node to connected component
/// \param roadmap node to be added
void addNode(const core::NodePtr_t& node);
const RoadmapNodes_t& getRoadmapNodes(
const graph::StatePtr_t graphState) const;
protected:
private:
bool check() const;
GraphStates_t graphStateMap_;
// a RoadmapWkPtr_t so that memory can be released ?
RoadmapWkPtr_t roadmap_;
static RoadmapNodes_t empty_;
HPP_SERIALIZABLE();
}; // class ConnectedComponent
} // namespace manipulation
} // namespace hpp
#endif // HPP_MANIPULATION_CONNECTED_COMPONENT_HH