vigra/vigra1.4.0.patch

   1 diff -uprN misc/vigra1.4.0/configure misc/build/vigra1.4.0/configure
   2 --- misc/vigra1.4.0/configure   Tue Dec 20 23:53:28 2005
   3 +++ misc/build/vigra1.4.0/configure     Wed Apr  4 20:35:48 2007
   4 @@ -7259,7 +7259,7 @@ kfreebsd*-gnu)
   5    ;;
   6
   7  freebsd*)
   8 -  objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
   9 +  objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo elf`
  10    version_type=freebsd-$objformat
  11    case $version_type in
  12      freebsd-elf*)
  13 @@ -10961,7 +10961,7 @@ kfreebsd*-gnu)
  14    ;;
  15
  16  freebsd*)
  17 -  objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
  18 +  objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo elf`
  19    version_type=freebsd-$objformat
  20    case $version_type in
  21      freebsd-elf*)
  22 @@ -14110,7 +14110,7 @@ kfreebsd*-gnu)
  23    ;;
  24
  25  freebsd*)
  26 -  objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
  27 +  objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo elf`
  28    version_type=freebsd-$objformat
  29    case $version_type in
  30      freebsd-elf*)
  31 @@ -16461,7 +16461,7 @@ kfreebsd*-gnu)
  32    ;;
  33
  34  freebsd*)
  35 -  objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
  36 +  objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo elf`
  37    version_type=freebsd-$objformat
  38    case $version_type in
  39      freebsd-elf*)
  40 diff -uprN misc/vigra1.4.0/include/vigra/array_vector.hxx misc/build/vigra1.4.0/include/vigra/array_vector.hxx
  41 --- misc/vigra1.4.0/include/vigra/array_vector.hxx      2005-12-21 05:53:30.000000000 +0100
  42 +++ misc/build/vigra1.4.0/include/vigra/array_vector.hxx        2006-08-31 12:08:15.172679000 +0200
  43 @@ -196,7 +196,38 @@ public:
  44      iterator insert(iterator p, size_type n, value_type const & v);
  45
  46      template <class InputIterator>
  47 -    iterator insert(iterator p, InputIterator i, InputIterator iend);
  48 +    iterator insert(iterator p, InputIterator i, InputIterator iend)
  49 +    {
  50 +        difference_type n = iend - i;
  51 +        difference_type pos = p - begin();
  52 +        size_type new_size = size() + n;
  53 +        if(new_size >= capacity_)
  54 +        {
  55 +            pointer new_data = reserve_raw(new_size);
  56 +            std::uninitialized_copy(begin(), p, new_data);
  57 +            std::uninitialized_copy(i, iend, new_data + pos);
  58 +            std::uninitialized_copy(p, end(), new_data + pos + n);
  59 +            deallocate(data_, size_);
  60 +            capacity_ = new_size;
  61 +            data_ = new_data;
  62 +        }
  63 +        else if(pos + n >= size_)
  64 +        {
  65 +            size_type diff = pos + n - size_;
  66 +            std::uninitialized_copy(p, end(), end() + diff);
  67 +            std::uninitialized_copy(iend - diff, iend, end());
  68 +            std::copy(i, iend - diff, p);
  69 +        }
  70 +        else
  71 +        {
  72 +            size_type diff = size_ - (pos + n);
  73 +            std::uninitialized_copy(end() - n, end(), end());
  74 +            std::copy_backward(p, p + diff, end());
  75 +            std::copy(i, iend, p);
  76 +        }
  77 +        size_ = new_size;
  78 +        return begin() + pos;
  79 +    }
  80
  81      iterator erase(iterator p);
  82
  83 @@ -260,23 +291,23 @@ ArrayVector<T, Alloc>::ArrayVector(Alloc
  84  {}
  85
  86  template <class T, class Alloc>
  87 -ArrayVector<T, Alloc>::ArrayVector( size_type size, Alloc const & alloc)
  88 +ArrayVector<T, Alloc>::ArrayVector( size_type sz, Alloc const & alloc)
  89  : alloc_(alloc),
  90 -  size_(size),
  91 -  capacity_(size),
  92 -  data_(reserve_raw(size))
  93 +  size_(sz),
  94 +  capacity_(sz),
  95 +  data_(reserve_raw(sz))
  96  {
  97      if(size_ > 0)
  98          std::uninitialized_fill(data_, data_+size_, value_type());
  99  }
 100
 101  template <class T, class Alloc>
 102 -ArrayVector<T, Alloc>::ArrayVector( size_type size,
 103 +ArrayVector<T, Alloc>::ArrayVector( size_type sz,
 104                           value_type const & initial, Alloc const & alloc)
 105  : alloc_(alloc),
 106 -  size_(size),
 107 -  capacity_(size),
 108 -  data_(reserve_raw(size))
 109 +  size_(sz),
 110 +  capacity_(sz),
 111 +  data_(reserve_raw(sz))
 112  {
 113      if(size_ > 0)
 114          std::uninitialized_fill(data_, data_+size_, initial);
 115 @@ -295,24 +326,24 @@ ArrayVector<T, Alloc>::ArrayVector( this
 116
 117  template <class T, class Alloc>
 118  template <class InputIterator>
 119 -ArrayVector<T, Alloc>::ArrayVector(InputIterator i, InputIterator end)
 120 +ArrayVector<T, Alloc>::ArrayVector(InputIterator i, InputIterator iend)
 121  : alloc_(),
 122 -  size_(std::distance(i, end)),
 123 +  size_(std::distance(i, iend)),
 124    capacity_(size_),
 125    data_(reserve_raw(size_))
 126  {
 127 -    std::uninitialized_copy(i, end, data_);
 128 +    std::uninitialized_copy(i, iend, data_);
 129  }
 130
 131  template <class T, class Alloc>
 132  template <class InputIterator>
 133 -ArrayVector<T, Alloc>::ArrayVector(InputIterator i, InputIterator end, Alloc const & alloc)
 134 +ArrayVector<T, Alloc>::ArrayVector(InputIterator i, InputIterator iend, Alloc const & alloc)
 135  : alloc_(alloc),
 136 -  size_(std::distance(i, end)),
 137 +  size_(std::distance(i, iend)),
 138    capacity_(size_),
 139    data_(reserve_raw(size_))
 140  {
 141 -    std::uninitialized_copy(i, end, data_);
 142 +    std::uninitialized_copy(i, iend, data_);
 143  }
 144
 145
 146 @@ -409,42 +440,6 @@ ArrayVector<T, Alloc>::insert(iterator p
 147  }
 148
 149  template <class T, class Alloc>
 150 -template <class InputIterator>
 151 -typename ArrayVector<T, Alloc>::iterator
 152 -ArrayVector<T, Alloc>::insert(iterator p, InputIterator i, InputIterator iend)
 153 -{
 154 -    difference_type n = iend - i;
 155 -    difference_type pos = p - begin();
 156 -    size_type new_size = size() + n;
 157 -    if(new_size >= capacity_)
 158 -    {
 159 -        pointer new_data = reserve_raw(new_size);
 160 -        std::uninitialized_copy(begin(), p, new_data);
 161 -        std::uninitialized_copy(i, iend, new_data + pos);
 162 -        std::uninitialized_copy(p, end(), new_data + pos + n);
 163 -        deallocate(data_, size_);
 164 -        capacity_ = new_size;
 165 -        data_ = new_data;
 166 -    }
 167 -    else if(pos + n >= size_)
 168 -    {
 169 -        size_type diff = pos + n - size_;
 170 -        std::uninitialized_copy(p, end(), end() + diff);
 171 -        std::uninitialized_copy(iend - diff, iend, end());
 172 -        std::copy(i, iend - diff, p);
 173 -    }
 174 -    else
 175 -    {
 176 -        size_type diff = size_ - (pos + n);
 177 -        std::uninitialized_copy(end() - n, end(), end());
 178 -        std::copy_backward(p, p + diff, end());
 179 -        std::copy(i, iend, p);
 180 -    }
 181 -    size_ = new_size;
 182 -    return begin() + pos;
 183 -}
 184 -
 185 -template <class T, class Alloc>
 186  typename ArrayVector<T, Alloc>::iterator
 187  ArrayVector<T, Alloc>::erase(iterator p)
 188  {
 189 @@ -504,25 +499,25 @@ void ArrayVector<T, Alloc>::swap(this_ty
 190  }
 191
 192  template <class T, class Alloc>
 193 -void ArrayVector<T, Alloc>::deallocate(pointer data, size_type size)
 194 +void ArrayVector<T, Alloc>::deallocate(pointer target_data, size_type sz)
 195  {
 196      if(data)
 197      {
 198 -        detail::destroy_n(data, size);
 199 -        alloc_.deallocate(data, size);
 200 +        detail::destroy_n(target_data, sz);
 201 +        alloc_.deallocate(target_data, sz);
 202      }
 203  }
 204
 205  template <class T, class Alloc>
 206  typename ArrayVector<T, Alloc>::pointer
 207 -ArrayVector<T, Alloc>::reserve_raw(size_type capacity)
 208 +ArrayVector<T, Alloc>::reserve_raw(size_type cap)
 209  {
 210 -    pointer data = 0;
 211 -    if(capacity)
 212 +    pointer new_data = 0;
 213 +    if(cap)
 214      {
 215 -        data = alloc_.allocate(capacity);
 216 +        new_data = alloc_.allocate(cap);
 217      }
 218 -    return data;
 219 +    return new_data;
 220  }
 221
 222  } // namespace vigra
 223 diff -uprN misc/vigra1.4.0/include/vigra/basicimage.hxx misc/build/vigra1.4.0/include/vigra/basicimage.hxx
 224 --- misc/vigra1.4.0/include/vigra/basicimage.hxx        2005-12-21 05:53:30.000000000 +0100
 225 +++ misc/build/vigra1.4.0/include/vigra/basicimage.hxx  2006-08-31 12:08:15.194050000 +0200
 226 @@ -552,7 +552,11 @@ class BasicImage
 227      typedef Alloc allocator_type;
 228
 229      typedef Alloc Allocator;
 230 +#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
 231      typedef typename Alloc::template rebind<PIXELTYPE *>::other LineAllocator;
 232 +#else
 233 +    typedef std::allocator<PIXELTYPE*> LineAllocator;
 234 +#endif
 235
 236          /** construct image of size 0x0
 237          */
 238 @@ -569,39 +573,51 @@ class BasicImage
 239        width_(0),
 240        height_(0),
 241        allocator_(alloc),
 242 +#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
 243        pallocator_(alloc)
 244 +#else
 245 +      pallocator_()
 246 +#endif
 247      {}
 248
 249          /** construct image of size width x height, use the specified allocator.
 250          */
 251 -    BasicImage(int width, int height, Alloc const & alloc = Alloc())
 252 +    BasicImage(int w, int h, Alloc const & alloc = Alloc())
 253      : data_(0),
 254        width_(0),
 255        height_(0),
 256        allocator_(alloc),
 257 +#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
 258        pallocator_(alloc)
 259 +#else
 260 +      pallocator_()
 261 +#endif
 262      {
 263 -        vigra_precondition((width >= 0) && (height >= 0),
 264 -             "BasicImage::BasicImage(int width, int height): "
 265 +        vigra_precondition((w >= 0) && (h >= 0),
 266 +             "BasicImage::BasicImage(int w, int h): "
 267               "width and height must be >= 0.\n");
 268
 269 -        resize(width, height, value_type());
 270 +        resize(w, h, value_type());
 271      }
 272
 273          /** construct image of size size.x x size.y, use the specified allocator.
 274          */
 275 -    explicit BasicImage(difference_type const & size, Alloc const & alloc = Alloc())
 276 +    explicit BasicImage(difference_type const & sz, Alloc const & alloc = Alloc())
 277      : data_(0),
 278        width_(0),
 279        height_(0),
 280        allocator_(alloc),
 281 +#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
 282        pallocator_(alloc)
 283 -    {
 284 -        vigra_precondition((size.x >= 0) && (size.y >= 0),
 285 -             "BasicImage::BasicImage(Diff2D size): "
 286 -             "size.x and size.y must be >= 0.\n");
 287 +#else
 288 +      pallocator_()
 289 +#endif
 290 +    {
 291 +        vigra_precondition((sz.x >= 0) && (sz.y >= 0),
 292 +             "BasicImage::BasicImage(Diff2D sz): "
 293 +             "sz.x and sz.y must be >= 0.\n");
 294
 295 -        resize(size.x, size.y, value_type());
 296 +        resize(sz.x, sz.y, value_type());
 297      }
 298
 299          /** construct image of size width*height and initialize every
 300 @@ -609,71 +625,87 @@ class BasicImage
 301          value_type doesn't have a default constructor).
 302          Use the specified allocator.
 303          */
 304 -    BasicImage(int width, int height, value_type const & d, Alloc const & alloc = Alloc())
 305 +    BasicImage(int w, int h, value_type const & d, Alloc const & alloc = Alloc())
 306      : data_(0),
 307        width_(0),
 308        height_(0),
 309        allocator_(alloc),
 310 +#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
 311        pallocator_(alloc)
 312 +#else
 313 +      pallocator_()
 314 +#endif
 315      {
 316 -        vigra_precondition((width >= 0) && (height >= 0),
 317 -             "BasicImage::BasicImage(int width, int height, value_type const & ): "
 318 +        vigra_precondition((w >= 0) && (h >= 0),
 319 +             "BasicImage::BasicImage(int w, int h, value_type const & ): "
 320               "width and height must be >= 0.\n");
 321
 322 -        resize(width, height, d);
 323 +        resize(w, h, d);
 324      }
 325
 326          /** construct image of size size.x x size.y and initialize
 327          every pixel with given data (use this constructor, if
 328          value_type doesn't have a default constructor). Use the specified allocator.
 329          */
 330 -    explicit BasicImage(difference_type const & size, value_type const & d, Alloc const & alloc = Alloc())
 331 +    explicit BasicImage(difference_type const & sz, value_type const & d, Alloc const & alloc = Alloc())
 332      : data_(0),
 333        width_(0),
 334        height_(0),
 335        allocator_(alloc),
 336 +#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
 337        pallocator_(alloc)
 338 -    {
 339 -        vigra_precondition((size.x >= 0) && (size.y >= 0),
 340 -             "BasicImage::BasicImage(Diff2D const & size, value_type const & v): "
 341 -             "size.x and size.y must be >= 0.\n");
 342 +#else
 343 +      pallocator_()
 344 +#endif
 345 +    {
 346 +        vigra_precondition((sz.x >= 0) && (sz.y >= 0),
 347 +             "BasicImage::BasicImage(Diff2D const & sz, value_type const & v): "
 348 +             "sz.x and sz.y must be >= 0.\n");
 349
 350 -        resize(size.x, size.y, d);
 351 +        resize(sz.x, sz.y, d);
 352      }
 353
 354
 355          /** construct image of size width*height and copy the data from the
 356              given C-style array \a d. Use the specified allocator.
 357          */
 358 -    BasicImage(int width, int height, const_pointer d, Alloc const & alloc = Alloc())
 359 +    BasicImage(int w, int h, const_pointer d, Alloc const & alloc = Alloc())
 360      : data_(0),
 361        width_(0),
 362        height_(0),
 363        allocator_(alloc),
 364 +#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
 365        pallocator_(alloc)
 366 +#else
 367 +      pallocator_()
 368 +#endif
 369      {
 370 -        vigra_precondition((width >= 0) && (height >= 0),
 371 -             "BasicImage::BasicImage(int width, int height, const_pointer ): "
 372 +        vigra_precondition((w >= 0) && (h >= 0),
 373 +             "BasicImage::BasicImage(int w, int h, const_pointer ): "
 374               "width and height must be >= 0.\n");
 375
 376 -        resizeCopy(width, height, d);
 377 +        resizeCopy(w, h, d);
 378      }
 379
 380          /** construct image of size size.x x size.y  and copy the data from the
 381              given C-style array. Use the specified allocator.
 382          */
 383 -    explicit BasicImage(difference_type const & size, const_pointer d, Alloc const & alloc = Alloc())
 384 +    explicit BasicImage(difference_type const & sz, const_pointer d, Alloc const & alloc = Alloc())
 385      : data_(0),
 386        width_(0),
 387        height_(0),
 388        allocator_(alloc),
 389 +#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
 390        pallocator_(alloc)
 391 -    {
 392 -        vigra_precondition((size.x >= 0) && (size.y >= 0),
 393 -             "BasicImage::BasicImage(Diff2D const & size, const_pointer): "
 394 -             "size.x and size.y must be >= 0.\n");
 395 +#else
 396 +      pallocator_()
 397 +#endif
 398 +    {
 399 +        vigra_precondition((sz.x >= 0) && (sz.y >= 0),
 400 +             "BasicImage::BasicImage(Diff2D const & sz, const_pointer): "
 401 +             "sz.x and sz.y must be >= 0.\n");
 402
 403 -        resizeCopy(size.x, size.y, d);
 404 +        resizeCopy(sz.x, sz.y, d);
 405      }
 406
 407          /** copy rhs image
 408 @@ -710,20 +742,20 @@ class BasicImage
 409          /** reset image to specified size (dimensions must not be negative)
 410              (old data are kept if new size matches old size)
 411          */
 412 -    void resize(int width, int height)
 413 +    void resize(int w, int h)
 414      {
 415 -        if(width != width_ || height != height_)
 416 -            resize(width, height, value_type());
 417 +        if(w != width_ || h != height_)
 418 +            resize(w, h, value_type());
 419      }
 420
 421          /** reset image to specified size (dimensions must not be negative)
 422              (old data are kept if new size matches old size)
 423          */
 424 -    void resize(difference_type const & size)
 425 +    void resize(difference_type const & sz)
 426      {
 427 -        if(size.x != width_ || size.y != height_)
 428 +        if(sz.x != width_ || sz.y != height_)
 429          {
 430 -            resize(size.x, size.y, value_type());
 431 +            resize(sz.x, sz.y, value_type());
 432          }
 433      }
 434
 435 @@ -732,12 +764,12 @@ class BasicImage
 436              constructor, dimensions must not be negative,
 437              old data are kept if new size matches old size)
 438          */
 439 -    void resize(int width, int height, value_type const & d);
 440 +    void resize(int w, int h, value_type const & d);
 441
 442          /** resize image to given size and initialize by copying data
 443              from the C-style arra \a data.
 444          */
 445 -    void resizeCopy(int width, int height, const_pointer data);
 446 +    void resizeCopy(int w, int h, const_pointer data);
 447
 448          /** resize image to size of other image and copy it's data
 449          */
 450 @@ -1046,30 +1078,30 @@ BasicImage<PIXELTYPE, Alloc>::init(value
 451
 452  template <class PIXELTYPE, class Alloc>
 453  void
 454 -BasicImage<PIXELTYPE, Alloc>::resize(int width, int height, value_type const & d)
 455 +BasicImage<PIXELTYPE, Alloc>::resize(int w, int h, value_type const & d)
 456  {
 457 -    vigra_precondition((width >= 0) && (height >= 0),
 458 -         "BasicImage::resize(int width, int height, value_type const &): "
 459 +    vigra_precondition((w >= 0) && (h >= 0),
 460 +         "BasicImage::resize(int w, int h, value_type const &): "
 461           "width and height must be >= 0.\n");
 462
 463 -    if (width_ != width || height_ != height)  // change size?
 464 +    if (width_ != w || height_ != h)  // change size?
 465      {
 466          value_type * newdata = 0;
 467          value_type ** newlines = 0;
 468 -        if(width*height > 0)
 469 +        if(w*h > 0)
 470          {
 471 -            if (width*height != width_*height_) // different sizes, must reallocate
 472 +            if (w*h != width_*height_) // different sizes, must reallocate
 473              {
 474 -                newdata = allocator_.allocate(width*height);
 475 -                std::uninitialized_fill_n(newdata, width*height, d);
 476 -                newlines = initLineStartArray(newdata, width, height);
 477 +                newdata = allocator_.allocate(w*h);
 478 +                std::uninitialized_fill_n(newdata, w*h, d);
 479 +                newlines = initLineStartArray(newdata, w, h);
 480                  deallocate();
 481              }
 482              else // need only to reshape
 483              {
 484                  newdata = data_;
 485 -                std::fill_n(newdata, width*height, d);
 486 -                newlines = initLineStartArray(newdata, width, height);
 487 +                std::fill_n(newdata, w*h, d);
 488 +                newlines = initLineStartArray(newdata, w, h);
 489                  pallocator_.deallocate(lines_, height_);
 490              }
 491          }
 492 @@ -1080,22 +1112,22 @@ BasicImage<PIXELTYPE, Alloc>::resize(int
 493
 494          data_ = newdata;
 495          lines_ = newlines;
 496 -        width_ = width;
 497 -        height_ = height;
 498 +        width_ = w;
 499 +        height_ = h;
 500      }
 501 -    else if(width*height > 0) // keep size, re-init data
 502 +    else if(w*h > 0) // keep size, re-init data
 503      {
 504 -        std::fill_n(data_, width*height, d);
 505 +        std::fill_n(data_, w*h, d);
 506      }
 507  }
 508
 509
 510  template <class PIXELTYPE, class Alloc>
 511  void
 512 -BasicImage<PIXELTYPE, Alloc>::resizeCopy(int width, int height, const_pointer data)
 513 +BasicImage<PIXELTYPE, Alloc>::resizeCopy(int w, int h, const_pointer src_data)
 514  {
 515 -    int newsize = width*height;
 516 -    if (width_ != width || height_ != height)  // change size?
 517 +    int newsize = w*h;
 518 +    if (width_ != w || height_ != h)  // change size?
 519      {
 520          value_type * newdata = 0;
 521          value_type ** newlines = 0;
 522 @@ -1104,15 +1136,15 @@ BasicImage<PIXELTYPE, Alloc>::resizeCopy
 523              if (newsize != width_*height_) // different sizes, must reallocate
 524              {
 525                  newdata = allocator_.allocate(newsize);
 526 -                std::uninitialized_copy(data, data + newsize, newdata);
 527 -                newlines = initLineStartArray(newdata, width, height);
 528 +                std::uninitialized_copy(src_data, src_data + newsize, newdata);
 529 +                newlines = initLineStartArray(newdata, w, h);
 530                  deallocate();
 531              }
 532              else // need only to reshape
 533              {
 534                  newdata = data_;
 535 -                std::copy(data, data + newsize, newdata);
 536 -                newlines = initLineStartArray(newdata, width, height);
 537 +                std::copy(src_data, src_data + newsize, newdata);
 538 +                newlines = initLineStartArray(newdata, w, h);
 539                  pallocator_.deallocate(lines_, height_);
 540              }
 541          }
 542 @@ -1123,12 +1155,12 @@ BasicImage<PIXELTYPE, Alloc>::resizeCopy
 543
 544          data_ = newdata;
 545          lines_ = newlines;
 546 -        width_ = width;
 547 -        height_ = height;
 548 +        width_ = w;
 549 +        height_ = h;
 550      }
 551      else if(newsize > 0) // keep size, copy data
 552      {
 553 -        std::copy(data, data + newsize, data_);
 554 +        std::copy(src_data, src_data + newsize, data_);
 555      }
 556  }
 557
 558 @@ -1163,11 +1195,11 @@ BasicImage<PIXELTYPE, Alloc>::deallocate
 559
 560  template <class PIXELTYPE, class Alloc>
 561  PIXELTYPE **
 562 -BasicImage<PIXELTYPE, Alloc>::initLineStartArray(value_type * data, int width, int height)
 563 +BasicImage<PIXELTYPE, Alloc>::initLineStartArray(value_type * src_data, int w, int h)
 564  {
 565 -    value_type ** lines = pallocator_.allocate(height);
 566 -    for(int y=0; y<height; ++y)
 567 -         lines[y] = data + y*width;
 568 +    value_type ** lines = pallocator_.allocate(h);
 569 +    for(int y=0; y<h; ++y)
 570 +         lines[y] = src_data + y*w;
 571      return lines;
 572  }
 573
 574 diff -uprN misc/vigra1.4.0/include/vigra/basicimageview.hxx misc/build/vigra1.4.0/include/vigra/basicimageview.hxx
 575 --- misc/vigra1.4.0/include/vigra/basicimageview.hxx    2005-12-21 05:53:30.000000000 +0100
 576 +++ misc/build/vigra1.4.0/include/vigra/basicimageview.hxx      2006-08-31 12:08:15.219210000 +0200
 577 @@ -176,20 +176,20 @@ class BasicImageView
 578
 579          /** construct view of size w x h
 580          */
 581 -    BasicImageView(const_pointer data, int w, int h, int stride = 0)
 582 -    : data_(const_cast<pointer>(data)),
 583 +    BasicImageView(const_pointer src_data, int w, int h, int data_stride = 0)
 584 +    : data_(const_cast<pointer>(src_data)),
 585        width_(w),
 586        height_(h),
 587 -      stride_(stride == 0 ? w : stride)
 588 +      stride_(data_stride == 0 ? w : data_stride)
 589      {}
 590
 591          /** construct view of size size.x x size.y
 592          */
 593 -    BasicImageView(const_pointer data, difference_type const & size, int stride = 0)
 594 -    : data_(const_cast<pointer>(data)),
 595 -      width_(size.x),
 596 -      height_(size.y),
 597 -      stride_(stride == 0 ? size.x : stride)
 598 +    BasicImageView(const_pointer src_data, difference_type const & sz, int data_stride = 0)
 599 +    : data_(const_cast<pointer>(src_data)),
 600 +      width_(sz.x),
 601 +      height_(sz.y),
 602 +      stride_(data_stride == 0 ? sz.x : data_stride)
 603      {}
 604
 605          /** set Image with const value
 606 diff -uprN misc/vigra1.4.0/include/vigra/boundarytensor.hxx misc/build/vigra1.4.0/include/vigra/boundarytensor.hxx
 607 --- misc/vigra1.4.0/include/vigra/boundarytensor.hxx    2005-12-21 05:53:31.000000000 +0100
 608 +++ misc/build/vigra1.4.0/include/vigra/boundarytensor.hxx      2006-08-31 12:08:15.240695000 +0200
 609 @@ -71,8 +71,8 @@ initGaussianPolarFilters1(double std_dev
 610      int radius = (int)(4.0*std_dev + 0.5);
 611      std_dev *= 1.08179074376;
 612      double f = 1.0 / VIGRA_CSTD::sqrt(2.0 * M_PI) / std_dev;  // norm
 613 -    double a = 0.558868151788 / VIGRA_CSTD::pow(std_dev, 5);
 614 -    double b = -2.04251639729 / VIGRA_CSTD::pow(std_dev, 3);
 615 +    double a = 0.558868151788 / VIGRA_CSTD::pow(std_dev, 5.0);
 616 +    double b = -2.04251639729 / VIGRA_CSTD::pow(std_dev, 3.0);
 617      double sigma22 = -0.5 / std_dev / std_dev;
 618
 619
 620 @@ -175,7 +175,7 @@ initGaussianPolarFilters3(double std_dev
 621      std_dev *= 1.15470053838;
 622      double sigma22 = -0.5 / std_dev / std_dev;
 623      double f = 1.0 / VIGRA_CSTD::sqrt(2.0 * M_PI) / std_dev;  // norm
 624 -    double a = 0.883887052922 / VIGRA_CSTD::pow(std_dev, 5);
 625 +    double a = 0.883887052922 / VIGRA_CSTD::pow(std_dev, 5.0);
 626
 627      for(unsigned int i=0; i<k.size(); ++i)
 628      {
 629 @@ -183,7 +183,7 @@ initGaussianPolarFilters3(double std_dev
 630          k[i].setBorderTreatment(BORDER_TREATMENT_REFLECT);
 631      }
 632
 633 -    double b = -1.3786348292 / VIGRA_CSTD::pow(std_dev, 3);
 634 +    double b = -1.3786348292 / VIGRA_CSTD::pow(std_dev, 3.0);
 635
 636      int ix;
 637      iterator c = k[0].center();
 638 diff -uprN misc/vigra1.4.0/include/vigra/config.hxx misc/build/vigra1.4.0/include/vigra/config.hxx
 639 --- misc/vigra1.4.0/include/vigra/config.hxx    2005-12-21 05:53:31.000000000 +0100
 640 +++ misc/build/vigra1.4.0/include/vigra/config.hxx      2006-08-31 12:08:15.261488000 +0200
 641 @@ -84,6 +84,12 @@
 642                 #endif // VIGRA_NO_STD_MINMAX
 643         #endif // (_MSC_VER < 1300)
 644
 645 +    #if _MSC_VER <= 1310
 646 +           #ifndef CMATH_NOT_IN_STD
 647 +               #define CMATH_NOT_IN_STD
 648 +        #endif
 649 +    #endif // _MSC_VER < 1310
 650 +
 651      #if _MSC_VER < 1310
 652          #define NO_PARTIAL_TEMPLATE_SPECIALIZATION
 653          #define NO_OUT_OF_LINE_MEMBER_TEMPLATES
 654 diff -uprN misc/vigra1.4.0/include/vigra/diff2d.hxx misc/build/vigra1.4.0/include/vigra/diff2d.hxx
 655 --- misc/vigra1.4.0/include/vigra/diff2d.hxx    2005-12-21 05:53:33.000000000 +0100
 656 +++ misc/build/vigra1.4.0/include/vigra/diff2d.hxx      2006-08-31 12:08:15.282334000 +0200
 657 @@ -490,8 +490,8 @@ public:
 658
 659          /** Construct point at given position.
 660          */
 661 -    Size2D(int width, int height)
 662 -    : Diff2D(width, height)
 663 +    Size2D(int w, int h)
 664 +    : Diff2D(w, h)
 665      {}
 666
 667          /** Copy Constructor.
 668 @@ -606,8 +606,8 @@ public:
 669
 670          /** Construct point at given position.
 671          */
 672 -    Point2D(int x, int y)
 673 -    : Diff2D(x, y)
 674 +    Point2D(int x_, int y_)
 675 +    : Diff2D(x_, y_)
 676      {}
 677
 678          /** Copy Constructor.
 679 @@ -870,26 +870,26 @@ public:
 680           * (lowerRight is considered to be outside the rectangle as
 681           * usual in the VIGRA)
 682           */
 683 -    Rect2D(Point2D const &upperLeft, Point2D const &lowerRight)
 684 -    : upperLeft_(upperLeft), lowerRight_(lowerRight)
 685 +    Rect2D(Point2D const &ul, Point2D const &lr)
 686 +    : upperLeft_(ul), lowerRight_(lr)
 687      {}
 688
 689          /** Construct a rectangle representing the given range
 690           */
 691 -    Rect2D(int left, int top, int right, int bottom)
 692 -    : upperLeft_(left, top), lowerRight_(right, bottom)
 693 +    Rect2D(int l, int t, int r, int b)
 694 +        : upperLeft_(l,t), lowerRight_(r,b)
 695      {}
 696
 697          /** Construct a rectangle of given position and size
 698           */
 699 -    Rect2D(Point2D const &upperLeft, Size2D const &size)
 700 -    : upperLeft_(upperLeft), lowerRight_(upperLeft + size)
 701 +    Rect2D(Point2D const &ul, Size2D const &sz)
 702 +    : upperLeft_(ul), lowerRight_(ul + sz)
 703      {}
 704
 705          /** Construct a rectangle of given size at position (0,0)
 706           */
 707 -    explicit Rect2D(Size2D const &size)
 708 -    : lowerRight_(Point2D(size))
 709 +    explicit Rect2D(Size2D const &sz)
 710 +    : lowerRight_(Point2D(sz))
 711      {}
 712
 713          /** Return the first point (scan-order wise) which is
 714 @@ -936,9 +936,9 @@ public:
 715          /** Move the whole rectangle so that upperLeft() will become
 716           * Point2D(left, top) afterwards.
 717           */
 718 -    void moveTo(int left, int top)
 719 +    void moveTo(int l, int t)
 720      {
 721 -        moveTo(Point2D(left, top));
 722 +        moveTo(Point2D(l, t));
 723      }
 724
 725          /** Move the whole rectangle by the given 2D offset.
 726 @@ -1023,17 +1023,17 @@ public:
 727          /** Resize this rectangle to the given extents. This will move
 728           * the lower right corner only.
 729           */
 730 -    void setSize(Size2D const &size)
 731 +    void setSize(Size2D const &sz)
 732      {
 733 -        lowerRight_ = upperLeft_ + size;
 734 +        lowerRight_ = upperLeft_ + sz;
 735      }
 736
 737          /** Resize this rectangle to the given extents. This will move
 738           * the lower right corner only.
 739           */
 740 -    void setSize(int width, int height)
 741 +    void setSize(int w, int h)
 742      {
 743 -        lowerRight_ = upperLeft_ + Size2D(width, height);
 744 +        lowerRight_ = upperLeft_ + Size2D(w, h);
 745      }
 746
 747          /** Increase the size of the rectangle by the given offset. This
 748 diff -uprN misc/vigra1.4.0/include/vigra/fftw.hxx misc/build/vigra1.4.0/include/vigra/fftw.hxx
 749 --- misc/vigra1.4.0/include/vigra/fftw.hxx      2005-12-21 05:53:34.000000000 +0100
 750 +++ misc/build/vigra1.4.0/include/vigra/fftw.hxx        2006-08-31 12:08:15.308081000 +0200
 751 @@ -399,8 +399,6 @@ inline FFTWComplex operator /(FFTWComple
 752      return a;
 753  }
 754
 755 -using VIGRA_CSTD::abs;
 756 -
 757  inline FFTWComplex::value_type abs(const FFTWComplex &a)
 758  {
 759      return a.magnitude();
 760 diff -uprN misc/vigra1.4.0/include/vigra/fftw3.hxx misc/build/vigra1.4.0/include/vigra/fftw3.hxx
 761 --- misc/vigra1.4.0/include/vigra/fftw3.hxx     2005-12-21 05:53:34.000000000 +0100
 762 +++ misc/build/vigra1.4.0/include/vigra/fftw3.hxx       2006-08-31 12:08:15.337248000 +0200
 763 @@ -572,8 +572,6 @@ inline FFTWComplex operator /(FFTWComple
 764      return a;
 765  }
 766
 767 -using VIGRA_CSTD::abs;
 768 -
 769      /// absolute value (= magnitude)
 770  inline FFTWComplex::value_type abs(const FFTWComplex &a)
 771  {
 772 diff -uprN misc/vigra1.4.0/include/vigra/fixedpoint.hxx misc/build/vigra1.4.0/include/vigra/fixedpoint.hxx
 773 --- misc/vigra1.4.0/include/vigra/fixedpoint.hxx        2005-12-21 05:53:34.000000000 +0100
 774 +++ misc/build/vigra1.4.0/include/vigra/fixedpoint.hxx  2006-08-31 12:08:15.367651000 +0200
 775 @@ -118,20 +118,18 @@ enum FixedPointNoShift { FPNoShift };
 776
 777  namespace detail {
 778
 779 -template <bool MustRound>
 780 +template <bool MustRound, int N>
 781  struct FPAssignWithRound;
 782
 783 -template <>
 784 -struct FPAssignWithRound<false>
 785 +template <int N>
 786 +struct FPAssignWithRound<false, N>
 787  {
 788 -    template <int N>
 789      static inline int exec(int v) { return v << (-N); }
 790  };
 791
 792 -template <>
 793 -struct FPAssignWithRound<true>
 794 +template <int N>
 795 +struct FPAssignWithRound<true, N>
 796  {
 797 -    template <int N>
 798      static inline int exec(int const v)
 799      {
 800          return (v + (1 << (N - 1))) >> (N);
 801 @@ -276,7 +274,7 @@ public:
 802          */
 803      template <unsigned Int2, unsigned Frac2>
 804      FixedPoint(const FixedPoint<Int2, Frac2> &other)
 805 -    : value(detail::FPAssignWithRound<(Frac2 > FractionalBits)>::template exec<Frac2 - FractionalBits>(other.value))
 806 +        : value(detail::FPAssignWithRound<(Frac2 > FractionalBits), Frac2 - FractionalBits>::exec(other.value))
 807      {
 808          VIGRA_STATIC_ASSERT((FixedPoint_overflow_error__More_than_31_bits_requested<(IntBits + FractionalBits)>));
 809          VIGRA_STATIC_ASSERT((FixedPoint_assignment_error__Target_object_has_too_few_integer_bits<(IntBits >= Int2)>));
 810 @@ -321,7 +319,7 @@ public:
 811      FixedPoint & operator=(const FixedPoint<Int2, Frac2> &other)
 812      {
 813          VIGRA_STATIC_ASSERT((FixedPoint_assignment_error__Target_object_has_too_few_integer_bits<(IntBits >= Int2)>));
 814 -        value = detail::FPAssignWithRound<(Frac2 > FractionalBits)>::template exec<Frac2 - FractionalBits>(other.value);
 815 +        value = detail::FPAssignWithRound<(Frac2 > FractionalBits),Frac2 - FractionalBits>::exec(other.value);
 816          return *this;
 817      }
 818
 819 @@ -373,7 +371,7 @@ public:
 820      FixedPoint & operator+=(const FixedPoint<Int2, Frac2> &other)
 821      {
 822          VIGRA_STATIC_ASSERT((FixedPoint_assignment_error__Target_object_has_too_few_integer_bits<(IntBits >= Int2)>));
 823 -        value += detail::FPAssignWithRound<(Frac2 > FractionalBits)>::template exec<Frac2 - FractionalBits>(other.value);
 824 +        value += detail::FPAssignWithRound<(Frac2 > FractionalBits),Frac2 - FractionalBits>::exec(other.value);
 825          return *this;
 826      }
 827
 828 @@ -384,7 +382,7 @@ public:
 829      FixedPoint & operator-=(const FixedPoint<Int2, Frac2> &other)
 830      {
 831          VIGRA_STATIC_ASSERT((FixedPoint_assignment_error__Target_object_has_too_few_integer_bits<(IntBits >= Int2)>));
 832 -        value -= detail::FPAssignWithRound<(Frac2 > FractionalBits)>::template exec<Frac2 - FractionalBits>(other.value);
 833 +        value -= detail::FPAssignWithRound<(Frac2 > FractionalBits),Frac2 - FractionalBits>::exec(other.value);
 834          return *this;
 835      }
 836
 837 @@ -428,12 +426,12 @@ struct FixedPointCast<type> \
 838      } \
 839  };
 840
 841 -VIGRA_FIXED_POINT_CAST(Int8);
 842 -VIGRA_FIXED_POINT_CAST(UInt8);
 843 -VIGRA_FIXED_POINT_CAST(Int16);
 844 -VIGRA_FIXED_POINT_CAST(UInt16);
 845 -VIGRA_FIXED_POINT_CAST(Int32);
 846 -VIGRA_FIXED_POINT_CAST(UInt32);
 847 +VIGRA_FIXED_POINT_CAST(Int8)
 848 +VIGRA_FIXED_POINT_CAST(UInt8)
 849 +VIGRA_FIXED_POINT_CAST(Int16)
 850 +VIGRA_FIXED_POINT_CAST(UInt16)
 851 +VIGRA_FIXED_POINT_CAST(Int32)
 852 +VIGRA_FIXED_POINT_CAST(UInt32)
 853
 854  #undef VIGRA_FIXED_POINT_CAST
 855
 856 diff -uprN misc/vigra1.4.0/include/vigra/gaborfilter.hxx misc/build/vigra1.4.0/include/vigra/gaborfilter.hxx
 857 --- misc/vigra1.4.0/include/vigra/gaborfilter.hxx       2005-12-21 05:53:35.000000000 +0100
 858 +++ misc/build/vigra1.4.0/include/vigra/gaborfilter.hxx 2006-08-31 12:08:15.389636000 +0200
 859 @@ -289,7 +289,11 @@ inline double angularGaborSigma(int dire
 860      Namespace: vigra
 861  */
 862  template <class ImageType,
 863 +#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
 864        class Alloc = typename ImageType::allocator_type::template rebind<ImageType>::other >
 865 +#else
 866 +      class Alloc = std::allocator<ImageType> >
 867 +#endif
 868  class GaborFilterFamily
 869  : public ImageArray<ImageType, Alloc>
 870  {
 871 diff -uprN misc/vigra1.4.0/include/vigra/gaussians.hxx misc/build/vigra1.4.0/include/vigra/gaussians.hxx
 872 --- misc/vigra1.4.0/include/vigra/gaussians.hxx 2005-12-21 05:53:35.000000000 +0100
 873 +++ misc/build/vigra1.4.0/include/vigra/gaussians.hxx   2006-08-31 12:08:15.409790000 +0200
 874 @@ -88,26 +88,26 @@ class Gaussian
 875              sigma > 0.0
 876              \endcode
 877          */
 878 -    explicit Gaussian(T sigma = 1.0, unsigned int derivativeOrder = 0)
 879 -    : sigma_(sigma),
 880 -      sigma2_(-0.5 / sigma / sigma),
 881 +    explicit Gaussian(T s = 1.0, unsigned int derivOrder = 0)
 882 +    : sigma_(s),
 883 +      sigma2_(-0.5 / s / s),
 884        norm_(0.0),
 885 -      order_(derivativeOrder),
 886 -      hermitePolynomial_(derivativeOrder / 2 + 1)
 887 +      order_(derivOrder),
 888 +      hermitePolynomial_(derivOrder / 2 + 1)
 889      {
 890 -        vigra_precondition(sigma_ > 0.0,
 891 +        vigra_precondition(s > 0.0,
 892              "Gaussian::Gaussian(): sigma > 0 required.");
 893          switch(order_)
 894          {
 895              case 1:
 896              case 2:
 897 -                norm_ = -1.0 / (VIGRA_CSTD::sqrt(2.0 * M_PI) * sq(sigma) * sigma);
 898 +                norm_ = -1.0 / (VIGRA_CSTD::sqrt(2.0 * M_PI) * sq(s) * s);
 899                  break;
 900              case 3:
 901 -                norm_ = 1.0 / (VIGRA_CSTD::sqrt(2.0 * M_PI) * sq(sigma) * sq(sigma) * sigma);
 902 +                norm_ = 1.0 / (VIGRA_CSTD::sqrt(2.0 * M_PI) * sq(s) * sq(s) * s);
 903                  break;
 904              default:
 905 -                norm_ = 1.0 / VIGRA_CSTD::sqrt(2.0 * M_PI) / sigma;
 906 +                norm_ = 1.0 / VIGRA_CSTD::sqrt(2.0 * M_PI) / s;
 907          }
 908          calculateHermitePolynomial();
 909      }
 910 diff -uprN misc/vigra1.4.0/include/vigra/imagecontainer.hxx misc/build/vigra1.4.0/include/vigra/imagecontainer.hxx
 911 --- misc/vigra1.4.0/include/vigra/imagecontainer.hxx    2005-12-21 05:53:36.000000000 +0100
 912 +++ misc/build/vigra1.4.0/include/vigra/imagecontainer.hxx      2006-08-31 12:08:15.429159000 +0200
 913 @@ -70,7 +70,11 @@ namespace vigra {
 914      Namespace: vigra
 915  */
 916  template <class ImageType,
 917 +#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
 918        class Alloc = typename ImageType::allocator_type::template rebind<ImageType>::other >
 919 +#else
 920 +      class Alloc = std::allocator<ImageType> >
 921 +#endif
 922  class ImageArray
 923  {
 924      Size2D imageSize_;
 925 diff -uprN misc/vigra1.4.0/include/vigra/mathutil.hxx misc/build/vigra1.4.0/include/vigra/mathutil.hxx
 926 --- misc/vigra1.4.0/include/vigra/mathutil.hxx  2005-12-21 05:53:39.000000000 +0100
 927 +++ misc/build/vigra1.4.0/include/vigra/mathutil.hxx    2006-08-31 12:08:15.449199000 +0200
 928 @@ -73,8 +73,6 @@
 929
 930  namespace vigra {
 931
 932 -#ifndef __sun
 933 -
 934  /** \addtogroup MathFunctions Mathematical Functions
 935
 936      Useful mathematical functions and functors.
 937 @@ -109,18 +107,11 @@ double erf(T x)
 938          return ans - 1.0;
 939  }
 940
 941 -#else
 942 -
 943 -using VIGRA_CSTD::erf;
 944 -
 945 -#endif
 946 -
 947  // import functions into namespace vigra which VIGRA is going to overload
 948
 949  using VIGRA_CSTD::pow;
 950  using VIGRA_CSTD::floor;
 951  using VIGRA_CSTD::ceil;
 952 -using std::abs;
 953
 954  #define VIGRA_DEFINE_UNSIGNED_ABS(T) \
 955      inline T abs(T t) { return t; }
 956 @@ -130,9 +121,39 @@ VIGRA_DEFINE_UNSIGNED_ABS(unsigned char)
 957  VIGRA_DEFINE_UNSIGNED_ABS(unsigned short)
 958  VIGRA_DEFINE_UNSIGNED_ABS(unsigned int)
 959  VIGRA_DEFINE_UNSIGNED_ABS(unsigned long)
 960 +#ifdef VIGRA_HAS_LONG_LONG
 961 +VIGRA_DEFINE_UNSIGNED_ABS(unsigned long long)
 962 +#endif
 963
 964  #undef VIGRA_DEFINE_UNSIGNED_ABS
 965
 966 +#define VIGRA_DEFINE_SIGNED_ABS(T) \
 967 +    inline T abs(T t) { return (T)abs(t); }
 968 +#define VIGRA_DEFINE_SIGNED_LABS(T) \
 969 +    inline T abs(T t) { return (T)labs(t); }
 970 +#define VIGRA_DEFINE_SIGNED_LLABS(T) \
 971 +    inline T abs(T t) { return (T)llabs(t); }
 972 +#define VIGRA_DEFINE_FABS(T) \
 973 +    inline T abs(T t) { return (T)fabs(t); }
 974 +
 975 +VIGRA_DEFINE_SIGNED_ABS(signed char)
 976 +VIGRA_DEFINE_SIGNED_ABS(signed short)
 977 +VIGRA_DEFINE_SIGNED_ABS(signed int)
 978 +VIGRA_DEFINE_SIGNED_LABS(signed long)
 979 +#ifdef VIGRA_HAS_LONG_LONG
 980 +VIGRA_DEFINE_SIGNED_LLABS(signed long long)
 981 +#endif
 982 +VIGRA_DEFINE_FABS(float)
 983 +VIGRA_DEFINE_FABS(double)
 984 +#ifdef VIGRA_HAS_LONG_DOUBLE
 985 +VIGRA_DEFINE_FABS(long double)
 986 +#endif
 987 +
 988 +#undef VIGRA_DEFINE_SIGNED_ABS
 989 +#undef VIGRA_DEFINE_SIGNED_LABS
 990 +#undef VIGRA_DEFINE_SIGNED_LLABS
 991 +#undef VIGRA_DEFINE_FABS
 992 +
 993      /*! The rounding function.
 994
 995          Defined for all floating point types. Rounds towards the nearest integer for both
 996 @@ -155,12 +176,14 @@ inline double round(double t)
 997                 : ceil(t - 0.5);
 998  }
 999
1000 +#ifdef VIGRA_HAS_LONG_DOUBLE
1001  inline long double round(long double t)
1002  {
1003      return t >= 0.0
1004                 ? floor(t + 0.5)
1005                 : ceil(t - 0.5);
1006  }
1007 +#endif
1008
1009      /*! The square function.
1010
1011 @@ -371,9 +394,15 @@ VIGRA_DEFINE_NORM(int)
1012  VIGRA_DEFINE_NORM(unsigned int)
1013  VIGRA_DEFINE_NORM(long)
1014  VIGRA_DEFINE_NORM(unsigned long)
1015 +#ifdef VIGRA_HAS_LONG_LONG
1016 +VIGRA_DEFINE_NORM(long long)
1017 +VIGRA_DEFINE_NORM(unsigned long long)
1018 +#endif
1019  VIGRA_DEFINE_NORM(float)
1020  VIGRA_DEFINE_NORM(double)
1021 +#ifdef VIGRA_HAS_LONG_DOUBLE
1022  VIGRA_DEFINE_NORM(long double)
1023 +#endif
1024
1025  #undef VIGRA_DEFINE_NORM
1026
1027 diff -uprN misc/vigra1.4.0/include/vigra/numerictraits.hxx misc/build/vigra1.4.0/include/vigra/numerictraits.hxx
1028 --- misc/vigra1.4.0/include/vigra/numerictraits.hxx     2005-12-21 05:53:41.000000000 +0100
1029 +++ misc/build/vigra1.4.0/include/vigra/numerictraits.hxx       2006-08-31 12:08:15.474422000 +0200
1030 @@ -891,6 +891,90 @@ struct NumericTraits<unsigned long>
1031      }
1032  };
1033
1034 +#ifdef VIGRA_HAS_LONG_LONG
1035 +template<>
1036 +struct NumericTraits<long long>
1037 +{
1038 +    typedef long long Type;
1039 +    typedef long long Promote;
1040 +    typedef double RealPromote;
1041 +    typedef std::complex<RealPromote> ComplexPromote;
1042 +    typedef Type ValueType;
1043 +
1044 +    typedef VigraTrueType isIntegral;
1045 +    typedef VigraTrueType isScalar;
1046 +    typedef VigraTrueType isSigned;
1047 +    typedef VigraTrueType isOrdered;
1048 +    typedef VigraFalseType isComplex;
1049 +
1050 +    static long long zero() { return 0; }
1051 +    static long long one() { return 1; }
1052 +    static long long nonZero() { return 1; }
1053 +    static long long min() { return LLONG_MIN; }
1054 +    static long long max() { return LLONG_MAX; }
1055 +
1056 +#ifdef NO_INLINE_STATIC_CONST_DEFINITION
1057 +    enum { minConst = LONG_MIN, maxConst = LLONG_MAX };
1058 +#else
1059 +    static const long long minConst = LLONG_MIN;
1060 +    static const long long maxConst = LLONG_MAX;
1061 +#endif
1062 +
1063 +    static Promote toPromote(long long v) { return v; }
1064 +    static RealPromote toRealPromote(long long v) { return v; }
1065 +    static long long fromPromote(Promote v) { return v; }
1066 +    static long long fromRealPromote(RealPromote v) {
1067 +        return ((v < 0.0)
1068 +                 ? ((v < (RealPromote)LLONG_MIN)
1069 +                     ? LLONG_MIN
1070 +                     : static_cast<long long>(v - 0.5))
1071 +                 : ((v > (RealPromote)LLONG_MAX)
1072 +                     ? LLONG_MAX
1073 +                     : static_cast<long long>(v + 0.5)));
1074 +    }
1075 +};
1076 +
1077 +template<>
1078 +struct NumericTraits<unsigned long long>
1079 +{
1080 +    typedef unsigned long long Type;
1081 +    typedef unsigned long long Promote;
1082 +    typedef double RealPromote;
1083 +    typedef std::complex<RealPromote> ComplexPromote;
1084 +    typedef Type ValueType;
1085 +
1086 +    typedef VigraTrueType isIntegral;
1087 +    typedef VigraTrueType isScalar;
1088 +    typedef VigraFalseType isSigned;
1089 +    typedef VigraTrueType isOrdered;
1090 +    typedef VigraFalseType isComplex;
1091 +
1092 +    static unsigned long long zero() { return 0; }
1093 +    static unsigned long long one() { return 1; }
1094 +    static unsigned long long nonZero() { return 1; }
1095 +    static unsigned long long min() { return 0; }
1096 +    static unsigned long long max() { return ULLONG_MAX; }
1097 +
1098 +#ifdef NO_INLINE_STATIC_CONST_DEFINITION
1099 +    enum { minConst = 0, maxConst = ULLONG_MAX };
1100 +#else
1101 +    static const unsigned long long minConst = 0;
1102 +    static const unsigned long long maxConst = ULLONG_MAX;
1103 +#endif
1104 +
1105 +    static Promote toPromote(unsigned long long v) { return v; }
1106 +    static RealPromote toRealPromote(unsigned long long v) { return v; }
1107 +    static unsigned long long fromPromote(Promote v) { return v; }
1108 +    static unsigned long long fromRealPromote(RealPromote v) {
1109 +            return ((v < 0.0)
1110 +                     ? 0
1111 +                     : ((v > (RealPromote)ULLONG_MAX)
1112 +                         ? ULLONG_MAX
1113 +                         : static_cast<unsigned long long>(v + 0.5)));
1114 +    }
1115 +};
1116 +#endif
1117 +
1118  template<>
1119  struct NumericTraits<float>
1120  {
1121 @@ -949,6 +1033,7 @@ struct NumericTraits<double>
1122      static double fromRealPromote(RealPromote v) { return v; }
1123  };
1124
1125 +#ifdef VIGRA_HAS_LONG_DOUBLE
1126  template<>
1127  struct NumericTraits<long double>
1128  {
1129 @@ -977,6 +1062,7 @@ struct NumericTraits<long double>
1130      static long double fromPromote(Promote v) { return v; }
1131      static long double fromRealPromote(RealPromote v) { return v; }
1132  };
1133 +#endif
1134
1135  #ifndef NO_PARTIAL_TEMPLATE_SPECIALIZATION
1136
1137 @@ -1055,9 +1141,15 @@ VIGRA_DEFINE_NORM_TRAITS(int)
1138  VIGRA_DEFINE_NORM_TRAITS(unsigned int)
1139  VIGRA_DEFINE_NORM_TRAITS(long)
1140  VIGRA_DEFINE_NORM_TRAITS(unsigned long)
1141 +#ifdef VIGRA_HAS_LONG_LONG
1142 +VIGRA_DEFINE_NORM_TRAITS(long long)
1143 +VIGRA_DEFINE_NORM_TRAITS(unsigned long long)
1144 +#endif
1145  VIGRA_DEFINE_NORM_TRAITS(float)
1146  VIGRA_DEFINE_NORM_TRAITS(double)
1147 +#ifdef VIGRA_HAS_LONG_DOUBLE
1148  VIGRA_DEFINE_NORM_TRAITS(long double)
1149 +#endif
1150
1151  #undef VIGRA_DEFINE_NORM_TRAITS
1152
1153 diff -uprN misc/vigra1.4.0/include/vigra/orientedtensorfilters.hxx misc/build/vigra1.4.0/include/vigra/orientedtensorfilters.hxx
1154 --- misc/vigra1.4.0/include/vigra/orientedtensorfilters.hxx     2005-12-21 05:53:42.000000000 +0100
1155 +++ misc/build/vigra1.4.0/include/vigra/orientedtensorfilters.hxx       2006-08-31 12:08:15.503678000 +0200
1156 @@ -434,7 +434,7 @@ class Sin6RingKernel
1157          if(x == 0 && y == 0)
1158              return weights_(radius_, radius_);
1159          double d = dot(vectors_(x+radius_, y+radius_), v);
1160 -        return VIGRA_CSTD::pow(1.0 - d * d, 3) * weights_(x+radius_, y+radius_);
1161 +        return VIGRA_CSTD::pow(1.0 - d * d, 3.0) * weights_(x+radius_, y+radius_);
1162      }
1163  };
1164
1165 @@ -455,7 +455,7 @@ class Sin6Kernel
1166          if(x == 0 && y == 0)
1167              return weights_(radius_, radius_);
1168          double d = dot(vectors_(x+radius_, y+radius_), v);
1169 -        return VIGRA_CSTD::pow(1.0 - d * d, 3) * weights_(x+radius_, y+radius_);
1170 +        return VIGRA_CSTD::pow(1.0 - d * d, 3.0) * weights_(x+radius_, y+radius_);
1171      }
1172  };
1173
1174 @@ -476,7 +476,7 @@ class Cos6RingKernel
1175          if(x == 0 && y == 0)
1176              return weights_(radius_, radius_);
1177          double d = dot(vectors_(x+radius_, y+radius_), v);
1178 -        return (1.0 - VIGRA_CSTD::pow(1.0 - d * d, 3)) * weights_(x+radius_, y+radius_);
1179 +        return (1.0 - VIGRA_CSTD::pow(1.0 - d * d, 3.0)) * weights_(x+radius_, y+radius_);
1180      }
1181  };
1182
1183 @@ -497,7 +497,7 @@ class Cos6Kernel
1184          if(x == 0 && y == 0)
1185              return weights_(radius_, radius_);
1186          double d = dot(vectors_(x+radius_, y+radius_), v);
1187 -        return (1.0 - VIGRA_CSTD::pow(1.0 - d * d, 3)) * weights_(x+radius_, y+radius_);
1188 +        return (1.0 - VIGRA_CSTD::pow(1.0 - d * d, 3.0)) * weights_(x+radius_, y+radius_);
1189      }
1190  };
1191
1192 diff -uprN misc/vigra1.4.0/include/vigra/polynomial.hxx misc/build/vigra1.4.0/include/vigra/polynomial.hxx
1193 --- misc/vigra1.4.0/include/vigra/polynomial.hxx        2005-12-21 05:53:42.000000000 +0100
1194 +++ misc/build/vigra1.4.0/include/vigra/polynomial.hxx  2006-08-31 12:08:15.526572000 +0200
1195 @@ -118,10 +118,10 @@ class PolynomialView
1196              of subsequent algorithms (especially root finding) performed on the
1197              polynomial.
1198          */
1199 -    PolynomialView(T * coeffs, unsigned int order, double epsilon = 1.0e-14)
1200 +    PolynomialView(T * coeffs, unsigned int ord, double eps = 1.0e-14)
1201      : coeffs_(coeffs),
1202 -      order_(order),
1203 -      epsilon_(epsilon)
1204 +      order_(ord),
1205 +      epsilon_(eps)
1206      {}
1207
1208          /// Access the coefficient of x^i
1209 @@ -244,16 +244,16 @@ class PolynomialView
1210          { epsilon_ = eps; }
1211
1212    protected:
1213 -    PolynomialView(double epsilon = 1e-14)
1214 +    PolynomialView(double eps = 1e-14)
1215      : coeffs_(0),
1216        order_(0),
1217 -      epsilon_(epsilon)
1218 +      epsilon_(eps)
1219      {}
1220
1221 -    void setCoeffs(T * coeffs, unsigned int order)
1222 +    void setCoeffs(T * coeffs, unsigned int ord)
1223      {
1224          coeffs_ = coeffs;
1225 -        order_ = order;
1226 +        order_ = ord;
1227      }
1228
1229      T * coeffs_;
1230 @@ -396,9 +396,9 @@ PolynomialView<T>::deflateConjugatePair(
1231
1232  template <class T>
1233  void
1234 -PolynomialView<T>::minimizeOrder(double epsilon)
1235 +PolynomialView<T>::minimizeOrder(double eps)
1236  {
1237 -    while(std::abs(coeffs_[order_]) <= epsilon && order_ > 0)
1238 +    while(std::abs(coeffs_[order_]) <= eps && order_ > 0)
1239              --order_;
1240  }
1241
1242 diff -uprN misc/vigra1.4.0/include/vigra/recursiveconvolution.hxx misc/build/vigra1.4.0/include/vigra/recursiveconvolution.hxx
1243 --- misc/vigra1.4.0/include/vigra/recursiveconvolution.hxx      2005-12-21 05:53:42.000000000 +0100
1244 +++ misc/build/vigra1.4.0/include/vigra/recursiveconvolution.hxx        2006-08-31 12:08:15.553556000 +0200
1245 @@ -259,16 +259,16 @@ void recursiveFilterLine(SrcIterator is,
1246      {
1247         // correction factors for b
1248          double bright = b;
1249 -        double bleft = VIGRA_CSTD::pow(b, w);
1250 +        double bleft = VIGRA_CSTD::pow(b, (double)w);
1251
1252          for(x=w-1; x>=0; --x, --is, --id)
1253          {
1254              TempType f = b * old;
1255              old = as(is) + f;
1256 -            double norm = (1.0 - b) / (1.0 + b - bleft - bright);
1257 +            double norm2 = (1.0 - b) / (1.0 + b - bleft - bright);
1258              bleft /= b;
1259              bright *= b;
1260 -            ad.set(norm * (line[x] + f), id);
1261 +            ad.set(norm2 * (line[x] + f), id);
1262          }
1263      }
1264      else if(border == BORDER_TREATMENT_AVOID)
1265 diff -uprN misc/vigra1.4.0/include/vigra/rgbvalue.hxx misc/build/vigra1.4.0/include/vigra/rgbvalue.hxx
1266 --- misc/vigra1.4.0/include/vigra/rgbvalue.hxx  2005-12-21 05:53:43.000000000 +0100
1267 +++ misc/build/vigra1.4.0/include/vigra/rgbvalue.hxx    2006-08-31 12:31:37.392094000 +0200
1268 @@ -39,6 +39,10 @@
1269  #ifndef VIGRA_RGBVALUE_HXX
1270  #define VIGRA_RGBVALUE_HXX
1271
1272 +#if defined __GNUC__
1273 +#pragma GCC system_header
1274 +#endif
1275 +
1276  #include <cmath>    // abs(double)
1277  #include <cstdlib>  // abs(int)
1278  #include "vigra/config.hxx"
1279 @@ -700,8 +704,6 @@ operator/=(RGBValue<V, RIDX, GIDX, BIDX>
1280      return l;
1281  }
1282
1283 -using VIGRA_CSTD::abs;
1284 -
1285      /// component-wise absolute value
1286  template <class T, unsigned int RIDX, unsigned int GIDX, unsigned int BIDX>
1287  inline
1288 diff -uprN misc/vigra1.4.0/include/vigra/separableconvolution.hxx misc/build/vigra1.4.0/include/vigra/separableconvolution.hxx
1289 --- misc/vigra1.4.0/include/vigra/separableconvolution.hxx      2005-12-21 05:53:44.000000000 +0100
1290 +++ misc/build/vigra1.4.0/include/vigra/separableconvolution.hxx        2006-08-31 12:08:15.610465000 +0200
1291 @@ -1017,11 +1017,11 @@ class Kernel1D
1292          */
1293      InitProxy operator=(value_type const & v)
1294      {
1295 -        int size = right_ - left_ + 1;
1296 +        int sz = right_ - left_ + 1;
1297          for(unsigned int i=0; i<kernel_.size(); ++i) kernel_[i] = v;
1298 -        norm_ = (double)size*v;
1299 +        norm_ = (double)sz*v;
1300
1301 -        return InitProxy(kernel_.begin(), size, norm_);
1302 +        return InitProxy(kernel_.begin(), sz, norm_);
1303      }
1304
1305          /** Destructor.
1306 @@ -1235,17 +1235,17 @@ class Kernel1D
1307                 is 1 or equals the size of the kernel.
1308              \endcode
1309          */
1310 -    Kernel1D & initExplicitly(int left, int right)
1311 +    Kernel1D & initExplicitly(int l, int r)
1312      {
1313 -        vigra_precondition(left <= 0,
1314 +        vigra_precondition(l <= 0,
1315                       "Kernel1D::initExplicitly(): left border must be <= 0.");
1316 -        vigra_precondition(right >= 0,
1317 +        vigra_precondition(r >= 0,
1318                       "Kernel1D::initExplicitly(): right border must be <= 0.");
1319
1320 -        right_ = right;
1321 -        left_ = left;
1322 +        right_ = r;
1323 +        left_ = l;
1324
1325 -        kernel_.resize(right - left + 1);
1326 +        kernel_.resize(r - l + 1);
1327
1328          return *this;
1329      }
1330 @@ -1342,8 +1342,8 @@ class Kernel1D
1331  };
1332
1333  template <class ARITHTYPE>
1334 -void Kernel1D<ARITHTYPE>::normalize(value_type norm,
1335 -                          unsigned int derivativeOrder,
1336 +void Kernel1D<ARITHTYPE>::normalize(value_type normFactor,
1337 +                          unsigned int derivOrder,
1338                            double offset)
1339  {
1340      typedef typename NumericTraits<value_type>::RealPromote TmpType;
1341 @@ -1352,7 +1352,7 @@ void Kernel1D<ARITHTYPE>::normalize(valu
1342      Iterator k = kernel_.begin();
1343      TmpType sum = NumericTraits<TmpType>::zero();
1344
1345 -    if(derivativeOrder == 0)
1346 +    if(derivOrder == 0)
1347      {
1348          for(; k < kernel_.end(); ++k)
1349          {
1350 @@ -1362,11 +1362,11 @@ void Kernel1D<ARITHTYPE>::normalize(valu
1351      else
1352      {
1353          unsigned int faculty = 1;
1354 -        for(unsigned int i = 2; i <= derivativeOrder; ++i)
1355 +        for(unsigned int i = 2; i <= derivOrder; ++i)
1356              faculty *= i;
1357          for(double x = left() + offset; k < kernel_.end(); ++x, ++k)
1358          {
1359 -            sum += *k * VIGRA_CSTD::pow(-x, int(derivativeOrder)) / faculty;
1360 +            sum += *k * VIGRA_CSTD::pow(-x, (double)derivOrder) / faculty;
1361          }
1362      }
1363
1364 @@ -1374,21 +1374,21 @@ void Kernel1D<ARITHTYPE>::normalize(valu
1365                      "Kernel1D<ARITHTYPE>::normalize(): "
1366                      "Cannot normalize a kernel with sum = 0");
1367      // normalize
1368 -    sum = norm / sum;
1369 +    sum = normFactor / sum;
1370      k = kernel_.begin();
1371      for(; k != kernel_.end(); ++k)
1372      {
1373          *k = *k * sum;
1374      }
1375
1376 -    norm_ = norm;
1377 +    norm_ = normFactor;
1378  }
1379
1380  /***********************************************************************/
1381
1382  template <class ARITHTYPE>
1383  void Kernel1D<ARITHTYPE>::initGaussian(double std_dev,
1384 -                                       value_type norm)
1385 +                                       value_type normFactor)
1386  {
1387      vigra_precondition(std_dev >= 0.0,
1388                "Kernel1D::initGaussian(): Standard deviation must be >= 0.");
1389 @@ -1421,8 +1421,8 @@ void Kernel1D<ARITHTYPE>::initGaussian(d
1390          right_ = 0;
1391      }
1392
1393 -    if(norm != 0.0)
1394 -        normalize(norm);
1395 +    if(normFactor != 0.0)
1396 +        normalize(normFactor);
1397      else
1398          norm_ = 1.0;
1399
1400 @@ -1434,7 +1434,7 @@ void Kernel1D<ARITHTYPE>::initGaussian(d
1401
1402  template <class ARITHTYPE>
1403  void Kernel1D<ARITHTYPE>::initDiscreteGaussian(double std_dev,
1404 -                                       value_type norm)
1405 +                                               value_type normFactor)
1406  {
1407      vigra_precondition(std_dev >= 0.0,
1408                "Kernel1D::initDiscreteGaussian(): Standard deviation must be >= 0.");
1409 @@ -1476,7 +1476,7 @@ void Kernel1D<ARITHTYPE>::initDiscreteGa
1410              er += warray[i];
1411          }
1412
1413 -        double scale = norm / (2*er - warray[0]);
1414 +        double scale = normFactor / (2*er - warray[0]);
1415
1416          initExplicitly(-radius, radius);
1417          iterator c = center();
1418 @@ -1489,12 +1489,12 @@ void Kernel1D<ARITHTYPE>::initDiscreteGa
1419      else
1420      {
1421          kernel_.erase(kernel_.begin(), kernel_.end());
1422 -        kernel_.push_back(norm);
1423 +        kernel_.push_back(normFactor);
1424          left_ = 0;
1425          right_ = 0;
1426      }
1427
1428 -    norm_ = norm;
1429 +    norm_ = normFactor;
1430
1431      // best border treatment for Gaussians is BORDER_TREATMENT_REFLECT
1432      border_treatment_ = BORDER_TREATMENT_REFLECT;
1433 @@ -1505,15 +1505,15 @@ void Kernel1D<ARITHTYPE>::initDiscreteGa
1434  template <class ARITHTYPE>
1435  void
1436  Kernel1D<ARITHTYPE>::initGaussianDerivative(double std_dev,
1437 -                    int order,
1438 -                    value_type norm)
1439 +                                            int order,
1440 +                                            value_type normFactor)
1441  {
1442      vigra_precondition(order >= 0,
1443                "Kernel1D::initGaussianDerivative(): Order must be >= 0.");
1444
1445      if(order == 0)
1446      {
1447 -        initGaussian(std_dev, norm);
1448 +        initGaussian(std_dev, normFactor);
1449          return;
1450      }
1451
1452 @@ -1544,7 +1544,7 @@ Kernel1D<ARITHTYPE>::initGaussianDerivat
1453
1454      // remove DC, but only if kernel correction is permitted by a non-zero
1455      // value for norm
1456 -    if(norm != 0.0)
1457 +    if(normFactor != 0.0)
1458      {
1459          for(unsigned int i=0; i < kernel_.size(); ++i)
1460          {
1461 @@ -1555,8 +1555,8 @@ Kernel1D<ARITHTYPE>::initGaussianDerivat
1462      left_ = -radius;
1463      right_ = radius;
1464
1465 -    if(norm != 0.0)
1466 -        normalize(norm, order);
1467 +    if(normFactor != 0.0)
1468 +        normalize(normFactor, order);
1469      else
1470          norm_ = 1.0;
1471
1472 @@ -1570,7 +1570,7 @@ Kernel1D<ARITHTYPE>::initGaussianDerivat
1473  template <class ARITHTYPE>
1474  void
1475  Kernel1D<ARITHTYPE>::initBinomial(int radius,
1476 -                                  value_type norm)
1477 +                                  value_type normFactor)
1478  {
1479      vigra_precondition(radius > 0,
1480                "Kernel1D::initBinomial(): Radius must be > 0.");
1481 @@ -1600,12 +1600,12 @@ Kernel1D<ARITHTYPE>::initBinomial(int ra
1482
1483      for(i=0; i<=radius*2+1; ++i)
1484      {
1485 -        kernel_.push_back(kernel[i] * norm);
1486 +        kernel_.push_back(kernel[i] * normFactor);
1487      }
1488
1489      left_ = -radius;
1490      right_ = radius;
1491 -    norm_ = norm;
1492 +    norm_ = normFactor;
1493
1494      // best border treatment for Binomial is BORDER_TREATMENT_REFLECT
1495      border_treatment_ = BORDER_TREATMENT_REFLECT;
1496 @@ -1615,7 +1615,7 @@ Kernel1D<ARITHTYPE>::initBinomial(int ra
1497
1498  template <class ARITHTYPE>
1499  void Kernel1D<ARITHTYPE>::initAveraging(int radius,
1500 -                                        value_type norm)
1501 +                                        value_type normFactor)
1502  {
1503      vigra_precondition(radius > 0,
1504                "Kernel1D::initAveraging(): Radius must be > 0.");
1505 @@ -1629,12 +1629,12 @@ void Kernel1D<ARITHTYPE>::initAveraging(
1506
1507      for(int i=0; i<=radius*2+1; ++i)
1508      {
1509 -        kernel_.push_back(scale * norm);
1510 +        kernel_.push_back(scale * normFactor);
1511      }
1512
1513      left_ = -radius;
1514      right_ = radius;
1515 -    norm_ = norm;
1516 +    norm_ = normFactor;
1517
1518      // best border treatment for Averaging is BORDER_TREATMENT_CLIP
1519      border_treatment_ = BORDER_TREATMENT_CLIP;
1520 @@ -1644,18 +1644,18 @@ void Kernel1D<ARITHTYPE>::initAveraging(
1521
1522  template <class ARITHTYPE>
1523  void
1524 -Kernel1D<ARITHTYPE>::initSymmetricGradient(value_type norm)
1525 +Kernel1D<ARITHTYPE>::initSymmetricGradient(value_type normFactor)
1526  {
1527      kernel_.erase(kernel_.begin(), kernel_.end());
1528      kernel_.reserve(3);
1529
1530 -    kernel_.push_back(0.5 * norm);
1531 -    kernel_.push_back(0.0 * norm);
1532 -    kernel_.push_back(-0.5 * norm);
1533 +    kernel_.push_back(0.5 * normFactor);
1534 +    kernel_.push_back(0.0 * normFactor);
1535 +    kernel_.push_back(-0.5 * normFactor);
1536
1537      left_ = -1;
1538      right_ = 1;
1539 -    norm_ = norm;
1540 +    norm_ = normFactor;
1541
1542      // best border treatment for SymmetricGradient is
1543      // BORDER_TREATMENT_REPEAT
1544 diff -uprN misc/vigra1.4.0/include/vigra/sized_int.hxx misc/build/vigra1.4.0/include/vigra/sized_int.hxx
1545 --- misc/vigra1.4.0/include/vigra/sized_int.hxx 2005-12-21 05:53:44.000000000 +0100
1546 +++ misc/build/vigra1.4.0/include/vigra/sized_int.hxx   2006-08-31 12:26:31.937797000 +0200
1547 @@ -73,6 +73,10 @@ struct SelectIntegerType<SIZE, Int_type_
1548      typedef Int_type_not_supported_on_this_platform type;
1549  };
1550
1551 +#if defined __SUNPRO_CC
1552 +#pragma disable_warn
1553 +#endif
1554 +
1555  template<class LIST>
1556  struct SelectBiggestIntegerType
1557  {
1558 @@ -86,6 +90,10 @@ struct SelectBiggestIntegerType
1559         type;
1560  };
1561
1562 +#if defined __SUNPRO_CC
1563 +#pragma enable_warn
1564 +#endif
1565 +
1566  template<>
1567  struct SelectBiggestIntegerType<Int_type_not_supported_on_this_platform>
1568  {
1569 diff -uprN misc/vigra1.4.0/include/vigra/splines.hxx misc/build/vigra1.4.0/include/vigra/splines.hxx
1570 --- misc/vigra1.4.0/include/vigra/splines.hxx   2005-12-21 05:53:44.000000000 +0100
1571 +++ misc/build/vigra1.4.0/include/vigra/splines.hxx     2006-08-31 12:08:15.655906000 +0200
1572 @@ -108,8 +108,8 @@ class BSplineBase
1573          /** Create functor for gevine derivative of the spline. The spline's order
1574              is specified spline by the template argument <TT>ORDER</tt>.
1575          */
1576 -    explicit BSplineBase(unsigned int derivativeOrder = 0)
1577 -    : s1_(derivativeOrder)
1578 +    explicit BSplineBase(unsigned int derivOrder = 0)
1579 +    : s1_(derivOrder)
1580      {}
1581
1582          /** Unary function call.
1583 @@ -280,8 +280,8 @@ class BSplineBase<0, T>
1584      typedef T            result_type;
1585      enum StaticOrder { order = 0 };
1586
1587 -    explicit BSplineBase(unsigned int derivativeOrder = 0)
1588 -    : derivativeOrder_(derivativeOrder)
1589 +    explicit BSplineBase(unsigned int derivOrder = 0)
1590 +    : derivativeOrder_(derivOrder)
1591      {}
1592
1593      result_type operator()(argument_type x) const
1594 @@ -357,8 +357,8 @@ class BSpline<1, T>
1595      typedef T            result_type;
1596      enum  StaticOrder { order = 1 };
1597
1598 -    explicit BSpline(unsigned int derivativeOrder = 0)
1599 -    : derivativeOrder_(derivativeOrder)
1600 +    explicit BSpline(unsigned int derivOrder = 0)
1601 +    : derivativeOrder_(derivOrder)
1602      {}
1603
1604      result_type operator()(argument_type x) const
1605 @@ -454,8 +454,8 @@ class BSpline<2, T>
1606      typedef T            result_type;
1607      enum StaticOrder { order = 2 };
1608
1609 -    explicit BSpline(unsigned int derivativeOrder = 0)
1610 -    : derivativeOrder_(derivativeOrder)
1611 +    explicit BSpline(unsigned int derivOrder = 0)
1612 +    : derivativeOrder_(derivOrder)
1613      {}
1614
1615      result_type operator()(argument_type x) const
1616 @@ -580,8 +580,8 @@ class BSpline<3, T>
1617      typedef T            result_type;
1618      enum StaticOrder { order = 3 };
1619
1620 -    explicit BSpline(unsigned int derivativeOrder = 0)
1621 -    : derivativeOrder_(derivativeOrder)
1622 +    explicit BSpline(unsigned int derivOrder = 0)
1623 +    : derivativeOrder_(derivOrder)
1624      {}
1625
1626      result_type operator()(argument_type x) const
1627 @@ -732,8 +732,8 @@ class BSpline<5, T>
1628      typedef T            result_type;
1629      enum StaticOrder { order = 5 };
1630
1631 -    explicit BSpline(unsigned int derivativeOrder = 0)
1632 -    : derivativeOrder_(derivativeOrder)
1633 +    explicit BSpline(unsigned int derivOrder = 0)
1634 +    : derivativeOrder_(derivOrder)
1635      {}
1636
1637      result_type operator()(argument_type x) const
1638 diff -uprN misc/vigra1.4.0/include/vigra/static_assert.hxx misc/build/vigra1.4.0/include/vigra/static_assert.hxx
1639 --- misc/vigra1.4.0/include/vigra/static_assert.hxx     2005-12-21 05:53:45.000000000 +0100
1640 +++ misc/build/vigra1.4.0/include/vigra/static_assert.hxx       2006-08-31 12:08:15.677548000 +0200
1641 @@ -115,7 +115,7 @@ assertImpl( void (*)(Predicate), typenam
1642
1643  TODO: provide more assertion base classes for other (non boolean) types of tests
1644  */
1645 -#if !defined(__GNUC__) || __GNUC__ > 2
1646 +#if (!defined(__GNUC__) || __GNUC__ > 2) && (!defined(__SUNPRO_CC) || __SUNPRO_CC > 0x550)
1647  #define VIGRA_STATIC_ASSERT(Predicate) \
1648  enum { \
1649      VIGRA_PREPROCESSOR_CONCATENATE(vigra_assertion_in_line_, __LINE__) = sizeof( \
1650 diff -uprN misc/vigra1.4.0/include/vigra/tinyvector.hxx misc/build/vigra1.4.0/include/vigra/tinyvector.hxx
1651 --- misc/vigra1.4.0/include/vigra/tinyvector.hxx        2005-12-21 05:53:46.000000000 +0100
1652 +++ misc/build/vigra1.4.0/include/vigra/tinyvector.hxx  2006-08-31 12:31:25.140791000 +0200
1653 @@ -39,6 +39,10 @@
1654  #ifndef VIGRA_TINYVECTOR_HXX
1655  #define VIGRA_TINYVECTOR_HXX
1656
1657 +#if defined __GNUC__
1658 +#pragma GCC system_header
1659 +#endif
1660 +
1661  #include <cmath>    // abs(double)
1662  #include <cstdlib>  // abs(int)
1663  #include <iosfwd>   // ostream
1664 @@ -49,7 +53,6 @@
1665
1666  namespace vigra {
1667
1668 -using VIGRA_CSTD::abs;
1669  using VIGRA_CSTD::ceil;
1670  using VIGRA_CSTD::floor;
1671
1672 @@ -439,9 +442,9 @@ class TinyVectorBase
1673          /** Initialize from another sequence (must have length SIZE!)
1674          */
1675      template <class Iterator>
1676 -    void init(Iterator i, Iterator end)
1677 +    void init(Iterator i, Iterator iend)
1678      {
1679 -               vigra_precondition(end-i == SIZE,
1680 +               vigra_precondition(iend-i == SIZE,
1681              "TinyVector::init(): Sequence has wrong size.");
1682          Loop::assignCast(data_, i);
1683      }
1684 diff -uprN misc/vigra1.4.0/include/vigra/transformimage.hxx misc/build/vigra1.4.0/include/vigra/transformimage.hxx
1685 --- misc/vigra1.4.0/include/vigra/transformimage.hxx    2005-12-21 05:53:46.000000000 +0100
1686 +++ misc/build/vigra1.4.0/include/vigra/transformimage.hxx      2006-08-31 12:08:15.727415000 +0200
1687 @@ -986,11 +986,11 @@ class BrightnessContrastFunctor
1688      result_type operator()(argument_type const & v) const
1689      {
1690          promote_type v1 = (v - min_) / diff_;
1691 -        promote_type brighter = pow(v1, b_);
1692 +        promote_type brighter = pow((promote_type)v1, b_);
1693          promote_type v2 = 2.0 * brighter - one_;
1694          promote_type contrasted = (v2 < zero_) ?
1695 -                                     -pow(-v2, c_) :
1696 -                                      pow(v2, c_);
1697 +                                     -pow((promote_type)-v2, c_) :
1698 +                                      pow((promote_type)v2, c_);
1699          return result_type(0.5 * diff_ * (contrasted + one_) + min_);
1700      }
1701