/*

 Copyright (C) 2002, 2009 Andy Adler

 Copyright (C) 2008 Thomas L. Scofield

 This file is part of Octave.

 Octave is free software; you can redistribute it and/or modify it

 under the terms of the GNU General Public License as published by the

 Free Software Foundation; either version 3 of the License, or (at your

 option) any later version.

 Octave is distributed in the hope that it will be useful, but WITHOUT

 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 for more details.

 You should have received a copy of the GNU General Public License

 along with Octave; see the file COPYING.  If not, see

 <http://www.gnu.org/licenses/>.

 */

 #ifdef HAVE_CONFIG_H

 #include <config.h>

 #endif

 #include <cmath>

 #include "defun-dld.h"

 #include "error.h"

 #include "ov-struct.h"

 #ifdef HAVE_MAGICK

 #include <GraphicsMagick/Magick++.h>

 unsigned int

 scale_quantum_to_depth (const Magick::Quantum& quantum, unsigned int depth)

 {

   return (static_cast<unsigned int> (static_cast<double> (quantum)

                                      / MaxRGB * ((1 << depth) - 1)));

 }

 octave_value_list

 read_indexed_images (std::vector<Magick::Image>& imvec,

                      const Array<int>& frameidx, bool wantalpha)

 {

   octave_value_list output;

   int rows = imvec[0].baseRows ();

   int columns = imvec[0].baseColumns ();

   int nframes = frameidx.length ();

   dim_vector idim = dim_vector ();

   idim.resize (4);

   idim(0) = rows;

   idim(1) = columns;

   idim(2) = 1;

   idim(3) = nframes;

   Array<int> idx (dim_vector (4));

   Magick::ImageType type = imvec[0].type ();

   unsigned int mapsize = imvec[0].colorMapSize ();

   unsigned int i = mapsize;

   unsigned int depth = 0;

   while (i >>= 1)

     depth++;

   i = 0;

   depth--;

   while (depth >>= 1)

     i++;

   depth = 1 << i;

   switch (depth)

     {

     case 1:

     case 2:

     case 4:

     case 8:

       {

         uint8NDArray im = uint8NDArray (idim);

         idx(2) = 0;

         for (int frame = 0; frame < nframes; frame++)

           {

             imvec[frameidx(frame)].getConstPixels (0, 0, columns, rows);

             const Magick::IndexPacket *pix

               = imvec[frameidx(frame)].getConstIndexes ();

             i = 0;

             idx(3) = frame;

             for (int y = 0; y < rows; y++)

               {

                 idx(0) = y;

                 for (int x = 0; x < columns; x++)

                   {

                     idx(1) = x;

                     im(idx) = static_cast<octave_uint8> (pix[i++]);

                   }

               }

           }

         im.chop_trailing_singletons ();

         output(0) = octave_value (im);

       }

       break;

     case 16:

       {

         uint16NDArray im = uint16NDArray (idim);

         idx(2) = 0;

         for (int frame = 0; frame < nframes; frame++)

           {

             imvec[frameidx(frame)].getConstPixels (0, 0, columns, rows);

             const Magick::IndexPacket *pix

               = imvec[frameidx(frame)].getConstIndexes ();

             i = 0;

             idx(3) = frame;

             for (int y = 0; y < rows; y++)

               {

                 idx(0) = y;

                 for (int x = 0; x < columns; x++)

                   {

                     idx(1) = x;

                     im(idx) = static_cast<octave_uint16> (pix[i++]);

                   }

               }

           }

         im.chop_trailing_singletons ();

         output(0) = octave_value (im);

       }

       break;

     default:

       error ("__magic_read__: index depths bigger than 16-bit not supported");

       return octave_value_list ();

     }

   Matrix map = Matrix (mapsize, 3);

   Matrix alpha;

   switch (type)

     {

     case Magick::PaletteMatteType:

 #if 0

       warning ("palettematte");

       Matrix map (mapsize, 3);

       Matrix alpha (mapsize, 1);

       for (i = 0; i < mapsize; i++)

         {

           warning ("%d", i);

           Magick::ColorRGB c = imvec[0].colorMap (i);

           map(i,0) = c.red ();

           map(i,1) = c.green ();

           map(i,2) = c.blue ();

           alpha(i,1) = c.alpha ();

         }

       break;

 #endif

     case Magick::PaletteType:

       alpha = Matrix (0, 0);

       for (i = 0; i < mapsize; i++)

         {

           Magick::ColorRGB c = imvec[0].colorMap (i);

           map(i,0) = c.red ();

           map(i,1) = c.green ();

           map(i,2) = c.blue ();

         }

       break;

     default:

       error ("__magick_read__: unsupported indexed image type");

       return octave_value_list ();

     }

   if (wantalpha)

     output(2) = alpha;

   output(1) = map;

   return output;

 }

 template <class T>

 octave_value_list

 read_images (const std::vector<Magick::Image>& imvec,

              const Array<int>& frameidx, unsigned int depth)

 {

   octave_value_list retval (3, Matrix ());

   T im;

   int rows = imvec[0].baseRows ();

   int columns = imvec[0].baseColumns ();

   int nframes = frameidx.length ();

   dim_vector idim = dim_vector ();

   idim.resize (4);

   idim(0) = rows;

   idim(1) = columns;

   idim(2) = 1;

   idim(3) = nframes;

   Array<int> idx (dim_vector (4));

   Magick::ImageType type = imvec[0].type ();

   switch (type)

     {

     case Magick::BilevelType:

     case Magick::GrayscaleType:

       im = T (idim);

       for (int frame = 0; frame < nframes; frame++)

         {

           const Magick::PixelPacket *pix

             = imvec[frameidx(frame)].getConstPixels (0, 0, columns, rows);

           int i = 0;

           idx(2) = 0;

           idx(3) = frame;

           for (int y = 0; y < rows; y++)

             {

               idx(0) = y;

               for (int x = 0; x < columns; x++)

                 {

                   idx(1) = x;

                   im(idx) = scale_quantum_to_depth (pix[i++].red, depth);

                 }

             }

         }

       break;

     case Magick::GrayscaleMatteType:

       idim(2) = 2;

       im = T (idim);

       for (int frame = 0; frame < nframes; frame++)

         {

           const Magick::PixelPacket *pix

             = imvec[frameidx(frame)].getConstPixels (0, 0, columns, rows);

           int i = 0;

           idx(3) = frame;

           for (int y = 0; y < rows; y++)

             {

               idx(0) = y;

               for (int x = 0; x < columns; x++)

                 {

                   idx(1) = x;

                   idx(2) = 0;

                   im(idx) = scale_quantum_to_depth (pix[i].red, depth);

                   idx(2) = 1;

                   im(idx) = scale_quantum_to_depth (pix[i].opacity, depth);

                   i++;

                 }

             }

         }

       break;

     case Magick::PaletteType:

     case Magick::TrueColorType:

       idim(2) = 3;

       im = T (idim);

       for (int frame = 0; frame < nframes; frame++)

         {

           const Magick::PixelPacket *pix

             = imvec[frameidx(frame)].getConstPixels (0, 0, columns, rows);

           int i = 0;

           idx(3) = frame;

           for (int y = 0; y < rows; y++)

             {

               idx(0) = y;

               for (int x = 0; x < columns; x++)

                 {

                   idx(1) = x;

                   idx(2) = 0;

                   im(idx) = scale_quantum_to_depth (pix[i].red, depth);

                   idx(2) = 1;

                   im(idx) = scale_quantum_to_depth (pix[i].green, depth);

                   idx(2) = 2;

                   im(idx) = scale_quantum_to_depth (pix[i].blue, depth);

                   i++;

                 }

             }

         }

       break;

     case Magick::PaletteMatteType:

     case Magick::TrueColorMatteType:

     case Magick::ColorSeparationType:

       idim(2) = 4;

       im = T (idim);

       for (int frame = 0; frame < nframes; frame++)

         {

           const Magick::PixelPacket *pix

             = imvec[frameidx(frame)].getConstPixels (0, 0, columns, rows);

           int i = 0;

           idx(3) = frame;

           for (int y = 0; y < rows; y++)

             {

               idx(0) = y;

               for (int x = 0; x < columns; x++)

                 {

                   idx(1) = x;

                   idx(2) = 0;

                   im(idx) = scale_quantum_to_depth (pix[i].red, depth);

                   idx(2) = 1;

                   im(idx) = scale_quantum_to_depth (pix[i].green, depth);

                   idx(2) = 2;

                   im(idx) = scale_quantum_to_depth (pix[i].blue, depth);

                   idx(2) = 3;

                   im(idx) = scale_quantum_to_depth (pix[i].opacity, depth);

                   i++;

                 }

             }

         }

       break;

     default:

       error ("__magick_read__: undefined ImageMagick image type");

       return retval;

     }

   im.chop_trailing_singletons ();

   retval(0) = im;

   return retval;

 }

 #endif

 DEFUN_DLD (magick_read, args, nargout,

   "-*- texinfo -*-\n\

 @deftypefn {Function File} {@var{m} =} __magick_read__(@var{fname}, @var{index})\n\

 @deftypefnx{Function File} {[@var{m}, @var{colormap}] =} __magick_read__(@var{fname}, @var{index})\n\

 @deftypefnx{Function File} {[@var{m}, @var{colormap}, @var{alpha}] =} __magick_read__(@var{fname}, @var{index})\n\

 Read images with ImageMagick++.  In general you should not be using this function.\n\

 Instead you should use @code{imread}.\n\

 @seealso{imread}\n\

 @end deftypefn")

 {

   octave_value_list output;

 #ifdef HAVE_MAGICK

   if (args.length () > 2 || args.length () < 1 || ! args(0).is_string ()

       || nargout > 3)

     {

       print_usage ();

       return output;

     }

   Array<int> frameidx;

   if (args.length () == 2 && args(1).is_real_type ())

     frameidx = args(1).int_vector_value();

   else

     {

       frameidx = Array<int> (1);

       frameidx(0) = 1;

     }

   std::vector<Magick::Image> imvec;

   try

     {

       // Read a file into vector of image objects

       Magick::readImages (&imvec, args(0).string_value ());

     }

   catch (Magick::Warning& w)

     {

       warning ("Magick++ warning: %s", w.what ());

     }

   catch (Magick::ErrorCoder& e)

     {

       warning ("Magick++ coder error: %s", e.what ());

     }

   catch (Magick::Exception& e)

     {

       error ("Magick++ exception: %s", e.what ());

       return output;

     }

   for (int i = 0; i < frameidx.length(); i++)

     {

       frameidx(i) = frameidx(i) - 1;

       int nframes = imvec.size ();

       if (frameidx(i) >= nframes || frameidx(i) < 0)

         {

           error ("__magick_read__: invalid index vector");

           return output;

         }

     }

   Magick::ClassType klass = imvec[0].classType ();

   if (klass == Magick::PseudoClass && nargout > 1)

     output = read_indexed_images (imvec, frameidx, (nargout == 3));

   else

     {

       unsigned int depth = imvec[0].modulusDepth ();

       int i = 0;

       while (depth >>= 1)

         i++;

       depth = 1 << i;

       switch (depth)

         {

         case 1:

           output = read_images<boolNDArray> (imvec, frameidx, depth);

           break;

         case 2:

         case 4:

         case 8:

           output = read_images<uint8NDArray> (imvec, frameidx, depth) ;

           break;

         case 16:

           output = read_images<uint16NDArray> (imvec, frameidx, depth);

           break;

         case 32:

         case 64:

         default:

           error ("__magick_read__: image depths bigger than 16-bit not supported");

         }

     }

 #else

   error ("__magick_read__: not available in this version of Octave");

 #endif

   return output;

 }

 #ifdef HAVE_MAGICK

 static void

 jpg_settings (std::vector<Magick::Image>& imvec,

               const Octave_map& options,

               bool)

 {

   int nframes = static_cast<int>(imvec.size ());

   bool something_set = 0;

   // Quality setting

   octave_value result;

   Octave_map::const_iterator p;

   bool found_it = 0;

   for (p = options.begin (); p != options.end (); p++)

     if (options.key (p) == "Quality")

       {

         found_it = 1;

         result = options.contents (p).elem (0);

         break;

       }

   if (found_it && (! result.is_empty ()))

     {

       something_set = 1;

       if (result.is_real_type ())

         {

           int qlev = static_cast<int>(result.int_value ());

           if (qlev < 0 || qlev > 100)

             warning ("warning: Quality setting invalid--use default of 75");

           else

             for (int fnum = 0; fnum < nframes; fnum++)

               imvec[fnum].quality (static_cast<unsigned int>(qlev));

         }

       else

         warning ("warning: Quality setting invalid--use default of 75");

     }

   // Other settings go here

   if (! something_set)

     warning ("__magick_write__ warning: All write parameters ignored.");

 }

 static void

 encode_bool_image (std::vector<Magick::Image>& imvec, const octave_value& img)

 {

   unsigned int nframes = 1;

   boolNDArray m = img.bool_array_value ();

   dim_vector dsizes = m.dims ();

   if (dsizes.length () == 4)

     nframes = dsizes(3);

   Array<octave_idx_type> idx (dsizes.length ());

   octave_idx_type rows = m.rows ();

   octave_idx_type columns = m.columns ();

   for (unsigned int ii = 0; ii < nframes; ii++)

     {

       Magick::Image im(Magick::Geometry (columns, rows), "black");

       im.classType (Magick::DirectClass);

       im.depth (1);

       for (int y=0; y < columns; y++)

         {

           idx(1) = y;

           for (int x=0; x < rows; x++)

             {

               if (nframes > 1)

                 {

                   idx(2) = 0;

                   idx(3) = ii;

                 }

               idx(0) = x;

               if (m(idx))

                 im.pixelColor (y, x, "white");

             }

         }

       imvec.push_back (im);

     }

 }

 template <class T>

 static void

 encode_uint_image (std::vector<Magick::Image>& imvec,

                    const octave_value& img,

                    bool has_map)

 {

   unsigned int bitdepth = 0;

   T m;

   if (img.is_uint8_type ())

     {

       bitdepth = 8;

       m = img.uint8_array_value ();

     }

   else if (img.is_uint16_type ())

     {

       bitdepth = 16;

       m = img.uint16_array_value ();

     }

   else

     error ("__magick_write__: invalid image class");

   dim_vector dsizes = m.dims ();

   unsigned int nframes = 1;

   if (dsizes.length () == 4)

     nframes = dsizes(3);

   bool is_color = ((dsizes.length () > 2) && (dsizes(2) > 2));

   bool has_alpha = (dsizes.length () > 2 && (dsizes(2) == 2 || dsizes(2) == 4));

   Array<octave_idx_type> idx (dsizes.length ());

   octave_idx_type rows = m.rows ();

   octave_idx_type columns = m.columns ();

   // FIXME -- maybe simply using bit shifting would be better?

   unsigned int div_factor = pow (2.0, static_cast<int> (bitdepth)) - 1;

   for (unsigned int ii = 0; ii < nframes; ii++)

     {

       Magick::Image im(Magick::Geometry (columns, rows), "black");

       im.depth (bitdepth);

       if (has_map)

         im.classType (Magick::PseudoClass);

       else

         im.classType (Magick::DirectClass);

       if (is_color)

         {

           if (has_alpha)

             im.type (Magick::TrueColorMatteType);

           else

             im.type (Magick::TrueColorType);

           Magick::ColorRGB c;

           for (int y=0; y < columns; y++)

             {

               idx(1) = y;

               for (int x=0; x < rows; x++)

                 {

                   idx(0) = x;

                   if (nframes > 1)

                     idx(3) = ii;

                   idx(2) = 0;

                   c.red (static_cast<double>(m(idx)) / div_factor);

                   idx(2) = 1;

                   c.green (static_cast<double>(m(idx)) / div_factor);

                   idx(2) = 2;

                   c.blue (static_cast<double>(m(idx)) / div_factor);

                   if (has_alpha)

                     {

                       idx(2) = 3;

                       c.alpha (static_cast<double>(m(idx)) / div_factor);

                     }

                   im.pixelColor (y, x, c);

                 }

             }

         }

       else

         {

           if (has_alpha)

             im.type (Magick::GrayscaleMatteType);

           else

             im.type (Magick::GrayscaleType);

           Magick::ColorGray c;

           for (int y=0; y < columns; y++)

             {

               idx(1) = y;

               for (int x=0; x < rows; x++)

                 {

                   idx(0) = x;

                   if (nframes > 1)

                     {

                       idx(2) = 0;

                       idx(3) = ii;

                     }

                   if (has_alpha)

                     {

                       idx(2) = 1;

                       c.alpha (static_cast<double>(m(idx)) / div_factor);

                       idx(2) = 0;

                     }

                   c.shade (static_cast<double>(m(idx)) / div_factor);

                   im.pixelColor (y, x, c);

                 }

             }

         }

       imvec.push_back (im);

     }

 }

 static void

 encode_map (std::vector<Magick::Image>& imvec, const NDArray& cmap)

 {

   unsigned int mapsize = cmap.dim1 ();

   int nframes = static_cast<int>(imvec.size ());

   for (int fnum = 0; fnum < nframes; fnum++)

     {

       imvec[fnum].colorMapSize (mapsize);

       imvec[fnum].type (Magick::PaletteType);

     }

   for (unsigned int ii = 0; ii < mapsize; ii++)

     {

       Magick::ColorRGB c (cmap(ii,0), cmap(ii,1), cmap(ii,2));

       // FIXME -- is this case needed?

       if (cmap.dim2 () == 4)

         c.alpha (cmap(ii,3));

       try

         {

           for_each (imvec.begin (), imvec.end (),

                     Magick::colorMapImage (ii, c));

         }

       catch (Magick::Warning& w)

         {

           warning ("Magick++ warning: %s", w.what ());

         }

       catch (Magick::ErrorCoder& e)

         {

           warning ("Magick++ coder error: %s", e.what ());

         }

       catch (Magick::Exception& e)

         {

           error ("Magick++ exception: %s", e.what ());

         }

     }

 }

 static void

 write_image (const std::string& filename, const std::string& fmt,

              const octave_value& img,

              const octave_value& map = octave_value (),

              const octave_value& params = octave_value ())

 {

   std::vector<Magick::Image> imvec;

   bool has_map = map.is_defined ();

   if (has_map)

     {

       error ("__magick_write__: direct saving of indexed images not currently supported; use ind2rgb and save converted image");

       return;

     }

   if (img.is_bool_type ())

     encode_bool_image (imvec, img);

   else if (img.is_uint8_type ())

     encode_uint_image<uint8NDArray> (imvec, img, has_map);

   else if (img.is_uint16_type ())

     encode_uint_image<uint16NDArray> (imvec, img, has_map);

   else

     error ("__magick_write__: image type not supported");

   if (! error_state && has_map)

     {

       NDArray cmap = map.array_value ();

       if (! error_state)

         encode_map (imvec, cmap);

     }

   if (! error_state && params.is_defined ())

     {

       Octave_map options = params.map_value ();

       // Insert calls here to handle parameters for various image formats

       if (fmt == "jpg" || fmt == "jpeg")

         jpg_settings (imvec, options, has_map);

       else

         warning ("warning: your parameter(s) currently not supported");

     }

   try

     {

       Magick::writeImages (imvec.begin (), imvec.end (), filename);

     }

   catch (Magick::Warning& w)

     {

       warning ("Magick++ warning: %s", w.what ());

     }

   catch (Magick::ErrorCoder& e)

     {

       warning ("Magick++ coder error: %s", e.what ());

     }

   catch (Magick::Exception& e)

     {

       error ("Magick++ exception: %s", e.what ());

     }

 }

 #endif

 DEFUN_DLD (magick_write, args, ,

   "-*- texinfo -*-\n\

 @deftypefn {Function File} {} __magick_write__(@var{fname}, @var{fmt}, @var{img})\n\

 @deftypefnx {Function File} {} __magick_write__(@var{fname}, @var{fmt}, @var{img}, @var{map})\n\

 Write images with ImageMagick++.  In general you should not be using this function.\n\

 Instead you should use @code{imwrite}.\n\

 @seealso{imread}\n\

 @end deftypefn")

 {

   octave_value_list retval;

 #ifdef HAVE_MAGICK

   int nargin = args.length ();

   if (nargin > 2)

     {

       std::string filename = args(0).string_value ();

       if (! error_state)

         {

           std::string fmt = args(1).string_value ();

           if (! error_state)

             {

               if (nargin > 4)

                 write_image (filename, fmt, args(2), args(3), args(4));

               else if (nargin > 3)

                 if (args(3).is_real_type ())

                   write_image (filename, fmt, args(2), args(3));

                 else

                   write_image (filename, fmt, args(2), octave_value(), args(3));

               else

                 write_image (filename, fmt, args(2));

             }

           else

             error ("__magick_write__: expecting format as second argument");

         }

       else

         error ("__magick_write__: expecting filename as first argument");

     }

   else

     print_usage ();

 #else

   error ("__magick_write__: not available in this version of Octave");

 #endif

 return retval;

 }

 #ifdef HAVE_MAGICK

 template<class T>

 static octave_value

 magick_to_octave_value (const T magick)

 {

   return octave_value (magick);

 }

 static octave_value

 magick_to_octave_value (const Magick::EndianType magick)

 {

   switch (magick)

     {

       case Magick::LSBEndian:

         return octave_value ("little-endian");

       case Magick::MSBEndian:

         return octave_value ("big-endian");

       default:

         return octave_value ("undefined");

     }

 }

 static octave_value

 magick_to_octave_value (const Magick::ResolutionType magick)

 {

   switch (magick)

     {

       case Magick::PixelsPerInchResolution:

         return octave_value ("pixels per inch");

       case Magick::PixelsPerCentimeterResolution:

         return octave_value ("pixels per centimeter");

       default:

         return octave_value ("undefined");

     }

 }

 static octave_value

 magick_to_octave_value (const Magick::ImageType magick)

 {

   switch (magick)

     {

       case Magick::BilevelType:

       case Magick::GrayscaleType:

       case Magick::GrayscaleMatteType:

         return octave_value ("grayscale");

       case Magick::PaletteType:

       case Magick::PaletteMatteType:

         return octave_value ("indexed");

       case Magick::TrueColorType:

       case Magick::TrueColorMatteType:

       case Magick::ColorSeparationType:

         return octave_value ("truecolor");

       default:

         return octave_value ("undefined");

     }

 }

 // We put this in a try-block because GraphicsMagick will throw

 // exceptions if a parameter isn't present in the current image.

 #define GET_PARAM(NAME, OUTNAME) \

   try \

     { \

       st.assign (OUTNAME, magick_to_octave_value (im.NAME ())); \

     } \

   catch (Magick::Warning& w) \

     { \

     }

 #endif

 DEFUN_DLD (magick_finfo, args, ,

   "-*- texinfo -*-\n\

 @deftypefn {Loadable File} {} __magick_finfo__(@var{fname})\n\

 Read image information with GraphicsMagick++.  In general you should\n\

 not be using this function.  Instead you should use @code{imfinfo}.\n\

 @seealso{imfinfo, imread}\n\

 @end deftypefn")

 {

   octave_value_list output;

 #ifdef HAVE_MAGICK

   if (args.length () < 1 || ! args (0).is_string ())

     {

       print_usage ();

       return output;

     }

   const std::string filename = args (0).string_value ();

   try

     {

       // Read the file.

       Magick::Image im;

       im.read (filename);

       // Read properties.

       Octave_map st;

       st.assign ("Filename", filename);

       // Annoying CamelCase naming is for Matlab compatibility.

       GET_PARAM (fileSize, "FileSize")

       GET_PARAM (rows, "Height")

       GET_PARAM (columns, "Width")

       GET_PARAM (depth, "BitDepth")

       GET_PARAM (magick, "Format")

       GET_PARAM (format, "LongFormat")

       GET_PARAM (xResolution, "XResolution")

       GET_PARAM (yResolution, "YResolution")

       GET_PARAM (totalColors, "TotalColors")

       GET_PARAM (tileName, "TileName")

       GET_PARAM (animationDelay, "AnimationDelay")

       GET_PARAM (animationIterations, "AnimationIterations")

       GET_PARAM (endian, "ByteOrder")

       GET_PARAM (gamma, "Gamma")

       GET_PARAM (matte, "Matte")

       GET_PARAM (modulusDepth, "ModulusDepth")

       GET_PARAM (quality, "Quality")

       GET_PARAM (quantizeColors, "QuantizeColors")

       GET_PARAM (resolutionUnits, "ResolutionUnits")

       GET_PARAM (type, "ColorType")

       GET_PARAM (view, "View")

       output (0) = st;

     }

   catch (Magick::Warning& w)

     {

       warning ("Magick++ warning: %s", w.what ());

     }

   catch (Magick::ErrorCoder& e)

     {

       warning ("Magick++ coder error: %s", e.what ());

     }

   catch (Magick::Exception& e)

     {

       error ("Magick++ exception: %s", e.what ());

       return output;

     }

 #else

   error ("imfinfo: not available in this version of Octave");

 #endif

   return output;

 }

 #undef GET_PARAM

 /*

 ;;; Local Variables: ***

 ;;; mode: C++ ***

 ;;; indent-tabs-mode: nil ***

 ;;; End: ***

 */