Commit eab392e3 authored by Florent Lamiraux's avatar Florent Lamiraux Committed by Florent Lamiraux florent@laas.fr
Browse files

Update to depencency of hpp to pinocchio.

parent 959ce26f
......@@ -78,8 +78,8 @@ pkg_list="$pkg_list $2"
# List packages.
JRL_GENERATELINK([HPPFCL], [hpp-fcl])
JRL_GENERATELINK([HPPUTIL], [hpp-util])
JRL_GENERATELINK([HPPMODEL], [hpp-model])
JRL_GENERATELINK([HPPMODELURDF], [hpp-model-urdf])
JRL_GENERATELINK([PINOCCHIO], [pinocchio])
JRL_GENERATELINK([HPPPINOCCHIO], [hpp-pinocchio])
JRL_GENERATELINK([HPPCORE], [hpp-core])
JRL_GENERATELINK([HPPCORBASERVER], [hpp-corbaserver])
JRL_GENERATELINK([HPPCONSTRAINTS], [hpp-constraints])
......
......@@ -7,8 +7,11 @@ FCL_REPO=https://github.com/flexible-collision-library
JRL_REPO=https://github.com/jrl-umi3218
LAAS_REPO=https://github.com/laas
HPP_REPO=https://github.com/humanoid-path-planner
SOT_REPO=https://github.com/stack-of-tasks
SRC_DIR=${DEVEL_DIR}/src
INSTALL_DIR=${DEVEL_DIR}/install
BUILD_TYPE=Debug
ifeq (${BUILD_TYPE},Debug)
BUILD_FOLDER=build
......@@ -16,8 +19,9 @@ else
BUILD_FOLDER=build-rel
endif
hpp-fcl_branch=master
hpp-fcl_branch=devel
hpp-fcl_repository=${HPP_REPO}
hpp-fcl_extra_flags= -DCMAKE_BUILD_TYPE=Release
hpp-util_branch=master
hpp-util_repository=${HPP_REPO}
......@@ -25,7 +29,14 @@ hpp-util_repository=${HPP_REPO}
hpp-model_branch=master
hpp-model_repository=${HPP_REPO}
hpp-model-urdf_branch=master
pinocchio_branch=master
pinocchio_repository=${SOT_REPO}
pinocchio_extra_flags= -DBUILD_PYTHON_INTERFACE=OFF
hpp-pinocchio_branch=master
hpp-pinocchio_repository=${HPP_REPO}
hpp-model-urdf_branch=xxx
hpp-model-urdf_repository=${HPP_REPO}
hpp-statistics_branch=master
......@@ -98,6 +109,9 @@ hpp_benchmark_repository=${HPP_REPO}
collada-dom_branch=master
collada-dom_repository=${HPP_REPO}
OpenSceneGraph-dae-plugin_branch=master
OpenSceneGraph-dae-plugin_repository=${HPP_REPO}
gepetto-viewer_branch=master
gepetto-viewer_repository=${HPP_REPO}
......@@ -116,7 +130,7 @@ hpp-environments_repository=${HPP_REPO}
hpp-baxter_branch=master
hpp-baxter_repository=${HPP_REPO}
OpenSceneGraph-3.4.0_extra_flags= -DDESIRED_QT_VERSION=4 -DCOLLADA_DYNAMIC_LIBRARY=${DEVEL_DIR}/install/lib/libcollada14dom.so -DCOLLADA_INCLUDE_DIR=${DEVEL_DIR}/install/include/collada-dom -DLIB_POSTFIX=""
OpenSceneGraph-dae-plugin_extra_flags= -DCOLLADA_DYNAMIC_LIBRARY=${INSTALL_DIR}/lib/libcollada14dom.so -DCOLLADA_INCLUDE_DIR=${INSTALL_DIR}/include/collada-dom
doxygen-Release_1_8_10_extra_flags= -DCMAKE_BUILD_TYPE=Release
......@@ -127,7 +141,7 @@ roboptim-trajectory-3.1_extra_flags= -DCMAKE_BUILD_TYPE=Release
qpOASES_extra_flags= -DCMAKE_BUILD_TYPE=Release
all: doxygen-Release_1_8_10.install hpp_tutorial.install \
hpp-gepetto-viewer.install hpp-manipulation-corba.install
hpp-manipulation-corba.install hpp-gepetto-viewer.install
${MAKE} hpp-doc.install
# source $DEVEL_DIR/install/setup.bash before installing hrp2.
......@@ -145,18 +159,22 @@ hpp-util.configure.dep: hpp-util.checkout
hpp-model.configure.dep: hpp-util.install hpp-fcl.install \
eigen3.install hpp-model.checkout
hpp-model-urdf.configure.dep: hpp-model.install hpp-model-urdf.checkout
pinocchio.configure.dep: eigen3.install hpp-fcl.install pinocchio.checkout
hpp-pinocchio.configure.dep: pinocchio.install hpp-util.install \
hpp-pinocchio.checkout
hpp-statistics.configure.dep: hpp-statistics.checkout
hpp-core.configure.dep: hpp-constraints.install hpp-statistics.install \
hpp-core.checkout
qpOASES.configure.dep: qpOASES.checkout
hpp-constraints.configure.dep: qpOASES.install hpp-model.install hpp-constraints.checkout
hpp-constraints.configure.dep: qpOASES.install \
hpp-pinocchio.install hpp-constraints.checkout
hpp-wholebody-step.configure.dep: hpp-constraints.install hpp-walkgen.install \
hpp-wholebody-step.checkout
hpp-manipulation.configure.dep: hpp-core.install hpp-constraints.install \
hpp-wholebody-step.install hpp-manipulation.checkout
hpp-manipulation-urdf.configure.dep:hpp-manipulation.install \
hpp-model-urdf.install hpp-manipulation-urdf.checkout
hpp-corbaserver.configure.dep: hpp-model-urdf.install hpp-core.install \
hpp-manipulation-urdf.checkout
hpp-corbaserver.configure.dep: hpp-core.install \
hpp-constraints.install hpp-corbaserver.checkout
hpp-wholebody-step-corba.configure.dep: hpp-corbaserver.install \
hpp-wholebody-step.install hpp-template-corba.install \
......@@ -179,9 +197,9 @@ hpp_tutorial.configure.dep: hpp-gepetto-viewer.install iai_maps.install \
hpp-corbaserver.install hpp_tutorial.checkout
hpp_benchmark.configure.dep: hpp_benchmark.checkout
collada-dom.configure.dep: collada-dom.checkout
OpenSceneGraph-3.4.0.configure.dep: collada-dom.install \
OpenSceneGraph-3.4.0.checkout
gepetto-viewer.configure.dep: OpenSceneGraph-3.4.0.install \
OpenSceneGraph-dae-plugin.configure.dep: collada-dom.install \
OpenSceneGraph-dae-plugin.checkout
gepetto-viewer.configure.dep: OpenSceneGraph-dae-plugin.install \
gepetto-viewer.checkout
gepetto-viewer-corba.configure.dep: gepetto-viewer.install \
gepetto-viewer-corba.checkout
......@@ -210,9 +228,9 @@ log:
done
update:
for d in hpp-util hpp-model hpp-model-urdf hpp-core hpp-template-corba hpp-corbaserver hpp-constraints hpp-wholebody-step hpp-wholebody-step-corba hpp-doc ; do \
for d in hpp-util hpp-pinocchio hpp-core hpp-template-corba hpp-corbaserver hpp-constraints hpp-wholebody-step hpp-wholebody-step-corba hpp-doc ; do \
echo "Updating $$d";\
make $$d.update; done
${MAKE} $$d.update; done
%.checkout:
if [ -d $(@:.checkout=) ]; then \
......@@ -232,22 +250,25 @@ update:
git branch -D bce46g;\
git submodule update
%.configure:%.configure.dep
mkdir -p ${SRC_DIR}/$(@:.configure=)/${BUILD_FOLDER}; \
cd ${SRC_DIR}/$(@:.configure=)/${BUILD_FOLDER}; \
cmake -DCMAKE_INSTALL_PREFIX=${DEVEL_DIR}/install -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DCMAKE_CXX_FLAGS_RELWITHDEBINFO="-g -O3 -DNDEBUG" ${$(@:.configure=)_extra_flags} ..
%.configure:%.configure.dep %.confthis
: # Do nothing else
%.confthis:%.checkout
mkdir -p ${SRC_DIR}/$(@:.confthis=)/${BUILD_FOLDER}; \
cd ${SRC_DIR}/$(@:.confthis=)/${BUILD_FOLDER}; \
cmake -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \ -DCMAKE_CXX_FLAGS_RELWITHDEBINFO="-g -O3 -DNDEBUG" ${$(@:.confthis=)_extra_flags} ..
%.install:%.configure
cd ${SRC_DIR}/$(@:.install=)/${BUILD_FOLDER};\
make install
${MAKE} -C ${SRC_DIR}/$(@:.install=)/${BUILD_FOLDER} install
%.instthis:%.confthis
${MAKE} -C ${SRC_DIR}/$(@:.instthis=)/${BUILD_FOLDER} install
%.uninstall:
cd ${SRC_DIR}/$(@:.uninstall=)/${BUILD_FOLDER};\
make uninstall
${MAKE} -C ${SRC_DIR}/$(@:.uninstall=)/${BUILD_FOLDER} uninstall
%.clean:
cd ${SRC_DIR}/$(@:.clean=)/${BUILD_FOLDER};\
make clean
${MAKE} -C ${SRC_DIR}/$(@:.clean=)/${BUILD_FOLDER} clean
%.very-clean:
rm -rf ${SRC_DIR}/$(@:.very-clean=)/${BUILD_FOLDER}/*
......@@ -268,7 +289,7 @@ hpp-doc.configure: hpp-doc.checkout
./bootstrap;\
mkdir -p ${BUILD_FOLDER}; \
cd ${SRC_DIR}/$(@:.configure=)/${BUILD_FOLDER}; \
../configure --prefix=${DEVEL_DIR}/install
../configure --prefix=${INSTALL_DIR}
eigen3.checkout:
if [ -d $(@:.checkout=) ]; then \
......@@ -282,7 +303,7 @@ eigen3.configure: eigen3.configure.dep
cd ${SRC_DIR}/eigen3;\
mkdir -p ${BUILD_FOLDER}; \
cd ${SRC_DIR}/eigen3/${BUILD_FOLDER}; \
cmake -DCMAKE_INSTALL_PREFIX=${DEVEL_DIR}/install -DCMAKE_INSTALL_LIBDIR=lib -Dpkg_config_libdir=${DEVEL_DIR}/install/lib ..
cmake -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} -DCMAKE_INSTALL_LIBDIR=lib -Dpkg_config_libdir=${INSTALL_DIR}/lib ..
roboptim-core-3.1.checkout:
if [ -d $(@:.checkout=) ]; then \
......@@ -306,37 +327,25 @@ doxygen-Release_1_8_10.checkout:
fi
hrp2.configure: hrp2.configure.dep
. ${DEVEL_DIR}/install/setup.sh; \
. ${INSTALL_DIR}/setup.sh; \
cd ${SRC_DIR}/hrp2/hrp2_14_description;\
mkdir -p ${BUILD_FOLDER}; \
cd ${SRC_DIR}/hrp2/hrp2_14_description/${BUILD_FOLDER}; \
cmake -DCMAKE_INSTALL_PREFIX=${DEVEL_DIR}/install -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_BUILD_TYPE=${BUILD_TYPE} ..
cmake -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_BUILD_TYPE=${BUILD_TYPE} ..
hrp2.install: hrp2.configure
cd ${SRC_DIR}/hrp2/hrp2_14_description/${BUILD_FOLDER};\
make install
${MAKE} -C ${SRC_DIR}/hrp2/hrp2_14_description/${BUILD_FOLDER} install
robot_model_py.configure: robot_model_py.configure.dep
cd ${SRC_DIR}/$(@:.configure=)/xml_reflection;\
mkdir -p ${BUILD_FOLDER}; \
cd ${BUILD_FOLDER}; \
cmake -DCMAKE_INSTALL_PREFIX=${DEVEL_DIR}/install -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_BUILD_TYPE=${BUILD_TYPE} ..
cmake -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_BUILD_TYPE=${BUILD_TYPE} ..
cd ${SRC_DIR}/$(@:.configure=)/urdf_parser_py;\
mkdir -p ${BUILD_FOLDER}; \
cd ${BUILD_FOLDER}; \
cmake -DCMAKE_INSTALL_PREFIX=${DEVEL_DIR}/install -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_BUILD_TYPE=${BUILD_TYPE} ..
cmake -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_BUILD_TYPE=${BUILD_TYPE} ..
robot_model_py.install: robot_model_py.configure
cd ${SRC_DIR}/$(@:.install=)/xml_reflection/${BUILD_FOLDER}; \
make install; \
cd ${SRC_DIR}/$(@:.install=)/urdf_parser_py/${BUILD_FOLDER}; \
make install;
OpenSceneGraph-3.4.0.checkout:
if [ -d $(@:.checkout=) ]; then \
echo "$(@:.checkout=) already checkout out."; \
else \
wget http://www.openscenegraph.org/downloads/stable_releases/OpenSceneGraph-3.4.0/source/OpenSceneGraph-3.4.0.zip;\
cd ${SRC_DIR}; unzip OpenSceneGraph-3.4.0.zip;\
rm -f OpenSceneGraph-3.4.0.zip;\
fi
${MAKE} -C ${SRC_DIR}/$(@:.install=)/xml_reflection/${BUILD_FOLDER} install; \
${MAKE} -C ${SRC_DIR}/$(@:.install=)/urdf_parser_py/${BUILD_FOLDER} install;
......@@ -33,18 +33,18 @@
</tr>
<tr>
<td>
<a href="@HPPMODEL_LINK@">hpp-model</a>
<a href="@PINOCCHIO_LINK@">pinocchio</a>
</td>
<td>implementation of kinematic chain with dynamic computations,</td>
</tr>
<tr>
<td>
<a href="@HPPMODELURDF_LINK@">hpp-model-urdf</a>
</td>
<td>construction of robots and objects by parsing urdf/srdf files,
</td>
</tr>
</table>
<tr>
<td>
<a href="@HPPPINOCCHIO_LINK@">hpp-pinocchio</a>
</td>
<td>Interface between pinocchio and hpp-core,
</td>
</tr>
</table>
<li><b>Non linear constraints</b></li>
<table class="pkglist">
......
How to install HPP
==================
Introduction
------------
*HPP* (Humanoid Path Planner) is composed of several software modules
packaged by autotools. These software modules are stored in a git
repositories on `git.laas.fr` (or `softs.laas.fr` for people working
at LAAS).
There are mainly two types of packages in HPP:
* packages under development that are not stable yet: each developer
needs to download his own version using git and commit his
modifications.
* packages that are more stable and for which versions have already
been released: these packages are automatically installed using a
tool called robotpkg.
Installation procedure
----------------------
Preliminary remarks
~~~~~~~~~~~~~~~~~~~
Environment variables
^^^^^^^^^^^^^^^^^^^^^
Along the installation procedure, some environment variables are
defined. It is recommended to include these definitions into an
initialization file like `.tcshrc` or `.bashrc` so that they will be
defined at each new session.
About KineoWorks
^^^^^^^^^^^^^^^^
To install KineoWorks, you will be asked for one archive:
* KPPSDK_x.yy.zzz.tgz and
You need to ask this archives to link:anthony.mallet@laas.fr[Anthony
Mallet].
Robotpkg
~~~~~~~~
The first step consists in installing robotpkg on your account. For
that, you need to create a directory where robotpkg will install all
necessary packages:
[source,shell]
[~] mkdir ${HOME}/openrobots
[~] cd ${HOME}/openrobots
Then download a working version of robotpkg:
[source,shell]
[openrobots] git-clone git+ssh://[git|softs].laas.fr/git/robots/robotpkg
Note that from now on, [git|softs] should be replaced by
* _softs_ if you are working on a LAAS account,
* _git_ if you are working from a distant site.
Set the following environment variable:
[source,shell]
[openrobots] setenv ROBOTPKG_BASE ${HOME}/openrobots
Install robotpkg:
[source,shell]
[openrobots] cd robotpkg
[robotpkg] ./bootstrap/bootstrap --prefix=${HOME}/openrobots
Then follow the instructions.
To install a package, go into
`${HOME}/openrobots/robotpkg/path-to-package` and type `make update`.
For instance:
[source,shell]
[robotpkg] cd path/hpp-core
[hpp-core] make update
All dependencies are automatically installed. For some packages, you
will need to follow instructions to accept license agreement. For
instance KineoWorks installation will output the following message:
[source,shell]
ERROR: kineo-pp-2.04.301r3 has an unacceptable license: kineocam-license.
ERROR: To view the license, enter "make show-license".
ERROR: To indicate acceptance, add this line to
ERROR: ${HOME}/openrobots/etc/robotpkg.conf:
ERROR: ACCEPTABLE_LICENSES+=kineocam-license
Follow the instruction and type again:
[source,shell]
[hpp-core] make update
Once modules managed by robotpkg have been installed, you can download
working versions of packages under development or create your own
package.
Packages under development or new packages
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
To download, compile and install packages not managed by robotpkg, or
packages that you want to modify or debug, create a development
directory as follows:
[source,shell]
[~] mkdir ${HOME}/devel
[~] cd ${HOME}/devel
[devel] mkdir src
[devel] cd src
Then download the packages you need:
[source,shell]
[src] git-clone git+ssh://[git|softs].laas.fr/git/jrl/name-of-package
Each package (managed by robotpkg or not) installs a file with
extension `.pc` in `prefix/lib/pkgconfig` where prefix is the
installation prefix of the package. This file stores information about
the package and its dependencies. This information is retrieved by
pkg-config executable. pkg-config searches for .pc files in paths
encoded in `PKG_CONFIG_PATH` environment variable. You need therefore
to set this variable correctly, for instance:
[source,shell]
[devel] setenv PKG_CONFIG_PATH ${HOME}/devel/lib/pkgconfig:${HOME}/openrobots/lib/pkgconfig:/usr/local/lib/pkgconfig
Compile and install the packages in your development directory:
[source,shell]
[src] cd package
[package] ./bootstrap (or ./autogen.sh)
[package] mkdir _build
[package] cd _build
[build] ../configure --prefix=${HOME}/devel
[build] make
[build] make install
Important installation rules
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
As explained above, releases of stable packages are installed by
robotpkg in `${HOME}/openrobots` prefix, while unstable packages are
installed by hand in ${HOME}/devel prefix.
It is very important that in the dependency tree, a package installed
by robotpkg never depends on a package installed by hand in
`${HOME}/devel` prefix. robotpkg indeed automatically installs
required dependencies and would be confused if the dependency of a
package it is trying to install was already installed in
`${HOME}/devel`.
You should therefore be very careful when switching a package from an
unstable version to a release. You should first uninstall the
dependencies of this package from `${HOME}/devel`:
[source,shell]
[~] cd ${HOME}/devel
[devel] rm -rf share/doc/package
[devel] rm -rf include/package
[devel] rm -f lib/libpackage*
[devel] rm -f lib/pkgconfig/package.pc
Configuring CORBA and using hppCorbaServer
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
hppCorbaServer is a package that enables developers to run their
algorithms from external application like python scripts for
instance. This package instanciates a 3 CORBA objects that can handle
requests trigerring actions in *HPP*. The CORBA objects correspond to
the following interfaces:
* ChppciRobot to define and build robots,
* ChppciObstacle to define obstacles,
* ChppciProblem to define and solve path planning problems. The
package also optionally implements an OpenHRP client (configuration
option --with-openhrp) that enables the user to download HRP2 model
by a Corba request.
hppCorbaServer is based on omniORB4 (installed by robotpkg), an
implementation of Corba. We will explain now how to configure
omniORB4 in order to be able:
* to load HRP2 model from OpenHRP
* to instanciate a Corba server to control your program.
The name server
^^^^^^^^^^^^^^^
Corba objects are defined by names. In order to communicate between
objects, Corba needs to map names with objects, that can run on
distant machines. This is the role of the name server. Before starting
launching Corba objects, you thus need to start a name server.
A name server is identified by the machine on which it runs and by a
port id on this machine. You thus need to choose a port id on your
machine. In order to avoid conflicts when several people work on the
same machine, we usually use as port id: `(user id + 1024)`. We
strongly recommend that you follow this procedure.
Type then
[source,shell]
[~] id -u
in a terminal and you get your user id on your machine. Add 1024 to
this number, you get your port id. Then create a directory to store
omniORB information
[source,shell]
[~] mkdir ${HOME}/omniORB
[~] cd ${HOME}/omniORB
In this directory, create a file omniORG.cfg and copy the following
line in this file:
[source,shell]
# Configuration file for omniOrb
InitRef = NameService=corbaloc:iiop:localhost:port-id/NameService
replacing port-id by your port id computed above.
File omniORG.cfg contains the address of the name server. The name server and each Corba object you launch thus needs to access to this file. For that, define the following environment variable:
[source,shell]
setenv OMNIORB_CONFIG ${HOME}/omniORB/omniORB.cfg
You need also to define a directory where log messages will be saved:
[source,shell]
setenv OMNINAMES_LOGDIR ${HOME}/omniORB/log
You can eventually launch the name server:
[source,shell]
omniNames -start port-id
the first time and
[source,shell]
omniNames
the following times.
Controlling an application using python scripts
To send request to hppCorbaServer using python, you need to install package
* hppPython through robotpkg.
[source,shell]
cd ${HOME}/openrobots/robotpkg/scripts/hpp-python
make update
hppPython installs a python script hppInit.py that initializes 3 CORBA
clients, one to each the 3 CORBA objects instanciated by
hppCorbaServer and described at the beginning of this section
(Configuring CORBA and using hppCorbaServer).
After installing hppPython, you need to reinstall this documentation
* either by doing `../configure --prefix=... ; make; make install`
in `hppDoc/build,`
* or by doing make update in `robotpkg/doc/hpp-doc`.
and to set environment variables. For that, follow this link.
Then open a python shell and call the initialization script
[source,shell]
[~] python
Python 2.4.3 (#1, Oct 23 2006, 14:19:47)
[GCC 4.1.1 20060525 (Red Hat 4.1.1-1)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from hppInit import *
>>>
Three variables robotClient, obstacleClient and problemClient are
defined and can be used to send requests to hppCorbaServer.
For an example, see `hppPython/src/example.py`.
Installing and running walk planner package and corresponding kpp Interface
---------------------------------------------------------------------------
Installing necessary packages
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Download, install robotpkg and type make update in
`graphics/kpp-interfacewalk` on a machine with a Kineo license.
Starting OpenHRP
~~~~~~~~~~~~~~~~
To download the model of HRP2, you need to launch OpenHRP.
Starting the name server
~~~~~~~~~~~~~~~~~~~~~~~~
The first step consists in starting the name server:
[source,shell]
[~] ${HOME}/openrobots/bin/omniNames -start port-id
where port-id is your port-id. If you run omniNames later, you will
not need to specify again the port id. Simply type:
[source,shell]
[~] ${HOME}/openrobots/bin/omniNames
Starting OpenHRP model loader
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Type
[source,shell]
[~] ${HOME}/openrobots/bin/Modelloader.sh
ready
Running KineoPathPlanner with kppInterfaceWalk module
You can now run KineoPathPlanner and load kppInterfaceWalk module:
[source,shell]
${HOME}/openrobots/bin/KineoPathPlanner -ModulePath ${HOME}/openrobots/lib/modules/${HOST}/libkppInterfaceWalk.so
where `${HOST}` is the name of your machine (or localhost.localdomain).
You should get the following interface:
.KineoPathPlanner with kppInterfaceWalk module
image:figures/kppInterfaceWalk.png[KineoPathPlanner with module
kppInterfaceWalk]
Defining and solving a problem using menu "HPP/WALK"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
To solve a simple problem without obstacles, do the following step:
* Click in menu "HPP/WALK -> Load HRP2"
* Click on button "Zoom All" and you should see the robot in a
bounding box.
* In the top left "Scene" tree, in the "Devices" node, select "Humanoid Box"
* Click in menu "Insert -> Path -> New"
* The background becomes grey. Move the box to the desired goal
configuration.
* Click on the button "Done" (top right panel). The background becomes
blue again.
* Click in menu "HPP/WALK -> Set Init and Goal Configs"
* Click in menu "HPP/WALK -> Solve Problem"
* In the "Scene" tree, in the "Paths" node, select the last path
* Play the path in the path player that has appeared.
Defining and solving a problem using python scripts
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Click in menu "HPP/WALK -> Start CORBA Server"
* Open a python interpreter and type the commands below.
[source,shell]
[~] python
Python 2.4.3 (#1, Oct 23 2006, 14:19:47)
[GCC 4.1.1 20060525 (Red Hat 4.1.1-1)] on linux2
Type "help", "copyright", "credits" or "license" for more information.