Merge lp:~xnox/ubuntu/quantal/libvigraimpex/boost1.49 into lp:ubuntu/quantal/libvigraimpex

[Dimitri John Ledkov]

This merges libvigraimpex from debian.
Barry, can you please review this package as it has interesting history and you were the last one to merge it.

[Barry Warsaw (barry)]

On Jun 14, 2012, at 08:30 PM, Dmitrijs Ledkovs wrote:

>Barry, can you please review this package as it has interesting history and
>you were the last one to merge it.

What a mess! Sigh. Just one thing stands out.

=== modified file 'include/vigra/box.hxx'
--- include/vigra/box.hxx 2011-02-20 23:21:40 +0000
+++ include/vigra/box.hxx 2012-06-14 20:29:21 +0000
> @@ -388,7 +388,7 @@
> if(r.isEmpty())
> return *this;
> if(isEmpty())
> - return operator=(r);
> + return this->operator=(r);
>
> for(unsigned int i = 0; i < DIMENSION; ++i)
> {
> @@ -421,7 +421,7 @@
> if(isEmpty())
> return *this;
> if(r.isEmpty())
> - return operator=(r);
> + return this->operator=(r);
>
> for(unsigned int i = 0; i < DIMENSION; ++i)
> {

=== modified file 'include/vigra/random_forest/rf_ridge_split.hxx'
[...]

Why are these being modified in the source tree? Is this just quilt/bzr
artifacts? Does it actually build with these changes? Are they in a quilt
patch?

[Dimitri John Ledkov (xnox)]

On 14/06/12 21:49, Barry Warsaw wrote:
> On Jun 14, 2012, at 08:30 PM, Dmitrijs Ledkovs wrote:
>
>> Barry, can you please review this package as it has interesting history and
>> you were the last one to merge it.
>
> What a mess! Sigh. Just one thing stands out.
>
>
> === modified file 'include/vigra/box.hxx'
> === modified file 'include/vigra/random_forest/rf_ridge_split.hxx'
>
> Why are these being modified in the source tree? Is this just quilt/bzr
> artifacts? Does it actually build with these changes? Are they in a quilt
> patch?
>

That is the new fix-ftbfs-gcc4.7.patch from doko, introduced in debian.
That's the reason why I'm merging this =)

Because it's a new patch you get: .pc/ & in tree modifications & an
extra patch in debian/patches/.

=/

--
Regards,
Dmitrijs.

[Barry Warsaw (barry)]

On Jun 14, 2012, at 09:55 PM, Dmitrijs Ledkovs wrote:

>Because it's a new patch you get: .pc/ & in tree modifications & an
>extra patch in debian/patches/.

:(

[Dimitri John Ledkov (xnox)]

On 14/06/12 22:02, Barry Warsaw wrote:
> On Jun 14, 2012, at 09:55 PM, Dmitrijs Ledkovs wrote:
>
>> Because it's a new patch you get: .pc/ & in tree modifications & an
>> extra patch in debian/patches/.
>
> :(
>

Will you sponsor this? =)

--
Regards,
Dmitrijs.

[Barry Warsaw (barry)]

On Jun 14, 2012, at 09:25 PM, Dmitrijs Ledkovs wrote:

>On 14/06/12 22:02, Barry Warsaw wrote:
>> On Jun 14, 2012, at 09:55 PM, Dmitrijs Ledkovs wrote:
>>
>>> Because it's a new patch you get: .pc/ & in tree modifications & an
>>> extra patch in debian/patches/.
>>
>> :(
>>
>
>Will you sponsor this? =)

Sure, if it builds locally for me. :)

[Dimitri John Ledkov (xnox)]

On 14/06/12 23:05, Barry Warsaw wrote:
> On Jun 14, 2012, at 09:25 PM, Dmitrijs Ledkovs wrote:
>
>> On 14/06/12 22:02, Barry Warsaw wrote:
>>> On Jun 14, 2012, at 09:55 PM, Dmitrijs Ledkovs wrote:
>>>
>>>> Because it's a new patch you get: .pc/ & in tree modifications & an
>>>> extra patch in debian/patches/.
>>>
>>> :(
>>>
>>
>> Will you sponsor this? =)
>
> Sure, if it builds locally for me. :)
>

I take it, it's still building ;-)
--
Regards,
Dmitrijs.

[Barry Warsaw (barry)]

On Jun 14, 2012, at 11:08 PM, Dmitrijs Ledkovs wrote:

>I take it, it's still building ;-)

chugga chugga :)

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2011-11-08 19:31:51 +0000
+++ .pc/applied-patches	2012-06-14 20:29:21 +0000
@@ -8,6 +8,6 @@
 fix-ftbfs-gcc4.6.diff
 fix-convolutiontest.diff
 libpng15
+fix-ftbfs-gcc4.7.diff
 no-hdf5.diff
 debian-changes-1.7.1+dfsg1-2ubuntu1
-sizeof_ldbl_not_sizeof_dbl.diff

=== removed file '.pc/debian-changes-1.7.1+dfsg1-2ubuntu1/include/vigra/numpy_array.hxx'
--- .pc/debian-changes-1.7.1+dfsg1-2ubuntu1/include/vigra/numpy_array.hxx	2011-10-20 09:30:45 +0000
+++ .pc/debian-changes-1.7.1+dfsg1-2ubuntu1/include/vigra/numpy_array.hxx	1970-01-01 00:00:00 +0000
@@ -1,1922 +0,0 @@
-/************************************************************************/
-/*                                                                      */
-/*       Copyright 2009 by Ullrich Koethe and Hans Meine                */
-/*                                                                      */
-/*    This file is part of the VIGRA computer vision library.           */
-/*    The VIGRA Website is                                              */
-/*        http://hci.iwr.uni-heidelberg.de/vigra/                       */
-/*    Please direct questions, bug reports, and contributions to        */
-/*        [e-mail]    or                    */
-/*        [e-mail]                               */
-/*                                                                      */
-/*    Permission is hereby granted, free of charge, to any person       */
-/*    obtaining a copy of this software and associated documentation    */
-/*    files (the "Software"), to deal in the Software without           */
-/*    restriction, including without limitation the rights to use,      */
-/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
-/*    sell copies of the Software, and to permit persons to whom the    */
-/*    Software is furnished to do so, subject to the following          */
-/*    conditions:                                                       */
-/*                                                                      */
-/*    The above copyright notice and this permission notice shall be    */
-/*    included in all copies or substantial portions of the             */
-/*    Software.                                                         */
-/*                                                                      */
-/*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
-/*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
-/*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
-/*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
-/*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
-/*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
-/*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
-/*    OTHER DEALINGS IN THE SOFTWARE.                                   */
-/*                                                                      */
-/************************************************************************/
-
-#ifndef VIGRA_NUMPY_ARRAY_HXX
-#define VIGRA_NUMPY_ARRAY_HXX
-
-#include <Python.h>
-#include <iostream>
-#include <algorithm>
-#include <complex>
-#include <string>
-#include <sstream>
-#include <map>
-#include <vigra/multi_array.hxx>
-#include <vigra/array_vector.hxx>
-#include <vigra/sized_int.hxx>
-#include <vigra/python_utility.hxx>
-#include <numpy/arrayobject.h>
-
-int _import_array();
-
-namespace vigra {
-
-/********************************************************/
-/*                                                      */
-/*              Singleband and Multiband                */
-/*                                                      */
-/********************************************************/
-
-typedef float NumpyValueType;
-
-template <class T>
-struct Singleband  // the last array dimension is not to be interpreted as a channel dimension
-{
-    typedef T value_type;
-};
-
-template <class T>
-struct Multiband  // the last array dimension is a channel dimension
-{
-    typedef T value_type;
-};
-
-template<class T>
-struct NumericTraits<Singleband<T> >
-: public NumericTraits<T>
-{};
-
-template<class T>
-struct NumericTraits<Multiband<T> >
-{
-    typedef Multiband<T> Type;
-/*
-    typedef int Promote;
-    typedef unsigned int UnsignedPromote;
-    typedef double RealPromote;
-    typedef std::complex<RealPromote> ComplexPromote;
-*/
-    typedef Type ValueType;
-
-    typedef typename NumericTraits<T>::isIntegral isIntegral;
-    typedef VigraFalseType isScalar;
-    typedef typename NumericTraits<T>::isSigned isSigned;
-    typedef typename NumericTraits<T>::isSigned isOrdered;
-    typedef typename NumericTraits<T>::isSigned isComplex;
-/*
-    static signed char zero() { return 0; }
-    static signed char one() { return 1; }
-    static signed char nonZero() { return 1; }
-    static signed char min() { return SCHAR_MIN; }
-    static signed char max() { return SCHAR_MAX; }
-
-#ifdef NO_INLINE_STATIC_CONST_DEFINITION
-    enum { minConst = SCHAR_MIN, maxConst = SCHAR_MIN };
-#else
-    static const signed char minConst = SCHAR_MIN;
-    static const signed char maxConst = SCHAR_MIN;
-#endif
-
-    static Promote toPromote(signed char v) { return v; }
-    static RealPromote toRealPromote(signed char v) { return v; }
-    static signed char fromPromote(Promote v) {
-        return ((v < SCHAR_MIN) ? SCHAR_MIN : (v > SCHAR_MAX) ? SCHAR_MAX : v);
-    }
-    static signed char fromRealPromote(RealPromote v) {
-        return ((v < 0.0)
-                   ? ((v < (RealPromote)SCHAR_MIN)
-                       ? SCHAR_MIN
-                       : static_cast<signed char>(v - 0.5))
-                   : (v > (RealPromote)SCHAR_MAX)
-                       ? SCHAR_MAX
-                       : static_cast<signed char>(v + 0.5));
-    }
-*/
-};
-
-template <class T>
-class MultibandVectorAccessor
-{
-    MultiArrayIndex size_, stride_;
-
-  public:
-    MultibandVectorAccessor(MultiArrayIndex size, MultiArrayIndex stride)
-    : size_(size),
-      stride_(stride)
-    {}
-
-
-    typedef Multiband<T> value_type;
-
-        /** the vector's value_type
-        */
-    typedef T component_type;
-
-    typedef VectorElementAccessor<MultibandVectorAccessor<T> > ElementAccessor;
-
-        /** Read the component data at given vector index
-            at given iterator position
-        */
-    template <class ITERATOR>
-    component_type const & getComponent(ITERATOR const & i, int idx) const
-    {
-        return *(&*i+idx*stride_);
-    }
-
-        /** Set the component data at given vector index
-            at given iterator position. The type <TT>V</TT> of the passed
-            in <TT>value</TT> is automatically converted to <TT>component_type</TT>.
-            In case of a conversion floating point -> intergral this includes rounding and clipping.
-        */
-    template <class V, class ITERATOR>
-    void setComponent(V const & value, ITERATOR const & i, int idx) const
-    {
-        *(&*i+idx*stride_) = detail::RequiresExplicitCast<component_type>::cast(value);
-    }
-
-        /** Read the component data at given vector index
-            at an offset of given iterator position
-        */
-    template <class ITERATOR, class DIFFERENCE>
-    component_type const & getComponent(ITERATOR const & i, DIFFERENCE const & diff, int idx) const
-    {
-        return *(&i[diff]+idx*stride_);
-    }
-
-    /** Set the component data at given vector index
-        at an offset of given iterator position. The type <TT>V</TT> of the passed
-        in <TT>value</TT> is automatically converted to <TT>component_type</TT>.
-            In case of a conversion floating point -> intergral this includes rounding and clipping.
-    */
-    template <class V, class ITERATOR, class DIFFERENCE>
-    void
-    setComponent(V const & value, ITERATOR const & i, DIFFERENCE const & diff, int idx) const
-    {
-        *(&i[diff]+idx*stride_) = detail::RequiresExplicitCast<component_type>::cast(value);
-    }
-
-    template <class U>
-    MultiArrayIndex size(U) const
-    {
-        return size_;
-    }
-};
-
-/********************************************************/
-/*                                                      */
-/*                a few Python utilities                */
-/*                                                      */
-/********************************************************/
-
-namespace detail {
-
-inline long spatialDimensions(PyObject * obj)
-{
-    static python_ptr key(PyString_FromString("spatialDimensions"), python_ptr::keep_count);
-    python_ptr pres(PyObject_GetAttr(obj, key), python_ptr::keep_count);
-    long res = pres && PyInt_Check(pres)
-                 ? PyInt_AsLong(pres)
-                 : -1;
-    return res;
-}
-
-/*
- * The registry is used to optionally map specific C++ types to
- * specific python sub-classes of numpy.ndarray (for example,
- * MultiArray<2, Singleband<int> > to a user-defined Python class 'ScalarImage').
- *
- * One needs to use NUMPY_ARRAY_INITIALIZE_REGISTRY once in a python
- * extension module using this technique, in order to actually provide
- * the registry (this is done by vigranumpycmodule and will then be
- * available for other modules, too).  Alternatively,
- * NUMPY_ARRAY_DUMMY_REGISTRY may be used to disable this feature
- * completely.  In both cases, the macro must not be enclosed by any
- * namespace, so it is best put right at the beginning of the file
- * (e.g. below the #includes).
- */
-
-typedef std::map<std::string, std::pair<python_ptr, python_ptr> > ArrayTypeMap;
-
-VIGRA_EXPORT ArrayTypeMap * getArrayTypeMap();
-
-#define NUMPY_ARRAY_INITIALIZE_REGISTRY                                 \
-    namespace vigra { namespace detail {                                \
-    ArrayTypeMap * getArrayTypeMap()                                    \
-    {                                                                   \
-        static ArrayTypeMap arrayTypeMap;                               \
-        return &arrayTypeMap;                                           \
-    }                                                                   \
-    }} // namespace vigra::detail
-
-#define NUMPY_ARRAY_DUMMY_REGISTRY                      \
-    namespace vigra { namespace detail {                \
-    ArrayTypeMap * getArrayTypeMap()                    \
-    {                                                   \
-        return NULL;                                    \
-    }                                                   \
-    }} // namespace vigra::detail
-
-inline
-void registerPythonArrayType(std::string const & name, PyObject * obj, PyObject * typecheck)
-{
-    ArrayTypeMap *types = getArrayTypeMap();
-    vigra_precondition(
-        types != NULL,
-        "registerPythonArrayType(): module was compiled without array type registry.");
-    vigra_precondition(
-        obj && PyType_Check(obj) && PyType_IsSubtype((PyTypeObject *)obj, &PyArray_Type),
-        "registerPythonArrayType(obj): obj is not a subtype of numpy.ndarray.");
-    if(typecheck && PyCallable_Check(typecheck))
-        (*types)[name] = std::make_pair(python_ptr(obj), python_ptr(typecheck));
-    else
-        (*types)[name] = std::make_pair(python_ptr(obj), python_ptr());
-//    std::cerr << "Registering " << ((PyTypeObject *)obj)->tp_name << " for " << name << "\n";
-}
-
-inline
-python_ptr getArrayTypeObject(std::string const & name, PyTypeObject * def = 0)
-{
-    ArrayTypeMap *types = getArrayTypeMap();
-    if(!types)
-        // dummy registry -> handle like empty registry
-        return python_ptr((PyObject *)def);
-
-    python_ptr res;
-    ArrayTypeMap::iterator i = types->find(name);
-    if(i != types->end())
-        res = i->second.first;
-    else
-        res = python_ptr((PyObject *)def);
-//    std::cerr << "Requested " << name << ", got " << ((PyTypeObject *)res.get())->tp_name << "\n";
-    return res;
-}
-
-// there are two cases for the return:
-// * if a typecheck function was registered, it is returned
-// * a null pointer is returned if nothing was registered for either key, or if
-//   a type was registered without typecheck function
-inline python_ptr
-getArrayTypecheckFunction(std::string const & keyFull, std::string const & key)
-{
-    python_ptr res;
-    ArrayTypeMap *types = getArrayTypeMap();
-    if(types)
-    {
-        ArrayTypeMap::iterator i = types->find(keyFull);
-        if(i == types->end())
-            i = types->find(key);
-        if(i != types->end())
-            res = i->second.second;
-    }
-    return res;
-}
-
-inline bool
-performCustomizedArrayTypecheck(PyObject * obj, std::string const & keyFull, std::string const & key)
-{
-    if(obj == 0 || !PyArray_Check(obj))
-        return false;
-    python_ptr typecheck = getArrayTypecheckFunction(keyFull, key);
-    if(typecheck == 0)
-        return true; // no custom test registered
-    python_ptr args(PyTuple_Pack(1, obj), python_ptr::keep_count);
-    pythonToCppException(args);
-    python_ptr res(PyObject_Call(typecheck.get(), args.get(), 0), python_ptr::keep_count);
-    pythonToCppException(res);
-    vigra_precondition(PyBool_Check(res),
-           "NumpyArray conversion: registered typecheck function did not return a boolean.");
-    return (void*)res.get() == (void*)Py_True;
-}
-
-inline
-python_ptr constructNumpyArrayImpl(
-    PyTypeObject * type,
-    ArrayVector<npy_intp> const & shape, npy_intp *strides,
-    NPY_TYPES typeCode, bool init)
-{
-    python_ptr array;
-
-    if(strides == 0)
-    {
-        array = python_ptr(PyArray_New(type, shape.size(), (npy_intp *)shape.begin(), typeCode, 0, 0, 0, 1 /* Fortran order */, 0),
-                           python_ptr::keep_count);
-    }
-    else
-    {
-        int N = shape.size();
-        ArrayVector<npy_intp> pshape(N);
-        for(int k=0; k<N; ++k)
-            pshape[strides[k]] = shape[k];
-
-        array = python_ptr(PyArray_New(type, N, pshape.begin(), typeCode, 0, 0, 0, 1 /* Fortran order */, 0),
-                           python_ptr::keep_count);
-        pythonToCppException(array);
-
-        PyArray_Dims permute = { strides, N };
-        array = python_ptr(PyArray_Transpose((PyArrayObject*)array.get(), &permute), python_ptr::keep_count);
-    }
-    pythonToCppException(array);
-
-    if(init)
-        PyArray_FILLWBYTE((PyArrayObject *)array.get(), 0);
-
-    return array;
-}
-
-// strideOrdering will be ignored unless order == "A"
-// TODO: this function should receive some refactoring in order to make
-//       the rules clear from the code rather than from comments
-inline python_ptr
-constructNumpyArrayImpl(PyTypeObject * type, ArrayVector<npy_intp> const & shape,
-                       unsigned int spatialDimensions, unsigned int channels,
-                       NPY_TYPES typeCode, std::string order, bool init,
-                       ArrayVector<npy_intp> strideOrdering = ArrayVector<npy_intp>())
-{
-    // shape must have at least length spatialDimensions, but can also have a channel dimension
-    vigra_precondition(shape.size() == spatialDimensions || shape.size() == spatialDimensions + 1,
-           "constructNumpyArray(type, shape, ...): shape has wrong length.");
-
-    // if strideOrdering is given, it must have at least length spatialDimensions,
-    // but can also have a channel dimension
-    vigra_precondition(strideOrdering.size() == 0 || strideOrdering.size() == spatialDimensions ||
-                       strideOrdering.size() == spatialDimensions + 1,
-           "constructNumpyArray(type, ..., strideOrdering): strideOrdering has wrong length.");
-
-    if(channels == 0) // if the requested number of channels is not given ...
-    {
-        // ... deduce it
-        if(shape.size() == spatialDimensions)
-            channels = 1;
-        else
-            channels = shape.back();
-    }
-    else
-    {
-        // otherwise, if the shape object also contains a channel dimension, they must be consistent
-        if(shape.size() > spatialDimensions)
-            vigra_precondition(channels == (unsigned int)shape[spatialDimensions],
-                   "constructNumpyArray(type, ...): shape contradicts requested number of channels.");
-    }
-
-    // if we have only one channel, no explicit channel dimension should be in the shape
-    unsigned int shapeSize = channels == 1
-                                  ? spatialDimensions
-                                  : spatialDimensions + 1;
-
-    // create the shape object with optional channel dimension
-    ArrayVector<npy_intp> pshape(shapeSize);
-    std::copy(shape.begin(), shape.begin()+std::min(shape.size(), pshape.size()), pshape.begin());
-    if(shapeSize > spatialDimensions)
-        pshape[spatialDimensions] = channels;
-
-    // order "A" means "preserve order" when an array is copied, and
-    // defaults to "V" when a new array is created without explicit strideOrdering
-    //
-    if(order == "A")
-    {
-        if(strideOrdering.size() == 0)
-        {
-            order = "V";
-        }
-        else if(strideOrdering.size() > shapeSize)
-        {
-            // make sure that strideOrdering length matches shape length
-            ArrayVector<npy_intp> pstride(strideOrdering.begin(), strideOrdering.begin()+shapeSize);
-
-            // adjust the ordering when the channel dimension has been dropped because channel == 1
-            if(strideOrdering[shapeSize] == 0)
-                for(unsigned int k=0; k<shapeSize; ++k)
-                    pstride[k] -= 1;
-            pstride.swap(strideOrdering);
-        }
-        else if(strideOrdering.size() < shapeSize)
-        {
-            // make sure that strideOrdering length matches shape length
-            ArrayVector<npy_intp> pstride(shapeSize);
-
-            // adjust the ordering when the channel dimension has been dropped because channel == 1
-            for(unsigned int k=0; k<shapeSize-1; ++k)
-                pstride[k] = strideOrdering[k] + 1;
-            pstride[shapeSize-1] = 0;
-            pstride.swap(strideOrdering);
-        }
-    }
-
-    // create the appropriate strideOrdering objects for the other memory orders
-    // (when strideOrdering already contained data, it is ignored because order != "A")
-    if(order == "C")
-    {
-        strideOrdering.resize(shapeSize);
-        for(unsigned int k=0; k<shapeSize; ++k)
-            strideOrdering[k] = shapeSize-1-k;
-    }
-    else if(order == "F" || (order == "V" && channels == 1))
-    {
-        strideOrdering.resize(shapeSize);
-        for(unsigned int k=0; k<shapeSize; ++k)
-            strideOrdering[k] = k;
-    }
-    else if(order == "V")
-    {
-        strideOrdering.resize(shapeSize);
-        for(unsigned int k=0; k<shapeSize-1; ++k)
-            strideOrdering[k] = k+1;
-        strideOrdering[shapeSize-1] = 0;
-    }
-
-    return constructNumpyArrayImpl(type, pshape, strideOrdering.begin(), typeCode, init);
-}
-
-template <class TINY_VECTOR>
-inline
-python_ptr constructNumpyArrayFromData(
-    std::string const & typeKeyFull,
-    std::string const & typeKey,
-    TINY_VECTOR const & shape, npy_intp *strides,
-    NPY_TYPES typeCode, void *data)
-{
-    ArrayVector<npy_intp> pyShape(shape.begin(), shape.end());
-
-    python_ptr type = detail::getArrayTypeObject(typeKeyFull);
-    if(type == 0)
-        type = detail::getArrayTypeObject(typeKey, &PyArray_Type);
-
-    python_ptr array(PyArray_New((PyTypeObject *)type.ptr(), shape.size(), pyShape.begin(), typeCode, strides, data, 0, NPY_WRITEABLE, 0),
-                     python_ptr::keep_count);
-    pythonToCppException(array);
-
-    return array;
-}
-
-
-} // namespace detail
-
-/********************************************************/
-/*                                                      */
-/*               NumpyArrayValuetypeTraits              */
-/*                                                      */
-/********************************************************/
-
-template<class ValueType>
-struct ERROR_NumpyArrayValuetypeTraits_not_specialized_for_ { };
-
-template<class ValueType>
-struct NumpyArrayValuetypeTraits
-{
-    static bool isValuetypeCompatible(PyArrayObject const * obj)
-    {
-        return ERROR_NumpyArrayValuetypeTraits_not_specialized_for_<ValueType>();
-    }
-
-    static ERROR_NumpyArrayValuetypeTraits_not_specialized_for_<ValueType> typeCode;
-
-    static std::string typeName()
-    {
-        return std::string("ERROR: NumpyArrayValuetypeTraits not specialized for this case");
-    }
-
-    static std::string typeNameImpex()
-    {
-        return std::string("ERROR: NumpyArrayValuetypeTraits not specialized for this case");
-    }
-
-    static PyObject * typeObject()
-    {
-        return (PyObject *)0;
-    }
-};
-
-template<class ValueType>
-ERROR_NumpyArrayValuetypeTraits_not_specialized_for_<ValueType> NumpyArrayValuetypeTraits<ValueType>::typeCode;
-
-#define VIGRA_NUMPY_VALUETYPE_TRAITS(type, typeID, numpyTypeName, impexTypeName) \
-template <> \
-struct NumpyArrayValuetypeTraits<type > \
-{ \
-    static bool isValuetypeCompatible(PyArrayObject const * obj) /* obj must not be NULL */ \
-    { \
-        return PyArray_EquivTypenums(typeID, PyArray_DESCR((PyObject *)obj)->type_num) && \
-               PyArray_ITEMSIZE((PyObject *)obj) == sizeof(type); \
-    } \
-    \
-    static NPY_TYPES const typeCode = typeID; \
-    \
-    static std::string typeName() \
-    { \
-        return #numpyTypeName; \
-    } \
-    \
-    static std::string typeNameImpex() \
-    { \
-        return impexTypeName; \
-    } \
-    \
-    static PyObject * typeObject() \
-    { \
-        return PyArray_TypeObjectFromType(typeID); \
-    } \
-};
-
-VIGRA_NUMPY_VALUETYPE_TRAITS(bool,           NPY_BOOL, bool, "UINT8")
-VIGRA_NUMPY_VALUETYPE_TRAITS(signed char,    NPY_INT8, int8, "INT16")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned char,  NPY_UINT8, uint8, "UINT8")
-VIGRA_NUMPY_VALUETYPE_TRAITS(short,          NPY_INT16, int16, "INT16")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned short, NPY_UINT16, uint16, "UINT16")
-
-#if VIGRA_BITSOF_LONG == 32
-VIGRA_NUMPY_VALUETYPE_TRAITS(long,           NPY_INT32, int32, "INT32")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned long,  NPY_UINT32, uint32, "UINT32")
-#elif VIGRA_BITSOF_LONG == 64
-VIGRA_NUMPY_VALUETYPE_TRAITS(long,           NPY_INT64, int64, "DOUBLE")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned long,  NPY_UINT64, uint64, "DOUBLE")
-#endif
-
-#if VIGRA_BITSOF_INT == 32
-VIGRA_NUMPY_VALUETYPE_TRAITS(int,            NPY_INT32, int32, "INT32")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned int,   NPY_UINT32, uint32, "UINT32")
-#elif VIGRA_BITSOF_INT == 64
-VIGRA_NUMPY_VALUETYPE_TRAITS(int,            NPY_INT64, int64, "DOUBLE")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned int,   NPY_UINT64, uint64, "DOUBLE")
-#endif
-
-#ifdef PY_LONG_LONG
-# if VIGRA_BITSOF_LONG_LONG == 32
-VIGRA_NUMPY_VALUETYPE_TRAITS(long long,            NPY_INT32, int32, "INT32")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned long long,   NPY_UINT32, uint32, "UINT32")
-# elif VIGRA_BITSOF_LONG_LONG == 64
-VIGRA_NUMPY_VALUETYPE_TRAITS(long long,          NPY_INT64, int64, "DOUBLE")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned long long, NPY_UINT64, uint64, "DOUBLE")
-# endif
-#endif
-
-VIGRA_NUMPY_VALUETYPE_TRAITS(npy_float32, NPY_FLOAT32, float32, "FLOAT")
-VIGRA_NUMPY_VALUETYPE_TRAITS(npy_float64, NPY_FLOAT64, float64, "DOUBLE")
-#if NPY_SIZEOF_LONGDOUBLE != NPY_SIZEOF_DOUBLE
-VIGRA_NUMPY_VALUETYPE_TRAITS(npy_longdouble, NPY_LONGDOUBLE, longdouble, "")
-#endif
-VIGRA_NUMPY_VALUETYPE_TRAITS(npy_cfloat, NPY_CFLOAT, complex64, "")
-VIGRA_NUMPY_VALUETYPE_TRAITS(std::complex<npy_float>, NPY_CFLOAT, complex64, "")
-VIGRA_NUMPY_VALUETYPE_TRAITS(npy_cdouble, NPY_CDOUBLE, complex128, "")
-VIGRA_NUMPY_VALUETYPE_TRAITS(std::complex<npy_double>, NPY_CDOUBLE, complex128, "")
-VIGRA_NUMPY_VALUETYPE_TRAITS(npy_clongdouble, NPY_CLONGDOUBLE, clongdouble, "")
-#if NPY_SIZEOF_LONGDOUBLE != NPY_SIZEOF_DOUBLE
-VIGRA_NUMPY_VALUETYPE_TRAITS(std::complex<npy_longdouble>, NPY_CLONGDOUBLE, clongdouble, "")
-#endif
-
-#undef VIGRA_NUMPY_VALUETYPE_TRAITS
-
-/********************************************************/
-/*                                                      */
-/*                  NumpyArrayTraits                    */
-/*                                                      */
-/********************************************************/
-
-template <class U, int N>
-bool stridesAreAscending(TinyVector<U, N> const & strides)
-{
-    for(int k=1; k<N; ++k)
-        if(strides[k] < strides[k-1])
-            return false;
-    return true;
-}
-
-template<unsigned int N, class T, class Stride>
-struct NumpyArrayTraits;
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, T, StridedArrayTag>
-{
-    typedef T dtype;
-    typedef T value_type;
-    typedef NumpyArrayValuetypeTraits<T> ValuetypeTraits;
-    static NPY_TYPES const typeCode = ValuetypeTraits::typeCode;
-
-    enum { spatialDimensions = N, channels = 1 };
-
-    static bool isArray(PyObject * obj)
-    {
-        return obj && PyArray_Check(obj);
-    }
-
-    static bool isClassCompatible(PyObject * obj)
-    {
-        return detail::performCustomizedArrayTypecheck(obj, typeKeyFull(), typeKey());
-    }
-
-    static bool isValuetypeCompatible(PyArrayObject * obj)  /* obj must not be NULL */
-    {
-        return ValuetypeTraits::isValuetypeCompatible(obj);
-    }
-
-    static bool isShapeCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return PyArray_NDIM((PyObject *)obj) == N-1 ||
-               PyArray_NDIM((PyObject *)obj) == N ||
-               (PyArray_NDIM((PyObject *)obj) == N+1 && PyArray_DIM((PyObject *)obj, N) == 1);
-    }
-
-    static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return ValuetypeTraits::isValuetypeCompatible(obj) &&
-               isShapeCompatible(obj);
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N> npyStride(stride * sizeof(T));
-        return detail::constructNumpyArrayFromData(typeKeyFull(), typeKey(), shape, npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKey()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", *>";
-        return key;
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", " +
-                                 ValuetypeTraits::typeName() + ", StridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, T, UnstridedArrayTag>
-: public NumpyArrayTraits<N, T, StridedArrayTag>
-{
-    typedef NumpyArrayTraits<N, T, StridedArrayTag> BaseType;
-    typedef typename BaseType::ValuetypeTraits ValuetypeTraits;
-
-    static bool isShapeCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return BaseType::isShapeCompatible(obj) &&
-               PyArray_STRIDES((PyObject *)obj)[0] == PyArray_ITEMSIZE((PyObject *)obj);
-    }
-
-    static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return BaseType::isValuetypeCompatible(obj) &&
-               isShapeCompatible(obj);
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N> npyStride(stride * sizeof(T));
-        return detail::constructNumpyArrayFromData(typeKeyFull(), BaseType::typeKey(), shape, npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", " +
-                                 ValuetypeTraits::typeName() + ", UnstridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, Singleband<T>, StridedArrayTag>
-: public NumpyArrayTraits<N, T, StridedArrayTag>
-{
-    typedef NumpyArrayTraits<N, T, StridedArrayTag> BaseType;
-    typedef typename BaseType::ValuetypeTraits ValuetypeTraits;
-
-    static bool isClassCompatible(PyObject * obj)
-    {
-        return detail::performCustomizedArrayTypecheck(obj, typeKeyFull(), typeKey());
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N> npyStride(stride * sizeof(T));
-        return detail::constructNumpyArrayFromData(typeKeyFull(), typeKey(), shape, npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKey()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", Singleband<*> >";
-        return key;
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", Singleband<" +
-                                 ValuetypeTraits::typeName() + ">, StridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, Singleband<T>, UnstridedArrayTag>
-: public NumpyArrayTraits<N, Singleband<T>, StridedArrayTag>
-{
-    typedef NumpyArrayTraits<N, T, UnstridedArrayTag> UnstridedTraits;
-    typedef NumpyArrayTraits<N, Singleband<T>, StridedArrayTag> BaseType;
-    typedef typename BaseType::ValuetypeTraits ValuetypeTraits;
-
-    static bool isShapeCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return UnstridedTraits::isShapeCompatible(obj);
-    }
-
-    static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return UnstridedTraits::isPropertyCompatible(obj);
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N> npyStride(stride * sizeof(T));
-        return detail::constructNumpyArrayFromData(typeKeyFull(), BaseType::typeKey(), shape, npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", Singleband<" +
-                                 ValuetypeTraits::typeName() + ">, UnstridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, Multiband<T>, StridedArrayTag>
-: public NumpyArrayTraits<N, T, StridedArrayTag>
-{
-    typedef NumpyArrayTraits<N, T, StridedArrayTag> BaseType;
-    typedef typename BaseType::ValuetypeTraits ValuetypeTraits;
-
-    enum { spatialDimensions = N-1, channels = 0 };
-
-    static bool isClassCompatible(PyObject * obj)
-    {
-        return detail::performCustomizedArrayTypecheck(obj, typeKeyFull(), typeKey());
-    }
-
-    static bool isShapeCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return PyArray_NDIM(obj) == N || PyArray_NDIM(obj) == N-1;
-    }
-
-    static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return ValuetypeTraits::isValuetypeCompatible(obj) &&
-               isShapeCompatible(obj);
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N> npyStride(stride * sizeof(T));
-        return detail::constructNumpyArrayFromData(typeKeyFull(), typeKey(), shape, npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKey()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", Multiband<*> >";
-        return key;
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", Multiband<" +
-                                 ValuetypeTraits::typeName() + ">, StridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, Multiband<T>, UnstridedArrayTag>
-: public NumpyArrayTraits<N, Multiband<T>, StridedArrayTag>
-{
-    typedef NumpyArrayTraits<N, Multiband<T>, StridedArrayTag> BaseType;
-    typedef typename BaseType::ValuetypeTraits ValuetypeTraits;
-
-    static bool isShapeCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return BaseType::isShapeCompatible(obj) &&
-               PyArray_STRIDES((PyObject *)obj)[0] == PyArray_ITEMSIZE((PyObject *)obj);
-    }
-
-    static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return BaseType::isValuetypeCompatible(obj) &&
-               isShapeCompatible(obj);
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N> npyStride(stride * sizeof(T));
-        return detail::constructNumpyArrayFromData(typeKeyFull(), BaseType::typeKey(), shape, npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", Multiband<" +
-                                 ValuetypeTraits::typeName() + ">, UnstridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, int M, class T>
-struct NumpyArrayTraits<N, TinyVector<T, M>, StridedArrayTag>
-{
-    typedef T dtype;
-    typedef TinyVector<T, M> value_type;
-    typedef NumpyArrayValuetypeTraits<T> ValuetypeTraits;
-    static NPY_TYPES const typeCode = ValuetypeTraits::typeCode;
-
-    enum { spatialDimensions = N, channels = M };
-
-    static bool isArray(PyObject * obj)
-    {
-        return obj && PyArray_Check(obj);
-    }
-
-    static bool isClassCompatible(PyObject * obj)
-    {
-        return detail::performCustomizedArrayTypecheck(obj, typeKeyFull(), typeKey());
-    }
-
-    static bool isValuetypeCompatible(PyArrayObject * obj)  /* obj must not be NULL */
-    {
-        return ValuetypeTraits::isValuetypeCompatible(obj);
-    }
-
-    static bool isShapeCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return PyArray_NDIM((PyObject *)obj) == N+1 &&
-               PyArray_DIM((PyObject *)obj, N) == M &&
-               PyArray_STRIDES((PyObject *)obj)[N] == PyArray_ITEMSIZE((PyObject *)obj);
-    }
-
-    static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return ValuetypeTraits::isValuetypeCompatible(obj) &&
-               isShapeCompatible(obj);
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N+1> npyShape;
-        std::copy(shape.begin(), shape.end(), npyShape.begin());
-        npyShape[N] = M;
-
-        TinyVector<npy_intp, N+1> npyStride;
-        std::transform(
-            stride.begin(), stride.end(), npyStride.begin(),
-            std::bind2nd(std::multiplies<npy_intp>(), sizeof(value_type)));
-        npyStride[N] = sizeof(T);
-
-        return detail::constructNumpyArrayFromData(
-            typeKeyFull(), typeKey(), npyShape,
-            npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKey()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", TinyVector<*, " + asString(M) + "> >";
-        return key;
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) +
-                      ", TinyVector<" + ValuetypeTraits::typeName() + ", " + asString(M) + ">, StridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, int M, class T>
-struct NumpyArrayTraits<N, TinyVector<T, M>, UnstridedArrayTag>
-: public NumpyArrayTraits<N, TinyVector<T, M>, StridedArrayTag>
-{
-    typedef NumpyArrayTraits<N, TinyVector<T, M>, StridedArrayTag> BaseType;
-    typedef typename BaseType::value_type value_type;
-    typedef typename BaseType::ValuetypeTraits ValuetypeTraits;
-
-    static bool isShapeCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return BaseType::isShapeCompatible(obj) &&
-               PyArray_STRIDES((PyObject *)obj)[0] == sizeof(TinyVector<T, M>);
-    }
-
-    static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return BaseType::isValuetypeCompatible(obj) &&
-               isShapeCompatible(obj);
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N+1> npyShape;
-        std::copy(shape.begin(), shape.end(), npyShape.begin());
-        npyShape[N] = M;
-
-        TinyVector<npy_intp, N+1> npyStride;
-        std::transform(
-            stride.begin(), stride.end(), npyStride.begin(),
-            std::bind2nd(std::multiplies<npy_intp>(), sizeof(value_type)));
-        npyStride[N] = sizeof(T);
-
-        return detail::constructNumpyArrayFromData(
-            typeKeyFull(), BaseType::typeKey(), npyShape,
-            npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) +
-                      ", TinyVector<" + ValuetypeTraits::typeName() + ", " + asString(M) + ">, UnstridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, RGBValue<T>, StridedArrayTag>
-: public NumpyArrayTraits<N, TinyVector<T, 3>, StridedArrayTag>
-{
-    typedef T dtype;
-    typedef RGBValue<T> value_type;
-    typedef NumpyArrayValuetypeTraits<T> ValuetypeTraits;
-
-    static bool isClassCompatible(PyObject * obj)
-    {
-        return detail::performCustomizedArrayTypecheck(obj, typeKeyFull(), typeKey());
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N+1> npyShape;
-        std::copy(shape.begin(), shape.end(), npyShape.begin());
-        npyShape[N] = 3;
-
-        TinyVector<npy_intp, N+1> npyStride;
-        std::transform(
-            stride.begin(), stride.end(), npyStride.begin(),
-            std::bind2nd(std::multiplies<npy_intp>(), sizeof(value_type)));
-        npyStride[N] = sizeof(T);
-
-        return detail::constructNumpyArrayFromData(
-            typeKeyFull(), typeKey(), npyShape,
-            npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKey()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", RGBValue<*> >";
-        return key;
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) +
-                      ", RGBValue<" + ValuetypeTraits::typeName() + ">, StridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, RGBValue<T>, UnstridedArrayTag>
-: public NumpyArrayTraits<N, RGBValue<T>, StridedArrayTag>
-{
-    typedef NumpyArrayTraits<N, TinyVector<T, 3>, UnstridedArrayTag> UnstridedTraits;
-    typedef NumpyArrayTraits<N, RGBValue<T>, StridedArrayTag> BaseType;
-    typedef typename BaseType::value_type value_type;
-    typedef typename BaseType::ValuetypeTraits ValuetypeTraits;
-
-    static bool isShapeCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return UnstridedTraits::isShapeCompatible(obj);
-    }
-
-    static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return UnstridedTraits::isPropertyCompatible(obj);
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N+1> npyShape;
-        std::copy(shape.begin(), shape.end(), npyShape.begin());
-        npyShape[N] = 3;
-
-        TinyVector<npy_intp, N+1> npyStride;
-        std::transform(
-            stride.begin(), stride.end(), npyStride.begin(),
-            std::bind2nd(std::multiplies<npy_intp>(), sizeof(value_type)));
-        npyStride[N] = sizeof(T);
-
-        return detail::constructNumpyArrayFromData(
-            typeKeyFull(), BaseType::typeKey(), npyShape,
-            npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) +
-                      ", RGBValue<" + ValuetypeTraits::typeName() + ">, UnstridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-/*                                                      */
-/*                    NumpyAnyArray                     */
-/*                                                      */
-/********************************************************/
-
-/** Wrapper class for a Python array.
-
-    This class stores a reference-counted pointer to an Python numpy array object,
-    i.e. an object where <tt>PyArray_Check(object)</tt> returns true (in Python, the
-    object is then a subclass of <tt>numpy.ndarray</tt>). This class is mainly used
-    as a smart pointer to these arrays, but some basic access and conversion functions
-    are also provided.
-
-    <b>\#include</b> \<<a href="numpy__array_8hxx-source.html">vigra/numpy_array.hxx</a>\><br>
-    Namespace: vigra
-*/
-class NumpyAnyArray
-{
-  protected:
-    python_ptr pyArray_;
-
-    // We want to apply broadcasting to the channel dimension.
-    // Since only leading dimensions can be added during numpy
-    // broadcasting, we permute the array accordingly.
-    NumpyAnyArray permuteChannelsToFront() const
-    {
-        MultiArrayIndex M = ndim();
-        ArrayVector<npy_intp> permutation(M);
-        for(int k=0; k<M; ++k)
-            permutation[k] = M-1-k;
-        // explicit cast to int is neede here to avoid gcc c++0x compilation
-        // error: narrowing conversion of ‘M’ from ‘vigra::MultiArrayIndex’
-        //        to ‘int’ inside { }
-        // int overflow should not occur here because PyArray_NDIM returns
-        // an integer which is converted to long in NumpyAnyArray::ndim()
-        PyArray_Dims permute = { permutation.begin(), (int) M };
-        python_ptr array(PyArray_Transpose(pyArray(), &permute), python_ptr::keep_count);
-        pythonToCppException(array);
-        return NumpyAnyArray(array.ptr());
-    }
-
-  public:
-
-        /// difference type
-    typedef ArrayVector<npy_intp> difference_type;
-
-        /**
-         Construct from a Python object. If \a obj is NULL, or is not a subclass
-         of numpy.ndarray, the resulting NumpyAnyArray will have no data (i.e.
-         hasData() returns false). Otherwise, it creates a new reference to the array
-         \a obj, unless \a createCopy is true, where a new array is created by calling
-         the C-equivalent of obj->copy().
-         */
-    explicit NumpyAnyArray(PyObject * obj = 0, bool createCopy = false, PyTypeObject * type = 0)
-    {
-        if(obj == 0)
-            return;
-        vigra_precondition(type == 0 || PyType_IsSubtype(type, &PyArray_Type),
-             "NumpyAnyArray(obj, createCopy, type): type must be numpy.ndarray or a subclass thereof.");
-        if(createCopy)
-            makeCopy(obj, type);
-        else
-            vigra_precondition(makeReference(obj, type), "NumpyAnyArray(obj): obj isn't a numpy array.");
-    }
-
-        /**
-         Copy constructor. By default, it creates a new reference to the array
-         \a other. When \a createCopy is true, a new array is created by calling
-         the C-equivalent of other.copy().
-         */
-    NumpyAnyArray(NumpyAnyArray const & other, bool createCopy = false, PyTypeObject * type = 0)
-    {
-        if(!other.hasData())
-            return;
-        vigra_precondition(type == 0 || PyType_IsSubtype(type, &PyArray_Type),
-             "NumpyAnyArray(obj, createCopy, type): type must be numpy.ndarray or a subclass thereof.");
-        if(createCopy)
-            makeCopy(other.pyObject(), type);
-        else
-            makeReference(other.pyObject(), type);
-    }
-
-    // auto-generated destructor is ok
-
-        /**
-         * Assignment operator. If this is already a view with data
-         * (i.e. hasData() is true) and the shapes match, the RHS
-         * array contents are copied via the C-equivalent of
-         * 'self[...] = other[...]'. If the shapes don't matched,
-         * broadcasting is tried on the trailing (i.e. channel)
-         * dimension.
-         * If the LHS is an empty view, assignment is identical to
-         * makeReference(other.pyObject()).
-         */
-    NumpyAnyArray & operator=(NumpyAnyArray const & other)
-    {
-        if(hasData())
-        {
-            vigra_precondition(other.hasData(),
-                "NumpyArray::operator=(): Cannot assign from empty array.");
-            if(PyArray_CopyInto(permuteChannelsToFront().pyArray(), other.permuteChannelsToFront().pyArray()) == -1)
-                pythonToCppException(0);
-        }
-        else
-        {
-            pyArray_ = other.pyArray_;
-        }
-        return *this;
-    }
-
-        /**
-         Returns the number of dimensions of this array, or 0 if
-         hasData() is false.
-         */
-    MultiArrayIndex ndim() const
-    {
-        if(hasData())
-            return PyArray_NDIM(pyObject());
-        return 0;
-    }
-
-        /**
-         Returns the number of spatial dimensions of this array, or 0 if
-         hasData() is false. If the enclosed Python array does not define
-         the attribute spatialDimensions, ndim() is returned.
-         */
-    MultiArrayIndex spatialDimensions() const
-    {
-        if(!hasData())
-            return 0;
-        MultiArrayIndex s = detail::spatialDimensions(pyObject());
-        if(s == -1)
-            s = ndim();
-        return s;
-    }
-
-        /**
-         Returns the shape of this array. The size of
-         the returned shape equals ndim().
-         */
-    difference_type shape() const
-    {
-        if(hasData())
-            return difference_type(PyArray_DIMS(pyObject()), PyArray_DIMS(pyObject()) + ndim());
-        return difference_type();
-    }
-
-        /** Compute the ordering of the strides of this array.
-            The result is describes the current permutation of the axes relative
-            to an ascending stride order.
-        */
-    difference_type strideOrdering() const
-    {
-        if(!hasData())
-            return difference_type();
-        MultiArrayIndex N = ndim();
-        difference_type stride(PyArray_STRIDES(pyObject()), PyArray_STRIDES(pyObject()) + N),
-                        permutation(N);
-        for(MultiArrayIndex k=0; k<N; ++k)
-            permutation[k] = k;
-        for(MultiArrayIndex k=0; k<N-1; ++k)
-        {
-            MultiArrayIndex smallest = k;
-            for(MultiArrayIndex j=k+1; j<N; ++j)
-            {
-                if(stride[j] < stride[smallest])
-                    smallest = j;
-            }
-            if(smallest != k)
-            {
-                std::swap(stride[k], stride[smallest]);
-                std::swap(permutation[k], permutation[smallest]);
-            }
-        }
-        difference_type ordering(N);
-        for(MultiArrayIndex k=0; k<N; ++k)
-            ordering[permutation[k]] = k;
-        return ordering;
-    }
-
-        /**
-         Returns the value type of the elements in this array, or -1
-         when hasData() is false.
-         */
-    int dtype() const
-    {
-        if(hasData())
-            return PyArray_DESCR(pyObject())->type_num;
-        return -1;
-    }
-
-        /**
-         * Return a borrowed reference to the internal PyArrayObject.
-         */
-    PyArrayObject * pyArray() const
-    {
-        return (PyArrayObject *)pyArray_.get();
-    }
-
-        /**
-         * Return a borrowed reference to the internal PyArrayObject
-         * (see pyArray()), cast to PyObject for your convenience.
-         */
-    PyObject * pyObject() const
-    {
-        return pyArray_.get();
-    }
-
-        /**
-           Reset the NumpyAnyArray to the given object. If \a obj is a numpy array object,
-           a new reference to that array is created, and the function returns
-           true. Otherwise, it returns false and the NumpyAnyArray remains unchanged.
-           If \a type is given, the new reference will be a view with that type, provided
-           that \a type is a numpy ndarray or a subclass thereof. Otherwise, an
-           exception is thrown.
-         */
-    bool makeReference(PyObject * obj, PyTypeObject * type = 0)
-    {
-        if(obj == 0 || !PyArray_Check(obj))
-            return false;
-        if(type != 0)
-        {
-            vigra_precondition(PyType_IsSubtype(type, &PyArray_Type) != 0,
-                "NumpyAnyArray::makeReference(obj, type): type must be numpy.ndarray or a subclass thereof.");
-            obj = PyArray_View((PyArrayObject*)obj, 0, type);
-            pythonToCppException(obj);
-        }
-        pyArray_.reset(obj);
-        return true;
-    }
-
-        /**
-           Create a copy of the given array object. If \a obj is a numpy array object,
-           a copy is created via the C-equivalent of 'obj->copy()'. If
-           this call fails, or obj was not an array, an exception is thrown
-           and the NumpyAnyArray remains unchanged.
-         */
-    void makeCopy(PyObject * obj, PyTypeObject * type = 0)
-    {
-        vigra_precondition(obj && PyArray_Check(obj),
-             "NumpyAnyArray::makeCopy(obj): obj is not an array.");
-        vigra_precondition(type == 0 || PyType_IsSubtype(type, &PyArray_Type),
-             "NumpyAnyArray::makeCopy(obj, type): type must be numpy.ndarray or a subclass thereof.");
-        python_ptr array(PyArray_NewCopy((PyArrayObject*)obj, NPY_ANYORDER), python_ptr::keep_count);
-        pythonToCppException(array);
-        makeReference(array, type);
-    }
-
-         /**
-           Check whether this NumpyAnyArray actually points to a Python array.
-         */
-    bool hasData() const
-    {
-        return pyArray_ != 0;
-    }
-};
-
-/********************************************************/
-/*                                                      */
-/*                     NumpyArray                       */
-/*                                                      */
-/********************************************************/
-
-/** Provide the MultiArrayView interface for a Python array.
-
-    This class inherits from both \ref vigra::MultiArrayView and \ref vigra::NumpyAnyArray
-    in order to support easy and save application of VIGRA functions to Python arrays.
-
-    <b>\#include</b> \<<a href="numpy__array_8hxx-source.html">vigra/numpy_array.hxx</a>\><br>
-    Namespace: vigra
-*/
-template <unsigned int N, class T, class Stride = StridedArrayTag>
-class NumpyArray
-: public MultiArrayView<N, typename NumpyArrayTraits<N, T, Stride>::value_type, Stride>,
-  public NumpyAnyArray
-{
-  public:
-    typedef NumpyArrayTraits<N, T, Stride> ArrayTraits;
-    typedef typename ArrayTraits::dtype dtype;
-    typedef T pseudo_value_type;
-
-    static NPY_TYPES const typeCode = ArrayTraits::typeCode;
-
-        /** the view type associated with this array.
-         */
-    typedef MultiArrayView<N, typename ArrayTraits::value_type, Stride> view_type;
-
-    enum { actual_dimension = view_type::actual_dimension };
-
-        /** the array's value type
-         */
-    typedef typename view_type::value_type value_type;
-
-        /** pointer type
-         */
-    typedef typename view_type::pointer pointer;
-
-        /** const pointer type
-         */
-    typedef typename view_type::const_pointer const_pointer;
-
-        /** reference type (result of operator[])
-         */
-    typedef typename view_type::reference reference;
-
-        /** const reference type (result of operator[] const)
-         */
-    typedef typename view_type::const_reference const_reference;
-
-        /** size type
-         */
-    typedef typename view_type::size_type size_type;
-
-        /** difference type (used for multi-dimensional offsets and indices)
-         */
-    typedef typename view_type::difference_type difference_type;
-
-        /** difference and index type for a single dimension
-         */
-    typedef typename view_type::difference_type_1 difference_type_1;
-
-        /** traverser type
-         */
-    typedef typename view_type::traverser traverser;
-
-        /** traverser type to const data
-         */
-    typedef typename view_type::const_traverser const_traverser;
-
-        /** sequential (random access) iterator type
-         */
-    typedef value_type * iterator;
-
-        /** sequential (random access) const iterator type
-         */
-    typedef value_type * const_iterator;
-
-    using view_type::shape;   // resolve ambiguity of multiple inheritance
-    using view_type::hasData; // resolve ambiguity of multiple inheritance
-    using view_type::strideOrdering; // resolve ambiguity of multiple inheritance
-
-  protected:
-
-    // this function assumes that pyArray_ has already been set, and compatibility been checked
-    void setupArrayView();
-
-    static python_ptr getArrayTypeObject()
-    {
-        python_ptr type = detail::getArrayTypeObject(ArrayTraits::typeKeyFull());
-        if(type == 0)
-            type = detail::getArrayTypeObject(ArrayTraits::typeKey(), &PyArray_Type);
-        return type;
-    }
-
-    static python_ptr init(difference_type const & shape, bool init = true)
-    {
-        ArrayVector<npy_intp> pshape(shape.begin(), shape.end());
-        return detail::constructNumpyArrayImpl((PyTypeObject *)getArrayTypeObject().ptr(), pshape,
-                       ArrayTraits::spatialDimensions, ArrayTraits::channels,
-                       typeCode, "V", init);
-    }
-
-    static python_ptr init(difference_type const & shape, difference_type const & strideOrdering, bool init = true)
-    {
-        ArrayVector<npy_intp> pshape(shape.begin(), shape.end()),
-                              pstrideOrdering(strideOrdering.begin(), strideOrdering.end());
-        return detail::constructNumpyArrayImpl((PyTypeObject *)getArrayTypeObject().ptr(), pshape,
-                       ArrayTraits::spatialDimensions, ArrayTraits::channels,
-                       typeCode, "A", init, pstrideOrdering);
-    }
-
-  public:
-
-    using view_type::init;
-
-        /**
-         * Construct from a given PyObject pointer. When the given
-         * python object is NULL, the internal python array will be
-         * NULL and hasData() will return false.
-         *
-         * Otherwise, the function attempts to create a
-         * new reference to the given Python object, unless
-         * copying is forced by setting \a createCopy to true.
-         * If either of this fails, the function throws an exception.
-         * This will not happen if isStrictlyCompatible(obj) (in case
-         * of creating a new reference) or isCopyCompatible(obj)
-         * (in case of copying) have returned true beforehand.
-         */
-    explicit NumpyArray(PyObject *obj = 0, bool createCopy = false)
-    {
-        if(obj == 0)
-            return;
-        if(createCopy)
-            makeCopy(obj);
-        else
-            vigra_precondition(makeReference(obj),
-                  "NumpyArray(obj): Cannot construct from incompatible array.");
-    }
-
-       /**
-         * Copy constructor; does not copy the memory, but creates a
-         * new reference to the same underlying python object, unless
-         * a copy is forced by setting \a createCopy to true.
-         * (If the source object has no data, this one will have
-         * no data, too.)
-         */
-    NumpyArray(const NumpyArray &other, bool createCopy = false) :
-            MultiArrayView<N, typename NumpyArrayTraits<N, T, Stride>::value_type, Stride>(other),
-            NumpyAnyArray(other, createCopy)
-    {
-        if(!other.hasData())
-            return;
-        if(createCopy)
-            makeCopy(other.pyObject());
-        else
-            makeReferenceUnchecked(other.pyObject());
-    }
-
-       /**
-         * Allocate new memory and copy data from a MultiArrayView.
-         */
-    explicit NumpyArray(const view_type &other)
-    {
-        if(!other.hasData())
-            return;
-        vigra_postcondition(makeReference(init(other.shape(), false)),
-                  "NumpyArray(view_type): Python constructor did not produce a compatible array.");
-        static_cast<view_type &>(*this) = other;
-    }
-
-        /**
-         * Construct a new array object, allocating an internal python
-         * ndarray of the given shape (in fortran order), initialized
-         * with zeros.
-         *
-         * An exception is thrown when construction fails.
-         */
-    explicit NumpyArray(difference_type const & shape)
-    {
-        vigra_postcondition(makeReference(init(shape)),
-                     "NumpyArray(shape): Python constructor did not produce a compatible array.");
-    }
-
-        /**
-         * Construct a new array object, allocating an internal python
-         * ndarray of the given shape and given stride ordering, initialized
-         * with zeros.
-         *
-         * An exception is thrown when construction fails.
-         */
-    NumpyArray(difference_type const & shape, difference_type const & strideOrdering)
-    {
-        vigra_postcondition(makeReference(init(shape, strideOrdering)),
-                     "NumpyArray(shape): Python constructor did not produce a compatible array.");
-    }
-
-        /**
-         * Constructor from NumpyAnyArray.
-         * Equivalent to NumpyArray(other.pyObject())
-         */
-    NumpyArray(const NumpyAnyArray &other, bool createCopy = false)
-    {
-        if(!other.hasData())
-            return;
-        if(createCopy)
-            makeCopy(other.pyObject());
-        else
-            vigra_precondition(makeReference(other.pyObject()), //, false),
-                   "NumpyArray(NumpyAnyArray): Cannot construct from incompatible or empty array.");
-    }
-
-        /**
-         * Assignment operator. If this is already a view with data
-         * (i.e. hasData() is true) and the shapes match, the RHS
-         * array contents are copied.  If this is an empty view,
-         * assignment is identical to makeReferenceUnchecked(other.pyObject()).
-         * See MultiArrayView::operator= for further information on
-         * semantics.
-         */
-    NumpyArray &operator=(const NumpyArray &other)
-    {
-        if(hasData())
-            view_type::operator=(other);
-        else
-            makeReferenceUnchecked(other.pyObject());
-        return *this;
-    }
-
-        /**
-         * Assignment operator. If this is already a view with data
-         * (i.e. hasData() is true) and the shapes match, the RHS
-         * array contents are copied.
-         * If this is an empty view, assignment is identical to
-         * makeReference(other.pyObject()).
-         * Otherwise, an exception is thrown.
-         */
-    NumpyArray &operator=(const NumpyAnyArray &other)
-    {
-        if(hasData())
-        {
-            NumpyAnyArray::operator=(other);
-        }
-        else if(isStrictlyCompatible(other.pyObject()))
-        {
-            makeReferenceUnchecked(other.pyObject());
-        }
-        else
-        {
-            vigra_precondition(false,
-                "NumpyArray::operator=(): Cannot assign from incompatible array.");
-        }
-        return *this;
-    }
-
-        /**
-         * Test whether a given python object is a numpy array that can be
-         * converted (copied) into an array compatible to this NumpyArray type.
-         * This means that the array's shape conforms to the requirements of
-         * makeCopy().
-         */
-    static bool isCopyCompatible(PyObject *obj)
-    {
-        return ArrayTraits::isArray(obj) &&
-               ArrayTraits::isShapeCompatible((PyArrayObject *)obj);
-    }
-
-        /**
-         * Test whether a given python object is a numpy array with a
-         * compatible dtype and the correct shape and strides, so that it
-         * can be referenced as a view by this NumpyArray type (i.e.
-         * it conforms to the requirements of makeReference()).
-         */
-    static bool isReferenceCompatible(PyObject *obj)
-    {
-        return ArrayTraits::isArray(obj) &&
-               ArrayTraits::isPropertyCompatible((PyArrayObject *)obj);
-    }
-
-        /**
-         * Like isReferenceCompatible(obj), but also executes a customized type compatibility
-         * check when such a check has been registered for this class via
-         * registerPythonArrayType().
-         *
-         * This facilitates proper overload resolution between
-         * NumpyArray<3, Multiband<T> > (a multiband image) and NumpyArray<3, Singleband<T> > (a scalar volume).
-         */
-    static bool isStrictlyCompatible(PyObject *obj)
-    {
-#if VIGRA_CONVERTER_DEBUG
-        std::cerr << "class " << typeid(NumpyArray).name() << " got " << obj->ob_type->tp_name << "\n";
-        bool isClassCompatible=ArrayTraits::isClassCompatible(obj);
-        bool isPropertyCompatible((PyArrayObject *)obj);
-        std::cerr<<"isClassCompatible: "<<isClassCompatible<<std::endl;
-        std::cerr<<"isPropertyCompatible: "<<isPropertyCompatible<<std::endl;
-#endif
-        return ArrayTraits::isClassCompatible(obj) &&
-               ArrayTraits::isPropertyCompatible((PyArrayObject *)obj);
-    }
-
-        /**
-         * Create a vector representing the standard stride ordering of a NumpyArray.
-         * That is, we get a vector representing the range [0,...,N-1], which
-         * denotes the stride ordering for Fortran order.
-         */
-    static difference_type standardStrideOrdering()
-    {
-        difference_type strideOrdering;
-        for(unsigned int k=0; k<N; ++k)
-            strideOrdering[k] = k;
-        return strideOrdering;
-    }
-
-        /**
-         * Set up a view to the given object without checking compatibility.
-         * This function must not be used unless isReferenceCompatible(obj) returned
-         * true on the given object (otherwise, a crash is likely).
-         */
-    void makeReferenceUnchecked(PyObject *obj)
-    {
-        NumpyAnyArray::makeReference(obj);
-        setupArrayView();
-    }
-
-        /**
-         * Try to set up a view referencing the given PyObject.
-         * Returns false if the python object is not a compatible
-         * numpy array (see isReferenceCompatible() or
-         * isStrictlyCompatible(), according to the parameter \a
-         * strict).
-         */
-    bool makeReference(PyObject *obj, bool strict = true)
-    {
-        if(strict)
-        {
-            if(!isStrictlyCompatible(obj))
-                return false;
-        }
-        else
-        {
-            if(!isReferenceCompatible(obj))
-                return false;
-        }
-        makeReferenceUnchecked(obj);
-        return true;
-    }
-
-        /**
-         * Try to set up a view referencing the same data as the given
-         * NumpyAnyArray.  This overloaded variant simply calls
-         * makeReference() on array.pyObject().
-         */
-    bool makeReference(const NumpyAnyArray &array, bool strict = true)
-    {
-        return makeReference(array.pyObject(), strict);
-    }
-
-        /**
-         * Set up an unsafe reference to the given MultiArrayView.
-         * ATTENTION: This creates a numpy.ndarray that points to the
-         * same data, but does not own it, so it must be ensured by
-         * other means that the memory does not get freed before the
-         * end of the ndarray's lifetime!  (One elegant way would be
-         * to set the 'base' attribute of the resulting ndarray to a
-         * python object which directly or indirectly holds the memory
-         * of the given MultiArrayView.)
-         */
-    void makeReference(const view_type &multiArrayView)
-    {
-        vigra_precondition(!hasData(), "makeReference(): cannot replace existing view with given buffer");
-
-        // construct an ndarray that points to our data (taking strides into account):
-        python_ptr array(ArrayTraits::constructor(multiArrayView.shape(), multiArrayView.data(), multiArrayView.stride()));
-
-        view_type::operator=(multiArrayView);
-        pyArray_ = array;
-    }
-
-        /**
-         Try to create a copy of the given PyObject.
-         Raises an exception when obj is not a compatible array
-         (see isCopyCompatible() or isStrictlyCompatible(), according to the
-         parameter \a strict) or the Python constructor call failed.
-         */
-    void makeCopy(PyObject *obj, bool strict = false)
-    {
-        vigra_precondition(strict ? isStrictlyCompatible(obj) : isCopyCompatible(obj),
-                     "NumpyArray::makeCopy(obj): Cannot copy an incompatible array.");
-
-        int M = PyArray_NDIM(obj);
-        TinyVector<npy_intp, N> shape;
-        std::copy(PyArray_DIMS(obj), PyArray_DIMS(obj)+M, shape.begin());
-        if(M == N-1)
-            shape[M] = 1;
-        vigra_postcondition(makeReference(init(shape, false)),
-                     "NumpyArray::makeCopy(obj): Copy created an incompatible array.");
-        NumpyAnyArray::operator=(NumpyAnyArray(obj));
-//        if(PyArray_CopyInto(pyArray(), (PyArrayObject*)obj) == -1)
-//            pythonToCppException(0);
-    }
-
-        /**
-            Allocate new memory with the given shape and initialize with zeros.<br>
-            If a stride ordering is given, the resulting array will have this stride
-            ordering, when it is compatible with the array's memory layout (unstrided
-            arrays only permit the standard ascending stride ordering).
-
-            <em>Note:</em> this operation invalidates dependent objects
-            (MultiArrayViews and iterators)
-         */
-    void reshape(difference_type const & shape, difference_type const & strideOrdering = standardStrideOrdering())
-    {
-        vigra_postcondition(makeReference(init(shape, strideOrdering)),
-                     "NumpyArray(shape): Python constructor did not produce a compatible array.");
-    }
-
-        /**
-            When this array has no data, allocate new memory with the given \a shape and
-            initialize with zeros. Otherwise, check if the new shape matches the old shape
-            and throw a precondition exception with the given \a message if not.
-         */
-    void reshapeIfEmpty(difference_type const & shape, std::string message = "")
-    {
-        reshapeIfEmpty(shape, standardStrideOrdering(), message);
-    }
-
-        /**
-            When this array has no data, allocate new memory with the given \a shape and
-            initialize with zeros. Otherwise, check if the new shape matches the old shape
-            and throw a precondition exception with the given \a message if not. If strict
-            is true, the given stride ordering must also match that of the existing data.
-         */
-    void reshapeIfEmpty(difference_type const & shape, difference_type const & strideOrdering,
-                        std::string message = "", bool strict = false)
-    {
-        if(hasData())
-        {
-            if(strict)
-            {
-                if(message == "")
-                    message = "NumpyArray::reshapeIfEmpty(shape): array was not empty, and shape or stride ordering did not match.";
-                vigra_precondition(shape == this->shape() && strideOrdering == this->strideOrdering(), message.c_str());
-            }
-            else
-            {
-                if(message == "")
-                    message = "NumpyArray::reshapeIfEmpty(shape): array was not empty, and shape did not match.";
-                vigra_precondition(shape == this->shape(), message.c_str());
-            }
-        }
-        else
-        {
-            reshape(shape, strideOrdering);
-        }
-    }
-};
-
-    // this function assumes that pyArray_ has already been set, and compatibility been checked
-template <unsigned int N, class T, class Stride>
-void NumpyArray<N, T, Stride>::setupArrayView()
-{
-    if(NumpyAnyArray::hasData())
-    {
-        unsigned int dimension = std::min<unsigned int>(actual_dimension, pyArray()->nd);
-        std::copy(pyArray()->dimensions, pyArray()->dimensions + dimension, this->m_shape.begin());
-        std::copy(pyArray()->strides, pyArray()->strides + dimension, this->m_stride.begin());
-        if(pyArray()->nd < actual_dimension)
-        {
-            this->m_shape[dimension] = 1;
-            this->m_stride[dimension] = sizeof(value_type);
-        }
-        this->m_stride /= sizeof(value_type);
-        this->m_ptr = reinterpret_cast<pointer>(pyArray()->data);
-    }
-    else
-    {
-        this->m_ptr = 0;
-    }
-}
-
-
-typedef NumpyArray<2, float >  NumpyFArray2;
-typedef NumpyArray<3, float >  NumpyFArray3;
-typedef NumpyArray<4, float >  NumpyFArray4;
-typedef NumpyArray<2, Singleband<float> >  NumpyFImage;
-typedef NumpyArray<3, Singleband<float> >  NumpyFVolume;
-typedef NumpyArray<2, RGBValue<float> >  NumpyFRGBImage;
-typedef NumpyArray<3, RGBValue<float> >  NumpyFRGBVolume;
-typedef NumpyArray<3, Multiband<float> >  NumpyFMultibandImage;
-typedef NumpyArray<4, Multiband<float> >  NumpyFMultibandVolume;
-
-inline void import_vigranumpy()
-{
-    if(_import_array() < 0)
-        pythonToCppException(0);
-    python_ptr module(PyImport_ImportModule("vigra.vigranumpycore"), python_ptr::keep_count);
-    pythonToCppException(module);
-}
-
-/********************************************************/
-/*                                                      */
-/*   NumpyArray Multiband Argument Object Factories     */
-/*                                                      */
-/********************************************************/
-
-template <class PixelType, class Stride>
-inline triple<ConstStridedImageIterator<PixelType>,
-              ConstStridedImageIterator<PixelType>,
-              MultibandVectorAccessor<PixelType> >
-srcImageRange(NumpyArray<3, Multiband<PixelType>, Stride> const & img)
-{
-    ConstStridedImageIterator<PixelType>
-        ul(img.data(), 1, img.stride(0), img.stride(1));
-    return triple<ConstStridedImageIterator<PixelType>,
-                  ConstStridedImageIterator<PixelType>,
-                  MultibandVectorAccessor<PixelType> >
-        (ul, ul + Size2D(img.shape(0), img.shape(1)), MultibandVectorAccessor<PixelType>(img.shape(2), img.stride(2)));
-}
-
-template <class PixelType, class Stride>
-inline pair< ConstStridedImageIterator<PixelType>,
-             MultibandVectorAccessor<PixelType> >
-srcImage(NumpyArray<3, Multiband<PixelType>, Stride> const & img)
-{
-    ConstStridedImageIterator<PixelType>
-        ul(img.data(), 1, img.stride(0), img.stride(1));
-    return pair<ConstStridedImageIterator<PixelType>, MultibandVectorAccessor<PixelType> >
-        (ul, MultibandVectorAccessor<PixelType>(img.shape(2), img.stride(2)));
-}
-
-template <class PixelType, class Stride>
-inline triple< StridedImageIterator<PixelType>,
-               StridedImageIterator<PixelType>,
-               MultibandVectorAccessor<PixelType> >
-destImageRange(NumpyArray<3, Multiband<PixelType>, Stride> & img)
-{
-    StridedImageIterator<PixelType>
-        ul(img.data(), 1, img.stride(0), img.stride(1));
-    typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
-    return triple<StridedImageIterator<PixelType>,
-                  StridedImageIterator<PixelType>,
-                  MultibandVectorAccessor<PixelType> >
-        (ul, ul + Size2D(img.shape(0), img.shape(1)),
-        MultibandVectorAccessor<PixelType>(img.shape(2), img.stride(2)));
-}
-
-template <class PixelType, class Stride>
-inline pair< StridedImageIterator<PixelType>,
-             MultibandVectorAccessor<PixelType> >
-destImage(NumpyArray<3, Multiband<PixelType>, Stride> & img)
-{
-    StridedImageIterator<PixelType>
-        ul(img.data(), 1, img.stride(0), img.stride(1));
-    return pair<StridedImageIterator<PixelType>, MultibandVectorAccessor<PixelType> >
-        (ul, MultibandVectorAccessor<PixelType>(img.shape(2), img.stride(2)));
-}
-
-template <class PixelType, class Stride>
-inline pair< ConstStridedImageIterator<PixelType>,
-             MultibandVectorAccessor<PixelType> >
-maskImage(NumpyArray<3, Multiband<PixelType>, Stride> const & img)
-{
-    ConstStridedImageIterator<PixelType>
-        ul(img.data(), 1, img.stride(0), img.stride(1));
-    typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
-    return pair<ConstStridedImageIterator<PixelType>, MultibandVectorAccessor<PixelType> >
-        (ul, MultibandVectorAccessor<PixelType>(img.shape(2), img.stride(2)));
-}
-
-} // namespace vigra
-
-#endif // VIGRA_NUMPY_ARRAY_HXX

=== removed directory '.pc/debian-changes-1.7.1+dfsg1-2ubuntu1/vigranumpy'
=== removed directory '.pc/debian-changes-1.7.1+dfsg1-2ubuntu1/vigranumpy/docsrc'
=== removed file '.pc/debian-changes-1.7.1+dfsg1-2ubuntu1/vigranumpy/docsrc/conf.py.THIS'
=== added directory '.pc/fix-ftbfs-gcc4.7.diff'
=== added directory '.pc/fix-ftbfs-gcc4.7.diff/include'
=== added directory '.pc/fix-ftbfs-gcc4.7.diff/include/vigra'
=== added file '.pc/fix-ftbfs-gcc4.7.diff/include/vigra/box.hxx'
--- .pc/fix-ftbfs-gcc4.7.diff/include/vigra/box.hxx	1970-01-01 00:00:00 +0000
+++ .pc/fix-ftbfs-gcc4.7.diff/include/vigra/box.hxx	2012-06-14 20:29:21 +0000
@@ -0,0 +1,545 @@
+/************************************************************************/
+/*                                                                      */
+/*     Copyright 2009-2010 by Ullrich Koethe and Hans Meine             */
+/*                                                                      */
+/*    This file is part of the VIGRA computer vision library.           */
+/*    The VIGRA Website is                                              */
+/*        http://hci.iwr.uni-heidelberg.de/vigra/                       */
+/*    Please direct questions, bug reports, and contributions to        */
+/*        [e-mail]    or                    */
+/*        [e-mail]                               */
+/*                                                                      */
+/*    Permission is hereby granted, free of charge, to any person       */
+/*    obtaining a copy of this software and associated documentation    */
+/*    files (the "Software"), to deal in the Software without           */
+/*    restriction, including without limitation the rights to use,      */
+/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
+/*    sell copies of the Software, and to permit persons to whom the    */
+/*    Software is furnished to do so, subject to the following          */
+/*    conditions:                                                       */
+/*                                                                      */
+/*    The above copyright notice and this permission notice shall be    */
+/*    included in all copies or substantial portions of the             */
+/*    Software.                                                         */
+/*                                                                      */
+/*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
+/*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
+/*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
+/*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
+/*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
+/*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
+/*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
+/*    OTHER DEALINGS IN THE SOFTWARE.                                   */
+/*                                                                      */
+/************************************************************************/
+
+#ifndef VIGRA_BOX_HXX
+#define VIGRA_BOX_HXX
+
+#include "metaprogramming.hxx"
+#include "numerictraits.hxx"
+#include "tinyvector.hxx"
+
+namespace vigra {
+
+namespace detail {
+
+// RangePolicy used for floating point coordinate types
+template<class VALUETYPE>
+struct EndInsidePolicy
+{
+    static inline bool isEmptyRange(VALUETYPE b, VALUETYPE e)
+    {
+        return e < b; // <=
+    }
+
+    static inline VALUETYPE pointEnd(VALUETYPE p)
+    {
+        return p; // +1
+    }
+};
+
+// RangePolicy used for integer coordinate types
+template<class VALUETYPE>
+struct EndOutsidePolicy
+{
+    static inline bool isEmptyRange(VALUETYPE b, VALUETYPE e)
+    {
+        return e <= b;
+    }
+
+    static inline VALUETYPE pointEnd(VALUETYPE p)
+    {
+        return p+1;
+    }
+};
+
+} // namespace vigra::detail
+
+/** \addtogroup RangesAndPoints */
+//@{
+   /** \brief Represent an n-dimensional box as a (begin, end) pair.
+     * Depending on the value type, end() is considered to be
+     * outside the box (as in the STL, for integer types), or
+     * inside (for floating point types).  size() will always be
+     * end() - begin().
+     */
+template<class VALUETYPE, unsigned int DIMENSION>
+class Box
+{
+  public:
+        /** STL-compatible definition of coordinate valuetype
+         */
+    typedef VALUETYPE value_type;
+
+        /** Promoted coordinate valuetype, used for volume()
+         */
+    typedef typename NumericTraits<VALUETYPE>::Promote VolumeType;
+
+        /** Vector type used for begin() and end()
+         */
+    typedef TinyVector<VALUETYPE, DIMENSION> Vector;
+
+    enum { Dimension = DIMENSION };
+
+  protected:
+    Vector begin_, end_;
+
+        /** Range policy (EndInsidePolicy/EndOutsidePolicy, depending on valuetype)
+         */
+    typedef typename If<typename NumericTraits<VALUETYPE>::isIntegral,
+                        detail::EndOutsidePolicy<VALUETYPE>,
+                        detail::EndInsidePolicy<VALUETYPE> >::type RangePolicy;
+
+  public:
+        /** Construct an empty box (isEmpty() will return true).
+         * (Internally, this will initialize all dimensions with the
+         * empty range [1..0].)
+         */
+    Box()
+    : begin_(NumericTraits<Vector>::one())
+    {}
+
+        /** Construct a box representing the given range.  Depending
+         * on the value type, end() is considered to be outside the
+         * box (as in the STL, for integer types), or inside (for
+         * floating point types).
+         */
+    Box(Vector const &begin, Vector const &end)
+    : begin_(begin), end_(end)
+    {}
+
+        /** Construct a box of given size at the origin (i.e. end() ==
+         * size()).
+         */
+    explicit Box(Vector const &size)
+    : end_(size)
+    {}
+
+        /** Get begin vector (i.e. smallest coordinates for each
+         * dimension).  This is the first point (scan-order wise)
+         * which is considered to be "in" the box.
+         */
+    Vector const & begin() const
+    {
+        return begin_;
+    }
+
+        /** Access begin vector (i.e. smallest coordinates for each
+         * dimension).  This is the first point (scan-order wise)
+         * which is considered to be "in" the box.
+         */
+    Vector & begin()
+    {
+        return begin_;
+    }
+
+        /** Get end vector (i.e. coordinates higher than begin() in
+         * each dimension for non-empty boxes).  This is begin() +
+         * size(), and depending on the valuetype (float/int), this is
+         * the last point within or the first point outside the box,
+         * respectively.
+         */
+    Vector const & end() const
+    {
+        return end_;
+    }
+
+        /** Access end vector (i.e. coordinates higher than begin() in
+         * each dimension for non-empty boxes).  This is begin() +
+         * size(), and depending on the valuetype (float/int), this is
+         * the last point within or the first point outside the box,
+         * respectively.
+         */
+    Vector & end()
+    {
+        return end_;
+    }
+
+        /** Change begin() without changing end(), changing size()
+         * accordingly.
+         */
+    void setBegin(Vector const &begin)
+    {
+        begin_ = begin;
+    }
+
+        /** Change end() without changing begin(), which will change
+         * the size() most probably.
+         */
+    void setEnd(Vector const &end)
+    {
+        end_ = end;
+    }
+
+        /** Move the whole box so that the given point will be
+         * begin() afterwards.
+         */
+    void moveTo(Vector const &newBegin)
+    {
+        end_ += newBegin - begin_;
+        begin_ = newBegin;
+    }
+
+        /** Move the whole box by the given offset.
+         * (Equivalent to operator+=)
+         */
+    void moveBy(Vector const &offset)
+    {
+        begin_ += offset;
+        end_ += offset;
+    }
+
+        /** Determine and return the area of this box. That is,
+         * if this rect isEmpty(), returns zero, otherwise returns the
+         * product of the extents in each dimension.
+         */
+    VolumeType volume() const
+    {
+        if(isEmpty())
+            return 0;
+
+        VolumeType result(end_[0] - begin_[0]);
+        for(unsigned int i = 1; i < DIMENSION; ++i)
+            result *= end_[i] - begin_[i];
+        return result;
+    }
+
+        /** Determine and return the size of this box. The size
+         * might be zero or even negative in one or more dimensions,
+         * and if so, isEmpty() will return true.
+         */
+    Vector size() const
+    {
+        return end_ - begin_;
+    }
+
+        /** Resize this box to the given extents. This will
+         * change end() only.
+         */
+    void setSize(Vector const &size)
+    {
+        end_ = begin_ + size;
+    }
+
+        /** Increase the size of the box by the given
+         * offset. This will move end() only. (If any of offset's
+         * components is negative, the box will get smaller
+         * accordingly.)
+         */
+    void addSize(Vector const &offset)
+    {
+        end_ += offset;
+    }
+
+        /** Adds a border of the given width around the box. That
+         * means, begin()'s components are moved by -borderWidth
+         * and end()'s by borderWidth. (If borderWidth is
+         * negative, the box will get smaller accordingly.)
+         */
+    void addBorder(VALUETYPE borderWidth)
+    {
+        for(unsigned int i = 0; i < DIMENSION; ++i)
+        {
+            begin_[i] -= borderWidth;
+            end_[i]   += borderWidth;
+        }
+    }
+
+        /// equality check
+    bool operator==(Box const &r) const
+    {
+        return (begin_ == r.begin_) && (end_ == r.end_);
+    }
+
+        /// inequality check
+    bool operator!=(Box const &r) const
+    {
+        return (begin_ != r.begin_) || (end_ != r.end_);
+    }
+
+        /** Return whether this box is considered empty. It is
+         * non-empty if all end() coordinates are greater than (or
+         * equal, for floating point valuetypes) the corresponding
+         * begin() coordinates. Uniting an empty box with something
+         * will return the bounding box of the 'something', and
+         * intersecting any box with an empty box will again yield an
+         * empty box.
+         */
+    bool isEmpty() const
+    {
+        for(unsigned int i = 0; i < DIMENSION; ++i)
+            if(RangePolicy::isEmptyRange(begin_[i], end_[i]))
+                return true;
+        return false;
+    }
+
+        /** Return whether this box contains the given point.
+         * That is, if the point lies within the range [begin, end] in
+         * each dimension (excluding end() itself for integer valuetypes).
+         */
+    bool contains(Vector const &p) const
+    {
+        for(unsigned int i = 0; i < DIMENSION; ++i)
+            if((p[i] < begin_[i]) ||
+               RangePolicy::isEmptyRange(p[i], end_[i]))
+                return false;
+        return true;
+    }
+
+        /** Return whether this box contains the given
+         * one. <tt>r1.contains(r2)</tt> returns the same as
+         * <tt>r1 == (r1|r2)</tt> (but is of course more
+         * efficient). That also means, a box (even an empty one!)
+         * contains() any empty box.
+         */
+    bool contains(Box const &r) const
+    {
+        if(r.isEmpty())
+            return true;
+        if(!contains(r.begin_))
+            return false;
+        for(unsigned int i = 0; i < DIMENSION; ++i)
+            if(r.end_[i] > end_[i])
+                return false;
+        return true;
+    }
+
+        /** Return whether this box overlaps with the given
+         * one. <tt>r1.intersects(r2)</tt> returns the same as
+         * <tt>!(r1&r2).isEmpty()</tt> (but is of course much more
+         * efficient).
+         */
+    bool intersects(Box const &r) const
+    {
+        if(r.isEmpty() || isEmpty())
+            return false;
+        for(unsigned int i = 0; i < DIMENSION; ++i)
+            if(RangePolicy::isEmptyRange(r.begin_[i], end_[i]) ||
+               RangePolicy::isEmptyRange(begin_[i], r.end_[i]))
+                return false;
+        return true;
+    }
+
+        /** Modifies this box by including the given point.
+         * The result will be the bounding box of the box and the
+         * point.  If isEmpty() returns true on the original box, the
+         * union will be a box containing only the given point.
+         */
+    Box &operator|=(Vector const &p)
+    {
+        if(isEmpty())
+        {
+            begin_ = p;
+            for(unsigned int i = 0; i < DIMENSION; ++i)
+                end_[i] = RangePolicy::pointEnd(p[i]);
+        }
+        else
+        {
+            for(unsigned int i = 0; i < DIMENSION; ++i)
+            {
+                if(p[i] < begin_[i])
+                    begin_[i] = p[i];
+                if(RangePolicy::isEmptyRange(p[i], end_[i]))
+                    end_[i] = RangePolicy::pointEnd(p[i]);
+            }
+        }
+        return *this;
+    }
+
+        /** Returns the union of this box and the given point.
+         * The result will be the bounding box of the box and the
+         * point.  If isEmpty() returns true on the original box, the
+         * union will be a box containing only the given point.
+         */
+    Box operator|(Vector const &p) const
+    {
+        Box result(*this);
+        result |= p;
+        return result;
+    }
+
+        /** Modifies this box by uniting it with the given one.
+         * The result will be the bounding box of both boxs. If one of
+         * the boxes isEmpty(), the union will be the other one.
+         */
+    Box &operator|=(Box const &r)
+    {
+        if(r.isEmpty())
+            return *this;
+        if(isEmpty())
+            return operator=(r);
+
+        for(unsigned int i = 0; i < DIMENSION; ++i)
+        {
+            if(r.begin_[i] < begin_[i])
+                begin_[i] = r.begin_[i];
+            if(end_[i] < r.end_[i])
+                end_[i] = r.end_[i];
+        }
+        return *this;
+    }
+
+        /** Returns the union of this box and the given one.
+         * The result will be the bounding box of both boxs. If one of
+         * the boxes isEmpty(), the union will be the other one.
+         */
+    Box operator|(Box const &r) const
+    {
+        Box result(*this);
+        result |= r;
+        return result;
+    }
+
+        /** Modifies this box by intersecting it with the given one.
+         * The result will be the maximal box contained in both
+         * original ones. Intersecting with an empty box will yield
+         * again an empty box.
+         */
+    Box &operator&=(Box const &r)
+    {
+        if(isEmpty())
+            return *this;
+        if(r.isEmpty())
+            return operator=(r);
+
+        for(unsigned int i = 0; i < DIMENSION; ++i)
+        {
+            if(begin_[i] < r.begin_[i])
+                begin_[i] = r.begin_[i];
+            if(r.end_[i] < end_[i])
+                end_[i] = r.end_[i];
+        }
+        return *this;
+    }
+
+        /** Intersects this box with the given one.
+         * The result will be the maximal box contained in both
+         * original ones.  Intersecting with an empty box will yield
+         * again an empty box.
+         */
+    Box operator&(Box const &r) const
+    {
+        Box result(*this);
+        result &= r;
+        return result;
+    }
+
+        /**
+         * Scale box by scalar multiply-assignment.  The same scalar
+         * multiply-assignment operation will be performed on both
+         * begin() and end().
+         */
+    Box &operator*=(double scale)
+    {
+        begin_ *= scale;
+        end_   *= scale;
+        return *this;
+    }
+
+        /**
+         * Return box scaled by given factor.  The same scalar
+         * multiplication will be performed on both begin() and end().
+         */
+    Box operator*(double scale)
+    {
+        Box result(*this);
+        result *= scale;
+        return result;
+    }
+
+        /**
+         * Scale box by scalar divide-assignment.  The same scalar
+         * divide-assignment operation will be performed on both
+         * begin() and end().
+         */
+    Box &operator/=(double scale)
+    {
+        begin_ /= scale;
+        end_   /= scale;
+        return *this;
+    }
+
+        /**
+         * Return box scaled by inverse of given factor.  The same scalar
+         * division will be performed on both begin() and end().
+         */
+    Box operator/(double scale)
+    {
+        Box result(*this);
+        result /= scale;
+        return result;
+    }
+
+        /**
+         * Translate box by vector addition-assignment.  The same vector
+         * addition-assignment operation will be performed on both
+         * begin() and end().
+         */
+    Box &operator+=(const Vector &offset)
+    {
+        begin_ += offset;
+        end_   += offset;
+        return *this;
+    }
+
+        /**
+         * Translate box by vector addition.  The same vector addition
+         * operation will be performed on both begin() and end().
+         */
+    Box operator+(const Vector &offset)
+    {
+        Box result(*this);
+        result += offset;
+        return result;
+    }
+
+        /**
+         * Translate box by vector subtract-assignment.  The same vector
+         * subtract-assignment operation will be performed on both
+         * begin() and end().
+         */
+    Box &operator-=(const Vector &offset)
+    {
+        begin_ -= offset;
+        end_   -= offset;
+        return *this;
+    }
+
+        /**
+         * Translate box by vector subtract.  The same vector subtract
+         * operation will be performed on both begin() and end().
+         */
+    Box operator-(const Vector &offset)
+    {
+        Box result(*this);
+        result -= offset;
+        return result;
+    }
+};
+
+//@}
+
+} // namespace vigra
+
+#endif // VIGRA_BOX_HXX

=== added directory '.pc/fix-ftbfs-gcc4.7.diff/include/vigra/random_forest'
=== added file '.pc/fix-ftbfs-gcc4.7.diff/include/vigra/random_forest/rf_ridge_split.hxx'
--- .pc/fix-ftbfs-gcc4.7.diff/include/vigra/random_forest/rf_ridge_split.hxx	1970-01-01 00:00:00 +0000
+++ .pc/fix-ftbfs-gcc4.7.diff/include/vigra/random_forest/rf_ridge_split.hxx	2012-06-14 20:29:21 +0000
@@ -0,0 +1,449 @@
+//
+// C++ Interface: rf_ridge_split
+//
+// Description: 
+//
+//
+// Author: Nico Splitthoff <splitthoff@zg00103>, (C) 2009
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef VIGRA_RANDOM_FOREST_RIDGE_SPLIT_H
+#define VIGRA_RANDOM_FOREST_RIDGE_SPLIT_H
+//#include "rf_sampling.hxx"
+#include "../sampling.hxx"
+#include "rf_split.hxx"
+#include "rf_nodeproxy.hxx"
+#include "../regression.hxx"
+
+#define outm(v) std::cout << (#v) << ": " << (v) << std::endl;
+#define outm2(v) std::cout << (#v) << ": " << (v) << ", ";
+
+namespace vigra
+{
+
+/*template<>
+class Node<i_RegrNode>
+: public NodeBase
+{
+public:
+	typedef NodeBase BT;
+
+
+	Node(   BT::T_Container_type &   topology,
+		BT::P_Container_type &   param,
+	    	int nNumCols)
+	:   BT(5+nNumCols,2+nNumCols,topology, param)
+	{
+		BT::typeID() = i_RegrNode;
+	}
+
+	Node(   BT::T_Container_type     &   topology,
+		BT::P_Container_type     &   param,
+		INT                   n             )
+	:   BT(5,2,topology, param, n)
+	{}
+
+	Node( BT & node_)
+	:   BT(5, 2, node_) 
+	{}
+
+	double& threshold()
+	{
+		return BT::parameters_begin()[1];
+	}
+
+	BT::INT& column()
+	{
+		return BT::column_data()[0];
+	}
+
+	template<class U, class C>
+			BT::INT& next(MultiArrayView<2,U,C> const & feature)
+			{
+				return (feature(0, column()) < threshold())? child(0):child(1);
+			}
+};*/
+
+
+template<class ColumnDecisionFunctor, class Tag = ClassificationTag>
+class RidgeSplit: public SplitBase<Tag>
+{
+  public:
+
+
+	typedef SplitBase<Tag> SB;
+
+	ArrayVector<Int32>          splitColumns;
+	ColumnDecisionFunctor       bgfunc;
+
+	double                      region_gini_;
+	ArrayVector<double>         min_gini_;
+	ArrayVector<ptrdiff_t>      min_indices_;
+	ArrayVector<double>         min_thresholds_;
+
+	int                         bestSplitIndex;
+	
+	//dns
+	bool			m_bDoScalingInTraining;
+	bool			m_bDoBestLambdaBasedOnGini;
+    
+	RidgeSplit()
+	:m_bDoScalingInTraining(true),
+	m_bDoBestLambdaBasedOnGini(true)
+	{
+	}
+
+	double minGini() const
+	{
+		return min_gini_[bestSplitIndex];
+	}
+	
+	int bestSplitColumn() const
+	{
+		return splitColumns[bestSplitIndex];
+	}
+	
+	bool& doScalingInTraining()
+	{ return m_bDoScalingInTraining; }
+
+	bool& doBestLambdaBasedOnGini()
+	{ return m_bDoBestLambdaBasedOnGini; }
+
+	template<class T>
+			void set_external_parameters(ProblemSpec<T> const & in)
+	{
+		SB::set_external_parameters(in);        
+		bgfunc.set_external_parameters(in);
+		int featureCount_ = in.column_count_;
+		splitColumns.resize(featureCount_);
+		for(int k=0; k<featureCount_; ++k)
+			splitColumns[k] = k;
+		min_gini_.resize(featureCount_);
+		min_indices_.resize(featureCount_);
+		min_thresholds_.resize(featureCount_);
+	}
+
+	
+    template<class T, class C, class T2, class C2, class Region, class Random>
+    int findBestSplit(MultiArrayView<2, T, C> features,
+                      MultiArrayView<2, T2, C2>  multiClassLabels,
+                      Region & region,
+                      ArrayVector<Region>& childRegions,
+                      Random & randint)
+    {
+
+	//std::cerr << "Split called" << std::endl;
+	typedef typename Region::IndexIterator IndexIterator;
+	typedef typename MultiArrayView <2, T, C>::difference_type fShape;
+	typedef typename MultiArrayView <2, T2, C2>::difference_type lShape;
+	typedef typename MultiArrayView <2, double>::difference_type dShape;
+        
+        // calculate things that haven't been calculated yet. 
+//	  std::cout << "start" << std::endl;
+        if(std::accumulate(region.classCounts().begin(),
+                           region.classCounts().end(), 0) != region.size())
+        {
+            RandomForestClassCounter<   MultiArrayView<2,T2, C2>, 
+                                        ArrayVector<double> >
+                counter(multiClassLabels, region.classCounts());
+            std::for_each(  region.begin(), region.end(), counter);
+            region.classCountsIsValid = true;
+        }
+
+
+        // Is the region pure already?
+	    region_gini_ = GiniCriterion::impurity(region.classCounts(),
+			    region.size());
+	    if(region_gini_ == 0 || region.size() < SB::ext_param_.actual_mtry_ || region.oob_size() < 2)
+		    return  makeTerminalNode(features, multiClassLabels, region, randint);
+
+        // select columns  to be tried.
+	for(int ii = 0; ii < SB::ext_param_.actual_mtry_; ++ii)
+		std::swap(splitColumns[ii], 
+			splitColumns[ii+ randint(features.shape(1) - ii)]);
+
+	//do implicit binary case
+	MultiArray<2, T2> labels(lShape(multiClassLabels.shape(0),1));
+	  //number of classes should be >1, otherwise makeTerminalNode would have been called
+	  int nNumClasses=0;
+	  for(int n=0; n<(int)region.classCounts().size(); n++)
+	    nNumClasses+=((region.classCounts()[n]>0) ? 1:0);
+	  
+	  //convert to binary case
+	  if(nNumClasses>2)
+	  {
+	    int nMaxClass=0;
+	    int nMaxClassCounts=0;
+	    for(int n=0; n<(int)region.classCounts().size(); n++)
+	    {
+	      //this should occur in any case:
+	      //we had more than two non-zero classes in order to get here
+	      if(region.classCounts()[n]>nMaxClassCounts)
+	      {
+		nMaxClassCounts=region.classCounts()[n];
+		nMaxClass=n;
+	      }
+	    }
+	    
+	    //create binary labels
+	    for(int n=0; n<multiClassLabels.shape(0); n++)
+	      labels(n,0)=((multiClassLabels(n,0)==nMaxClass) ? 1:0);
+	  }
+	  else
+	    labels=multiClassLabels;
+
+	//_do implicit binary case
+	
+	//uncomment this for some debugging
+/*	int nNumCases=features.shape(0);
+
+	typedef typename MultiArrayView <2, int>::difference_type nShape;
+	MultiArray<2, int> elementCounterArray(nShape(nNumCases,1),(int)0);
+	int nUniqueElements=0;
+	for(int n=0; n<region.size(); n++)
+		elementCounterArray[region[n]]++;
+	
+	for(int n=0; n<nNumCases; n++)
+		nUniqueElements+=((elementCounterArray[n]>0) ? 1:0);
+	
+	outm(nUniqueElements);
+	nUniqueElements=0;
+	MultiArray<2, int> elementCounterArray_oob(nShape(nNumCases,1),(int)0);
+	for(int n=0; n<region.oob_size(); n++)
+		elementCounterArray_oob[region.oob_begin()[n]]++;
+	for(int n=0; n<nNumCases; n++)
+		nUniqueElements+=((elementCounterArray_oob[n]>0) ? 1:0);
+	outm(nUniqueElements);
+	
+	int notUniqueElements=0;
+	for(int n=0; n<nNumCases; n++)
+		notUniqueElements+=(((elementCounterArray_oob[n]>0) && (elementCounterArray[n]>0)) ? 1:0);
+	outm(notUniqueElements);*/
+	
+	//outm(SB::ext_param_.actual_mtry_);
+	
+	
+//select submatrix of features for regression calculation
+	MultiArrayView<2, T, C> cVector;
+	MultiArray<2, T> xtrain(fShape(region.size(),SB::ext_param_.actual_mtry_));
+	//we only want -1 and 1 for this
+	MultiArray<2, double> regrLabels(dShape(region.size(),1));
+
+	//copy data into a vigra data structure and centre and scale while doing so
+	MultiArray<2, double> meanMatrix(dShape(SB::ext_param_.actual_mtry_,1));
+	MultiArray<2, double> stdMatrix(dShape(SB::ext_param_.actual_mtry_,1));
+	for(int m=0; m<SB::ext_param_.actual_mtry_; m++)
+	{
+		cVector=columnVector(features, splitColumns[m]);
+		
+		//centre and scale the data
+		double dCurrFeatureColumnMean=0.0;
+		double dCurrFeatureColumnStd=1.0; //default value
+		
+		//calc mean on bootstrap data
+		for(int n=0; n<region.size(); n++)
+		  dCurrFeatureColumnMean+=cVector[region[n]];
+		dCurrFeatureColumnMean/=region.size();
+		//calc scaling
+		if(m_bDoScalingInTraining)
+		{
+		  for(int n=0; n<region.size(); n++)
+		  {
+		      dCurrFeatureColumnStd+=
+			(cVector[region[n]]-dCurrFeatureColumnMean)*(cVector[region[n]]-dCurrFeatureColumnMean);
+		  }
+		  //unbiased std estimator:
+		  dCurrFeatureColumnStd=sqrt(dCurrFeatureColumnStd/(region.size()-1));
+		}
+		//dCurrFeatureColumnStd is still 1.0 if we didn't want scaling
+		stdMatrix(m,0)=dCurrFeatureColumnStd;
+		
+		meanMatrix(m,0)=dCurrFeatureColumnMean;
+		
+		//get feature matrix, i.e. A (note that weighting is done automatically
+		//since rows can occur multiple times -> bagging)
+		for(int n=0; n<region.size(); n++)
+			xtrain(n,m)=(cVector[region[n]]-dCurrFeatureColumnMean)/dCurrFeatureColumnStd;
+	}
+	
+//	  std::cout << "middle" << std::endl;
+	//get label vector (i.e. b)
+	for(int n=0; n<region.size(); n++)
+	{
+		//we checked for/built binary case further up.
+		//class labels should thus be either 0 or 1
+		//-> convert to -1 and 1 for regression
+		regrLabels(n,0)=((labels[region[n]]==0) ? -1:1);
+	}
+
+	MultiArray<2, double> dLambdas(dShape(11,1));
+	int nCounter=0;
+	for(int nLambda=-5; nLambda<=5; nLambda++)
+		dLambdas[nCounter++]=pow(10.0,nLambda);
+	//destination vector for regression coefficients; use same type as for xtrain
+	MultiArray<2, double> regrCoef(dShape(SB::ext_param_.actual_mtry_,11));
+	ridgeRegressionSeries(xtrain,regrLabels,regrCoef,dLambdas);
+	
+	double dMaxRidgeSum=NumericTraits<double>::min();
+	double dCurrRidgeSum;
+	int nMaxRidgeSumAtLambdaInd=0;
+
+	for(int nLambdaInd=0; nLambdaInd<11; nLambdaInd++)
+	{
+		//just sum up the correct answers
+		//(correct means >=intercept for class 1, <intercept for class 0)
+		//(intercept=0 or intercept=threshold based on gini)
+		dCurrRidgeSum=0.0;
+		
+		//assemble projection vector
+		MultiArray<2, double> dDistanceFromHyperplane(dShape(features.shape(0),1));
+		
+		for(int n=0; n<region.oob_size(); n++)
+		{
+		  dDistanceFromHyperplane(region.oob_begin()[n],0)=0.0;
+		  for (int m=0; m<SB::ext_param_.actual_mtry_; m++)
+		  {
+		    dDistanceFromHyperplane(region.oob_begin()[n],0)+=
+		      features(region.oob_begin()[n],splitColumns[m])*regrCoef(m,nLambdaInd);
+		  }
+		}
+
+		double dCurrIntercept=0.0;
+		if(m_bDoBestLambdaBasedOnGini)
+		{
+		  //calculate gini index
+		  bgfunc(dDistanceFromHyperplane,
+				 0,
+			  labels, 
+			  region.oob_begin(), region.oob_end(), 
+			  region.classCounts());
+		  dCurrIntercept=bgfunc.min_threshold_;
+		}
+		else
+		{
+		  for (int m=0; m<SB::ext_param_.actual_mtry_; m++)
+		    dCurrIntercept+=meanMatrix(m,0)*regrCoef(m,nLambdaInd);
+		}
+		
+		for(int n=0; n<region.oob_size(); n++)
+		{
+		    //check what lambda performs best on oob data
+		    int nClassPrediction=((dDistanceFromHyperplane(region.oob_begin()[n],0) >=dCurrIntercept) ? 1:0);
+		    dCurrRidgeSum+=((nClassPrediction == labels(region.oob_begin()[n],0)) ? 1:0);
+		}
+		if(dCurrRidgeSum>dMaxRidgeSum)
+		{
+			dMaxRidgeSum=dCurrRidgeSum;
+			nMaxRidgeSumAtLambdaInd=nLambdaInd;
+		}
+	}
+
+//	  std::cout << "middle2" << std::endl;
+        //create a Node for output
+	    Node<i_HyperplaneNode>   node(SB::ext_param_.actual_mtry_, SB::t_data, SB::p_data);
+
+	//normalise coeffs
+	    //data was scaled (by 1.0 or by std) -> take into account
+	    MultiArray<2, double> dCoeffVector(dShape(SB::ext_param_.actual_mtry_,1));
+	    for(int n=0; n<SB::ext_param_.actual_mtry_; n++)
+	      dCoeffVector(n,0)=regrCoef(n,nMaxRidgeSumAtLambdaInd)*stdMatrix(n,0);
+	    
+	    //calc norm
+	    double dVnorm=columnVector(regrCoef,nMaxRidgeSumAtLambdaInd).norm();
+
+	    for(int n=0; n<SB::ext_param_.actual_mtry_; n++)
+		    node.weights()[n]=dCoeffVector(n,0)/dVnorm;
+	//_normalise coeffs
+	
+	//save the columns
+	    node.column_data()[0]=SB::ext_param_.actual_mtry_;
+	    for(int n=0; n<SB::ext_param_.actual_mtry_; n++)
+		    node.column_data()[n+1]=splitColumns[n];
+
+	//assemble projection vector
+	    //careful here: "region" is a pointer to indices...
+	    //all the indices in "region" need to have valid data
+	    //convert from "region" space to original "feature" space
+	    MultiArray<2, double> dDistanceFromHyperplane(dShape(features.shape(0),1));
+	    
+	    for(int n=0; n<region.size(); n++)
+	    {
+		    dDistanceFromHyperplane(region[n],0)=0.0;
+		    for (int m=0; m<SB::ext_param_.actual_mtry_; m++)
+		    {
+		      dDistanceFromHyperplane(region[n],0)+=
+		       features(region[n],m)*node.weights()[m];
+		    }
+	    }
+	    for(int n=0; n<region.oob_size(); n++)
+	    {
+		    dDistanceFromHyperplane(region.oob_begin()[n],0)=0.0;
+		    for (int m=0; m<SB::ext_param_.actual_mtry_; m++)
+		    {
+		      dDistanceFromHyperplane(region.oob_begin()[n],0)+=
+			features(region.oob_begin()[n],m)*node.weights()[m];
+		    }
+	    }
+		
+	//calculate gini index
+	    bgfunc(dDistanceFromHyperplane,
+			   0,
+		    labels, 
+		    region.begin(), region.end(), 
+		    region.classCounts());
+	
+        // did not find any suitable split
+	if(closeAtTolerance(bgfunc.min_gini_, NumericTraits<double>::max()))
+		return  makeTerminalNode(features, multiClassLabels, region, randint);
+	
+	//take gini threshold here due to scaling, normalisation, etc. of the coefficients
+	node.intercept()	= bgfunc.min_threshold_;
+	SB::node_ = node;
+	
+	childRegions[0].classCounts() = bgfunc.bestCurrentCounts[0];
+	childRegions[1].classCounts() = bgfunc.bestCurrentCounts[1];
+	childRegions[0].classCountsIsValid = true;
+	childRegions[1].classCountsIsValid = true;
+	
+        // Save the ranges of the child stack entries.
+	childRegions[0].setRange(   region.begin()  , region.begin() + bgfunc.min_index_   );
+	childRegions[0].rule = region.rule;
+	childRegions[0].rule.push_back(std::make_pair(1, 1.0));
+	childRegions[1].setRange(   region.begin() + bgfunc.min_index_       , region.end()    );
+	childRegions[1].rule = region.rule;
+	childRegions[1].rule.push_back(std::make_pair(1, 1.0));
+	
+	//adjust oob ranges
+//	  std::cout << "adjust oob" << std::endl;
+	//sort the oobs
+	  std::sort(region.oob_begin(), region.oob_end(), 
+		    SortSamplesByDimensions< MultiArray<2, double> > (dDistanceFromHyperplane, 0));
+		    
+	  //find split index
+	  int nOOBindx;
+	  for(nOOBindx=0; nOOBindx<region.oob_size(); nOOBindx++)
+	  {
+	    if(dDistanceFromHyperplane(region.oob_begin()[nOOBindx],0)>=node.intercept())
+	      break;
+	  }
+
+	  childRegions[0].set_oob_range(   region.oob_begin()  , region.oob_begin() + nOOBindx   );
+	  childRegions[1].set_oob_range(   region.oob_begin() + nOOBindx , region.oob_end() );
+
+//	  std::cout << "end" << std::endl;
+//	  outm2(region.oob_begin());outm2(nOOBindx);outm(region.oob_begin() + nOOBindx);
+	//_adjust oob ranges
+
+	return i_HyperplaneNode;
+    }
+};
+
+/** Standard ridge regression split
+ */
+typedef RidgeSplit<BestGiniOfColumn<GiniCriterion> >  GiniRidgeSplit;
+
+
+} //namespace vigra
+#endif // VIGRA_RANDOM_FOREST_RIDGE_SPLIT_H

=== added file '.pc/fix-ftbfs-gcc4.7.diff/include/vigra/random_forest/rf_split.hxx'
--- .pc/fix-ftbfs-gcc4.7.diff/include/vigra/random_forest/rf_split.hxx	1970-01-01 00:00:00 +0000
+++ .pc/fix-ftbfs-gcc4.7.diff/include/vigra/random_forest/rf_split.hxx	2012-06-14 20:29:21 +0000
@@ -0,0 +1,1199 @@
+/************************************************************************/
+/*                                                                      */
+/*        Copyright 2008-2009 by  Ullrich Koethe and Rahul Nair         */
+/*                                                                      */
+/*    This file is part of the VIGRA computer vision library.           */
+/*    The VIGRA Website is                                              */
+/*        http://hci.iwr.uni-heidelberg.de/vigra/                       */
+/*    Please direct questions, bug reports, and contributions to        */
+/*        [e-mail]    or                    */
+/*        [e-mail]                               */
+/*                                                                      */
+/*    Permission is hereby granted, free of charge, to any person       */
+/*    obtaining a copy of this software and associated documentation    */
+/*    files (the "Software"), to deal in the Software without           */
+/*    restriction, including without limitation the rights to use,      */
+/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
+/*    sell copies of the Software, and to permit persons to whom the    */
+/*    Software is furnished to do so, subject to the following          */
+/*    conditions:                                                       */
+/*                                                                      */
+/*    The above copyright notice and this permission notice shall be    */
+/*    included in all copies or substantial portions of the             */
+/*    Software.                                                         */
+/*                                                                      */
+/*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
+/*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
+/*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
+/*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
+/*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
+/*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
+/*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
+/*    OTHER DEALINGS IN THE SOFTWARE.                                   */
+/*                                                                      */
+/************************************************************************/
+#ifndef VIGRA_RANDOM_FOREST_SPLIT_HXX
+#define VIGRA_RANDOM_FOREST_SPLIT_HXX
+#include <algorithm>
+#include <cstddef>
+#include <map>
+#include <numeric>
+#include <math.h>
+#include "../mathutil.hxx"
+#include "../array_vector.hxx"
+#include "../sized_int.hxx"
+#include "../matrix.hxx"
+#include "../random.hxx"
+#include "../functorexpression.hxx"
+#include "rf_nodeproxy.hxx"
+//#include "rf_sampling.hxx"
+#include "rf_region.hxx"
+//#include "../hokashyap.hxx"
+//#include "vigra/rf_helpers.hxx"
+
+namespace vigra
+{
+
+// Incomplete Class to ensure that findBestSplit is always implemented in
+// the derived classes of SplitBase
+class CompileTimeError;
+
+
+namespace detail
+{
+    template<class Tag>
+    class Normalise
+    {
+    public:
+        template<class Iter>
+        static void exec(Iter begin, Iter  end)
+        {}
+    };
+
+    template<>
+    class Normalise<ClassificationTag>
+    {
+    public:
+        template<class Iter>
+        static void exec (Iter begin, Iter end)
+        {
+            double bla = std::accumulate(begin, end, 0.0);
+            for(int ii = 0; ii < end - begin; ++ii)
+                begin[ii] = begin[ii]/bla ;
+        }
+    };
+}
+
+
+/** Base Class for all SplitFunctors used with the \ref RandomForest class
+    defines the interface used while learning a tree.
+**/
+template<class Tag>
+class SplitBase
+{
+  public:
+
+    typedef Tag           RF_Tag;
+    typedef DT_StackEntry<ArrayVectorView<Int32>::iterator>
+                                        StackEntry_t;
+
+    ProblemSpec<>           ext_param_;
+
+    NodeBase::T_Container_type          t_data;
+    NodeBase::P_Container_type          p_data;
+
+    NodeBase                            node_;
+
+    /** returns the DecisionTree Node created by
+        \ref findBestSplit or \ref makeTerminalNode.
+    **/
+
+    template<class T>
+    void set_external_parameters(ProblemSpec<T> const & in)
+    {
+        ext_param_ = in;
+        t_data.push_back(in.column_count_);
+        t_data.push_back(in.class_count_);
+    }
+
+    NodeBase & createNode() 
+    {
+        return node_;
+    }
+
+    int classCount() const
+    {
+        return int(t_data[1]);
+    }
+
+    int featureCount() const
+    {
+        return int(t_data[0]);
+    }
+
+    /** resets internal data. Should always be called before
+        calling findBestSplit or makeTerminalNode
+    **/
+    void reset()
+    {
+        t_data.resize(2);
+        p_data.resize(0);
+    }
+
+
+    /** findBestSplit has to be implemented in derived split functor.
+        these functions only insures That a CompileTime error is issued
+        if no such method was defined.
+    **/
+
+    template<class T, class C, class T2, class C2, class Region, class Random>
+    int findBestSplit(MultiArrayView<2, T, C> features,
+                      MultiArrayView<2, T2, C2> labels,
+                      Region region,
+                      ArrayVector<Region> childs,
+                      Random randint)
+    {
+        CompileTimeError SplitFunctor__findBestSplit_member_was_not_defined;
+        return 0;
+    }
+
+    /** default action for creating a terminal Node.
+        sets the Class probability of the remaining region according to
+        the class histogram
+    **/
+    template<class T, class C, class T2,class C2, class Region, class Random>
+    int makeTerminalNode(MultiArrayView<2, T, C> features,
+                      MultiArrayView<2, T2, C2>  labels,
+                      Region &                   region,
+                      Random                     randint)
+    {
+        Node<e_ConstProbNode> ret(t_data, p_data);
+        node_ = ret;
+        if(ext_param_.class_weights_.size() != region.classCounts().size())
+        {
+        std::copy(          region.classCounts().begin(),
+                            region.classCounts().end(),
+                            ret.prob_begin());
+        }
+        else
+        {
+        std::transform(     region.classCounts().begin(),
+                            region.classCounts().end(),
+                            ext_param_.class_weights_.begin(),
+                            ret.prob_begin(), std::multiplies<double>());
+        }
+        detail::Normalise<RF_Tag>::exec(ret.prob_begin(), ret.prob_end());
+        ret.weights() = region.size();  
+        return e_ConstProbNode;
+    }
+
+
+};
+
+/** Functor to sort the indices of a feature Matrix by a certain dimension
+**/
+template<class DataMatrix>
+class SortSamplesByDimensions
+{
+    DataMatrix const & data_;
+    MultiArrayIndex sortColumn_;
+    double thresVal_;
+  public:
+
+    SortSamplesByDimensions(DataMatrix const & data, 
+                            MultiArrayIndex sortColumn,
+                            double thresVal = 0.0)
+    : data_(data),
+      sortColumn_(sortColumn),
+      thresVal_(thresVal)
+    {}
+
+    void setColumn(MultiArrayIndex sortColumn)
+    {
+        sortColumn_ = sortColumn;
+    }
+    void setThreshold(double value)
+    {
+        thresVal_ = value; 
+    }
+
+    bool operator()(MultiArrayIndex l, MultiArrayIndex r) const
+    {
+        return data_(l, sortColumn_) < data_(r, sortColumn_);
+    }
+    bool operator()(MultiArrayIndex l) const
+    {
+        return data_(l, sortColumn_) < thresVal_;
+    }
+};
+
+template<class DataMatrix>
+class DimensionNotEqual
+{
+    DataMatrix const & data_;
+    MultiArrayIndex sortColumn_;
+
+  public:
+
+    DimensionNotEqual(DataMatrix const & data, 
+                            MultiArrayIndex sortColumn)
+    : data_(data),
+      sortColumn_(sortColumn)
+    {}
+
+    void setColumn(MultiArrayIndex sortColumn)
+    {
+        sortColumn_ = sortColumn;
+    }
+
+    bool operator()(MultiArrayIndex l, MultiArrayIndex r) const
+    {
+        return data_(l, sortColumn_) != data_(r, sortColumn_);
+    }
+};
+
+template<class DataMatrix>
+class SortSamplesByHyperplane
+{
+    DataMatrix const & data_;
+    Node<i_HyperplaneNode> const & node_;
+
+  public:
+
+    SortSamplesByHyperplane(DataMatrix              const & data, 
+                            Node<i_HyperplaneNode>  const & node)
+    :       
+            data_(data), 
+            node_()
+    {}
+
+    /** calculate the distance of a sample point to a hyperplane
+     */
+    double operator[](MultiArrayIndex l) const
+    {
+        double result_l = -1 * node_.intercept();
+        for(int ii = 0; ii < node_.columns_size(); ++ii)
+        {
+            result_l +=     rowVector(data_, l)[node_.columns_begin()[ii]] 
+                        *   node_.weights()[ii];
+        }
+        return result_l;
+    }
+
+    bool operator()(MultiArrayIndex l, MultiArrayIndex r) const
+    {
+        return (*this)[l]  < (*this)[r];
+    }
+
+};
+
+/** makes a Class Histogram given indices in a labels_ array
+ *  usage: 
+ *      MultiArrayView<2, T2, C2> labels = makeSomeLabels()
+ *      ArrayVector<int> hist(numberOfLabels(labels), 0);
+ *      RandomForestClassCounter<T2, C2, ArrayVector> counter(labels, hist);
+ *
+ *      Container<int> indices = getSomeIndices()
+ *      std::for_each(indices, counter);
+ */
+template <class DataSource, class CountArray>
+class RandomForestClassCounter
+{
+    DataSource  const &     labels_;
+    CountArray        &     counts_;
+
+  public:
+
+    RandomForestClassCounter(DataSource  const & labels, 
+                             CountArray & counts)
+    : labels_(labels),
+      counts_(counts)
+    {
+        reset();
+    }
+
+    void reset()
+    {
+        counts_.init(0);
+    }
+
+    void operator()(MultiArrayIndex l) const
+    {
+        counts_[labels_[l]] +=1;
+    }
+};
+
+
+/** Functor To Calculate the Best possible Split Based on the Gini Index
+    given Labels and Features along a given Axis
+*/
+
+namespace detail
+{
+    template<int N>
+    class ConstArr
+    {
+    public:
+        double operator[](size_t) const
+        {
+            return (double)N;
+        }
+    };
+
+
+}
+
+
+
+
+/** Functor to calculate the entropy based impurity
+ */
+class EntropyCriterion
+{
+public:
+    /**caculate the weighted gini impurity based on class histogram
+     * and class weights
+     */
+    template<class Array, class Array2>
+    double operator()        (Array     const & hist, 
+                              Array2    const & weights, 
+                              double            total = 1.0) const
+    {
+        return impurity(hist, weights, total);
+    }
+    
+    /** calculate the gini based impurity based on class histogram
+     */
+    template<class Array>
+    double operator()(Array const & hist, double total = 1.0) const
+    {
+        return impurity(hist, total);
+    }
+    
+    /** static version of operator(hist total)
+     */
+    template<class Array>
+    static double impurity(Array const & hist, double total)
+    {
+        return impurity(hist, detail::ConstArr<1>(), total);
+    }
+
+    /** static version of operator(hist, weights, total)
+     */
+    template<class Array, class Array2>
+    static double impurity   (Array     const & hist, 
+                              Array2    const & weights, 
+                              double            total)
+    {
+
+        int     class_count     = hist.size();
+        double  entropy            = 0.0;
+        if(class_count == 2)
+        {
+			double p0			= (hist[0]/total);
+			double p1			= (hist[1]/total);
+			entropy				= 0 - weights[0]*p0*std::log(p0) - weights[1]*p1*std::log(p1);
+        }
+        else
+        {
+            for(int ii = 0; ii < class_count; ++ii)
+            {
+                double w        = weights[ii];
+				double pii		= hist[ii]/total;
+                entropy         -= w*( pii*std::log(pii));
+            }
+        }
+  		entropy 			= total * entropy;
+        return entropy; 
+    }
+};
+
+/** Functor to calculate the gini impurity
+ */
+class GiniCriterion
+{
+public:
+    /**caculate the weighted gini impurity based on class histogram
+     * and class weights
+     */
+    template<class Array, class Array2>
+    double operator()        (Array     const & hist, 
+                              Array2    const & weights, 
+                              double            total = 1.0) const
+    {
+        return impurity(hist, weights, total);
+    }
+    
+    /** calculate the gini based impurity based on class histogram
+     */
+    template<class Array>
+    double operator()(Array const & hist, double total = 1.0) const
+    {
+        return impurity(hist, total);
+    }
+    
+    /** static version of operator(hist total)
+     */
+    template<class Array>
+    static double impurity(Array const & hist, double total)
+    {
+        return impurity(hist, detail::ConstArr<1>(), total);
+    }
+
+    /** static version of operator(hist, weights, total)
+     */
+    template<class Array, class Array2>
+    static double impurity   (Array     const & hist, 
+                              Array2    const & weights, 
+                              double            total)
+    {
+
+        int     class_count     = hist.size();
+        double  gini            = 0.0;
+        if(class_count == 2)
+        {
+            double w            = weights[0] * weights[1];
+            gini                = w * (hist[0] * hist[1] / total);
+        }
+        else
+        {
+            for(int ii = 0; ii < class_count; ++ii)
+            {
+                double w        = weights[ii];
+                gini           += w*( hist[ii]*( 1.0 - w * hist[ii]/total ) );
+            }
+        }
+        return gini; 
+    }
+};
+
+
+template <class DataSource, class Impurity= GiniCriterion>
+class ImpurityLoss
+{
+
+    DataSource  const &         labels_;
+    ArrayVector<double>        counts_;
+    ArrayVector<double> const  class_weights_;
+    double                      total_counts_;
+    Impurity                    impurity_;
+
+  public:
+
+    template<class T>
+    ImpurityLoss(DataSource  const & labels, 
+                                ProblemSpec<T> const & ext_)
+    : labels_(labels),
+      counts_(ext_.class_count_, 0.0),
+      class_weights_(ext_.class_weights_),
+      total_counts_(0.0)
+    {}
+
+    void reset()
+    {
+        counts_.init(0);
+        total_counts_ = 0.0;
+    }
+
+    template<class Counts>
+    double increment_histogram(Counts const & counts)
+    {
+        std::transform(counts.begin(), counts.end(),
+                       counts_.begin(), counts_.begin(),
+                       std::plus<double>());
+        total_counts_ = std::accumulate( counts_.begin(), 
+                                         counts_.end(),
+                                         0.0);
+        return impurity_(counts_, class_weights_, total_counts_);
+    }
+
+    template<class Counts>
+    double decrement_histogram(Counts const & counts)
+    {
+        std::transform(counts.begin(), counts.end(),
+                       counts_.begin(), counts_.begin(),
+                       std::minus<double>());
+        total_counts_ = std::accumulate( counts_.begin(), 
+                                         counts_.end(),
+                                         0.0);
+        return impurity_(counts_, class_weights_, total_counts_);
+    }
+
+    template<class Iter>
+    double increment(Iter begin, Iter end)
+    {
+        for(Iter iter = begin; iter != end; ++iter)
+        {
+            counts_[labels_(*iter, 0)] +=1.0;
+            total_counts_ +=1.0;
+        }
+        return impurity_(counts_, class_weights_, total_counts_);
+    }
+
+    template<class Iter>
+    double decrement(Iter const &  begin, Iter const & end)
+    {
+        for(Iter iter = begin; iter != end; ++iter)
+        {
+            counts_[labels_(*iter,0)] -=1.0;
+            total_counts_ -=1.0;
+        }
+        return impurity_(counts_, class_weights_, total_counts_);
+    }
+
+    template<class Iter, class Resp_t>
+    double init (Iter begin, Iter end, Resp_t resp)
+    {
+        reset();
+        std::copy(resp.begin(), resp.end(), counts_.begin());
+        total_counts_ = std::accumulate(counts_.begin(), counts_.end(), 0.0); 
+        return impurity_(counts_,class_weights_, total_counts_);
+    }
+    
+    ArrayVector<double> const & response()
+    {
+        return counts_;
+    }
+};
+
+template <class DataSource>
+class RegressionForestCounter
+{
+    typedef MultiArrayShape<2>::type Shp;
+    DataSource const &      labels_;
+    ArrayVector <double>    mean_;
+    ArrayVector <double>    variance_;
+    ArrayVector <double>    tmp_;
+    size_t                  count_;
+
+    template<class T>
+    RegressionForestCounter(DataSource const & labels, 
+                            ProblemSpec<T> const & ext_)
+    :
+        labels_(labels),
+        mean_(ext_.response_size, 0.0),
+        variance_(ext_.response_size, 0.0),
+        tmp_(ext_.response_size),
+        count_(0)
+    {}
+    
+    //  west's alorithm for incremental variance
+    // calculation
+    template<class Iter>
+    double increment (Iter begin, Iter end)
+    {
+        for(Iter iter = begin; iter != end; ++iter)
+        {
+            ++count_;
+            for(int ii = 0; ii < mean_.size(); ++ii)
+                tmp_[ii] = labels_(*iter, ii) - mean_[ii]; 
+            double f  = 1.0 / count_,
+                   f1 = 1.0 - f;
+            for(int ii = 0; ii < mean_.size(); ++ii)
+                mean_[ii] += f*tmp_[ii]; 
+            for(int ii = 0; ii < mean_.size(); ++ii)
+                variance_[ii] += f1*sq(tmp_[ii]);
+        }
+        return std::accumulate(variance_.begin(), 
+                               variance_.end(),
+                               0.0,
+                               std::plus<double>())
+                /(count_ -1);
+    }
+
+    template<class Iter>
+    double decrement (Iter begin, Iter end)
+    {
+        for(Iter iter = begin; iter != end; ++iter)
+        {
+            --count_;
+            for(int ii = 0; ii < mean_.size(); ++ii)
+                tmp_[ii] = labels_(*iter, ii) - mean_[ii]; 
+            double f  = 1.0 / count_,
+                   f1 = 1.0 + f;
+            for(int ii = 0; ii < mean_.size(); ++ii)
+                mean_[ii] -= f*tmp_[ii]; 
+            for(int ii = 0; ii < mean_.size(); ++ii)
+                variance_[ii] -= f1*sq(tmp_[ii]);
+        }
+        return std::accumulate(variance_.begin(), 
+                               variance_.end(),
+                               0.0,
+                               std::plus<double>())
+                /(count_ -1);
+    }
+
+    template<class Iter, class Resp_t>
+    double init (Iter begin, Iter end, Resp_t resp)
+    {
+        reset();
+        return increment(begin, end);
+    }
+    
+
+    ArrayVector<double> const & response()
+    {
+        return mean_;
+    }
+
+    void reset()
+    {
+        mean_.init(0.0);
+        variance_.init(0.0);
+        count_ = 0; 
+    }
+};
+
+template<class Tag, class Datatyp>
+struct LossTraits;
+
+struct LSQLoss
+{};
+
+template<class Datatype>
+struct LossTraits<GiniCriterion, Datatype>
+{
+    typedef ImpurityLoss<Datatype, GiniCriterion> type;
+};
+
+template<class Datatype>
+struct LossTraits<EntropyCriterion, Datatype>
+{
+    typedef ImpurityLoss<Datatype, EntropyCriterion> type;
+};
+
+template<class Datatype>
+struct LossTraits<LSQLoss, Datatype>
+{
+    typedef RegressionForestCounter<Datatype> type;
+};
+
+/** Given a column, choose a split that minimizes some loss
+ */
+template<class LineSearchLossTag>
+class BestGiniOfColumn
+{
+public:
+    ArrayVector<double>     class_weights_;
+    ArrayVector<double>     bestCurrentCounts[2];
+    double                  min_gini_;
+    ptrdiff_t               min_index_;
+    double                  min_threshold_;
+    ProblemSpec<>           ext_param_;
+
+    BestGiniOfColumn()
+    {}
+
+    template<class T> 
+    BestGiniOfColumn(ProblemSpec<T> const & ext)
+    :
+        class_weights_(ext.class_weights_),
+        ext_param_(ext)
+    {
+        bestCurrentCounts[0].resize(ext.class_count_);
+        bestCurrentCounts[1].resize(ext.class_count_);
+    }
+    template<class T> 
+    void set_external_parameters(ProblemSpec<T> const & ext)
+    {
+        class_weights_ = ext.class_weights_; 
+        ext_param_ = ext;
+        bestCurrentCounts[0].resize(ext.class_count_);
+        bestCurrentCounts[1].resize(ext.class_count_);
+    }
+    /** calculate the best gini split along a Feature Column
+     * \param column, the feature vector - has to support the [] operator
+     * \param labels, the label vector 
+     * \param begin 
+     * \param end     (in and out)
+     *                begin and end iterators to the indices of the
+     *                samples in the current region. 
+     *                the range begin - end is sorted by the column supplied
+     *                during function execution.
+     * \param class_counts
+     *                class histogram of the range. 
+     *
+     *  precondition: begin, end valid range, 
+     *                class_counts positive integer valued array with the 
+     *                class counts in the current range.
+     *                labels.size() >= max(begin, end); 
+     *  postcondition:
+     *                begin, end sorted by column given. 
+     *                min_gini_ contains the minimum gini found or 
+     *                NumericTraits<double>::max if no split was found.
+     *                min_index_ countains the splitting index in the range
+     *                or invalid data if no split was found.
+     *                BestCirremtcounts[0] and [1] contain the 
+     *                class histogram of the left and right region of 
+     *                the left and right regions. 
+     */
+    template<   class DataSourceF_t,
+                class DataSource_t, 
+                class I_Iter, 
+                class Array>
+    void operator()(DataSourceF_t   const & column,
+                    int                     g,
+                    DataSource_t    const & labels,
+                    I_Iter                & begin, 
+                    I_Iter                & end,
+                    Array           const & region_response)
+    {
+        std::sort(begin, end, 
+                  SortSamplesByDimensions<DataSourceF_t>(column, g));
+        typedef typename 
+            LossTraits<LineSearchLossTag, DataSource_t>::type LineSearchLoss;
+        LineSearchLoss left(labels, ext_param_);
+        LineSearchLoss right(labels, ext_param_);
+
+        
+
+        min_gini_ = right.init(begin, end, region_response);
+        min_threshold_ = *begin;
+        min_index_     = 0;
+        DimensionNotEqual<DataSourceF_t> comp(column, g); 
+        
+        I_Iter iter = begin;
+        I_Iter next = std::adjacent_find(iter, end, comp);
+        while( next  != end)
+        {
+
+            double loss = right.decrement(iter, next + 1) 
+                     +     left.increment(iter , next + 1);
+#ifdef CLASSIFIER_TEST
+            if(loss < min_gini_ && !closeAtTolerance(loss, min_gini_))
+#else
+            if(loss < min_gini_ )
+#endif 
+            {
+                bestCurrentCounts[0] = left.response();
+                bestCurrentCounts[1] = right.response();
+#ifdef CLASSIFIER_TEST
+                min_gini_       = loss < min_gini_? loss : min_gini_;
+#else
+                min_gini_       = loss; 
+#endif
+                min_index_      = next - begin +1 ;
+                min_threshold_  = (double(column(*next,g)) + double(column(*(next +1), g)))/2.0;
+            }
+            iter = next +1 ;
+            next = std::adjacent_find(iter, end, comp);
+        }
+    }
+
+    template<class DataSource_t, class Iter, class Array>
+    double loss_of_region(DataSource_t const & labels,
+                          Iter & begin, 
+                          Iter & end, 
+                          Array const & region_response) const
+    {
+        typedef typename 
+            LossTraits<LineSearchLossTag, DataSource_t>::type LineSearchLoss;
+        LineSearchLoss region_loss(labels, ext_param_);
+        return 
+            region_loss.init(begin, end, region_response);
+    }
+
+};
+
+
+/** Chooses mtry columns ad applys ColumnDecisionFunctor to each of the
+ * columns. Then Chooses the column that is best
+ */
+template<class ColumnDecisionFunctor, class Tag = ClassificationTag>
+class ThresholdSplit: public SplitBase<Tag>
+{
+  public:
+
+
+    typedef SplitBase<Tag> SB;
+    
+    ArrayVector<Int32>          splitColumns;
+    ColumnDecisionFunctor       bgfunc;
+
+    double                      region_gini_;
+    ArrayVector<double>         min_gini_;
+    ArrayVector<ptrdiff_t>      min_indices_;
+    ArrayVector<double>         min_thresholds_;
+
+    int                         bestSplitIndex;
+
+    double minGini() const
+    {
+        return min_gini_[bestSplitIndex];
+    }
+    int bestSplitColumn() const
+    {
+        return splitColumns[bestSplitIndex];
+    }
+    double bestSplitThreshold() const
+    {
+        return min_thresholds_[bestSplitIndex];
+    }
+
+    template<class T>
+    void set_external_parameters(ProblemSpec<T> const & in)
+    {
+        SB::set_external_parameters(in);        
+        bgfunc.set_external_parameters( SB::ext_param_);
+        int featureCount_ = SB::ext_param_.column_count_;
+        splitColumns.resize(featureCount_);
+        for(int k=0; k<featureCount_; ++k)
+            splitColumns[k] = k;
+        min_gini_.resize(featureCount_);
+        min_indices_.resize(featureCount_);
+        min_thresholds_.resize(featureCount_);
+    }
+
+
+    template<class T, class C, class T2, class C2, class Region, class Random>
+    int findBestSplit(MultiArrayView<2, T, C> features,
+                      MultiArrayView<2, T2, C2>  labels,
+                      Region & region,
+                      ArrayVector<Region>& childRegions,
+                      Random & randint)
+    {
+
+        typedef typename Region::IndexIterator IndexIterator;
+        if(region.size() == 0)
+        {
+           std::cerr << "SplitFunctor::findBestSplit(): stackentry with 0 examples encountered\n"
+                        "continuing learning process...."; 
+        }
+        // calculate things that haven't been calculated yet. 
+        
+        if(std::accumulate(region.classCounts().begin(),
+                           region.classCounts().end(), 0) != region.size())
+        {
+            RandomForestClassCounter<   MultiArrayView<2,T2, C2>, 
+                                        ArrayVector<double> >
+                counter(labels, region.classCounts());
+            std::for_each(  region.begin(), region.end(), counter);
+            region.classCountsIsValid = true;
+        }
+
+        // Is the region pure already?
+        region_gini_ = bgfunc.loss_of_region(labels,
+                                             region.begin(), 
+                                             region.end(),
+                                             region.classCounts());
+        if(region_gini_ <= SB::ext_param_.precision_)
+            return  makeTerminalNode(features, labels, region, randint);
+
+        // select columns  to be tried.
+        for(int ii = 0; ii < SB::ext_param_.actual_mtry_; ++ii)
+            std::swap(splitColumns[ii], 
+                      splitColumns[ii+ randint(features.shape(1) - ii)]);
+
+        // find the best gini index
+        bestSplitIndex              = 0;
+        double  current_min_gini    = region_gini_;
+        int     num2try             = features.shape(1);
+        for(int k=0; k<num2try; ++k)
+        {
+            //this functor does all the work
+            bgfunc(features,
+                   splitColumns[k],
+                   labels, 
+                   region.begin(), region.end(), 
+                   region.classCounts());
+            min_gini_[k]            = bgfunc.min_gini_; 
+            min_indices_[k]         = bgfunc.min_index_;
+            min_thresholds_[k]      = bgfunc.min_threshold_;
+#ifdef CLASSIFIER_TEST
+            if(     bgfunc.min_gini_ < current_min_gini
+               &&  !closeAtTolerance(bgfunc.min_gini_, current_min_gini))
+#else
+            if(bgfunc.min_gini_ < current_min_gini)
+#endif
+            {
+                current_min_gini = bgfunc.min_gini_;
+                childRegions[0].classCounts() = bgfunc.bestCurrentCounts[0];
+                childRegions[1].classCounts() = bgfunc.bestCurrentCounts[1];
+                childRegions[0].classCountsIsValid = true;
+                childRegions[1].classCountsIsValid = true;
+
+                bestSplitIndex   = k;
+                num2try = SB::ext_param_.actual_mtry_;
+            }
+        }
+
+        // did not find any suitable split
+        if(closeAtTolerance(current_min_gini, region_gini_))
+            return  makeTerminalNode(features, labels, region, randint);
+        
+        //create a Node for output
+        Node<i_ThresholdNode>   node(SB::t_data, SB::p_data);
+        SB::node_ = node;
+        node.threshold()    = min_thresholds_[bestSplitIndex];
+        node.column()       = splitColumns[bestSplitIndex];
+        
+        // partition the range according to the best dimension 
+        SortSamplesByDimensions<MultiArrayView<2, T, C> > 
+            sorter(features, node.column(), node.threshold());
+        IndexIterator bestSplit =
+            std::partition(region.begin(), region.end(), sorter);
+        // Save the ranges of the child stack entries.
+        childRegions[0].setRange(   region.begin()  , bestSplit       );
+        childRegions[0].rule = region.rule;
+        childRegions[0].rule.push_back(std::make_pair(1, 1.0));
+        childRegions[1].setRange(   bestSplit       , region.end()    );
+        childRegions[1].rule = region.rule;
+        childRegions[1].rule.push_back(std::make_pair(1, 1.0));
+
+        return i_ThresholdNode;
+    }
+};
+
+typedef  ThresholdSplit<BestGiniOfColumn<GiniCriterion> >                 	 GiniSplit;
+typedef  ThresholdSplit<BestGiniOfColumn<EntropyCriterion> >                 EntropySplit;
+typedef  ThresholdSplit<BestGiniOfColumn<LSQLoss>, RegressionTag>         	 RegressionSplit;
+
+namespace rf
+{
+
+/** This namespace contains additional Splitfunctors.
+ *
+ * The Split functor classes are designed in a modular fashion because new split functors may 
+ * share a lot of code with existing ones. 
+ * 
+ * ThresholdSplit implements the functionality needed for any split functor, that makes its 
+ * decision via one dimensional axis-parallel cuts. The Template parameter defines how the split
+ * along one dimension is chosen. 
+ *
+ * The BestGiniOfColumn class chooses a split that minimizes one of the Loss functions supplied
+ * (GiniCriterion for classification and LSQLoss for regression). Median chooses the Split in a 
+ * kD tree fashion. 
+ *
+ *
+ * Currently defined typedefs: 
+ * \code
+ * typedef  ThresholdSplit<BestGiniOfColumn<GiniCriterion> >                 GiniSplit;
+ * typedef  ThresholdSplit<BestGiniOfColumn<LSQLoss>, RegressionTag>         RegressionSplit;
+ * typedef  ThresholdSplit<Median> MedianSplit;
+ * \endcode
+ */
+namespace split
+{
+
+/** This Functor chooses the median value of a column
+ */
+class Median
+{
+public:
+
+    typedef GiniCriterion   LineSearchLossTag;
+    ArrayVector<double>     class_weights_;
+    ArrayVector<double>     bestCurrentCounts[2];
+    double                  min_gini_;
+    ptrdiff_t               min_index_;
+    double                  min_threshold_;
+    ProblemSpec<>           ext_param_;
+
+    Median()
+    {}
+
+    template<class T> 
+    Median(ProblemSpec<T> const & ext)
+    :
+        class_weights_(ext.class_weights_),
+        ext_param_(ext)
+    {
+        bestCurrentCounts[0].resize(ext.class_count_);
+        bestCurrentCounts[1].resize(ext.class_count_);
+    }
+  
+    template<class T> 
+    void set_external_parameters(ProblemSpec<T> const & ext)
+    {
+        class_weights_ = ext.class_weights_; 
+        ext_param_ = ext;
+        bestCurrentCounts[0].resize(ext.class_count_);
+        bestCurrentCounts[1].resize(ext.class_count_);
+    }
+     
+    template<   class DataSourceF_t,
+                class DataSource_t, 
+                class I_Iter, 
+                class Array>
+    void operator()(DataSourceF_t   const & column,
+                    DataSource_t    const & labels,
+                    I_Iter                & begin, 
+                    I_Iter                & end,
+                    Array           const & region_response)
+    {
+        std::sort(begin, end, 
+                  SortSamplesByDimensions<DataSourceF_t>(column, 0));
+        typedef typename 
+            LossTraits<LineSearchLossTag, DataSource_t>::type LineSearchLoss;
+        LineSearchLoss left(labels, ext_param_);
+        LineSearchLoss right(labels, ext_param_);
+        right.init(begin, end, region_response);
+
+        min_gini_ = NumericTraits<double>::max();
+        min_index_ = floor(double(end - begin)/2.0); 
+        min_threshold_ =  column[*(begin + min_index_)];
+        SortSamplesByDimensions<DataSourceF_t> 
+            sorter(column, 0, min_threshold_);
+        I_Iter part = std::partition(begin, end, sorter);
+        DimensionNotEqual<DataSourceF_t> comp(column, 0); 
+        if(part == begin)
+        {
+            part= std::adjacent_find(part, end, comp)+1;
+            
+        }
+        if(part >= end)
+        {
+            return; 
+        }
+        else
+        {
+            min_threshold_ = column[*part];
+        }
+        min_gini_ = right.decrement(begin, part) 
+              +     left.increment(begin , part);
+
+        bestCurrentCounts[0] = left.response();
+        bestCurrentCounts[1] = right.response();
+        
+        min_index_      = part - begin;
+    }
+
+    template<class DataSource_t, class Iter, class Array>
+    double loss_of_region(DataSource_t const & labels,
+                          Iter & begin, 
+                          Iter & end, 
+                          Array const & region_response) const
+    {
+        typedef typename 
+            LossTraits<LineSearchLossTag, DataSource_t>::type LineSearchLoss;
+        LineSearchLoss region_loss(labels, ext_param_);
+        return 
+            region_loss.init(begin, end, region_response);
+    }
+
+};
+
+typedef  ThresholdSplit<Median> MedianSplit;
+
+
+/** This Functor chooses a random value of a column
+ */
+class RandomSplitOfColumn
+{
+public:
+
+    typedef GiniCriterion   LineSearchLossTag;
+    ArrayVector<double>     class_weights_;
+    ArrayVector<double>     bestCurrentCounts[2];
+    double                  min_gini_;
+    ptrdiff_t               min_index_;
+    double                  min_threshold_;
+    ProblemSpec<>           ext_param_;
+	typedef RandomMT19937	Random_t;
+	Random_t				random;
+
+    RandomSplitOfColumn()
+    {}
+
+    template<class T> 
+    RandomSplitOfColumn(ProblemSpec<T> const & ext)
+    :
+        class_weights_(ext.class_weights_),
+        ext_param_(ext),
+		random(RandomSeed)
+    {
+        bestCurrentCounts[0].resize(ext.class_count_);
+        bestCurrentCounts[1].resize(ext.class_count_);
+    }
+    
+	template<class T> 
+    RandomSplitOfColumn(ProblemSpec<T> const & ext, Random_t & random_)
+    :
+        class_weights_(ext.class_weights_),
+        ext_param_(ext),
+		random(random_)
+    {
+        bestCurrentCounts[0].resize(ext.class_count_);
+        bestCurrentCounts[1].resize(ext.class_count_);
+    }
+  
+    template<class T> 
+    void set_external_parameters(ProblemSpec<T> const & ext)
+    {
+        class_weights_ = ext.class_weights_; 
+        ext_param_ = ext;
+        bestCurrentCounts[0].resize(ext.class_count_);
+        bestCurrentCounts[1].resize(ext.class_count_);
+    }
+     
+    template<   class DataSourceF_t,
+                class DataSource_t, 
+                class I_Iter, 
+                class Array>
+    void operator()(DataSourceF_t   const & column,
+                    DataSource_t    const & labels,
+                    I_Iter                & begin, 
+                    I_Iter                & end,
+                    Array           const & region_response)
+    {
+        std::sort(begin, end, 
+                  SortSamplesByDimensions<DataSourceF_t>(column, 0));
+        typedef typename 
+            LossTraits<LineSearchLossTag, DataSource_t>::type LineSearchLoss;
+        LineSearchLoss left(labels, ext_param_);
+        LineSearchLoss right(labels, ext_param_);
+        right.init(begin, end, region_response);
+
+		
+		min_gini_ = NumericTraits<double>::max();
+        
+		min_index_ = begin + random.uniformInt(end -begin);
+        min_threshold_ =  column[*(begin + min_index_)];
+        SortSamplesByDimensions<DataSourceF_t> 
+            sorter(column, 0, min_threshold_);
+        I_Iter part = std::partition(begin, end, sorter);
+        DimensionNotEqual<DataSourceF_t> comp(column, 0); 
+        if(part == begin)
+        {
+            part= std::adjacent_find(part, end, comp)+1;
+            
+        }
+        if(part >= end)
+        {
+            return; 
+        }
+        else
+        {
+            min_threshold_ = column[*part];
+        }
+        min_gini_ = right.decrement(begin, part) 
+              +     left.increment(begin , part);
+
+        bestCurrentCounts[0] = left.response();
+        bestCurrentCounts[1] = right.response();
+        
+        min_index_      = part - begin;
+    }
+
+    template<class DataSource_t, class Iter, class Array>
+    double loss_of_region(DataSource_t const & labels,
+                          Iter & begin, 
+                          Iter & end, 
+                          Array const & region_response) const
+    {
+        typedef typename 
+            LossTraits<LineSearchLossTag, DataSource_t>::type LineSearchLoss;
+        LineSearchLoss region_loss(labels, ext_param_);
+        return 
+            region_loss.init(begin, end, region_response);
+    }
+
+};
+
+typedef  ThresholdSplit<RandomSplitOfColumn> RandomSplit;
+}
+}
+
+
+} //namespace vigra
+#endif // VIGRA_RANDOM_FOREST_SPLIT_HXX

=== removed directory '.pc/sizeof_ldbl_not_sizeof_dbl.diff'
=== removed directory '.pc/sizeof_ldbl_not_sizeof_dbl.diff/include'
=== removed directory '.pc/sizeof_ldbl_not_sizeof_dbl.diff/include/vigra'
=== removed file '.pc/sizeof_ldbl_not_sizeof_dbl.diff/include/vigra/numpy_array.hxx'
--- .pc/sizeof_ldbl_not_sizeof_dbl.diff/include/vigra/numpy_array.hxx	2011-11-08 19:31:51 +0000
+++ .pc/sizeof_ldbl_not_sizeof_dbl.diff/include/vigra/numpy_array.hxx	1970-01-01 00:00:00 +0000
@@ -1,1918 +0,0 @@
-/************************************************************************/
-/*                                                                      */
-/*       Copyright 2009 by Ullrich Koethe and Hans Meine                */
-/*                                                                      */
-/*    This file is part of the VIGRA computer vision library.           */
-/*    The VIGRA Website is                                              */
-/*        http://hci.iwr.uni-heidelberg.de/vigra/                       */
-/*    Please direct questions, bug reports, and contributions to        */
-/*        [e-mail]    or                    */
-/*        [e-mail]                               */
-/*                                                                      */
-/*    Permission is hereby granted, free of charge, to any person       */
-/*    obtaining a copy of this software and associated documentation    */
-/*    files (the "Software"), to deal in the Software without           */
-/*    restriction, including without limitation the rights to use,      */
-/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
-/*    sell copies of the Software, and to permit persons to whom the    */
-/*    Software is furnished to do so, subject to the following          */
-/*    conditions:                                                       */
-/*                                                                      */
-/*    The above copyright notice and this permission notice shall be    */
-/*    included in all copies or substantial portions of the             */
-/*    Software.                                                         */
-/*                                                                      */
-/*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
-/*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
-/*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
-/*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
-/*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
-/*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
-/*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
-/*    OTHER DEALINGS IN THE SOFTWARE.                                   */
-/*                                                                      */
-/************************************************************************/
-
-#ifndef VIGRA_NUMPY_ARRAY_HXX
-#define VIGRA_NUMPY_ARRAY_HXX
-
-#include <Python.h>
-#include <iostream>
-#include <algorithm>
-#include <complex>
-#include <string>
-#include <sstream>
-#include <map>
-#include <vigra/multi_array.hxx>
-#include <vigra/array_vector.hxx>
-#include <vigra/sized_int.hxx>
-#include <vigra/python_utility.hxx>
-#include <numpy/arrayobject.h>
-
-int _import_array();
-
-namespace vigra {
-
-/********************************************************/
-/*                                                      */
-/*              Singleband and Multiband                */
-/*                                                      */
-/********************************************************/
-
-typedef float NumpyValueType;
-
-template <class T>
-struct Singleband  // the last array dimension is not to be interpreted as a channel dimension
-{
-    typedef T value_type;
-};
-
-template <class T>
-struct Multiband  // the last array dimension is a channel dimension
-{
-    typedef T value_type;
-};
-
-template<class T>
-struct NumericTraits<Singleband<T> >
-: public NumericTraits<T>
-{};
-
-template<class T>
-struct NumericTraits<Multiband<T> >
-{
-    typedef Multiband<T> Type;
-/*
-    typedef int Promote;
-    typedef unsigned int UnsignedPromote;
-    typedef double RealPromote;
-    typedef std::complex<RealPromote> ComplexPromote;
-*/
-    typedef Type ValueType;
-
-    typedef typename NumericTraits<T>::isIntegral isIntegral;
-    typedef VigraFalseType isScalar;
-    typedef typename NumericTraits<T>::isSigned isSigned;
-    typedef typename NumericTraits<T>::isSigned isOrdered;
-    typedef typename NumericTraits<T>::isSigned isComplex;
-/*
-    static signed char zero() { return 0; }
-    static signed char one() { return 1; }
-    static signed char nonZero() { return 1; }
-    static signed char min() { return SCHAR_MIN; }
-    static signed char max() { return SCHAR_MAX; }
-
-#ifdef NO_INLINE_STATIC_CONST_DEFINITION
-    enum { minConst = SCHAR_MIN, maxConst = SCHAR_MIN };
-#else
-    static const signed char minConst = SCHAR_MIN;
-    static const signed char maxConst = SCHAR_MIN;
-#endif
-
-    static Promote toPromote(signed char v) { return v; }
-    static RealPromote toRealPromote(signed char v) { return v; }
-    static signed char fromPromote(Promote v) {
-        return ((v < SCHAR_MIN) ? SCHAR_MIN : (v > SCHAR_MAX) ? SCHAR_MAX : v);
-    }
-    static signed char fromRealPromote(RealPromote v) {
-        return ((v < 0.0)
-                   ? ((v < (RealPromote)SCHAR_MIN)
-                       ? SCHAR_MIN
-                       : static_cast<signed char>(v - 0.5))
-                   : (v > (RealPromote)SCHAR_MAX)
-                       ? SCHAR_MAX
-                       : static_cast<signed char>(v + 0.5));
-    }
-*/
-};
-
-template <class T>
-class MultibandVectorAccessor
-{
-    MultiArrayIndex size_, stride_;
-
-  public:
-    MultibandVectorAccessor(MultiArrayIndex size, MultiArrayIndex stride)
-    : size_(size),
-      stride_(stride)
-    {}
-
-
-    typedef Multiband<T> value_type;
-
-        /** the vector's value_type
-        */
-    typedef T component_type;
-
-    typedef VectorElementAccessor<MultibandVectorAccessor<T> > ElementAccessor;
-
-        /** Read the component data at given vector index
-            at given iterator position
-        */
-    template <class ITERATOR>
-    component_type const & getComponent(ITERATOR const & i, int idx) const
-    {
-        return *(&*i+idx*stride_);
-    }
-
-        /** Set the component data at given vector index
-            at given iterator position. The type <TT>V</TT> of the passed
-            in <TT>value</TT> is automatically converted to <TT>component_type</TT>.
-            In case of a conversion floating point -> intergral this includes rounding and clipping.
-        */
-    template <class V, class ITERATOR>
-    void setComponent(V const & value, ITERATOR const & i, int idx) const
-    {
-        *(&*i+idx*stride_) = detail::RequiresExplicitCast<component_type>::cast(value);
-    }
-
-        /** Read the component data at given vector index
-            at an offset of given iterator position
-        */
-    template <class ITERATOR, class DIFFERENCE>
-    component_type const & getComponent(ITERATOR const & i, DIFFERENCE const & diff, int idx) const
-    {
-        return *(&i[diff]+idx*stride_);
-    }
-
-    /** Set the component data at given vector index
-        at an offset of given iterator position. The type <TT>V</TT> of the passed
-        in <TT>value</TT> is automatically converted to <TT>component_type</TT>.
-            In case of a conversion floating point -> intergral this includes rounding and clipping.
-    */
-    template <class V, class ITERATOR, class DIFFERENCE>
-    void
-    setComponent(V const & value, ITERATOR const & i, DIFFERENCE const & diff, int idx) const
-    {
-        *(&i[diff]+idx*stride_) = detail::RequiresExplicitCast<component_type>::cast(value);
-    }
-
-    template <class U>
-    MultiArrayIndex size(U) const
-    {
-        return size_;
-    }
-};
-
-/********************************************************/
-/*                                                      */
-/*                a few Python utilities                */
-/*                                                      */
-/********************************************************/
-
-namespace detail {
-
-inline long spatialDimensions(PyObject * obj)
-{
-    static python_ptr key(PyString_FromString("spatialDimensions"), python_ptr::keep_count);
-    python_ptr pres(PyObject_GetAttr(obj, key), python_ptr::keep_count);
-    long res = pres && PyInt_Check(pres)
-                 ? PyInt_AsLong(pres)
-                 : -1;
-    return res;
-}
-
-/*
- * The registry is used to optionally map specific C++ types to
- * specific python sub-classes of numpy.ndarray (for example,
- * MultiArray<2, Singleband<int> > to a user-defined Python class 'ScalarImage').
- *
- * One needs to use NUMPY_ARRAY_INITIALIZE_REGISTRY once in a python
- * extension module using this technique, in order to actually provide
- * the registry (this is done by vigranumpycmodule and will then be
- * available for other modules, too).  Alternatively,
- * NUMPY_ARRAY_DUMMY_REGISTRY may be used to disable this feature
- * completely.  In both cases, the macro must not be enclosed by any
- * namespace, so it is best put right at the beginning of the file
- * (e.g. below the #includes).
- */
-
-typedef std::map<std::string, std::pair<python_ptr, python_ptr> > ArrayTypeMap;
-
-VIGRA_EXPORT ArrayTypeMap * getArrayTypeMap();
-
-#define NUMPY_ARRAY_INITIALIZE_REGISTRY                                 \
-    namespace vigra { namespace detail {                                \
-    ArrayTypeMap * getArrayTypeMap()                                    \
-    {                                                                   \
-        static ArrayTypeMap arrayTypeMap;                               \
-        return &arrayTypeMap;                                           \
-    }                                                                   \
-    }} // namespace vigra::detail
-
-#define NUMPY_ARRAY_DUMMY_REGISTRY                      \
-    namespace vigra { namespace detail {                \
-    ArrayTypeMap * getArrayTypeMap()                    \
-    {                                                   \
-        return NULL;                                    \
-    }                                                   \
-    }} // namespace vigra::detail
-
-inline
-void registerPythonArrayType(std::string const & name, PyObject * obj, PyObject * typecheck)
-{
-    ArrayTypeMap *types = getArrayTypeMap();
-    vigra_precondition(
-        types != NULL,
-        "registerPythonArrayType(): module was compiled without array type registry.");
-    vigra_precondition(
-        obj && PyType_Check(obj) && PyType_IsSubtype((PyTypeObject *)obj, &PyArray_Type),
-        "registerPythonArrayType(obj): obj is not a subtype of numpy.ndarray.");
-    if(typecheck && PyCallable_Check(typecheck))
-        (*types)[name] = std::make_pair(python_ptr(obj), python_ptr(typecheck));
-    else
-        (*types)[name] = std::make_pair(python_ptr(obj), python_ptr());
-//    std::cerr << "Registering " << ((PyTypeObject *)obj)->tp_name << " for " << name << "\n";
-}
-
-inline
-python_ptr getArrayTypeObject(std::string const & name, PyTypeObject * def = 0)
-{
-    ArrayTypeMap *types = getArrayTypeMap();
-    if(!types)
-        // dummy registry -> handle like empty registry
-        return python_ptr((PyObject *)def);
-
-    python_ptr res;
-    ArrayTypeMap::iterator i = types->find(name);
-    if(i != types->end())
-        res = i->second.first;
-    else
-        res = python_ptr((PyObject *)def);
-//    std::cerr << "Requested " << name << ", got " << ((PyTypeObject *)res.get())->tp_name << "\n";
-    return res;
-}
-
-// there are two cases for the return:
-// * if a typecheck function was registered, it is returned
-// * a null pointer is returned if nothing was registered for either key, or if
-//   a type was registered without typecheck function
-inline python_ptr
-getArrayTypecheckFunction(std::string const & keyFull, std::string const & key)
-{
-    python_ptr res;
-    ArrayTypeMap *types = getArrayTypeMap();
-    if(types)
-    {
-        ArrayTypeMap::iterator i = types->find(keyFull);
-        if(i == types->end())
-            i = types->find(key);
-        if(i != types->end())
-            res = i->second.second;
-    }
-    return res;
-}
-
-inline bool
-performCustomizedArrayTypecheck(PyObject * obj, std::string const & keyFull, std::string const & key)
-{
-    if(obj == 0 || !PyArray_Check(obj))
-        return false;
-    python_ptr typecheck = getArrayTypecheckFunction(keyFull, key);
-    if(typecheck == 0)
-        return true; // no custom test registered
-    python_ptr args(PyTuple_Pack(1, obj), python_ptr::keep_count);
-    pythonToCppException(args);
-    python_ptr res(PyObject_Call(typecheck.get(), args.get(), 0), python_ptr::keep_count);
-    pythonToCppException(res);
-    vigra_precondition(PyBool_Check(res),
-           "NumpyArray conversion: registered typecheck function did not return a boolean.");
-    return (void*)res.get() == (void*)Py_True;
-}
-
-inline
-python_ptr constructNumpyArrayImpl(
-    PyTypeObject * type,
-    ArrayVector<npy_intp> const & shape, npy_intp *strides,
-    NPY_TYPES typeCode, bool init)
-{
-    python_ptr array;
-
-    if(strides == 0)
-    {
-        array = python_ptr(PyArray_New(type, shape.size(), (npy_intp *)shape.begin(), typeCode, 0, 0, 0, 1 /* Fortran order */, 0),
-                           python_ptr::keep_count);
-    }
-    else
-    {
-        int N = shape.size();
-        ArrayVector<npy_intp> pshape(N);
-        for(int k=0; k<N; ++k)
-            pshape[strides[k]] = shape[k];
-
-        array = python_ptr(PyArray_New(type, N, pshape.begin(), typeCode, 0, 0, 0, 1 /* Fortran order */, 0),
-                           python_ptr::keep_count);
-        pythonToCppException(array);
-
-        PyArray_Dims permute = { strides, N };
-        array = python_ptr(PyArray_Transpose((PyArrayObject*)array.get(), &permute), python_ptr::keep_count);
-    }
-    pythonToCppException(array);
-
-    if(init)
-        PyArray_FILLWBYTE((PyArrayObject *)array.get(), 0);
-
-    return array;
-}
-
-// strideOrdering will be ignored unless order == "A"
-// TODO: this function should receive some refactoring in order to make
-//       the rules clear from the code rather than from comments
-inline python_ptr
-constructNumpyArrayImpl(PyTypeObject * type, ArrayVector<npy_intp> const & shape,
-                       unsigned int spatialDimensions, unsigned int channels,
-                       NPY_TYPES typeCode, std::string order, bool init,
-                       ArrayVector<npy_intp> strideOrdering = ArrayVector<npy_intp>())
-{
-    // shape must have at least length spatialDimensions, but can also have a channel dimension
-    vigra_precondition(shape.size() == spatialDimensions || shape.size() == spatialDimensions + 1,
-           "constructNumpyArray(type, shape, ...): shape has wrong length.");
-
-    // if strideOrdering is given, it must have at least length spatialDimensions,
-    // but can also have a channel dimension
-    vigra_precondition(strideOrdering.size() == 0 || strideOrdering.size() == spatialDimensions ||
-                       strideOrdering.size() == spatialDimensions + 1,
-           "constructNumpyArray(type, ..., strideOrdering): strideOrdering has wrong length.");
-
-    if(channels == 0) // if the requested number of channels is not given ...
-    {
-        // ... deduce it
-        if(shape.size() == spatialDimensions)
-            channels = 1;
-        else
-            channels = shape.back();
-    }
-    else
-    {
-        // otherwise, if the shape object also contains a channel dimension, they must be consistent
-        if(shape.size() > spatialDimensions)
-            vigra_precondition(channels == (unsigned int)shape[spatialDimensions],
-                   "constructNumpyArray(type, ...): shape contradicts requested number of channels.");
-    }
-
-    // if we have only one channel, no explicit channel dimension should be in the shape
-    unsigned int shapeSize = channels == 1
-                                  ? spatialDimensions
-                                  : spatialDimensions + 1;
-
-    // create the shape object with optional channel dimension
-    ArrayVector<npy_intp> pshape(shapeSize);
-    std::copy(shape.begin(), shape.begin()+std::min(shape.size(), pshape.size()), pshape.begin());
-    if(shapeSize > spatialDimensions)
-        pshape[spatialDimensions] = channels;
-
-    // order "A" means "preserve order" when an array is copied, and
-    // defaults to "V" when a new array is created without explicit strideOrdering
-    //
-    if(order == "A")
-    {
-        if(strideOrdering.size() == 0)
-        {
-            order = "V";
-        }
-        else if(strideOrdering.size() > shapeSize)
-        {
-            // make sure that strideOrdering length matches shape length
-            ArrayVector<npy_intp> pstride(strideOrdering.begin(), strideOrdering.begin()+shapeSize);
-
-            // adjust the ordering when the channel dimension has been dropped because channel == 1
-            if(strideOrdering[shapeSize] == 0)
-                for(unsigned int k=0; k<shapeSize; ++k)
-                    pstride[k] -= 1;
-            pstride.swap(strideOrdering);
-        }
-        else if(strideOrdering.size() < shapeSize)
-        {
-            // make sure that strideOrdering length matches shape length
-            ArrayVector<npy_intp> pstride(shapeSize);
-
-            // adjust the ordering when the channel dimension has been dropped because channel == 1
-            for(unsigned int k=0; k<shapeSize-1; ++k)
-                pstride[k] = strideOrdering[k] + 1;
-            pstride[shapeSize-1] = 0;
-            pstride.swap(strideOrdering);
-        }
-    }
-
-    // create the appropriate strideOrdering objects for the other memory orders
-    // (when strideOrdering already contained data, it is ignored because order != "A")
-    if(order == "C")
-    {
-        strideOrdering.resize(shapeSize);
-        for(unsigned int k=0; k<shapeSize; ++k)
-            strideOrdering[k] = shapeSize-1-k;
-    }
-    else if(order == "F" || (order == "V" && channels == 1))
-    {
-        strideOrdering.resize(shapeSize);
-        for(unsigned int k=0; k<shapeSize; ++k)
-            strideOrdering[k] = k;
-    }
-    else if(order == "V")
-    {
-        strideOrdering.resize(shapeSize);
-        for(unsigned int k=0; k<shapeSize-1; ++k)
-            strideOrdering[k] = k+1;
-        strideOrdering[shapeSize-1] = 0;
-    }
-
-    return constructNumpyArrayImpl(type, pshape, strideOrdering.begin(), typeCode, init);
-}
-
-template <class TINY_VECTOR>
-inline
-python_ptr constructNumpyArrayFromData(
-    std::string const & typeKeyFull,
-    std::string const & typeKey,
-    TINY_VECTOR const & shape, npy_intp *strides,
-    NPY_TYPES typeCode, void *data)
-{
-    ArrayVector<npy_intp> pyShape(shape.begin(), shape.end());
-
-    python_ptr type = detail::getArrayTypeObject(typeKeyFull);
-    if(type == 0)
-        type = detail::getArrayTypeObject(typeKey, &PyArray_Type);
-
-    python_ptr array(PyArray_New((PyTypeObject *)type.ptr(), shape.size(), pyShape.begin(), typeCode, strides, data, 0, NPY_WRITEABLE, 0),
-                     python_ptr::keep_count);
-    pythonToCppException(array);
-
-    return array;
-}
-
-
-} // namespace detail
-
-/********************************************************/
-/*                                                      */
-/*               NumpyArrayValuetypeTraits              */
-/*                                                      */
-/********************************************************/
-
-template<class ValueType>
-struct ERROR_NumpyArrayValuetypeTraits_not_specialized_for_ { };
-
-template<class ValueType>
-struct NumpyArrayValuetypeTraits
-{
-    static bool isValuetypeCompatible(PyArrayObject const * obj)
-    {
-        return ERROR_NumpyArrayValuetypeTraits_not_specialized_for_<ValueType>();
-    }
-
-    static ERROR_NumpyArrayValuetypeTraits_not_specialized_for_<ValueType> typeCode;
-
-    static std::string typeName()
-    {
-        return std::string("ERROR: NumpyArrayValuetypeTraits not specialized for this case");
-    }
-
-    static std::string typeNameImpex()
-    {
-        return std::string("ERROR: NumpyArrayValuetypeTraits not specialized for this case");
-    }
-
-    static PyObject * typeObject()
-    {
-        return (PyObject *)0;
-    }
-};
-
-template<class ValueType>
-ERROR_NumpyArrayValuetypeTraits_not_specialized_for_<ValueType> NumpyArrayValuetypeTraits<ValueType>::typeCode;
-
-#define VIGRA_NUMPY_VALUETYPE_TRAITS(type, typeID, numpyTypeName, impexTypeName) \
-template <> \
-struct NumpyArrayValuetypeTraits<type > \
-{ \
-    static bool isValuetypeCompatible(PyArrayObject const * obj) /* obj must not be NULL */ \
-    { \
-        return PyArray_EquivTypenums(typeID, PyArray_DESCR((PyObject *)obj)->type_num) && \
-               PyArray_ITEMSIZE((PyObject *)obj) == sizeof(type); \
-    } \
-    \
-    static NPY_TYPES const typeCode = typeID; \
-    \
-    static std::string typeName() \
-    { \
-        return #numpyTypeName; \
-    } \
-    \
-    static std::string typeNameImpex() \
-    { \
-        return impexTypeName; \
-    } \
-    \
-    static PyObject * typeObject() \
-    { \
-        return PyArray_TypeObjectFromType(typeID); \
-    } \
-};
-
-VIGRA_NUMPY_VALUETYPE_TRAITS(bool,           NPY_BOOL, bool, "UINT8")
-VIGRA_NUMPY_VALUETYPE_TRAITS(signed char,    NPY_INT8, int8, "INT16")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned char,  NPY_UINT8, uint8, "UINT8")
-VIGRA_NUMPY_VALUETYPE_TRAITS(short,          NPY_INT16, int16, "INT16")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned short, NPY_UINT16, uint16, "UINT16")
-
-#if VIGRA_BITSOF_LONG == 32
-VIGRA_NUMPY_VALUETYPE_TRAITS(long,           NPY_INT32, int32, "INT32")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned long,  NPY_UINT32, uint32, "UINT32")
-#elif VIGRA_BITSOF_LONG == 64
-VIGRA_NUMPY_VALUETYPE_TRAITS(long,           NPY_INT64, int64, "DOUBLE")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned long,  NPY_UINT64, uint64, "DOUBLE")
-#endif
-
-#if VIGRA_BITSOF_INT == 32
-VIGRA_NUMPY_VALUETYPE_TRAITS(int,            NPY_INT32, int32, "INT32")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned int,   NPY_UINT32, uint32, "UINT32")
-#elif VIGRA_BITSOF_INT == 64
-VIGRA_NUMPY_VALUETYPE_TRAITS(int,            NPY_INT64, int64, "DOUBLE")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned int,   NPY_UINT64, uint64, "DOUBLE")
-#endif
-
-#ifdef PY_LONG_LONG
-# if VIGRA_BITSOF_LONG_LONG == 32
-VIGRA_NUMPY_VALUETYPE_TRAITS(long long,            NPY_INT32, int32, "INT32")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned long long,   NPY_UINT32, uint32, "UINT32")
-# elif VIGRA_BITSOF_LONG_LONG == 64
-VIGRA_NUMPY_VALUETYPE_TRAITS(long long,          NPY_INT64, int64, "DOUBLE")
-VIGRA_NUMPY_VALUETYPE_TRAITS(unsigned long long, NPY_UINT64, uint64, "DOUBLE")
-# endif
-#endif
-
-VIGRA_NUMPY_VALUETYPE_TRAITS(npy_float32, NPY_FLOAT32, float32, "FLOAT")
-VIGRA_NUMPY_VALUETYPE_TRAITS(npy_float64, NPY_FLOAT64, float64, "DOUBLE")
-VIGRA_NUMPY_VALUETYPE_TRAITS(npy_longdouble, NPY_LONGDOUBLE, longdouble, "")
-VIGRA_NUMPY_VALUETYPE_TRAITS(npy_cfloat, NPY_CFLOAT, complex64, "")
-VIGRA_NUMPY_VALUETYPE_TRAITS(std::complex<npy_float>, NPY_CFLOAT, complex64, "")
-VIGRA_NUMPY_VALUETYPE_TRAITS(npy_cdouble, NPY_CDOUBLE, complex128, "")
-VIGRA_NUMPY_VALUETYPE_TRAITS(std::complex<npy_double>, NPY_CDOUBLE, complex128, "")
-VIGRA_NUMPY_VALUETYPE_TRAITS(npy_clongdouble, NPY_CLONGDOUBLE, clongdouble, "")
-VIGRA_NUMPY_VALUETYPE_TRAITS(std::complex<npy_longdouble>, NPY_CLONGDOUBLE, clongdouble, "")
-
-#undef VIGRA_NUMPY_VALUETYPE_TRAITS
-
-/********************************************************/
-/*                                                      */
-/*                  NumpyArrayTraits                    */
-/*                                                      */
-/********************************************************/
-
-template <class U, int N>
-bool stridesAreAscending(TinyVector<U, N> const & strides)
-{
-    for(int k=1; k<N; ++k)
-        if(strides[k] < strides[k-1])
-            return false;
-    return true;
-}
-
-template<unsigned int N, class T, class Stride>
-struct NumpyArrayTraits;
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, T, StridedArrayTag>
-{
-    typedef T dtype;
-    typedef T value_type;
-    typedef NumpyArrayValuetypeTraits<T> ValuetypeTraits;
-    static NPY_TYPES const typeCode = ValuetypeTraits::typeCode;
-
-    enum { spatialDimensions = N, channels = 1 };
-
-    static bool isArray(PyObject * obj)
-    {
-        return obj && PyArray_Check(obj);
-    }
-
-    static bool isClassCompatible(PyObject * obj)
-    {
-        return detail::performCustomizedArrayTypecheck(obj, typeKeyFull(), typeKey());
-    }
-
-    static bool isValuetypeCompatible(PyArrayObject * obj)  /* obj must not be NULL */
-    {
-        return ValuetypeTraits::isValuetypeCompatible(obj);
-    }
-
-    static bool isShapeCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return PyArray_NDIM((PyObject *)obj) == N-1 ||
-               PyArray_NDIM((PyObject *)obj) == N ||
-               (PyArray_NDIM((PyObject *)obj) == N+1 && PyArray_DIM((PyObject *)obj, N) == 1);
-    }
-
-    static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return ValuetypeTraits::isValuetypeCompatible(obj) &&
-               isShapeCompatible(obj);
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N> npyStride(stride * sizeof(T));
-        return detail::constructNumpyArrayFromData(typeKeyFull(), typeKey(), shape, npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKey()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", *>";
-        return key;
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", " +
-                                 ValuetypeTraits::typeName() + ", StridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, T, UnstridedArrayTag>
-: public NumpyArrayTraits<N, T, StridedArrayTag>
-{
-    typedef NumpyArrayTraits<N, T, StridedArrayTag> BaseType;
-    typedef typename BaseType::ValuetypeTraits ValuetypeTraits;
-
-    static bool isShapeCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return BaseType::isShapeCompatible(obj) &&
-               PyArray_STRIDES((PyObject *)obj)[0] == PyArray_ITEMSIZE((PyObject *)obj);
-    }
-
-    static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return BaseType::isValuetypeCompatible(obj) &&
-               isShapeCompatible(obj);
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N> npyStride(stride * sizeof(T));
-        return detail::constructNumpyArrayFromData(typeKeyFull(), BaseType::typeKey(), shape, npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", " +
-                                 ValuetypeTraits::typeName() + ", UnstridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, Singleband<T>, StridedArrayTag>
-: public NumpyArrayTraits<N, T, StridedArrayTag>
-{
-    typedef NumpyArrayTraits<N, T, StridedArrayTag> BaseType;
-    typedef typename BaseType::ValuetypeTraits ValuetypeTraits;
-
-    static bool isClassCompatible(PyObject * obj)
-    {
-        return detail::performCustomizedArrayTypecheck(obj, typeKeyFull(), typeKey());
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N> npyStride(stride * sizeof(T));
-        return detail::constructNumpyArrayFromData(typeKeyFull(), typeKey(), shape, npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKey()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", Singleband<*> >";
-        return key;
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", Singleband<" +
-                                 ValuetypeTraits::typeName() + ">, StridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, Singleband<T>, UnstridedArrayTag>
-: public NumpyArrayTraits<N, Singleband<T>, StridedArrayTag>
-{
-    typedef NumpyArrayTraits<N, T, UnstridedArrayTag> UnstridedTraits;
-    typedef NumpyArrayTraits<N, Singleband<T>, StridedArrayTag> BaseType;
-    typedef typename BaseType::ValuetypeTraits ValuetypeTraits;
-
-    static bool isShapeCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return UnstridedTraits::isShapeCompatible(obj);
-    }
-
-    static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return UnstridedTraits::isPropertyCompatible(obj);
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N> npyStride(stride * sizeof(T));
-        return detail::constructNumpyArrayFromData(typeKeyFull(), BaseType::typeKey(), shape, npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", Singleband<" +
-                                 ValuetypeTraits::typeName() + ">, UnstridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, Multiband<T>, StridedArrayTag>
-: public NumpyArrayTraits<N, T, StridedArrayTag>
-{
-    typedef NumpyArrayTraits<N, T, StridedArrayTag> BaseType;
-    typedef typename BaseType::ValuetypeTraits ValuetypeTraits;
-
-    enum { spatialDimensions = N-1, channels = 0 };
-
-    static bool isClassCompatible(PyObject * obj)
-    {
-        return detail::performCustomizedArrayTypecheck(obj, typeKeyFull(), typeKey());
-    }
-
-    static bool isShapeCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return PyArray_NDIM(obj) == N || PyArray_NDIM(obj) == N-1;
-    }
-
-    static bool isPropertyCompatible(PyArrayObject * obj) /* obj must not be NULL */
-    {
-        return ValuetypeTraits::isValuetypeCompatible(obj) &&
-               isShapeCompatible(obj);
-    }
-
-    template <class U>
-    static python_ptr constructor(TinyVector<U, N> const & shape,
-                                  T *data, TinyVector<U, N> const & stride)
-    {
-        TinyVector<npy_intp, N> npyStride(stride * sizeof(T));
-        return detail::constructNumpyArrayFromData(typeKeyFull(), typeKey(), shape, npyStride.begin(), ValuetypeTraits::typeCode, data);
-    }
-
-    static std::string typeKey()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", Multiband<*> >";
-        return key;
-    }
-
-    static std::string typeKeyFull()
-    {
-        static std::string key = std::string("NumpyArray<") + asString(N) + ", Multiband<" +
-                                 ValuetypeTraits::typeName() + ">, StridedArrayTag>";
-        return key;
-    }
-};
-
-/********************************************************/
-
-template<unsigned int N, class T>
-struct NumpyArrayTraits<N, Multiband<T>, UnstridedArrayTag>
-: public NumpyArrayTraits<N, Multiband<T>, StridedArrayTag>
-{
-    typedef NumpyArrayTraits<N, Multiband<T>, StridedArrayTag> BaseType;
-    typedef typename BaseType::ValuetypeTraits ValuetypeTraits;