Thank you for the quick response. I have included the full code (at the bottom
of the message) of how I think it "should" work. I've put "should" in quotes
because it's based upon my understanding of how to put a converter from C++ to
Python together. Compiling this produces two errors (first about no match and
second for no get_pytype() declared:
/usr/include/boost/python/detail/invoke.hpp: In instantiation of 'PyObject*
boost::python::detail::invoke(boost::python::detail::invoke_tag_<false, true>,
const RC&, F&, TC&) [with RC =
boost::python::detail::specify_a_return_value_policy_to_wrap_functions_returning<const
Vec3d&>; F = const Vec3d& (UseVec3d::*)() const; TC =
boost::python::arg_from_python<UseVec3d&>; PyObject = _object]':
/usr/include/boost/python/detail/caller.hpp:218:46: required from 'PyObject*
boost::python::detail::caller_arity<1u>::impl<F, Policies,
Sig>::operator()(PyObject*, PyObject*) [with F = const Vec3d& (UseVec3d::*)()
const; Policies = boost::python::default_call_policies; Sig =
boost::mpl::vector2<const Vec3d&, UseVec3d&>; PyObject = _object]'
/usr/include/boost/python/object/py_function.hpp:38:33: required from
'PyObject*
boost::python::objects::caller_py_function_impl<Caller>::operator()(PyObject*,
PyObject*) [with Caller = boost::python::detail::caller<const Vec3d&
(UseVec3d::*)() const, boost::python::default_call_policies,
boost::mpl::vector2<const Vec3d&, UseVec3d&> >; PyObject = _object]'
/root/RAF/RAF/Python/raf.cpp:80:1: required from here
/usr/include/boost/python/detail/invoke.hpp:88:14: error: no match for call to
'(const
boost::python::detail::specify_a_return_value_policy_to_wrap_functions_returning<const
Vec3d&>) (const Vec3d&)'
return rc( (tc().*f)(BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, ()
BOOST_PP_INTERCEPT)) );
and
/usr/include/boost/python/detail/caller.hpp: In instantiation of 'static const
PyTypeObject*
boost::python::detail::converter_target_type<ResultConverter>::get_pytype()
[with ResultConverter =
boost::python::detail::specify_a_return_value_policy_to_wrap_functions_returning<const
Vec3d&>; PyTypeObject = _typeobject]':
/usr/include/boost/python/detail/caller.hpp:240:19: required from 'static
boost::python::detail::py_func_sig_info
boost::python::detail::caller_arity<1u>::impl<F, Policies, Sig>::signature()
[with F = const Vec3d& (UseVec3d::*)() const; Policies =
boost::python::default_call_policies; Sig = boost::mpl::vector2<const Vec3d&,
UseVec3d&>]'
/usr/include/boost/python/object/py_function.hpp:48:35: required from
'boost::python::detail::py_func_sig_info
boost::python::objects::caller_py_function_impl<Caller>::signature() const
[with Caller = boost::python::detail::caller<const Vec3d& (UseVec3d::*)()
const, boost::python::default_call_policies, boost::mpl::vector2<const Vec3d&,
UseVec3d&> >]'
/root/RAF/RAF/Python/raf.cpp:80:1: required from here
/usr/include/boost/python/detail/caller.hpp:102:98: error: 'struct
boost::python::detail::specify_a_return_value_policy_to_wrap_functions_returning<const
Vec3d&>' has no member named 'get_pytype'
return create_result_converter((PyObject*)0, (ResultConverter *)0,
(ResultConverter *)0).get_pytype();
> ...
> (But I'm a little confused by your phrasing: Something like
> `class_<cv::Vec3d>` doesn't "redefine" anything, and it doesn't make a
> C++ type "visible" in Python.
> ...
Here I'm trying to understand if I have an OpenCV Vec3d type (that I've defined
using p::class_<cv::Vec3d>) getting returned to Python from a function call,
how does one prevent collision with the OpenCV Vec3d defined by another library
(that uses OpenCV and may be using the same mechanism)? The two declarations
may not be compatible despite their apparent similarities (the other library is
several revisions behind on OpenCV, for example).
Here is the code with converter. I don't know if there's a preferred way of
doing what I'm attempting:
#include <boost/python.hpp>
namespace p = boost::python;
class Vec3d
{
public:
Vec3d() {v[0] = v[1] = v[2] = 0.0;}
virtual ~Vec3d() {}
double operator[](size_t idx) const {return v[idx];}
double& operator[](size_t idx) {return v[idx];}
private:
double v[3];
};
class UseVec3d
{
public:
UseVec3d() {}
UseVec3d(const Vec3d& vec) : v(vec) {}
virtual ~UseVec3d() {};
const Vec3d& get_vec() const {return v;}
void set_vec(const Vec3d& vec) {v = vec;}
private:
Vec3d v;
};
struct vec3d_to_py
{
static PyObject* convert(const Vec3d& src)
{
return Py_BuildValue("(ddd)", src[0], src[1], src[2]);
}
static PyTypeObject const *get_pytype () // Could use
converter::to_python_target_type
{
return &PyTuple_Type;
}
};
struct vec3d_from_py
{
vec3d_from_py()
{
boost::python::converter::registry::push_back(
&convertible,
&construct,
boost::python::type_id<Vec3d>()
);
}
static void* convertible(PyObject* obj)
{
return obj;
}
static void construct(PyObject* self,
p::converter::rvalue_from_python_stage1_data* data)
{
typedef p::converter::rvalue_from_python_storage<Vec3d>
storage_t;
storage_t* store = reinterpret_cast<storage_t *>(data);
void* mem = store->storage.bytes;
new (mem) Vec3d();
Vec3d* pv = reinterpret_cast<Vec3d *>(mem);
PyArg_ParseTuple(self, "ddd", &((*pv)[0]), &((*pv)[1]),
&((*pv)[2]));
data->convertible = mem;
}
};
BOOST_PYTHON_MODULE(raf)
{
vec3d_from_py();
p::to_python_converter<Vec3d, vec3d_to_py, true>();
p::class_<UseVec3d>("UseVec3d")
.def("get_vec", &UseVec3d::get_vec)
;
}
_______________________________________________
Cplusplus-sig mailing list
[email protected]
https://mail.python.org/mailman/listinfo/cplusplus-sig
