36 #ifndef VIGRA_NUMPY_ARRAY_CONVERTERS_HXX 
   37 #define VIGRA_NUMPY_ARRAY_CONVERTERS_HXX 
   39 #include "numpy_array.hxx" 
   40 #include "metaprogramming.hxx" 
   41 #include <boost/python.hpp> 
   42 #include <boost/python/to_python_converter.hpp> 
   43 #include <boost/python/raw_function.hpp> 
   45 #include <type_traits> 
   49 template <
class Array>
 
   50 PyObject * returnNumpyArray(Array 
const & a)
 
   52     PyObject * pa = a.pyObject();
 
   54         PyErr_SetString(PyExc_ValueError, 
"returnNumpyArray(): Conversion to Python failed, array has no data.");
 
   60 VIGRA_EXPORT std::set<std::string> & exportedArrayKeys();
 
   62 template <
class ArrayType>
 
   63 struct NumpyArrayConverter {};
 
   65 template <
unsigned int N, 
class T, 
class Str
ide>
 
   66 struct NumpyArrayConverter<NumpyArray<N, T, Stride> >
 
   68     typedef NumpyArray<N, T, Stride> ArrayType;
 
   69     typedef typename ArrayType::ArrayTraits ArrayTraits;
 
   71     NumpyArrayConverter();
 
   73     static void* convertible(PyObject* obj);
 
   76     static void construct(PyObject* obj,
 
   77         boost::python::converter::rvalue_from_python_stage1_data* data);
 
   80     static PyObject* convert(ArrayType 
const& a)
 
   82         return returnNumpyArray(a);
 
   86 template <
unsigned int N, 
class T, 
class Str
ide>
 
   87 NumpyArrayConverter<NumpyArray<N, T, Stride> >::NumpyArrayConverter()
 
   89     using namespace boost::python;
 
   91     converter::registration 
const * reg = converter::registry::query(type_id<ArrayType>());
 
   94     if(!reg || !reg->rvalue_chain)
 
   96         to_python_converter<ArrayType, NumpyArrayConverter>();
 
   97         converter::registry::insert(&convertible, &construct, type_id<ArrayType>());
 
  101 template <
unsigned int N, 
class T, 
class Str
ide>
 
  102 void * NumpyArrayConverter<NumpyArray<N, T, Stride> >::convertible(PyObject* obj)
 
  104     bool isCompatible = obj == Py_None || ArrayType::isStrictlyCompatible(obj);
 
  112 template <
unsigned int N, 
class T, 
class Str
ide>
 
  113 void NumpyArrayConverter<NumpyArray<N, T, Stride> >::construct(PyObject* obj,
 
  114                    boost::python::converter::rvalue_from_python_stage1_data* data)
 
  116     void* 
const storage =
 
  117         ((boost::python::converter::rvalue_from_python_storage<ArrayType>* ) data)->storage.bytes;
 
  119     ArrayType * array = 
new (storage) ArrayType();
 
  121         array->makeReferenceUnchecked(obj);
 
  123     data->convertible = storage;
 
  126 template <
unsigned int N, 
class T, 
class Str
ide>
 
  127 struct NumpyArrayConverter<MultiArrayView<N, T, Stride> >
 
  128 : 
public NumpyArrayConverter<NumpyArray<N, T, Stride> >
 
  130     typedef NumpyArrayConverter<NumpyArray<N, T, Stride> > BaseType;
 
  131     typedef MultiArrayView<N, T, Stride> ArrayType;
 
  133     NumpyArrayConverter()
 
  135         using namespace boost::python;
 
  136         converter::registry::insert(&BaseType::convertible, &BaseType::construct,
 
  137                                     type_id<ArrayType>());
 
  141 template <
class Iter, 
class End>
 
  142 struct RegisterNumpyArrayConverters
 
  146         typedef typename UnqualifiedType<typename boost::mpl::deref<Iter>::type>::type Type;
 
  147         NumpyArrayConverter<Type>();
 
  148         RegisterNumpyArrayConverters<typename boost::mpl::next<Iter>::type, End>::exec();
 
  153 struct RegisterNumpyArrayConverters<End, End>
 
  159 template <
class Typelist>
 
  160 void registerNumpyArrayConverters(Typelist)
 
  162     RegisterNumpyArrayConverters<typename boost::mpl::begin<Typelist>::type,
 
  163                                  typename boost::mpl::end<Typelist>::type >::exec();
 
  167 FN registerConverters(FN f)
 
  169     registerNumpyArrayConverters(boost::python::detail::get_signature(f));
 
  179 struct TypeName<Singleband<T>>
 
  184 struct TypeName<Multiband<T>>
 
  188 template <
class T, 
int N>
 
  189 struct TypeName<TinyVector<T, N>>
 
  194 struct TypeName<void>
 
  196     static std::string name() {
 
  197         return std::string(
"void");
 
  199     static std::string sized_name() {
 
  200         return std::string(
"void");
 
  205 struct TypeName<bool>
 
  207     static std::string name() {
 
  208         return std::string(
"bool");
 
  210     static std::string sized_name() {
 
  211         return std::string(
"bool8");
 
  215 #define VIGRA_SIGNED_INT_NAME(type) \ 
  217 struct TypeName<type> \ 
  219     static std::string name() { \ 
  220         return std::string(#type); \ 
  222     static std::string sized_name() { \ 
  223         return std::string("int") + std::to_string(sizeof(type)*8); \ 
  227 VIGRA_SIGNED_INT_NAME(
signed char)
 
  228 VIGRA_SIGNED_INT_NAME(
short)
 
  229 VIGRA_SIGNED_INT_NAME(
int)
 
  230 VIGRA_SIGNED_INT_NAME(
long)
 
  231 VIGRA_SIGNED_INT_NAME(
long long)
 
  233 #define VIGRA_UNSIGNED_INT_NAME(type) \ 
  235 struct TypeName<type> \ 
  237     static std::string name() { \ 
  238         return std::string(#type); \ 
  240     static std::string sized_name() { \ 
  241         return std::string("uint") + std::to_string(sizeof(type)*8); \ 
  245 VIGRA_UNSIGNED_INT_NAME(
unsigned char)
 
  246 VIGRA_UNSIGNED_INT_NAME(
unsigned short)
 
  247 VIGRA_UNSIGNED_INT_NAME(
unsigned int)
 
  248 VIGRA_UNSIGNED_INT_NAME(
unsigned long)
 
  249 VIGRA_UNSIGNED_INT_NAME(
unsigned long long)
 
  251 #define VIGRA_FLOAT_NAME(type) \ 
  253 struct TypeName<type> \ 
  255     static std::string name() { \ 
  256         return std::string(#type); \ 
  258     static std::string sized_name() { \ 
  259         return std::string("float") + std::to_string(sizeof(type)*8); \ 
  263 VIGRA_FLOAT_NAME(
float)
 
  264 VIGRA_FLOAT_NAME(
double)
 
  265 VIGRA_FLOAT_NAME(
long double)
 
  267 #undef VIGRA_SIGNED_INT_NAME 
  268 #undef VIGRA_UNSIGNED_INT_NAME 
  269 #undef VIGRA_FLOAT_NAME 
  271 template <
class T = 
void>
 
  274     static char const * exec(
char const *) { 
return 0; }
 
  278 struct ExportDoc<void>
 
  280     static char const * exec(
char const * h) { 
return h; }
 
  287 namespace boost { 
namespace python {
 
  294 #define VIGRA_PYTHON_MULTITYPE_FUNCTOR(functor_name, function) \ 
  296 struct functor_name##Impl \ 
  298     static void def(const char * pythonName) \ 
  300         boost::python::docstring_options doc(false); \ 
  301         boost::python::def(pythonName, vigra::registerConverters(&function<T>)); \ 
  304     template <class Args> \ 
  305     static void def(const char * pythonName, Args const & args) \ 
  307         boost::python::docstring_options doc(false); \ 
  308         boost::python::def(pythonName, vigra::registerConverters(&function<T>), args); \ 
  311     static void def(const char * pythonName, char const * help) \ 
  314             boost::python::def(pythonName, \ 
  315                          vigra::registerConverters(&function<T>), help); \ 
  320     template <class Args> \ 
  321     static void def(const char * pythonName, Args const & args, char const * help) \ 
  324             boost::python::def(pythonName, \ 
  325                          vigra::registerConverters(&function<T>), args, help); \ 
  327             def(pythonName, args); \ 
  332 struct functor_name##Impl<void> \ 
  334     static void def(const char *) {} \ 
  336     template <class A1> \ 
  337     static void def(const char *, A1 const &) {} \ 
  339     template <class A1, class A2> \ 
  340     static void def(const char *, A1 const &, A2 const &) {} \ 
  343 template <class T1, \ 
  355 struct functor_name \ 
  356 : public boost::python::PythonMultidefFunctor \ 
  358     bool install_fallback_, show_python_signature_; \ 
  361     : install_fallback_(false) \ 
  362     , show_python_signature_(true) \ 
  365     functor_name & installFallback() \ 
  367         install_fallback_ = true; \ 
  371     functor_name & noPythonSignature() \ 
  373         show_python_signature_ = false; \ 
  377     typedef boost::python::ArgumentMismatchMessage\ 
  378         <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Message; \ 
  379     typedef functor_name##Impl<T1 > F1; \ 
  380     typedef functor_name##Impl<T2 > F2; \ 
  381     typedef functor_name##Impl<T3 > F3; \ 
  382     typedef functor_name##Impl<T4 > F4; \ 
  383     typedef functor_name##Impl<T5 > F5; \ 
  384     typedef functor_name##Impl<T6 > F6; \ 
  385     typedef functor_name##Impl<T7 > F7; \ 
  386     typedef functor_name##Impl<T8 > F8; \ 
  387     typedef functor_name##Impl<T9 > F9; \ 
  388     typedef functor_name##Impl<T10> F10; \ 
  389     typedef functor_name##Impl<T11> F11; \ 
  390     typedef functor_name##Impl<T12> F12; \ 
  392     void def(const char * pythonName) const \ 
  394         boost::python::docstring_options doc(false, false, false); \ 
  395         if(install_fallback_) \ 
  396             Message::def(pythonName); \ 
  397         F1 ::def(pythonName); \ 
  398         F2 ::def(pythonName); \ 
  399         F3 ::def(pythonName); \ 
  400         F4 ::def(pythonName); \ 
  401         F5 ::def(pythonName); \ 
  402         F6 ::def(pythonName); \ 
  403         F7 ::def(pythonName); \ 
  404         F8 ::def(pythonName); \ 
  405         F9 ::def(pythonName); \ 
  406         F10::def(pythonName); \ 
  407         F11::def(pythonName); \ 
  408         F12::def(pythonName); \ 
  411     template <class Args> \ 
  412     void def(const char * pythonName, Args const & args) const \ 
  414         boost::python::docstring_options doc(false, false, false); \ 
  415         if(install_fallback_) \ 
  416             Message::def(pythonName); \ 
  417         F1 ::def(pythonName, args); \ 
  418         F2 ::def(pythonName, args); \ 
  419         F3 ::def(pythonName, args); \ 
  420         F4 ::def(pythonName, args); \ 
  421         F5 ::def(pythonName, args); \ 
  422         F6 ::def(pythonName, args); \ 
  423         F7 ::def(pythonName, args); \ 
  424         F8 ::def(pythonName, args); \ 
  425         F9 ::def(pythonName, args); \ 
  426         F10::def(pythonName, args); \ 
  427         F11::def(pythonName, args); \ 
  428         F12::def(pythonName, args); \ 
  431     void def(const char * pythonName, const char * help) const \ 
  433         if(install_fallback_) \ 
  434             Message::def(pythonName); \ 
  435         boost::python::docstring_options doc(true, show_python_signature_, false); \ 
  436         F1 ::def(pythonName, detail::ExportDoc<T2 >::exec(help)); \ 
  437         F2 ::def(pythonName, detail::ExportDoc<T3 >::exec(help)); \ 
  438         F3 ::def(pythonName, detail::ExportDoc<T4 >::exec(help)); \ 
  439         F4 ::def(pythonName, detail::ExportDoc<T5 >::exec(help)); \ 
  440         F5 ::def(pythonName, detail::ExportDoc<T6 >::exec(help)); \ 
  441         F6 ::def(pythonName, detail::ExportDoc<T7 >::exec(help)); \ 
  442         F7 ::def(pythonName, detail::ExportDoc<T8 >::exec(help)); \ 
  443         F8 ::def(pythonName, detail::ExportDoc<T9 >::exec(help)); \ 
  444         F9 ::def(pythonName, detail::ExportDoc<T10>::exec(help)); \ 
  445         F10::def(pythonName, detail::ExportDoc<T11>::exec(help)); \ 
  446         F11::def(pythonName, detail::ExportDoc<T12>::exec(help)); \ 
  447         F12::def(pythonName, detail::ExportDoc<   >::exec(help)); \ 
  450     template <class Args> \ 
  451     void def(const char * pythonName, Args const & args, char const * help) const \ 
  453         if(install_fallback_) \ 
  454             Message::def(pythonName); \ 
  455         boost::python::docstring_options doc(true, show_python_signature_, false); \ 
  456         F1 ::def(pythonName, args, detail::ExportDoc<T2 >::exec(help)); \ 
  457         F2 ::def(pythonName, args, detail::ExportDoc<T3 >::exec(help)); \ 
  458         F3 ::def(pythonName, args, detail::ExportDoc<T4 >::exec(help)); \ 
  459         F4 ::def(pythonName, args, detail::ExportDoc<T5 >::exec(help)); \ 
  460         F5 ::def(pythonName, args, detail::ExportDoc<T6 >::exec(help)); \ 
  461         F6 ::def(pythonName, args, detail::ExportDoc<T7 >::exec(help)); \ 
  462         F7 ::def(pythonName, args, detail::ExportDoc<T8 >::exec(help)); \ 
  463         F8 ::def(pythonName, args, detail::ExportDoc<T9 >::exec(help)); \ 
  464         F9 ::def(pythonName, args, detail::ExportDoc<T10>::exec(help)); \ 
  465         F10::def(pythonName, args, detail::ExportDoc<T11>::exec(help)); \ 
  466         F11::def(pythonName, args, detail::ExportDoc<T12>::exec(help)); \ 
  467         F12::def(pythonName, args, detail::ExportDoc<   >::exec(help)); \ 
  471 #define VIGRA_PYTHON_MULTITYPE_FUNCTOR_NDIM(functor_name, function) \ 
  472 template <class T, int FROM, int TO> \ 
  473 struct functor_name##Impl \ 
  475     typedef functor_name##Impl type; \ 
  477     static void def(const char * pythonName) \ 
  479         functor_name##Impl<T, FROM, FROM>::def(pythonName); \ 
  480         functor_name##Impl<T, FROM+1, TO>::def(pythonName); \ 
  483     template <class Args> \ 
  484     static void def(const char * pythonName, Args const & args) \ 
  486         functor_name##Impl<T, FROM, FROM>::def(pythonName, args); \ 
  487         functor_name##Impl<T, FROM+1, TO>::def(pythonName, args); \ 
  490     static void def(const char * pythonName, char const * help) \ 
  492         functor_name##Impl<T, FROM, FROM>::def(pythonName); \ 
  493         functor_name##Impl<T, FROM+1, TO>::def(pythonName, help); \ 
  496     template <class Args> \ 
  497     static void def(const char * pythonName, Args const & args, char const * help) \ 
  499         functor_name##Impl<T, FROM, FROM>::def(pythonName, args); \ 
  500         functor_name##Impl<T, FROM+1, TO>::def(pythonName, args, help); \ 
  504 template <class T, int N> \ 
  505 struct functor_name##Impl<T, N, N> \ 
  507     typedef functor_name##Impl type; \ 
  509     static void def(const char * pythonName) \ 
  511         boost::python::docstring_options doc(false); \ 
  512         boost::python::def(pythonName, vigra::registerConverters(&function<T, N>)); \ 
  515     template <class Args> \ 
  516     static void def(const char * pythonName, Args const & args) \ 
  518         boost::python::docstring_options doc(false); \ 
  519         boost::python::def(pythonName, vigra::registerConverters(&function<T, N>), args); \ 
  522     static void def(const char * pythonName, char const * help) \ 
  525             boost::python::def(pythonName, \ 
  526                          vigra::registerConverters(&function<T, N>), help); \ 
  531     template <class Args> \ 
  532     static void def(const char * pythonName, Args const & args, char const * help) \ 
  535             boost::python::def(pythonName, \ 
  536                          vigra::registerConverters(&function<T, N>), args, help); \ 
  538             def(pythonName, args); \ 
  542 template <int FROM, int TO> \ 
  543 struct functor_name##Impl<void, FROM, TO> \ 
  545     static void def(const char *) {} \ 
  547     template <class A1> \ 
  548     static void def(const char *, A1 const &) {} \ 
  550     template <class A1, class A2> \ 
  551     static void def(const char *, A1 const &, A2 const &) {} \ 
  555 struct functor_name##Impl<void, N, N> \ 
  557     static void def(const char *) {} \ 
  559     template <class A1> \ 
  560     static void def(const char *, A1 const &) {} \ 
  562     template <class A1, class A2> \ 
  563     static void def(const char *, A1 const &, A2 const &) {} \ 
  566 template <int FROM, int TO, \ 
  579 struct functor_name \ 
  580 : public boost::python::PythonMultidefFunctor \ 
  582     bool install_fallback_, show_python_signature_; \ 
  585     : install_fallback_(false) \ 
  586     , show_python_signature_(true) \ 
  588         static_assert(FROM <= TO, #functor_name ": dimension range empty (FROM > TO)"); \ 
  591     functor_name & installFallback() \ 
  593         install_fallback_ = true; \ 
  597     functor_name & noPythonSignature() \ 
  599         show_python_signature_ = false; \ 
  603     typedef boost::python::ArgumentMismatchMessage\ 
  604         <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Message; \ 
  605     typedef functor_name##Impl<T1 , FROM, TO> F1; \ 
  606     typedef functor_name##Impl<T2 , FROM, TO> F2; \ 
  607     typedef functor_name##Impl<T3 , FROM, TO> F3; \ 
  608     typedef functor_name##Impl<T4 , FROM, TO> F4; \ 
  609     typedef functor_name##Impl<T5 , FROM, TO> F5; \ 
  610     typedef functor_name##Impl<T6 , FROM, TO> F6; \ 
  611     typedef functor_name##Impl<T7 , FROM, TO> F7; \ 
  612     typedef functor_name##Impl<T8 , FROM, TO> F8; \ 
  613     typedef functor_name##Impl<T9 , FROM, TO> F9; \ 
  614     typedef functor_name##Impl<T10, FROM, TO> F10; \ 
  615     typedef functor_name##Impl<T11, FROM, TO> F11; \ 
  616     typedef functor_name##Impl<T12, FROM, TO> F12; \ 
  618     void def(const char * pythonName) const \ 
  620         boost::python::docstring_options doc(false, false, false); \ 
  621         if(install_fallback_) \ 
  622             Message::def(pythonName); \ 
  623         F1 ::def(pythonName); \ 
  624         F2 ::def(pythonName); \ 
  625         F3 ::def(pythonName); \ 
  626         F4 ::def(pythonName); \ 
  627         F5 ::def(pythonName); \ 
  628         F6 ::def(pythonName); \ 
  629         F7 ::def(pythonName); \ 
  630         F8 ::def(pythonName); \ 
  631         F9 ::def(pythonName); \ 
  632         F10::def(pythonName); \ 
  633         F11::def(pythonName); \ 
  634         F12::def(pythonName); \ 
  637     template <class Args> \ 
  638     void def(const char * pythonName, Args const & args) const \ 
  640         boost::python::docstring_options doc(false, false, false); \ 
  641         if(install_fallback_) \ 
  642             Message::def(pythonName); \ 
  643         F1 ::def(pythonName, args); \ 
  644         F2 ::def(pythonName, args); \ 
  645         F3 ::def(pythonName, args); \ 
  646         F4 ::def(pythonName, args); \ 
  647         F5 ::def(pythonName, args); \ 
  648         F6 ::def(pythonName, args); \ 
  649         F7 ::def(pythonName, args); \ 
  650         F8 ::def(pythonName, args); \ 
  651         F9 ::def(pythonName, args); \ 
  652         F10::def(pythonName, args); \ 
  653         F11::def(pythonName, args); \ 
  654         F12::def(pythonName, args); \ 
  657     void def(const char * pythonName, const char * help) const \ 
  659         if(install_fallback_) \ 
  660             Message::def(pythonName); \ 
  661         boost::python::docstring_options doc(true, show_python_signature_, false); \ 
  662         F1 ::def(pythonName, detail::ExportDoc<T2 >::exec(help)); \ 
  663         F2 ::def(pythonName, detail::ExportDoc<T3 >::exec(help)); \ 
  664         F3 ::def(pythonName, detail::ExportDoc<T4 >::exec(help)); \ 
  665         F4 ::def(pythonName, detail::ExportDoc<T5 >::exec(help)); \ 
  666         F5 ::def(pythonName, detail::ExportDoc<T6 >::exec(help)); \ 
  667         F6 ::def(pythonName, detail::ExportDoc<T7 >::exec(help)); \ 
  668         F7 ::def(pythonName, detail::ExportDoc<T8 >::exec(help)); \ 
  669         F8 ::def(pythonName, detail::ExportDoc<T9 >::exec(help)); \ 
  670         F9 ::def(pythonName, detail::ExportDoc<T10>::exec(help)); \ 
  671         F10::def(pythonName, detail::ExportDoc<T11>::exec(help)); \ 
  672         F11::def(pythonName, detail::ExportDoc<T12>::exec(help)); \ 
  673         F12::def(pythonName, detail::ExportDoc<   >::exec(help)); \ 
  676     template <class Args> \ 
  677     void def(const char * pythonName, Args const & args, char const * help) const \ 
  679         if(install_fallback_) \ 
  680             Message::def(pythonName); \ 
  681         boost::python::docstring_options doc(true, show_python_signature_, false); \ 
  682         F1 ::def(pythonName, args, detail::ExportDoc<T2 >::exec(help)); \ 
  683         F2 ::def(pythonName, args, detail::ExportDoc<T3 >::exec(help)); \ 
  684         F3 ::def(pythonName, args, detail::ExportDoc<T4 >::exec(help)); \ 
  685         F4 ::def(pythonName, args, detail::ExportDoc<T5 >::exec(help)); \ 
  686         F5 ::def(pythonName, args, detail::ExportDoc<T6 >::exec(help)); \ 
  687         F6 ::def(pythonName, args, detail::ExportDoc<T7 >::exec(help)); \ 
  688         F7 ::def(pythonName, args, detail::ExportDoc<T8 >::exec(help)); \ 
  689         F8 ::def(pythonName, args, detail::ExportDoc<T9 >::exec(help)); \ 
  690         F9 ::def(pythonName, args, detail::ExportDoc<T10>::exec(help)); \ 
  691         F10::def(pythonName, args, detail::ExportDoc<T11>::exec(help)); \ 
  692         F11::def(pythonName, args, detail::ExportDoc<T12>::exec(help)); \ 
  693         F12::def(pythonName, args, detail::ExportDoc<   >::exec(help)); \ 
  697 struct PythonMultidefFunctor {};
 
  711 struct ArgumentMismatchMessage
 
  713     static std::string message()
 
  716             "No C++ overload matches the arguments. This can have three reasons:\n\n" 
  717             " * The array arguments may have an unsupported element type. You may need\n" 
  718             "   to convert your array(s) to another element type using 'array.astype(...)'.\n" 
  719             "   The function currently supports the following types:\n\n     ");
 
  720         res += vigra::detail::TypeName<T1>::sized_name();
 
  722         if(vigra::detail::TypeName<T2>::sized_name() != 
"void")
 
  723             res += 
", " + vigra::detail::TypeName<T2>::sized_name();
 
  724         if(vigra::detail::TypeName<T3>::sized_name() != 
"void")
 
  725             res += 
", " + vigra::detail::TypeName<T3>::sized_name();
 
  726         if(vigra::detail::TypeName<T4>::sized_name() != 
"void")
 
  727             res += 
", " + vigra::detail::TypeName<T4>::sized_name();
 
  728         if(vigra::detail::TypeName<T5>::sized_name() != 
"void")
 
  729             res += 
", " + vigra::detail::TypeName<T5>::sized_name();
 
  730         if(vigra::detail::TypeName<T6>::sized_name() != 
"void")
 
  731             res += 
", " + vigra::detail::TypeName<T6>::sized_name();
 
  732         if(vigra::detail::TypeName<T7>::sized_name() != 
"void")
 
  733             res += 
", " + vigra::detail::TypeName<T7>::sized_name();
 
  734         if(vigra::detail::TypeName<T8>::sized_name() != 
"void")
 
  735             res += 
", " + vigra::detail::TypeName<T8>::sized_name();
 
  736         if(vigra::detail::TypeName<T9>::sized_name() != 
"void")
 
  737             res += 
", " + vigra::detail::TypeName<T9>::sized_name();
 
  738         if(vigra::detail::TypeName<T10>::sized_name() != 
"void")
 
  739             res += 
", " + vigra::detail::TypeName<T10>::sized_name();
 
  740         if(vigra::detail::TypeName<T11>::sized_name() != 
"void")
 
  741             res += 
", " + vigra::detail::TypeName<T11>::sized_name();
 
  742         if(vigra::detail::TypeName<T12>::sized_name() != 
"void")
 
  743             res += 
", " + vigra::detail::TypeName<T12>::sized_name();
 
  747             " * The dimension of your array(s) is currently unsupported (consult the\n" 
  748             "   function's documentation for information about supported dimensions).\n\n" 
  749             " * You provided an unrecognized argument, or an argument with incorrect type\n" 
  750             "   (consult the documentation for valid function signatures).\n\n" 
  751             "Additional overloads can easily be added in the vigranumpy C++ sources.\n" 
  752             "Please submit an issue at http://github.com/ukoethe/vigra/ to let us know\n" 
  753             "what you need (or a pull request if you solved it on your own :-).\n\n";
 
  758     static void def(
const char * pythonName)
 
  760         docstring_options doc(
false, 
false, 
false);
 
  761         std::string msg    = message(),
 
  762                     module = extract<std::string>(scope().attr(
"__name__"))() + 
".";
 
  763         msg += 
"Type 'help(" + module + pythonName + 
")' to get full documentation.\n";
 
  764         boost::python::def(pythonName,
 
  765             raw_function([msg](tuple, dict) -> 
object {
 
  766                 throw std::invalid_argument(msg);
 
  774 template <
class Functor>
 
  775 inline typename std::enable_if<std::is_base_of<PythonMultidefFunctor, Functor>::value,
 
  777 multidef(
char const* python_name, Functor 
const & f)
 
  782 template <
class Functor, 
class Args>
 
  783 inline typename std::enable_if<std::is_base_of<PythonMultidefFunctor, Functor>::value,
 
  785 multidef(
char const* python_name, Functor 
const & f, Args 
const& args)
 
  787     f.def(python_name, args);
 
  790 template <
class Functor>
 
  791 inline typename std::enable_if<std::is_base_of<PythonMultidefFunctor, Functor>::value,
 
  793 multidef(
char const* python_name, Functor 
const & f, 
const char * help)
 
  795     f.def(python_name, help);
 
  798 template <
class Functor, 
class Args>
 
  799 inline typename std::enable_if<std::is_base_of<PythonMultidefFunctor, Functor>::value,
 
  801 multidef(
char const* python_name, Functor 
const & f, Args 
const& args, 
const char * help)
 
  803     f.def(python_name, args, help);
 
  807 template <
class Functor>
 
  808 inline typename std::enable_if<std::is_base_of<PythonMultidefFunctor, Functor>::value,
 
  810 def(
char const*, Functor 
const &)
 
  812     static_assert(!std::is_base_of<PythonMultidefFunctor, Functor>::value,
 
  813                   "def(): use multidef() to export multiple overloads.");
 
  816 template <
class Functor, 
class Args>
 
  817 inline typename std::enable_if<std::is_base_of<PythonMultidefFunctor, Functor>::value,
 
  819 def(
char const*, Functor 
const &, Args 
const& )
 
  821     static_assert(!std::is_base_of<PythonMultidefFunctor, Functor>::value,
 
  822                   "def(): use multidef() to export multiple overloads.");
 
  825 template <
class Functor>
 
  826 inline typename std::enable_if<std::is_base_of<PythonMultidefFunctor, Functor>::value,
 
  828 def(
char const*, Functor 
const &, 
const char *)
 
  830     static_assert(!std::is_base_of<PythonMultidefFunctor, Functor>::value,
 
  831                   "def(): use multidef() to export multiple overloads.");
 
  834 template <
class Functor, 
class Args>
 
  835 inline typename std::enable_if<std::is_base_of<PythonMultidefFunctor, Functor>::value,
 
  837 def(
char const*, Functor 
const &, Args 
const&, 
const char *)
 
  839     static_assert(!std::is_base_of<PythonMultidefFunctor, Functor>::value,
 
  840                   "def(): use multidef() to export multiple overloads.");
 
  845 #endif // VIGRA_NUMPY_ARRAY_CONVERTERS_HXX