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
  • ostasse/dynamic-graph-python
  • gsaurel/dynamic-graph-python
  • stack-of-tasks/dynamic-graph-python
3 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 1161 additions and 898 deletions
src/dynamic-graph-py.cc deleted 100644 → 0
View file @ 68e09d67
// Copyright 2010, Florent Lamiraux, Thomas Moulard, LAAS-CNRS.
//
// This file is part of dynamic-graph-python.
// dynamic-graph-python 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.
//
// dynamic-graph-python 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 dynamic-graph. If not, see <http://www.gnu.org/licenses/>.
#include <Python.h>
#include <iostream>
#include <sstream>
#include <string>
#include <dynamic-graph/debug.h>
#include <dynamic-graph/exception-factory.h>
#include <dynamic-graph/signal-base.h>
#include "exception.hh"
namespace dynamicgraph {
namespace python {
// Declare functions defined in other source files
namespace signalBase {
extern PyObject* create(PyObject* self, PyObject* args);
extern PyObject* getTime(PyObject* self, PyObject* args);
extern PyObject* setTime(PyObject* self, PyObject* args);
extern PyObject* getName(PyObject* self, PyObject* args);
extern PyObject* getClassName(PyObject* self, PyObject* args);
extern PyObject* display(PyObject* self, PyObject* args);
extern PyObject* displayDependencies(PyObject* self, PyObject* args);
extern PyObject* getValue(PyObject* self, PyObject* args);
extern PyObject* setValue(PyObject* self, PyObject* args);
extern PyObject* recompute(PyObject* self, PyObject* args);
extern PyObject* unplug(PyObject* self, PyObject* args);
extern PyObject* isPlugged(PyObject* self, PyObject* args);
extern PyObject* getPlugged(PyObject* self, PyObject* args);
}
namespace entity {
extern PyObject* create(PyObject* self, PyObject* args);
extern PyObject* display(PyObject* self, PyObject* args);
extern PyObject* display(PyObject* self, PyObject* args);
extern PyObject* getName(PyObject* self, PyObject* args);
extern PyObject* hasSignal(PyObject* self, PyObject* args);
extern PyObject* getSignal(PyObject* self, PyObject* args);
extern PyObject* listSignals(PyObject* self, PyObject* args);
extern PyObject* executeCommand(PyObject* self, PyObject* args);
extern PyObject* listCommands(PyObject* self, PyObject* args);
extern PyObject* getCommandDocstring(PyObject* self, PyObject* args);
extern PyObject* getDocString(PyObject* self, PyObject* args);
}
namespace factory {
extern PyObject* getEntityClassList(PyObject* self, PyObject* args);
}
namespace signalCaster {
extern PyObject* getSignalTypeList(PyObject* self, PyObject* args);
}
namespace pool {
extern PyObject* writeGraph (PyObject* self, PyObject* args);
}
PyObject* dgpyError;
/**
\brief plug a signal into another one.
*/
PyObject*
plug(PyObject* /*self*/, PyObject* args)
{
PyObject* objOut = NULL;
PyObject* objIn = NULL;
void* pObjOut;
void* pObjIn;
if (!PyArg_ParseTuple(args,"OO", &objOut, &objIn))
return NULL;
if (!PyCObject_Check(objOut)) {
PyErr_SetString(PyExc_TypeError,
"first argument should be a pointer to"
" signalBase<int>.");
return NULL;
}
if (!PyCObject_Check(objIn)) {
PyErr_SetString(PyExc_TypeError,
"second argument should be a pointer to"
" signalBase<int>.");
return NULL;
}
pObjIn = PyCObject_AsVoidPtr(objIn);
SignalBase<int>* signalIn = (SignalBase<int>*)pObjIn;
pObjOut = PyCObject_AsVoidPtr(objOut);
SignalBase<int>* signalOut = (SignalBase<int>*)pObjOut;
std::ostringstream os;
try {
signalIn->plug(signalOut);
} CATCH_ALL_EXCEPTIONS();
return Py_BuildValue("");
}
PyObject*
enableTrace(PyObject* /*self*/, PyObject* args)
{
PyObject* boolean;
char* filename = NULL;
if (PyArg_ParseTuple(args,"Os", &boolean, &filename)) {
if (!PyBool_Check(boolean)) {
PyErr_SetString(PyExc_TypeError, "enableTrace takes as first "
"argument True or False,\n"" and as "
"second argument a filename.");
return NULL;
}
if (PyObject_IsTrue(boolean)) {
try {
DebugTrace::openFile(filename);
} CATCH_ALL_EXCEPTIONS();
} else {
try {
DebugTrace::closeFile(filename);
} CATCH_ALL_EXCEPTIONS();
}
} else {
return NULL;
}
return Py_BuildValue("");
}
}
}
/**
\brief List of python functions
*/
static PyMethodDef dynamicGraphMethods[] = {
{"w_plug", dynamicgraph::python::plug, METH_VARARGS,
"plug an output signal into an input signal"},
{"enableTrace", dynamicgraph::python::enableTrace, METH_VARARGS,
"Enable or disable tracing debug info in a file"},
// Signals
{"create_signal_base", dynamicgraph::python::signalBase::create, METH_VARARGS,
"create a SignalBase C++ object"},
{"signal_base_get_time", dynamicgraph::python::signalBase::getTime,
METH_VARARGS, "Get time of a SignalBase"},
{"signal_base_set_time", dynamicgraph::python::signalBase::setTime,
METH_VARARGS, "Set time of a SignalBase"},
{"signal_base_get_name", dynamicgraph::python::signalBase::getName,
METH_VARARGS, "Get the name of a signal"},
{"signal_base_get_class_name", dynamicgraph::python::signalBase::getClassName,
METH_VARARGS, "Get the class name of a signal"},
{"signal_base_display", dynamicgraph::python::signalBase::display,
METH_VARARGS, "Print the signal in a string"},
{"signal_base_display_dependencies", dynamicgraph::python::signalBase::displayDependencies,
METH_VARARGS, "Print the signal dependencies in a string"},
{"signal_base_get_value", dynamicgraph::python::signalBase::getValue,
METH_VARARGS, "Read the value of a signal"},
{"signal_base_set_value", dynamicgraph::python::signalBase::setValue,
METH_VARARGS, "Set the value of a signal"},
{"signal_base_recompute", dynamicgraph::python::signalBase::recompute,
METH_VARARGS, "Recompute the signal at given time"},
{"signal_base_unplug", dynamicgraph::python::signalBase::unplug,
METH_VARARGS, "Unplug the signal"},
{"signal_base_isPlugged", dynamicgraph::python::signalBase::isPlugged,
METH_VARARGS, "Whether the signal is plugged"},
{"signal_base_getPlugged", dynamicgraph::python::signalBase::getPlugged,
METH_VARARGS, "To which signal the signal is plugged"},
// Entity
{"create_entity", dynamicgraph::python::entity::create, METH_VARARGS,
"create an Entity C++ object"},
{"display_entity", dynamicgraph::python::entity::display, METH_VARARGS,
"print an Entity C++ object"},
{"entity_get_name", dynamicgraph::python::entity::getName, METH_VARARGS,
"get the name of an Entity"},
{"entity_has_signal", dynamicgraph::python::entity::hasSignal, METH_VARARGS,
"return True if the entity has a signal with the given name"},
{"entity_get_signal", dynamicgraph::python::entity::getSignal, METH_VARARGS,
"get signal by name from an Entity"},
{"entity_list_signals", dynamicgraph::python::entity::listSignals,
METH_VARARGS,
"Return the list of signals of an entity."},
{"entity_execute_command",
dynamicgraph::python::entity::executeCommand,
METH_VARARGS,
"execute a command"},
{"entity_list_commands",
dynamicgraph::python::entity::listCommands,
METH_VARARGS,
"list the commands of an entity"},
{"entity_get_command_docstring",
dynamicgraph::python::entity::getCommandDocstring,
METH_VARARGS,
"get the docstring of an entity command"},
{"entity_get_docstring",
dynamicgraph::python::entity::getDocString,
METH_VARARGS,
"get the doc string of an entity type"},
{"factory_get_entity_class_list",
dynamicgraph::python::factory::getEntityClassList,
METH_VARARGS,
"return the list of entity classes"},
{"signal_caster_get_type_list",
dynamicgraph::python::signalCaster::getSignalTypeList,
METH_VARARGS,
"return the list of signal type names"},
{"writeGraph",
dynamicgraph::python::pool::writeGraph,
METH_VARARGS,
"Write the graph of entities in a filename."},
{NULL, NULL, 0, NULL} /* Sentinel */
};
PyMODINIT_FUNC
initwrap(void)
{
PyObject *m;
m = Py_InitModule("wrap", dynamicGraphMethods);
if (m == NULL)
return;
std::string msg("dynamic_graph.error");
dynamicgraph::python::dgpyError =
PyErr_NewException(const_cast<char*>(msg.c_str()), NULL, NULL);
Py_INCREF(dynamicgraph::python::dgpyError);
PyModule_AddObject(m, "error", dynamicgraph::python::dgpyError);
}
src/dynamic_graph/CMakeLists.txt 0 → 100644
View file @ a76b5b78
# Copyright 2010-2021, Florent Lamiraux, Thomas Moulard, Olivier Stasse, Guilhem
# Saurel, JRL, CNRS/AIST, LAAS-CNRS
set(PYTHON_MODULE wrap)
add_library(
${PYTHON_MODULE} MODULE debug-py.cc dynamic-graph-py.cc factory-py.cc
pool-py.cc signal-base-py.cc signal-wrapper.cc)
target_link_libraries(${PYTHON_MODULE} PUBLIC ${PROJECT_NAME} eigenpy::eigenpy)
# Remove prefix lib
set_target_properties(${PYTHON_MODULE} PROPERTIES PREFIX "")
if(UNIX AND NOT APPLE)
set_target_properties(${PYTHON_MODULE} PROPERTIES INSTALL_RPATH
"\$ORIGIN/../../..")
endif()
install(
TARGETS ${PYTHON_MODULE}
EXPORT ${TARGETS_EXPORT_NAME}
DESTINATION ${PYTHON_SITELIB}/dynamic_graph)
src/dynamic_graph/__init__.py
View file @ a76b5b78
...@@ -3,20 +3,8 @@ Copyright (c) 2010 CNRS ...@@ -3,20 +3,8 @@ Copyright (c) 2010 CNRS
Author: Florent Lamiraux Author: Florent Lamiraux
""" """
import sys, DLFCN from __future__ import print_function
flags = sys.getdlopenflags()
# Import C++ symbols in a global scope
# This is necessary for signal compiled in different modules to be compatible
sys.setdlopenflags(DLFCN.RTLD_NOW|DLFCN.RTLD_GLOBAL)
from wrap import *
# Recover previous flags
sys.setdlopenflags(flags)
import entity, signal_base from . import entity # noqa
from . import signal_base # noqa
def plug (signalOut, signalIn) : from .wrap import * # noqa
"""
Plug an output signal into an input signal
"""
# get signals and entities
w_plug(signalOut.obj, signalIn.obj)
src/dynamic_graph/attrpath.py
View file @ a76b5b78
...@@ -9,6 +9,8 @@ ...@@ -9,6 +9,8 @@
# >>> e.a.b.c.d( ...) # >>> e.a.b.c.d( ...)
# as if it was a classical member function of e. # as if it was a classical member function of e.
from __future__ import print_function
class CommandPath(object): class CommandPath(object):
""" """
...@@ -16,95 +18,115 @@ class CommandPath(object): ...@@ -16,95 +18,115 @@ class CommandPath(object):
to store entity commands. It has no members except those automatically to store entity commands. It has no members except those automatically
defined at run time (which should be CommandPath or functions). defined at run time (which should be CommandPath or functions).
""" """
mother=None
def __getattr__(self,name): mother = None
privateName=name+'_obj'
def __getattr__(self, name):
privateName = name + "_obj"
if privateName in self.__dict__: if privateName in self.__dict__:
obj=getattr(self,privateName) obj = getattr(self, privateName)
obj.mother=self.mother obj.mother = self.mother
return obj return obj
return object.__getattr__(self,name) return object.__getattr__(self, name)
def createCommandModule( target,name ): def createCommandModule(target, name):
def createGetter( name ): def createGetter(name):
def __( self ): def __(self):
obj = getattr(self,name) obj = getattr(self, name)
obj.mother=self obj.mother = self
return obj return obj
return __ return __
privateName = name+'_obj' privateName = name + "_obj"
setattr( target,privateName, CommandPath() ) setattr(target, privateName, CommandPath())
module = getattr( target,privateName )
if not isinstance(target, CommandPath):
setattr(target, name, property(createGetter(privateName)))
if not isinstance(target,CommandPath) :
setattr( target,name, property(createGetter(privateName)) )
class CommandLauncher(object): class CommandLauncher(object):
""" """ """
"""
mother=None mother = None
fun=None fun = None
def __init__(self,fun): self.fun=fun
def __call__(self,*arg): def __init__(self, fun):
return self.fun(self.mother,*arg) self.fun = fun
def createCommandLauncher( target,name,fun ): def __call__(self, *arg):
if isinstance(target,CommandPath) : return self.fun(self.mother, *arg)
privateName = name+'_obj'
setattr( target,privateName, CommandLauncher(fun) )
def createCommandLauncher(target, name, fun):
if isinstance(target, CommandPath):
privateName = name + "_obj"
setattr(target, privateName, CommandLauncher(fun))
else: else:
setattr( target,name,fun ) setattr(target, name, fun)
def setattrpath( target,path,attribute ): def setattrpath(target, path, attribute):
""" """
Create in target an new attribute with value path (available at Create in target an new attribute with value path (available at
target.path1. ... .pathn). target.path1. ... .pathn).
""" """
pathk=target pathk = target
read=True read = True
if type(path)==type(str()): path=path.split('.') if isinstance(path, str):
path = path.split(".")
for tokenk in path[0:-1]: for tokenk in path[0:-1]:
if (not read) | (tokenk not in pathk.__dict__): if (not read) | (tokenk not in pathk.__dict__):
read=False read = False
createCommandModule(pathk,tokenk) createCommandModule(pathk, tokenk)
pathk = getattr(pathk,tokenk+"_obj") pathk = getattr(pathk, tokenk + "_obj")
if callable(attribute): if callable(attribute):
createCommandLauncher( pathk,path[-1],attribute ) createCommandLauncher(pathk, path[-1], attribute)
else: else:
print("Should not happen") print("Should not happen")
setattr(pathk,path[-1],attribute ) setattr(pathk, path[-1], attribute)
def getattrpath( target,path ): def getattrpath(target, path):
""" """
Get in target the value located at path (available at Get in target the value located at path (available at
target.path1. ... .pathn). target.path1. ... .pathn).
""" """
pathk=target pathk = target
if type(path)==type(str()): path=path.split('.') if isinstance(path, str):
path = path.split(".")
for tokenk in path: for tokenk in path:
privateName=tokenk+"_obj" privateName = tokenk + "_obj"
if (privateName in pathk.__dict__): pathk = getattr(pathk,privateName) if hasattr(pathk, privateName):
pathk = getattr(pathk, privateName)
else: else:
if ( tokenk in pathk.__dict__): pathk = getattr(pathk,tokenk) if hasattr(pathk, tokenk):
pathk = getattr(pathk, tokenk)
else: else:
raise Exception('Path does not exist -- while accessing "'+tokenk+'" in '+'.'.join(path)) raise Exception(
'Path does not exist -- while accessing "'
+ tokenk
+ '" in '
+ ".".join(path)
)
return pathk return pathk
def existattrpath( target,path ):
def existattrpath(target, path):
""" """
Check for the existence in target of a value located at path (available at Check for the existence in target of a value located at path (available at
target.path1. ... .pathn). target.path1. ... .pathn).
""" """
pathk=target pathk = target
if type(path)==type(str()): path=path.split('.') if isinstance(path, str):
path = path.split(".")
for tokenk in path[0:-1]: for tokenk in path[0:-1]:
print('check ',tokenk) print("check ", tokenk)
privateName=tokenk+"_obj" privateName = tokenk + "_obj"
if (privateName not in pathk.__dict__): if privateName not in pathk.__dict__:
return False return False
pathk = getattr(pathk,privateName) pathk = getattr(pathk, privateName)
name=path[-1] name = path[-1]
privateName=name+"_obj" privateName = name + "_obj"
return (name in pathk.__dict__)|(privateName in pathk.__dict__) return (name in pathk.__dict__) | (privateName in pathk.__dict__)
src/dynamic_graph/convert-dg-to-py.cc 0 → 100644
View file @ a76b5b78
// Copyright 2010, Florent Lamiraux, Thomas Moulard, LAAS-CNRS.
#include "dynamic-graph/python/convert-dg-to-py.hh"
#include <dynamic-graph/signal-base.h>
#include <dynamic-graph/signal-caster.h>
#include <dynamic-graph/signal.h>
#include <boost/python.hpp>
#include <boost/python/stl_iterator.hpp>
#include <iostream>
#include <sstream>
#include "dynamic-graph/python/python-compat.hh"
namespace dynamicgraph {
using ::dynamicgraph::SignalBase;
namespace python {
namespace convert {
namespace bp = boost::python;
command::Value toValue(bp::object o, const command::Value::Type& valueType) {
using command::Value;
switch (valueType) {
case (Value::BOOL):
return Value(bp::extract<bool>(o));
case (Value::UNSIGNED):
return Value(bp::extract<unsigned>(o));
case (Value::INT):
return Value(bp::extract<int>(o));
case (Value::FLOAT):
return Value(bp::extract<float>(o));
case (Value::DOUBLE):
return Value(bp::extract<double>(o));
case (Value::STRING):
return Value(bp::extract<std::string>(o));
case (Value::VECTOR):
// TODO for backward compatibility, support tuple or list ?
// I don't think so
return Value(bp::extract<Vector>(o));
case (Value::MATRIX):
// TODO for backward compatibility, support tuple or list ?
// I don't think so
return Value(bp::extract<Matrix>(o));
case (Value::MATRIX4D):
return Value(bp::extract<Eigen::Matrix4d>(o));
case (Value::VALUES):
// TODO the vector of values cannot be built since
// - the value type inside the vector are not know
// - inferring the value type from the Python type is not implemented.
throw std::invalid_argument(
"not implemented: cannot create a vector of values");
break;
default:
std::cerr << "Only int, double and string are supported." << std::endl;
}
return Value();
}
bp::object fromValue(const command::Value& value) {
using command::Value;
switch (value.type()) {
case (Value::BOOL):
return bp::object(value.boolValue());
case (Value::UNSIGNED):
return bp::object(value.unsignedValue());
case (Value::INT):
return bp::object(value.intValue());
case (Value::FLOAT):
return bp::object(value.floatValue());
case (Value::DOUBLE):
return bp::object(value.doubleValue());
case (Value::STRING):
return bp::object(value.stringValue());
case (Value::VECTOR):
return bp::object(value.vectorValue());
case (Value::MATRIX):
return bp::object(value.matrixXdValue());
case (Value::MATRIX4D):
return bp::object(value.matrix4dValue());
case (Value::VALUES): {
bp::list list;
for (const Value& v : value.constValuesValue()) list.append(fromValue(v));
return list;
}
case (Value::NONE):
default:
return bp::object();
}
}
} // namespace convert
} // namespace python
} // namespace dynamicgraph
src/dynamic_graph/debug-py.cc 0 → 100644
View file @ a76b5b78
// Copyright 2019, Olivier Stasse, LAAS-CNRS.
//
// See LICENSE
#include <iostream>
#define ENABLE_RT_LOG
#include <dynamic-graph/entity.h>
#include <dynamic-graph/pool.h>
#include <dynamic-graph/real-time-logger.h>
#include <boost/shared_ptr.hpp>
#include <map>
#include <vector>
#include "dynamic-graph/python/dynamic-graph-py.hh"
typedef boost::shared_ptr<std::ofstream> ofstreamShrPtr;
namespace dynamicgraph {
namespace python {
namespace debug {
std::map<std::string, ofstreamShrPtr> mapOfFiles_;
void addLoggerFileOutputStream(const char* filename) {
std::ofstream* aofs = new std::ofstream;
ofstreamShrPtr ofs_shrptr = boost::shared_ptr<std::ofstream>(aofs);
aofs->open(filename, std::ofstream::out);
dynamicgraph::RealTimeLogger::instance();
dgADD_OSTREAM_TO_RTLOG(*aofs);
dgRTLOG() << "Added " << filename << " as an output stream \n";
mapOfFiles_[filename] = ofs_shrptr;
}
void closeLoggerFileOutputStream() {
for (const auto& el : mapOfFiles_) el.second->close();
}
void addLoggerCoutOutputStream() { dgADD_OSTREAM_TO_RTLOG(std::cout); }
void realTimeLoggerDestroy() { RealTimeLogger::destroy(); }
void realTimeLoggerSpinOnce() { RealTimeLogger::instance().spinOnce(); }
void realTimeLoggerInstance() { RealTimeLogger::instance(); }
} // namespace debug
} // namespace python
} // namespace dynamicgraph
src/dynamic_graph/dynamic-graph-py.cc 0 → 100644
View file @ a76b5b78
// Copyright 2010, Florent Lamiraux, Thomas Moulard, LAAS-CNRS.
#include "dynamic-graph/python/dynamic-graph-py.hh"
#include <dynamic-graph/command.h>
#include <dynamic-graph/debug.h>
#include <dynamic-graph/entity.h>
#include <dynamic-graph/exception-factory.h>
#include <dynamic-graph/factory.h>
#include <dynamic-graph/pool.h>
#include <dynamic-graph/signal-base.h>
#include <dynamic-graph/signal-time-dependent.h>
#include <dynamic-graph/signal.h>
#include <dynamic-graph/tracer.h>
#include <Eigen/Geometry>
#include <boost/python.hpp>
#include <boost/python/raw_function.hpp>
#include <boost/python/suite/indexing/map_indexing_suite.hpp>
#include <eigenpy/eigenpy.hpp>
#include <eigenpy/geometry.hpp>
#include <iostream>
#include <sstream>
#include "dynamic-graph/python/convert-dg-to-py.hh"
#include "dynamic-graph/python/module.hh"
#include "dynamic-graph/python/signal-wrapper.hh"
namespace dynamicgraph {
namespace python {
/**
\brief plug a signal into another one.
*/
void plug(SignalBase<int>* signalOut, SignalBase<int>* signalIn) {
signalIn->plug(signalOut);
}
void enableTrace(bool enable, const char* filename) {
if (enable)
DebugTrace::openFile(filename);
else
DebugTrace::closeFile(filename);
}
} // namespace python
} // namespace dynamicgraph
namespace bp = boost::python;
namespace dg = dynamicgraph;
typedef bp::return_value_policy<bp::manage_new_object> manage_new_object;
typedef bp::return_value_policy<bp::reference_existing_object>
reference_existing_object;
typedef dg::PoolStorage::Entities MapOfEntities;
struct MapOfEntitiesPairToPythonConverter {
static PyObject* convert(const MapOfEntities::value_type& pair) {
return bp::incref(bp::make_tuple(pair.first, bp::ptr(pair.second)).ptr());
}
};
MapOfEntities* getEntityMap() {
return const_cast<MapOfEntities*>(
&dg::PoolStorage::getInstance()->getEntityMap());
}
dg::SignalBase<int>* getSignal(dg::Entity& e, const std::string& name) {
return &e.getSignal(name);
}
class PythonEntity : public dg::Entity {
DYNAMIC_GRAPH_ENTITY_DECL();
public:
using dg::Entity::Entity;
void signalRegistration(dg::SignalBase<int>& signal) {
dg::Entity::signalRegistration(signal);
}
void signalDeregistration(const std::string& name) {
dg::Entity::signalDeregistration(name);
}
};
DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(PythonEntity, "PythonEntity");
void exposeEntityBase() {
using namespace dynamicgraph;
bp::enum_<LoggerVerbosity>("LoggerVerbosity")
.value("VERBOSITY_ALL", VERBOSITY_ALL)
.value("VERBOSITY_INFO_WARNING_ERROR", VERBOSITY_INFO_WARNING_ERROR)
.value("VERBOSITY_WARNING_ERROR", VERBOSITY_WARNING_ERROR)
.value("VERBOSITY_ERROR", VERBOSITY_ERROR)
.value("VERBOSITY_NONE", VERBOSITY_NONE)
.export_values();
bp::class_<Entity, boost::noncopyable>("Entity", bp::no_init)
.add_property("name",
bp::make_function(
&Entity::getName,
bp::return_value_policy<bp::copy_const_reference>()))
.add_property("className",
bp::make_function(
&Entity::getClassName,
bp::return_value_policy<bp::copy_const_reference>()),
"the class name of the Entity")
.add_property("__doc__", &Entity::getDocString)
.def("setLoggerVerbosityLevel", &Entity::setLoggerVerbosityLevel)
.def("getLoggerVerbosityLevel", &Entity::getLoggerVerbosityLevel)
.add_property("loggerVerbosityLevel", &Entity::setLoggerVerbosityLevel,
&Entity::getLoggerVerbosityLevel,
"the verbosity level of the entity")
.def("setTimeSample", &Entity::setTimeSample)
.def("getTimeSample", &Entity::getTimeSample)
.add_property("timeSample", &Entity::getTimeSample,
&Entity::setTimeSample,
"the time sample for printing debugging information")
.def("setStreamPrintPeriod", &Entity::setStreamPrintPeriod)
.def("getStreamPrintPeriod", &Entity::getStreamPrintPeriod)
.add_property("streamPrintPeriod", &Entity::getStreamPrintPeriod,
&Entity::setStreamPrintPeriod,
"set the period at which debugging information are printed")
.def(
"__str__",
+[](const Entity& e) -> std::string {
std::ostringstream os;
e.display(os);
return os.str();
})
.def(
"signals",
+[](const Entity& e) -> bp::list {
bp::list ret;
for (auto& el : e.getSignalMap()) ret.append(bp::ptr(el.second));
return ret;
},
"Return the list of signals.")
//.def("signal", +[](Entity& e, const std::string &name) { return
//&e.getSignal(name); },
// reference_existing_object())
.def("signal", &getSignal, reference_existing_object(),
"get signal by name from an Entity", bp::arg("name"))
.def("hasSignal", &Entity::hasSignal,
"return True if the entity has a signal with the given name")
.def(
"displaySignals",
+[](const Entity& e) {
Entity::SignalMap signals(e.getSignalMap());
std::cout << "--- <" << e.getName();
if (signals.empty())
std::cout << "> has no signal\n";
else
std::cout << "> signal list:\n";
for (const auto& el : signals)
el.second->display(std::cout << " |-- <") << '\n';
},
"Print the list of signals into standard output: temporary.")
/*
.def("__getattr__", +[](Entity& e, const std::string &name) ->
SignalBase<int>* { return &e.getSignal(name); },
reference_existing_object())
def __getattr__(self, name):
try:
return self.signal(name)
except Exception:
try:
object.__getattr__(self, name)
except AttributeError:
raise AttributeError("'%s' entity has no attribute %s\n" %
(self.name, name) + ' entity attributes are usually either\n' + ' -
commands,\n' + ' - signals or,\n' + ' - user defined attributes')
*/
/*
.def("__setattr__", +[](bp::object self, const std::string &name,
bp::object value) { Entity& e = bp::extract<Entity&> (self); if
(e.hasSignal(name)) throw std::invalid_argument(name + " already
designates a signal. " "It is not advised to set a new attribute of the
same name.");
// TODO How do you do that ? I am sure it is possible.
//object.__setattr__(self, name, value)
})
*/
/* TODO ?
def boundNewCommand(self, cmdName):
"""
At construction, all existing commands are bound directly in the
class. This method enables to bound new commands dynamically. These new
bounds are not made with the class, but directly with the object instance.
"""
def boundAllNewCommands(self):
"""
For all commands that are not attribute of the object instance nor of
the class, a new attribute of the instance is created to bound the
command.
"""
*/
// For backward compat
.add_static_property(
"entities",
bp::make_function(&getEntityMap, reference_existing_object()));
python::exposeEntity<PythonEntity, bp::bases<Entity>, 0>()
.def("signalRegistration", &PythonEntity::signalRegistration)
.def("signalDeregistration", &PythonEntity::signalDeregistration);
python::exposeEntity<python::PythonSignalContainer, bp::bases<Entity>, 0>()
.def("rmSignal", &python::PythonSignalContainer::rmSignal,
"Remove a signal", bp::arg("signal_name"));
}
void exposeCommand() {
using dg::command::Command;
bp::class_<Command, boost::noncopyable>("Command", bp::no_init)
.def("__call__", bp::raw_function(dg::python::entity::executeCmd, 1),
"execute the command")
.add_property("__doc__", &Command::getDocstring);
}
void exposeOldAPI() {
bp::def("plug", dynamicgraph::python::plug,
"plug an output signal into an input signal",
(bp::arg("signalOut"), "signalIn"));
bp::def("enableTrace", dynamicgraph::python::enableTrace,
"Enable or disable tracing debug info in a file");
// Signals
bp::def("create_signal_wrapper",
dynamicgraph::python::signalBase::createSignalWrapper,
reference_existing_object(), "create a SignalWrapper C++ object");
// Entity
bp::def("factory_get_entity_class_list",
dynamicgraph::python::factory::getEntityClassList,
"return the list of entity classes");
bp::def("writeGraph", dynamicgraph::python::pool::writeGraph,
"Write the graph of entities in a filename.");
bp::def("get_entity_list", dynamicgraph::python::pool::getEntityList,
"return the list of instanciated entities");
bp::def("addLoggerFileOutputStream",
dynamicgraph::python::debug::addLoggerFileOutputStream,
"add a output file stream to the logger by filename");
bp::def("addLoggerCoutOutputStream",
dynamicgraph::python::debug::addLoggerCoutOutputStream,
"add std::cout as output stream to the logger");
bp::def("closeLoggerFileOutputStream",
dynamicgraph::python::debug::closeLoggerFileOutputStream,
"close all the loggers file output streams.");
bp::def("real_time_logger_destroy",
dynamicgraph::python::debug::realTimeLoggerDestroy,
"Destroy the real time logger.");
bp::def("real_time_logger_spin_once",
dynamicgraph::python::debug::realTimeLoggerSpinOnce,
"Destroy the real time logger.");
bp::def("real_time_logger_instance",
dynamicgraph::python::debug::realTimeLoggerInstance,
"Starts the real time logger.");
}
void enableEigenPy() {
eigenpy::enableEigenPy();
if (!eigenpy::register_symbolic_link_to_registered_type<Eigen::Quaterniond>())
eigenpy::exposeQuaternion();
if (!eigenpy::register_symbolic_link_to_registered_type<Eigen::AngleAxisd>())
eigenpy::exposeAngleAxis();
eigenpy::enableEigenPySpecific<Eigen::Matrix4d>();
}
BOOST_PYTHON_MODULE(wrap) {
enableEigenPy();
exposeOldAPI();
dg::python::exposeSignals();
exposeEntityBase();
exposeCommand();
typedef dg::PoolStorage::Entities MapOfEntities;
bp::class_<MapOfEntities>("MapOfEntities")
.def("__len__", &MapOfEntities::size)
.def(
"keys",
+[](const MapOfEntities& m) -> bp::tuple {
bp::list res;
for (const auto& el : m) res.append(el.first);
return bp::tuple(res);
})
.def(
"values",
+[](const MapOfEntities& m) -> bp::tuple {
bp::list res;
for (const auto& el : m) res.append(bp::ptr(el.second));
return bp::tuple(res);
})
.def("__getitem__",
static_cast<dg::Entity*& (MapOfEntities::*)(const std::string& k)>(
&MapOfEntities::at),
reference_existing_object())
.def(
"__setitem__", +[](MapOfEntities& m, const std::string& n,
dg::Entity* e) { m.emplace(n, e); })
.def("__iter__", bp::iterator<MapOfEntities>())
.def(
"__contains__",
+[](const MapOfEntities& m, const std::string& n) -> bool {
return m.count(n);
});
bp::to_python_converter<MapOfEntities::value_type,
MapOfEntitiesPairToPythonConverter>();
}
src/dynamic_graph/entity-py.cc 0 → 100644
View file @ a76b5b78
// Copyright 2010, Florent Lamiraux, Thomas Moulard, LAAS-CNRS.
#include <dynamic-graph/command.h>
#include <dynamic-graph/entity.h>
#include <dynamic-graph/factory.h>
#include <dynamic-graph/linear-algebra.h>
#include <dynamic-graph/pool.h>
#include <dynamic-graph/value.h>
#include <iostream>
#include "dynamic-graph/python/convert-dg-to-py.hh"
#include "dynamic-graph/python/dynamic-graph-py.hh"
// Ignore "dereferencing type-punned pointer will break strict-aliasing rules"
// warnings on gcc caused by Py_RETURN_TRUE and Py_RETURN_FALSE.
#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif
namespace bp = boost::python;
using dynamicgraph::Entity;
using dynamicgraph::Matrix;
using dynamicgraph::SignalBase;
using dynamicgraph::Vector;
using dynamicgraph::command::Command;
using dynamicgraph::command::Value;
namespace dynamicgraph {
namespace python {
using namespace convert;
namespace entity {
/// \param obj an Entity object
void addCommands(bp::object obj) {
Entity& entity = bp::extract<Entity&>(obj);
for (const auto& el : entity.getNewStyleCommandMap())
obj.attr(el.first.c_str()) = bp::object(bp::ptr(el.second));
}
/// \param obj an Entity object
void addSignals(bp::object obj) {
Entity& entity = bp::extract<Entity&>(obj);
for (const auto& el : entity.getSignalMap())
// obj.attr(el.first.c_str()) = bp::make_function(
//+[&entity,el]() { return &entity.getSignal(el.first); },
// bp::return_value_policy<bp::reference_existing_object>());
obj.attr(el.first.c_str()) = bp::object(bp::ptr(el.second));
}
/**
\brief Create an instance of Entity
*/
Entity* create(const char* className, const char* instanceName) {
Entity* obj = NULL;
/* Try to find if the corresponding object already exists. */
if (dynamicgraph::PoolStorage::getInstance()->existEntity(instanceName,
obj)) {
if (obj->getClassName() != className) {
throw std::invalid_argument("Found an object named " +
std::string(instanceName) +
",\n"
"but this object is of type " +
std::string(obj->getClassName()) +
" and not " + std::string(className));
}
} else /* If not, create a new object. */
{
obj = dynamicgraph::FactoryStorage::getInstance()->newEntity(
std::string(className), std::string(instanceName));
}
return obj;
}
bp::object executeCmd(bp::tuple args, bp::dict) {
Command& command = bp::template extract<Command&>(args[0]);
if (bp::len(args) != int(command.valueTypes().size() + 1))
// TODO Put expected and given number of args
throw std::out_of_range("Wrong number of arguments");
std::vector<Value> values;
values.reserve(command.valueTypes().size());
for (int i = 1; i < bp::len(args); ++i)
values.push_back(convert::toValue(args[i], command.valueTypes()[i - 1]));
command.setParameterValues(values);
return convert::fromValue(command.execute());
}
} // namespace entity
} // namespace python
} // namespace dynamicgraph
src/dynamic_graph/entity.py
View file @ a76b5b78
""" # Copyright (C) 2020 CNRS
Copyright (C) 2010 CNRS #
# Author: Florent Lamiraux, Nicolas Mansard
Author: Florent Lamiraux, Nicolas Mansard from __future__ import print_function
"""
import wrap, signal_base, new
from attrpath import setattrpath
if 'display' not in globals().keys(): # for backward compat
def display(s): from .wrap import LoggerVerbosity as VerbosityLevel # noqa
print(s) from .wrap import Entity # noqa
# --- FACTORY ------------------------------------------------------------------
# --- FACTORY ------------------------------------------------------------------
# --- FACTORY ------------------------------------------------------------------
class PyEntityFactoryClass(type):
"""
The class build dynamically a new class type, and return the reference
on the class-type object. The class type is not added to any context.
"""
def __new__(factory, className,bases=(), dict={} ):
if len(bases)==0:
# Initialize a basic Entity class
EntityClass = type.__new__(factory, className, (Entity,), dict)
EntityClass.className = className
EntityClass.__init__ = Entity.initEntity
else:
# Initialize a heritated class
EntityClass = type.__new__(factory, className, bases, dict)
for c in bases:
if issubclass(c,Entity):
EntityClass.className = c.className
break
EntityClass.commandCreated = False
return EntityClass
def PyEntityFactory( className, context ):
"""
Build a new class type by calling the factory, and add it
to the given context.
"""
EntityClass = PyEntityFactoryClass( className )
context[ className ] = EntityClass
return EntityClass
def updateEntityClasses(dictionary):
"""
For all c++entity types that are not in the pyentity class list
(entityClassNameList) run the factory and store the new type in the given
context (dictionary).
"""
cxx_entityList = wrap.factory_get_entity_class_list()
for e in filter(lambda x: not x in Entity.entityClassNameList, cxx_entityList):
# Store new class in dictionary with class name
PyEntityFactory( e,dictionary )
# Store class name in local list
Entity.entityClassNameList.append(e)
# --- ENTITY -------------------------------------------------------------------
# --- ENTITY -------------------------------------------------------------------
# --- ENTITY -------------------------------------------------------------------
class Entity (object) :
"""
This class binds dynamicgraph::Entity C++ class
"""
obj = None
"""
Store list of entities created via python
"""
entities = dict ()
def __init__(self, className, instanceName):
"""
Constructor: if not called by a child class, create and store a pointer
to a C++ Entity object.
"""
object.__setattr__(self, 'obj', wrap.create_entity(className, instanceName) )
Entity.entities [instanceName] = self
@staticmethod
def initEntity(self, name):
"""
Common constructor of specialized Entity classes. This function is bound
by the factory to each new class derivated from the Entity class as the
constructor of the new class.
"""
Entity.__init__(self, self.className, name)
if not self.__class__.commandCreated:
self.boundClassCommands()
self.__class__.__doc__ = wrap.entity_get_docstring (self.obj)
self.__class__.commandCreated = True
@property
def name(self) :
return wrap.entity_get_name(self.obj)
def __str__(self) :
return wrap.display_entity(self.obj)
def signal (self, name) :
"""
Get a signal of the entity from signal name
"""
signalPt = wrap.entity_get_signal(self.obj, name)
return signal_base.SignalBase(name = "", obj = signalPt)
def hasSignal(self, name) :
"""
Indicates if a signal with the given name exists in the entity
"""
return wrap.entity_has_signal(self.obj, name)
def displaySignals(self) :
"""
Print the list of signals into standard output: temporary.
"""
signals = self.signals()
if len(signals) == 0:
display ("--- <" + self.name + "> has no signal")
else:
display ("--- <" + self.name + "> signal list: ")
for s in signals[:-1]:
display(" |-- <" + str(s))
display(" `-- <" + str(signals[-1]))
def signals(self) :
"""
Return the list of signals
"""
sl = wrap.entity_list_signals(self.obj)
return map(lambda pyObj: signal_base.SignalBase(obj=pyObj), sl)
def commands(self):
"""
Return the list of commands.
"""
return wrap.entity_list_commands(self.obj)
def globalHelp(self):
"""
Print a short description of each command.
"""
if self.__doc__ :
print self.__doc__
print "List of commands:"
print "-----------------"
for cstr in self.commands():
ctitle=cstr+':'
for i in range(len(cstr),15):
ctitle+=' '
for docstr in wrap.entity_get_command_docstring(self.obj,cstr).split('\n'):
if (len(docstr)>0) and (not docstr.isspace()):
display(ctitle+"\t"+docstr)
break
def help( self,comm=None ):
"""
With no arg, print the global help. With arg the name of
a specific command, print the help associated to the command.
"""
if comm is None:
self.globalHelp()
else:
display(comm+":\n"+wrap.entity_get_command_docstring(self.obj,comm))
def __getattr__(self, name):
try:
return self.signal(name)
except:
try:
object.__getattr__(self, name)
except AttributeError:
raise AttributeError("'%s' entity has no attribute %s\n"%
(self.name, name)+
' entity attributes are usually either\n'+
' - commands,\n'+
' - signals or,\n'+
' - user defined attributes')
def __setattr__(self, name, value):
if name in map(lambda s: s.getName().split(':')[-1],self.signals()):
raise NameError(name+" already designates a signal. "
"It is not advised to set a new attribute of the same name.")
object.__setattr__(self, name, value)
# --- COMMANDS BINDER -----------------------------------------------------
# List of all the entity classes from the c++ factory, that have been bound
# bind the py factory.
entityClassNameList = []
# This function dynamically create the function object that runs the command.
@staticmethod
def createCommandBind(name, docstring) :
def commandBind(self, *arg):
return wrap.entity_execute_command(self.obj, name, arg)
commandBind.__doc__ = docstring
return commandBind
def boundClassCommands(self):
"""
This static function has to be called from a class heritating from Entity.
It should be called only once. It parses the list of commands obtained from
c++, and bind each of them to a python class method.
"""
# Get list of commands of the Entity object
commands = wrap.entity_list_commands(self.obj)
# for each command, add a method with the name of the command
for cmdstr in commands:
docstr = wrap.entity_get_command_docstring(self.obj, cmdstr)
cmdpy = Entity.createCommandBind(cmdstr, docstr)
setattrpath(self.__class__, cmdstr, cmdpy)
def boundNewCommand(self,cmdName):
"""
At construction, all existing commands are bound directly in the class.
This method enables to bound new commands dynamically. These new bounds
are not made with the class, but directly with the object instance.
"""
if (cmdName in self.__dict__) | (cmdName in self.__class__.__dict__):
print("Warning: command ",cmdName," will overwrite an object attribute.")
docstring = wrap.entity_get_command_docstring(self.obj, cmdName)
cmd = Entity.createCommandBind(cmdName,docstring)
# Limitation (todo): does not handle for path attribute name (see setattrpath).
setattr(self,cmdName,new.instancemethod( cmd, self,self.__class__))
def boundAllNewCommands(self):
"""
For all commands that are not attribute of the object instance nor of the
class, a new attribute of the instance is created to bound the command.
"""
cmdList = wrap.entity_list_commands(self.obj)
cmdList = filter(lambda x: not x in self.__dict__, cmdList)
cmdList = filter(lambda x: not x in self.__class__.__dict__, cmdList)
for cmd in cmdList:
self.boundNewCommand( cmd )
src/dynamic_graph/factory-py.cc 0 → 100644
View file @ a76b5b78
// Copyright 2010, Florent Lamiraux, Thomas Moulard, LAAS-CNRS.
#include <dynamic-graph/factory.h>
#include <iostream>
#include "dynamic-graph/python/dynamic-graph-py.hh"
using dynamicgraph::Entity;
using dynamicgraph::ExceptionAbstract;
namespace dynamicgraph {
namespace python {
namespace factory {
/**
\brief Get name of entity
*/
bp::tuple getEntityClassList() {
std::vector<std::string> classNames;
dynamicgraph::FactoryStorage::getInstance()->listEntities(classNames);
return to_py_tuple(classNames.begin(), classNames.end());
}
} // namespace factory
} // namespace python
} // namespace dynamicgraph
src/dynamic_graph/matlab.py deleted 100644 → 0
View file @ 68e09d67
# The matlab class is define to produce a nice rendering of vector and matrix
# signals. The class builds at construction a string from the display
# of the matrix/vector, and stores the string internally. The string can be recovered
# using the str() member.
# The statics prec, space and fullPrec can be used to modify the display.
def pseudozero(prec):
"""
Return a string with '0...' and enough space to fill prec cars.
"""
res='0...'
for i in range(2,prec):
res+=' '
return res
class matlab:
prec=12
space=2
fullPrec=1e-5
def __init__( self,obj ):
try:
return self.matlabFromMatrix(obj)
except:
pass
try:
return self.matlabFromVector(obj)
except:
pass
self.resstr = str(obj)
def __str__(self):
return self.resstr
def matlabFromMatrix(self,A):
nr=len(A)
nc=len(A[0]);
fm='%.'+str(self.prec)+'f'
maxstr=0
mstr=(())
for v in A:
lnstr=()
for x in v:
if (abs(x)<self.fullPrec*self.fullPrec):
curr='0'
else:
if (abs(x)<self.fullPrec):
curr=pseudozero(self.prec)
else:
curr= ' '+(fm % x)
if( maxstr<len(curr)):
maxstr=len(curr)
lnstr+=(curr,)
mstr+=(lnstr,)
maxstr+=self.space
resstr='[...\n'
first=True
for v in mstr:
if first:
first=False;
else:
resstr+=' ;\n'
firstC=True
for x in v:
if firstC:
firstC=False
else:
resstr+=','
for i in range(1,maxstr-len(x)):
resstr+=' '
resstr+=x
resstr+=' ];'
self.resstr = resstr
def matlabFromVector(self,v):
nr=len(v)
fm='%.'+str(self.prec)+'f'
maxstr=0
vstr=(())
for x in v:
if (abs(x)<self.fullPrec*self.fullPrec):
curr='0'
else:
if (abs(x)<self.fullPrec):
curr=pseudozero(self.prec)
else:
curr= ' '+(fm % x)
if( maxstr<len(curr)):
maxstr=len(curr)
vstr+=(curr,)
maxstr+=self.space
resstr='[ '
first=True
for x in vstr:
if first:
first=False;
else:
resstr+=','
for i in range(1,maxstr-len(x)):
resstr+=' '
resstr+=x
resstr+=' ]\';'
self.resstr = resstr
src/dynamic_graph/pool-py.cc 0 → 100644
View file @ a76b5b78
// Copyright 2011, 2012, Florent Lamiraux, LAAS-CNRS.
#include <dynamic-graph/entity.h>
#include <dynamic-graph/pool.h>
#include <vector>
#include "dynamic-graph/python/dynamic-graph-py.hh"
namespace dynamicgraph {
namespace python {
namespace pool {
void writeGraph(const char* filename) {
PoolStorage::getInstance()->writeGraph(filename);
}
const std::map<std::string, Entity*>* getEntityMap() {
return &PoolStorage::getInstance()->getEntityMap();
}
/**
\brief Get list of entities
*/
bp::list getEntityList() {
std::vector<std::string> entityNames;
bp::list res;
const PoolStorage::Entities& listOfEntities =
PoolStorage::getInstance()->getEntityMap();
for (const auto& el : listOfEntities) res.append(el.second->getName());
return res;
}
} // namespace pool
} // namespace python
} // namespace dynamicgraph
src/dynamic_graph/python-compat.cc 0 → 100644
View file @ a76b5b78
#include "dynamic-graph/python/python-compat.hh"
// Get any PyObject and get its str() representation as an std::string
std::string obj_to_str(PyObject* o) {
std::string ret;
PyObject* os;
#if PY_MAJOR_VERSION >= 3
os = PyObject_Str(o);
assert(os != NULL);
assert(PyUnicode_Check(os));
ret = PyUnicode_AsUTF8(os);
#else
os = PyObject_Unicode(o);
assert(os != NULL);
assert(PyUnicode_Check(os));
PyObject* oss = PyUnicode_AsUTF8String(os);
assert(oss != NULL);
ret = PyString_AsString(oss);
Py_DECREF(oss);
#endif
Py_DECREF(os);
return ret;
}
src/dynamic_graph/script_shortcuts.py
View file @ a76b5b78
...@@ -8,17 +8,22 @@ ...@@ -8,17 +8,22 @@
# entity -> same as print(entity) # entity -> same as print(entity)
# change the prompt to be '%' # change the prompt to be '%'
from __future__ import print_function
# Changing prompt
import sys
from .entity import Entity
from .signal_base import SignalBase
from dynamic_graph.signal_base import *
from dynamic_graph.entity import *
from matlab import matlab
# Enables shortcut "name" # Enables shortcut "name"
def sig_short_name(self): def sig_short_name(self):
return self.getName().split(':')[-1] return self.getName().split(":")[-1]
setattr(SignalBase, "name", property(sig_short_name))
setattr(SignalBase,'name',property(sig_short_name))
# Enables shortcuts "m" # Enables shortcuts "m"
# This code implements a pseudo function 'm' in the class signal_base, # This code implements a pseudo function 'm' in the class signal_base,
...@@ -28,40 +33,51 @@ setattr(SignalBase,'name',property(sig_short_name)) ...@@ -28,40 +33,51 @@ setattr(SignalBase,'name',property(sig_short_name))
# - sig.m +time: recompute at <time> after current time, and display. # - sig.m +time: recompute at <time> after current time, and display.
class PrettySignalPrint: class PrettySignalPrint:
sig = None sig = None
def __init__(self,sig):
def __init__(self, sig):
self.sig = sig self.sig = sig
def __str__(self): def __str__(self):
return self.sig.name+" = "+str(matlab(self.sig.value)) return self.sig.name + " = " + str(self.sig.value)
def __repr__(self): def __repr__(self):
return str(self) return str(self)
def __call__(self,iter):
def __call__(self, iter):
self.sig.recompute(iter) self.sig.recompute(iter)
return self return self
def __add__(self,iter):
self.sig.recompute( self.sig.time+iter ) def __add__(self, iter):
self.sig.recompute(self.sig.time + iter)
return self return self
def sigMatPrint(sig): def sigMatPrint(sig):
return PrettySignalPrint(sig) return PrettySignalPrint(sig)
setattr(SignalBase,'m',property(PrettySignalPrint))
#print('Pretty matlab print set') setattr(SignalBase, "m", property(PrettySignalPrint))
# Enable the same as 'm', but directly on the signal object. # Enable the same as 'm', but directly on the signal object.
def sigRepr( self ): def sigRepr(self):
return self.name+' = '+str(matlab(self.value)) return self.name + " = " + str(self.value)
def sigCall( sig,iter ): def sigCall(sig, iter):
sig.recompute(iter) sig.recompute(iter)
print(sigRepr(sig)) print(sigRepr(sig))
def sigTimeIncr( sig,iter ):
sig.recompute(sig.time+iter) def sigTimeIncr(sig, iter):
sig.recompute(sig.time + iter)
print(sigRepr(sig)) print(sigRepr(sig))
setattr(SignalBase,'__repr__',sigRepr)
setattr(SignalBase,'__call__',sigCall) setattr(SignalBase, "__repr__", sigRepr)
setattr(SignalBase,'__add__',sigTimeIncr) setattr(SignalBase, "__call__", sigCall)
setattr(SignalBase, "__add__", sigTimeIncr)
# Enables shortcut "deps" # Enables shortcut "deps"
# Implements the peudo function 'deps', that can be called without arg, # Implements the peudo function 'deps', that can be called without arg,
...@@ -69,31 +85,40 @@ setattr(SignalBase,'__add__',sigTimeIncr) ...@@ -69,31 +85,40 @@ setattr(SignalBase,'__add__',sigTimeIncr)
class SignalDepPrint: class SignalDepPrint:
defaultDepth = 2 defaultDepth = 2
sig = None sig = None
def __init__(self,sig):
self.sig=sig def __init__(self, sig):
self.sig = sig
def __repr__(self): def __repr__(self):
return self.sig.displayDependencies(self.defaultDepth) return self.sig.displayDependencies(self.defaultDepth)
def __call__(self,depth):
def __call__(self, depth):
self.defaultDepth = depth self.defaultDepth = depth
return self return self
setattr(SignalBase,'deps',property(SignalDepPrint))
setattr(Entity,'sigs',property(Entity.displaySignals)) setattr(SignalBase, "deps", property(SignalDepPrint))
setattr(Entity,'__repr__',Entity.__str__)
setattr(Entity, "sigs", property(Entity.displaySignals))
setattr(Entity, "__repr__", Entity.__str__)
sys.ps1 = "% "
# Changing prompt
import sys
sys.ps1 = '% '
# Enable function that can be call without()def optionalparentheses(f): # Enable function that can be call without()def optionalparentheses(f):
def optionalparentheses(f): def optionalparentheses(f):
class decoclass: class decoclass:
def __init__(self,f): self.functor=f def __init__(self, f):
self.functor = f
def __repr__(self): def __repr__(self):
res=self.functor() res = self.functor()
if isinstance(res,str): return res if isinstance(res, str):
else: return '' return res
def __call__(self,*arg): else:
return ""
def __call__(self, *arg):
return self.functor(*arg) return self.functor(*arg)
return decoclass(f) return decoclass(f)
src/dynamic_graph/signal-base-py.cc 0 → 100644
View file @ a76b5b78
// Copyright 2010, Florent Lamiraux, Thomas Moulard, LAAS-CNRS.
#include <dynamic-graph/linear-algebra.h>
#include <dynamic-graph/signal-base.h>
#include <dynamic-graph/signal-ptr.h>
#include <dynamic-graph/signal-time-dependent.h>
#include <dynamic-graph/signal.h>
#include <dynamic-graph/value.h>
#include <boost/python.hpp>
#include <iostream>
#include <sstream>
#include "dynamic-graph/python/dynamic-graph-py.hh"
#include "dynamic-graph/python/signal-wrapper.hh"
#include "dynamic-graph/python/signal.hh"
using dynamicgraph::SignalBase;
namespace bp = boost::python;
namespace dynamicgraph {
namespace python {
typedef int time_type;
typedef Eigen::AngleAxis<double> VectorUTheta;
typedef Eigen::Quaternion<double> Quaternion;
typedef Eigen::VectorXd Vector;
typedef Eigen::Vector3d Vector3;
typedef Eigen::Matrix<double, 7, 1> Vector7;
typedef Eigen::MatrixXd Matrix;
typedef Eigen::Matrix<double, 3, 3> MatrixRotation;
typedef Eigen::Matrix<double, 4, 4> Matrix4;
typedef Eigen::Transform<double, 3, Eigen::Affine> MatrixHomogeneous;
typedef Eigen::Matrix<double, 6, 6> MatrixTwist;
template <typename Time>
void exposeSignalBase(const char* name) {
typedef SignalBase<Time> S_t;
bp::class_<S_t, boost::noncopyable>(name, bp::no_init)
.add_property("time",
bp::make_function(
&S_t::getTime,
bp::return_value_policy<bp::copy_const_reference>()),
&S_t::setTime)
.add_property("name",
bp::make_function(
&S_t::getName,
bp::return_value_policy<bp::copy_const_reference>()))
.def("getName", &S_t::getName,
bp::return_value_policy<bp::copy_const_reference>())
.def(
"getClassName",
+[](const S_t& s) -> std::string {
std::string ret;
s.getClassName(ret);
return ret;
})
.def("plug", &S_t::plug, "Plug the signal to another signal")
.def("unplug", &S_t::unplug, "Unplug the signal")
.def("isPlugged", &S_t::isPlugged, "Whether the signal is plugged")
.def("getPlugged", &S_t::getPluged,
bp::return_value_policy<bp::reference_existing_object>(),
"To which signal the signal is plugged")
.def("recompute", &S_t::recompute, "Recompute the signal at given time")
.def(
"__str__",
+[](const S_t& s) -> std::string {
std::ostringstream oss;
s.display(oss);
return oss.str();
})
.def(
"displayDependencies",
+[](const S_t& s, int time) -> std::string {
std::ostringstream oss;
s.displayDependencies(oss, time);
return oss.str();
},
"Print the signal dependencies in a string");
}
template <>
auto exposeSignal<MatrixHomogeneous, time_type>(const std::string& name) {
typedef Signal<MatrixHomogeneous, time_type> S_t;
bp::class_<S_t, bp::bases<SignalBase<time_type> >, boost::noncopyable> obj(
name.c_str(), bp::init<std::string>());
obj.add_property(
"value",
+[](const S_t& signal) -> Matrix4 {
return signal.accessCopy().matrix();
},
+[](S_t& signal, const Matrix4& v) {
// TODO it isn't hard to support pinocchio::SE3 type here.
// However, this adds a dependency to pinocchio.
signal.setConstant(MatrixHomogeneous(v));
},
"the signal value.");
return obj;
}
void exposeSignals() {
exposeSignalBase<time_type>("SignalBase");
exposeSignalsOfType<bool, time_type>("Bool");
exposeSignalsOfType<int, time_type>("Int");
exposeSignalsOfType<double, time_type>("Double");
exposeSignalsOfType<Vector, time_type>("Vector");
exposeSignalsOfType<Vector3, time_type>("Vector3");
exposeSignalsOfType<Vector7, time_type>("Vector7");
exposeSignalsOfType<Matrix, time_type>("Matrix");
exposeSignalsOfType<MatrixRotation, time_type>("MatrixRotation");
exposeSignalsOfType<MatrixHomogeneous, time_type>("MatrixHomogeneous");
exposeSignalsOfType<MatrixTwist, time_type>("MatrixTwist");
exposeSignalsOfType<Quaternion, time_type>("Quaternion");
exposeSignalsOfType<VectorUTheta, time_type>("VectorUTheta");
}
namespace signalBase {
template <class T>
SignalWrapper<T, int>* createSignalWrapperTpl(const char* name, bp::object o,
std::string& error) {
typedef SignalWrapper<T, int> SignalWrapper_t;
if (!SignalWrapper_t::checkCallable(o, error)) {
return NULL;
}
SignalWrapper_t* obj = new SignalWrapper_t(name, o);
return obj;
}
PythonSignalContainer* getPythonSignalContainer() {
Entity* obj = entity::create("PythonSignalContainer", "python_signals");
return dynamic_cast<PythonSignalContainer*>(obj);
}
#define SIGNAL_WRAPPER_TYPE(IF, Enum, Type) \
IF(command::Value::typeName(command::Value::Enum).compare(type) == 0) { \
obj = createSignalWrapperTpl<Type>(name, object, error); \
}
/**
\brief Create an instance of SignalWrapper
*/
SignalBase<int>* createSignalWrapper(const char* name, const char* type,
bp::object object) {
PythonSignalContainer* psc = getPythonSignalContainer();
if (psc == NULL) return NULL;
SignalBase<int>* obj = NULL;
std::string error;
SIGNAL_WRAPPER_TYPE(if, BOOL, bool)
// SIGNAL_WRAPPER_TYPE(else if, UNSIGNED ,bool)
SIGNAL_WRAPPER_TYPE(else if, INT, int)
SIGNAL_WRAPPER_TYPE(else if, FLOAT, float)
SIGNAL_WRAPPER_TYPE(else if, DOUBLE, double)
// SIGNAL_WRAPPER_TYPE(else if, STRING ,bool)
SIGNAL_WRAPPER_TYPE(else if, VECTOR, Vector)
// SIGNAL_WRAPPER_TYPE(else if, MATRIX ,bool)
// SIGNAL_WRAPPER_TYPE(else if, MATRIX4D ,bool)
else {
error = "Type not understood";
}
if (obj == NULL) throw std::runtime_error(error);
// Register signal into the python signal container
psc->signalRegistration(*obj);
// Return the pointer
return obj;
}
} // namespace signalBase
} // namespace python
} // namespace dynamicgraph
src/dynamic_graph/signal-wrapper.cc 0 → 100644
View file @ a76b5b78
// Copyright (c) 2018, Joseph Mirabel
// Authors: Joseph Mirabel (joseph.mirabel@laas.fr)
#include "dynamic-graph/python/signal-wrapper.hh"
#include <dynamic-graph/command-bind.h>
#include <dynamic-graph/factory.h>
namespace dynamicgraph {
namespace python {
void PythonSignalContainer::signalRegistration(
const SignalArray<int>& signals) {
Entity::signalRegistration(signals);
}
void PythonSignalContainer::rmSignal(const std::string& name) {
Entity::signalDeregistration(name);
}
DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(PythonSignalContainer,
"PythonSignalContainer");
template <class T, class Time>
bool SignalWrapper<T, Time>::checkCallable(pyobject c, std::string& error) {
if (PyCallable_Check(c.ptr()) == 0) {
error = boost::python::extract<std::string>(c.attr("__str__")());
error += " is not callable";
return false;
}
return true;
}
template class SignalWrapper<bool, int>;
template class SignalWrapper<int, int>;
template class SignalWrapper<float, int>;
template class SignalWrapper<double, int>;
template class SignalWrapper<Vector, int>;
} // namespace python
} // namespace dynamicgraph
src/dynamic_graph/signal_base.py
View file @ a76b5b78
""" # Copyright (C) 2020 CNRS
Copyright (C) 2010 CNRS #
# Author: Joseph Mirabel
Author: Florent Lamiraux from __future__ import print_function
"""
import wrap # I kept what follows for backward compatibility but I think it should be
import entity # removed
import re import re
import collections
def stringToTuple (vector) : from .wrap import SignalBase # noqa
from .wrap import create_signal_wrapper as SignalWrapper # noqa
def stringToTuple(vector):
""" """
Transform a string of format '[n](x_1,x_2,...,x_n)' into a tuple of numbers. Transform a string of format '[n](x_1,x_2,...,x_n)' into a tuple of numbers.
""" """
# Find vector length # Find vector length
a = re.match('\[(\d+)\]',vector) a = re.match(r"\[(\d+)\]", vector)
size = int(a.group(1)) size = int(a.group(1))
# remove '[n]' prefix # remove '[n]' prefix
vector = vector[len(a.group(0)):] vector = vector[len(a.group(0)) :]
# remove '(' and ')' at beginning and end # remove '(' and ')' at beginning and end
vector = vector.lstrip('(').rstrip(')\n') vector = vector.lstrip("(").rstrip(")\n")
# split string by ',' # split string by ','
vector = vector.split(',') vector = vector.split(",")
# check size # check size
if len(vector) != size: if len(vector) != size:
raise TypeError('displayed size ' + raise TypeError(
str(size) + ' of vector does not fit actual size: ' "displayed size "
+ str(len(vector))) + str(size)
+ " of vector does not fit actual size: "
+ str(len(vector))
)
res = map(float, vector) res = map(float, vector)
return tuple (res) return tuple(res)
def tupleToString (vector) : def tupleToString(vector):
""" """
Transform a tuple of numbers into a string of format Transform a tuple of numbers into a string of format
'[n](x_1, x_2, ..., x_n)' '[n](x_1, x_2, ..., x_n)'
""" """
string = '[%d]('%len (vector) string = "[%d](" % len(vector)
for x in vector[:-1]: for x in vector[:-1]:
string += '%f,'%x string += "%f," % x
string += '%f)'%vector[-1] string += "%f)" % vector[-1]
return string return string
def stringToMatrix (string) :
def stringToMatrix(string):
""" """
Transform a string of format Transform a string of format
'[n,m]((x_11,x_12,...,x_1m),...,(x_n1,x_n2,...,x_nm))' into a tuple '[n,m]((x_11,x_12,...,x_1m),...,(x_n1,x_n2,...,x_nm))' into a tuple
of tuple of numbers. of tuple of numbers.
""" """
# Find matrix size # Find matrix size
a = re.search ('\[(\d+),(\d+)]', string) a = re.search(r"\[(\d+),(\d+)]", string)
nRows = int (a.group(1)) nRows = int(a.group(1))
nCols = int (a.group(2)) nCols = int(a.group(2))
# Remove '[n,m]' prefix # Remove '[n,m]' prefix
string = string[len(a.group(0)):] string = string[len(a.group(0)) :]
rows = string.split('),(') rows = string.split("),(")
if len(rows) != nRows: if len(rows) != nRows:
raise TypeError('displayed nb rows ' + raise TypeError(
nRows + ' of matrix does not fit actual nb rows: ' "displayed nb rows "
+ str(len(rows))) + nRows
+ " of matrix does not fit actual nb rows: "
+ str(len(rows))
)
m = [] m = []
for rstr in rows: for rstr in rows:
rstr = rstr.lstrip('(').rstrip(')\n') rstr = rstr.lstrip("(").rstrip(")\n")
r = map(float, rstr.split(',')) r = map(float, rstr.split(","))
if len(r) != nCols: if len(r) != nCols:
raise TypeError('one row length ' + raise TypeError(
len(r) + "one row length "
' of matrix does not fit displayed nb cols: ' + + len(r)
nCols) + " of matrix does not fit displayed nb cols: "
+ nCols
)
m.append(tuple(r)) m.append(tuple(r))
return tuple (m) return tuple(m)
def matrixToString(matrix) : def matrixToString(matrix):
""" """
Transform a tuple of tuple of numbers into a string of format Transform a tuple of tuple of numbers into a string of format
'[n,m]((x_11,x_12,...,x_1m),...,(x_n1,x_n2,...,x_nm))'. '[n,m]((x_11,x_12,...,x_1m),...,(x_n1,x_n2,...,x_nm))'.
""" """
nRows = len(matrix) nRows = len(matrix)
if nRows is 0 : if nRows == 0:
return '[0,0](())' return "[0,0](())"
nCols = len(matrix[0]) nCols = len(matrix[0])
string = '[%d,%d](' % (nRows, nCols) string = "[%d,%d](" % (nRows, nCols)
for r in range (nRows) : for r in range(nRows):
string += '(' string += "("
for c in range (nCols) : for c in range(nCols):
string += str (float (matrix [r][c])) string += str(float(matrix[r][c]))
if c != nCols-1 : if c != nCols - 1:
string += ',' string += ","
string += ')' string += ")"
if r != nRows -1 : if r != nRows - 1:
string += ',' string += ","
string += ')' string += ")"
return string return string
def objectToString(obj) :
def objectToString(obj):
""" """
Transform an object to a string. Object is either Transform an object to a string. Object is either
- an entity (more precisely a sub-class named Feature) - an entity (more precisely a sub-class named Feature)
...@@ -101,23 +117,24 @@ def objectToString(obj) : ...@@ -101,23 +117,24 @@ def objectToString(obj) :
- an integer, - an integer,
- a boolean, - a boolean,
""" """
if (hasattr (obj, "__iter__")) : if hasattr(obj, "__iter__"):
# matrix or vector # matrix or vector
if len(obj) is 0 : if len(obj) == 0:
return "" return ""
else : else:
if (hasattr(obj[0], "__iter__")) : if hasattr(obj[0], "__iter__"):
#matrix # matrix
return matrixToString(obj) return matrixToString(obj)
else : else:
#vector # vector
return tupleToString(obj) return tupleToString(obj)
elif isinstance(obj, entity.Entity) : elif hasattr(obj, "name"):
return obj.name return obj.name
else : else:
return str(obj) return str(obj)
def stringToObject(string) :
def stringToObject(string):
""" """
Convert a string into one of the following types Convert a string into one of the following types
- a matrix (tuple of tuple), - a matrix (tuple of tuple),
...@@ -127,147 +144,25 @@ def stringToObject(string) : ...@@ -127,147 +144,25 @@ def stringToObject(string) :
Successively attempts conversion in the above order and return Successively attempts conversion in the above order and return
on success. If no conversion fits, the string is returned. on success. If no conversion fits, the string is returned.
""" """
if isinstance(string,float): return string if isinstance(string, float):
if isinstance(string,int): return string return string
if isinstance(string,tuple): return string if isinstance(string, int):
try : return string
if isinstance(string, tuple):
return string
try:
return stringToMatrix(string) return stringToMatrix(string)
except : except Exception:
pass pass
try : try:
return stringToTuple(string) return stringToTuple(string)
except : except Exception:
pass pass
try : try:
return int(string) return int(string)
except : except Exception:
pass pass
try : try:
return float(string) return float(string)
except : except Exception:
return string return string
class SignalBase (object) :
"""
This class binds dynamicgraph::SignalBase<int> C++ class
"""
obj = None
def __init__(self, name = "", obj = None) :
"""
Constructor: if not called by a child class, create and store a pointer
to a C++ SignalBase<int> object.
"""
if obj :
self.obj = obj
else :
raise RuntimeError(
"A pointer is required to create SignalBase object.")
if (obj==None):
self.className=self.getClassName()
self.name=self.getName()
@property
def time(self) :
"""
Get time of signal
"""
return wrap.signal_base_get_time(self.obj)
@time.setter
def time(self, val) :
"""
Set Time of signal
Input:
- an integer
"""
return wrap.signal_base_set_time(self.obj, val)
@property
def value(self) :
"""
Setter and getter for the value of a signal
Binds C++ SignalBase<int>::get() and set() methods. Values are passed
through string streams.
A string is interpreted as respectively:
* a matrix (tuple of tuple) if string fits '[n,m]((x_11,x_12,...,x_1m),...,(x_n1,x_n2,...,x_nm))' format where n and m are integers, x_ij are floating point numbers,
* a tuple if string fits '[n](x_1, x_2, ..., x_n)' format,
* an integer,
* a floating point number.
If string fits none of the above formats, no conversion is performed.
For instance, is s binds a signal of type vector,
>>> s.value = (2.5, .1, 1e2)
will call SignalBase<int>::set("[3](2.5,0.1,100.0)") and
>>> s.value
(2.5, 0.1, 100.0)
"""
string = wrap.signal_base_get_value(self.obj)
return stringToObject(string)
@value.setter
def value(self, val) :
"""
Set the signal as a constant signal with given value.
If the signal is plugged, it will be unplugged
"""
string = objectToString(val)
return wrap.signal_base_set_value(self.obj, string)
def getName(self):
"""
Get name of signal
"""
return wrap.signal_base_get_name(self.obj)
@property
def name (self) :
"""
Get name of signal
"""
return wrap.signal_base_get_name(self.obj)
def getClassName(self):
"""
Get class name of signal
"""
return wrap.signal_base_get_class_name(self.obj)
def recompute(self, time):
"""
Force signal to recompute the value at given time.
"""
return wrap.signal_base_recompute(self.obj, time)
def unplug(self):
"""
Unplug a PTR signal.
"""
return wrap.signal_base_unplug(self.obj)
def isPlugged(self):
"""
Return whether a signal is plugged.
"""
return wrap.signal_base_isPlugged(self.obj)
def getPlugged(self):
"""
Return the plugged signal.
"""
return SignalBase (obj = wrap.signal_base_getPlugged(self.obj))
def __str__(self):
"""
Print signal in a string
"""
return wrap.signal_base_display(self.obj)
def displayDependencies(self,iter):
"""
Print signal dependencies in a string
"""
return(wrap.signal_base_display_dependencies(self.obj,iter))
src/dynamic_graph/tools.py
View file @ a76b5b78
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
# Copyright 2011, Florent Lamiraux, Thomas Moulard, JRL, CNRS/AIST # Copyright 2011, Florent Lamiraux, Thomas Moulard, JRL, CNRS/AIST
#
# This file is part of dynamic-graph.
# dynamic-graph 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.
#
# dynamic-graph 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
# dynamic-graph. If not, see <http://www.gnu.org/licenses/>.
from __future__ import print_function from __future__ import print_function
def addTrace(robot, trace, entityName, signalName, autoRecompute = True):
def addTrace(robot, trace, entityName, signalName, autoRecompute=True):
""" """
Add a signal to a tracer and recompute it automatically if necessary. Add a signal to a tracer and recompute it automatically if necessary.
""" """
signal = '{0}.{1}'.format(entityName, signalName) signal = "{0}.{1}".format(entityName, signalName)
filename = '{0}-{1}'.format(entityName, signalName) filename = "{0}-{1}".format(entityName, signalName).replace("/", "_")
trace.add(signal, filename) trace.add(signal, filename)
if autoRecompute: if autoRecompute:
robot.device.after.addSignal(signal) robot.device.after.addSignal(signal)
src/dynamic_graph/tracer/wrap.cc 0 → 100644
View file @ a76b5b78
#include <dynamic-graph/tracer.h>
#include "dynamic-graph/python/module.hh"
BOOST_PYTHON_MODULE(wrap) {
using dynamicgraph::Tracer;
bp::import("dynamic_graph");
dynamicgraph::python::exposeEntity<Tracer>().def("addSignal",
&Tracer::addSignalToTrace);
}
src/dynamic_graph/tracer_real_time/wrap.cc 0 → 100644
View file @ a76b5b78
#include <dynamic-graph/tracer-real-time.h>
#include "dynamic-graph/python/module.hh"
BOOST_PYTHON_MODULE(wrap) {
using dynamicgraph::Tracer;
using dynamicgraph::TracerRealTime;
bp::import("dynamic_graph.tracer");
dynamicgraph::python::exposeEntity<TracerRealTime, bp::bases<Tracer> >();
}