sci-mathematics/octave/files/octave-3.8.1-imagemagick.patch

--- octave-3.8.1-orig/libinterp/dldfcn/__magick_read__.cc	2014-03-07 06:37:51.000000000 +1100
+++ octave-3.8.1/libinterp/dldfcn/__magick_read__.cc	2014-03-09 00:18:04.593088077 +1100
@@ -38,8 +38,15 @@
 #include "gripes.h"
 
 #ifdef HAVE_MAGICK
-
+#define MAGICKCORE_EXCLUDE_DEPRECATED 1
 #include <Magick++.h>
+#if !defined(QuantumRange) && defined(MaxRGB)
+#define QuantumRange MaxRGB
+#endif
+#if !defined(MAGICKCORE_QUANTUM_DEPTH) && defined(QuantumDepth)
+#define MAGICKCORE_QUANTUM_DEPTH QuantumDepth
+#endif
+
 #include <clocale>
 
 // In theory, it should be enough to check the class:
@@ -104,12 +111,18 @@
 get_depth (Magick::Image& img)
 {
   octave_idx_type depth = img.depth ();
+#if defined(MagickLibVersion) && (MagickLibVersion <= 0x686)
+#define Magick MagickCore
+#endif
   if (depth == 8
       && img.channelDepth (Magick::RedChannel)     == 1
       && img.channelDepth (Magick::CyanChannel)    == 1
       && img.channelDepth (Magick::OpacityChannel) == 1
       && img.channelDepth (Magick::GrayChannel)    == 1)
     depth = 1;
+#if defined(MagickLibVersion) && (MagickLibVersion <= 0x686)
+#undef Magick
+#endif
 
   return depth;
 }
@@ -332,7 +345,10 @@
   if (imvec[def_elem].depth () == 32)
     divisor = std::numeric_limits<uint32_t>::max ();
   else
-    divisor = MaxRGB / ((uint64_t (1) << imvec[def_elem].depth ()) - 1);
+  {
+    using namespace Magick;
+    divisor = QuantumRange / ((uint64_t (1) << imvec[def_elem].depth ()) - 1);
+  }
 
   // FIXME: this workaround should probably be fixed in GM by creating a
   //        new ImageType BilevelMatteType
@@ -464,7 +480,8 @@
                 for (octave_idx_type row = 0; row < nRows; row++)
                   {
                     img_fvec[idx] = pix->red / divisor;
-                    a_fvec[idx]   = (MaxRGB - pix->opacity) / divisor;
+                    using namespace Magick;
+                    a_fvec[idx]   = (QuantumRange - pix->opacity) / divisor;
                     pix += row_shift;
                     idx++;
                   }
@@ -541,7 +558,8 @@
                     rbuf[idx]     = pix->red     / divisor;
                     gbuf[idx]     = pix->green   / divisor;
                     bbuf[idx]     = pix->blue    / divisor;
-                    a_fvec[a_idx++] = (MaxRGB - pix->opacity) / divisor;
+                    using namespace Magick;
+                    a_fvec[a_idx++] = (QuantumRange - pix->opacity) / divisor;
                     pix += row_shift;
                     idx++;
                   }
@@ -626,7 +644,8 @@
                     mbuf[idx]     = pix->green   / divisor;
                     ybuf[idx]     = pix->blue    / divisor;
                     kbuf[idx]     = pix->opacity / divisor;
-                    a_fvec[a_idx++] = (MaxRGB - *apix) / divisor;
+                    using namespace Magick;
+                    a_fvec[a_idx++] = (QuantumRange - *apix) / divisor;
                     pix += row_shift;
                     idx++;
                   }
@@ -685,9 +704,10 @@
       // Restore locale from before GraphicsMagick initialisation
       setlocale (LC_ALL, locale.c_str ());
 
-      if (QuantumDepth < 32)
+      using namespace Magick;
+      if (MAGICKCORE_QUANTUM_DEPTH < 32)
         warning ("your version of %s limits images to %d bits per pixel",
-                 MagickPackageName, QuantumDepth);
+                 MagickPackageName, MAGICKCORE_QUANTUM_DEPTH);
 
       initialized = true;
     }
@@ -1060,8 +1080,9 @@
   // From GM documentation:
   //  Color arguments are must be scaled to fit the Quantum size according to
   //  the range of MaxRGB
+  using namespace Magick;
   const double divisor = static_cast<double>((uint64_t (1) << bitdepth) - 1)
-                         / MaxRGB;
+                         / QuantumRange;
 
   const P *img_fvec = img.fortran_vec ();
   const P *a_fvec   = alpha.fortran_vec ();
@@ -1111,8 +1132,9 @@
                 for (octave_idx_type row = 0; row < nRows; row++)
                   {
                     double grey = double (*img_fvec) / divisor;
+                    using namespace Magick;
                     Magick::Color c (grey, grey, grey,
-                                     MaxRGB - (double (*a_fvec) / divisor));
+                                     QuantumRange - (double (*a_fvec) / divisor));
                     pix[GM_idx] = c;
                     img_fvec++;
                     a_fvec++;
@@ -1178,10 +1200,11 @@
               {
                 for (octave_idx_type row = 0; row < nRows; row++)
                   {
+                    using namespace Magick;
                     Magick::Color c (double (*img_fvec)          / divisor,
                                      double (img_fvec[G_offset]) / divisor,
                                      double (img_fvec[B_offset]) / divisor,
-                                     MaxRGB - (double (*a_fvec) / divisor));
+                                     QuantumRange - (double (*a_fvec) / divisor));
                     pix[GM_idx] = c;
                     img_fvec++;
                     a_fvec++;
@@ -1257,7 +1280,8 @@
                                      double (img_fvec[Y_offset]) / divisor,
                                      double (img_fvec[K_offset]) / divisor);
                     pix[GM_idx] = c;
-                    ind[GM_idx] = MaxRGB - (double (*a_fvec) / divisor);
+                    using namespace Magick;
+                    ind[GM_idx] = QuantumRange - (double (*a_fvec) / divisor);
                     img_fvec++;
                     a_fvec++;
                     GM_idx += nCols;