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