octave: libinterp/dldfcn/__magick_read_

annotate libinterp/dldfcn/__magick_read__.cc @ 17116:59acfe9209dd

Do not read alpha channel from image if output not requested. * __magick_read__.cc (read_images): check nargout and change image type to its non-matte equivalent if alpha channel is not requested as output.

author	Carnë Draug <carandraug@octave.org>
date	Wed, 31 Jul 2013 13:14:09 +0100
parents	95055b814d35
children	c97a26408ee0

rev	line source
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	1 /*
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	2
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	3 Copyright (C) 2013 Carnë Draug
14138 72c96de7a403 maint: update copyright notices for 2012 John W. Eaton <jwe@octave.org> parents: 13029 diff changeset	4 Copyright (C) 2002-2012 Andy Adler
7932 d75586531aac style fixes John W. Eaton <jwe@octave.org> parents: 7931 diff changeset	5 Copyright (C) 2008 Thomas L. Scofield
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	6 Copyright (C) 2010 David Grundberg
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	7
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	8 This file is part of Octave.
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	9
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	10 Octave is free software; you can redistribute it and/or modify it
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	11 under the terms of the GNU General Public License as published by the
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	12 Free Software Foundation; either version 3 of the License, or (at your
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	13 option) any later version.
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	14
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	15 Octave is distributed in the hope that it will be useful, but WITHOUT
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	18 for more details.
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	19
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	20 You should have received a copy of the GNU General Public License
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	21 along with Octave; see the file COPYING. If not, see
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	22 <http://www.gnu.org/licenses/>.
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	23
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	24 */
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	25
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	26 #ifdef HAVE_CONFIG_H
d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	27 #include <config.h>
d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	28 #endif
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	29
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	30 #include <cmath>
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	31
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	32 #include "file-stat.h"
10390 ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	33 #include "oct-env.h"
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	34 #include "oct-time.h"
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	35
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	36 #include "defun-dld.h"
d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	37 #include "error.h"
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	38 #include "ov-struct.h"
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	39
16925 5c25f7ed080c __magick_read__.cc: add missing include of gripes.h Torsten <ttl@justmail.de>* parents: 16901 diff changeset	40 #include "gripes.h"
5c25f7ed080c __magick_read__.cc: add missing include of gripes.h Torsten <ttl@justmail.de>* parents: 16901 diff changeset	41
7937 6661387827d6 Allow build without GraphicsMagick installed David Bateman <dbateman@free.fr> parents: 7933 diff changeset	42 #ifdef HAVE_MAGICK
6661387827d6 Allow build without GraphicsMagick installed David Bateman <dbateman@free.fr> parents: 7933 diff changeset	43
9575 55ecaefb7d0f Use pkg-config to configure GraphicsMagick++. David Grundberg <individ@acc.umu.se> parents: 9439 diff changeset	44 #include <Magick++.h>
10739 d27bd2f74137 src/DLD_FUNCTIONS/__magick_read__.cc: restore locale after GraphicsMagick initialisation Soren Hauberg <hauberg@gmail.com> parents: 10390 diff changeset	45 #include <clocale>
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	46
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	47 template <class T>
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	48 static octave_value_list
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	49 read_indexed_images (std::vector<Magick::Image>& imvec,
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	50 const Array<octave_idx_type>& frameidx,
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	51 const octave_idx_type nargout)
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	52 {
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	53 typedef typename T::element_type P;
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	54
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	55 octave_value_list retval (3, Matrix ());
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	56
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	57 const octave_idx_type nRows = imvec[0].baseRows ();
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	58 const octave_idx_type nCols = imvec[0].baseColumns ();
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	59 const octave_idx_type nFrames = frameidx.length ();
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	60
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	61 T img = T (dim_vector (nRows, nCols, 1, nFrames));
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	62 P* img_fvec = img.fortran_vec ();
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	63
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	64 // When reading PixelPackets from the Image Pixel Cache, they come in
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	65 // row major order. So we keep moving back and forth there so we can
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	66 // write the image in column major order.
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	67 octave_idx_type idx = 0;
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	68 for (octave_idx_type frame = 0; frame < nFrames; frame++)
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	69 {
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	70 imvec[frameidx(frame)].getConstPixels (0, 0, nCols, nRows);
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	71
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	72 const Magick::IndexPacket *pix
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	73 = imvec[frameidx(frame)].getConstIndexes ();
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	74
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	75 for (octave_idx_type col = 0; col < nCols; col++)
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	76 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	77 for (octave_idx_type row = 0; row < nRows; row++)
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	78 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	79 img_fvec[idx++] = static_cast<P> (*pix);
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	80 pix += nCols;
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	81 }
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	82 pix -= nCols * nRows -1;
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	83 }
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	84 }
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	85 retval(0) = octave_value (img);
7933 54e414cc106b style fixes John W. Eaton <jwe@octave.org> parents: 7932 diff changeset	86
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	87 // Do we need to get the colormap to interpret the image and alpha channel?
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	88 if (nargout > 1)
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	89 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	90 const octave_idx_type mapsize = imvec[0].colorMapSize ();
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	91 Matrix cmap = Matrix (mapsize, 3);
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	92
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	93 // In theory, it should be possible for each frame of an image to
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	94 // have different colormaps but for Matlab compatibility, we only
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	95 // return the colormap of the first frame.
10100 dd4d4b14b340 __magick_read__.cc: no need to explicitly call chop_trailing_singletons now John W. Eaton <jwe@octave.org> parents: 9575 diff changeset	96
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	97 // only get alpha channel if it exists and was requested as output
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	98 if (imvec[0].matte () && nargout >= 3)
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	99 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	100 Matrix amap = Matrix (mapsize, 1);
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	101 for (octave_idx_type i = 0; i < mapsize; i++)
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	102 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	103 const Magick::ColorRGB c = imvec[0].colorMap (i);
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	104 cmap(i,0) = c.red ();
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	105 cmap(i,1) = c.green ();
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	106 cmap(i,2) = c.blue ();
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	107 amap(i,0) = c.alpha ();
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	108 }
7933 54e414cc106b style fixes John W. Eaton <jwe@octave.org> parents: 7932 diff changeset	109
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	110 NDArray alpha (dim_vector (nRows, nCols, 1, nFrames));
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	111 const octave_idx_type nPixels = alpha.numel ();
7933 54e414cc106b style fixes John W. Eaton <jwe@octave.org> parents: 7932 diff changeset	112
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	113 double* alpha_fvec = alpha.fortran_vec ();
7933 54e414cc106b style fixes John W. Eaton <jwe@octave.org> parents: 7932 diff changeset	114
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	115 idx = 0;
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	116 for (octave_idx_type pix = 0; pix < nPixels; pix++)
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	117 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	118 // GraphicsMagick stores the alpha values inverted, i.e.,
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	119 // 1 for transparent and 0 for opaque so we fix that here.
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	120 alpha_fvec[idx] = abs (amap(img(idx), 0) - 1);
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	121 idx++;
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	122 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	123 retval(2) = alpha;
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	124 }
10100 dd4d4b14b340 __magick_read__.cc: no need to explicitly call chop_trailing_singletons now John W. Eaton <jwe@octave.org> parents: 9575 diff changeset	125
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	126 else
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	127 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	128 for (octave_idx_type i = 0; i < mapsize; i++)
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	129 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	130 const Magick::ColorRGB c = imvec[0].colorMap (i);
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	131 cmap(i,0) = c.red ();
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	132 cmap(i,1) = c.green ();
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	133 cmap(i,2) = c.blue ();
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	134 }
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	135 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	136
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	137 retval(1) = cmap;
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	138 }
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	139
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	140 return retval;
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	141 }
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	142
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	143 // This function is highly repetitive, a bunch of for loops that are
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	144 // very similar to account for different image types. They are different
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	145 // enough that trying to reduce the copy and paste would decrease its
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	146 // readability too much.
10193 1a4074e277fe undo unintended change to __magick_read__.cc John W. Eaton <jwe@octave.org> parents: 10191 diff changeset	147 template <class T>
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	148 octave_value_list
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	149 read_images (std::vector<Magick::Image>& imvec,
17116 59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	150 const Array<octave_idx_type>& frameidx,
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	151 const octave_idx_type nargout)
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	152 {
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	153 typedef typename T::element_type P;
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	154
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	155 octave_value_list retval (3, Matrix ());
d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	156
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	157 const octave_idx_type nRows = imvec[0].baseRows ();
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	158 const octave_idx_type nCols = imvec[0].baseColumns ();
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	159 const octave_idx_type nFrames = frameidx.length ();
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	160 T img;
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	161
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	162 // GraphicsMagick (GM) keeps the image values in memory using whatever
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	163 // QuantumDepth it was built with independently of the original image
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	164 // bitdepth. Basically this means that if GM was built with quantum 16
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	165 // all values are scaled in the uint16 range. If the original image
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	166 // had an 8 bit depth, we need to rescale it for that range.
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	167 // However, if the image had a bitdepth of 32, then we will be returning
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	168 // a floating point image. In this case, the values need to be rescaled
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	169 // for the range [0 1] (this is what Matlab has documented on the page
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	170 // about image types but in some cases seems to be doing something else.
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	171 // See bug #39249).
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	172 // Finally, we must do the division ourselves (set a divisor) instead of
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	173 // using quantumOperator for the cases where we will be returning floating
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	174 // point and want things in the range [0 1]. This is the same reason why
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	175 // the divisor is of type double.
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	176 const double divisor = (imvec[0].depth () == 32) ?
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	177 std::numeric_limits<uint32_t>::max () :
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	178 ((uint64_t (1) << QuantumDepth) - 1) /
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	179 ((uint64_t (1) << imvec[0].depth ()) - 1);
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	180
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	181 // FIXME: this workaround should probably be fixed in GM by creating a
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	182 // new ImageType BilevelMatteType
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	183 // Despite what GM documentation claims, opacity is not only on the types
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	184 // with Matte on the name. It is possible that an image is completely
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	185 // black (1 color), and have a second channel set for transparency (2nd
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	186 // color). Its type will be bilevel since there is no BilevelMatte. The
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	187 // only way to check for this seems to be by checking matte ().
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	188 Magick::ImageType type = imvec[0].type ();
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	189 if (type == Magick::BilevelType && imvec[0].matte ())
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	190 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	191 type = Magick::GrayscaleMatteType;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	192 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	193
17116 59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	194 // If the alpha channel was not requested, treat images as if
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	195 // it doesn't exist.
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	196 if (nargout < 3)
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	197 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	198 switch (type)
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	199 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	200 case Magick::GrayscaleMatteType:
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	201 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	202 type = Magick::GrayscaleType;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	203 break;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	204 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	205 case Magick::PaletteMatteType:
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	206 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	207 type = Magick::PaletteType;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	208 break;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	209 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	210 case Magick::TrueColorMatteType:
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	211 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	212 type = Magick::TrueColorType;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	213 break;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	214 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	215 case Magick::ColorSeparationMatteType:
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	216 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	217 type = Magick::ColorSeparationType;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	218 break;
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	219 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	220 default:
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	221 {
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	222 // do nothing, other than silencing warnings about enumeration
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	223 // values not being handled in switch.
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	224 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	225 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	226 }
59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	227
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	228 switch (type)
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	229 {
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	230 case Magick::BilevelType: // Monochrome bi-level image
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	231 case Magick::GrayscaleType: // Grayscale image
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	232 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	233 img = T (dim_vector (nRows, nCols, 1, nFrames));
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	234 P *img_fvec = img.fortran_vec ();
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	235
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	236 octave_idx_type idx = 0;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	237 for (octave_idx_type frame = 0; frame < nFrames; frame++)
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	238 {
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	239 const Magick::PixelPacket *pix
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	240 = imvec[frameidx(frame)].getConstPixels (0, 0, nCols, nRows);
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	241
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	242 for (octave_idx_type col = 0; col < nCols; col++)
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	243 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	244 for (octave_idx_type row = 0; row < nRows; row++)
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	245 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	246 img_fvec[idx++] = pix->red / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	247 pix += nCols;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	248 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	249 pix -= nRows * nCols -1;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	250 }
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	251 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	252 break;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	253 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	254
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	255 case Magick::GrayscaleMatteType: // Grayscale image with opacity
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	256 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	257 img = T (dim_vector (nRows, nCols, 1, nFrames));
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	258 T alpha (dim_vector (nRows, nCols, 1, nFrames));
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	259 P *img_fvec = img.fortran_vec ();
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	260 P *a_fvec = alpha.fortran_vec ();
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	261
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	262 octave_idx_type idx = 0;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	263 for (octave_idx_type frame = 0; frame < nFrames; frame++)
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	264 {
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	265 const Magick::PixelPacket *pix
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	266 = imvec[frameidx(frame)].getConstPixels (0, 0, nCols, nRows);
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	267
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	268 for (octave_idx_type col = 0; col < nCols; col++)
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	269 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	270 for (octave_idx_type row = 0; row < nRows; row++)
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	271 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	272 img_fvec[idx] = pix->red / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	273 a_fvec[idx] = pix->opacity / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	274 pix += nCols;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	275 idx++;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	276 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	277 pix -= nRows * nCols -1;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	278 }
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	279 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	280 retval(2) = alpha;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	281 break;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	282 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	283
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	284 case Magick::PaletteType: // Indexed color (palette) image
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	285 case Magick::TrueColorType: // Truecolor image
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	286 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	287 img = T (dim_vector (nRows, nCols, 3, nFrames));
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	288 P *img_fvec = img.fortran_vec ();
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	289
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	290 for (octave_idx_type frame = 0; frame < nFrames; frame++)
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	291 {
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	292 const Magick::PixelPacket *pix
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	293 = imvec[frameidx(frame)].getConstPixels (0, 0, nCols, nRows);
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	294
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	295 octave_idx_type idx = 0;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	296 img_fvec += nRows * nCols * frame;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	297 P *rbuf = img_fvec;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	298 P gbuf = img_fvec + nRows nCols;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	299 P bbuf = img_fvec + nRows nCols * 2;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	300
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	301 for (octave_idx_type col = 0; col < nCols; col++)
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	302 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	303 for (octave_idx_type row = 0; row < nRows; row++)
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	304 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	305 rbuf[idx] = pix->red / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	306 gbuf[idx] = pix->green / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	307 bbuf[idx] = pix->blue / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	308 pix += nCols;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	309 idx++;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	310 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	311 pix -= nRows * nCols -1;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	312 }
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	313 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	314 break;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	315 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	316
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	317 case Magick::PaletteMatteType: // Indexed color (palette) image with opacity
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	318 case Magick::TrueColorMatteType: // Truecolor image with opacity
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	319 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	320 img = T (dim_vector (nRows, nCols, 3, nFrames));
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	321 T alpha (dim_vector (nRows, nCols, 1, nFrames));
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	322 P *img_fvec = img.fortran_vec ();
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	323 P *a_fvec = alpha.fortran_vec ();
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	324
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	325 // Unlike the index for the other channels, this one won't need
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	326 // to be reset on each frame since it's a separate matrix.
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	327 octave_idx_type a_idx = 0;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	328 for (octave_idx_type frame = 0; frame < nFrames; frame++)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	329 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	330 const Magick::PixelPacket *pix
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	331 = imvec[frameidx(frame)].getConstPixels (0, 0, nCols, nRows);
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	332
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	333 octave_idx_type idx = 0;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	334 img_fvec += nRows * nCols * frame;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	335 P *rbuf = img_fvec;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	336 P gbuf = img_fvec + nRows nCols;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	337 P bbuf = img_fvec + nRows nCols * 2;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	338
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	339 for (octave_idx_type col = 0; col < nCols; col++)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	340 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	341 for (octave_idx_type row = 0; row < nRows; row++)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	342 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	343 rbuf[idx] = pix->red / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	344 gbuf[idx] = pix->green / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	345 bbuf[idx] = pix->blue / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	346 a_fvec[a_idx] = pix->opacity / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	347 pix += nCols;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	348 idx++;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	349 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	350 pix -= nRows * nCols -1;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	351 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	352 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	353 retval(2) = alpha;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	354 break;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	355 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	356
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	357 case Magick::ColorSeparationType: // Cyan/Yellow/Magenta/Black (CYMK) image
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	358 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	359 img = T (dim_vector (nRows, nCols, 4, nFrames));
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	360 P *img_fvec = img.fortran_vec ();
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	361
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	362 for (octave_idx_type frame = 0; frame < nFrames; frame++)
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	363 {
13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	364 const Magick::PixelPacket *pix
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	365 = imvec[frameidx(frame)].getConstPixels (0, 0, nCols, nRows);
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	366
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	367 octave_idx_type idx = 0;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	368 img_fvec += nRows * nCols * frame;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	369 P *cbuf = img_fvec;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	370 P mbuf = img_fvec + nRows nCols;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	371 P ybuf = img_fvec + nRows nCols * 2;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	372 P kbuf = img_fvec + nRows nCols * 3;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	373
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	374 for (octave_idx_type col = 0; col < nCols; col++)
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	375 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	376 for (octave_idx_type row = 0; row < nRows; row++)
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	377 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	378 cbuf[idx] = pix->red / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	379 mbuf[idx] = pix->green / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	380 ybuf[idx] = pix->blue / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	381 kbuf[idx] = pix->opacity / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	382 pix += nCols;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	383 idx++;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	384 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	385 pix -= nRows * nCols -1;
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	386 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	387 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	388 break;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	389 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	390
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	391 // Cyan, magenta, yellow, and black with alpha (opacity) channel
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	392 case Magick::ColorSeparationMatteType:
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	393 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	394 img = T (dim_vector (nRows, nCols, 4, nFrames));
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	395 T alpha (dim_vector (nRows, nCols, 1, nFrames));
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	396 P *img_fvec = img.fortran_vec ();
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	397 P *a_fvec = alpha.fortran_vec ();
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	398
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	399 // Unlike the index for the other channels, this one won't need
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	400 // to be reset on each frame since it's a separate matrix.
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	401 octave_idx_type a_idx = 0;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	402 for (octave_idx_type frame = 0; frame < nFrames; frame++)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	403 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	404 const Magick::PixelPacket *pix
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	405 = imvec[frameidx(frame)].getConstPixels (0, 0, nCols, nRows);
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	406 // Note that for CMYKColorspace + matte (CMYKA), the opacity is
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	407 // stored in the assocated IndexPacket.
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	408 const Magick::IndexPacket *apix
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	409 = imvec[frameidx(frame)].getConstIndexes ();
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	410
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	411 octave_idx_type idx = 0;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	412 img_fvec += nRows * nCols * frame;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	413 P *cbuf = img_fvec;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	414 P mbuf = img_fvec + nRows nCols;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	415 P ybuf = img_fvec + nRows nCols * 2;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	416 P kbuf = img_fvec + nRows nCols * 3;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	417
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	418 for (octave_idx_type col = 0; col < nCols; col++)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	419 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	420 for (octave_idx_type row = 0; row < nRows; row++)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	421 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	422 cbuf[idx] = pix->red / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	423 mbuf[idx] = pix->green / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	424 ybuf[idx] = pix->blue / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	425 kbuf[idx] = pix->opacity / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	426 a_fvec[a_idx] = *apix / divisor;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	427 pix += nCols;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	428 idx++;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	429 a_idx++;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	430 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	431 pix -= nRows * nCols -1;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	432 }
10295 13d382fc758b imread: Make reading non-indexed images faster David Grundberg <davidg@cs.umu.se> parents: 10193 diff changeset	433 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	434 retval(2) = alpha;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	435 break;
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	436 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	437
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	438 default:
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	439 error ("__magick_read__: unknown Magick++ image type");
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	440 return retval;
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	441 }
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	442
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	443 retval(0) = img;
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	444 return retval;
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	445 }
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	446
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	447
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	448 void static
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	449 read_file (const std::string filename, std::vector<Magick::Image>& imvec)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	450 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	451 try
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	452 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	453 // Read a file into vector of image objects
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	454 Magick::readImages (&imvec, filename);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	455 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	456 catch (Magick::Warning& w)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	457 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	458 warning ("Magick++ warning: %s", w.what ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	459 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	460 catch (Magick::ErrorCoder& e)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	461 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	462 // FIXME: there's a WarningCoder and ErrorCoder. Shouldn't this
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	463 // exception cause an error?
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	464 warning ("Magick++ coder error: %s", e.what ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	465 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	466 catch (Magick::Exception& e)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	467 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	468 error ("Magick++ exception: %s", e.what ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	469 error_state = 1;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	470 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	471 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	472
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	473
10947 dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	474 static void
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	475 maybe_initialize_magick (void)
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	476 {
10390 ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	477 static bool initialized = false;
ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	478
ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	479 if (! initialized)
ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	480 {
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	481 // Save locale as GraphicsMagick might change this (fixed in
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	482 // GraphicsMagick since version 1.3.13 released on December 24, 2011)
10739 d27bd2f74137 src/DLD_FUNCTIONS/__magick_read__.cc: restore locale after GraphicsMagick initialisation Soren Hauberg <hauberg@gmail.com> parents: 10390 diff changeset	483 const char *static_locale = setlocale (LC_ALL, NULL);
d27bd2f74137 src/DLD_FUNCTIONS/__magick_read__.cc: restore locale after GraphicsMagick initialisation Soren Hauberg <hauberg@gmail.com> parents: 10390 diff changeset	484 const std::string locale (static_locale);
d27bd2f74137 src/DLD_FUNCTIONS/__magick_read__.cc: restore locale after GraphicsMagick initialisation Soren Hauberg <hauberg@gmail.com> parents: 10390 diff changeset	485
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	486 const std::string program_name = octave_env::get_program_invocation_name ();
10390 ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	487 Magick::InitializeMagick (program_name.c_str ());
ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	488
10739 d27bd2f74137 src/DLD_FUNCTIONS/__magick_read__.cc: restore locale after GraphicsMagick initialisation Soren Hauberg <hauberg@gmail.com> parents: 10390 diff changeset	489 // Restore locale from before GraphicsMagick initialisation
d27bd2f74137 src/DLD_FUNCTIONS/__magick_read__.cc: restore locale after GraphicsMagick initialisation Soren Hauberg <hauberg@gmail.com> parents: 10390 diff changeset	490 setlocale (LC_ALL, locale.c_str ());
d27bd2f74137 src/DLD_FUNCTIONS/__magick_read__.cc: restore locale after GraphicsMagick initialisation Soren Hauberg <hauberg@gmail.com> parents: 10390 diff changeset	491
11036 169f59f626d3 Add check for QuantumDepth at initialization of Magick and an associated warning John Swensen <jpswensen@gmail.com>* parents: 11035 diff changeset	492 if (QuantumDepth < 32)
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	493 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	494 warning ("your version of %s limits images to %d bits per pixel",
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	495 MagickPackageName, QuantumDepth);
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	496 }
10390 ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	497 initialized = true;
ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	498 }
16983 4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	499 }
10947 dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	500 #endif
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	501
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	502 DEFUN_DLD (__magick_read__, args, nargout,
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	503 "-- texinfo --\n\
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	504 @deftypefn {Loadable Function} {[@var{img}, @var{map}, @var{alpha}] =} __magick_read__ (@var{fname}, @var{options})\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	505 Read image with GraphicsMagick or ImageMagick.\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	506 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	507 This is a private internal function not intended for direct use. Instead\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	508 use @code{imread}.\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	509 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	510 @seealso{imfinfo, imformats, imread, imwrite}\n\
10947 dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	511 @end deftypefn")
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	512 {
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	513 octave_value_list output;
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	514
16983 4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	515 #ifndef HAVE_MAGICK
4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	516 gripe_disabled_feature ("imread", "Image IO");
4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	517 #else
10947 dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	518
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	519 maybe_initialize_magick ();
10390 ad0b54ae206a __magick_read__ (F__magick_read__): call Magick::InitializeMagick John W. Eaton <jwe@octave.org> parents: 10350 diff changeset	520
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	521 if (args.length () != 2 \|\| ! args(0).is_string ())
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	522 {
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	523 print_usage ();
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	524 return output;
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	525 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	526
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	527 const octave_map options = args(1).map_value ();
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	528 if (error_state)
10778 6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	529 {
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	530 error ("__magick_read__: OPTIONS must be a struct");
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	531 }
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	532
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	533 std::vector<Magick::Image> imvec;
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	534 read_file (args(0).string_value (), imvec);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	535 if (error_state)
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	536 {
d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	537 return output;
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	538 }
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	539
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	540 // Prepare an Array with the indexes for the requested frames.
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	541 const octave_idx_type nFrames = imvec.size ();
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	542 Array<octave_idx_type> frameidx;
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	543 const octave_value indexes = options.getfield ("index")(0);
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	544 if (indexes.is_string () && indexes.string_value () == "all")
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	545 {
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	546 frameidx.resize (dim_vector (1, nFrames));
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	547 for (octave_idx_type i = 0; i < nFrames; i++)
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	548 {
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	549 frameidx(i) = i;
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	550 }
10778 6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	551 }
6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	552 else
6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	553 {
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	554 frameidx = indexes.int_vector_value ();
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	555 if (error_state)
10778 6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	556 {
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	557 error ("__magick_read__: invalid value for Index/Frame");
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	558 }
16989 7a69ab84b8c9 __magick_write__: confirm file exists before reading to append. Carnë Draug <carandraug@octave.org> parents: 16988 diff changeset	559 // Fix indexes from base 1 to base 0, and at the same time, make
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	560 // sure none of the indexes is outside the range of image number.
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	561 const octave_idx_type n = frameidx.nelem ();
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	562 for (octave_idx_type i = 0; i < n; i++)
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	563 {
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	564 frameidx(i)--;
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	565 if (frameidx(i) < 0 \|\| frameidx(i) > nFrames - 1)
10778 6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	566 {
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	567 error ("imread: index/frames specified are outside the number of images");
10778 6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	568 return output;
6035bf68a755 Support imread('file', 'frames', 'all') (Feature Request #30365) David Bateman <dbateman@free.fr> parents: 10739 diff changeset	569 }
8053 89a512e8ec43 Replace leading tabs with spaces. scofield@scofield parents: 7974 diff changeset	570 }
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	571 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	572
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	573 const Magick::ClassType klass = imvec[0].classType ();
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	574 const octave_idx_type depth = imvec[0].depth ();
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	575
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	576 // Magick::ClassType
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	577 // PseudoClass:
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	578 // Image is composed of pixels which specify an index in a color palette.
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	579 // DirectClass:
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	580 // Image is composed of pixels which represent literal color values.
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	581
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	582 // FIXME: GraphicsMagick does not really distinguishes between indexed and
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	583 // normal images. After reading a file, it decides itself the optimal
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	584 // way to store the image in memory, independently of the how the
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	585 // image was stored in the file. That's what ClassType returns. While
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	586 // it seems to match the original file most of the times, this is
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	587 // not necessarily true all the times. See
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	588 // https://sourceforge.net/mailarchive/message.php?msg_id=31180507
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	589 // A grayscale jpeg image reports being indexed even though the JPEG
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	590 // format has no support for indexed images. So we can skip at least
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	591 // for that.
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	592
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	593 if (klass == Magick::PseudoClass && imvec[0].magick () != "JPEG")
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	594 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	595 if (depth <= 1)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	596 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	597 output = read_indexed_images <boolNDArray> (imvec, frameidx, nargout);
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	598 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	599 else if (depth <= 8)
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	600 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	601 output = read_indexed_images <uint8NDArray> (imvec, frameidx, nargout);
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	602 }
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	603 else if (depth <= 16)
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	604 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	605 output = read_indexed_images <uint16NDArray> (imvec, frameidx, nargout);
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	606 }
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	607 else
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	608 {
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	609 error ("imread: indexed images with depths greater than 16-bit are not supported");
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	610 return output;
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	611 }
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	612 }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11585 diff changeset	613
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	614 else
a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	615 {
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	616 if (depth <= 1)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	617 {
17116 59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	618 output = read_images<boolNDArray> (imvec, frameidx, nargout);
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	619 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	620 else if (depth <= 8)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	621 {
17116 59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	622 output = read_images<uint8NDArray> (imvec, frameidx, nargout);
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	623 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	624 else if (depth <= 16)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	625 {
17116 59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	626 output = read_images<uint16NDArray> (imvec, frameidx, nargout);
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	627 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	628 else if (depth <= 32)
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	629 {
17116 59acfe9209dd Do not read alpha channel from image if output not requested. Carnë Draug <carandraug@octave.org> parents: 17110 diff changeset	630 output = read_images<FloatNDArray> (imvec, frameidx, nargout);
17110 95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	631 }
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	632 else
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	633 {
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	634 error ("imread: reading of images with %i-bit depth is not supported",
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	635 depth);
95055b814d35 imread: implement reading of images with 32 bitdepth and alpha channels. Carnë Draug <carandraug@octave.org> parents: 16996 diff changeset	636 }
16996 a1d091243d11 Read alpha values from indexed images. Always read indexes from indexed images. Carnë Draug <carandraug@octave.org> parents: 16989 diff changeset	637 }
7937 6661387827d6 Allow build without GraphicsMagick installed David Bateman <dbateman@free.fr> parents: 7933 diff changeset	638
6661387827d6 Allow build without GraphicsMagick installed David Bateman <dbateman@free.fr> parents: 7933 diff changeset	639 #endif
7925 9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	640 return output;
9316b59903c9 Add original imread() files (from octave-forge) to core octave. Thomas L. Scofield <scofield AT calvin DOT edu> parents: diff changeset	641 }
7926 d74f996e005d __magick_read__.cc: configuration and style fixes John W. Eaton <jwe@octave.org> parents: 7925 diff changeset	642
12805 3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	643 /*
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	644 ## No test needed for internal helper function.
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	645 %!assert (1)
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	646 */
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	647
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	648 #ifdef HAVE_MAGICK
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	649
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	650 static void
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	651 encode_bool_image (std::vector<Magick::Image>& imvec, const octave_value& img)
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	652 {
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	653 unsigned int nframes = 1;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	654 boolNDArray m = img.bool_array_value ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	655
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	656 dim_vector dsizes = m.dims ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	657 if (dsizes.length () == 4)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	658 nframes = dsizes(3);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	659
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11553 diff changeset	660 Array<octave_idx_type> idx (dim_vector (dsizes.length (), 1));
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	661
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	662 octave_idx_type rows = m.rows ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	663 octave_idx_type columns = m.columns ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	664
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	665 for (unsigned int ii = 0; ii < nframes; ii++)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	666 {
14854 5ae9f0f77635 maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory Rik <octave@nomad.inbox5.com> parents: 14846 diff changeset	667 Magick::Image im (Magick::Geometry (columns, rows), "black");
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	668 im.classType (Magick::DirectClass);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	669 im.depth (1);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	670
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	671 for (int y = 0; y < columns; y++)
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	672 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	673 idx(1) = y;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	674
7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	675 for (int x = 0; x < rows; x++)
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	676 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	677 if (nframes > 1)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	678 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	679 idx(2) = 0;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	680 idx(3) = ii;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	681 }
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	682
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	683 idx(0) = x;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	684
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	685 if (m(idx))
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	686 im.pixelColor (y, x, "white");
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	687 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	688 }
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	689
11034 6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	690 im.quantizeColorSpace (Magick::GRAYColorspace);
6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	691 im.quantizeColors (2);
6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	692 im.quantize ();
6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	693
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	694 imvec.push_back (im);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	695 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	696 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	697
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	698 template <class T>
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	699 static void
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	700 encode_uint_image (std::vector<Magick::Image>& imvec,
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	701 const octave_value& img,
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	702 const bool has_map)
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	703 {
8520 715f6cd8d5e7 __magick_read__.cc (encode_uint_image): initialize bitdepth Soren Hauberg <hauberg@gmail.com> parents: 8165 diff changeset	704 unsigned int bitdepth = 0;
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	705 T m;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	706
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	707 if (img.is_uint8_type ())
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	708 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	709 bitdepth = 8;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	710 m = img.uint8_array_value ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	711 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	712 else if (img.is_uint16_type ())
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	713 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	714 bitdepth = 16;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	715 m = img.uint16_array_value ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	716 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	717 else
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	718 error ("__magick_write__: invalid image class");
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	719
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	720 const dim_vector dsizes = m.dims ();
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	721 unsigned int nframes = 1;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	722 if (dsizes.length () == 4)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	723 nframes = dsizes(3);
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	724
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	725 const bool is_color = ((dsizes.length () > 2) && (dsizes(2) > 2));
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	726 const bool has_alpha = (dsizes.length () > 2 && (dsizes(2) == 2 \|\| dsizes(2) == 4));
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	727
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11553 diff changeset	728 Array<octave_idx_type> idx (dim_vector (dsizes.length (), 1));
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	729 octave_idx_type rows = m.rows ();
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	730 octave_idx_type columns = m.columns ();
8090 3cc1ca1b1576 MSVC compilation fix Michael Goffioul parents: 8054 diff changeset	731
13020 58d704d3283c Fix ambigous call to int pow (int, unsigned int&) Carlo de Falco <kingcrimson@tiscali.it> parents: 11590 diff changeset	732 unsigned int div_factor = (1 << bitdepth) - 1;
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	733
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	734 for (unsigned int ii = 0; ii < nframes; ii++)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	735 {
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	736 Magick::Image im (Magick::Geometry (columns, rows), "black");
7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	737
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	738 im.depth (bitdepth);
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	739
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	740 if (has_map)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	741 im.classType (Magick::PseudoClass);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	742 else
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	743 im.classType (Magick::DirectClass);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	744
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	745 if (is_color)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	746 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	747 if (has_alpha)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	748 im.type (Magick::TrueColorMatteType);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	749 else
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	750 im.type (Magick::TrueColorType);
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	751
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	752 Magick::ColorRGB c;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	753
7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	754 for (int y = 0; y < columns; y++)
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	755 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	756 idx(1) = y;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	757
7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	758 for (int x = 0; x < rows; x++)
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	759 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	760 idx(0) = x;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	761
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	762 if (nframes > 1)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	763 idx(3) = ii;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	764
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	765 idx(2) = 0;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	766 c.red (static_cast<double>(m(idx)) / div_factor);
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	767
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	768 idx(2) = 1;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	769 c.green (static_cast<double>(m(idx)) / div_factor);
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	770
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	771 idx(2) = 2;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	772 c.blue (static_cast<double>(m(idx)) / div_factor);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	773
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	774 if (has_alpha)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	775 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	776 idx(2) = 3;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	777 c.alpha (static_cast<double>(m(idx)) / div_factor);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	778 }
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	779
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	780 im.pixelColor (y, x, c);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	781 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	782 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	783 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	784 else
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	785 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	786 if (has_alpha)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	787 im.type (Magick::GrayscaleMatteType);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	788 else
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	789 im.type (Magick::GrayscaleType);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	790
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	791 Magick::ColorGray c;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	792
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	793 for (int y = 0; y < columns; y++)
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	794 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	795 idx(1) = y;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	796
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	797 for (int x=0; x < rows; x++)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	798 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	799 idx(0) = x;
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	800
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	801 if (nframes > 1)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	802 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	803 idx(2) = 0;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	804 idx(3) = ii;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	805 }
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	806
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	807 if (has_alpha)
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	808 {
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	809 idx(2) = 1;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	810 c.alpha (static_cast<double>(m(idx)) / div_factor);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	811 idx(2) = 0;
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	812 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	813
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	814 c.shade (static_cast<double>(m(idx)) / div_factor);
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	815
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	816 im.pixelColor (y, x, c);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	817 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	818 }
11034 6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	819
6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	820 im.quantizeColorSpace (Magick::GRAYColorspace);
13020 58d704d3283c Fix ambigous call to int pow (int, unsigned int&) Carlo de Falco <kingcrimson@tiscali.it> parents: 11590 diff changeset	821 im.quantizeColors (1 << bitdepth);
11034 6589aaf769f6 Correctly handle logical and integer bit depths John Swensen <jpswensen@gmail.com> parents: 10988 diff changeset	822 im.quantize ();
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	823 }
10979 7f49dc864f32 __magick_read__.cc: style fixes John W. Eaton <jwe@octave.org> parents: 10978 diff changeset	824
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	825 imvec.push_back (im);
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	826 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	827 }
272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	828
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	829 // FIXME: this will be needed to write indexed images
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	830 //static void
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	831 //encode_map (std::vector<Magick::Image>& imvec, const NDArray& cmap)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	832 //{
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	833 // unsigned int mapsize = cmap.dim1 ();
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	834
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	835 // for (size_t fnum = 0; fnum < imvec.size (); fnum++)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	836 // {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	837 // imvec[fnum].colorMapSize (mapsize);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	838 // imvec[fnum].type (Magick::PaletteType);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	839 // }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	840
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	841 // for (unsigned int ii = 0; ii < mapsize; ii++)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	842 // {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	843 // Magick::ColorRGB c (cmap(ii,0), cmap(ii,1), cmap(ii,2));
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	844
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	845 // // FIXME -- is this case needed?
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	846 // if (cmap.dim2 () == 4)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	847 // c.alpha (cmap(ii,3));
8054 272eaebbb6ba Various features added to imwrite scofield@scofield parents: 8053 diff changeset	848
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	849 // try
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	850 // {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	851 // for_each (imvec.begin (), imvec.end (),
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	852 // Magick::colorMapImage (ii, c));
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	853 // }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	854 // catch (Magick::Warning& w)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	855 // {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	856 // warning ("Magick++ warning: %s", w.what ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	857 // }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	858 // catch (Magick::ErrorCoder& e)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	859 // {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	860 // warning ("Magick++ coder error: %s", e.what ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	861 // }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	862 // catch (Magick::Exception& e)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	863 // {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	864 // error ("Magick++ exception: %s", e.what ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	865 // }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	866 // }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	867 //}
9275 86f475d5e7d1 imwrite.m: convert indexed images to RGB before calling __magick_write__ John W. Eaton <jwe@octave.org> parents: 9274 diff changeset	868
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	869 void static
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	870 write_file (const std::string filename,
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	871 const std::string ext,
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	872 std::vector<Magick::Image>& imvec)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	873 {
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	874 try
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	875 {
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	876 Magick::writeImages (imvec.begin (), imvec.end (), ext + ":" + filename);
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	877 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	878 catch (Magick::Warning& w)
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	879 {
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	880 warning ("Magick++ warning: %s", w.what ());
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	881 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	882 catch (Magick::ErrorCoder& e)
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	883 {
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	884 warning ("Magick++ coder error: %s", e.what ());
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	885 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	886 catch (Magick::Exception& e)
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	887 {
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	888 error ("Magick++ exception: %s", e.what ());
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	889 error_state = 1;
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	890 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	891 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	892
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	893 #endif
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	894
9436 5302df15ad76 __magick_read__.cc: undo unintended change John W. Eaton <jwe@octave.org> parents: 9434 diff changeset	895 DEFUN_DLD (__magick_write__, args, ,
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	896 "-- texinfo --\n\
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	897 @deftypefn {Loadable Function} {} __magick_write__ (@var{fname}, @var{fmt}, @var{img}, @var{map}, @var{options})\n\
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	898 Write image with GraphicsMagick or ImageMagick.\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	899 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	900 This is a private internal function not intended for direct use. Instead\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	901 use @code{imwrite}.\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	902 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	903 @seealso{imfinfo, imformats, imread, imwrite}\n\
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	904 @end deftypefn")
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	905 {
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	906 octave_value_list retval;
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	907
16983 4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	908 #ifndef HAVE_MAGICK
4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	909 gripe_disabled_feature ("imwrite", "Image IO");
4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	910 #else
4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	911
10947 dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	912 maybe_initialize_magick ();
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	913
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	914 if (args.length () != 5 \|\| ! args(0).is_string () \|\| ! args(1).is_string ())
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	915 {
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	916 print_usage ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	917 return retval;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	918 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	919 const std::string filename = args(0).string_value ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	920 const std::string ext = args(1).string_value ();
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	921
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	922 const octave_map options = args(4).map_value ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	923 if (error_state)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	924 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	925 error ("__magick_write__: OPTIONS must be a struct");
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	926 }
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	927
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	928 const octave_value img = args(2);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	929 const Matrix cmap = args(3).matrix_value ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	930 if (error_state)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	931 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	932 error ("__magick_write__: invalid IMG or MAP");
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	933 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	934 const bool is_indexed = ! cmap.is_empty ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	935
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	936 // Create vector with the images to write
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	937 std::vector<Magick::Image> imvec;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	938 if (img.is_bool_type ())
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	939 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	940 encode_bool_image (imvec, img);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	941 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	942 else if (img.is_uint8_type ())
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	943 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	944 encode_uint_image<uint8NDArray> (imvec, img, is_indexed);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	945 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	946 else if (img.is_uint16_type ())
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	947 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	948 encode_uint_image<uint16NDArray> (imvec, img, is_indexed);
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	949 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	950 else
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	951 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	952 error ("__magick_write__: image type not supported");
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	953 return retval;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	954 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	955 const int nframes = imvec.size ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	956
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	957 // Add colormap to image
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	958 if (is_indexed)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	959 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	960 // FIXME: this should be implemented. At the moment, imwrite is doing the
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	961 // conversion in case of indexed images.
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	962 error ("__magick_write__: direct saving of indexed images not currently supported; use ind2rgb and save converted image");
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	963 // encode_map (imvec, cmap);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	964 return retval;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	965 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	966
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	967 // Set quality.
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	968 // FIXME What happens when we try to set with formats that do not support it?
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	969 const unsigned int quality = options.getfield ("quality")(0).int_value ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	970 for (int i = 0; i < nframes; i++)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	971 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	972 imvec[i].quality (quality);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	973 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	974
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	975 // Finally, save the file.
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	976 // If writemode is set to append, read the image first, append to it,
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	977 // and then save it. But even if set to append, make sure anything was
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	978 // read at all.
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	979 const std::string writemode = options.getfield ("writemode")(0).string_value ();
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	980 std::vector<Magick::Image> ini_imvec;
16989 7a69ab84b8c9 __magick_write__: confirm file exists before reading to append. Carnë Draug <carandraug@octave.org> parents: 16988 diff changeset	981 if (writemode == "append" && file_stat (filename).exists ())
16988 54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	982 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	983 read_file (filename, ini_imvec);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	984 if (error_state)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	985 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	986 return retval;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	987 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	988 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	989
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	990 if (ini_imvec.size () > 0)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	991 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	992 ini_imvec.insert (ini_imvec.end (), imvec.begin (), imvec.end ());
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	993 write_file (filename, ext, ini_imvec);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	994 if (error_state)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	995 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	996 return retval;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	997 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	998 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	999 else
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1000 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1001 write_file (filename, ext, imvec);
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1002 if (error_state)
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1003 {
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1004 return retval;
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1005 }
54b75bed4bc7 imwrite: implement WriteMode option. Carnë Draug <carandraug@octave.org> parents: 16984 diff changeset	1006 }
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	1007
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	1008 #endif
16983 4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	1009 return retval;
7974 fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	1010 }
fcaddd090f98 imwrite: new function John W. Eaton <jwe@octave.org> parents: 7937 diff changeset	1011
12805 3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1012 /*
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1013 ## No test needed for internal helper function.
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1014 %!assert (1)
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1015 */
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1016
8165 75014ec4ac84 __magick_read__.cc: only define magick_to_octave_value functions if HAVE_MAGICK is defined John W. Eaton <jwe@octave.org> parents: 8144 diff changeset	1017 #ifdef HAVE_MAGICK
75014ec4ac84 __magick_read__.cc: only define magick_to_octave_value functions if HAVE_MAGICK is defined John W. Eaton <jwe@octave.org> parents: 8144 diff changeset	1018
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1019 template<class T>
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1020 static octave_value
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1021 magick_to_octave_value (const T magick)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1022 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1023 return octave_value (magick);
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1024 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1025
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1026 static octave_value
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1027 magick_to_octave_value (const Magick::EndianType magick)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1028 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1029 switch (magick)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1030 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1031 case Magick::LSBEndian:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1032 return octave_value ("little-endian");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1033
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1034 case Magick::MSBEndian:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1035 return octave_value ("big-endian");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1036
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1037 default:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1038 return octave_value ("undefined");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1039 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1040 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1041
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1042 static octave_value
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1043 magick_to_octave_value (const Magick::ResolutionType magick)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1044 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1045 switch (magick)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1046 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1047 case Magick::PixelsPerInchResolution:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1048 return octave_value ("pixels per inch");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1049
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1050 case Magick::PixelsPerCentimeterResolution:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1051 return octave_value ("pixels per centimeter");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1052
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1053 default:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1054 return octave_value ("undefined");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1055 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1056 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1057
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1058 static octave_value
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1059 magick_to_octave_value (const Magick::ImageType magick)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1060 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1061 switch (magick)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1062 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1063 case Magick::BilevelType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1064 case Magick::GrayscaleType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1065 case Magick::GrayscaleMatteType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1066 return octave_value ("grayscale");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1067
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1068 case Magick::PaletteType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1069 case Magick::PaletteMatteType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1070 return octave_value ("indexed");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1071
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1072 case Magick::TrueColorType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1073 case Magick::TrueColorMatteType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1074 case Magick::ColorSeparationType:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1075 return octave_value ("truecolor");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1076
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1077 default:
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1078 return octave_value ("undefined");
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1079 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1080 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1081
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1082 // We put this in a try-block because GraphicsMagick will throw
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1083 // exceptions if a parameter isn't present in the current image.
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1084 #define GET_PARAM(NAME, OUTNAME) \
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1085 try \
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1086 { \
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1087 info.contents (OUTNAME)(frame,0) = magick_to_octave_value (im.NAME ()); \
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1088 } \
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1089 catch (Magick::Warning& w) \
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1090 { \
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1091 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1092
8165 75014ec4ac84 __magick_read__.cc: only define magick_to_octave_value functions if HAVE_MAGICK is defined John W. Eaton <jwe@octave.org> parents: 8144 diff changeset	1093 #endif
75014ec4ac84 __magick_read__.cc: only define magick_to_octave_value functions if HAVE_MAGICK is defined John W. Eaton <jwe@octave.org> parents: 8144 diff changeset	1094
9436 5302df15ad76 __magick_read__.cc: undo unintended change John W. Eaton <jwe@octave.org> parents: 9434 diff changeset	1095 DEFUN_DLD (__magick_finfo__, args, ,
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1096 "-- texinfo --\n\
14854 5ae9f0f77635 maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory Rik <octave@nomad.inbox5.com> parents: 14846 diff changeset	1097 @deftypefn {Loadable Function} {} __magick_finfo__ (@var{fname})\n\
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	1098 Read image information with GraphicsMagick or ImageMagick.\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	1099 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	1100 This is a private internal function not intended for direct use. Instead\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	1101 use @code{imfinfo}.\n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	1102 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	1103 @seealso{imfinfo, imformats, imread, imwrite}\n\
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1104 @end deftypefn")
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1105 {
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1106 octave_value retval;
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1107
16983 4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	1108 #ifndef HAVE_MAGICK
4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	1109 gripe_disabled_feature ("imfinfo", "Image IO");
4660d047955e Make use of gripe_disabled_feature() for image IO functions. Carnë Draug <carandraug+dev@gmail.com> parents: 16944 diff changeset	1110 #else
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1111
10947 dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	1112 maybe_initialize_magick ();
dc74ce93cfc4 initialize GraphicsMagick in all __magick_* functions Jaroslav Hajek <highegg@gmail.com> parents: 10840 diff changeset	1113
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1114 if (args.length () < 1 \|\| ! args (0).is_string ())
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1115 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1116 print_usage ();
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1117 return retval;
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1118 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1119
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1120 const std::string filename = args (0).string_value ();
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1121
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1122 try
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1123 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1124 // Read the file.
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1125 std::vector<Magick::Image> imvec;
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1126 Magick::readImages (&imvec, args(0).string_value ());
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11585 diff changeset	1127 int nframes = imvec.size ();
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11585 diff changeset	1128
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1129 // Create the right size for the output.
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1130
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1131 static const char *fields[] =
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1132 {
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1133 "Filename",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1134 "FileModDate",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1135 "FileSize",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1136 "Height",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1137 "Width",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1138 "BitDepth",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1139 "Format",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1140 "LongFormat",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1141 "XResolution",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1142 "YResolution",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1143 "TotalColors",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1144 "TileName",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1145 "AnimationDelay",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1146 "AnimationIterations",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1147 "ByteOrder",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1148 "Gamma",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1149 "Matte",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1150 "ModulusDepth",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1151 "Quality",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1152 "QuantizeColors",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1153 "ResolutionUnits",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1154 "ColorType",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1155 "View",
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1156 0
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1157 };
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1158
16871 5e30b1c950b8 Replace uses of Octave_map with octave_map or octave_scalar_map. Rik <rik@octave.org> parents: 16543 diff changeset	1159 octave_map info (dim_vector (nframes, 1), string_vector (fields));
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1160
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1161 file_stat fs (filename);
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1162
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1163 std::string filetime;
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1164
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1165 if (fs)
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1166 {
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1167 octave_localtime mtime = fs.mtime ();
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1168
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1169 filetime = mtime.strftime ("%e-%b-%Y %H:%M:%S");
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1170 }
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1171 else
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1172 {
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1173 std::string msg = fs.error ();
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1174
15466 d174210ce1ec use ' instead of ` in error messages, warnings and most comments John W. Eaton <jwe@octave.org> parents: 14173 diff changeset	1175 error ("imfinfo: error reading '%s': %s",
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1176 filename.c_str (), msg.c_str ());
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1177
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1178 return retval;
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1179 }
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1180
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1181 // For each frame in the image (some images contain multiple
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1182 // layers, each to be treated like a separate image).
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1183 for (int frame = 0; frame < nframes; frame++)
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1184 {
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1185 Magick::Image im = imvec[frame];
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11585 diff changeset	1186
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1187 // Add file name and timestamp.
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1188 info.contents ("Filename")(frame,0) = filename;
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1189 info.contents ("FileModDate")(frame,0) = filetime;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11585 diff changeset	1190
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1191 // Annoying CamelCase naming is for Matlab compatibility.
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1192 GET_PARAM (fileSize, "FileSize")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1193 GET_PARAM (rows, "Height")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1194 GET_PARAM (columns, "Width")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1195 GET_PARAM (depth, "BitDepth")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1196 GET_PARAM (magick, "Format")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1197 GET_PARAM (format, "LongFormat")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1198 GET_PARAM (xResolution, "XResolution")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1199 GET_PARAM (yResolution, "YResolution")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1200 GET_PARAM (totalColors, "TotalColors")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1201 GET_PARAM (tileName, "TileName")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1202 GET_PARAM (animationDelay, "AnimationDelay")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1203 GET_PARAM (animationIterations, "AnimationIterations")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1204 GET_PARAM (endian, "ByteOrder")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1205 GET_PARAM (gamma, "Gamma")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1206 GET_PARAM (matte, "Matte")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1207 GET_PARAM (modulusDepth, "ModulusDepth")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1208 GET_PARAM (quality, "Quality")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1209 GET_PARAM (quantizeColors, "QuantizeColors")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1210 GET_PARAM (resolutionUnits, "ResolutionUnits")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1211 GET_PARAM (type, "ColorType")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1212 GET_PARAM (view, "View")
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1213 }
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1214
0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1215 retval = octave_value (info);
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1216 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1217 catch (Magick::Warning& w)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1218 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1219 warning ("Magick++ warning: %s", w.what ());
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1220 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1221 catch (Magick::ErrorCoder& e)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1222 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1223 warning ("Magick++ coder error: %s", e.what ());
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1224 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1225 catch (Magick::Exception& e)
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1226 {
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1227 error ("Magick++ exception: %s", e.what ());
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1228 return retval;
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1229 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1230 #endif
10333 0c42b6b7da24 imfinfo: support image files with multiple frames Søren Hauberg <soren@hauberg.org> parents: 10298 diff changeset	1231 return retval;
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1232 }
01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1233
12805 3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1234 /*
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1235 ## No test needed for internal helper function.
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1236 %!assert (1)
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1237 */
3641167e5b75 codesprint: .cc helper functions do not need tests Rik <octave@nomad.inbox5.com>* parents: 11590 diff changeset	1238
8144 01fac748b680 Add the 'imfinfo' function for reading image file information. sh@sh-laptop parents: 8090 diff changeset	1239 #undef GET_PARAM
11035 8a6b7947f618 Added support for checking supported image types at runtime. John Swensen <jpswensen@gmail.com> parents: 11034 diff changeset	1240
16901 861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1241 DEFUN_DLD (__magick_formats__, args, ,
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1242 "-- texinfo --\n\
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1243 @deftypefn {Loadable Function} {} __magick_imformats__ (@var{formats})\n\
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1244 Fill formats info with GraphicsMagick CoderInfo.\n\
16984 997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	1245 \n\
997efb8d0b19 imread: implement options Index, Frames, and Info. Carnë Draug <carandraug@octave.org> parents: 16983 diff changeset	1246 @seealso{imfinfo, imformats, imread, imwrite}\n\
16901 861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1247 @end deftypefn")
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1248 {
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1249 octave_value retval;
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1250 #ifndef HAVE_MAGICK
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1251 gripe_disabled_feature ("imformats", "Image IO");
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1252 #else
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1253 if (args.length () != 1 \|\| ! args (0).is_map ())
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1254 {
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1255 print_usage ();
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1256 return retval;
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1257 }
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1258 octave_map formats = args(0).map_value ();
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1259
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1260 maybe_initialize_magick ();
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1261 for (octave_idx_type idx = 0; idx < formats.numel (); idx++)
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1262 {
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1263 try
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1264 {
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1265 octave_scalar_map fmt = formats.checkelem (idx);
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1266 Magick::CoderInfo coder (fmt.getfield ("coder").string_value ());
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1267
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1268 fmt.setfield ("description", octave_value (coder.description ()));
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1269 fmt.setfield ("multipage", coder.isMultiFrame () ? true : false);
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1270 // default for read and write is a function handle. If we can't
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1271 // read or write them, them set it to an empty value
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1272 if (! coder.isReadable ())
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1273 fmt.setfield ("read", Matrix ());
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1274 if (! coder.isWritable ())
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1275 fmt.setfield ("write", Matrix ());
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1276 formats.fast_elem_insert (idx, fmt);
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1277 }
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1278 catch (Magick::Exception& e)
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1279 {
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1280 // Exception here are missing formats. So we remove the format
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1281 // from the structure and reduce idx.
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1282 formats.delete_elements (idx);
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1283 idx--;
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1284 }
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1285 }
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1286 retval = formats;
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1287 #endif
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1288 return retval;
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1289 }
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1290
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1291 /*
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1292 ## No test needed for internal helper function.
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1293 %!assert (1)
861516dcad19 New function imformats. Carnë Draug <carandraug@octave.org> parents: 16871 diff changeset	1294 */

Mercurial > octave

annotate libinterp/dldfcn/__magick_read__.cc @ 17116:59acfe9209dd