  class ImageArray
  {
      Size2D imageSize_;
---- misc/build/vigra1.4.0/include/vigra/orientedtensorfilters.hxx	2005-12-21 05:53:42.000000000 +0100
-+++ misc/vigra1.4.0/include/vigra/orientedtensorfilters.hxx	2006-05-30 11:56:11.000000000 +0200
+diff -uprN misc/vigra1.4.0/include/vigra/mathutil.hxx misc/build/vigra1.4.0/include/vigra/mathutil.hxx
+--- misc/vigra1.4.0/include/vigra/mathutil.hxx	2005-12-21 05:53:39.000000000 +0100
++++ misc/build/vigra1.4.0/include/vigra/mathutil.hxx	2006-08-31 12:08:15.449199000 +0200
+@@ -73,8 +73,6 @@
+ 
+ namespace vigra {
+ 
+-#ifndef __sun 
+-
+ /** \addtogroup MathFunctions Mathematical Functions
+ 
+     Useful mathematical functions and functors.
+@@ -109,18 +107,11 @@ double erf(T x)
+         return ans - 1.0;
+ }
+ 
+-#else
+-
+-using VIGRA_CSTD::erf;
+-
+-#endif
+-
+ // import functions into namespace vigra which VIGRA is going to overload
+ 
+ using VIGRA_CSTD::pow;  
+ using VIGRA_CSTD::floor;  
+ using VIGRA_CSTD::ceil;  
+-using std::abs;  
+ 
+ #define VIGRA_DEFINE_UNSIGNED_ABS(T) \
+     inline T abs(T t) { return t; }
+@@ -130,9 +121,39 @@ VIGRA_DEFINE_UNSIGNED_ABS(unsigned char)
+ VIGRA_DEFINE_UNSIGNED_ABS(unsigned short)
+ VIGRA_DEFINE_UNSIGNED_ABS(unsigned int)
+ VIGRA_DEFINE_UNSIGNED_ABS(unsigned long)
++#ifdef VIGRA_HAS_LONG_LONG
++VIGRA_DEFINE_UNSIGNED_ABS(unsigned long long)
++#endif
+ 
+ #undef VIGRA_DEFINE_UNSIGNED_ABS
+ 
++#define VIGRA_DEFINE_SIGNED_ABS(T) \
++    inline T abs(T t) { return (T)abs(t); }
++#define VIGRA_DEFINE_SIGNED_LABS(T) \
++    inline T abs(T t) { return (T)labs(t); }
++#define VIGRA_DEFINE_SIGNED_LLABS(T) \
++    inline T abs(T t) { return (T)llabs(t); }
++#define VIGRA_DEFINE_FABS(T) \
++    inline T abs(T t) { return (T)fabs(t); }
++
++VIGRA_DEFINE_SIGNED_ABS(signed char)
++VIGRA_DEFINE_SIGNED_ABS(signed short)
++VIGRA_DEFINE_SIGNED_ABS(signed int)
++VIGRA_DEFINE_SIGNED_LABS(signed long)
++#ifdef VIGRA_HAS_LONG_LONG
++VIGRA_DEFINE_SIGNED_LLABS(signed long long)
++#endif
++VIGRA_DEFINE_FABS(float)
++VIGRA_DEFINE_FABS(double)
++#ifdef VIGRA_HAS_LONG_DOUBLE
++VIGRA_DEFINE_FABS(long double)
++#endif
++
++#undef VIGRA_DEFINE_SIGNED_ABS
++#undef VIGRA_DEFINE_SIGNED_LABS
++#undef VIGRA_DEFINE_SIGNED_LLABS
++#undef VIGRA_DEFINE_FABS
++
+     /*! The rounding function.
+ 
+         Defined for all floating point types. Rounds towards the nearest integer for both 
+@@ -155,12 +176,14 @@ inline double round(double t)
+                : ceil(t - 0.5);
+ }
+ 
++#ifdef VIGRA_HAS_LONG_DOUBLE
+ inline long double round(long double t)
+ {
+     return t >= 0.0
+                ? floor(t + 0.5)
+                : ceil(t - 0.5);
+ }
++#endif
+ 
+     /*! The square function.
+ 
+@@ -371,9 +394,15 @@ VIGRA_DEFINE_NORM(int)
+ VIGRA_DEFINE_NORM(unsigned int)
+ VIGRA_DEFINE_NORM(long)
+ VIGRA_DEFINE_NORM(unsigned long)
++#ifdef VIGRA_HAS_LONG_LONG
++VIGRA_DEFINE_NORM(long long)
++VIGRA_DEFINE_NORM(unsigned long long)
++#endif
+ VIGRA_DEFINE_NORM(float)
+ VIGRA_DEFINE_NORM(double)
++#ifdef VIGRA_HAS_LONG_DOUBLE
+ VIGRA_DEFINE_NORM(long double)
++#endif
+ 
+ #undef VIGRA_DEFINE_NORM
+ 
+diff -uprN misc/vigra1.4.0/include/vigra/numerictraits.hxx misc/build/vigra1.4.0/include/vigra/numerictraits.hxx
+--- misc/vigra1.4.0/include/vigra/numerictraits.hxx	2005-12-21 05:53:41.000000000 +0100
++++ misc/build/vigra1.4.0/include/vigra/numerictraits.hxx	2006-08-31 12:08:15.474422000 +0200
+@@ -891,6 +891,90 @@ struct NumericTraits<unsigned long>
+     }
+ };
+ 
++#ifdef VIGRA_HAS_LONG_LONG
++template<>
++struct NumericTraits<long long>
++{
++    typedef long long Type;
++    typedef long long Promote;
++    typedef double RealPromote;
++    typedef std::complex<RealPromote> ComplexPromote;
++    typedef Type ValueType;
++
++    typedef VigraTrueType isIntegral;
++    typedef VigraTrueType isScalar;
++    typedef VigraTrueType isSigned;
++    typedef VigraTrueType isOrdered;
++    typedef VigraFalseType isComplex;
++    
++    static long long zero() { return 0; }
++    static long long one() { return 1; }
++    static long long nonZero() { return 1; }
++    static long long min() { return LLONG_MIN; }
++    static long long max() { return LLONG_MAX; }
++    
++#ifdef NO_INLINE_STATIC_CONST_DEFINITION
++    enum { minConst = LONG_MIN, maxConst = LLONG_MAX };
++#else
++    static const long long minConst = LLONG_MIN;
++    static const long long maxConst = LLONG_MAX;
++#endif
++
++    static Promote toPromote(long long v) { return v; }
++    static RealPromote toRealPromote(long long v) { return v; }
++    static long long fromPromote(Promote v) { return v; }
++    static long long fromRealPromote(RealPromote v) {
++        return ((v < 0.0) 
++                 ? ((v < (RealPromote)LLONG_MIN) 
++                     ? LLONG_MIN 
++                     : static_cast<long long>(v - 0.5)) 
++                 : ((v > (RealPromote)LLONG_MAX) 
++                     ? LLONG_MAX 
++                     : static_cast<long long>(v + 0.5))); 
++    }
++};
++
++template<>
++struct NumericTraits<unsigned long long>
++{
++    typedef unsigned long long Type;
++    typedef unsigned long long Promote;
++    typedef double RealPromote;
++    typedef std::complex<RealPromote> ComplexPromote;
++    typedef Type ValueType;
++
++    typedef VigraTrueType isIntegral;
++    typedef VigraTrueType isScalar;
++    typedef VigraFalseType isSigned;
++    typedef VigraTrueType isOrdered;
++    typedef VigraFalseType isComplex;
++    
++    static unsigned long long zero() { return 0; }
++    static unsigned long long one() { return 1; }
++    static unsigned long long nonZero() { return 1; }
++    static unsigned long long min() { return 0; }
++    static unsigned long long max() { return ULLONG_MAX; }
++    
++#ifdef NO_INLINE_STATIC_CONST_DEFINITION
++    enum { minConst = 0, maxConst = ULLONG_MAX };
++#else
++    static const unsigned long long minConst = 0;
++    static const unsigned long long maxConst = ULLONG_MAX;
++#endif
++
++    static Promote toPromote(unsigned long long v) { return v; }
++    static RealPromote toRealPromote(unsigned long long v) { return v; }
++    static unsigned long long fromPromote(Promote v) { return v; }
++    static unsigned long long fromRealPromote(RealPromote v) {
++            return ((v < 0.0) 
++                     ? 0 
++                     : ((v > (RealPromote)ULLONG_MAX) 
++                         ? ULLONG_MAX 
++                         : static_cast<unsigned long long>(v + 0.5)));
++    }
++};
++#endif
++
+ template<>
+ struct NumericTraits<float>
+ {
+@@ -949,6 +1033,7 @@ struct NumericTraits<double>
+     static double fromRealPromote(RealPromote v) { return v; }
+ };
+ 
++#ifdef VIGRA_HAS_LONG_DOUBLE
+ template<>
+ struct NumericTraits<long double>
+ {
+@@ -977,6 +1062,7 @@ struct NumericTraits<long double>
+     static long double fromPromote(Promote v) { return v; }
+     static long double fromRealPromote(RealPromote v) { return v; }
+ };
++#endif
+ 
+ #ifndef NO_PARTIAL_TEMPLATE_SPECIALIZATION
+ 
+@@ -1055,9 +1141,15 @@ VIGRA_DEFINE_NORM_TRAITS(int)
+ VIGRA_DEFINE_NORM_TRAITS(unsigned int)
+ VIGRA_DEFINE_NORM_TRAITS(long)
+ VIGRA_DEFINE_NORM_TRAITS(unsigned long)
++#ifdef VIGRA_HAS_LONG_LONG
++VIGRA_DEFINE_NORM_TRAITS(long long)
++VIGRA_DEFINE_NORM_TRAITS(unsigned long long)
++#endif
+ VIGRA_DEFINE_NORM_TRAITS(float)
+ VIGRA_DEFINE_NORM_TRAITS(double)
++#ifdef VIGRA_HAS_LONG_DOUBLE
+ VIGRA_DEFINE_NORM_TRAITS(long double)
++#endif
+ 
+ #undef VIGRA_DEFINE_NORM_TRAITS
+ 
+diff -uprN misc/vigra1.4.0/include/vigra/orientedtensorfilters.hxx misc/build/vigra1.4.0/include/vigra/orientedtensorfilters.hxx
+--- misc/vigra1.4.0/include/vigra/orientedtensorfilters.hxx	2005-12-21 05:53:42.000000000 +0100
++++ misc/build/vigra1.4.0/include/vigra/orientedtensorfilters.hxx	2006-08-31 12:08:15.503678000 +0200
 @@ -434,7 +434,7 @@ class Sin6RingKernel
          if(x == 0 && y == 0)
              return weights_(radius_, radius_);

+                                      pow((promote_type)v2, c_);
         return result_type(0.5 * diff_ * (contrasted + one_) + min_);
     }

     }
 };
 
diff -uprN misc/vigra1.4.0/include/vigra/polynomial.hxx misc/build/vigra1.4.0/include/vigra/polynomial.hxx
--- misc/vigra1.4.0/include/vigra/polynomial.hxx	2005-12-21 05:53:42.000000000 +0100
+++ misc/build/vigra1.4.0/include/vigra/polynomial.hxx	2006-08-31 12:08:15.526572000 +0200
@@ -118,10 +118,10 @@ class PolynomialView
             of subsequent algorithms (especially root finding) performed on the
             polynomial.
         */
-    PolynomialView(T * coeffs, unsigned int order, double epsilon = 1.0e-14)
+    PolynomialView(T * coeffs, unsigned int ord, double eps = 1.0e-14)
     : coeffs_(coeffs),
-      order_(order),
-      epsilon_(epsilon)
+      order_(ord),
+      epsilon_(eps)
     {}
     
         /// Access the coefficient of x^i
@@ -244,16 +244,16 @@ class PolynomialView
         { epsilon_ = eps; }
 
   protected:
-    PolynomialView(double epsilon = 1e-14)
+    PolynomialView(double eps = 1e-14)
     : coeffs_(0),
       order_(0),
-      epsilon_(epsilon)
+      epsilon_(eps)
     {}
     
-    void setCoeffs(T * coeffs, unsigned int order)
+    void setCoeffs(T * coeffs, unsigned int ord)
     {
         coeffs_ = coeffs;
-        order_ = order;
+        order_ = ord;
     }
   
     T * coeffs_;
@@ -396,9 +396,9 @@ PolynomialView<T>::deflateConjugatePair(
     
 template <class T>
 void 
-PolynomialView<T>::minimizeOrder(double epsilon)
+PolynomialView<T>::minimizeOrder(double eps)
 {
-    while(std::abs(coeffs_[order_]) <= epsilon && order_ > 0)
+    while(std::abs(coeffs_[order_]) <= eps && order_ > 0)
             --order_;
 }
 
diff -uprN misc/vigra1.4.0/include/vigra/recursiveconvolution.hxx misc/build/vigra1.4.0/include/vigra/recursiveconvolution.hxx
--- misc/vigra1.4.0/include/vigra/recursiveconvolution.hxx	2005-12-21 05:53:42.000000000 +0100
+++ misc/build/vigra1.4.0/include/vigra/recursiveconvolution.hxx	2006-08-31 12:08:15.553556000 +0200
@@ -259,16 +259,16 @@ void recursiveFilterLine(SrcIterator is,
     {    
        // correction factors for b
         double bright = b;
