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 (758)
658 additional commits have been omitted to prevent performance issues.
Hide whitespace changes
Inline Side-by-side
Showing
with 655 additions and 346 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)
SET (HPP_BENCHMARK FALSE CACHE BOOL "trigger hpp-util benchmarking output") if(jrl-cmakemodules_FOUND)
IF (HPP_BENCHMARK) get_property(
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHPP_ENABLE_BENCHMARK") JRL_CMAKE_MODULES
ENDIF() TARGET jrl-cmakemodules::jrl-cmakemodules
PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
# Activate test using UR5 if requested message(STATUS "JRL cmakemodules found on system at ${JRL_CMAKE_MODULES}")
SET (TEST_UR5 FALSE CACHE BOOL "Activate tests using ur5") elseif(${CMAKE_VERSION} VERSION_LESS "3.14.0")
message(
SEARCH_FOR_BOOST() FATAL_ERROR
ADD_DOC_DEPENDENCY("hpp-model >= 3.0.0") "\nCan't find jrl-cmakemodules. Please either:\n"
ADD_DOC_DEPENDENCY("hpp-fcl") " - use git submodule: 'git submodule update --init'\n"
ADD_REQUIRED_DEPENDENCY("hpp-core >= 3.0.0") " - or install https://github.com/jrl-umi3218/jrl-cmakemodules\n"
ADD_REQUIRED_DEPENDENCY("hpp-constraints >= 3.0.0") " - or upgrade your CMake version to >= 3.14 to allow automatic fetching\n"
ADD_REQUIRED_DEPENDENCY("hpp-statistics >= 0.1") )
IF (TEST_UR5) else()
ADD_REQUIRED_DEPENDENCY(hpp-model-urdf >= 3.0.0) message(STATUS "JRL cmakemodules not found. Let's fetch it.")
ENDIF () include(FetchContent)
FetchContent_Declare(
CONFIGURE_FILE (${CMAKE_SOURCE_DIR}/doc/main.hh.in "jrl-cmakemodules"
${CMAKE_BINARY_DIR}/doc/main.hh GIT_REPOSITORY "https://github.com/jrl-umi3218/jrl-cmakemodules.git")
@ONLY FetchContent_MakeAvailable("jrl-cmakemodules")
) FetchContent_GetProperties("jrl-cmakemodules" SOURCE_DIR JRL_CMAKE_MODULES)
endif()
SET (${PROJECT_NAME}_HEADERS endif()
include/hpp/manipulation/fwd.hh
include/hpp/manipulation/axial-handle.hh include("${JRL_CMAKE_MODULES}/hpp.cmake")
include/hpp/manipulation/handle.hh include("${JRL_CMAKE_MODULES}/boost.cmake")
include/hpp/manipulation/problem.hh include("${JRL_CMAKE_MODULES}/test.cmake")
include/hpp/manipulation/problem-solver.hh
include/hpp/manipulation/device.hh compute_project_args(PROJECT_ARGS LANGUAGES CXX)
include/hpp/manipulation/weighed-distance.hh project(${PROJECT_NAME} ${PROJECT_ARGS})
include/hpp/manipulation/constraint-set.hh
include/hpp/manipulation/roadmap.hh list(APPEND PKG_CONFIG_ADDITIONAL_VARIABLES cmake_plugin)
include/hpp/manipulation/roadmap-node.hh
include/hpp/manipulation/connected-component.hh # Ask Doxygen to create a tree view in html documentation
include/hpp/manipulation/manipulation-planner.hh set(DOXYGEN_TREEVIEW
include/hpp/manipulation/graph-path-validation.hh "NO"
include/hpp/manipulation/graph-steering-method.hh CACHE STRING "Set to YES to generate a tree view in the html documentation")
include/hpp/manipulation/graph-optimizer.hh
include/hpp/manipulation/graph/node.hh add_project_dependency(Boost REQUIRED COMPONENTS regex)
include/hpp/manipulation/graph/edge.hh
include/hpp/manipulation/graph/node-selector.hh add_project_dependency("hpp-core" REQUIRED)
include/hpp/manipulation/graph/guided-node-selector.hh if(BUILD_TESTING)
include/hpp/manipulation/graph/graph.hh find_package(Boost REQUIRED COMPONENTS unit_test_framework)
include/hpp/manipulation/graph/statistics.hh add_project_dependency("example-robot-data" REQUIRED)
include/hpp/manipulation/graph/graph-component.hh endif()
include/hpp/manipulation/graph/fwd.hh
include/hpp/manipulation/graph/dot.hh config_files(doc/main.hh include/hpp/manipulation/package-config.hh)
include/hpp/manipulation/graph/helper.hh
set(${PROJECT_NAME}_HEADERS
include/hpp/manipulation/path-optimization/config-optimization.hh ${CMAKE_BINARY_DIR}/include/hpp/manipulation/package-config.hh
) include/hpp/manipulation/fwd.hh
include/hpp/manipulation/handle.hh
ADD_SUBDIRECTORY(src) include/hpp/manipulation/problem.hh
ADD_SUBDIRECTORY(tests) include/hpp/manipulation/problem-solver.hh
include/hpp/manipulation/device.hh
# Add dependency toward hpp-manipulation library in pkg-config file. include/hpp/manipulation/weighed-distance.hh
PKG_CONFIG_APPEND_LIBS("hpp-manipulation") include/hpp/manipulation/constraint-set.hh
include/hpp/manipulation/roadmap.hh
SETUP_PROJECT_FINALIZE() 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.1 -*- outline -*-
* Add projector for paths. * Dependency to hpp-wholebody-step has been removed.
* Add information in the tooltips of the DOT graph. New in 4.10.0
* In graph::steeringMethod, if q1 == q2, the steering method calls the problem
inner steering method. This avoids a failure if no loop transition has been
set on the state containing q1.
* In class Edge,
- different security margins for different pairs of links can
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.
2014/12/03 - Release 1.0.2 New in 4.8.0
* Fix bug when projection using WaypointEdge * Rewrite steering method CrossStateOptimization.
* In graph component classes (State, Edge, Graph) locked joints are handled as other numerical constraints.
- decouple waypoint computations.
2014/12/03 - Release 1.0.1 New in 4.6.0
* Fix bug in WaypointEdge * 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.
2014/11/18 - Release 1.0 New in 4.1
* Manipulation planner based on RRT. * Reset data when inserting robot.
* A graph of constraint. * Fix detection of hpp-wholebody-step.
* graph::Edge has 3 implementations: Edge, WaypointEdge, LevelSetEdge * In GraphSteeringMethod; create a inner steering method at construction.
* WaypointEdge supports several waypoints. * Move lockedJointPtr_t to hpp-core in hpp::manipulation::ProblemSolver
* LevelSetEdge solves the zero-probability problem. * 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.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 b166d5e143fc4d5a212a34e7de43d7831a980774 Subproject commit 29c0eb4e659304f44d55a0389e2749812d858659
doc/Doxyfile.extra.in
View file @ 539aab52
...@@ -2,15 +2,10 @@ INPUT = @CMAKE_SOURCE_DIR@/doc \ ...@@ -2,15 +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@ \
@HPP_FCL_DOXYGENDOCDIR@/hpp-fcl.doxytag=@HPP_FCL_DOXYGENDOCDIR@ \
@HPP_STATISTICS_DOXYGENDOCDIR@/hpp-statistics.doxytag=@HPP_STATISTICS_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.in
View file @ 539aab52
namespace hpp { namespace hpp {
namespace manipulation { namespace manipulation {
namespace graph {
/** /**
\mainpage \mainpage hpp-manipulation documentation
\anchor hpp_manipulation_documentation
\section sec_intro_hpp_manipulation Introduction \par Introduction
This package implements a solver for manipulation planning problems. A This package implements a solver for manipulation planning problems. A
manipulation planning problem is defined by: manipulation planning problem is defined by:
\li Device: a collection of several \LModel{Device} with \ref Gripper \li Device: a collection of several \LPinocchio{Device} with \ref Gripper
"grippers" and \ref Handle "handles", "grippers" and \ref Handle "handles",
\li Graph: A graph of constraints defining the rules of a manipulation \li Graph: A graph of constraints defining the rules of a manipulation
problem. problem.
...@@ -16,42 +16,39 @@ namespace hpp { ...@@ -16,42 +16,39 @@ namespace hpp {
ManipulationPlanner implements a RRT-based algorithm to solve manipulation ManipulationPlanner implements a RRT-based algorithm to solve manipulation
planning problems. planning problems.
\section sec_graph_hpp_manipulation Constraint graph \par Constraint graph
The graph of constraint, also referred to as constraint graph, represents the The graph of constraint, also referred to as constraint graph, represents the
rules of a manipulation problem. The component of the graph are: rules of a manipulation problem. The component of the graph are:
\li Node represents a state of the Robot with constraints, \li graph::State represents a state of the Robot with constraints,
\li Edge represents a transition between two Node with parametric constraints. \li graph::Edge represents a transition between two graph::State with parametric constraints.
Node contains a set of \LHPP{core,Constraint} that a configuration of the 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 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. configuration is in only one state, the graph::State are ordered in a graph::StateSelector.
The method NodeSelector::getNode(ConfigurationIn_t) const returns a pointer to The method graph::StateSelector::getState(ConfigurationIn_t) const returns a pointer to
the first Node for which Node::contains(ConfigurationIn_t) const returns true. 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 For optimization only, another set of \LHPP{core,Constraint} is used for
\LHPP{core,StraightPath} lying in this Node. \LHPP{core,StraightPath} lying in this graph::State.
Edge has methods Edge::isInNodeFrom, to tell if a corresponding path lyes in graph::Edge has methods graph::Edge::state() to tell in which graph::State a corresponding path lyes
Edge::from() or Edge::to(), and Edge::node(), to retrive this Node. graph::Edge also contains two sets of \LHPP{core,Constraint}:
Edge also contains two sets of \LHPP{core,Constraint}: \li graph::Edge::configConstraint() returns a \LHPP{core,ConstraintSet} used to
\li Edge::configConstraint() returns a \LHPP{core,ConstraintSet} used to generate a configuration lying in graph::Edge::to() and respecting the
generate a configuration lying in Edge::to() and respecting the
\LHPP{core,ConfigProjector::rightHandSide}, \LHPP{core,ConfigProjector::rightHandSide},
\li Edge::pathConstraint() returns a \LHPP{core,ConstraintSet} to be inserted \li graph::Edge::pathConstraint() returns a \LHPP{core,ConstraintSet} to be inserted
in \LHPP{core,Path} represented by this Edge. in \LHPP{core,Path} represented by this graph::Edge.
\note \note
For implementation details, see graph::Graph. For implementation details, see graph::Graph.
For more information about parametric and non-parametric constraints, see For more information about parametric and non-parametric constraints, see
\LHPP{core,DifferentiableFunction} and \LHPP{core,ConfigProjector} \LHPP{core,DifferentiableFunction} and \LHPP{core,ConfigProjector}
\section sec_solver_hpp_manipulation Manipulation planner \par Manipulation planner
ManipulationPlanner class implements an algorithm based on RRT. See ManipulationPlanner class implements an algorithm based on RRT. See
<a href="ObjectManipulation_MasterThesis_JosephMirabel.pdf">this master <a href="ObjectManipulation_MasterThesis_JosephMirabel.pdf">this master
thesis</a> for details about the algorithm. 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 @ 903d2372
///
/// 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 z-axis. The constraint defined for a grasp
/// by a gripper is free to rotate around z-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 NumericalConstraintPtr_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 NumericalConstraintPtr_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 NumericalConstraintPtr_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
/// \param width width of the interval of freedom of gripper along 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 NumericalConstraintPtr_t createPreGraspComplement
(const GripperPtr_t& gripper, const value_type& shift,
const value_type& width) 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
View file @ 539aab52
...@@ -2,19 +2,30 @@ ...@@ -2,19 +2,30 @@
// Copyright (c) 2015 CNRS // Copyright (c) 2015 CNRS
// Authors: Anna Seppala (seppala@laas.fr) // Authors: Anna Seppala (seppala@laas.fr)
// //
// This file is part of hpp-core
// hpp-core is free software: you can redistribute it // Redistribution and use in source and binary forms, with or without
// and/or modify it under the terms of the GNU Lesser General Public // modification, are permitted provided that the following conditions are
// License as published by the Free Software Foundation, either version // met:
// 3 of the License, or (at your option) any later version. //
// 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.
// //
// hpp-core is distributed in the hope that it will be // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// General Lesser Public License for more details. You should have // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// received a copy of the GNU Lesser General Public License along with // HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// hpp-core If not, see // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// <http://www.gnu.org/licenses/>. // 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 #ifndef HPP_MANIPULATION_CONNECTED_COMPONENT_HH
#define HPP_MANIPULATION_CONNECTED_COMPONENT_HH #define HPP_MANIPULATION_CONNECTED_COMPONENT_HH
...@@ -25,38 +36,45 @@ ...@@ -25,38 +36,45 @@
#include <hpp/manipulation/graph/fwd.hh> #include <hpp/manipulation/graph/fwd.hh>
namespace hpp { namespace hpp {
namespace manipulation { namespace manipulation {
/// Extension of hpp::core::connected-component. Adds a list of roadmap nodes for /// Extension of hpp::core::connected-component. Adds a list of roadmap nodes
/// every contraint graph node within the connected component. Thus every roadmap /// for every contraint graph state within the connected component. Thus every
/// node is assigned to a grahp node, which minimises computation time. /// roadmap node is assigned to a grahp state, which minimises computation time.
class HPP_MANIPULATION_DLLAPI ConnectedComponent : public core::ConnectedComponent class HPP_MANIPULATION_DLLAPI ConnectedComponent
{ : public core::ConnectedComponent {
public: public:
typedef std::vector<RoadmapNodePtr_t> RoadmapNodes_t; /// Map of graph states within the connected component
/// Map of graph nodes within the connected component typedef std::map<graph::StatePtr_t, RoadmapNodes_t> GraphStates_t;
typedef std::map <graph::NodePtr_t, RoadmapNodes_t> GraphNodes_t;
ConnectedComponent() {}
ConnectedComponent() {}
/// return a shared pointer to new instance of
/// return a shared pointer to new instance of manipulation::ConnectedComponent /// manipulation::ConnectedComponent
static ConnectedComponentPtr_t create (const RoadmapWkPtr_t& roadmap); static ConnectedComponentPtr_t create(const RoadmapWkPtr_t& roadmap);
/// Merge two connected components (extension of core::ConnectedComponent::merge) /// Merge two connected components (extension of
/// \param other manipulation connected component to merge into this one. /// core::ConnectedComponent::merge) \param other manipulation connected
/// \note other will be empty after calling this method. /// component to merge into this one. \note other will be empty after calling
void merge (const core::ConnectedComponentPtr_t& otherCC); /// this method.
void merge(const core::ConnectedComponentPtr_t& otherCC);
/// Add roadmap node to connected component
/// \param roadmap node to be added /// Add roadmap node to connected component
void addNode (const core::NodePtr_t& node); /// \param roadmap node to be added
void addNode(const core::NodePtr_t& node);
RoadmapNodes_t getRoadmapNodes (const graph::NodePtr_t graphNode);
const RoadmapNodes_t& getRoadmapNodes(
protected: const graph::StatePtr_t graphState) const;
private:
GraphNodes_t graphNodeMap_; protected:
RoadmapPtr_t roadmap_; private:
}; // class ConnectedComponent bool check() const;
} // namespace manipulation GraphStates_t graphStateMap_;
} // namespace hpp // a RoadmapWkPtr_t so that memory can be released ?
#endif // HPP_MANIPULATION_CONNECTED_COMPONENT_HH RoadmapWkPtr_t roadmap_;
static RoadmapNodes_t empty_;
HPP_SERIALIZABLE();
}; // class ConnectedComponent
} // namespace manipulation
} // namespace hpp
#endif // HPP_MANIPULATION_CONNECTED_COMPONENT_HH
include/hpp/manipulation/constraint-set.hh
View file @ 539aab52
// Copyright (c) 2015 CNRS // Copyright (c) 2015 CNRS
// Authors: Joseph Mirabel // Authors: Joseph Mirabel
// //
// This file is part of hpp-manipulation
// hpp-manipulation is free software: you can redistribute it // Redistribution and use in source and binary forms, with or without
// and/or modify it under the terms of the GNU Lesser General Public // modification, are permitted provided that the following conditions are
// License as published by the Free Software Foundation, either version // met:
// 3 of the License, or (at your option) any later version. //
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// //
// hpp-manipulation is distributed in the hope that it will be // 2. Redistributions in binary form must reproduce the above copyright
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty // notice, this list of conditions and the following disclaimer in the
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // documentation and/or other materials provided with the distribution.
// General Lesser Public License for more details. You should have //
// received a copy of the GNU Lesser General Public License along with // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// hpp-manipulation If not, see // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// <http://www.gnu.org/licenses/>. // 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_CONSTRAINT_SET_HH #ifndef HPP_MANIPULATION_CONSTRAINT_SET_HH
# define HPP_MANIPULATION_CONSTRAINT_SET_HH #define HPP_MANIPULATION_CONSTRAINT_SET_HH
# include <hpp/core/constraint-set.hh>
# include <hpp/manipulation/fwd.hh> #include <hpp/core/constraint-set.hh>
# include <hpp/manipulation/graph/fwd.hh> #include <hpp/manipulation/config.hh>
# include <hpp/manipulation/config.hh> #include <hpp/manipulation/fwd.hh>
#include <hpp/manipulation/graph/fwd.hh>
namespace hpp { namespace hpp {
namespace manipulation { namespace manipulation {
/// \addtogroup constraints /// \addtogroup constraints
/// \{ /// \{
/// a core::ConstraintSet remembering which edge created it
class HPP_MANIPULATION_DLLAPI ConstraintSet : public core::ConstraintSet {
public:
typedef core::ConstraintSet Parent_t;
/// Return shared pointer to new object
static ConstraintSetPtr_t create(const DevicePtr_t& robot,
const std::string& name);
/// Return shared pointer to new object
static ConstraintSetPtr_t createCopy(const ConstraintSetPtr_t& cs);
/// a core::ConstraintSet remembering which edge created it /// return shared pointer to copy
class HPP_MANIPULATION_DLLAPI ConstraintSet : public core::ConstraintSet virtual ConstraintPtr_t copy() const;
{
public:
typedef core::ConstraintSet Parent_t;
/// Return shared pointer to new object void edge(graph::EdgePtr_t edge);
static ConstraintSetPtr_t create (const DevicePtr_t& robot,
const std::string& name);
/// Return shared pointer to new object graph::EdgePtr_t edge() const;
static ConstraintSetPtr_t createCopy (const ConstraintSetPtr_t& cs);
/// return shared pointer to copy protected:
virtual ConstraintPtr_t copy () const; /// Constructor
ConstraintSet(const DevicePtr_t& robot, const std::string& name);
/// Copy constructor
ConstraintSet(const ConstraintSet& other);
/// Store weak pointer to itself.
void init(const ConstraintSetPtr_t& self);
void edge (graph::EdgePtr_t edge); virtual std::ostream& print(std::ostream& os) const;
graph::EdgePtr_t edge () const; private:
graph::EdgePtr_t edge_;
ConstraintSetWkPtr_t weak_;
protected: ConstraintSet() {}
/// Constructor HPP_SERIALIZABLE();
ConstraintSet (const DevicePtr_t& robot, const std::string& name); }; // class ConstraintSet
/// Copy constructor
ConstraintSet (const ConstraintSet& other);
/// Store weak pointer to itself.
void init (const ConstraintSetPtr_t& self);
virtual std::ostream& print (std::ostream& os) const; struct ConstraintAndComplement_t {
ImplicitPtr_t constraint;
ImplicitPtr_t complement;
ImplicitPtr_t both;
ConstraintAndComplement_t(const ImplicitPtr_t& constr,
const ImplicitPtr_t& comp, const ImplicitPtr_t& b)
: constraint(constr), complement(comp), both(b) {}
};
typedef std::vector<ConstraintAndComplement_t> ConstraintsAndComplements_t;
/// \}
} // namespace manipulation
} // namespace hpp
private: BOOST_CLASS_EXPORT_KEY(hpp::manipulation::ConstraintSet)
graph::EdgePtr_t edge_;
ConstraintSetWkPtr_t weak_;
}; // class ConstraintSet
/// \}
} // namespace manipulation
} // namespace hpp
#endif // HPP_MANIPULATION_CONSTRAINT_SET_HH #endif // HPP_MANIPULATION_CONSTRAINT_SET_HH