36 #ifndef VIGRA_PYTHON_UTILITY_HXX 
   37 #define VIGRA_PYTHON_UTILITY_HXX 
   42 #include "vigra/error.hxx" 
   43 #include "vigra/tinyvector.hxx" 
   53 inline std::string dataFromPython(PyObject * data, 
const char * defaultVal);
 
   55 template <
class PYOBJECT_PTR>
 
   56 void pythonToCppException(PYOBJECT_PTR obj)
 
   60     PyObject * type, * value, * 
trace;
 
   61     PyErr_Fetch(&type, &value, &trace);
 
   64     std::string message(((PyTypeObject *)type)->tp_name);
 
   65     message += 
": " + dataFromPython(value, 
"<no error message>");
 
   69     throw std::runtime_error(message.c_str());
 
   85     typedef PyObject element_type;
 
   86     typedef PyObject value_type;
 
   87     typedef PyObject * pointer;
 
   88     typedef PyObject & reference;
 
   90     enum refcount_policy { increment_count, borrowed_reference = increment_count,
 
   91                            keep_count, new_reference = keep_count, new_nonzero_reference };
 
   93     explicit python_ptr(pointer p = 0, refcount_policy rp = increment_count)
 
   96         if(rp == increment_count)
 
  100         else if(rp == new_nonzero_reference)
 
  102             pythonToCppException(p);
 
  106     python_ptr(python_ptr 
const & p)
 
  112     python_ptr & operator=(pointer p)
 
  118     python_ptr & operator=(python_ptr 
const & r)
 
  129     void reset(pointer p = 0, refcount_policy rp = increment_count)
 
  133         if(rp == increment_count)
 
  137         else if(rp == new_nonzero_reference)
 
  139             pythonToCppException(p);
 
  145     pointer release(
bool return_borrowed_reference = 
false)
 
  149         if(return_borrowed_reference)
 
  156     reference operator* ()
 const 
  158         vigra_precondition(ptr_ != 0, 
"python_ptr::operator*(): Cannot dereference NULL pointer.");
 
  162     pointer operator-> ()
 const 
  164         vigra_precondition(ptr_ != 0, 
"python_ptr::operator->(): Cannot dereference NULL pointer.");
 
  178     operator pointer()
 const 
  183     bool operator! ()
 const 
  190         return ptr_ && ptr_->ob_refcnt == 1;
 
  193     void swap(python_ptr & other)
 
  195         std::swap(ptr_, other.ptr_);
 
  200         return ptr_ == p.ptr_;
 
  210         return ptr_ != p.ptr_;
 
  219 inline void swap(python_ptr & a, python_ptr & b)
 
  230 inline python_ptr pythonFromData(
bool t)
 
  232     return python_ptr(PyBool_FromLong(t ? 1 : 0), python_ptr::new_nonzero_reference);
 
  235 inline python_ptr pythonFromData(
char const * str)
 
  237 #if PY_MAJOR_VERSION < 3 
  238     return python_ptr(PyString_FromString(str), python_ptr::new_nonzero_reference);
 
  240     return python_ptr(PyUnicode_FromString(str), python_ptr::new_nonzero_reference);
 
  244 inline python_ptr pythonFromData(std::string 
const & str)
 
  246     return pythonFromData(str.c_str());
 
  249 #define VIGRA_PYTHON_FROM_DATA(type, fct, cast_type) \ 
  250 inline python_ptr pythonFromData(type t) \ 
  252     return python_ptr(fct((cast_type)t), python_ptr::new_nonzero_reference); \ 
  255 #if PY_MAJOR_VERSION < 3 
  256     VIGRA_PYTHON_FROM_DATA(
signed char, PyInt_FromLong, 
long)
 
  257     VIGRA_PYTHON_FROM_DATA(
unsigned char, PyInt_FromLong, 
long)
 
  258     VIGRA_PYTHON_FROM_DATA(
short, PyInt_FromLong, 
long)
 
  259     VIGRA_PYTHON_FROM_DATA(
unsigned short, PyInt_FromLong, 
long)
 
  260     VIGRA_PYTHON_FROM_DATA(
long, PyInt_FromLong, 
long)
 
  261     VIGRA_PYTHON_FROM_DATA(
unsigned long, PyInt_FromSize_t, 
size_t)
 
  262     VIGRA_PYTHON_FROM_DATA(
int, PyInt_FromSsize_t, Py_ssize_t)
 
  263     VIGRA_PYTHON_FROM_DATA(
unsigned int, PyInt_FromSize_t, 
size_t)
 
  264     VIGRA_PYTHON_FROM_DATA(
float, PyFloat_FromDouble, 
double)
 
  265     VIGRA_PYTHON_FROM_DATA(
double, PyFloat_FromDouble, 
double)
 
  267     VIGRA_PYTHON_FROM_DATA(
signed char, PyLong_FromLong, 
long)
 
  268     VIGRA_PYTHON_FROM_DATA(
unsigned char, PyLong_FromLong, 
long)
 
  269     VIGRA_PYTHON_FROM_DATA(
short, PyLong_FromLong, 
long)
 
  270     VIGRA_PYTHON_FROM_DATA(
unsigned short, PyLong_FromLong, 
long)
 
  271     VIGRA_PYTHON_FROM_DATA(
long, PyLong_FromLong, 
long)
 
  272     VIGRA_PYTHON_FROM_DATA(
unsigned long, PyLong_FromSize_t, 
size_t)
 
  273     VIGRA_PYTHON_FROM_DATA(
int, PyLong_FromSsize_t, Py_ssize_t)
 
  274     VIGRA_PYTHON_FROM_DATA(
unsigned int, PyLong_FromSize_t, 
size_t)
 
  275     VIGRA_PYTHON_FROM_DATA(
float, PyFloat_FromDouble, 
double)
 
  276     VIGRA_PYTHON_FROM_DATA(
double, PyFloat_FromDouble, 
double)
 
  278 #undef VIGRA_PYTHON_FROM_DATA 
  280 inline python_ptr pythonFromData(
long long t)
 
  282     if(t > (
long long)NumericTraits<long>::max() || t < (
long long)NumericTraits<long>::min())
 
  283         return python_ptr(PyLong_FromLongLong(t), python_ptr::new_nonzero_reference);
 
  285         return pythonFromData((
long)t);
 
  288 inline python_ptr pythonFromData(
unsigned long long t)
 
  290     if(t > (
unsigned long long)NumericTraits<long>::max())
 
  291         return python_ptr(PyLong_FromUnsignedLongLong(t), python_ptr::new_nonzero_reference);
 
  293         return pythonFromData((
long)t);
 
  302 #define VIGRA_DATA_FROM_PYTHON(type, check, extract) \ 
  303 inline type dataFromPython(PyObject * data, type const & defaultVal) \ 
  305     return data && check(data) \ 
  306              ? (type)extract(data) \ 
  310 #if PY_MAJOR_VERSION < 3 
  311     VIGRA_DATA_FROM_PYTHON(
signed char, PyInt_Check, PyInt_AsLong)
 
  312     VIGRA_DATA_FROM_PYTHON(
unsigned char, PyInt_Check, PyInt_AsLong)
 
  313     VIGRA_DATA_FROM_PYTHON(
short, PyInt_Check, PyInt_AsLong)
 
  314     VIGRA_DATA_FROM_PYTHON(
unsigned short, PyInt_Check, PyInt_AsLong)
 
  315     VIGRA_DATA_FROM_PYTHON(
long, PyInt_Check, PyInt_AsLong)
 
  316     VIGRA_DATA_FROM_PYTHON(
unsigned long, PyInt_Check, PyInt_AsUnsignedLongMask)
 
  317     VIGRA_DATA_FROM_PYTHON(
int, PyInt_Check, PyInt_AsLong)
 
  318     VIGRA_DATA_FROM_PYTHON(
unsigned int, PyInt_Check, PyInt_AsUnsignedLongMask)
 
  319     VIGRA_DATA_FROM_PYTHON(
long long, PyInt_Check, PyInt_AsSsize_t)
 
  320     VIGRA_DATA_FROM_PYTHON(
unsigned long long, PyInt_Check, PyInt_AsUnsignedLongLongMask)
 
  322     VIGRA_DATA_FROM_PYTHON(
signed char, PyLong_Check, PyLong_AsLong)
 
  323     VIGRA_DATA_FROM_PYTHON(
unsigned char, PyLong_Check, PyLong_AsLong)
 
  324     VIGRA_DATA_FROM_PYTHON(
short, PyLong_Check, PyLong_AsLong)
 
  325     VIGRA_DATA_FROM_PYTHON(
unsigned short, PyLong_Check, PyLong_AsLong)
 
  326     VIGRA_DATA_FROM_PYTHON(
long, PyLong_Check, PyLong_AsLong)
 
  327     VIGRA_DATA_FROM_PYTHON(
unsigned long, PyLong_Check, PyLong_AsUnsignedLongMask)
 
  328     VIGRA_DATA_FROM_PYTHON(
int, PyLong_Check, PyLong_AsLong)
 
  329     VIGRA_DATA_FROM_PYTHON(
unsigned int, PyLong_Check, PyLong_AsUnsignedLongMask)
 
  330     VIGRA_DATA_FROM_PYTHON(
long long, PyLong_Check, PyLong_AsSsize_t)
 
  331     VIGRA_DATA_FROM_PYTHON(
unsigned long long, PyLong_Check, PyLong_AsUnsignedLongLongMask)
 
  333 VIGRA_DATA_FROM_PYTHON(
float, PyFloat_Check, PyFloat_AsDouble)
 
  334 VIGRA_DATA_FROM_PYTHON(
double, PyFloat_Check, PyFloat_AsDouble)
 
  336 inline std::
string dataFromPython(PyObject * data, const 
char * defaultVal)
 
  338 #if PY_MAJOR_VERSION < 3 
  339     return data && PyString_Check(data)
 
  340         ? std::string(PyString_AsString(data))
 
  342     python_ptr ascii(PyUnicode_AsASCIIString(data), python_ptr::keep_count);
 
  343     return data && PyBytes_Check(ascii)
 
  344         ? std::string(PyBytes_AsString(ascii))
 
  346         : std::string(defaultVal);
 
  349 inline std::string dataFromPython(PyObject * data, std::string 
const & defaultVal)
 
  351 #if PY_MAJOR_VERSION < 3 
  352     return data && PyString_Check(data)
 
  353         ? std::string(PyString_AsString(data))
 
  355     python_ptr ascii(PyUnicode_AsASCIIString(data), python_ptr::keep_count);
 
  356     return data && PyBytes_Check(ascii)
 
  357         ? std::string(PyBytes_AsString(ascii))
 
  362 inline python_ptr dataFromPython(PyObject * data, python_ptr defaultVal)
 
  369 #undef VIGRA_DATA_FROM_PYTHON 
  378 T pythonGetAttr(PyObject * obj, 
const char * key, T defaultValue)
 
  382     python_ptr k(pythonFromData(key));
 
  383     pythonToCppException(k);
 
  384     python_ptr pres(PyObject_GetAttr(obj, k), python_ptr::keep_count);
 
  387     return dataFromPython(pres, defaultValue);
 
  391 pythonGetAttr(PyObject * obj, 
const char * key, 
const char * defaultValue)
 
  394         return std::string(defaultValue);
 
  395     python_ptr k(pythonFromData(key));
 
  396     pythonToCppException(k);
 
  397     python_ptr pres(PyObject_GetAttr(obj, k), python_ptr::keep_count);
 
  400     return dataFromPython(pres, defaultValue);
 
  406 makePythonDictionary(
char const * k1 = 0, PyObject * a1 = 0,
 
  407                     char const * k2 = 0, PyObject * a2 = 0,
 
  408                     char const * k3 = 0, PyObject * a3 = 0)
 
  410     python_ptr dict(PyDict_New(), python_ptr::new_nonzero_reference);
 
  412         PyDict_SetItemString(dict, k1, a1);
 
  414         PyDict_SetItemString(dict, k2, a2);
 
  416         PyDict_SetItemString(dict, k3, a3);
 
  422 template <
class T, 
int N>
 
  423 python_ptr shapeToPythonTuple(TinyVector<T, N> 
const & shape)
 
  425     python_ptr tuple(PyTuple_New(N), python_ptr::keep_count);
 
  426     pythonToCppException(tuple);
 
  427     for(
unsigned int k=0; k<N; ++k)
 
  429         PyTuple_SET_ITEM((PyTupleObject *)tuple.get(), k, pythonFromData(shape[k]).release());
 
  435 python_ptr shapeToPythonTuple(ArrayVectorView<T> 
const & shape)
 
  437     python_ptr tuple(PyTuple_New(shape.size()), python_ptr::keep_count);
 
  438     pythonToCppException(tuple);
 
  439     for(
unsigned int k=0; k<shape.size(); ++k)
 
  441         PyTuple_SET_ITEM((PyTupleObject *)tuple.get(), k, pythonFromData(shape[k]).release());
 
  450     PyThreadState * save_;
 
  453     PyAllowThreads(PyAllowThreads 
const &);
 
  454     PyAllowThreads & operator=(PyAllowThreads 
const &);
 
  458     : save_(PyEval_SaveThread())
 
  463         PyEval_RestoreThread(save_);
 
  469 #endif  // VIGRA_PYTHON_UTILITY_HXX 
NumericTraits< T >::Promote trace(MultiArrayView< 2, T, C > const &m)
Definition: matrix.hxx:801
bool operator!=(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
not equal 
Definition: fftw3.hxx:841
bool operator==(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
equal 
Definition: fftw3.hxx:825