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