You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openoffice.apache.org by pf...@apache.org on 2012/09/20 01:31:30 UTC
svn commit: r1387816 - in /incubator/ooo/trunk: ext_sources/ main/
main/mdds/ main/mdds/prj/ main/vigra/ main/vigra/prj/
Author: pfg
Date: Wed Sep 19 23:31:29 2012
New Revision: 1387816
URL: http://svn.apache.org/viewvc?rev=1387816&view=rev
Log:
Updates to upstream mdds and Vigra
mdds 0.3.1
* added support for boost::unordered_map (boost) and
std::hash_map (stlport) in addition to C++0x's
std::unordered_map.
More information here on the mdds changes here:
http://kohei.us/2010/10/15/mdds-0-3-1/
Vigra 1.6.0 (Newer versions use Cmake)
* Adds a lot of functionality and includes improvements
for 64 bit compilers.
* Add explicit cast (gcc 4.7 compatibility patch by Stephan Bergmann)
https://github.com/ukoethe/vigra/commit/e0dcd31c76bb13c98920e21544b309ca47bb3c5c
More information on the Vigra changes here:
http://hci.iwr.uni-heidelberg.de/vigra/doc/vigra/CreditsChangelog.html
Added:
incubator/ooo/trunk/main/vigra/vigra1.6.0.patch
Removed:
incubator/ooo/trunk/ext_sources/cf8a6967f7de535ae257fa411c98eb88-mdds_0.3.0.tar.bz2
incubator/ooo/trunk/ext_sources/ea91f2fb4212a21d708aced277e6e85a-vigra1.4.0.tar.gz
incubator/ooo/trunk/main/vigra/vigra1.4.0.patch
Modified:
incubator/ooo/trunk/main/external_deps.lst
incubator/ooo/trunk/main/mdds/makefile.mk
incubator/ooo/trunk/main/mdds/prj/d.lst
incubator/ooo/trunk/main/vigra/makefile.mk
incubator/ooo/trunk/main/vigra/prj/d.lst
Modified: incubator/ooo/trunk/main/external_deps.lst
URL: http://svn.apache.org/viewvc/incubator/ooo/trunk/main/external_deps.lst?rev=1387816&r1=1387815&r2=1387816&view=diff
==============================================================================
--- incubator/ooo/trunk/main/external_deps.lst (original)
+++ incubator/ooo/trunk/main/external_deps.lst Wed Sep 19 23:31:29 2012
@@ -47,6 +47,12 @@ if ( true )
URL1 = http://sourceforge.net/projects/hunspell/files/MyThes/1.2.0/mythes-1.2.0.tar.gz/download
URL2 = $(OOO_EXTRAS)$(MD5)-$(name)
+if ( true )
+ MD5 = 0dd138efff4412c707e239290fb82d4f
+ name = mdds_0.3.1.tar.bz2
+ URL1 = http://multidimalgorithm.googlecode.com/files/mdds_0.3.1.tar.bz2
+ URL2 = $(OOO_EXTRAS)$(MD5)-$(name)
+
if (SYSTEM_LIBTEXTCAT != YES)
MD5 = 128cfc86ed5953e57fe0f5ae98b62c2e
name = libtextcat-2.2.tar.gz
@@ -69,7 +75,7 @@ if (SOLAR_JAVA == TRUE)
name = lucene-2.9.4-src.tar.gz
URL1 = http://archive.apache.org/dist/lucene/java/2.9.4/lucene-2.9.4-src.tar.gz
URL2 = $(OOO_EXTRAS)$(MD5)-$(name)
-
+
if (WITH_MOZILLA != NO)
MD5 = 1f24ab1d39f4a51faf22244c94a6203f
name = xmlsec1-1.2.14.tar.gz
@@ -216,12 +222,6 @@ if (GUI!=UNX || SYSTEM_ZLIB!=YES)
name = zlib-1.2.5.tar.gz
URL1 = $(OOO_EXTRAS)$(MD5)-$(name)
-if ( true )
- MD5 = cf8a6967f7de535ae257fa411c98eb88
- name = mdds_0.3.0.tar.bz2
- URL1 = http://multidimalgorithm.googlecode.com/files/mdds_0.3.0.tar.bz2
- URL2 = $(OOO_EXTRAS)$(MD5)-$(name)
-
if (SYSTEM_BOOST!=YES || (OS==SOLARIS && COM!=GCC))
MD5 = d1e9a7a7f532bb031a3c175d86688d95
name = boost_1_48_0.tar.bz2
@@ -229,9 +229,9 @@ if (SYSTEM_BOOST!=YES || (OS==SOLARIS &&
URL2 = $(OOO_EXTRAS)$(MD5)-$(name)
if (SYSTEM_VIGRA != YES)
- MD5 = ea91f2fb4212a21d708aced277e6e85a
- name = vigra1.4.0.tar.gz
- URL1 = http://hci.iwr.uni-heidelberg.de/vigra/vigra1.4.0.tar.gz
+ MD5 = d62650a6f908e85643e557a236ea989c
+ name = vigra1.6.0.tar.gz
+ URL1 = http://hci.iwr.uni-heidelberg.de/vigra/vigra1.6.0.tar.gz
URL2 = $(OOO_EXTRAS)$(MD5)-$(name)
if (SYSTEM_CURL != YES)
Modified: incubator/ooo/trunk/main/mdds/makefile.mk
URL: http://svn.apache.org/viewvc/incubator/ooo/trunk/main/mdds/makefile.mk?rev=1387816&r1=1387815&r2=1387816&view=diff
==============================================================================
--- incubator/ooo/trunk/main/mdds/makefile.mk (original)
+++ incubator/ooo/trunk/main/mdds/makefile.mk Wed Sep 19 23:31:29 2012
@@ -32,8 +32,8 @@ TARGET=mdds
# --- Files --------------------------------------------------------
-TARFILE_NAME=mdds_0.3.0
-TARFILE_MD5=cf8a6967f7de535ae257fa411c98eb88
+TARFILE_NAME=mdds_0.3.1
+TARFILE_MD5=0dd138efff4412c707e239290fb82d4f
PATCH_FILES=
CONFIGURE_DIR=
@@ -55,7 +55,7 @@ NORMALIZE_FLAG_FILE=so_normalized_$(TARG
$(PACKAGE_DIR)$/$(NORMALIZE_FLAG_FILE) : $(PACKAGE_DIR)$/$(BUILD_FLAG_FILE)
-@$(MKDIRHIER) $(INCCOM)
- @$(GNUCOPY) -r $(PACKAGE_DIR)$/$(TARFILE_NAME)$/inc$/mdds $(INCCOM)
+ @$(GNUCOPY) -R $(PACKAGE_DIR)$/$(TARFILE_NAME)$/include$/mdds $(INCCOM)
@$(TOUCH) $(PACKAGE_DIR)$/$(NORMALIZE_FLAG_FILE)
$(PACKAGE_DIR)$/$(PREDELIVER_FLAG_FILE) : $(PACKAGE_DIR)$/$(NORMALIZE_FLAG_FILE)
Modified: incubator/ooo/trunk/main/mdds/prj/d.lst
URL: http://svn.apache.org/viewvc/incubator/ooo/trunk/main/mdds/prj/d.lst?rev=1387816&r1=1387815&r2=1387816&view=diff
==============================================================================
--- incubator/ooo/trunk/main/mdds/prj/d.lst (original)
+++ incubator/ooo/trunk/main/mdds/prj/d.lst Wed Sep 19 23:31:29 2012
@@ -1,5 +1,5 @@
mkdir: %_DEST%\inc%_EXT%\mdds
+mkdir: %_DEST%\inc%_EXT%\mdds\hash_container
..\%__SRC%\inc\mdds\* %_DEST%\inc%_EXT%\mdds
-
-
+..\%__SRC%\inc\mdds\hash_container\* %_DEST%\inc%_EXT%\mdds\hash_container
Modified: incubator/ooo/trunk/main/vigra/makefile.mk
URL: http://svn.apache.org/viewvc/incubator/ooo/trunk/main/vigra/makefile.mk?rev=1387816&r1=1387815&r2=1387816&view=diff
==============================================================================
--- incubator/ooo/trunk/main/vigra/makefile.mk (original)
+++ incubator/ooo/trunk/main/vigra/makefile.mk Wed Sep 19 23:31:29 2012
@@ -42,8 +42,8 @@ all:
# --- Files --------------------------------------------------------
-TARFILE_NAME=vigra1.4.0
-TARFILE_MD5=ea91f2fb4212a21d708aced277e6e85a
+TARFILE_NAME=vigra1.6.0
+TARFILE_MD5=d62650a6f908e85643e557a236ea989c
PATCH_FILES=$(TARFILE_NAME).patch
CONFIGURE_DIR=
Modified: incubator/ooo/trunk/main/vigra/prj/d.lst
URL: http://svn.apache.org/viewvc/incubator/ooo/trunk/main/vigra/prj/d.lst?rev=1387816&r1=1387815&r2=1387816&view=diff
==============================================================================
--- incubator/ooo/trunk/main/vigra/prj/d.lst (original)
+++ incubator/ooo/trunk/main/vigra/prj/d.lst Wed Sep 19 23:31:29 2012
@@ -1,3 +1,3 @@
mkdir: %_DEST%\inc%_EXT%\vigra
-..\%__SRC%\misc\build\vigra1.4.0\include\vigra\*.hxx %_DEST%\inc%_EXT%\vigra\*.hxx
+..\%__SRC%\misc\build\vigra1.6.0\include\vigra\*.hxx %_DEST%\inc%_EXT%\vigra\*.hxx
Added: incubator/ooo/trunk/main/vigra/vigra1.6.0.patch
URL: http://svn.apache.org/viewvc/incubator/ooo/trunk/main/vigra/vigra1.6.0.patch?rev=1387816&view=auto
==============================================================================
--- incubator/ooo/trunk/main/vigra/vigra1.6.0.patch (added)
+++ incubator/ooo/trunk/main/vigra/vigra1.6.0.patch Wed Sep 19 23:31:29 2012
@@ -0,0 +1,1357 @@
+diff -uprN misc/vigra1.6.0/configure misc/build/vigra1.6.0/configure
+--- misc/vigra1.6.0/configure 2008-08-13 08:15:32.000000000 -0500
++++ misc/build/vigra1.6.0/configure 2012-09-19 17:30:24.000000000 -0500
+@@ -7843,7 +7843,7 @@ kfreebsd*-gnu)
+ ;;
+
+ freebsd*)
+- objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
++ objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo elf`
+ version_type=freebsd-$objformat
+ case $version_type in
+ freebsd-elf*)
+@@ -11504,7 +11504,7 @@ kfreebsd*-gnu)
+ ;;
+
+ freebsd*)
+- objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
++ objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo elf`
+ version_type=freebsd-$objformat
+ case $version_type in
+ freebsd-elf*)
+@@ -14616,7 +14616,7 @@ kfreebsd*-gnu)
+ ;;
+
+ freebsd*)
+- objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
++ objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo elf`
+ version_type=freebsd-$objformat
+ case $version_type in
+ freebsd-elf*)
+@@ -16958,7 +16958,7 @@ kfreebsd*-gnu)
+ ;;
+
+ freebsd*)
+- objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
++ objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo elf`
+ version_type=freebsd-$objformat
+ case $version_type in
+ freebsd-elf*)
+diff -uprN misc/vigra1.6.0/include/vigra/array_vector.hxx misc/build/vigra1.6.0/include/vigra/array_vector.hxx
+--- misc/vigra1.6.0/include/vigra/array_vector.hxx 2008-08-13 08:15:34.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/array_vector.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -578,7 +578,38 @@ public:
+ iterator insert(iterator p, size_type n, value_type const & v);
+
+ template <class InputIterator>
+- iterator insert(iterator p, InputIterator i, InputIterator iend);
++ iterator insert(iterator p, InputIterator i, InputIterator iend)
++ {
++ difference_type n = iend - i;
++ difference_type pos = p - begin();
++ size_type new_size = size() + n;
++ if(new_size >= capacity_)
++ {
++ pointer new_data = reserve_raw(new_size);
++ std::uninitialized_copy(begin(), p, new_data);
++ std::uninitialized_copy(i, iend, new_data + pos);
++ std::uninitialized_copy(p, end(), new_data + pos + n);
++ deallocate(data_, size_);
++ capacity_ = new_size;
++ data_ = new_data;
++ }
++ else if(pos + n >= size_)
++ {
++ size_type diff = pos + n - size_;
++ std::uninitialized_copy(p, end(), end() + diff);
++ std::uninitialized_copy(iend - diff, iend, end());
++ std::copy(i, iend - diff, p);
++ }
++ else
++ {
++ size_type diff = size_ - (pos + n);
++ std::uninitialized_copy(end() - n, end(), end());
++ std::copy_backward(p, p + diff, end());
++ std::copy(i, iend, p);
++ }
++ size_ = new_size;
++ return begin() + pos;
++ }
+
+ iterator erase(iterator p);
+
+diff -uprN misc/vigra1.6.0/include/vigra/basicimage.hxx misc/build/vigra1.6.0/include/vigra/basicimage.hxx
+--- misc/vigra1.6.0/include/vigra/basicimage.hxx 2008-08-13 08:15:34.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/basicimage.hxx 2012-09-19 17:46:22.000000000 -0500
+@@ -572,7 +572,11 @@ class BasicImage
+ typedef Alloc allocator_type;
+
+ typedef Alloc Allocator;
++#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
+ typedef typename Alloc::template rebind<PIXELTYPE *>::other LineAllocator;
++#else
++ typedef std::allocator<PIXELTYPE*> LineAllocator;
++#endif
+
+ /** construct image of size 0x0
+ */
+@@ -589,39 +593,51 @@ class BasicImage
+ width_(0),
+ height_(0),
+ allocator_(alloc),
++#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
+ pallocator_(alloc)
++#else
++ pallocator_()
++#endif
+ {}
+
+ /** construct image of size width x height, use the specified allocator.
+ */
+- BasicImage(int width, int height, Alloc const & alloc = Alloc())
++ BasicImage(int w, int h, Alloc const & alloc = Alloc())
+ : data_(0),
+ width_(0),
+ height_(0),
+ allocator_(alloc),
++#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
+ pallocator_(alloc)
++#else
++ pallocator_()
++#endif
+ {
+- vigra_precondition((width >= 0) && (height >= 0),
+- "BasicImage::BasicImage(int width, int height): "
++ vigra_precondition((w >= 0) && (h >= 0),
++ "BasicImage::BasicImage(int w, int h): "
+ "width and height must be >= 0.\n");
+
+- resize(width, height, value_type());
++ resize(w, h, value_type());
+ }
+
+ /** construct image of size size.x x size.y, use the specified allocator.
+ */
+- explicit BasicImage(difference_type const & size, Alloc const & alloc = Alloc())
++ explicit BasicImage(difference_type const & sz, Alloc const & alloc = Alloc())
+ : data_(0),
+ width_(0),
+ height_(0),
+ allocator_(alloc),
++#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
+ pallocator_(alloc)
+- {
+- vigra_precondition((size.x >= 0) && (size.y >= 0),
+- "BasicImage::BasicImage(Diff2D size): "
+- "size.x and size.y must be >= 0.\n");
++#else
++ pallocator_()
++#endif
++ {
++ vigra_precondition((sz.x >= 0) && (sz.y >= 0),
++ "BasicImage::BasicImage(Diff2D sz): "
++ "sz.x and sz.y must be >= 0.\n");
+
+- resize(size.x, size.y, value_type());
++ resize(sz.x, sz.y, value_type());
+ }
+
+ /** construct image of size width*height and initialize every
+@@ -629,71 +645,87 @@ class BasicImage
+ value_type doesn't have a default constructor).
+ Use the specified allocator.
+ */
+- BasicImage(int width, int height, value_type const & d, Alloc const & alloc = Alloc())
++ BasicImage(int w, int h, value_type const & d, Alloc const & alloc = Alloc())
+ : data_(0),
+ width_(0),
+ height_(0),
+ allocator_(alloc),
++#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
+ pallocator_(alloc)
++#else
++ pallocator_()
++#endif
+ {
+- vigra_precondition((width >= 0) && (height >= 0),
+- "BasicImage::BasicImage(int width, int height, value_type const & ): "
++ vigra_precondition((w >= 0) && (h >= 0),
++ "BasicImage::BasicImage(int w, int h, value_type const & ): "
+ "width and height must be >= 0.\n");
+
+- resize(width, height, d);
++ resize(w, h, d);
+ }
+
+ /** construct image of size size.x x size.y and initialize
+ every pixel with given data (use this constructor, if
+ value_type doesn't have a default constructor). Use the specified allocator.
+ */
+- explicit BasicImage(difference_type const & size, value_type const & d, Alloc const & alloc = Alloc())
++ explicit BasicImage(difference_type const & sz, value_type const & d, Alloc const & alloc = Alloc())
+ : data_(0),
+ width_(0),
+ height_(0),
+ allocator_(alloc),
++#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
+ pallocator_(alloc)
+- {
+- vigra_precondition((size.x >= 0) && (size.y >= 0),
+- "BasicImage::BasicImage(Diff2D const & size, value_type const & v): "
+- "size.x and size.y must be >= 0.\n");
++#else
++ pallocator_()
++#endif
++ {
++ vigra_precondition((sz.x >= 0) && (sz.y >= 0),
++ "BasicImage::BasicImage(Diff2D const & sz, value_type const & v): "
++ "sz.x and sz.y must be >= 0.\n");
+
+- resize(size.x, size.y, d);
++ resize(sz.x, sz.y, d);
+ }
+
+
+ /** construct image of size width*height and copy the data from the
+ given C-style array \a d. Use the specified allocator.
+ */
+- BasicImage(int width, int height, const_pointer d, Alloc const & alloc = Alloc())
++ BasicImage(int w, int h, const_pointer d, Alloc const & alloc = Alloc())
+ : data_(0),
+ width_(0),
+ height_(0),
+ allocator_(alloc),
++#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
+ pallocator_(alloc)
++#else
++ pallocator_()
++#endif
+ {
+- vigra_precondition((width >= 0) && (height >= 0),
+- "BasicImage::BasicImage(int width, int height, const_pointer ): "
++ vigra_precondition((w >= 0) && (h >= 0),
++ "BasicImage::BasicImage(int w, int h, const_pointer ): "
+ "width and height must be >= 0.\n");
+
+- resizeCopy(width, height, d);
++ resizeCopy(w, h, d);
+ }
+
+ /** construct image of size size.x x size.y and copy the data from the
+ given C-style array. Use the specified allocator.
+ */
+- explicit BasicImage(difference_type const & size, const_pointer d, Alloc const & alloc = Alloc())
++ explicit BasicImage(difference_type const & sz, const_pointer d, Alloc const & alloc = Alloc())
+ : data_(0),
+ width_(0),
+ height_(0),
+ allocator_(alloc),
++#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
+ pallocator_(alloc)
+- {
+- vigra_precondition((size.x >= 0) && (size.y >= 0),
+- "BasicImage::BasicImage(Diff2D const & size, const_pointer): "
+- "size.x and size.y must be >= 0.\n");
++#else
++ pallocator_()
++#endif
++ {
++ vigra_precondition((sz.x >= 0) && (sz.y >= 0),
++ "BasicImage::BasicImage(Diff2D const & sz, const_pointer): "
++ "sz.x and sz.y must be >= 0.\n");
+
+- resizeCopy(size.x, size.y, d);
++ resizeCopy(sz.x, sz.y, d);
+ }
+
+ /** copy rhs image
+@@ -730,20 +762,20 @@ class BasicImage
+ /** reset image to specified size (dimensions must not be negative)
+ (old data are kept if new size matches old size)
+ */
+- void resize(int width, int height)
++ void resize(int w, int h)
+ {
+- if(width != width_ || height != height_)
+- resize(width, height, value_type());
++ if(w != width_ || h != height_)
++ resize(w, h, value_type());
+ }
+
+ /** reset image to specified size (dimensions must not be negative)
+ (old data are kept if new size matches old size)
+ */
+- void resize(difference_type const & size)
++ void resize(difference_type const & sz)
+ {
+- if(size.x != width_ || size.y != height_)
++ if(sz.x != width_ || sz.y != height_)
+ {
+- resize(size.x, size.y, value_type());
++ resize(sz.x, sz.y, value_type());
+ }
+ }
+
+@@ -752,12 +784,12 @@ class BasicImage
+ constructor, dimensions must not be negative,
+ old data are kept if new size matches old size)
+ */
+- void resize(int width, int height, value_type const & d);
++ void resize(int w, int h, value_type const & d);
+
+ /** resize image to given size and initialize by copying data
+ from the C-style arra \a data.
+ */
+- void resizeCopy(int width, int height, const_pointer data);
++ void resizeCopy(int w, int h, const_pointer data);
+
+ /** resize image to size of other image and copy it's data
+ */
+@@ -1066,30 +1098,30 @@ BasicImage<PIXELTYPE, Alloc>::init(value
+
+ template <class PIXELTYPE, class Alloc>
+ void
+-BasicImage<PIXELTYPE, Alloc>::resize(int width, int height, value_type const & d)
++BasicImage<PIXELTYPE, Alloc>::resize(int w, int h, value_type const & d)
+ {
+- vigra_precondition((width >= 0) && (height >= 0),
+- "BasicImage::resize(int width, int height, value_type const &): "
++ vigra_precondition((w >= 0) && (h >= 0),
++ "BasicImage::resize(int w, int h, value_type const &): "
+ "width and height must be >= 0.\n");
+
+- if (width_ != width || height_ != height) // change size?
++ if (width_ != w || height_ != h) // change size?
+ {
+ value_type * newdata = 0;
+ value_type ** newlines = 0;
+- if(width*height > 0)
++ if(w*h > 0)
+ {
+- if (width*height != width_*height_) // different sizes, must reallocate
++ if (w*h != width_*height_) // different sizes, must reallocate
+ {
+- newdata = allocator_.allocate(typename Alloc::size_type(width*height));
+- std::uninitialized_fill_n(newdata, width*height, d);
+- newlines = initLineStartArray(newdata, width, height);
++ newdata = allocator_.allocate(typename Alloc::size_type(w*h));
++ std::uninitialized_fill_n(newdata, w*h, d);
++ newlines = initLineStartArray(newdata, w, h);
+ deallocate();
+ }
+ else // need only to reshape
+ {
+ newdata = data_;
+- std::fill_n(newdata, width*height, d);
+- newlines = initLineStartArray(newdata, width, height);
++ std::fill_n(newdata, w*h, d);
++ newlines = initLineStartArray(newdata, w, h);
+ pallocator_.deallocate(lines_, typename Alloc::size_type(height_));
+ }
+ }
+@@ -1100,22 +1132,22 @@ BasicImage<PIXELTYPE, Alloc>::resize(int
+
+ data_ = newdata;
+ lines_ = newlines;
+- width_ = width;
+- height_ = height;
++ width_ = w;
++ height_ = h;
+ }
+- else if(width*height > 0) // keep size, re-init data
++ else if(w*h > 0) // keep size, re-init data
+ {
+- std::fill_n(data_, width*height, d);
++ std::fill_n(data_, w*h, d);
+ }
+ }
+
+
+ template <class PIXELTYPE, class Alloc>
+ void
+-BasicImage<PIXELTYPE, Alloc>::resizeCopy(int width, int height, const_pointer data)
++BasicImage<PIXELTYPE, Alloc>::resizeCopy(int w, int h, const_pointer src_data)
+ {
+- int newsize = width*height;
+- if (width_ != width || height_ != height) // change size?
++ int newsize = w*h;
++ if (width_ != w || height_ != h) // change size?
+ {
+ value_type * newdata = 0;
+ value_type ** newlines = 0;
+@@ -1124,8 +1156,8 @@ BasicImage<PIXELTYPE, Alloc>::resizeCopy
+ if (newsize != width_*height_) // different sizes, must reallocate
+ {
+ newdata = allocator_.allocate(typename Alloc::size_type(newsize));
+- std::uninitialized_copy(data, data + newsize, newdata);
+- newlines = initLineStartArray(newdata, width, height);
++ std::uninitialized_copy(src_data, src_data + newsize, newdata);
++ newlines = initLineStartArray(newdata, w, h);
+ deallocate();
+ }
+ else // need only to reshape
+@@ -1143,12 +1175,12 @@ BasicImage<PIXELTYPE, Alloc>::resizeCopy
+
+ data_ = newdata;
+ lines_ = newlines;
+- width_ = width;
+- height_ = height;
++ width_ = w;
++ height_ = h;
+ }
+ else if(newsize > 0) // keep size, copy data
+ {
+- std::copy(data, data + newsize, data_);
++ std::copy(src_data, src_data + newsize, data_);
+ }
+ }
+
+@@ -1183,11 +1215,11 @@ BasicImage<PIXELTYPE, Alloc>::deallocate
+
+ template <class PIXELTYPE, class Alloc>
+ PIXELTYPE **
+-BasicImage<PIXELTYPE, Alloc>::initLineStartArray(value_type * data, int width, int height)
++BasicImage<PIXELTYPE, Alloc>::initLineStartArray(value_type * src_data, int w, int h)
+ {
+- value_type ** lines = pallocator_.allocate(typename Alloc::size_type(height));
+- for(int y=0; y<height; ++y)
+- lines[y] = data + y*width;
++ value_type ** lines = pallocator_.allocate(typename Alloc::size_type(h));
++ for(int y=0; y<h; ++y)
++ lines[y] = src_data + y*w;
+ return lines;
+ }
+
+diff -uprN misc/vigra1.6.0/include/vigra/basicimageview.hxx misc/build/vigra1.6.0/include/vigra/basicimageview.hxx
+--- misc/vigra1.6.0/include/vigra/basicimageview.hxx 2008-08-13 08:15:34.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/basicimageview.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -176,20 +176,20 @@ class BasicImageView
+
+ /** construct view of size w x h
+ */
+- BasicImageView(const_pointer data, int w, int h, int stride = 0)
+- : data_(const_cast<pointer>(data)),
++ BasicImageView(const_pointer src_data, int w, int h, int data_stride = 0)
++ : data_(const_cast<pointer>(src_data)),
+ width_(w),
+ height_(h),
+- stride_(stride == 0 ? w : stride)
++ stride_(data_stride == 0 ? w : data_stride)
+ {}
+
+ /** construct view of size size.x x size.y
+ */
+- BasicImageView(const_pointer data, difference_type const & size, int stride = 0)
+- : data_(const_cast<pointer>(data)),
+- width_(size.x),
+- height_(size.y),
+- stride_(stride == 0 ? size.x : stride)
++ BasicImageView(const_pointer src_data, difference_type const & sz, int data_stride = 0)
++ : data_(const_cast<pointer>(src_data)),
++ width_(sz.x),
++ height_(sz.y),
++ stride_(data_stride == 0 ? sz.x : data_stride)
+ {}
+
+ /** set Image with const value
+diff -uprN misc/vigra1.6.0/include/vigra/boundarytensor.hxx misc/build/vigra1.6.0/include/vigra/boundarytensor.hxx
+--- misc/vigra1.6.0/include/vigra/boundarytensor.hxx 2008-08-13 08:15:34.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/boundarytensor.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -71,8 +71,8 @@ initGaussianPolarFilters1(double std_dev
+ int radius = (int)(4.0*std_dev + 0.5);
+ std_dev *= 1.08179074376;
+ double f = 1.0 / VIGRA_CSTD::sqrt(2.0 * M_PI) / std_dev; // norm
+- double a = 0.558868151788 / VIGRA_CSTD::pow(std_dev, 5);
+- double b = -2.04251639729 / VIGRA_CSTD::pow(std_dev, 3);
++ double a = 0.558868151788 / VIGRA_CSTD::pow(std_dev, 5.0);
++ double b = -2.04251639729 / VIGRA_CSTD::pow(std_dev, 3.0);
+ double sigma22 = -0.5 / std_dev / std_dev;
+
+
+@@ -175,7 +175,7 @@ initGaussianPolarFilters3(double std_dev
+ std_dev *= 1.15470053838;
+ double sigma22 = -0.5 / std_dev / std_dev;
+ double f = 1.0 / VIGRA_CSTD::sqrt(2.0 * M_PI) / std_dev; // norm
+- double a = 0.883887052922 / VIGRA_CSTD::pow(std_dev, 5);
++ double a = 0.883887052922 / VIGRA_CSTD::pow(std_dev, 5.0);
+
+ for(unsigned int i=0; i<k.size(); ++i)
+ {
+diff -uprN misc/vigra1.6.0/include/vigra/config.hxx misc/build/vigra1.6.0/include/vigra/config.hxx
+--- misc/vigra1.6.0/include/vigra/config.hxx 2008-08-13 08:15:35.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/config.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -84,6 +84,12 @@
+ #endif // VIGRA_NO_STD_MINMAX
+ #endif // (_MSC_VER < 1300)
+
++ #if _MSC_VER <= 1310
++ #ifndef CMATH_NOT_IN_STD
++ #define CMATH_NOT_IN_STD
++ #endif
++ #endif // _MSC_VER < 1310
++
+ #if _MSC_VER < 1310
+ #define NO_PARTIAL_TEMPLATE_SPECIALIZATION
+ #define NO_OUT_OF_LINE_MEMBER_TEMPLATES
+diff -uprN misc/vigra1.6.0/include/vigra/diff2d.hxx misc/build/vigra1.6.0/include/vigra/diff2d.hxx
+--- misc/vigra1.6.0/include/vigra/diff2d.hxx 2008-08-13 08:15:35.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/diff2d.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -490,8 +490,8 @@ public:
+
+ /** Construct point at given position.
+ */
+- Size2D(int width, int height)
+- : Diff2D(width, height)
++ Size2D(int w, int h)
++ : Diff2D(w, h)
+ {}
+
+ /** Copy Constructor.
+@@ -620,8 +620,8 @@ public:
+
+ /** Construct point at given position.
+ */
+- Point2D(int x, int y)
+- : Diff2D(x, y)
++ Point2D(int x_, int y_)
++ : Diff2D(x_, y_)
+ {}
+
+ /** Copy Constructor.
+@@ -884,26 +884,26 @@ public:
+ * (lowerRight is considered to be outside the rectangle as
+ * usual in the VIGRA)
+ */
+- Rect2D(Point2D const &upperLeft, Point2D const &lowerRight)
+- : upperLeft_(upperLeft), lowerRight_(lowerRight)
++ Rect2D(Point2D const &ul, Point2D const &lr)
++ : upperLeft_(ul), lowerRight_(lr)
+ {}
+
+ /** Construct a rectangle representing the given range
+ */
+- Rect2D(int left, int top, int right, int bottom)
+- : upperLeft_(left, top), lowerRight_(right, bottom)
++ Rect2D(int l, int t, int r, int b)
++ : upperLeft_(l,t), lowerRight_(r,b)
+ {}
+
+ /** Construct a rectangle of given position and size
+ */
+- Rect2D(Point2D const &upperLeft, Size2D const &size)
+- : upperLeft_(upperLeft), lowerRight_(upperLeft + size)
++ Rect2D(Point2D const &ul, Size2D const &sz)
++ : upperLeft_(ul), lowerRight_(ul + sz)
+ {}
+
+ /** Construct a rectangle of given size at position (0,0)
+ */
+- explicit Rect2D(Size2D const &size)
+- : lowerRight_(Point2D(size))
++ explicit Rect2D(Size2D const &sz)
++ : lowerRight_(Point2D(sz))
+ {}
+
+ /** Return the first point (scan-order wise) which is
+@@ -950,9 +950,9 @@ public:
+ /** Move the whole rectangle so that upperLeft() will become
+ * Point2D(left, top) afterwards.
+ */
+- void moveTo(int left, int top)
++ void moveTo(int l, int t)
+ {
+- moveTo(Point2D(left, top));
++ moveTo(Point2D(l, t));
+ }
+
+ /** Move the whole rectangle by the given 2D offset.
+@@ -1037,17 +1037,17 @@ public:
+ /** Resize this rectangle to the given extents. This will move
+ * the lower right corner only.
+ */
+- void setSize(Size2D const &size)
++ void setSize(Size2D const &sz)
+ {
+- lowerRight_ = upperLeft_ + size;
++ lowerRight_ = upperLeft_ + sz;
+ }
+
+ /** Resize this rectangle to the given extents. This will move
+ * the lower right corner only.
+ */
+- void setSize(int width, int height)
++ void setSize(int w, int h)
+ {
+- lowerRight_ = upperLeft_ + Size2D(width, height);
++ lowerRight_ = upperLeft_ + Size2D(w, h);
+ }
+
+ /** Increase the size of the rectangle by the given offset. This
+@@ -1131,7 +1131,7 @@ public:
+ bool contains(Rect2D const &r) const
+ {
+ return r.isEmpty() ||
+- contains(r.upperLeft()) && contains(r.lowerRight()-Diff2D(1,1));
++ (contains(r.upperLeft()) && contains(r.lowerRight()-Diff2D(1,1)));
+ }
+
+ /** Return whether this rectangle overlaps with the given
+diff -uprN misc/vigra1.6.0/include/vigra/fftw.hxx misc/build/vigra1.6.0/include/vigra/fftw.hxx
+--- misc/vigra1.6.0/include/vigra/fftw.hxx 2008-08-13 08:15:36.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/fftw.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -399,8 +399,6 @@ inline FFTWComplex operator /(FFTWComple
+ return a;
+ }
+
+-using VIGRA_CSTD::abs;
+-
+ inline FFTWComplex::value_type abs(const FFTWComplex &a)
+ {
+ return a.magnitude();
+diff -uprN misc/vigra1.6.0/include/vigra/fftw3.hxx misc/build/vigra1.6.0/include/vigra/fftw3.hxx
+--- misc/vigra1.6.0/include/vigra/fftw3.hxx 2008-08-13 08:15:36.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/fftw3.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -572,8 +572,6 @@ inline FFTWComplex operator /(FFTWComple
+ return a;
+ }
+
+-using VIGRA_CSTD::abs;
+-
+ /// absolute value (= magnitude)
+ inline FFTWComplex::value_type abs(const FFTWComplex &a)
+ {
+diff -uprN misc/vigra1.6.0/include/vigra/fixedpoint.hxx misc/build/vigra1.6.0/include/vigra/fixedpoint.hxx
+--- misc/vigra1.6.0/include/vigra/fixedpoint.hxx 2008-08-13 08:15:36.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/fixedpoint.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -118,20 +118,18 @@ enum FixedPointNoShift { FPNoShift };
+
+ namespace detail {
+
+-template <bool MustRound>
++template <bool MustRound, int N>
+ struct FPAssignWithRound;
+
+-template <>
+-struct FPAssignWithRound<false>
++template <int N>
++struct FPAssignWithRound<false, N>
+ {
+- template <int N>
+ static inline int exec(int v) { return v << (-N); }
+ };
+
+-template <>
+-struct FPAssignWithRound<true>
++template <int N>
++struct FPAssignWithRound<true, N>
+ {
+- template <int N>
+ static inline int exec(int const v)
+ {
+ return (v + (1 << (N - 1))) >> (N);
+@@ -276,7 +274,7 @@ public:
+ */
+ template <unsigned Int2, unsigned Frac2>
+ FixedPoint(const FixedPoint<Int2, Frac2> &other)
+- : value(detail::FPAssignWithRound<(Frac2 > FractionalBits)>::template exec<Frac2 - FractionalBits>(other.value))
++ : value(detail::FPAssignWithRound<(Frac2 > FractionalBits), Frac2 - FractionalBits>::exec(other.value))
+ {
+ VIGRA_STATIC_ASSERT((FixedPoint_overflow_error__More_than_31_bits_requested<(IntBits + FractionalBits)>));
+ VIGRA_STATIC_ASSERT((FixedPoint_assignment_error__Target_object_has_too_few_integer_bits<(IntBits >= Int2)>));
+@@ -321,7 +319,7 @@ public:
+ FixedPoint & operator=(const FixedPoint<Int2, Frac2> &other)
+ {
+ VIGRA_STATIC_ASSERT((FixedPoint_assignment_error__Target_object_has_too_few_integer_bits<(IntBits >= Int2)>));
+- value = detail::FPAssignWithRound<(Frac2 > FractionalBits)>::template exec<Frac2 - FractionalBits>(other.value);
++ value = detail::FPAssignWithRound<(Frac2 > FractionalBits),Frac2 - FractionalBits>::exec(other.value);
+ return *this;
+ }
+
+@@ -373,7 +371,7 @@ public:
+ FixedPoint & operator+=(const FixedPoint<Int2, Frac2> &other)
+ {
+ VIGRA_STATIC_ASSERT((FixedPoint_assignment_error__Target_object_has_too_few_integer_bits<(IntBits >= Int2)>));
+- value += detail::FPAssignWithRound<(Frac2 > FractionalBits)>::template exec<Frac2 - FractionalBits>(other.value);
++ value += detail::FPAssignWithRound<(Frac2 > FractionalBits),Frac2 - FractionalBits>::exec(other.value);
+ return *this;
+ }
+
+@@ -384,7 +382,7 @@ public:
+ FixedPoint & operator-=(const FixedPoint<Int2, Frac2> &other)
+ {
+ VIGRA_STATIC_ASSERT((FixedPoint_assignment_error__Target_object_has_too_few_integer_bits<(IntBits >= Int2)>));
+- value -= detail::FPAssignWithRound<(Frac2 > FractionalBits)>::template exec<Frac2 - FractionalBits>(other.value);
++ value -= detail::FPAssignWithRound<(Frac2 > FractionalBits),Frac2 - FractionalBits>::exec(other.value);
+ return *this;
+ }
+
+diff -uprN misc/vigra1.6.0/include/vigra/gaborfilter.hxx misc/build/vigra1.6.0/include/vigra/gaborfilter.hxx
+--- misc/vigra1.6.0/include/vigra/gaborfilter.hxx 2008-08-13 08:15:36.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/gaborfilter.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -287,7 +287,11 @@ inline double angularGaborSigma(int dire
+ Namespace: vigra
+ */
+ template <class ImageType,
++#ifndef VIGRA_WITHOUT_NESTED_TEMPLATE_PARAMS
+ class Alloc = typename ImageType::allocator_type::template rebind<ImageType>::other >
++#else
++ class Alloc = std::allocator<ImageType> >
++#endif
+ class GaborFilterFamily
+ : public ImageArray<ImageType, Alloc>
+ {
+diff -uprN misc/vigra1.6.0/include/vigra/gaussians.hxx misc/build/vigra1.6.0/include/vigra/gaussians.hxx
+--- misc/vigra1.6.0/include/vigra/gaussians.hxx 2008-08-13 08:15:36.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/gaussians.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -88,26 +88,26 @@ class Gaussian
+ sigma > 0.0
+ \endcode
+ */
+- explicit Gaussian(T sigma = 1.0, unsigned int derivativeOrder = 0)
+- : sigma_(sigma),
+- sigma2_(-0.5 / sigma / sigma),
++ explicit Gaussian(T s = 1.0, unsigned int derivOrder = 0)
++ : sigma_(s),
++ sigma2_(-0.5 / s / s),
+ norm_(0.0),
+- order_(derivativeOrder),
+- hermitePolynomial_(derivativeOrder / 2 + 1)
++ order_(derivOrder),
++ hermitePolynomial_(derivOrder / 2 + 1)
+ {
+- vigra_precondition(sigma_ > 0.0,
++ vigra_precondition(s > 0.0,
+ "Gaussian::Gaussian(): sigma > 0 required.");
+ switch(order_)
+ {
+ case 1:
+ case 2:
+- norm_ = -1.0 / (VIGRA_CSTD::sqrt(2.0 * M_PI) * sq(sigma) * sigma);
++ norm_ = -1.0 / (VIGRA_CSTD::sqrt(2.0 * M_PI) * sq(s) * s);
+ break;
+ case 3:
+- norm_ = 1.0 / (VIGRA_CSTD::sqrt(2.0 * M_PI) * sq(sigma) * sq(sigma) * sigma);
++ norm_ = 1.0 / (VIGRA_CSTD::sqrt(2.0 * M_PI) * sq(s) * sq(s) * s);
+ break;
+ default:
+- norm_ = 1.0 / VIGRA_CSTD::sqrt(2.0 * M_PI) / sigma;
++ norm_ = 1.0 / VIGRA_CSTD::sqrt(2.0 * M_PI) / s;
+ }
+ calculateHermitePolynomial();
+ }
+diff -uprN misc/vigra1.6.0/include/vigra/numerictraits.hxx misc/build/vigra1.6.0/include/vigra/numerictraits.hxx
+--- misc/vigra1.6.0/include/vigra/numerictraits.hxx 2008-08-13 08:15:39.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/numerictraits.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -863,6 +863,90 @@ struct NumericTraits<long>
+ }
+ };
+
++#ifdef VIGRA_HAS_LONG_LONG
++template<>
++struct NumericTraits<long long>
++{
++ typedef long long Type;
++ typedef long long Promote;
++ typedef double RealPromote;
++ typedef std::complex<RealPromote> ComplexPromote;
++ typedef Type ValueType;
++
++ typedef VigraTrueType isIntegral;
++ typedef VigraTrueType isScalar;
++ typedef VigraTrueType isSigned;
++ typedef VigraTrueType isOrdered;
++ typedef VigraFalseType isComplex;
++
++ static long long zero() { return 0; }
++ static long long one() { return 1; }
++ static long long nonZero() { return 1; }
++ static long long min() { return LLONG_MIN; }
++ static long long max() { return LLONG_MAX; }
++
++#ifdef NO_INLINE_STATIC_CONST_DEFINITION
++ enum { minConst = LONG_MIN, maxConst = LLONG_MAX };
++#else
++ static const long long minConst = LLONG_MIN;
++ static const long long maxConst = LLONG_MAX;
++#endif
++
++ static Promote toPromote(long long v) { return v; }
++ static RealPromote toRealPromote(long long v) { return v; }
++ static long long fromPromote(Promote v) { return v; }
++ static long long fromRealPromote(RealPromote v) {
++ return ((v < 0.0)
++ ? ((v < (RealPromote)LLONG_MIN)
++ ? LLONG_MIN
++ : static_cast<long long>(v - 0.5))
++ : ((v > (RealPromote)LLONG_MAX)
++ ? LLONG_MAX
++ : static_cast<long long>(v + 0.5)));
++ }
++};
++
++template<>
++struct NumericTraits<unsigned long long>
++{
++ typedef unsigned long long Type;
++ typedef unsigned long long Promote;
++ typedef double RealPromote;
++ typedef std::complex<RealPromote> ComplexPromote;
++ typedef Type ValueType;
++
++ typedef VigraTrueType isIntegral;
++ typedef VigraTrueType isScalar;
++ typedef VigraFalseType isSigned;
++ typedef VigraTrueType isOrdered;
++ typedef VigraFalseType isComplex;
++
++ static unsigned long long zero() { return 0; }
++ static unsigned long long one() { return 1; }
++ static unsigned long long nonZero() { return 1; }
++ static unsigned long long min() { return 0; }
++ static unsigned long long max() { return ULLONG_MAX; }
++
++#ifdef NO_INLINE_STATIC_CONST_DEFINITION
++ enum { minConst = 0, maxConst = ULLONG_MAX };
++#else
++ static const unsigned long long minConst = 0;
++ static const unsigned long long maxConst = ULLONG_MAX;
++#endif
++
++ static Promote toPromote(unsigned long long v) { return v; }
++ static RealPromote toRealPromote(unsigned long long v) { return v; }
++ static unsigned long long fromPromote(Promote v) { return v; }
++ static unsigned long long fromRealPromote(RealPromote v) {
++ return ((v < 0.0)
++ ? 0
++ : ((v > (RealPromote)ULLONG_MAX)
++ ? ULLONG_MAX
++ : static_cast<unsigned long long>(v + 0.5)));
++ }
++};
++#endif
++
+ template<>
+ struct NumericTraits<unsigned long>
+ {
+@@ -1050,6 +1134,7 @@ struct NumericTraits<double>
+ static double fromRealPromote(RealPromote v) { return v; }
+ };
+
++#ifdef VIGRA_HAS_LONG_DOUBLE
+ template<>
+ struct NumericTraits<long double>
+ {
+@@ -1079,6 +1164,7 @@ struct NumericTraits<long double>
+ static long double fromPromote(Promote v) { return v; }
+ static long double fromRealPromote(RealPromote v) { return v; }
+ };
++#endif
+
+ #ifndef NO_PARTIAL_TEMPLATE_SPECIALIZATION
+
+@@ -1158,9 +1244,15 @@ VIGRA_DEFINE_NORM_TRAITS(int)
+ VIGRA_DEFINE_NORM_TRAITS(unsigned int)
+ VIGRA_DEFINE_NORM_TRAITS(long)
+ VIGRA_DEFINE_NORM_TRAITS(unsigned long)
++#ifdef VIGRA_HAS_LONG_LONG
++VIGRA_DEFINE_NORM_TRAITS(long long)
++VIGRA_DEFINE_NORM_TRAITS(unsigned long long)
++#endif
+ VIGRA_DEFINE_NORM_TRAITS(float)
+ VIGRA_DEFINE_NORM_TRAITS(double)
++#ifdef VIGRA_HAS_LONG_DOUBLE
+ VIGRA_DEFINE_NORM_TRAITS(long double)
++#endif
+
+ #ifdef LLONG_MAX
+ VIGRA_DEFINE_NORM_TRAITS(long long)
+diff -uprN misc/vigra1.6.0/include/vigra/orientedtensorfilters.hxx misc/build/vigra1.6.0/include/vigra/orientedtensorfilters.hxx
+--- misc/vigra1.6.0/include/vigra/orientedtensorfilters.hxx 2008-08-13 08:15:40.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/orientedtensorfilters.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -435,7 +435,7 @@ class Sin6RingKernel
+ if(x == 0 && y == 0)
+ return weights_(radius_, radius_);
+ double d = dot(vectors_(x+radius_, y+radius_), v);
+- return VIGRA_CSTD::pow(1.0 - d * d, 3) * weights_(x+radius_, y+radius_);
++ return VIGRA_CSTD::pow(1.0 - d * d, 3.0) * weights_(x+radius_, y+radius_);
+ }
+ };
+
+@@ -456,7 +456,7 @@ class Sin6Kernel
+ if(x == 0 && y == 0)
+ return weights_(radius_, radius_);
+ double d = dot(vectors_(x+radius_, y+radius_), v);
+- return VIGRA_CSTD::pow(1.0 - d * d, 3) * weights_(x+radius_, y+radius_);
++ return VIGRA_CSTD::pow(1.0 - d * d, 3.0) * weights_(x+radius_, y+radius_);
+ }
+ };
+
+@@ -477,7 +477,7 @@ class Cos6RingKernel
+ if(x == 0 && y == 0)
+ return weights_(radius_, radius_);
+ double d = dot(vectors_(x+radius_, y+radius_), v);
+- return (1.0 - VIGRA_CSTD::pow(1.0 - d * d, 3)) * weights_(x+radius_, y+radius_);
++ return (1.0 - VIGRA_CSTD::pow(1.0 - d * d, 3.0)) * weights_(x+radius_, y+radius_);
+ }
+ };
+
+@@ -498,7 +498,7 @@ class Cos6Kernel
+ if(x == 0 && y == 0)
+ return weights_(radius_, radius_);
+ double d = dot(vectors_(x+radius_, y+radius_), v);
+- return (1.0 - VIGRA_CSTD::pow(1.0 - d * d, 3)) * weights_(x+radius_, y+radius_);
++ return (1.0 - VIGRA_CSTD::pow(1.0 - d * d, 3.0)) * weights_(x+radius_, y+radius_);
+ }
+ };
+
+diff -uprN misc/vigra1.6.0/include/vigra/polynomial.hxx misc/build/vigra1.6.0/include/vigra/polynomial.hxx
+--- misc/vigra1.6.0/include/vigra/polynomial.hxx 2008-08-13 08:15:40.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/polynomial.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -119,10 +119,10 @@ class PolynomialView
+ of subsequent algorithms (especially root finding) performed on the
+ polynomial.
+ */
+- PolynomialView(T * coeffs, unsigned int order, double epsilon = 1.0e-14)
++ PolynomialView(T * coeffs, unsigned int ord, double eps = 1.0e-14)
+ : coeffs_(coeffs),
+- order_(order),
+- epsilon_(epsilon)
++ order_(ord),
++ epsilon_(eps)
+ {}
+
+ /// Access the coefficient of x^i
+@@ -245,16 +245,16 @@ class PolynomialView
+ { epsilon_ = eps; }
+
+ protected:
+- PolynomialView(double epsilon = 1e-14)
++ PolynomialView(double eps = 1e-14)
+ : coeffs_(0),
+ order_(0),
+- epsilon_(epsilon)
++ epsilon_(eps)
+ {}
+
+- void setCoeffs(T * coeffs, unsigned int order)
++ void setCoeffs(T * coeffs, unsigned int ord)
+ {
+ coeffs_ = coeffs;
+- order_ = order;
++ order_ = ord;
+ }
+
+ T * coeffs_;
+@@ -397,9 +397,9 @@ PolynomialView<T>::deflateConjugatePair(
+
+ template <class T>
+ void
+-PolynomialView<T>::minimizeOrder(double epsilon)
++PolynomialView<T>::minimizeOrder(double eps)
+ {
+- while(std::abs(coeffs_[order_]) <= epsilon && order_ > 0)
++ while(std::abs(coeffs_[order_]) <= eps && order_ > 0)
+ --order_;
+ }
+
+diff -uprN misc/vigra1.6.0/include/vigra/recursiveconvolution.hxx misc/build/vigra1.6.0/include/vigra/recursiveconvolution.hxx
+--- misc/vigra1.6.0/include/vigra/recursiveconvolution.hxx 2008-08-13 08:15:40.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/recursiveconvolution.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -261,16 +261,16 @@ void recursiveFilterLine(SrcIterator is,
+ {
+ // correction factors for b
+ double bright = b;
+- double bleft = VIGRA_CSTD::pow(b, w);
++ double bleft = VIGRA_CSTD::pow(b, (double)w);
+
+ for(x=w-1; x>=0; --x, --is, --id)
+ {
+ TempType f = b * old;
+ old = as(is) + f;
+- double norm = (1.0 - b) / (1.0 + b - bleft - bright);
++ double norm2 = (1.0 - b) / (1.0 + b - bleft - bright);
+ bleft /= b;
+ bright *= b;
+- ad.set(norm * (line[x] + f), id);
++ ad.set(norm2 * (line[x] + f), id);
+ }
+ }
+ else if(border == BORDER_TREATMENT_AVOID)
+diff -uprN misc/vigra1.6.0/include/vigra/rgbvalue.hxx misc/build/vigra1.6.0/include/vigra/rgbvalue.hxx
+--- misc/vigra1.6.0/include/vigra/rgbvalue.hxx 2008-08-13 08:15:41.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/rgbvalue.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -39,6 +39,10 @@
+ #ifndef VIGRA_RGBVALUE_HXX
+ #define VIGRA_RGBVALUE_HXX
+
++#if defined __GNUC__
++#pragma GCC system_header
++#endif
++
+ #include <cmath> // abs(double)
+ #include <cstdlib> // abs(int)
+ #include "config.hxx"
+@@ -702,8 +706,6 @@ operator/=(RGBValue<V, RIDX, GIDX, BIDX>
+ return l;
+ }
+
+-using VIGRA_CSTD::abs;
+-
+ /// component-wise absolute value
+ template <class T, unsigned int RIDX, unsigned int GIDX, unsigned int BIDX>
+ inline
+diff -uprN misc/vigra1.6.0/include/vigra/separableconvolution.hxx misc/build/vigra1.6.0/include/vigra/separableconvolution.hxx
+--- misc/vigra1.6.0/include/vigra/separableconvolution.hxx 2008-08-13 08:15:41.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/separableconvolution.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -1022,11 +1022,11 @@ class Kernel1D
+ */
+ InitProxy operator=(value_type const & v)
+ {
+- int size = right_ - left_ + 1;
++ int sz = right_ - left_ + 1;
+ for(unsigned int i=0; i<kernel_.size(); ++i) kernel_[i] = v;
+- norm_ = (double)size*v;
++ norm_ = (double)sz*v;
+
+- return InitProxy(kernel_.begin(), size, norm_);
++ return InitProxy(kernel_.begin(), sz, norm_);
+ }
+
+ /** Destructor.
+@@ -1663,8 +1663,8 @@ class Kernel1D
+ };
+
+ template <class ARITHTYPE>
+-void Kernel1D<ARITHTYPE>::normalize(value_type norm,
+- unsigned int derivativeOrder,
++void Kernel1D<ARITHTYPE>::normalize(value_type normFactor,
++ unsigned int derivOrder,
+ double offset)
+ {
+ typedef typename NumericTraits<value_type>::RealPromote TmpType;
+@@ -1673,7 +1673,7 @@ void Kernel1D<ARITHTYPE>::normalize(valu
+ Iterator k = kernel_.begin();
+ TmpType sum = NumericTraits<TmpType>::zero();
+
+- if(derivativeOrder == 0)
++ if(derivOrder == 0)
+ {
+ for(; k < kernel_.end(); ++k)
+ {
+@@ -1683,11 +1683,11 @@ void Kernel1D<ARITHTYPE>::normalize(valu
+ else
+ {
+ unsigned int faculty = 1;
+- for(unsigned int i = 2; i <= derivativeOrder; ++i)
++ for(unsigned int i = 2; i <= derivOrder; ++i)
+ faculty *= i;
+ for(double x = left() + offset; k < kernel_.end(); ++x, ++k)
+ {
+- sum += *k * VIGRA_CSTD::pow(-x, int(derivativeOrder)) / faculty;
++ sum += *k * VIGRA_CSTD::pow(-x, (double)derivOrder) / faculty;
+ }
+ }
+
+@@ -1695,21 +1695,21 @@ void Kernel1D<ARITHTYPE>::normalize(valu
+ "Kernel1D<ARITHTYPE>::normalize(): "
+ "Cannot normalize a kernel with sum = 0");
+ // normalize
+- sum = norm / sum;
++ sum = normFactor / sum;
+ k = kernel_.begin();
+ for(; k != kernel_.end(); ++k)
+ {
+ *k = *k * sum;
+ }
+
+- norm_ = norm;
++ norm_ = normFactor;
+ }
+
+ /***********************************************************************/
+
+ template <class ARITHTYPE>
+ void Kernel1D<ARITHTYPE>::initGaussian(double std_dev,
+- value_type norm)
++ value_type normFactor)
+ {
+ vigra_precondition(std_dev >= 0.0,
+ "Kernel1D::initGaussian(): Standard deviation must be >= 0.");
+@@ -1742,8 +1742,8 @@ void Kernel1D<ARITHTYPE>::initGaussian(d
+ right_ = 0;
+ }
+
+- if(norm != 0.0)
+- normalize(norm);
++ if(normFactor != 0.0)
++ normalize(normFactor);
+ else
+ norm_ = 1.0;
+
+@@ -1755,7 +1755,7 @@ void Kernel1D<ARITHTYPE>::initGaussian(d
+
+ template <class ARITHTYPE>
+ void Kernel1D<ARITHTYPE>::initDiscreteGaussian(double std_dev,
+- value_type norm)
++ value_type normFactor)
+ {
+ vigra_precondition(std_dev >= 0.0,
+ "Kernel1D::initDiscreteGaussian(): Standard deviation must be >= 0.");
+@@ -1797,7 +1797,7 @@ void Kernel1D<ARITHTYPE>::initDiscreteGa
+ er += warray[i];
+ }
+
+- double scale = norm / (2*er - warray[0]);
++ double scale = normFactor / (2*er - warray[0]);
+
+ initExplicitly(-radius, radius);
+ iterator c = center();
+@@ -1810,12 +1810,12 @@ void Kernel1D<ARITHTYPE>::initDiscreteGa
+ else
+ {
+ kernel_.erase(kernel_.begin(), kernel_.end());
+- kernel_.push_back(norm);
++ kernel_.push_back(normFactor);
+ left_ = 0;
+ right_ = 0;
+ }
+
+- norm_ = norm;
++ norm_ = normFactor;
+
+ // best border treatment for Gaussians is BORDER_TREATMENT_REFLECT
+ border_treatment_ = BORDER_TREATMENT_REFLECT;
+@@ -1826,15 +1826,15 @@ void Kernel1D<ARITHTYPE>::initDiscreteGa
+ template <class ARITHTYPE>
+ void
+ Kernel1D<ARITHTYPE>::initGaussianDerivative(double std_dev,
+- int order,
+- value_type norm)
++ int order,
++ value_type normFactor)
+ {
+ vigra_precondition(order >= 0,
+ "Kernel1D::initGaussianDerivative(): Order must be >= 0.");
+
+ if(order == 0)
+ {
+- initGaussian(std_dev, norm);
++ initGaussian(std_dev, normFactor);
+ return;
+ }
+
+@@ -1865,7 +1865,7 @@ Kernel1D<ARITHTYPE>::initGaussianDerivat
+
+ // remove DC, but only if kernel correction is permitted by a non-zero
+ // value for norm
+- if(norm != 0.0)
++ if(normFactor != 0.0)
+ {
+ for(unsigned int i=0; i < kernel_.size(); ++i)
+ {
+@@ -1876,8 +1876,8 @@ Kernel1D<ARITHTYPE>::initGaussianDerivat
+ left_ = -radius;
+ right_ = radius;
+
+- if(norm != 0.0)
+- normalize(norm, order);
++ if(normFactor != 0.0)
++ normalize(normFactor, order);
+ else
+ norm_ = 1.0;
+
+@@ -1891,7 +1891,7 @@ Kernel1D<ARITHTYPE>::initGaussianDerivat
+ template <class ARITHTYPE>
+ void
+ Kernel1D<ARITHTYPE>::initBinomial(int radius,
+- value_type norm)
++ value_type normFactor)
+ {
+ vigra_precondition(radius > 0,
+ "Kernel1D::initBinomial(): Radius must be > 0.");
+@@ -1921,12 +1921,12 @@ Kernel1D<ARITHTYPE>::initBinomial(int ra
+
+ for(i=0; i<=radius*2+1; ++i)
+ {
+- kernel_.push_back(kernel[i] * norm);
++ kernel_.push_back(kernel[i] * normFactor);
+ }
+
+ left_ = -radius;
+ right_ = radius;
+- norm_ = norm;
++ norm_ = normFactor;
+
+ // best border treatment for Binomial is BORDER_TREATMENT_REFLECT
+ border_treatment_ = BORDER_TREATMENT_REFLECT;
+@@ -1936,7 +1936,7 @@ Kernel1D<ARITHTYPE>::initBinomial(int ra
+
+ template <class ARITHTYPE>
+ void Kernel1D<ARITHTYPE>::initAveraging(int radius,
+- value_type norm)
++ value_type normFactor)
+ {
+ vigra_precondition(radius > 0,
+ "Kernel1D::initAveraging(): Radius must be > 0.");
+@@ -1950,12 +1950,12 @@ void Kernel1D<ARITHTYPE>::initAveraging(
+
+ for(int i=0; i<=radius*2+1; ++i)
+ {
+- kernel_.push_back(scale * norm);
++ kernel_.push_back(scale * normFactor);
+ }
+
+ left_ = -radius;
+ right_ = radius;
+- norm_ = norm;
++ norm_ = normFactor;
+
+ // best border treatment for Averaging is BORDER_TREATMENT_CLIP
+ border_treatment_ = BORDER_TREATMENT_CLIP;
+diff -uprN misc/vigra1.6.0/include/vigra/sized_int.hxx misc/build/vigra1.6.0/include/vigra/sized_int.hxx
+--- misc/vigra1.6.0/include/vigra/sized_int.hxx 2008-08-13 08:15:41.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/sized_int.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -73,11 +73,15 @@ struct SelectIntegerType<SIZE, Int_type_
+ typedef Int_type_not_supported_on_this_platform type;
+ };
+
++#if defined __SUNPRO_CC
++#pragma disable_warn
++#endif
++
+ template<class LIST>
+ struct SelectBiggestIntegerType
+ {
+- enum { cursize = LIST::size,
+- nextsize = SelectBiggestIntegerType<typename LIST::next>::size,
++ enum { cursize = static_cast< int >(LIST::size),
++ nextsize = static_cast< int >(SelectBiggestIntegerType<typename LIST::next>::size),
+ size = (cursize < nextsize) ? nextsize : cursize };
+ typedef typename
+ IfBool<(cursize < nextsize),
+@@ -86,6 +90,10 @@ struct SelectBiggestIntegerType
+ type;
+ };
+
++#if defined __SUNPRO_CC
++#pragma enable_warn
++#endif
++
+ template<>
+ struct SelectBiggestIntegerType<Int_type_not_supported_on_this_platform>
+ {
+diff -uprN misc/vigra1.6.0/include/vigra/splines.hxx misc/build/vigra1.6.0/include/vigra/splines.hxx
+--- misc/vigra1.6.0/include/vigra/splines.hxx 2008-08-13 08:15:41.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/splines.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -108,8 +108,8 @@ class BSplineBase
+ /** Create functor for gevine derivative of the spline. The spline's order
+ is specified spline by the template argument <TT>ORDER</tt>.
+ */
+- explicit BSplineBase(unsigned int derivativeOrder = 0)
+- : s1_(derivativeOrder)
++ explicit BSplineBase(unsigned int derivOrder = 0)
++ : s1_(derivOrder)
+ {}
+
+ /** Unary function call.
+@@ -280,8 +280,8 @@ class BSplineBase<0, T>
+ typedef T result_type;
+ enum StaticOrder { order = 0 };
+
+- explicit BSplineBase(unsigned int derivativeOrder = 0)
+- : derivativeOrder_(derivativeOrder)
++ explicit BSplineBase(unsigned int derivOrder = 0)
++ : derivativeOrder_(derivOrder)
+ {}
+
+ result_type operator()(argument_type x) const
+@@ -357,8 +357,8 @@ class BSpline<1, T>
+ typedef T result_type;
+ enum StaticOrder { order = 1 };
+
+- explicit BSpline(unsigned int derivativeOrder = 0)
+- : derivativeOrder_(derivativeOrder)
++ explicit BSpline(unsigned int derivOrder = 0)
++ : derivativeOrder_(derivOrder)
+ {}
+
+ result_type operator()(argument_type x) const
+@@ -454,8 +454,8 @@ class BSpline<2, T>
+ typedef T result_type;
+ enum StaticOrder { order = 2 };
+
+- explicit BSpline(unsigned int derivativeOrder = 0)
+- : derivativeOrder_(derivativeOrder)
++ explicit BSpline(unsigned int derivOrder = 0)
++ : derivativeOrder_(derivOrder)
+ {}
+
+ result_type operator()(argument_type x) const
+@@ -583,8 +583,8 @@ class BSpline<3, T>
+ typedef T result_type;
+ enum StaticOrder { order = 3 };
+
+- explicit BSpline(unsigned int derivativeOrder = 0)
+- : derivativeOrder_(derivativeOrder)
++ explicit BSpline(unsigned int derivOrder = 0)
++ : derivativeOrder_(derivOrder)
+ {}
+
+ result_type operator()(argument_type x) const
+@@ -735,8 +735,8 @@ class BSpline<4, T>
+ typedef T result_type;
+ enum StaticOrder { order = 4 };
+
+- explicit BSpline(unsigned int derivativeOrder = 0)
+- : derivativeOrder_(derivativeOrder)
++ explicit BSpline(unsigned int derivOrder = 0)
++ : derivativeOrder_(derivOrder)
+ {}
+
+ result_type operator()(argument_type x) const
+diff -uprN misc/vigra1.6.0/include/vigra/static_assert.hxx misc/build/vigra1.6.0/include/vigra/static_assert.hxx
+--- misc/vigra1.6.0/include/vigra/static_assert.hxx 2008-08-13 08:15:41.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/static_assert.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -115,7 +115,7 @@ assertImpl( void (*)(Predicate), typenam
+
+ TODO: provide more assertion base classes for other (non boolean) types of tests
+ */
+-#if !defined(__GNUC__) || __GNUC__ > 2
++#if (!defined(__GNUC__) || __GNUC__ > 2) && (!defined(__SUNPRO_CC) || __SUNPRO_CC > 0x550)
+ #define VIGRA_STATIC_ASSERT(Predicate) \
+ enum { \
+ VIGRA_PREPROCESSOR_CONCATENATE(vigra_assertion_in_line_, __LINE__) = sizeof( \
+diff -uprN misc/vigra1.6.0/include/vigra/tinyvector.hxx misc/build/vigra1.6.0/include/vigra/tinyvector.hxx
+--- misc/vigra1.6.0/include/vigra/tinyvector.hxx 2008-08-13 08:15:42.000000000 -0500
++++ misc/build/vigra1.6.0/include/vigra/tinyvector.hxx 2012-09-19 17:30:24.000000000 -0500
+@@ -39,6 +39,10 @@
+ #ifndef VIGRA_TINYVECTOR_HXX
+ #define VIGRA_TINYVECTOR_HXX
+
++#if defined __GNUC__
++#pragma GCC system_header
++#endif
++
+ #include <cmath> // abs(double)
+ #include <cstdlib> // abs(int)
+ #include <iosfwd> // ostream
+@@ -49,7 +53,6 @@
+
+ namespace vigra {
+
+-using VIGRA_CSTD::abs;
+ using VIGRA_CSTD::ceil;
+ using VIGRA_CSTD::floor;
+
+@@ -439,9 +442,9 @@ class TinyVectorBase
+ /** Initialize from another sequence (must have length SIZE!)
+ */
+ template <class Iterator>
+- void init(Iterator i, Iterator end)
++ void init(Iterator i, Iterator iend)
+ {
+- vigra_precondition(end-i == SIZE,
++ vigra_precondition(iend-i == SIZE,
+ "TinyVector::init(): Sequence has wrong size.");
+ Loop::assignCast(data_, i);
+ }